public IEnumerator AlertPresenterTest()
{
var obj = new GameObject("view");
var view = obj.AddComponent <AlertView>();
var pre = new AlertPresenter(view);
Assert.NotNull(pre);
Assert.IsInstanceOf <IAlertPresenter>(pre);
yield return(null);
}
/// <summary>
/// Indexes the specified alert identifier.
/// </summary>
/// <param name="alertId">The alert identifier.</param>
/// <param name="type">The type.</param>
/// <returns>alert list</returns>
public async Task<ActionResult> Index(string alertId, string type)
{
var alertPresenter = new AlertPresenter();
if (!string.IsNullOrEmpty(SessionData.Instance.IsMessageMode) && SessionData.Instance.IsMessageMode == TrueConstant)
{
alertPresenter.IsMessage = true;
}
BaseController.GetAboutUsInformation(alertPresenter);
if (!string.IsNullOrEmpty(alertId))
{
string types = type;
var alertDetailResult = await this.alertManager.GetAlertDetailsById(alertId, string.IsNullOrEmpty(types) ? TypeConstant : types);
if (alertDetailResult != null)
{
alertPresenter.Description = alertDetailResult.Description;
if (alertDetailResult.AddedDate != null)
{
var addedDate = Convert.ToDateTime(alertDetailResult.AddedDate, CultureInfo.InvariantCulture);
alertPresenter.CreatedDate = BaseController.GenerateLocalDateTime(addedDate);
}
alertPresenter.TypeId = alertDetailResult.TypeId;
alertPresenter.UserName = alertDetailResult.UserName;
alertPresenter.ExpiryDate = alertDetailResult.ExpiryDate.HasValue ? alertDetailResult.ExpiryDate.Value.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : string.Empty;
alertPresenter.StartDate = alertDetailResult.StartDate.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.PersonCount = alertDetailResult.PersonCount;
alertPresenter.MessageFrom = alertDetailResult.MessageFrom;
if (alertDetailResult.Persons.Count > 0)
{
SessionData.Instance.AssignPersonsResult(alertDetailResult.Persons);
var maxPaging = DefaultPageSize > alertPresenter.PersonCount ? alertPresenter.PersonCount : DefaultPageSize;
var pagingResult = SessionData.Instance.PersonsResult.Skip(0).Take(maxPaging - 0).ToList();
alertPresenter.AssignPagingPersonList(pagingResult);
}
}
}
return this.View(alertPresenter);
}
/// <summary>
/// Adds the passenger.
/// </summary>
/// <param name="presenter">The alert presenter.</param>
/// <param name="personId">The person ids.</param>
/// <returns>
/// The JSON Result
/// </returns>
public ActionResult AddPassenger(AlertPresenter presenter, string personId)
{
var alertPresenter = new AlertPresenter();
if (presenter != null)
{
alertPresenter = presenter;
}
if (!string.IsNullOrEmpty(personId))
{
var filteredPersonList = new List<Person>();
var personSearchResult = new ListResult<Person>();
if (!SessionData.Instance.SelectedPersonIds.Contains(personId))
{
SessionData.Instance.SelectedPersonIds.Add(personId);
}
if (SessionData.Instance.PassengerAutoSearchItems != null && SessionData.Instance.PassengerAutoSearchItems.Items.Count > 0)
{
filteredPersonList.Add(SessionData.Instance.PassengerAutoSearchItems.Items.FirstOrDefault(person => person.PersonId.Equals(personId)));
}
if (filteredPersonList.Count > 0)
{
if (SessionData.Instance.FilterPersonList != null && SessionData.Instance.FilterPersonList.Count > 0)
{
foreach (var person in SessionData.Instance.FilterPersonList.Where(person => !person.PersonId.Equals(personId)))
{
filteredPersonList.Add(person);
}
}
personSearchResult.AssignItems(filteredPersonList);
alertPresenter.AssignPersonSearchResult(personSearchResult);
SessionData.Instance.AssignFilterPersonResult(filteredPersonList);
}
return this.PartialView(AlertPassengerListPartialView, alertPresenter);
}
return this.View();
}
/// <summary>
/// Automatics the complete suggestions.
/// </summary>
/// <param name="searchText">The search text.</param>
/// <param name="searchType">Type of the search.</param>
/// <param name="isAutoComplete">if set to <c>true</c> [is automatic complete].</param>
/// <returns>
/// The Suggestion as per search Text.
/// </returns>
public async Task<JsonResult> AutoCompleteSuggestions(string searchText, string searchType, bool isAutoComplete)
{
if (string.IsNullOrEmpty(searchType))
{
searchType = LastName;
}
if (!string.IsNullOrEmpty(searchText) && !string.IsNullOrEmpty(searchType))
{
var searchFilter = new SearchFilters { IsAlertCount = false, IsMessageCount = false };
foreach (var voyage in SessionData.Instance.MasterData.Voyages)
{
searchFilter.VoyageId += voyage.VoyageId + Comma;
}
if (searchType.Equals(Stateroom, StringComparison.InvariantCultureIgnoreCase))
{
searchFilter.Stateroom = searchText;
}
else if (searchType.Equals(BookingNo, StringComparison.InvariantCultureIgnoreCase))
{
searchFilter.ReservationNo = searchText;
}
else if (searchType.Equals(PassportNo, StringComparison.InvariantCultureIgnoreCase))
{
searchFilter.PassportNo = searchText;
}
else if (searchType.Equals(LastName, StringComparison.InvariantCultureIgnoreCase))
{
searchFilter.LastNameContains = searchText;
}
else if (searchType.Equals(Birthdate, StringComparison.InvariantCultureIgnoreCase))
{
searchFilter.Birthdate = searchText;
}
searchFilter.IsAutoComplete = isAutoComplete;
var presenter = new AlertPresenter();
var persons = await this.personManager.GetPersonsAsync(searchFilter, presenter.AuthenticationToken);
SessionData.Instance.AssignPersonAutoSearchResult(persons);
var namelist = SessionData.Instance.PassengerAutoSearchItems.Items.SelectMany(items => new List<string> { string.Format(PassengerAutoSearchStringFormat, items.PersonalDetail.LastName, items.PersonalDetail.FirstName, items.PersonId, items.Stateroom, items.PersonalDetail.Gender) });
return this.Json(namelist, JsonRequestBehavior.AllowGet);
}
return this.Json(string.Empty, JsonRequestBehavior.AllowGet);
}
public async Task<ActionResult> AlertPassengerSearch(AlertPresenter alertPresenter)
{
if (alertPresenter != null && !string.IsNullOrEmpty(alertPresenter.SearchText))
{
ModelState.Clear();
var searchFilter = new SearchFilters { LastNameContains = alertPresenter.SearchText, IsAlertCount = false, IsMessageCount = false };
var persons = await this.personManager.GetPersonsAsync(searchFilter, alertPresenter.AuthenticationToken);
alertPresenter.AssignPersonSearchResult(persons);
SessionData.Instance.AssignPersonSearchResult(persons.Items.ToList());
return this.PartialView(AlertPassengerListPartialView, alertPresenter);
}
return this.View();
}
/// <summary>
/// Alerts the type template.
/// </summary>
/// <param name="alertTypeId">The alert type identifier.</param>
/// <returns>The Action Result</returns>
public async Task<ActionResult> AlertTypeTemplate(string alertTypeId)
{
var alertPresenter = new AlertPresenter();
var shipTime = DateTime.UtcNow;
var alertDetails = await this.alertManager.AlertTypeAsync(alertTypeId, false, false, false, BaseController.GenerateLocalDateTime(shipTime).ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture), true, string.Empty);
ModelState.Clear();
if (alertDetails != null)
{
SessionData.Instance.AssignAlertSearchResult(alertDetails);
var maxPaging = DefaultPageSize > SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Count() ? SessionData.Instance.AlertItems.Items.Count() : DefaultPageSize;
var pagingResult = SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Skip(0).Take(maxPaging - 0).ToList();
alertPresenter.AssignAlertSearchResult(pagingResult);
}
return this.PartialView(AlertTemplateListPartialView, alertPresenter);
}
/// <summary>
/// Alerts the type.
/// </summary>
/// <param name="alertTypeId">The alert type identifier.</param>
/// <param name="isExpiredAlert">The is expired alert.</param>
/// <param name="todaysAlert">The todays alert.</param>
/// <param name="isCreatedAlert">The is created alert.</param>
/// <returns>
/// return list
/// </returns>
public async Task<ActionResult> AlertType(string alertTypeId, string isExpiredAlert, string todaysAlert, string isCreatedAlert)
{
var alertPresenter = new AlertPresenter();
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow).ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture);
var addedDateParameter = string.Empty;
ViewBag.IsCreatedAlertList = false;
var alertList = new ListResult<Alert>();
if (isCreatedAlert.Equals("true", StringComparison.InvariantCultureIgnoreCase))
{
addedDateParameter = shipTime;
ViewBag.IsCreatedAlertList = true;
}
var alertDetails = await this.alertManager.AlertTypeAsync(alertTypeId, Convert.ToBoolean(isExpiredAlert, CultureInfo.InvariantCulture), Convert.ToBoolean(todaysAlert, CultureInfo.InvariantCulture), false, shipTime, false, addedDateParameter);
ModelState.Clear();
foreach (var alert in alertDetails.Items)
{
var addedDate = Convert.ToDateTime(alert.AddedDate, CultureInfo.InvariantCulture);
alert.AddedDate = Convert.ToString(BaseController.GenerateLocalDateTime(addedDate), CultureInfo.InvariantCulture);
if (alert.Persons.Count > 0)
{
alertList.Items.Add(alert);
}
}
SessionData.Instance.AssignAlertSearchResult(alertList);
var maxPaging = DefaultPageSize > SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Count() ? SessionData.Instance.AlertItems.Items.Count() : DefaultPageSize;
var pagingResult = SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Skip(0).Take(maxPaging - 0).ToList();
alertPresenter.AssignAlertSearchResult(pagingResult);
return this.PartialView(AlertListPartialView, alertPresenter);
}
public void ResetAlertPassengersTest()
{
try
{
SessionData.Instance.User = CommonHelper.SetupUserData();
var alertPresenter = new AlertPresenter();
string templateValue = string.Empty;
Alert alertDetailResult = SetUpAlertData();
alertDetailResult.Persons = new PersonCollection { new Person { PersonId = "1228", PersonTypeId = "3", PersonalDetail = new PersonalDetail { FirstName = "R", LastName = "Della", DepartmentId = string.Empty, CitizenshipCountryId = "102", Gender = "M", Title = "Mr." } } };
if (alertDetailResult.Persons.Count > 0 && string.IsNullOrEmpty(templateValue))
{
var personList = new ListResult<Person>();
personList.AssignItems(alertDetailResult.Persons);
alertPresenter.AssignPersonSearchResult(personList);
foreach (var person in alertDetailResult.Persons)
{
SessionData.Instance.SelectedPersonIds.Add(person.PersonId);
}
SessionData.Instance.AssignFilterPersonResult(alertDetailResult.Persons);
}
this.alertController.ResetPassengers(new AlertPresenter());
Assert.IsTrue(true);
}
finally
{
this.Dispose();
}
}
/// <summary>
/// Manages the alert template.
/// </summary>
/// <param name="alertPresenter">The alert presenter.</param>
/// <returns>The Action Result.</returns>
public async Task<ActionResult> ManageAlertTemplate(AlertPresenter alertPresenter)
{
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow);
alertPresenter.IsTemplate = true;
var alertType = alertPresenter.AlertTypes.FirstOrDefault();
string alertId = alertType != null ? alertType.AlertTypeId.ToString(CultureInfo.CurrentCulture) : string.Empty;
var alertDetails = await this.alertManager.AlertTypeAsync(alertId, false, false, false, shipTime.ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture), true, string.Empty);
if (alertDetails != null)
{
SessionData.Instance.AssignAlertSearchResult(alertDetails);
var maxPaging = DefaultPageSize > SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Count() ? SessionData.Instance.AlertItems.Items.Count() : DefaultPageSize;
var pagingResult = SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Skip(0).Take(maxPaging - 0).ToList();
alertPresenter.AssignAlertSearchResult(pagingResult);
}
alertPresenter.FilterAlertsType = FillAlertTypeList(alertPresenter);
BaseController.GetAboutUsInformation(alertPresenter);
return this.View(AlertTemplateView, alertPresenter);
}
public async Task<ActionResult> CreateAlert(AlertPresenter alertPresenter, string alertType)
{
if (alertPresenter != null)
{
var personData = new PersonCollection();
if (alertType.Equals(SetData, StringComparison.InvariantCultureIgnoreCase))
{
var alertData = new Alert
{
Description = alertPresenter.Description,
TypeId = Convert.ToInt32(alertPresenter.SelectedAlertTypes),
StartDate = Convert.ToDateTime(alertPresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = Convert.ToDateTime(alertPresenter.ExpiryDate, CultureInfo.InvariantCulture),
IsOverride = alertPresenter.IsOverrideAllowed,
IsSoundEnable = alertPresenter.IsSoundEnable,
AlertType = alertPresenter.AlertType,
IsTemplate = alertPresenter.IsTemplate,
TemplateName = alertPresenter.Description,
CrewDepartmentId = alertPresenter.SelectedCrewDepartment
};
SessionData.Instance.AssignAlertData(alertData);
return this.Json(true);
}
var alert = new Alert
{
Description = alertPresenter.Description,
TypeId = Convert.ToInt32(alertPresenter.SelectedAlertTypes),
Rank = alertPresenter.Rank,
StartDate = Convert.ToDateTime(alertPresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = Convert.ToDateTime(alertPresenter.ExpiryDate, CultureInfo.InvariantCulture),
IsOverride = alertPresenter.IsOverrideAllowed,
IsSoundEnable = alertPresenter.IsSoundEnable,
AlertType = alertPresenter.AlertType,
UserName = !string.IsNullOrWhiteSpace(SessionData.Instance.User.FirstName) ? SessionData.Instance.User.LastName + Comma + SessionData.Instance.User.FirstName : SessionData.Instance.User.LastName,
IsTemplate = alertPresenter.IsTemplate,
TemplateName = alertPresenter.Description,
CrewDepartmentId = alertPresenter.SelectedCrewDepartment
};
if (!string.IsNullOrEmpty(SessionData.Instance.ActiveAlertId))
{
alert.AlertId = SessionData.Instance.ActiveAlertId;
}
if (SessionData.Instance.FilterPersonList != null)
{
foreach (var person in SessionData.Instance.FilterPersonList)
{
personData.Add(person);
}
}
alert.Persons = personData;
var alertDetail = alertType == Update ? await this.alertManager.UpdateAlertAsync(alert, SessionData.Instance.ActiveAlertId) : await this.alertManager.CreateAlertAsync(alert);
if (alertDetail != null && SessionData.Instance.FilterPersonList != null)
{
SessionData.Instance.PassengerSearchItems.Items.Clear();
SessionData.Instance.FilterPersonList.Clear();
SessionData.Instance.ActiveAlertId = string.Empty;
SessionData.Instance.GlobalAlertPersonList.Clear();
SessionData.Instance.GlobalMessagePersonList.Clear();
SessionData.Instance.SelectedPersonIds.Clear();
SessionData.Instance.AlertData = null;
return this.Json(true);
}
}
return this.Json(false);
}
/// <summary>
/// Creates the alert.
/// </summary>
/// <param name="alertId">The alert identifier.</param>
/// <param name="isTemplate">The is template.</param>
/// <param name="type">The type.</param>
/// <returns>
/// The create alert
/// </returns>
public async Task<ActionResult> CreateAlert(string alertId, string isTemplate, string type)
{
var alertPresenter = new AlertPresenter();
alertPresenter.IsTemplate = string.IsNullOrEmpty(isTemplate) ? SessionData.Instance.AlertData != null && SessionData.Instance.AlertData.IsTemplate : Convert.ToBoolean(isTemplate, CultureInfo.InvariantCulture);
BaseController.GetAboutUsInformation(alertPresenter);
var saveUtcNow = BaseController.GenerateLocalDateTime(DateTime.UtcNow);
SessionData.Instance.IsMessageMode = FalseConstantValue;
if (!string.IsNullOrEmpty(alertId))
{
var alertDetailResult = await this.alertManager.GetAlertDetailsById(alertId, type);
alertPresenter.SelectedCrewDepartment = Convert.ToString(alertDetailResult.CrewDepartmentId, CultureInfo.InvariantCulture);
alertPresenter.SelectedAlertTypes = Convert.ToString(alertDetailResult.TypeId, CultureInfo.InvariantCulture);
alertPresenter.UserName = alertDetailResult.UserName;
alertPresenter.StartDate = alertDetailResult.StartDate.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.ExpiryDate = !alertPresenter.IsTemplate ? alertDetailResult.ExpiryDate.Value.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : string.Empty;
ViewBag.startDate = alertPresenter.IsTemplate ? saveUtcNow.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : alertDetailResult.StartDate.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
ViewBag.expireDate = alertPresenter.IsTemplate ? saveUtcNow.AddHours(1).ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : alertDetailResult.ExpiryDate.Value.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.PersonCount = alertDetailResult.PersonCount;
alertPresenter.IsOverrideAllowed = alertDetailResult.IsOverride;
alertPresenter.IsSoundEnable = alertDetailResult.IsSoundEnable;
SessionData.Instance.ActiveAlertId = alertId;
SessionData.Instance.TypeId = type;
SessionData.Instance.AssignAlertData(alertDetailResult);
if (alertDetailResult.Persons.Count > 0 && string.IsNullOrEmpty(isTemplate))
{
var personList = new ListResult<Person>();
personList.AssignItems(alertDetailResult.Persons);
alertPresenter.AssignPersonSearchResult(personList);
foreach (var person in alertDetailResult.Persons)
{
SessionData.Instance.SelectedPersonIds.Add(person.PersonId);
}
SessionData.Instance.AssignFilterPersonResult(alertDetailResult.Persons);
}
}
if (SessionData.Instance.GlobalAlertPersonList != null && SessionData.Instance.GlobalAlertPersonList.Count > 0)
{
foreach (var person in SessionData.Instance.GlobalAlertPersonList)
{
if (!SessionData.Instance.FilterPersonList.Any(p => p.PersonId == person.PersonId))
{
SessionData.Instance.AssignGlobalPersonResult(person);
}
}
SetPassengerData(alertPresenter);
}
if (SessionData.Instance.SelectedPersonIds != null && SessionData.Instance.SelectedPersonIds.Count > 0 && string.IsNullOrEmpty(isTemplate))
{
SetPassengerData(alertPresenter);
}
if (SessionData.Instance.AlertData != null)
{
alertPresenter.SelectedCrewDepartment = Convert.ToString(SessionData.Instance.AlertData.CrewDepartmentId, CultureInfo.InvariantCulture);
alertPresenter.AlertType = SessionData.Instance.AlertData.AlertType;
alertPresenter.Description = SessionData.Instance.AlertData.Description;
alertPresenter.StartDate = SessionData.Instance.AlertData.StartDate.ToString(CultureInfo.InvariantCulture);
alertPresenter.ExpiryDate = !alertPresenter.IsTemplate ? SessionData.Instance.AlertData.ExpiryDate.Value.ToString(CultureInfo.InvariantCulture) : string.Empty;
alertPresenter.IsOverrideAllowed = SessionData.Instance.AlertData.IsOverride;
alertPresenter.IsSoundEnable = SessionData.Instance.AlertData.IsSoundEnable;
alertPresenter.SelectedAlertTypes = Convert.ToString(SessionData.Instance.AlertData.TypeId, CultureInfo.InvariantCulture);
ViewBag.startDate = alertPresenter.StartDate;
ViewBag.expireDate = alertPresenter.ExpiryDate;
}
else if (string.IsNullOrEmpty(alertId))
{
ViewBag.startDate = saveUtcNow.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
ViewBag.expireDate = saveUtcNow.AddHours(1).ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.StartDate = saveUtcNow.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.ExpiryDate = saveUtcNow.AddHours(1).ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
alertPresenter.IsOverrideAllowed = true;
alertPresenter.IsSoundEnable = true;
}
return this.View(CreateView, alertPresenter);
}
/// <summary>
/// Sets the passenger data.
/// </summary>
/// <param name="alertPresenter">The alert presenter.</param>
public static void SetPassengerData(AlertPresenter alertPresenter)
{
var filterPersonList = new ListResult<Person>();
if (SessionData.Instance.FilterPersonList != null)
{
foreach (var person in SessionData.Instance.FilterPersonList)
{
filterPersonList.Items.Add(person);
}
}
if (filterPersonList.Items.Count > 0)
{
if (alertPresenter != null)
{
alertPresenter.AssignPersonSearchResult(filterPersonList);
}
}
}
/// <summary>
/// Paging the specified alert presenter.
/// </summary>
/// <param name="alertPresenter">The alert presenter.</param>
/// <param name="pageNumber">The page number.</param>
/// <returns>The Action Result.</returns>
public ActionResult Paging(AlertPresenter alertPresenter, string pageNumber)
{
if (alertPresenter != null && !string.IsNullOrEmpty(pageNumber) && !pageNumber.Equals(UndefinedConstant))
{
var persons = SessionData.Instance.PersonsResult.ToList();
var pagingResult = GetPagedResult(pageNumber, persons);
if (pagingResult != null && pagingResult.Count > 0)
{
alertPresenter.AssignPagingPersonList(pagingResult);
return this.PartialView(PagingPartialView, alertPresenter);
}
}
return this.PartialView(PagingPartialView, alertPresenter);
}
/// <summary>
/// Sets up alert presenter.
/// </summary>
/// <returns>Alert Presenter</returns>
private static AlertPresenter SetUpAlertPresenter()
{
var alertPresenter = new AlertPresenter();
alertPresenter.Description = "Test template 1000";
alertPresenter.Rank = string.Empty;
alertPresenter.StartDate = "2015-05-12";
alertPresenter.ExpiryDate = "2015-05-17";
alertPresenter.AlertType = "Deny Onboard";
alertPresenter.SelectedAlertTypes = "1";
return alertPresenter;
}
/// <summary>
/// Paging the specified alert presenter.
/// </summary>
/// <param name="alertPresenter">The alert presenter.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="partialView">The partial view.</param>
/// <returns>The Action Result for Next Page.</returns>
public ActionResult Paging(AlertPresenter alertPresenter, string pageNumber, string partialView)
{
if (alertPresenter != null && !string.IsNullOrEmpty(pageNumber) && !pageNumber.Equals(UndefinedConstant))
{
if (!string.IsNullOrEmpty(partialView) && string.Equals(partialView, AlertPassengerListPartialView, StringComparison.OrdinalIgnoreCase))
{
var filterPersons = SessionData.Instance.FilterPersonList.ToList();
var pagingResult = GetPagedResult(pageNumber, filterPersons);
if (pagingResult != null && pagingResult.Count > 0)
{
var pagingListResult = new ListResult<Person>();
pagingListResult.AssignItems(pagingResult);
alertPresenter.AssignPersonSearchResult(pagingListResult);
return this.PartialView(AlertPassengerListPartialView, alertPresenter);
}
}
else
{
string partialViewScreen = AlertListPartialView;
if (!string.IsNullOrEmpty(partialView) && string.Equals(partialView, AlertTemplateListPartialView, StringComparison.OrdinalIgnoreCase))
{
partialViewScreen = partialView;
}
var alerts = SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).ToList();
var pagingResult = GetPagedResult(pageNumber, alerts);
if (pagingResult != null && pagingResult.Count > 0)
{
alertPresenter.AssignAlertSearchResult(pagingResult);
return this.PartialView(partialViewScreen, alertPresenter);
}
}
}
return this.PartialView(AlertListPartialView, alertPresenter);
}
/// <summary>
/// Created the alert list.
/// </summary>
/// <param name="alertPresenter">The alert presenter.</param>
/// <returns>created alert list</returns>
public async Task<ActionResult> CreatedAlertList(AlertPresenter alertPresenter)
{
BaseController.GetAboutUsInformation(alertPresenter);
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow).ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture);
SessionData.Instance.AlertItems.Items.Clear();
ViewBag.IsCreatedAlertList = true;
SessionData.Instance.IsCreatedAlertList = true;
var alertList = new ListResult<Alert>();
alertPresenter.TodaysAlertOnly = alertPresenter.TypeId == 0;
alertPresenter.IncludeExpired = true;
string alertId = alertPresenter.TypeId.ToString(CultureInfo.InvariantCulture);
var alertDetails = await this.alertManager.AlertTypeAsync(alertId, true, alertPresenter.TodaysAlertOnly, false, shipTime, false, shipTime);
if (alertDetails.Items.Count > 0)
{
foreach (var alert in alertDetails.Items)
{
var addedDate = Convert.ToDateTime(alert.AddedDate, CultureInfo.InvariantCulture);
alert.AddedDate = Convert.ToString(BaseController.GenerateLocalDateTime(addedDate), CultureInfo.InvariantCulture);
if (alert.Persons.Count > 0)
{
alertList.Items.Add(alert);
}
}
SessionData.Instance.AssignAlertSearchResult(alertList);
var maxPaging = DefaultPageSize > SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Count() ? SessionData.Instance.AlertItems.Items.Count() : DefaultPageSize;
var pagingResult = SessionData.Instance.AlertItems.Items.OrderByDescending(item => item.AddedDate).Skip(0).Take(maxPaging - 0).ToList();
alertPresenter.AssignAlertSearchResult(pagingResult);
}
alertPresenter.FilterAlertsType = FillAlertTypeList(alertPresenter);
return this.View(ManageView, alertPresenter);
}
/// <summary>
/// Resets the passengers.
/// </summary>
/// <param name="presenter">The alert presenter.</param>
/// <returns>
/// Reset passengers selected for alert
/// </returns>
public ActionResult ResetPassengers(AlertPresenter presenter)
{
var alertPresenter = new AlertPresenter();
if (presenter != null)
{
alertPresenter = presenter;
}
if (SessionData.Instance.FilterPersonList != null && SessionData.Instance.FilterPersonList.Count > 0)
{
alertPresenter.PersonItemListResult.Items.Clear();
SessionData.Instance.FilterPersonList.Clear();
SessionData.Instance.SelectedPassengerIds.Clear();
SessionData.Instance.SelectedPersonIds.Clear();
}
return this.PartialView(AlertPassengerListPartialView, alertPresenter);
}
public JsonResult AlertDeletePassenger(AlertPresenter alertPresenter, string passengerId, string alertType)
{
if (!string.IsNullOrEmpty(passengerId))
{
if (alertPresenter != null && !string.IsNullOrEmpty(alertType))
{
if (alertType.Equals(SetData))
{
var alertData = new Alert
{
Description = alertPresenter.Description,
TypeId = Convert.ToInt32(alertPresenter.SelectedAlertTypes, CultureInfo.InvariantCulture),
StartDate = Convert.ToDateTime(alertPresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = Convert.ToDateTime(alertPresenter.ExpiryDate, CultureInfo.InvariantCulture),
IsOverride = alertPresenter.IsOverrideAllowed,
IsSoundEnable = alertPresenter.IsSoundEnable,
AlertType = alertPresenter.AlertType,
IsTemplate = alertPresenter.IsTemplate,
TemplateName = alertPresenter.Description,
CrewDepartmentId = alertPresenter.SelectedCrewDepartment
};
SessionData.Instance.AssignAlertData(alertData);
}
}
if (SessionData.Instance.FilterPersonList != null && SessionData.Instance.FilterPersonList.Count > 0)
{
for (int count = 0; count < SessionData.Instance.FilterPersonList.Count; count++)
{
if (passengerId == SessionData.Instance.FilterPersonList[count].PersonId)
{
SessionData.Instance.FilterPersonList.RemoveAt(count);
}
}
}
if (SessionData.Instance.GlobalAlertPersonList != null && SessionData.Instance.GlobalAlertPersonList.Count > 0)
{
for (int count = 0; count < SessionData.Instance.GlobalAlertPersonList.Count; count++)
{
if (passengerId == SessionData.Instance.GlobalAlertPersonList[count].PersonId)
{
SessionData.Instance.GlobalAlertPersonList.RemoveAt(count);
}
}
}
SessionData.Instance.SelectedPersonIds.Remove(passengerId);
}
return this.Json(true);
}
/// <summary>
/// Fills the alert type list.
/// </summary>
/// <param name="presenter">The presenter.</param>
/// <returns>List of alert types</returns>
private static IList<AlertType> FillAlertTypeList(AlertPresenter presenter)
{
var alerts = new List<AlertType>();
if (!presenter.IsTemplate)
{
alerts.Add(new AlertType { AlertTypeId = 0, Name = TodaysAlertsConstant });
}
if (presenter.AlertTypes != null)
{
foreach (var alert in presenter.AlertTypes)
{
alerts.Add(alert);
}
}
return alerts;
}
public async Task AlertPassengerSearchTest()
{
try
{
SessionData.Instance.User = CommonHelper.SetupUserData();
ListResult<Person> persons = SetUpPersonData();
var alertPresenter = new AlertPresenter();
alertPresenter.SearchText = "Oliver";
this.personManager.Setup(mockItem => mockItem.GetPersonsAsync(It.IsNotNull<SearchFilters>(), It.IsAny<string>())).Returns(Task.FromResult(persons));
var searchResult = await this.alertController.AlertPassengerSearch(alertPresenter);
Assert.IsTrue(true);
searchResult = await this.alertController.AlertPassengerSearch(new AlertPresenter());
Assert.IsTrue(true);
}
finally
{
this.Dispose();
}
}
