コード例 #1
0
        private async Task SendEventHubNotificationAsync(Input input, LabUser user, Output output, SeligaParsedOutput seligaOutput)
        {
            var client = EventHubs.EventHubClient(_configuration);

            var messageData = new
            {
                inputId      = input.InputId,
                batchId      = input.BatchId,
                outputId     = output.OutputId,
                deploymentId = _configuration["BatchServer:DeploymentId"],
                user         = new
                {
                    email       = user.EMail,
                    fullName    = user.FullName,
                    location    = user.Location,
                    teamName    = user.TeamName,
                    companyName = user.CompanyName,
                    countryCode = user.CountryCode
                },
                score = new {
                    totalItems = seligaOutput.Outputs.Count,
                    maxScore   = seligaOutput.MaxScore,
                    avgScore   = seligaOutput.AvgScore,
                    totalScore = seligaOutput.TotalScore
                }
            };

            var message = await Task.Factory.StartNew(() => JsonConvert.SerializeObject(messageData));

            if (client == null)
            {
                _logger.LogWarning("Event hubs disabled: {message}", message);
            }
            else
            {
                await client.SendAsync(new Microsoft.Azure.EventHubs.EventData(Encoding.UTF8.GetBytes(message)));
            }
        }
コード例 #2
0
        private async Task <Tuple <Output, bool> > UpdateOuputAsync(string result, Input input, SeligaParsedOutput parsedOutput)
        {
            _logger.LogInformation("Updating input {inputId} to processed state", input.InputId);
            input.ModifiedOn = DateTime.UtcNow;
            input.Status     = Input.InputStatusEnum.Processed;
            _context.Inputs.Update(input);

            var firstUpdate = false;
            var output      = await _context.Outputs.FirstOrDefaultAsync(o => o.Input.InputId == input.InputId);

            if (output == null)
            {
                _logger.LogInformation("Creating output for input {inputId}", input.InputId);
                output = new Output
                {
                    Input      = input,
                    Result     = result,
                    TotalItems = parsedOutput.Outputs.Count,
                    MaxScore   = parsedOutput.MaxScore,
                    AvgScore   = parsedOutput.AvgScore,
                    TotalScore = parsedOutput.TotalScore,
                };
                _context.Outputs.Add(output);
                firstUpdate = true;
            }
            else
            {
                _logger.LogWarning("Updating output {outputId} for input {inputId}", output.OutputId, input.InputId);
                output.Result     = result;
                output.TotalItems = parsedOutput.Outputs.Count;
                output.MaxScore   = parsedOutput.MaxScore;
                output.AvgScore   = parsedOutput.AvgScore;
                output.TotalScore = parsedOutput.TotalScore;
                output.ModifiedOn = DateTime.UtcNow;
                _context.Outputs.Update(output);
            }
            await _context.SaveChangesAsync();

            return(new Tuple <Output, bool>(output, firstUpdate));
        }