public async Task SendMessage(GatewaySetting gatewaySetting, List <string> recipientPhoneNumbers, string body)
{
if (string.IsNullOrEmpty(gatewaySetting.EmailAddress))
{
return;
}
var recipients = string.Join(",", recipientPhoneNumbers);
await _emailPublisherService.SendEmail((gatewaySetting.EmailAddress, gatewaySetting.Name), recipients, body, true);
}
public static GatewaySetting GatewayLoad()
{
GatewaySetting setting = null;
if (!Directory.Exists($"{MyWorkPath}\\stf"))
{
Directory.CreateDirectory($"{MyWorkPath}\\stf");
}
string SettingPath = $"{MyWorkPath}\\stf\\Gateway.json";
try
{
if (File.Exists(SettingPath))
{
string json = File.ReadAllText(SettingPath, Encoding.UTF8);
setting = JsonConvert.DeserializeObject <GatewaySetting>(json);
}
else
{
GatewaySetting Setting = new GatewaySetting()
{
CaseNo = "AAA0000000",
Gateways =
{
new Gateway()
{
GatewayIndex = 0,
GatewayTypeEnum = 1,
Location = "127.0.0.1",
Rate = 502,
Devices =
{
new Device()
{
DeviceIndex = 0,
ID = 4,
}
}
}
}
};
setting = Setting;
string output = JsonConvert.SerializeObject(setting, Formatting.Indented, new JsonSerializerSettings());
File.WriteAllText(SettingPath, output);
}
}
catch (Exception ex)
{
Log.Error(ex, " Gateway資訊設定載入錯誤");
}
return(setting);
}
/// <summary>
/// Assigns the values.
/// </summary>
/// <param name="setting">The setting.</param>
/// <param name="kolibriValue">The kolibri values.</param>
/// <returns></returns>
private GatewayDatapoint AssignValues(GatewaySetting setting, KolibriValue kolibriValue)
{
var datapoint = new GatewayDatapoint()
{
Id = setting.Id,
Description = setting.Description,
HexAdress = setting.HexAdress,
IsReadOnly = setting.IsReadOnly,
Value = this.valueConverter.ConvertFromDevice(setting, kolibriValue.Value)
};
return(datapoint);
}
public async Task SendNotificationsForNewAlert(Alert alert, GatewaySetting gatewaySetting)
{
var phoneNumbersOfSupervisorsInAlert = await _nyssContext.AlertReports
.Where(ar => ar.Alert.Id == alert.Id)
.Select(ar => ar.Report.DataCollector.Supervisor.PhoneNumber)
.Distinct()
.ToListAsync();
var message = await CreateNotificationMessageForNewAlert(alert);
await _queuePublisherService.SendSMSesViaEagle(gatewaySetting.EmailAddress, gatewaySetting.Name, phoneNumbersOfSupervisorsInAlert, message);
await _queuePublisherService.QueueAlertCheck(alert.Id);
}
/// <summary>
/// Converts to.
/// </summary>
/// <param name="setting">The setting.</param>
/// <param name="rawValue">The raw value.</param>
/// <returns></returns>
public string ConvertToDevice(GatewaySetting setting, string rawValue)
{
switch (setting.DataType)
{
case SettingDataType.NoConversion:
return(rawValue);
case SettingDataType.Div10:
return((Convert.ToInt32(rawValue) * 10).ToString());
default:
return(rawValue);
}
}
/// <summary>
/// Saves the value to kolibri.
/// </summary>
/// <param name="setting">The setting.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
private Task <IRestResponse> SaveValueToKolibri(GatewaySetting setting, string value)
{
var restClient = new RestClient(ConfigurationManager.AppSettings["ServiceEndpoints:Kolibri"]);
var kolibriRequest = new RestRequest("kolibri", Method.POST);
var body = new KolibriValue()
{
Value = this.valueConverter.ConvertToDevice(setting, value),
HexAddress = setting.HexAdress
};
kolibriRequest.RequestFormat = DataFormat.Json;
kolibriRequest.AddBody(body);
return(restClient.ExecuteTaskAsync(kolibriRequest));
}
public async Task <GatewaySetting> CreateGatewaySetting()
{
var gatewaySetting = new GatewaySetting
{
Id = 1,
Description = "Fake description",
IsReadonly = true,
DataType = SettingDataType.Div10,
HexAdress = "123"
};
using (var context = this.CreateContext())
{
context.GatewaySettings.Add(gatewaySetting);
await context.SaveChangesAsync();
}
return(gatewaySetting);
}
public async Task SendMessage_WhenSuccessful_ShouldCallEmailPublisherService()
{
// Arrange
var recipients = new List <string> {
"+47123143513"
};
var message = "Thanks for your message";
var gatewaySetting = new GatewaySetting
{
Id = 1,
EmailAddress = "*****@*****.**"
};
// Act
await _emailToSMSService.SendMessage(gatewaySetting, recipients, message);
await _emailPublisherServiceMock.Received(1).SendEmail(Arg.Any <(string, string)>(), Arg.Is <string>(_ => _ == "+47123143513"), Arg.Is <string>(body => body == "Thanks for your message"),
Arg.Is <bool>(_ => _));
}
public async Task <Result <int> > Create(int nationalSocietyId, GatewaySettingRequestDto gatewaySettingRequestDto)
{
try
{
var nationalSocietyExists = await _nyssContext.NationalSocieties.AnyAsync(ns => ns.Id == nationalSocietyId);
if (!nationalSocietyExists)
{
return(Error <int>(ResultKey.NationalSociety.SmsGateway.NationalSocietyDoesNotExist));
}
var apiKeyExists = await _nyssContext.GatewaySettings.AnyAsync(gs => gs.ApiKey == gatewaySettingRequestDto.ApiKey);
if (apiKeyExists)
{
return(Error <int>(ResultKey.NationalSociety.SmsGateway.ApiKeyAlreadyExists));
}
var gatewaySettingToAdd = new GatewaySetting
{
Name = gatewaySettingRequestDto.Name,
ApiKey = gatewaySettingRequestDto.ApiKey,
GatewayType = gatewaySettingRequestDto.GatewayType,
EmailAddress = gatewaySettingRequestDto.EmailAddress,
NationalSocietyId = nationalSocietyId
};
await _nyssContext.GatewaySettings.AddAsync(gatewaySettingToAdd);
await _nyssContext.SaveChangesAsync();
await UpdateAuthorizedApiKeys();
return(Success(gatewaySettingToAdd.Id, ResultKey.NationalSociety.SmsGateway.SuccessfullyAdded));
}
catch (ResultException exception)
{
_loggerAdapter.Debug(exception);
return(exception.GetResult <int>());
}
}
private async Task SendFeedbackOnError(ErrorReportData errorReport, GatewaySetting gatewaySetting)
{
if (gatewaySetting != null && !string.IsNullOrEmpty(errorReport.Sender))
{
var feedbackMessage = errorReport.ReportErrorType switch
{
ReportErrorType.FormatError => await GetFeedbackMessageContent(SmsContentKey.ReportError.FormatError, errorReport.LanguageCode),
ReportErrorType.HealthRiskNotFound => await GetFeedbackMessageContent(SmsContentKey.ReportError.HealthRiskNotFound, errorReport.LanguageCode),
ReportErrorType.DataCollectorNotFound => null,
_ => await GetFeedbackMessageContent(SmsContentKey.ReportError.Other, errorReport.LanguageCode)
};
if (string.IsNullOrEmpty(feedbackMessage))
{
_loggerAdapter.Warn($"No feedback message found for error type {errorReport.ReportErrorType}");
return;
}
var senderList = new List <string>(new[] { errorReport.Sender });
await _queuePublisherService.SendSMSesViaEagle(gatewaySetting.EmailAddress, gatewaySetting.Name, senderList, feedbackMessage);
}
}
public async Task Handle(string queryString)
{
var parsedQueryString = HttpUtility.ParseQueryString(queryString);
var sender = parsedQueryString[SenderParameterName];
var timestamp = parsedQueryString[TimestampParameterName];
var text = parsedQueryString[TextParameterName];
var incomingMessageId = parsedQueryString[IncomingMessageIdParameterName].ParseToNullableInt();
var outgoingMessageId = parsedQueryString[OutgoingMessageIdParameterName].ParseToNullableInt();
var modemNumber = parsedQueryString[ModemNumberParameterName].ParseToNullableInt();
var apiKey = parsedQueryString[ApiKeyParameterName];
ErrorReportData reportErrorData = null;
try
{
Alert triggeredAlert = null;
ProjectHealthRisk projectHealthRisk = null;
GatewaySetting gatewaySetting = null;
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var rawReport = new RawReport
{
Sender = sender,
Timestamp = timestamp,
ReceivedAt = _dateTimeProvider.UtcNow,
Text = text,
IncomingMessageId = incomingMessageId,
OutgoingMessageId = outgoingMessageId,
ModemNumber = modemNumber,
ApiKey = apiKey
};
await _nyssContext.AddAsync(rawReport);
var reportValidationResult = await ParseAndValidateReport(rawReport, parsedQueryString);
if (reportValidationResult.IsSuccess)
{
gatewaySetting = reportValidationResult.GatewaySetting;
projectHealthRisk = reportValidationResult.ReportData.ProjectHealthRisk;
var epiDate = _dateTimeProvider.GetEpiDate(reportValidationResult.ReportData.ReceivedAt);
var report = new Report
{
IsTraining = reportValidationResult.ReportData.DataCollector.IsInTrainingMode,
ReportType = reportValidationResult.ReportData.ParsedReport.ReportType,
Status = ReportStatus.New,
ReceivedAt = reportValidationResult.ReportData.ReceivedAt,
CreatedAt = _dateTimeProvider.UtcNow,
DataCollector = reportValidationResult.ReportData.DataCollector,
EpiWeek = epiDate.EpiWeek,
EpiYear = epiDate.EpiYear,
PhoneNumber = sender,
Location = reportValidationResult.ReportData.DataCollector.Location,
ReportedCase = reportValidationResult.ReportData.ParsedReport.ReportedCase,
KeptCase = new ReportCase
{
CountMalesBelowFive = null,
CountMalesAtLeastFive = null,
CountFemalesBelowFive = null,
CountFemalesAtLeastFive = null
},
DataCollectionPointCase = reportValidationResult.ReportData.ParsedReport.DataCollectionPointCase,
ProjectHealthRisk = projectHealthRisk,
ReportedCaseCount = projectHealthRisk.HealthRisk.HealthRiskType == HealthRiskType.Human
? (reportValidationResult.ReportData.ParsedReport.ReportedCase.CountFemalesAtLeastFive ?? 0)
+ (reportValidationResult.ReportData.ParsedReport.ReportedCase.CountFemalesBelowFive ?? 0)
+ (reportValidationResult.ReportData.ParsedReport.ReportedCase.CountMalesAtLeastFive ?? 0)
+ (reportValidationResult.ReportData.ParsedReport.ReportedCase.CountMalesBelowFive ?? 0)
: 1
};
rawReport.Report = report;
await _nyssContext.Reports.AddAsync(report);
triggeredAlert = await _alertService.ReportAdded(report);
}
else
{
reportErrorData = reportValidationResult.ErrorReportData;
gatewaySetting = reportValidationResult.GatewaySetting;
}
await _nyssContext.SaveChangesAsync();
transactionScope.Complete();
}
if (reportErrorData == null)
{
if (!string.IsNullOrEmpty(gatewaySetting?.EmailAddress) && projectHealthRisk != null)
{
var recipients = new List <string> {
sender
};
await _queuePublisherService.SendSMSesViaEagle(gatewaySetting.EmailAddress, gatewaySetting.Name, recipients, projectHealthRisk.FeedbackMessage);
}
if (triggeredAlert != null)
{
await _alertService.SendNotificationsForNewAlert(triggeredAlert, gatewaySetting);
}
}
else
{
await SendFeedbackOnError(reportErrorData, gatewaySetting);
}
}
catch (ReportValidationException e)
{
_loggerAdapter.Warn(e.Message);
}
}
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
});
}
}
