public void ParseReport_WhenEmptyReportSent_ShouldThrowException(string reportMessage)
 {
     // Assert
     Should.Throw <ReportValidationException>(() => _reportMessageService.ParseReport(reportMessage));
 }
示例#2
0
        private async Task <ReportValidationResult> ParseAndValidateReport(RawReport rawReport, NameValueCollection parsedQueryString)
        {
            GatewaySetting gatewaySetting = null;

            try
            {
                var apiKey    = parsedQueryString[ApiKeyParameterName];
                var sender    = parsedQueryString[SenderParameterName];
                var timestamp = parsedQueryString[TimestampParameterName];
                var text      = parsedQueryString[TextParameterName];

                var receivedAt = ParseTimestamp(timestamp);
                ValidateReceivalTime(receivedAt);
                rawReport.ReceivedAt = receivedAt;

                gatewaySetting = await ValidateGatewaySetting(apiKey);

                rawReport.NationalSociety = gatewaySetting.NationalSociety;

                var dataCollector = await ValidateDataCollector(sender, gatewaySetting.NationalSocietyId);

                rawReport.DataCollector = dataCollector;
                rawReport.IsTraining    = dataCollector.IsInTrainingMode;
                rawReport.Village       = dataCollector.Village;
                rawReport.Zone          = dataCollector.Zone;

                var parsedReport      = _reportMessageService.ParseReport(text);
                var projectHealthRisk = await ValidateReport(parsedReport, dataCollector);

                return(new ReportValidationResult
                {
                    IsSuccess = true,
                    ReportData = new ReportData
                    {
                        DataCollector = dataCollector,
                        ProjectHealthRisk = projectHealthRisk,
                        ReceivedAt = receivedAt,
                        ParsedReport = parsedReport
                    },
                    GatewaySetting = gatewaySetting
                });
            }
            catch (ReportValidationException e)
            {
                _loggerAdapter.Warn(e);

                var sender = parsedQueryString[SenderParameterName];

                string languageCode = null;
                if (gatewaySetting != null)
                {
                    languageCode = await _nyssContext.NationalSocieties
                                   .Where(ns => ns.Id == gatewaySetting.NationalSocietyId)
                                   .Select(ns => ns.ContentLanguage.LanguageCode)
                                   .FirstOrDefaultAsync();
                }

                return(new ReportValidationResult
                {
                    IsSuccess = false,
                    ErrorReportData = new ErrorReportData
                    {
                        Sender = sender,
                        LanguageCode = languageCode,
                        ReportErrorType = e.ErrorType
                    },
                    GatewaySetting = gatewaySetting
                });
            }
            catch (Exception e)
            {
                _loggerAdapter.Warn(e.Message);
                return(new ReportValidationResult {
                    IsSuccess = false
                });
            }
        }