public static HttpResponseMessage Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "post")] ProcessingRequest request,
[Blob("%input-container%/{FileId}")] CloudBlockBlob outBlob,
TraceWriter log,
[ServiceBus("mytopic", AccessRights.Manage)] out BrokeredMessage topicMessage)
{
log.Info("(Fun1) Received image for processing...");
AsyncHelper.RunSync(async() =>
{
await outBlob.UploadFromByteArrayAsync(request.Content, 0, request.Content.Length);
});
var analysisRequest = new AnalysisReq
{
BlobRef = outBlob.Name,
Width = request.Width,
ImageUrl = request.ImageUrl
};
topicMessage = new BrokeredMessage(analysisRequest);
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(outBlob.Name)
});
}
public async Task <IActionResult> AddNewProcessingRequest(DateTime fromDate, DateTime toDate, string employees)
{
try
{
var newData = new ProcessingRequest
{
RequestDate = DateTime.Now,
FromDate = fromDate,
ToDate = toDate,
Employees = employees
};
if (User.Identity.IsAuthenticated)
{
newData.UserId = User.Identity.Name.ConvertToInteger();
}
var saveResult = await _processingsRequestsManager.InsertNewDataItem(newData);
if (saveResult.Status == RepositoryActionStatus.Created)
{
return(Json("Ok"));
}
else
{
return(Json(new { errors = "Error" }));
}
}
catch (Exception)
{
return(Json(new { errors = "Error" }));
}
}
/// <summary>
/// Gets static files by TModel.
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task <HttpResponseMessage> Get <TModel>(TModel model)
where TModel : StaticFileModel
{
var result = new HttpResponseMessage();
if (!ModelState.IsValid)
{
result.StatusCode = HttpStatusCode.BadRequest;
return(result);
}
try
{
var request = new ProcessingRequest <StaticFileModel>
{
//Temporary Repo access, need to go back and build out processors and interfaces.
File = await _repo.GetStaticFile <TModel>(model)
};
request.File.Flush();
result.Content = new StreamContent(request.File);
request.File.Close();
return(result);
}
catch (Exception e)
{
result.StatusCode = HttpStatusCode.InternalServerError;
result.Content = new StringContent(e.ToString());
return(result);
}
}
private void WriteStatus(ProcessingRequest request, string status, string details = null, bool issueRedirect = true, Exception exception = null)
{
var jobStatus = new JobStatus {
JobId = request.JobId,
JobName = request.Name,
Status = status,
QueueId = request.QueueId,
QueueName = request.QueueName,
Details = details,
};
foreach (var provider in _statusProviders)
{
try {
provider.WriteStatus(jobStatus);
} catch (Exception ex) {
Trace.TraceError($"Error recording status: {ex}");
}
}
OnStatusReported(jobStatus);
if (issueRedirect)
{
Redirect(jobStatus, request, exception);
}
}
protected virtual async Task <ProcessingRequest <TModel> > ValidateSequence(TModel item)
{
var request = new ProcessingRequest <TModel>
{
Item = item
};
foreach (var v in ValidationSequence)
{
await v.ValidateAsync(request);
}
if (request.Messages.Count > 0)
{
foreach (var message in request.Messages)
{
request.IsValid = (message.Type != ProcessingMessageType.ValidationError);
}
}
else
{
request.IsValid = true;
}
return(request);
}
public override async Task ValidateAsync(ProcessingRequest <TModelType> request)
{
if (_repo.GetItem <TModelType>(m => m.Id == request.Item.Id)?.Id == null)
{
request.AddValidationMessage($"Object not found by id of type {typeof(TModelType)}",
ProcessingMessageType.ValidationError);
}
}
static private void ShowForm()
{
p = new ProcessingRequest();
p.StartPosition = FormStartPosition.Manual;
p.Location = point;
p.TopMost = true;
Application.Run(p);
}
public override async Task ValidateAsync(ProcessingRequest <TModel> request)
{
if (request.Item.PlayerId != null)
{
await Task.Run(() => request.AddValidationMessage(
$"Requested objects to create must have null Ids.",
ProcessingMessageType.ValidationError));
}
}
private void Redirect(JobStatus status, ProcessingRequest request, Exception exception)
{
if (_queueRedirects.TryGetValue(request.QueueId, out var strategy))
{
var result = ExecuteRedirect(strategy, status, request, exception);
if (result != null)
{
RequestRedirected?.Invoke(this, new RequestRedirectedEventArgs(result.Message, request.QueueId, result.NewQueue));
}
}
}
public override async Task <ProcessingRequest <QuakeSoundModel> > Process(QuakeSoundModel model, ActionType actionType)
{
model.FileDirectory += model.Variation;
var request = new ProcessingRequest <QuakeSoundModel>
{
Item = model,
File = await _repo.GetStaticFile <QuakeSoundModel>(model),
ActionType = actionType
};
return(request);
}
/// <summary>
/// Execute <see cref="JobHandler.ProcessAsync(ProcessingRequest, CancellationToken)"/> for the specified <see cref="ProcessingRequest"/>
/// </summary>
/// <param name="request">Request to process</param>
/// <param name="handler">Handler to handle the job</param>
private Task HandleJob(ProcessingRequest request, JobHandler handler)
{
var cts = new CancellationTokenSource();
if (_config.JobTimeout > 0)
{
cts.CancelAfter(_config.JobTimeout);
}
using (cts) {
return(handler.ProcessAsync(request, cts.Token));
}
}
public ProcessingRequest <Player> CreatePlayer(Player player)
{
var playerEntity = PlayerToPlayerEntity(player);
var playerEntityRO = ProcessCreate(playerEntity).Result;
_request = new ProcessingRequest <Player>()
{
IsValid = playerEntityRO.IsValid,
Item = PlayerEntityToPlayer(playerEntityRO.Item),
Messages = playerEntityRO.Messages
};
return(_request);
}
public override Task ProcessAsync(ProcessingRequest request, CancellationToken cancellationToken)
{
if (_hangOnProcessing)
{
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
}
}
if (_throwOnProcessing)
{
throw new System.Exception("test");
}
base.OnProcessingCompleted(request, "test");
return(Task.FromResult(true));
}
private async Task HandleRequestAsync(ProcessingRequest request, bool processEvents)
{
WriteStatus(request, JobStatus.Received, issueRedirect: false);
if (_cancelProcessing)
{
WriteStatus(request, JobStatus.Canceled);
return;
}
if (!_handlerLocator.TryGetHandlerByQueueId(request.QueueId, out var handler))
{
// NOTE: this will never be reached due to the throw in InternalJobQueueFactory.Create(),
// which is called by all entrypoints into this method.
WriteStatus(request, JobStatus.Skipped, $"No handler found for {request}");
return;
}
if (!handler.CanProcess(request))
{
WriteStatus(request, JobStatus.Skipped, $"No handler could process request '{request}'");
return;
}
WriteStatus(request, JobStatus.Processing, issueRedirect: false);
if (!processEvents)
{
await HandleJob(request, handler);
return;
}
try {
await HandleJob(request, handler);
} catch (OperationCanceledException ex) {
//? JobStatus.Cancelled?
OnProcessingTimedOut(handler, new ProcessingFailedEventArgs(request, ex));
} catch (Exception ex) {
OnProcessingFailed(handler, new ProcessingFailedEventArgs(request, ex));
}
}
private async Task <string> CallFunctionAsync(string contentReference,
byte[] byteData,
string imageUrl)
{
var req = new ProcessingRequest
{
FileId = contentReference,
Content = byteData,
Width = 150,
ImageUrl = imageUrl
};
using (var content = new StringContent(JsonConvert.SerializeObject(req)))
{
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await
Global.HttpClient.Value.PostAsync(_settings.Settings.RequestFunctionUri,
content).ConfigureAwait(false);
return(await response.Content.ReadAsStringAsync()
.ConfigureAwait(false));
}
}
/// <summary>
/// Invokes the <see cref="ProcessingRequest" /> event
/// </summary>
protected virtual void OnProcessingRequest(IHttpContext context)
{
ProcessingRequest?.Invoke(this, new EndpointRequestEventArgs(context));
}
public abstract Task ValidateAsync(ProcessingRequest <TModel> request);
/// <summary>
/// Initialize a new instance of the <see cref="JobReceivedEventArgs"/> class
/// </summary>
/// <param name="request">Originating request</param>
public JobReceivedEventArgs(ProcessingRequest request)
{
ProcessingRequest = request;
}
public override bool CanProcess(ProcessingRequest request) => _canProcess;
/// <remarks>Returning null from this method causes the calling code to ignore the redirect</remarks>
private RedirectResult ExecuteRedirect(RedirectStrategy strategy, JobStatus status, ProcessingRequest request, Exception exception)
{
if (!strategy.Decider(status, exception))
{
return(null);
}
var newQueue = strategy.Redirect(status);
if (string.IsNullOrWhiteSpace(newQueue))
{
return(null);
}
var message = SendJob(newQueue, request.JobRequest.Type, request.JobRequest.Payload, request.Name);
WriteStatus(request, JobStatus.Redirected, $"New Queue: {newQueue} Message Id: {message.Id}", false);
return(new RedirectResult {
Message = message,
NewQueue = newQueue
});
}
