public static void TimerIoT(
[TimerTrigger("*/5 * * * * *", RunOnStartup = true, UseMonitor = false)] TimerInfo timer,
[IoTHubInput] ServiceClient client,
[IoTHub("myDevice")] out string output,
[IoTHub("myDevice")] out byte[] arr,
[IoTHub("myDevice")] ICollector <string> coll,
[IoTHub("myDevice")] out JObject jobj)
{
Console.WriteLine("timer");
client.SendAsync("myDevice", new Message(Encoding.UTF8.GetBytes("client"))).GetAwaiter().GetResult();
output = "string";
arr = Encoding.UTF8.GetBytes("array");
coll.Add("collstring");
var message = new Message();
jobj = JObject.Parse("{ \"to\": \"something\", \"body\": \"body\", \"properties\": { \"a\": \"b\"} }");
}
public static async Task <string> RunAsync(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequest req,
[ServiceBus("my-queue", Connection = "SBConnectionString")] ICollector <string> queue,
ILogger log)
{
log.LogInformation("C# HTTP trigger function precessing a request.");
var body = await new StreamReader(req.Body).ReadToEndAsync();
var count = int.Parse(body);
for (int i = 0; i < count; i++)
{
queue.Add(i.ToString());
}
return($"produced {count} messages");
}
// The ICollector interface is to write multiple to the output
public static void Run(
[QueueTrigger("appqueue", Connection = "storage_connection")] JObject myQueueItem,
[Table("Customer", Connection = "storage_connection")] ICollector <Customer> outputTable,
[Queue("newqueue", Connection = "storage_connection")] ICollector <Customer> outputQueue,
[Blob("data/{rand-guid}", FileAccess.Write, Connection = "storage_connection")] TextWriter blobOutput,
ILogger log)
{
log.LogInformation("Adding Customer");
Customer obj = new Customer();
obj.PartitionKey = myQueueItem["Id"].ToString();
obj.RowKey = myQueueItem["Quantity"].ToString();
outputTable.Add(obj); // Use ICollector<T>
outputQueue.Add(obj); // The output can be an object serializable as JSON, string, byte[] and CloudQueueMessage
blobOutput.Write($"Partition Key {obj.PartitionKey}");
// For blob, you have an output of Stream, string, CloudBlockBlob
}
public static void Run([BlobTrigger("cosmosdb-blob/{name}", Connection = "BlobConnection")] Stream myBlob, string name, TraceWriter log,
[DocumentDB("Wedding", "guestcollection", ConnectionStringSetting = "CosmosDBConnection")] ICollector <WeddingGuest> documentDB)
{
//https://docs.microsoft.com/en-us/azure/azure-functions/functions-dotnet-class-library
log.Info($"C# Blob trigger function Processed blob\n Name:{name} \n Size: {myBlob.Length} Bytes");
var reader = new StreamReader(myBlob);
var textAsString = reader.ReadToEnd();
var weddingGuestList = JsonConvert.DeserializeObject <WeddingGuestRequest>(textAsString);
foreach (var guest in weddingGuestList.WeddingGuests)
{
guest.PartitionKey = guest.Id.ToString();
guest.RowKey = guest.Name;
documentDB.Add(guest);
}
}
public static void Run([TimerTrigger("*/5 * * * * *")] TimerInfo myTimer,
[EventHub("truckevent", Connection = "EventHub")] ICollector <string> outputEventHubMessage,
TraceWriter log)
{
int trucksPerHour;
int currentTrucks;
var sql = @"SELECT SettingValue FROM dbo.Settings
WHERE SettingName = 'TrucksPerHour'";
var trucks = @"SELECT Count(*) FROM dbo.Truck
WHERE EnterDCTime >= DATEADD(hour, -1, getdate())";
var addTruck = @"INSERT INTO dbo.Truck
(Pallets, EnterDCTime)
OUTPUT inserted.TruckId
VALUES
(@Pallets, @EnterDCTime)";
var str = ConfigurationManager.ConnectionStrings["DatabaseConnection"].ConnectionString;
using (SqlConnection conn = new SqlConnection(str))
{
trucksPerHour = Int32.Parse(conn.Query <string>(sql).FirstOrDefault());
currentTrucks = conn.Query <int>(trucks).FirstOrDefault();
while (ProbabilityCheck.ShouldCreate(trucksPerHour, currentTrucks))
{
var truck = new Truck();
truck.Pallets = ProbabilityCheck.PalletCount();
truck.EnterDCTime = DateTime.UtcNow;
var truckId = conn.Query <int>(addTruck, truck).FirstOrDefault();
truck.TruckId = truckId;
string json = JsonConvert.SerializeObject(truck);
outputEventHubMessage.Add(json);
currentTrucks++;
}
}
}
public static void ProcessOrders(
[QueueTrigger("incoming-orders",
Connection = "AzureWebJobsStorage")]
CloudQueueMessage queueItem,
[Table("Orders",
Connection = "AzureWebJobsStorage")]
ICollector <Order> tableBindings,
ILogger log)
{
log.LogInformation($"Processing Order (mesage Id): {queueItem.Id}");
log.LogInformation($"Processing at: {DateTime.UtcNow}");
log.LogInformation($"Queue Insertion Time: {queueItem.InsertionTime}");
log.LogInformation($"Queue Insertion Time: {queueItem.ExpirationTime}");
log.LogInformation($"Data: {queueItem.AsString}");
tableBindings.Add(JsonConvert.DeserializeObject <Order>(
queueItem.AsString));
}
public static void Run([QueueTrigger("incoming", Connection = "AzureWebJobsStorage")] string json,
[Queue("contacts", Connection = "AzureWebJobsStorage")] ICollector <Contact> contacts,
[Queue("messages", Connection = "AzureWebJobsStorage")] ICollector <Message> messages,
ILogger log)
{
var update = JsonConvert.DeserializeObject <Update>(json);
log.LogInformation($"C# Queue trigger function processed: {update.Type}");
if (update.Type != UpdateType.Message || update.Message == null)
{
return; // only handle message updates
}
// get user
if (update.Message.Contact != null)
{
if (update.Message.Contact.UserId == update.Message.Chat.Id)
{
var phonenumber = update.Message.Contact.PhoneNumber;
phonenumber = phonenumber.Replace("+", "");
contacts.Add(new Contact {
PhoneNumber = phonenumber,
RowKey = update.Message.Chat.Id.ToString()
});
return;
}
}
var text = update.Message.Text.ToLower();
if (text == "/streak" || text == "/start" || text == "/hjelp")
{
messages.Add(new Message()
{
ChatId = update.Message.Chat.Id.ToString(),
Text = text
});
return;
}
else
{
// send about message?
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Queue("surveydata"), StorageAccount("AzureWebJobsStorage")] ICollector <SurveyItem> msg,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
var item = JsonConvert.DeserializeObject <SurveyItem>(requestBody);
// Add a message to the output collection.
msg.Add(item);
var referenceNumber = Guid.NewGuid().ToString();
return((ActionResult) new OkObjectResult(referenceNumber));;
}
public static void AddEvents([Table("events")] ICollector <Event> tableBinding, TextWriter logger)
{
var qty = 10000;
for (int i = 0; i < qty; i++)
{
tableBinding.Add(new Event
{
PartitionKey = "sensor",
RowKey = i.ToString(),
Time = DateTime.UtcNow,
Name = "Event" + i.ToString()
});
logger.WriteLine("Added event #{0}", i);
}
}
public static async Task Run(
[CosmosDBTrigger(
databaseName: "jjdb",
collectionName: "votes",
ConnectionStringSetting = "jjcosmos_DOCUMENTDB",
LeaseCollectionName = "leases",
CreateLeaseCollectionIfNotExists = true)] IReadOnlyList <Document> inputDocuments,
[CosmosDB(
databaseName: "jjdb",
collectionName: "articles",
ConnectionStringSetting = "jjcosmos_DOCUMENTDB")] DocumentClient client,
[CosmosDB(
databaseName: "jjdb",
collectionName: "articles",
ConnectionStringSetting = "jjcosmos_DOCUMENTDB")]
ICollector <ArticleItem> articlesOut,
ILogger log)
{
if (inputDocuments != null && inputDocuments.Count > 0)
{
log.LogInformation("Like process triggered, received document count: " + inputDocuments.Count.ToString());
foreach (Document input in inputDocuments)
{
string articleId = input.GetPropertyValue <string>("articleid");
log.LogInformation("Processing articleId " + articleId);
Uri collectionUri = UriFactory.CreateDocumentCollectionUri("jjdb", "articles");
IDocumentQuery <ArticleItem> query = client.CreateDocumentQuery <ArticleItem>(collectionUri)
.Where(p => p.articleid == articleId)
.AsDocumentQuery();
while (query.HasMoreResults)
{
foreach (ArticleItem result in await query.ExecuteNextAsync())
{
log.LogInformation(result.voteCount.ToString());
result.voteCount++;
articlesOut.Add(result);
log.LogInformation("Processed articleId " + articleId + " with voteCount " + result.voteCount.ToString());
}
}
}
}
}
public static async Task <AskQuestionResponse> AnswerQuestion(AskQuestionRequest request, ICollector <SessionTableEntity> sessionTable)
{
// Get unique identifier
string id = Guid.NewGuid().ToString();
DateTime timestampUtc = DateTime.UtcNow;
// Get key phrases extraction
request.Topics = await ServicesUtility.GetTopics(request.Question, request.Topics);
string queryWithTopics = request.Topics?.Count() > 0 ? string.Join(" ", request.Topics).Trim() : request.Question;
// Create video indexer task
VideoIndexerSearchResult videoIndexerResult = await ServicesUtility.VideoIndexer.SearchAsync(query : queryWithTopics);
// Process results
AskQuestionResponse response = new AskQuestionResponse()
{
Id = id,
Results = new AskQuestionResult[0]
};
if (videoIndexerResult.Results?.Count() > 0)
{
response.Results = ServicesUtility.GetAskQuestionResults(videoIndexerResult);
}
else
{
// Create Bing Search tasks
BingWebSearchResult bingWebSearchResult =
await ServicesUtility.BingSearch.SearchWebAsync(query : request.Question, count : SettingsUtility.MaxResultsCount);
// Process Bing search results
if (bingWebSearchResult.WebPagesResult?.Values?.Count() > 0)
{
response.Results = ServicesUtility.GetAskQuestionResults(bingWebSearchResult);
}
}
// Write to session table
sessionTable.Add(new SessionTableEntity(id, timestampUtc, "LearnMore", request, response));
// Return response
return(response);
}
public static async Task <HttpResponseMessage> Run(HttpRequestMessage req, ICollector <string> errormessage, TraceWriter log)
{
log.Verbose($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}");
try
{
JObject data = await req.Content.ReadAsAsync <JObject>();
log.Verbose($"received data :={data}", "JE.RMS.Services.GetCustomers");
List <SqlParameter> objprm = new List <SqlParameter>();
objprm.Add(new SqlParameter("@pageNumber", Convert.ToInt32(data.SelectToken("pageNumber").ToString().TrimStart('{').TrimEnd('}'))));
objprm.Add(new SqlParameter("@pageSize", Convert.ToInt32(data.SelectToken("pageSize").ToString().TrimStart('{').TrimEnd('}'))));
objprm.Add(new SqlParameter("@searchText", data.SelectToken("searchText") == null?"" : data.SelectToken("searchText").ToString().TrimStart('{').TrimEnd('}')));
log.Verbose($"calling sp", "JE.RMS.Services.GetCustomers");
List <Common.Model.Customer> retobj = MSSQLConnection.ExecuteStoredProcedure <Common.Model.Customer>(Common.Constants.USPContstants.GetCustomers, objprm);
Common.Model.CustomerList obj = new Common.Model.CustomerList();
if (retobj.Count > 0)
{
obj.TotalRows = retobj.FirstOrDefault().TotalRows;
}
else
{
obj.TotalRows = 0;
}
obj.Users = new List <Common.Model.Customer>();
obj.Users = retobj;
log.Verbose($"received response:={obj}", "JE.RMS.Services.GetCustomers");
var CustomerResponse = req.CreateResponse(HttpStatusCode.OK);
CustomerResponse.Content = new StringContent(JsonConvert.SerializeObject(obj), System.Text.Encoding.UTF8, "application/json");
return(CustomerResponse);
//return req.CreateResponse(HttpStatusCode.OK, obj);
}
catch (Exception ex)
{
log.Error($"Exception ={ex}");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Function, "post", Route = "users/{userId}/subscriptions")]
HttpRequestMessage req,
string userId,
[Table(TableNames.GroupEventSubscription, Connection = "AzureWebJobsStorage")]
ICollector <GroupEventSubscriptionEntity> outTable,
TraceWriter log)
{
var json = await req.Content.ReadAsStringAsync();
var model = JsonConvert.DeserializeObject <GroupEventSubscriptionModel>(json);
if (model?.Type != "GroupEvent")
{
return(req.CreateResponse(HttpStatusCode.BadRequest, $"Subscription type '{model?.Type}' not supported"));
}
if (string.IsNullOrEmpty(model.Name) || string.IsNullOrEmpty(model.UrlName))
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "Name and UrlName are all required for creating a subscription"));
}
if (!model.EndpointUrl.IsAbsoluteUri ||
!new[] { Uri.UriSchemeHttp, Uri.UriSchemeHttps }.Contains(model.EndpointUrl.Scheme))
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "A Valid http or https endpoint url is required for creating a subscription"));
}
var id = Guid.NewGuid().ToString();
outTable.Add(new GroupEventSubscriptionEntity()
{
PartitionKey = userId,
RowKey = id,
Name = model.Name,
UrlName = model.UrlName,
OnCreated = model.OnCreated,
OnUpdated = model.OnUpdated,
OnDeleted = model.OnDeleted,
EndpointUrl = model.EndpointUrl
});
return(req.CreateResponse(HttpStatusCode.Created, new { id }));
}
public static async Task <HttpResponseMessage> Run(HttpRequestMessage req, ICollector <string> errormessage, TraceWriter log)
{
log.Verbose($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}", "JE.RMS.Services.SubmitRewardsRequest");
try
{
//To obtain client IP Address
clientIP = ((HttpContextWrapper)req.Properties["MS_HttpContext"]).Request.UserHostAddress;
log.Verbose($"clientIP:={clientIP}", "JE.RMS.Services.SubmitRewardsRequest");
//Read request object as string
string reqString = await req.Content.ReadAsStringAsync();
reqMessage = JObject.Parse(reqString);
// Retrieve storage account from connection string
CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["jermsstorage_STORAGE"].ToString());
// Create the queue client
CloudQueueClient queueClient = storageAccount.CreateCloudQueueClient();
// Retrieve a reference to a queue
CloudQueue queue = queueClient.GetQueueReference("submitrewardsrequestqueue");
// Create the queue if it doesn't already exist.
queue.CreateIfNotExists();
foreach (JObject x in reqMessage["RewardsRequest"])
{
//Added Audit fields in request object
x.Add("SourceIP", clientIP);
x.Add("RMSRewardID", Guid.NewGuid().ToString());
x.Add("RewardsRequestReceiveTimestamp", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
CloudQueueMessage message = new CloudQueueMessage(x.ToString());
queue.AddMessage(message);
log.Verbose($"Message was published={x}", "JE.RMS.Services.SubmitRewardsRequest");
}
var Status = "Success";
return(req.CreateResponse(HttpStatusCode.OK, new { Status }, JsonMediaTypeFormatter.DefaultMediaType));
}
catch (Exception ex)
{
log.Error($"Exception ={ex}", ex, "JE.RMS.Services.SubmitRewardsRequest");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message, ex));
}
}
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = "AddPictureOrder")] HttpRequest req, TraceWriter log, [Table("PictureFormDB", Connection = "StorageConnection")] ICollector <PictureForm> formTable)
{
log.Info("C# HTTP trigger function processed a request.");
string requestBody = new StreamReader(req.Body).ReadToEnd();
PictureForm data = JsonConvert.DeserializeObject <PictureForm>(requestBody);
data.PartitionKey = DateTime.UtcNow.DayOfYear.ToString();
data.RowKey = data.FileName;
formTable.Add(data);
return(data != null
? (ActionResult) new OkObjectResult($"Hello, {"OK"}")
: new BadRequestObjectResult("Please pass a name on the query string or in the request body"));
}
public static async Task <HttpResponseMessage> Run(HttpRequestMessage req, ICollector <string> errormessage, TraceWriter log)
{
log.Verbose($"C# HTTP trigger GetRoles function processed a request. RequestUri={req.RequestUri}", "JE.RMS.Services.GetRoles");
try
{
var roles = MSSQLConnection.ExecuteStoredProcedure <Role>(Common.Constants.USPContstants.GetRoles);
log.Verbose($"received response:={roles}", "JE.RMS.Services.GetRoles");
return(req.CreateResponse(HttpStatusCode.OK, roles));
}
catch (Exception ex)
{
log.Error("Something went wrong while GetRoles", ex, "JE.RMS.Services.GetRoles");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public static async Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
[Queue("mailerqueue")] ICollector <string> destinationQueue,
ILogger log)
{
log.LogInformation("C# HTTP trigger function processed a request.");
string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
if (JsonConvert.DeserializeObject <EmailMessage>(requestBody) == null)
{
return(new BadRequestResult());
}
destinationQueue.Add(requestBody);
return(new AcceptedResult());
}
public static async Task <HttpResponseMessage> Run(HttpRequestMessage req, ICollector <string> errormessage, TraceWriter log)
{
try
{
log.Verbose($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}", "JE.RMS.Services.EvaluateRewardsTrx");
string rewardfulfillmentrequest = await req.Content.ReadAsStringAsync();
var evaluationResult = EvaluateRewardsTrxMessage(rewardfulfillmentrequest, log);
log.Verbose($"C# HTTP function processed a request. inputmessage= {rewardfulfillmentrequest}", "JE.RMS.Services.EvaluateRewardsTrx");
return(req.CreateResponse(HttpStatusCode.OK, evaluationResult));
}
catch (Exception ex)
{
log.Error($"Exception={ex}", ex, "JE.RMS.Services.EvaluateRewardsTrx");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = null)] HttpRequest req,
[Table("Orders", Connection = "StorageConnection")] ICollector <Order> ordersTable, TraceWriter log)
{
try
{
var requestBody = new StreamReader(req.Body).ReadToEnd();
var order = JsonConvert.DeserializeObject <Order>(requestBody);
order.PartitionKey = DateTime.UtcNow.DayOfYear.ToString();
order.RowKey = order.FileName;
ordersTable.Add(order);
}
catch (Exception)
{
return(new BadRequestObjectResult("Received data invalid"));
}
return(new OkObjectResult("Success"));
}
public static void Run([HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log,
[Queue("numberToBeFactored", Connection = "AzureWebJobsStorage")] ICollector <string> outQueueItem)
{
log.LogInformation("C# HTTP trigger function processed a request to factor a number");
// parse query parameter
long?number = Convert.ToInt64(req.Query["number"]);
// Get request body
string requestBody = new StreamReader(req.Body).ReadToEnd();
dynamic data = JsonConvert.DeserializeObject(requestBody);
// Set name to query string or body data
number = (number == 0 ? data?.number : null);
log.LogInformation("Received " + number);
outQueueItem.Add(number.ToString());
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] HttpRequestMessage req,
[Queue("scorequeue", Connection = "AzureWebJobsStorage")] ICollector <string> outputQueueMessage,
TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
// Get request body
dynamic data = await req.Content.ReadAsAsync <object>();
// Get the TeamId
string teamId = data?.teamId;
// Queue Point
outputQueueMessage.Add(teamId);
return(req.CreateResponse(HttpStatusCode.OK));
}
//Adding records to the collector. The Function binding will handle serialization to EventHub
public bool Serialize(string message,
ICollector <EventData> outData)
{
bool retVal = true;
try
{
byte[] messageBytes = System.Text.Encoding.UTF8.GetBytes(message);
outData.Add(new EventData(messageBytes));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
retVal = false;
}
return(retVal);
}
public static void Run(
[CosmosDBTrigger("testdb", "testcollection", ConnectionStringSetting = "CosmosDB", CreateLeaseCollectionIfNotExists = true)]
IReadOnlyList <Document> documents,
[CosmosDB("testdb", "testcollection", Id = "id", ConnectionStringSetting = "CosmosDb")]
ICollector <dynamic> translatedDocs,
TraceWriter log)
{
foreach (var doc in documents)
{
if (doc.GetPropertyValue <object>("translated") == null)
{
doc.SetPropertyValue(
"translated",
new string(doc.GetPropertyValue <string>("text").Reverse().ToArray()));
translatedDocs.Add(doc);
}
}
}
private static void PostToSlackQueue(ICollector <string> outputToSlack, double?temperature, long?humidity, long?timestamp)
{
var postToSlack = Environment.GetEnvironmentVariable(EnvPostToSlack);
if (!string.IsNullOrEmpty(postToSlack) && postToSlack.Equals("true"))
{
if (timestamp.HasValue)
{
var messageToSlack = new
{
TimestampUtc = DateTimeOffset.FromUnixTimeSeconds(timestamp.Value).UtcDateTime.ToString(DateTimeFormat),
Temperature = temperature.Value,
Humidity = humidity.Value
};
outputToSlack.Add(JsonConvert.SerializeObject(messageToSlack));
}
}
}
public static IActionResult Run([HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "saveMessage")] HttpRequest req,
[Queue("demomessages", Connection = "queueConn")] ICollector <string> outputMessage, TraceWriter log)
{
string requestBody = new StreamReader(req.Body).ReadToEnd();
Person person = JsonConvert.DeserializeObject <Person>(requestBody);
if (person == null || person.FirstName == null || person.LastName == null)
{
return(new BadRequestObjectResult("Prz222ekaz poprawne dane osobowe"));
}
string message = person.FirstName + " " + person.LastName;
outputMessage.Add(message);
return(new OkObjectResult($"Zapisano wiadomosc: {message}"));
}
public static async Task <HttpResponseMessage> Run(HttpRequestMessage req, ICollector <string> errormessage, TraceWriter log)
{
log.Info($"C# HTTP trigger function processed a request. RequestUri={req.RequestUri}", "JE.RMS.Services.EEGetPointsTransactions");
try
{
// Get request body
string startDate = req.GetQueryNameValuePairs().FirstOrDefault(q => string.Compare(q.Key, "startDate", true) == 0).Value;
string endDate = req.GetQueryNameValuePairs().FirstOrDefault(q => string.Compare(q.Key, "endDate", true) == 0).Value;
log.Verbose($"Get Points transaction called with start date = {startDate}, end date = {endDate}", "JE.RMS.Services.EEGetPointsTransactions");
//Check if start date & end date is provided
if (!string.IsNullOrEmpty(startDate) && !string.IsNullOrEmpty(endDate))
{
using (HttpClient httpClient = new HttpClient())
{
//Add Basic Authentication header
httpClient.BaseAddress = new Uri(ConfigurationManager.AppSettings["EnergyEarthBaseUrl"].ToString());
var auth = Encoding.ASCII.GetBytes(ConfigurationManager.AppSettings["EEUserName"].ToString() + ":" + ConfigurationManager.AppSettings["EEPassword"].ToString());
httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(auth));
string GetPointTransactionsUrl = ConfigurationManager.AppSettings["EEGetPointsTransactionsUrl"].ToString() + "?startDate=" + startDate + "&endDate=" + endDate;
var response = await httpClient.GetAsync(GetPointTransactionsUrl);
log.Verbose($"Success : Get Points transaction start date={startDate}, end date = {endDate}.", "JE.RMS.Services.EEGetPointsTransactions");
return(response);
}
}
else //Bad request : Start Date or End Date is not provided.
{
log.Error("Missing Parameter for EEGetPointsTransactions : startDate/endDate", null, "JE.RMS.Services.EEGetPointsTransactions");
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Missing parametre : startDate/endDate"));
}
}
catch (Exception ex)
{
log.Error("Something went wrong while EEGetPointsTransactions", ex, "JE.RMS.Services.EEGetPointsTransactions");
errormessage.Add(JsonConvert.SerializeObject(ex).ToString());
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Function, "get",
Route = "ProcessTabularModel/{databaseName}/async")] HttpRequestMessage req,
[Queue("%ProcessModelQueue%", Connection = "AzureWebJobsStorage")] ICollector <QueueMessageProcesssTabular> queue,
[Table("%ProcessModelStatusTable%", Connection = "AzureWebJobsStorage")] ICollector <QueueMessageProcesssTabular> statusTable,
string databaseName,
TraceWriter log)
{
log.Info($"Received request to process the model {databaseName} asynchronously.");
QueueMessageProcesssTabular queuedMessage = null;
try
{
DateTime enqueuedDateTime = DateTime.UtcNow;
string trackingId = Guid.NewGuid().ToString();
queuedMessage = new QueueMessageProcesssTabular()
{
TrackingId = trackingId,
EnqueuedDateTime = enqueuedDateTime,
Database = databaseName,
Tables = null,
TargetDate = DateTime.Now,
Parition = null,
Status = "Queued",
PartitionKey = enqueuedDateTime.ToString("yyyy-MM-dd"),
RowKey = trackingId,
ETag = "*"
};
queue.Add(queuedMessage);
statusTable.Add(queuedMessage);
log.Info($"Successfully queued request to process database - {databaseName} as {queuedMessage.PartitionKey}/{queuedMessage.RowKey}");
}
catch (Exception e)
{
log.Error($"Error occured trying to queue request to process database - {databaseName}. Details : {e.ToString()}", e);
return(req.CreateErrorResponse(HttpStatusCode.InternalServerError, e));
}
return(req.CreateResponse(HttpStatusCode.OK, queuedMessage.ToProcessingTrackingInfo()));
}
public static async Task RunImageUpdateMessage(
[QueueTrigger("imageupdatemessage")] ImageUpdateMessage imageUpdateMessage,
[Table("installation", "{InstallationId}", "{RepoName}")] Installation installation,
[Queue("openprmessage")] ICollector <OpenPrMessage> openPrMessages,
TraceWriter log,
ExecutionContext context)
{
if (installation == null)
{
throw new Exception($"No installation found for InstallationId: {installation.InstallationId}");
}
var installationTokenParameters = new InstallationTokenParameters
{
AccessTokensUrl = installation.AccessTokensUrl,
AppId = KnownGitHubs.AppId,
};
var installationToken = await InstallationToken.GenerateAsync(
installationTokenParameters,
File.OpenText(Path.Combine(context.FunctionDirectory, $"..\\{KnownGitHubs.AppPrivateKey}")));
var compressImagesParameters = new CompressimagesParameters
{
CloneUrl = installation.CloneUrl,
LocalPath = LocalPath.CloneDir(Environment.GetEnvironmentVariable("TMP"), installation.RepoName),
Password = installationToken.Token,
RepoName = installation.RepoName,
RepoOwner = installation.Owner,
PgpPrivateKeyStream = File.OpenRead(Path.Combine(context.FunctionDirectory, $"..\\{KnownGitHubs.PGPPrivateKeyFilename}")),
PgPPassword = File.ReadAllText(Path.Combine(context.FunctionDirectory, $"..\\{KnownGitHubs.PGPPasswordFilename}"))
};
var didCompress = CompressImages.Run(compressImagesParameters);
if (didCompress)
{
openPrMessages.Add(new OpenPrMessage
{
InstallationId = imageUpdateMessage.InstallationId,
RepoName = imageUpdateMessage.RepoName,
});
}
}
public static async Task RunAsync(
IInstallationTokenProvider installationTokenProvider,
CompressImagesMessage compressImagesMessage,
ICollector <OpenPrMessage> openPrMessages,
ILogger logger,
ExecutionContext context)
{
logger.LogInformation("CompressImagesFunction: starting run for {Owner}/{RepoName}", compressImagesMessage.Owner, compressImagesMessage.RepoName);
var installationTokenParameters = new InstallationTokenParameters
{
AccessTokensUrl = string.Format(KnownGitHubs.AccessTokensUrlFormat, compressImagesMessage.InstallationId),
AppId = KnownGitHubs.AppId,
};
var installationToken = await installationTokenProvider.GenerateAsync(
installationTokenParameters,
File.OpenText(Path.Combine(context.FunctionDirectory, $"../{KnownGitHubs.AppPrivateKey}")));
var compressImagesParameters = new CompressimagesParameters
{
CloneUrl = compressImagesMessage.CloneUrl,
LocalPath = LocalPath.CloneDir(Environment.GetEnvironmentVariable("TMP") ?? "/private/tmp/", compressImagesMessage.RepoName),
Password = installationToken.Token,
RepoName = compressImagesMessage.RepoName,
RepoOwner = compressImagesMessage.Owner,
PgpPrivateKeyStream = File.OpenRead(Path.Combine(context.FunctionDirectory, $"../{KnownGitHubs.PGPPrivateKeyFilename}")),
PgPPassword = File.ReadAllText(Path.Combine(context.FunctionDirectory, $"../{KnownGitHubs.PGPPasswordFilename}"))
};
var didCompress = CompressImages.Run(compressImagesParameters, logger);
if (didCompress)
{
logger.LogInformation("CompressImagesFunction: Successfully compressed images for {Owner}/{RepoName}", compressImagesMessage.Owner, compressImagesMessage.RepoName);
openPrMessages.Add(new OpenPrMessage
{
InstallationId = compressImagesMessage.InstallationId,
RepoName = compressImagesMessage.RepoName,
CloneUrl = compressImagesMessage.CloneUrl,
});
}
logger.LogInformation("CompressImagesFunction: finished run for {Owner}/{RepoName}", compressImagesMessage.Owner, compressImagesMessage.RepoName);
}
public static async Task Run([BlobTrigger("takmil/{blobName}",
Connection = "AzureWebJobsStorage")] Stream inputBlob, string blobName,
[Table("TakmilTable")] ICollector <ConnectionLog> outputTable,
ILogger log)
{
log.LogInformation($"C# Blob trigger function Processed blob\n Name:{blobName}\n Size: {inputBlob.Length} Bytes");
blobName = Path.GetFileNameWithoutExtension(blobName);
string[] nameParts = blobName.Split(new char[] { '_' });
if (nameParts.Length != 5)
{
log.LogError("File name is in invalid format, expected A_B_C_D_E.json");
return;
}
string schoolName = nameParts[0];
string uploadTimeStr = nameParts[1] + "T" + nameParts[2];
string orgName = nameParts[4];
PictureData picture = GetPictureData(inputBlob, log);
Tuple <int, int, int> t = ProcessPicture(picture.PictureURL, log);
DateTime uploadTime = DateTime.UtcNow;
DateTime createTime = DateTime.ParseExact(picture.PictureTimestamp, "yyyy-MM-dd HH:mm:ss", System.Globalization.CultureInfo.InvariantCulture);
ConnectionLog record = new ConnectionLog
{
PartitionKey = schoolName,
RowKey = orgName + "-" + schoolName + "-" + uploadTimeStr,
Location = picture.Location,
LatLong = picture.LatLong,
SchoolName = picture.SchoolName,
ClassName = picture.ClassName,
TeacherName = picture.TeacherName,
NoOfBoys = t.Item1,
NoOfGirls = t.Item2,
NoOfStudents = t.Item3,
PictureLocationURL = picture.PictureURL,
CreationTimestamp = createTime,
UploadTimestamp = uploadTime
};
outputTable.Add(record);
}
