public MessageConsoleView()
{
InitializeComponent();
_currentMessages = new List <LogMessage>();
DataContext = _currentMessages;
EventAggregator.Get <MessageArrivedEvent <LogMessage>, LogMessage>()
.Subscribe(MessagePosted);
Presenter = new MessagePresenter(this);
}
public void SetMessage(MessagePresenter message, double timeoutInMs = 5000)
{
MessageTimer.Stop();
message.IsVisible = true;
MessageControl.DataContext = message;
MessageTimer.Interval = timeoutInMs;
MessageTimer.Elapsed +=
(sender, args) =>
{
Application.Current.Dispatcher.BeginInvoke(new Action(() => message.IsVisible = false));
};
MessageTimer.Start();
}
private void InstantiateMessage(Message message)
{
MessagePresenter messagePresenter = Instantiate(messagePrefabByType[message.Type], messageContainer);
messagePresenter.SetMessage(message.Emoji, message.Author);
messageScroller.verticalNormalizedPosition = 0; // scrolls to bottom
if (message.Type == MessageType.Player)
{
OnPlayerMessageSent.Invoke();
}
else
{
OnPizzaMessageSent.Invoke();
}
}
private void SetupNetworkConnection()
{
// Setup Access Endpoint
var url = "ec2-52-90-46-132.compute-1.amazonaws.com";
// Debug
//var url = "localhost:51216/";
var httpEndPoint = $@"http://{url}";
//var httpEndPoint = "http://*****:*****@"ws://{url}/Websocket/WsChatHandler.ashx";
var sessionEventEndpoint = $@"ws://{url}/Websocket/WsSessionEventHandler.ashx";
var connexionEndpoint = $@"ws://{url}/Websocket/WsConnexionHandler.ashx";
// Websocket endpoint
WebsocketChatAccess.Instance = new WebsocketChatAccess(chatEndpoint);
SessionEventWebsocketAccess.Initialize(sessionEventEndpoint);
ConnexionWebsocketAccess.Instance = new ConnexionWebsocketAccess(connexionEndpoint);
// Http endpoint
UserAccess.Instance = new UserAccess(httpEndPoint);
ProfileAccess.Instance = new ProfileAccess(httpEndPoint);
FriendAccess.Instance = new FriendAccess(httpEndPoint);
GameAccess.Instance = new GameAccess(httpEndPoint);
PingAccess.Instance = new PingAccess(httpEndPoint);
LeaderboardAccess.Instance = new LeaderboardAccess(httpEndPoint);
ZoneAccess.Instance = new ZoneAccess(httpEndPoint);
DailyAccess.Instance = new DailyAccess(httpEndPoint);
// Setup Chat
Chatmenu = new ChatMenu();
ChatPanel.Content = Chatmenu;
ChatPanel.Visibility = Visibility.Hidden;
// Setup Achievement panel
Achievement = new AchievementPanel();
AchievementPanel.Content = Achievement;
Achievement.HideAchievement();
// Setup Message Panel
var defaultMessage = new MessagePresenter();
SetMessage(defaultMessage);
defaultMessage.IsVisible = false;
}
public void ResetMessagePassengersTest()
{
try
{
SessionData.Instance.User = CommonHelper.SetupUserData();
var messagePresenter = new MessagePresenter();
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);
messagePresenter.AssignPersonSearchResult(personList);
foreach (var person in alertDetailResult.Persons)
{
SessionData.Instance.SelectedPersonIds.Add(person.PersonId);
}
SessionData.Instance.AssignFilterPersonResult(alertDetailResult.Persons);
}
this.messageController.ResetPassengers(new MessagePresenter());
Assert.IsTrue(true);
}
finally
{
this.Dispose();
}
}
/// <summary>
/// Messages 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="isCreatedMessage">The is created message.</param>
/// <returns>
/// The View for Action Result
/// </returns>
public async Task<ActionResult> MessageType(string alertTypeId, string isExpiredAlert, string todaysAlert, string isCreatedMessage)
{
var messagePresenter = new MessagePresenter();
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow).ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture);
var addedDateParameter = string.Empty;
var messageList = new ListResult<Alert>();
if (isCreatedMessage.Equals(TrueConstant, StringComparison.InvariantCultureIgnoreCase))
{
addedDateParameter = shipTime;
}
var alertDetails = await this.alertManager.AlertTypeAsync(alertTypeId, Convert.ToBoolean(isExpiredAlert, CultureInfo.InvariantCulture), Convert.ToBoolean(todaysAlert, CultureInfo.InvariantCulture), true, 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)
{
messageList.Items.Add(alert);
}
}
if (Convert.ToBoolean(isExpiredAlert))
{
var filterPersonCountResult = alertDetails.Items.Where(alerts => alerts.PersonCount > 0).ToList();
var filteredPersonCountAlerts = new ListResult<Alert>();
filteredPersonCountAlerts.AssignItems(filterPersonCountResult);
SessionData.Instance.AssignAlertSearchResult(filteredPersonCountAlerts);
}
else
{
SessionData.Instance.AssignAlertSearchResult(messageList);
}
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();
messagePresenter.AssignAlertSearchResult(pagingResult);
return this.PartialView(MessageListPartialView, messagePresenter);
}
/// <summary>
/// Manages the message template.
/// </summary>
/// <param name="messagePresenter">The message presenter.</param>
/// <returns>The Message Template Page.</returns>
public async Task<ActionResult> ManageMessageTemplate(MessagePresenter messagePresenter)
{
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow);
var alertDetails = await this.alertManager.AlertTypeAsync(string.Empty, false, false, true, 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();
messagePresenter.AssignAlertSearchResult(pagingResult);
}
BaseController.GetAboutUsInformation(messagePresenter);
return this.View(MessageTemplateView, messagePresenter);
}
/// <summary>
/// Sets up message presenter.
/// </summary>
/// <returns>Message Presenter</returns>
private static MessagePresenter SetUpMessagePresenter()
{
var messagePresenter = new MessagePresenter();
messagePresenter.Description = "Test template 1000";
messagePresenter.Rank = string.Empty;
messagePresenter.StartDate = "2015-05-12";
messagePresenter.ExpiryDate = "2015-05-17";
messagePresenter.AlertType = "Deny Onboard";
messagePresenter.SelectedAlertTypes = "1";
return messagePresenter;
}
/// <summary>
/// Paging the specified message presenter.
/// </summary>
/// <param name="messagePresenter">The message presenter.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="partialView">The partial view.</param>
/// <returns>
/// The View for Action Result
/// </returns>
public ActionResult Paging(MessagePresenter messagePresenter, string pageNumber, string partialView)
{
if (messagePresenter != null && !string.IsNullOrEmpty(pageNumber) && !pageNumber.Equals(UndefinedConstant))
{
if (!string.IsNullOrEmpty(partialView) && string.Equals(partialView, MessagePassengerListPartialView, 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);
messagePresenter.AssignPersonSearchResult(pagingListResult);
return this.PartialView(MessagePassengerListPartialView, messagePresenter);
}
}
else
{
string partialViewScreen = MessageListPartialView;
if (!string.IsNullOrEmpty(partialView) && string.Equals(partialView, MessageTemplateListPartialView, 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)
{
messagePresenter.AssignAlertSearchResult(pagingResult);
return this.PartialView(partialViewScreen, messagePresenter);
}
}
}
return this.PartialView(MessageListPartialView, messagePresenter);
}
/// <summary>
/// Resets the passengers.
/// </summary>
/// <param name="presenter">The alert presenter.</param>
/// <returns>Reset passengers selected for alert</returns>
public ActionResult ResetPassengers(MessagePresenter presenter)
{
var messagePresenter = new MessagePresenter();
if (presenter != null)
{
messagePresenter = presenter;
}
if (SessionData.Instance.FilterPersonList != null && SessionData.Instance.FilterPersonList.Count > 0)
{
messagePresenter.PersonItemListResult.Items.Clear();
SessionData.Instance.FilterPersonList.Clear();
SessionData.Instance.SelectedPassengerIds.Clear();
SessionData.Instance.SelectedPersonIds.Clear();
}
return this.PartialView(MessagePassengerListPartialView, messagePresenter);
}
/// <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> MessageAutoCompleteSuggestions(string searchText, string searchType, bool isAutoComplete)
{
if (!string.IsNullOrEmpty(searchText))
{
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;
}
else
{
searchFilter.LastNameContains = searchText;
}
searchFilter.IsAutoComplete = isAutoComplete;
var presenter = new MessagePresenter();
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);
}
/// <summary>
/// Adds the passenger.
/// </summary>
/// <param name="presenter">The message presenter.</param>
/// <param name="personId">The person ids.</param>
/// <returns>
/// The JSON Result
/// </returns>
public ActionResult MessageAddPassenger(MessagePresenter presenter, string personId)
{
var messagePresenter = new MessagePresenter();
if (presenter != null)
{
messagePresenter = 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);
messagePresenter.AssignPersonSearchResult(personSearchResult);
SessionData.Instance.AssignFilterPersonResult(filteredPersonList);
}
return this.PartialView(MessagePassengerListPartialView, messagePresenter);
}
return this.View();
}
public async Task AlertPassengerSearchTest()
{
try
{
SessionData.Instance.User = CommonHelper.SetupUserData();
ListResult<Person> persons = SetUpPersonData();
var messagePresenter = new MessagePresenter { SearchText = "Oliver" };
this.personManager.Setup(mockItem => mockItem.GetPersonsAsync(It.IsNotNull<SearchFilters>(), It.IsAny<string>())).Returns(Task.FromResult(persons));
var task = this.messageController.AlertPassengerSearch(messagePresenter);
await task;
Assert.IsTrue(true);
}
finally
{
this.Dispose();
}
}
public async Task<ActionResult> AlertPassengerSearch(MessagePresenter messagePresenter)
{
if (messagePresenter != null && !string.IsNullOrEmpty(messagePresenter.SearchText))
{
ModelState.Clear();
var searchFilter = new SearchFilters { LastNameContains = messagePresenter.SearchText, IsAlertCount = false, IsMessageCount = false };
var persons = await this.personManager.GetPersonsAsync(searchFilter, messagePresenter.AuthenticationToken);
messagePresenter.AssignPersonSearchResult(persons);
SessionData.Instance.AssignPersonSearchResult(persons.Items.ToList());
return this.PartialView(MessagePassengerListPartialView, messagePresenter);
}
return this.View();
}
public JsonResult MessageDeletePassenger(MessagePresenter messagePresenter, string passengerId, string alertType)
{
if (!string.IsNullOrEmpty(passengerId))
{
if (messagePresenter != null && !string.IsNullOrEmpty(alertType))
{
if (alertType.Equals(SetData))
{
var alertData = new Alert
{
Description = messagePresenter.Description,
TypeId = Convert.ToInt32(messagePresenter.SelectedAlertTypes, CultureInfo.InvariantCulture),
StartDate = Convert.ToDateTime(messagePresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = Convert.ToDateTime(messagePresenter.ExpiryDate, CultureInfo.InvariantCulture),
AlertType = messagePresenter.AlertType,
MessageFrom = messagePresenter.MessageFrom,
IsMessage = true,
IsTemplate = messagePresenter.IsTemplate,
TemplateName = messagePresenter.Description,
IsSoundEnable = messagePresenter.IsSoundEnable
};
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.GlobalMessagePersonList != null && SessionData.Instance.GlobalMessagePersonList.Count > 0)
{
for (int count = 0; count < SessionData.Instance.GlobalMessagePersonList.Count; count++)
{
if (passengerId == SessionData.Instance.GlobalMessagePersonList[count].PersonId)
{
SessionData.Instance.GlobalMessagePersonList.RemoveAt(count);
}
}
}
SessionData.Instance.SelectedPersonIds.Remove(passengerId);
}
return this.Json(true);
}
/// <summary>
/// Created the message list.
/// </summary>
/// <param name="messagePresenter">The message presenter.</param>
/// <returns>created message list</returns>
public async Task<ActionResult> CreatedMessageList(MessagePresenter messagePresenter)
{
SessionData.Instance.IsMessageMode = TrueConstantValue;
var shipTime = BaseController.GenerateLocalDateTime(DateTime.UtcNow).ToString(this.ApplicationSettings.ShipDateTimeFormat, CultureInfo.InvariantCulture);
ViewBag.IsCreatedMessageList = true;
SessionData.Instance.IsCreatedMessageList = true;
SessionData.Instance.AlertItems.Items.Clear();
var messageList = new ListResult<Alert>();
messagePresenter.IncludeExpired = true;
var alertDetails = await this.alertManager.AlertTypeAsync(string.Empty, true, false, true, shipTime, false, shipTime);
if (alertDetails != null)
{
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)
{
messageList.Items.Add(alert);
}
}
SessionData.Instance.AssignAlertSearchResult(messageList);
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();
messagePresenter.AssignAlertSearchResult(pagingResult);
}
BaseController.GetAboutUsInformation(messagePresenter);
return this.View(ManageView, messagePresenter);
}
public async Task<ActionResult> CreateMessage(MessagePresenter messagePresenter, string alertType, string type)
{
if (messagePresenter != null)
{
var personData = new PersonCollection();
if (alertType.Equals(SetData, StringComparison.InvariantCultureIgnoreCase))
{
var alertData = new Alert
{
Description = messagePresenter.Description,
TypeId = Convert.ToInt32(messagePresenter.SelectedAlertTypes),
StartDate = Convert.ToDateTime(messagePresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = Convert.ToDateTime(messagePresenter.ExpiryDate, CultureInfo.InvariantCulture),
AlertType = messagePresenter.AlertType,
MessageFrom = messagePresenter.MessageFrom,
IsMessage = true,
IsTemplate = messagePresenter.IsTemplate,
TemplateName = messagePresenter.Description,
IsSoundEnable = messagePresenter.IsSoundEnable
};
SessionData.Instance.AssignAlertData(alertData);
return this.Json(true);
}
SessionData.Instance.TypeId = type;
var alert = new Alert
{
Description = messagePresenter.Description,
StartDate = Convert.ToDateTime(messagePresenter.StartDate, CultureInfo.InvariantCulture),
ExpiryDate = !string.IsNullOrEmpty(messagePresenter.ExpiryDate) ? Convert.ToDateTime(messagePresenter.ExpiryDate, CultureInfo.InvariantCulture) : default(DateTime?),
AlertType = messagePresenter.AlertType,
UserName = !string.IsNullOrWhiteSpace(SessionData.Instance.User.FirstName) ? SessionData.Instance.User.LastName + Comma + SessionData.Instance.User.FirstName : SessionData.Instance.User.LastName,
MessageFrom = messagePresenter.MessageFrom,
IsMessage = true,
IsTemplate = messagePresenter.IsTemplate,
TemplateName = messagePresenter.Description,
IsSoundEnable = messagePresenter.IsSoundEnable
};
SessionData.Instance.TypeId = type;
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;
if (alertType.Equals(Update, StringComparison.InvariantCultureIgnoreCase))
{
await this.alertManager.UpdateAlertAsync(alert, SessionData.Instance.ActiveAlertId);
}
else
{
await this.alertManager.CreateAlertAsync(alert);
}
if (SessionData.Instance.FilterPersonList != null)
{
SessionData.Instance.PassengerSearchItems.Items.Clear();
SessionData.Instance.FilterPersonList.Clear();
SessionData.Instance.ActiveAlertId = string.Empty;
SessionData.Instance.SelectedPersonIds.Clear();
SessionData.Instance.AlertData = null;
return this.Json(true);
}
}
return this.Json(false);
}
/// <summary>
/// Creates the message.
/// </summary>
/// <param name="alertId">The alert identifier.</param>
/// <param name="isTemplate">The is template.</param>
/// <param name="type">The type.</param>
/// <returns>
/// The Message View for Action Result
/// </returns>
public async Task<ActionResult> CreateMessage(string alertId, string isTemplate, string type)
{
var messagePresenter = new MessagePresenter();
messagePresenter.IsTemplate = string.IsNullOrEmpty(isTemplate) ? SessionData.Instance.AlertData != null && SessionData.Instance.AlertData.IsTemplate : Convert.ToBoolean(isTemplate, CultureInfo.InvariantCulture);
BaseController.GetAboutUsInformation(messagePresenter);
var saveUtcNow = BaseController.GenerateLocalDateTime(DateTime.UtcNow);
SessionData.Instance.IsMessageMode = TrueConstantValue;
if (!string.IsNullOrEmpty(alertId))
{
var alertDetailResult = await this.alertManager.GetAlertDetailsById(alertId, type);
messagePresenter.UserName = alertDetailResult.UserName;
messagePresenter.StartDate = alertDetailResult.StartDate.ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
messagePresenter.ExpiryDate = alertDetailResult.ExpiryDate.HasValue ? alertDetailResult.ExpiryDate.Value.ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : string.Empty;
ViewBag.startDate = messagePresenter.IsTemplate ? saveUtcNow.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : alertDetailResult.StartDate.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
ViewBag.expireDate = messagePresenter.IsTemplate ? saveUtcNow.AddHours(1).ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : alertDetailResult.ExpiryDate.HasValue ? alertDetailResult.ExpiryDate.Value.ToString(this.ApplicationSettings.DateFormat, CultureInfo.InvariantCulture) : string.Empty;
messagePresenter.PersonCount = alertDetailResult.PersonCount;
messagePresenter.MessageFrom = alertDetailResult.MessageFrom;
messagePresenter.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);
messagePresenter.AssignPersonSearchResult(personList);
foreach (var person in alertDetailResult.Persons)
{
SessionData.Instance.SelectedPersonIds.Add(person.PersonId);
}
SessionData.Instance.AssignFilterPersonResult(alertDetailResult.Persons);
}
}
if (SessionData.Instance.GlobalMessagePersonList != null && SessionData.Instance.GlobalMessagePersonList.Count > 0)
{
foreach (var person in SessionData.Instance.GlobalMessagePersonList)
{
if (!SessionData.Instance.FilterPersonList.Any(p => p.PersonId == person.PersonId))
{
SessionData.Instance.AssignGlobalPersonResult(person);
}
}
SetPassengerData(messagePresenter);
}
if (SessionData.Instance.SelectedPersonIds != null && SessionData.Instance.SelectedPersonIds.Count > 0 && string.IsNullOrEmpty(isTemplate))
{
SetPassengerData(messagePresenter);
}
if (SessionData.Instance.AlertData != null)
{
messagePresenter.AlertType = SessionData.Instance.AlertData.AlertType;
messagePresenter.Description = SessionData.Instance.AlertData.Description;
messagePresenter.StartDate = SessionData.Instance.AlertData.StartDate.ToString(CultureInfo.InvariantCulture);
messagePresenter.ExpiryDate = SessionData.Instance.AlertData.ExpiryDate.HasValue ? SessionData.Instance.AlertData.ExpiryDate.Value.ToString(CultureInfo.InvariantCulture) : string.Empty;
messagePresenter.MessageFrom = SessionData.Instance.AlertData.MessageFrom;
messagePresenter.IsSoundEnable = SessionData.Instance.AlertData.IsSoundEnable;
ViewBag.startDate = messagePresenter.StartDate;
ViewBag.expireDate = messagePresenter.ExpiryDate;
}
else if (string.IsNullOrEmpty(alertId))
{
ViewBag.startDate = saveUtcNow.ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
ViewBag.expireDate = saveUtcNow.AddHours(1).ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
messagePresenter.IsSoundEnable = false;
messagePresenter.StartDate = saveUtcNow.ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
messagePresenter.ExpiryDate = saveUtcNow.AddHours(1).ToString(ApplicationSettings.DateFormat, CultureInfo.InvariantCulture);
messagePresenter.IsSoundEnable = true;
}
return this.View(CreateView, messagePresenter);
}
/// <summary>
/// Sets the passenger data.
/// </summary>
/// <param name="messagePresenter">The message presenter.</param>
public static void SetPassengerData(MessagePresenter messagePresenter)
{
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 (messagePresenter != null)
{
messagePresenter.AssignPersonSearchResult(filterPersonList);
}
}
}
