/// <summary>
/// Lists the asynchronous.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns>
/// List of Alerts
/// </returns>
public async Task<ListResult<Entities.AlertType>> ListAsync(AlertListRequestSearchParameters filter)
{
string task;
if (filter.TypeIds == "0")
{
filter.TypeIds = string.Empty;
}
if (filter.IsMessage.HasValue && filter.IsMessage.Value && !filter.IsTemplate && filter.IsAlert.HasValue && !filter.IsAlert.Value)
{
task = await this.messageClient.GetListAsync(
messageIds: filter.AlertTypeIds,
personIds: filter.PersonIds,
addedDate: filter.AddedDate,
pageNumber: 1,
maxResults: int.MaxValue,
orderBy: filter.OrderBy);
return !string.IsNullOrEmpty(task) ? MapMessageDataListFromService(JsonConvert.DeserializeObject<ListResult<Message>>(task)) : default(ListResult<Entities.AlertType>);
}
if (filter.IsMessage.HasValue && filter.IsMessage.Value && filter.IsTemplate)
{
task = await this.messageTemplateClient.GetListAsync(
messageTemplateIds: filter.AlertTypeIds,
pageNumber: 1,
maxResults: int.MaxValue,
orderBy: filter.OrderBy);
return !string.IsNullOrEmpty(task) ? MapMessageTemplateDataListFromService(JsonConvert.DeserializeObject<ListResult<MessageTemplate>>(task)) : default(ListResult<Entities.AlertType>);
}
if (filter.IsTemplate)
{
task = await this.alertTemplateClient.ListAsync(
alertTemplateIds: filter.AlertTypeIds,
alertTypeIds: filter.TypeIds,
orderBy: filter.OrderBy,
pageNumber: 1,
maxResults: int.MaxValue);
return !string.IsNullOrEmpty(task) ? MapAlertTemplateDataListFromService(JsonConvert.DeserializeObject<ListResult<AlertTemplate>>(task)) : default(ListResult<Entities.AlertType>);
}
ListResult<Entities.AlertType> alerts;
task = await this.alertClient.GetListAsync(
alertIds: filter.AlertTypeIds,
personIds: filter.PersonIds,
alertTypeIds: filter.TypeIds,
addedDate: filter.AddedDate,
pageNumber: 1,
maxResults: int.MaxValue);
alerts = !string.IsNullOrEmpty(task) ? MapAlertDataListFromService(JsonConvert.DeserializeObject<ListResult<Entities.PersonNotification.Alert>>(task)) : default(ListResult<Entities.AlertType>);
if (filter.IsMessage.HasValue && filter.IsMessage.Value)
{
task = await this.messageClient.GetListAsync(
messageIds: filter.AlertTypeIds,
personIds: filter.PersonIds,
addedDate: filter.AddedDate,
pageNumber: 1,
maxResults: int.MaxValue);
ListResult<Entities.AlertType> messages = !string.IsNullOrEmpty(task) ? MapMessageDataList(JsonConvert.DeserializeObject<ListResult<Message>>(task), alerts) : default(ListResult<Entities.AlertType>);
if (messages != null && messages.Items.Count > 0)
{
return messages;
}
}
return alerts;
}
/// <summary>
/// Setups the search request.
/// </summary>
private void SetupSearchRequest()
{
filter = new AlertListRequestSearchParameters
{
AlertTypeIds = "1",
ApplicationId = "1",
DenyAshore = false,
DenyBoarding = false,
IsAlert = false,
IsExpiredAlert = false,
IsMessage = true,
IsRecentAlert = true,
IsTemplate = false,
MaxResults = 50,
OrderBy = null,
PageNumber = 1,
PersonIds = "1",
ShipId = "5",
ShipTime = DateTime.Now,
TypeIds = "1"
};
var alertType = new Entities.AlertType
{
AddedBy = "Ryan",
AddedDate = DateTime.Now,
AlertTypeId = "1",
AllowCheckIn = true,
ApplicationId = "2",
DepartmentId = "2",
Description = "agree",
DueDate = DateTime.Now,
ExpiryDate = DateTime.Now,
IsDenyAshore = true,
IsDenyBoarding = true,
IsMessage = true,
IsOverride = true,
IsSoundEnable = true,
IsTemplate = false,
MessageFrom = "trott",
ModifiedBy = "jhone",
OrderCode = "33",
TemplateName = "edd",
TypeId = "3"
};
alertType.Alerts.Add(new Entities.Alert { PersonId = "1" });
alertTypes = new Entities.AlertTypeCollection
{
alertType
};
}
/// <summary>
/// Retrieves the person alerts.
/// </summary>
/// <param name="personSearchParameter">The person search parameter.</param>
/// <param name="personIds">The person ids.</param>
/// <returns>
/// The alerts.
/// </returns>
private async Task<ListResult<Entities.AlertType>> RetrievePersonAlerts(PersonSearchParameter personSearchParameter, string personIds)
{
var isMessage = false;
var isAlert = false;
if (personSearchParameter.IsMessageCount != null && Convert.ToBoolean(personSearchParameter.IsMessageCount, CultureInfo.CurrentCulture))
{
isMessage = true;
}
if (personSearchParameter.IsAlertCount != null && Convert.ToBoolean(personSearchParameter.IsAlertCount, CultureInfo.CurrentCulture))
{
isAlert = true;
}
var alertSearchParameter = new AlertListRequestSearchParameters
{
ApplicationId = Convert.ToString(this.applicationSettings.ApplicationId, CultureInfo.CurrentCulture),
PersonIds = personIds,
IsMessage = isMessage,
IsAlert = isAlert,
IsExpiredAlert = false
};
if (string.IsNullOrWhiteSpace(personSearchParameter.ShipTime))
{
var shipTimeTask = await this.shipTimeRepository.GetByIdAsync(this.applicationSettings.ShipId, null);
alertSearchParameter.ShipTime = string.IsNullOrWhiteSpace(shipTimeTask) ? DateTime.Now : DateTime.UtcNow.AddMinutes(Convert.ToDouble(shipTimeTask));
}
else
{
alertSearchParameter.ShipTime = DateTime.Parse(personSearchParameter.ShipTime, CultureInfo.InvariantCulture);
}
var result = new ListResult<Entities.AlertType>();
var alertTemplate = new Entities.AlertTypeCollection();
var alertDetails = await this.RetrieveAlertDetails(alertSearchParameter);
foreach (var alert in alertDetails.Items)
{
if ((alert.ExpiryDate.HasValue && alert.ExpiryDate.Value > alertSearchParameter.ShipTime) || !alert.ExpiryDate.HasValue)
{
var active = alert.Alerts.Any(personAlert => personAlert.StatusId == "1");
if (active)
{
alertTemplate.Add(alert);
}
}
}
result.AssignItems(alertTemplate);
return result;
}
/// <summary>
/// Retrieves the alert details.
/// </summary>
/// <param name="alertSearchParameter">The alert search parameter.</param>
/// <returns>The alert details.</returns>
private async Task<ListResult<Entities.AlertType>> RetrieveAlertDetails(AlertListRequestSearchParameters alertSearchParameter)
{
var batchSize = 20;
var personIdsArray = !string.IsNullOrEmpty(alertSearchParameter.PersonIds) ? alertSearchParameter.PersonIds.Split(',') : null;
if (personIdsArray != null && personIdsArray.Length > batchSize)
{
int counter = 0;
var alertDetails = new ListResult<Entities.AlertType>();
string[] currentBatch = new string[(personIdsArray.Length / batchSize) + ((personIdsArray.Length % batchSize) > 0 ? 1 : 0)];
int batchCounter = 0;
foreach (var id in personIdsArray)
{
if (counter == batchSize)
{
batchCounter++;
counter = 0;
}
counter++;
currentBatch[batchCounter] += id + ",";
}
var tasks = currentBatch.Select(personBatch => { alertSearchParameter.PersonIds = personBatch; return this.alertClientRepository.ListAsync(alertSearchParameter); }).ToList();
await Task.WhenAll(tasks);
foreach (var task in tasks)
{
var partialalerts = task.Result;
foreach (var item in partialalerts.Items)
{
alertDetails.Items.Add(item);
}
}
alertDetails.TotalResults = alertDetails.Items.Count;
return alertDetails;
}
return await this.alertClientRepository.ListAsync(alertSearchParameter);
}
/// <summary>
/// Retrieves the alerts.
/// </summary>
/// <param name="filter">The filter.</param>
/// <returns>
/// Alert task
/// </returns>
public async Task<ListResult<Alert>> ListAsync(AlertSearchParameters filter)
{
var alertSearch = new AlertListRequestSearchParameters
{
PageNumber = filter.PageNumber.RetrievePageNumber(),
MaxResults = filter.MaxResults.RetrieveMaxResults(),
AlertTypeIds = filter.AlertTypeIds,
ApplicationId = string.IsNullOrWhiteSpace(filter.ApplicationId) ? Convert.ToString(this.applicationSettings.ApplicationId, CultureInfo.CurrentCulture) : filter.ApplicationId,
OrderBy = filter.OrderBy,
ShipId = filter.ShipId,
PersonIds = filter.PersonIds,
IsTemplate = !string.IsNullOrEmpty(filter.IsTemplate) ? Convert.ToBoolean(filter.IsTemplate, CultureInfo.CurrentCulture) : false,
TypeIds = !string.IsNullOrEmpty(filter.TypeId) ? filter.TypeId : null,
IsAlert = !string.IsNullOrEmpty(filter.IsAlert) ? Convert.ToBoolean(filter.IsAlert, CultureInfo.CurrentCulture) : (bool?)null,
IsRecentAlert = !string.IsNullOrEmpty(filter.IsRecentAlert) ? Convert.ToBoolean(filter.IsRecentAlert, CultureInfo.CurrentCulture) : (bool?)null,
IsMessage = !string.IsNullOrWhiteSpace(filter.IsMessage) ? Convert.ToBoolean(filter.IsMessage, CultureInfo.CurrentCulture) : (bool?)null,
IsExpiredAlert = !string.IsNullOrWhiteSpace(filter.IsExpiredAlert) ? Convert.ToBoolean(filter.IsExpiredAlert, CultureInfo.CurrentCulture) : (bool?)null,
AddedDate = filter.AddedDate
};
if (string.IsNullOrWhiteSpace(filter.ShipTime))
{
var shipTimeTask = await this.shipTimeRepository.GetByIdAsync(this.applicationSettings.ShipId, null);
alertSearch.ShipTime = string.IsNullOrWhiteSpace(shipTimeTask) ? DateTime.Now : DateTime.UtcNow.AddMinutes(Convert.ToDouble(shipTimeTask));
}
else
{
alertSearch.ShipTime = DateTime.Parse(filter.ShipTime, CultureInfo.InvariantCulture);
}
var alertData = await this.alertRepository.ListAsync(alertSearch);
var result = new ListResult<Alert>();
var alerts = new AlertCollection();
foreach (var alertType in alertData.Items)
{
alerts.Add(MapAlertData(alertType, alertSearch.ShipTime));
}
if (!alertSearch.IsExpiredAlert.GetValueOrDefault(false) && !alertSearch.IsTemplate)
{
var filteredAlerts = alerts.Where(alert => alert.IsActive).ToList();
result.AssignItems(filteredAlerts);
result.TotalResults = filteredAlerts.Count;
}
else
{
result.AssignItems(alerts);
result.TotalResults = alerts.Count;
}
return result;
}
