public void AlertSubscribers(NotificationEventType notificationType, long senderIndex)
{
_LogHelper.Log("FDS32432KJ", $"Start. Notification type {notificationType.ToString()} Sender index: {senderIndex}", LogLevel.Information, true);
if (notificationType == NotificationEventType.OrderChange)
{
for (int i = QueueList.Count - 1; i > senderIndex; i--)
{
if (i != 0)
{
string notificationText = _localizationHelper.GetLocalizedString(StringToLocalize.OrderChangeAlert)
.Replace("[QUEUEPOS]", i.ToString())
.Replace("[WAITTIME]", GetTimeToWait(QueueList[i].ChatId).ToString());
AlertSubscriber(QueueList[i].ChatId, notificationText);
}
}
}
else
{
for (int i = QueueList.Count - 1; i > senderIndex; i--)
{
string notificationText = _localizationHelper.GetLocalizedString(StringToLocalize.TimeChangeAlert)
.Replace("[WAITTIME]", GetTimeToWait(QueueList[i].ChatId).ToString());
AlertSubscriber(QueueList[i].ChatId, notificationText);
}
}
}
public NotificationSubscription CreateSubscriptionForTeam()
{
NotificationSubscription newSubscription;
WebApiTeamRef team = ClientSampleHelpers.FindAnyTeam(this.Context, null);
NotificationHttpClient notificationClient = Context.Connection.GetClient <NotificationHttpClient>();
// Query the available event types and find the first that can be used in a custom subscription
List <NotificationEventType> eventTypes = notificationClient.ListEventTypesAsync().Result;
NotificationEventType eventType = eventTypes.Find(e => { return(e.CustomSubscriptionsAllowed); });
NotificationSubscriptionCreateParameters createParams = new NotificationSubscriptionCreateParameters()
{
Description = "A subscription for our team",
Filter = new ExpressionFilter(eventType.Id),
Channel = new UserSubscriptionChannel(),
Subscriber = new IdentityRef()
{
Id = team.Id.ToString()
}
};
newSubscription = notificationClient.CreateSubscriptionAsync(createParams).Result;
LogSubscription(newSubscription);
return(newSubscription);
}
/// <summary>
/// Reset alert collection for Guest
/// </summary>
/// <param name="message">The message.</param>
/// <param name="eventType">Instance of NotificationEventType</param>
public static void RetrievePerson(NotificationEvent message, NotificationEventType eventType)
{
List<PersonType> personTypeList = new List<PersonType>();
if (message != null && message.PersonTypeId == CommonConstants.GuestTypeId)
{
personTypeList.Add(PersonType.Guest);
}
else if (message != null && message.PersonTypeId == CommonConstants.CrewmemberTypeId)
{
personTypeList.Add(PersonType.Crewmember);
}
else if (message != null && message.PersonTypeId == CommonConstants.VisitorTypeId)
{
personTypeList.Add(PersonType.Visitor);
}
if (eventType == NotificationEventType.Reservation)
{
RetrieveGuestForReservation(message, eventType, personTypeList);
}
else
{
RetrieveGuest(message, eventType, personTypeList);
}
}
public async Task <NotificationTemplateModel> GetNotificationTemplate(NotificationEventType eventType)
{
var result = await dbContext.NotificationTemplates.FirstOrDefaultAsync(x => x.EventType == eventType);
if (result != null)
{
return(mapper.Map <NotificationTemplateModel>(result));
}
return(null);
}
public void Notify(NotificationPriority priority, NotificationEventType eventType, string logMessage)
{
switch (eventType)
{
case NotificationEventType.FileSystem:
SystemSounds.Asterisk.Play();
break;
case NotificationEventType.Update:
SystemSounds.Hand.Play();
break;
case NotificationEventType.Error:
SystemSounds.Exclamation.Play();
break;
}
}
public NotificationSubscription CreateSubscriptionForUser()
{
NotificationHttpClient notificationClient = Context.Connection.GetClient <NotificationHttpClient>();
// Query the available event types and find the first that can be used in a custom subscription
List <NotificationEventType> eventTypes = notificationClient.ListEventTypesAsync().Result;
NotificationEventType eventType = eventTypes.Find(e => { return(e.CustomSubscriptionsAllowed); });
NotificationSubscriptionCreateParameters createParams = new NotificationSubscriptionCreateParameters()
{
Description = "My first subscription!",
Filter = new ExpressionFilter(eventType.Id),
Channel = new UserSubscriptionChannel()
};
NotificationSubscription newSubscription = notificationClient.CreateSubscriptionAsync(createParams).Result;
LogSubscription(newSubscription);
return(newSubscription);
}
public void Notify(NotificationPriority priority, NotificationEventType eventType, string logMessage)
{
const int scaleInterval = 131;
var duration = priority switch
{
NotificationPriority.High => 500,
NotificationPriority.Medium => 200,
NotificationPriority.Low => 0,
_ => 0,
};
var frequency = eventType switch
{
NotificationEventType.Error => scaleInterval * 1,
NotificationEventType.FileSystem => scaleInterval * 2,
NotificationEventType.JournalEntry => scaleInterval * 3,
NotificationEventType.Update => scaleInterval * 5,
_ => 0,
};
if (frequency > 0 && duration > 0)
{
System.Console.Beep(frequency, duration);
}
}
/// <summary>
/// Retrieves the guest.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="eventType">Type of the event.</param>
/// <param name="personTypeList">The person type list.</param>
private static void RetrieveGuest(NotificationEvent message, NotificationEventType eventType, List<PersonType> personTypeList)
{
Workstation workStation = DIContainer.Instance.Resolve<Workstation>();
var task = Task.Run(async () => await PersonsService.RetrievePersonsBySearchText(workStation.Ship.ShipId, null, personTypeList, SearchType.PersonId, personId: message.PersonId, folioNumber: null));
task.Wait();
if (!task.IsCanceled && !task.IsFaulted)
{
var personData = task.Result;
var personsPartyManager = DIContainer.Instance.Resolve<PersonsPartyManager>();
if (personsPartyManager.CurrentParty != null)
{
ApplicationDispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)(() => UpdateSelectedPerson(message, personData, personTypeList, personsPartyManager, eventType)));
}
}
}
/// <summary>
/// Function to find out whether is there need for search.
/// </summary>
/// <param name="message">Instance of NotificationEvent</param>
/// <param name="eventType">NotificationEventType enumeration</param>
/// <returns>True or false</returns>
public static bool IsNeedForSearch(NotificationEvent message, NotificationEventType eventType)
{
var personsPartyManager = DIContainer.Instance.Resolve<PersonsPartyManager>();
bool isNeedForSearch = false;
PersonType personType = PersonType.Guest;
if (message != null && message.PersonTypeId == CommonConstants.GuestTypeId)
{
personType = PersonType.Guest;
}
else if (message != null && message.PersonTypeId == CommonConstants.CrewmemberTypeId)
{
personType = PersonType.Crewmember;
}
else if (message != null && message.PersonTypeId == CommonConstants.VisitorTypeId)
{
personType = PersonType.Visitor;
}
if (eventType == NotificationEventType.Reservation)
{
isNeedForSearch = personsPartyManager.CurrentParty.Guests.Any(g => g.CruiseDetail.ReservationNumber.Equals(message.ReservationNumber, StringComparison.OrdinalIgnoreCase));
}
else
{
if (personType == PersonType.Guest)
{
isNeedForSearch = personsPartyManager.CurrentParty.Guests.Any(g => g.GuestId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
}
else if (personType == PersonType.Crewmember)
{
isNeedForSearch = personsPartyManager.CurrentParty.Crew.Any(c => c.CrewmemberId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
}
else if (personType == PersonType.Visitor)
{
isNeedForSearch = personsPartyManager.CurrentParty.Visitors.Any(v => v.VisitorId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
}
}
return isNeedForSearch;
}
/// <summary>
/// Retrieves the guest.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="personData">The person data.</param>
/// <param name="workStation">The work station.</param>
/// <param name="eventType">Type of the event.</param>
/// <param name="personTypeList">The person type list.</param>
/// <param name="personList">The person list.</param>
private static void RetrieveGuestForReservation(NotificationEvent message, Person personData, Workstation workStation, NotificationEventType eventType, List<PersonType> personTypeList, IList<PersonBase> personList)
{
var task = Task.Run(async () => await PersonsService.RetrievePersonsBySearchText(workStation.Ship.ShipId, message.ReservationNumber, personTypeList, SearchType.Reservation, null, null, null, 0, null, folioNumber: null));
task.Wait();
if (!task.IsCanceled && !task.IsFaulted)
{
personData = task.Result;
if (personData != null)
{
personData.Guests.Iterate(g =>
{
var person = personList.FirstOrDefault(p => p.PersonId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
if (person != null)
{
MapPersonData(person, g.MapToPersonBase(), eventType);
RetrievePhoto(person);
}
});
}
}
}
/// <summary>
/// Maps the visitor data.
/// </summary>
/// <param name="visitor">The visitor.</param>
/// <param name="persons">The persons.</param>
/// <param name="eventType">Type of the event.</param>
private static void MapVisitorData(Visitor visitor, Person persons, NotificationEventType eventType)
{
var selectedPerson = RetrieveSelectedPerson();
Visitor retrievedVisitor = persons.Visitors.FirstOrDefault();
if (visitor != null)
{
if (eventType == NotificationEventType.PersonData)
{
visitor.PersonalDetail.FirstName = retrievedVisitor.PersonalDetail.FirstName;
visitor.PersonalDetail.LastName = retrievedVisitor.PersonalDetail.LastName;
visitor.PersonalDetail.Gender = retrievedVisitor.PersonalDetail.Gender;
visitor.PersonalDetail.Age = retrievedVisitor.PersonalDetail.Age;
visitor.PersonalDetail.Birthdate = retrievedVisitor.PersonalDetail.Birthdate;
visitor.SecurityPhotoAddress = retrievedVisitor.SecurityPhotoAddress;
visitor.PersonalDetail.Country = RetriveCountry(retrievedVisitor.PersonalDetail);
if (visitor.PersonalDetail.Country != null)
{
visitor.PersonalDetail.Country.Name = retrievedVisitor.PersonalDetail.Country.Name;
}
visitor.PersonalDetail.DocumentType = retrievedVisitor.PersonalDetail.DocumentType;
visitor.PersonalDetail.DocumentNumber = retrievedVisitor.PersonalDetail.DocumentNumber;
visitor.PersonalDetail.Title = retrievedVisitor.PersonalDetail.Title;
visitor.PersonalDetail.DepartmentPOC = retrievedVisitor.PersonalDetail.DepartmentPOC;
visitor.VisitorType = retrievedVisitor.VisitorType;
if (visitor.VisitorInfo == null)
{
visitor.VisitorInfo = new VisitorInfo();
}
visitor.VisitorInfo.VisitPurpose = retrievedVisitor.VisitorInfo.VisitPurpose;
visitor.AssignVisitorAccessCard(retrievedVisitor.VisitorAccessCards);
visitor.VisitorInfo.CompanyName = retrievedVisitor.VisitorInfo.CompanyName;
visitor.PersonalDetail.DepartmentName = retrievedVisitor.PersonalDetail.DepartmentName;
visitor.VisitorInfo.ContactNumber = retrievedVisitor.VisitorInfo.ContactNumber;
visitor.VisitorInfo.CompanyContactNumber = retrievedVisitor.VisitorInfo.CompanyContactNumber;
}
else if (eventType == NotificationEventType.BoardingStatus)
{
visitor.IsOnboard = retrievedVisitor.IsOnboard;
visitor.LastEvent = retrievedVisitor.LastEvent;
visitor.LastDateTime = retrievedVisitor.LastDateTime;
if (visitor.VisitorId.Equals(selectedPerson.PersonId, StringComparison.OrdinalIgnoreCase))
{
selectedPerson.IsOnboard = retrievedVisitor.IsOnboard;
selectedPerson.LastEvent = retrievedVisitor.LastEvent;
selectedPerson.LastDateTime = retrievedVisitor.LastDateTime;
}
}
else if (eventType == NotificationEventType.Alert)
{
visitor.HasAlert = retrievedVisitor.HasAlert;
visitor.AssignAlerts(retrievedVisitor.Alerts);
selectedPerson.HasAlert = retrievedVisitor.HasAlert;
selectedPerson.AssignAlerts(retrievedVisitor.Alerts);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonAlert, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyAlertDetails, selectedPerson);
}
else if (eventType == NotificationEventType.Message)
{
var messageAcknowledge = retrievedVisitor.Messages.All(m => m.StatusId.Equals(CommonConstants.MessageAcknowledgeStatusId));
visitor.AreAllMessagesGotAcknowledged = messageAcknowledge;
visitor.AssignMessages(retrievedVisitor.Messages);
selectedPerson.AreAllMessagesGotAcknowledged = messageAcknowledge;
selectedPerson.AssignPersonMessages(retrievedVisitor.Messages);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonMessage, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyMessageDetails, selectedPerson);
}
}
}
/// <summary>
/// Retrieves the guest.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="personData">The person data.</param>
/// <param name="workStation">The work station.</param>
/// <param name="eventType">Type of the event.</param>
/// <param name="personTypeList">The person type list.</param>
/// <param name="personList">The person list.</param>
/// <returns>
/// The person
/// </returns>
private static Person RetrievePerson(NotificationEvent message, Person personData, Workstation workStation, NotificationEventType eventType, List<PersonType> personTypeList, IList<PersonBase> personList)
{
var person = personList.Where(p => p.PersonId == message.PersonId).FirstOrDefault();
var task = Task.Run(async () => await PersonsService.RetrievePersonsBySearchText(workStation.Ship.ShipId, null, personTypeList, SearchType.PersonId, personId: message.PersonId, folioNumber: null));
task.Wait();
if (!task.IsCanceled && !task.IsFaulted)
{
personData = task.Result;
PersonBase retrievedPerson = null;
if (personTypeList.FirstOrDefault() == PersonType.Guest)
{
retrievedPerson = personData.Guests.FirstOrDefault().MapToPersonBase();
}
else if (personTypeList.FirstOrDefault() == PersonType.Crewmember)
{
retrievedPerson = personData.Crewmembers.FirstOrDefault().MapToPersonBase();
}
else if (personTypeList.FirstOrDefault() == PersonType.Visitor)
{
retrievedPerson = personData.Visitors.FirstOrDefault().MapToPersonBase();
}
if (personData != null)
{
MapPersonData(person, retrievedPerson, eventType);
if (person != null)
{
RetrievePhoto(person);
}
}
}
return personData;
}
/// <summary>
/// Maps the guest data.
/// </summary>
/// <param name="guest">The guest.</param>
/// <param name="retrievedGuest">The retrieved guest.</param>
/// <param name="eventType">Type of the event.</param>
private static void MapGuestData(Guest guest, Guest retrievedGuest, NotificationEventType eventType)
{
if (guest != null)
{
if (eventType == NotificationEventType.PersonData)
{
MapGuestPersonalDetails(guest, retrievedGuest);
}
else if (eventType == NotificationEventType.Reservation)
{
MapGuestPersonalDetails(guest, retrievedGuest);
MapGuestBoardingStatusData(guest, retrievedGuest);
MapGuestAlerts(guest, retrievedGuest);
MapGuestMessages(guest, retrievedGuest);
}
else if (eventType == NotificationEventType.BoardingStatus)
{
MapGuestBoardingStatusData(guest, retrievedGuest);
}
else if (eventType == NotificationEventType.Alert)
{
MapGuestAlerts(guest, retrievedGuest);
}
else if (eventType == NotificationEventType.Message)
{
MapGuestMessages(guest, retrievedGuest);
}
}
}
/// <summary>
/// Retrieves the guest.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="eventType">Type of the event.</param>
/// <param name="personTypeList">The person type list.</param>
private static void RetrieveGuestForReservation(NotificationEvent message, NotificationEventType eventType, List<PersonType> personTypeList)
{
Workstation workStation = DIContainer.Instance.Resolve<Workstation>();
var task = Task.Run(async () => await PersonsService.RetrievePersonsBySearchText(workStation.Ship.ShipId, message.ReservationNumber, personTypeList, SearchType.Reservation, null, null, 1, CommonConstants.MaxPageCount, null, folioNumber: null));
task.Wait();
if (!task.IsCanceled && !task.IsFaulted)
{
var personData = task.Result;
var personsPartyManager = DIContainer.Instance.Resolve<PersonsPartyManager>();
personData.Guests.Iterate(g =>
{
if (personsPartyManager.CurrentParty.IsPartyCreated && personsPartyManager.CurrentParty.Guests.Any(a => a.GuestId.Equals(g.GuestId, StringComparison.OrdinalIgnoreCase)))
{
var guest = personsPartyManager.CurrentParty.Guests.FirstOrDefault(p => p.GuestId.Equals(g.GuestId, StringComparison.OrdinalIgnoreCase));
MapGuestData(guest, g, eventType);
RetrieveGuestPhoto(guest);
}
});
}
}
private static SendNotificationsRequest CreateSendNotificationsRequest()
{
// Build the TrackNotificationRequest
SendNotificationsRequest request = new SendNotificationsRequest();
//
request.WebAuthenticationDetail = new WebAuthenticationDetail();
request.WebAuthenticationDetail.UserCredential = new WebAuthenticationCredential();
request.WebAuthenticationDetail.UserCredential.Key = "XXX"; // Replace "XXX" with the Key
request.WebAuthenticationDetail.UserCredential.Password = "******"; // Replace "XXX" with the Password
request.WebAuthenticationDetail.ParentCredential = new WebAuthenticationCredential();
request.WebAuthenticationDetail.ParentCredential.Key = "XXX"; // Replace "XXX" with the Key
request.WebAuthenticationDetail.ParentCredential.Password = "******"; // Replace "XXX"
if (usePropertyFile()) //Set values from a file for testing purposes
{
request.WebAuthenticationDetail.UserCredential.Key = getProperty("key");
request.WebAuthenticationDetail.UserCredential.Password = getProperty("password");
request.WebAuthenticationDetail.ParentCredential.Key = getProperty("parentkey");
request.WebAuthenticationDetail.ParentCredential.Password = getProperty("parentpassword");
}
//
request.ClientDetail = new ClientDetail();
request.ClientDetail.AccountNumber = "XXX"; // Replace "XXX" with the client's account number
request.ClientDetail.MeterNumber = "XXX"; // Replace "XXX" with the client's meter number
if (usePropertyFile()) //Set values from a file for testing purposes
{
request.ClientDetail.AccountNumber = getProperty("accountnumber");
request.ClientDetail.MeterNumber = getProperty("meternumber");
}
//
request.TransactionDetail = new TransactionDetail();
request.TransactionDetail.CustomerTransactionId = "***TrackNotification Request using VC#***"; //This is a reference field for the customer. Any value can be used and will be provided in the response.
//
request.Version = new VersionId();
//
request.TrackingNumber = "XXX"; // Replace "XXX" with the tracking number
if (usePropertyFile()) //Set values from a file for testing purposes
{
request.TrackingNumber = getProperty("trackingnumber");
}
//
// Date range is optional.
// If omitted, set to false
request.ShipDateRangeBegin = DateTime.Parse("3/25/2012"); //MM/DD/YYYY
request.ShipDateRangeEnd = DateTime.Parse("6/19/2012"); //MM/DD/YYYY
request.ShipDateRangeBeginSpecified = false;
request.ShipDateRangeEndSpecified = false;
//
request.SenderEMailAddress = "*****@*****.**";
request.SenderContactName = "Sender";
request.EventNotificationDetail = new ShipmentEventNotificationDetail();
request.EventNotificationDetail.AggregationType = ShipmentNotificationAggregationType.PER_SHIPMENT;
request.EventNotificationDetail.AggregationTypeSpecified = true;
request.EventNotificationDetail.PersonalMessage = "Personal Message";
request.EventNotificationDetail.EventNotifications = new ShipmentEventNotificationSpecification[1] {
new ShipmentEventNotificationSpecification()
};
request.EventNotificationDetail.EventNotifications[0].Role = ShipmentNotificationRoleType.THIRD_PARTY;
request.EventNotificationDetail.EventNotifications[0].RoleSpecified = true;
request.EventNotificationDetail.EventNotifications[0].FormatSpecification = new ShipmentNotificationFormatSpecification();
request.EventNotificationDetail.EventNotifications[0].FormatSpecification.Type = NotificationFormatType.HTML;
request.EventNotificationDetail.EventNotifications[0].FormatSpecification.TypeSpecified = true;
request.EventNotificationDetail.EventNotifications[0].NotificationDetail = new NotificationDetail();
request.EventNotificationDetail.EventNotifications[0].NotificationDetail.EmailDetail = new EMailDetail();
request.EventNotificationDetail.EventNotifications[0].NotificationDetail.EmailDetail.EmailAddress = "*****@*****.**";
request.EventNotificationDetail.EventNotifications[0].NotificationDetail.EmailDetail.Name = "recipient name";
request.EventNotificationDetail.EventNotifications[0].NotificationDetail.NotificationType = NotificationType.EMAIL;
request.EventNotificationDetail.EventNotifications[0].NotificationDetail.NotificationTypeSpecified = true;
NotificationEventType[] EventTypes = new NotificationEventType[5];
EventTypes[0] = NotificationEventType.ON_DELIVERY;
EventTypes[1] = NotificationEventType.ON_ESTIMATED_DELIVERY;
EventTypes[2] = NotificationEventType.ON_EXCEPTION;
EventTypes[3] = NotificationEventType.ON_SHIPMENT;
EventTypes[4] = NotificationEventType.ON_TENDER;
request.EventNotificationDetail.EventNotifications[0].Events = EventTypes;
//
return(request);
}
public void Notify(NotificationPriority priority, NotificationEventType eventType, string logMessage)
{
Log.Info($"{priority} {eventType}: {logMessage}");
}
public void RemoveEventListener(NotificationEventType type, EventListener <NotificationEvent> listener, bool useCapture = false)
{
}
/// <summary>
/// Function to updates the selected person.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="personData">The person data.</param>
/// <param name="personTypeList">The person type list.</param>
/// <param name="personsPartyManager">The persons party manager.</param>
/// <param name="eventType">Type of the event.</param>
private static void UpdateSelectedPerson(NotificationEvent message, Person personData, List<PersonType> personTypeList, PersonsPartyManager personsPartyManager, NotificationEventType eventType)
{
if (personTypeList.FirstOrDefault() == PersonType.Guest && personsPartyManager.CurrentParty.IsPartyCreated)
{
var guest = personsPartyManager.CurrentParty.Guests.FirstOrDefault(g => g.GuestId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
MapGuestData(guest, personData.Guests.FirstOrDefault(), eventType);
RetrieveGuestPhoto(guest);
}
else if (personTypeList.FirstOrDefault() == PersonType.Crewmember && personsPartyManager.CurrentParty.IsPartyCreated)
{
var crewMember = personsPartyManager.CurrentParty.Crew.FirstOrDefault(c => c.CrewmemberId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
MapCrewMemberData(crewMember, personData, eventType);
RetrieveCrewmemberPhoto(crewMember);
}
else if (personTypeList.FirstOrDefault() == PersonType.Visitor && personsPartyManager.CurrentParty.IsPartyCreated)
{
var visitor = personsPartyManager.CurrentParty.Visitors.FirstOrDefault(v => v.VisitorId.Equals(message.PersonId, StringComparison.OrdinalIgnoreCase));
MapVisitorData(visitor, personData, eventType);
RetrieveVisitorPhoto(visitor);
}
}
internal static extern NotificationError GetExtensionAction(NotificationSafeHandle handle, NotificationEventType type, out SafeAppControlHandle appcontrol);
/// <summary>
/// Maps the crew member data.
/// </summary>
/// <param name="crewMember">The crew member.</param>
/// <param name="persons">The persons.</param>
/// <param name="eventType">Type of the event.</param>
private static void MapCrewMemberData(Crewmember crewMember, Person persons, NotificationEventType eventType)
{
var selectedPerson = RetrieveSelectedPerson();
Crewmember retrievedcrewMember = persons.Crewmembers.FirstOrDefault();
if (crewMember != null)
{
if (eventType == NotificationEventType.PersonData)
{
crewMember.PersonalDetail.FirstName = retrievedcrewMember.PersonalDetail.FirstName;
crewMember.PersonalDetail.LastName = retrievedcrewMember.PersonalDetail.LastName;
crewMember.PersonalDetail.Gender = retrievedcrewMember.PersonalDetail.Gender;
crewMember.PersonalDetail.Age = retrievedcrewMember.PersonalDetail.Age;
crewMember.PersonalDetail.Birthdate = retrievedcrewMember.PersonalDetail.Birthdate;
crewMember.SecurityPhotoAddress = retrievedcrewMember.SecurityPhotoAddress;
crewMember.Stateroom = retrievedcrewMember.Stateroom;
crewMember.PersonalDetail.Country = RetriveCountry(retrievedcrewMember.PersonalDetail);
if (crewMember.PersonalDetail.Country != null)
{
crewMember.PersonalDetail.Country.Name = retrievedcrewMember.PersonalDetail.Country.Name;
}
crewMember.Department = retrievedcrewMember.Department;
crewMember.Position = retrievedcrewMember.Position;
crewMember.PersonalDetail.DocumentNumber = retrievedcrewMember.PersonalDetail.DocumentNumber;
crewMember.BoardingInfo.OnboardDate = retrievedcrewMember.BoardingInfo.OnboardDate;
crewMember.BoardingInfo.AshoreDate = retrievedcrewMember.BoardingInfo.AshoreDate;
}
else if (eventType == NotificationEventType.BoardingStatus)
{
crewMember.IsOnboard = retrievedcrewMember.IsOnboard;
crewMember.LastEvent = retrievedcrewMember.LastEvent;
crewMember.LastDateTime = retrievedcrewMember.LastDateTime;
if (crewMember.CrewmemberId.Equals(selectedPerson.PersonId, StringComparison.OrdinalIgnoreCase))
{
selectedPerson.IsOnboard = retrievedcrewMember.IsOnboard;
selectedPerson.LastEvent = retrievedcrewMember.LastEvent;
selectedPerson.LastDateTime = retrievedcrewMember.LastDateTime;
}
}
else if (eventType == NotificationEventType.Alert)
{
crewMember.HasAlert = retrievedcrewMember.HasAlert;
crewMember.AssignAlerts(retrievedcrewMember.Alerts);
selectedPerson.HasAlert = retrievedcrewMember.HasAlert;
selectedPerson.AssignAlerts(retrievedcrewMember.Alerts);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonAlert, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyAlertDetails, selectedPerson);
}
else if (eventType == NotificationEventType.Message)
{
var messageAcknowledge = retrievedcrewMember.Messages.All(m => m.StatusId.Equals(CommonConstants.MessageAcknowledgeStatusId));
crewMember.AreAllMessagesGotAcknowledged = messageAcknowledge;
crewMember.AssignMessages(retrievedcrewMember.Messages);
selectedPerson.AreAllMessagesGotAcknowledged = messageAcknowledge;
selectedPerson.AssignPersonMessages(retrievedcrewMember.Messages);
Messenger.Instance.Notify(MessengerMessage.NotifyPersonMessage, selectedPerson);
Messenger.Instance.Notify(MessengerMessage.NotifyMessageDetails, selectedPerson);
}
}
}
public EventTypeNotSupportedException(NotificationEventType eventType) : base(
$"No matching EventTemplate was found for EventType '{eventType}'")
{
}
public NotificationSignal(NotificationEventType _type, string _attachedNotificationId)
{
Type = _type;
AttachedNotificationId = _attachedNotificationId;
}
/// <summary>
/// Maps the guest data.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="retrievedPerson">The retrieved person.</param>
/// <param name="eventType">Type of the event.</param>
public static void MapPersonData(PersonBase person, PersonBase retrievedPerson, NotificationEventType eventType)
{
if (person != null)
{
if (eventType == NotificationEventType.PersonData)
{
MapPersonalDetails(person, retrievedPerson);
}
else if (eventType == NotificationEventType.Reservation)
{
MapPersonalDetails(person, retrievedPerson);
MapBoardingStatusData(person, retrievedPerson);
MapAlerts(person, retrievedPerson);
MapMessages(person, retrievedPerson);
}
else if (eventType == NotificationEventType.BoardingStatus)
{
MapBoardingStatusData(person, retrievedPerson);
}
else if (eventType == NotificationEventType.Alert)
{
MapAlerts(person, retrievedPerson);
}
else if (eventType == NotificationEventType.Message)
{
MapMessages(person, retrievedPerson);
}
}
}
