/// <summary>
/// Maps the alert template data from service.
/// </summary>
/// <param name="alertTemplateResults">The alert template results.</param>
/// <returns>
/// alert template data
/// </returns>
private static ListResult<Entities.AlertType> MapAlertTemplateDataListFromService(ListResult<AlertTemplate> alertTemplateResults)
{
var result = new ListResult<Entities.AlertType>();
var alertTemplate = new AlertTypeCollection();
foreach (var alert in alertTemplateResults.Items)
{
var alertTemplateData = new Entities.AlertType();
alertTemplateData.Description = alert.Description;
alertTemplateData.ModifiedBy = alert.LastModifiedBy;
alertTemplateData.AlertTypeId = alert.AlertTemplateId;
alertTemplateData.IsTemplate = true;
alertTemplateData.IsMessage = false;
alertTemplateData.TypeId = alert.AlertTypeId;
alertTemplate.Add(alertTemplateData);
}
result.AssignItems(alertTemplate);
return result;
}
/// <summary>
/// Maps the message data from service.
/// </summary>
/// <param name="messageData">The message data.</param>
/// <returns>Alert type list</returns>
private static ListResult<Entities.AlertType> MapMessageDataListFromService(ListResult<Message> messageData)
{
var result = new ListResult<Entities.AlertType>();
var messages = new AlertTypeCollection();
foreach (var message in messageData.Items)
{
var messagesData = new Entities.AlertType();
messagesData.AddedBy = message.AddedBy;
messagesData.AddedDate = message.AddedDate.GetValueOrDefault();
messagesData.Description = message.Description;
messagesData.DueDate = message.DueDate;
messagesData.ExpiryDate = message.ExpiryDate;
messagesData.ModifiedBy = message.LastModifiedBy;
messagesData.AlertTypeId = message.MessageId;
messagesData.MessageFrom = message.MessageFrom;
messagesData.IsMessage = true;
messagesData.IsTemplate = false;
messagesData.IsSoundEnable = message.IsSoundEnable;
foreach (var personMessages in message.PersonMessages)
{
var personMessage = new Entities.Alert();
personMessage.PersonId = personMessages.PersonId;
personMessage.PersonTypeId = personMessages.PersonTypeId;
personMessage.ShipId = personMessages.ShipId;
personMessage.VoyageId = personMessages.VoyageId;
personMessage.StatusId = personMessages.StatusId;
personMessage.AlertTypeId = personMessages.MessageId;
personMessage.PersonAlertId = personMessages.PersonMessageId;
messagesData.Alerts.Add(personMessage);
}
messages.Add(messagesData);
}
result.AssignItems(messages);
return result;
}
/// <summary>
/// Maps the alert template data from service.
/// </summary>
/// <param name="messageTemplateResults">The message template results.</param>
/// <returns>
/// Message template data
/// </returns>
private static ListResult<Entities.AlertType> MapMessageTemplateDataListFromService(ListResult<MessageTemplate> messageTemplateResults)
{
var result = new ListResult<Entities.AlertType>();
var messageTemplate = new AlertTypeCollection();
foreach (var message in messageTemplateResults.Items)
{
var messageTempalteData = new Entities.AlertType();
messageTempalteData.Description = message.Description;
messageTempalteData.ModifiedBy = message.LastModifiedBy;
messageTempalteData.AlertTypeId = message.MessageTemplateId;
messageTempalteData.IsTemplate = true;
messageTempalteData.IsMessage = true;
messageTemplate.Add(messageTempalteData);
}
result.AssignItems(messageTemplate);
return result;
}
/// <summary>
/// Maps the message template data update.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Message template data</returns>
private static MessageTemplate MapMessageTemplateDataUpdate(AlertTypeCollection alertCollection)
{
var messageTemplateData = new MessageTemplate();
foreach (var messageTemplate in alertCollection)
{
messageTemplateData.Description = messageTemplate.Description;
if (!string.IsNullOrEmpty(messageTemplate.AlertTypeId))
{
messageTemplateData.MessageTemplateId = messageTemplate.AlertTypeId;
messageTemplateData.LastModifiedBy = messageTemplate.ModifiedBy;
}
messageTemplateData.Name = messageTemplate.Description;
}
return messageTemplateData;
}
/// <summary>
/// Maps the alert data from database.
/// </summary>
/// <param name="alertData">The alert data.</param>
/// <returns>
/// Alert type list
/// </returns>
private static ListResult<Entities.AlertType> MapAlertDataListFromService(ListResult<Entities.PersonNotification.Alert> alertData)
{
var result = new ListResult<Entities.AlertType>();
var alerts = new AlertTypeCollection();
foreach (var alert in alertData.Items)
{
Entities.AlertType alertTypeData = new Entities.AlertType();
alertTypeData.AlertTypeId = alert.AlertId;
alertTypeData.AddedBy = alert.AddedBy;
alertTypeData.AddedDate = alert.AddedDate;
alertTypeData.Description = alert.Description;
alertTypeData.DueDate = alert.DueDate;
alertTypeData.ExpiryDate = alert.ExpiryDate;
alertTypeData.IsOverride = alert.IsOverride;
alertTypeData.IsSoundEnable = alert.IsSoundEnable;
alertTypeData.ModifiedBy = alert.LastModifiedBy;
alertTypeData.IsMessage = false;
alertTypeData.IsTemplate = false;
alertTypeData.DepartmentId = alert.DepartmentId;
foreach (var applicationIds in alert.AlertTargetApplications)
{
alertTypeData.ApplicationId = applicationIds.ApplicationId;
}
alertTypeData.TypeId = alert.AlertTypeId;
foreach (var personAlerts in alert.PersonAlerts)
{
Entities.Alert personAlert = new Entities.Alert();
personAlert.PersonId = personAlerts.PersonId;
personAlert.PersonTypeId = personAlerts.PersonTypeId;
personAlert.ShipId = personAlerts.ShipId;
personAlert.VoyageId = personAlerts.VoyageId;
personAlert.StatusId = personAlerts.StatusId;
personAlert.AlertTypeId = personAlerts.AlertId;
personAlert.PersonAlertId = personAlerts.PersonAlertId;
alertTypeData.Alerts.Add(personAlert);
}
alerts.Add(alertTypeData);
}
result.AssignItems(alerts);
return result;
}
/// <summary>
/// Maps the alert template data update.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Alert template data</returns>
private static AlertTemplate MapAlertTemplateDataUpdate(AlertTypeCollection alertCollection)
{
var alertTemplateData = new AlertTemplate();
foreach (var alertTemplate in alertCollection)
{
if (!string.IsNullOrEmpty(alertTemplate.AlertTypeId))
{
alertTemplateData.AlertTemplateId = alertTemplate.AlertTypeId;
alertTemplateData.LastModifiedBy = alertTemplate.ModifiedBy;
}
alertTemplateData.AlertTypeId = alertTemplate.TypeId;
alertTemplateData.Description = alertTemplate.Description;
alertTemplateData.Code = alertTemplate.Description;
}
return alertTemplateData;
}
/// <summary>
/// Maps the message template data.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Message template data</returns>
private static MessageTemplate MapMessageTemplateData(AlertTypeCollection alertCollection)
{
var messageTemplateData = new MessageTemplate();
foreach (var messageTemplate in alertCollection)
{
messageTemplateData.Description = messageTemplate.Description;
messageTemplateData.Name = messageTemplate.Description;
}
return messageTemplateData;
}
/// <summary>
/// Maps the alert template data.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Alert template data</returns>
private static AlertTemplate MapAlertTemplateData(AlertTypeCollection alertCollection)
{
var alertTemplateData = new AlertTemplate();
foreach (var alertTemplate in alertCollection)
{
alertTemplateData.AlertTypeId = alertTemplate.TypeId;
alertTemplateData.Description = alertTemplate.Description;
alertTemplateData.Code = alertTemplate.Description;
}
return alertTemplateData;
}
/// <summary>
/// Maps the message data.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Message data</returns>
private static Message MapMessageData(AlertTypeCollection alertCollection)
{
var messageData = new Message();
foreach (var message in alertCollection)
{
messageData.Description = message.Description;
messageData.DueDate = message.DueDate;
messageData.Name = message.Description;
messageData.ExpiryDate = message.ExpiryDate;
messageData.MessageFrom = message.MessageFrom;
messageData.IsSoundEnable = message.IsSoundEnable;
foreach (var personMessage in message.Alerts)
{
var personMessageData = new PersonMessage();
personMessageData.MessageId = personMessage.AlertTypeId;
personMessageData.PersonId = personMessage.PersonId;
personMessageData.PersonTypeId = personMessage.PersonTypeId;
personMessageData.ShipId = personMessage.ShipId;
personMessageData.VoyageId = personMessage.VoyageId;
if (!string.IsNullOrEmpty(personMessage.StatusId) && personMessage.StatusId.Equals("2"))
{
personMessageData.StatusId = personMessage.StatusId;
}
else
{
personMessageData.StatusId = "1";
}
messageData.PersonMessages.Add(personMessageData);
}
var applicationId = new AlertTargetApplication();
applicationId.ApplicationId = message.ApplicationId;
messageData.AlertTargetApplications.Add(applicationId);
if (!string.IsNullOrEmpty(message.AlertTypeId))
{
messageData.MessageId = message.AlertTypeId;
messageData.LastModifiedBy = message.ModifiedBy;
}
else
{
messageData.AddedBy = message.AddedBy;
}
}
return messageData;
}
/// <summary>
/// Maps the alert data.
/// </summary>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>Alert data</returns>
private static Entities.PersonNotification.Alert MapAlertData(AlertTypeCollection alertCollection)
{
var alertData = new Entities.PersonNotification.Alert();
foreach (var alert in alertCollection)
{
if (!string.IsNullOrEmpty(alert.AlertTypeId))
{
alertData.AlertId = alert.AlertTypeId;
alertData.LastModifiedBy = alert.ModifiedBy;
}
else
{
alertData.AddedBy = alert.AddedBy;
}
foreach (var personAlert in alert.Alerts)
{
var personAlertData = new PersonAlert();
personAlertData.AlertId = personAlert.AlertTypeId;
personAlertData.PersonId = personAlert.PersonId;
personAlertData.PersonTypeId = personAlert.PersonTypeId;
personAlertData.ShipId = personAlert.ShipId;
personAlertData.VoyageId = personAlert.VoyageId;
if (!string.IsNullOrEmpty(personAlert.StatusId) && personAlert.StatusId.Equals("2"))
{
personAlertData.StatusId = personAlert.StatusId;
}
else
{
personAlertData.StatusId = "1";
}
alertData.PersonAlerts.Add(personAlertData);
}
var applicationId = new AlertTargetApplication();
applicationId.ApplicationId = alert.ApplicationId;
alertData.AlertTargetApplications.Add(applicationId);
alertData.AlertTypeId = alert.TypeId;
alertData.Description = alert.Description;
alertData.DueDate = alert.DueDate;
alertData.ExpiryDate = alert.ExpiryDate;
alertData.IsOverride = alert.IsOverride;
alertData.IsSoundEnable = alert.IsSoundEnable;
alertData.DepartmentId = alert.DepartmentId;
}
return alertData;
}
/// <summary>
/// Updates the asynchronous.
/// </summary>
/// <param name="alertTypeId">The alertType identifier.</param>
/// <param name="alertCollection">The alert collection.</param>
/// <returns>
/// Task containing nothing
/// </returns>
public async Task UpdateAsync(string alertTypeId, AlertTypeCollection alertCollection)
{
bool isAlertOrMessage;
foreach (var alert in alertCollection)
{
isAlertOrMessage = alert.Alerts.Any(alertData => !string.IsNullOrEmpty(alertData.PersonId));
if (alert.IsMessage)
{
if (isAlertOrMessage)
{
await this.messageClient.UpdateAsync(
messageId: alertTypeId,
messageData: JsonConvert.SerializeObject(MapMessageData(alertCollection)));
}
if (alert.IsTemplate)
{
if (isAlertOrMessage)
{
ListResult<Entities.AlertType> messageTemplate;
////Name and Desc are Same.
var task = await this.messageTemplateClient.GetListAsync(
name: alert.Description,
pageNumber: 1,
maxResults: int.MaxValue);
messageTemplate = !string.IsNullOrEmpty(task) ? MapMessageTemplateDataListFromService(JsonConvert.DeserializeObject<ListResult<MessageTemplate>>(task)) : default(ListResult<Entities.AlertType>);
if (messageTemplate == null || messageTemplate.Items.Count == 0 || (messageTemplate.Items.Count > 0 && messageTemplate.Items.Any(messageTemplateData => !messageTemplateData.Description.Equals(alert.Description, StringComparison.OrdinalIgnoreCase))))
{
await this.messageTemplateClient.CreateAsync(messageTemplate: JsonConvert.SerializeObject(MapMessageTemplateData(alertCollection)));
}
}
else
{
await this.messageTemplateClient.UpdateAsync(messageTemplateId: alertTypeId, messageTemplate: JsonConvert.SerializeObject(MapMessageTemplateDataUpdate(alertCollection)));
}
}
}
else if (!alert.IsMessage)
{
if (isAlertOrMessage)
{
await this.alertClient.UpdateAlertAsync(alertId: alertTypeId, alertData: JsonConvert.SerializeObject(MapAlertData(alertCollection)));
}
if (alert.IsTemplate)
{
if (isAlertOrMessage)
{
ListResult<Entities.AlertType> alertTemplate;
////Code and description are same
var task = await this.alertTemplateClient.ListAsync(code: alert.Description, pageNumber: 1, maxResults: int.MaxValue);
alertTemplate = !string.IsNullOrEmpty(task) ? MapAlertTemplateDataListFromService(JsonConvert.DeserializeObject<ListResult<AlertTemplate>>(task)) : default(ListResult<Entities.AlertType>);
if (alertTemplate == null || alertTemplate.Items.Count == 0 || (alertTemplate.Items.Count > 0 && alertTemplate.Items.Any(alertTemplateData => !alertTemplateData.Description.Equals(alert.Description, StringComparison.OrdinalIgnoreCase))))
{
await this.alertTemplateClient.CreateAsync(alertTemplate: JsonConvert.SerializeObject(MapAlertTemplateData(alertCollection)));
}
}
else
{
await this.alertTemplateClient.UpdateAsync(id: alertTypeId, alertTemplate: JsonConvert.SerializeObject(MapAlertTemplateDataUpdate(alertCollection)));
}
}
}
}
}
/// <summary>
/// Create alert
/// </summary>
/// <param name="alertCollection">Alert collection</param>
/// <returns>
/// Id of created alert
/// </returns>
public async Task<string> CreateAsync(AlertTypeCollection alertCollection)
{
string task = null;
foreach (var alert in alertCollection)
{
var isAlertOrMessage = alert.Alerts.Any(alertData => !string.IsNullOrEmpty(alertData.PersonId));
if (alert.IsMessage)
{
if (isAlertOrMessage)
{
task = await this.messageClient.CreateAsync(messageData: JsonConvert.SerializeObject(MapMessageData(alertCollection)));
}
if (alert.IsTemplate)
{
task = await this.messageTemplateClient.CreateAsync(messageTemplate: JsonConvert.SerializeObject(MapMessageTemplateData(alertCollection)));
}
}
else if (!alert.IsMessage)
{
if (isAlertOrMessage)
{
task = await this.alertClient.CreateAlertAsync(alertData: JsonConvert.SerializeObject(MapAlertData(alertCollection)));
}
if (alert.IsTemplate)
{
task = await this.alertTemplateClient.CreateAsync(alertTemplate: JsonConvert.SerializeObject(MapAlertTemplateData(alertCollection)));
}
}
}
return task != null ? task : string.Empty;
}
