Exemplo n.º 1
0
        public async Task<IHttpActionResult> ClearAlert([FromBody] ClearAlertMessage entity, string alertId = null, string statusId = null, bool? isAlert = null, bool? isOnlineMode = null)
        {
            return await this.DeleteAsync(async operationResult =>
            {
                var clearAlertMessage = new ClearAlertMessage();
                bool isAlertFlag;
                string id;
                if (isAlert.HasValue)
                {
                    isAlertFlag = isAlert.Value;
                    id = alertId;
                    clearAlertMessage.StatusId = statusId;
                    if (isAlertFlag)
                    {
                        clearAlertMessage.PersonAlertId = alertId;
                    }
                    else
                    {
                        clearAlertMessage.PersonMessageId = alertId;
                    }
                }
                else
                {
                    isAlertFlag = !string.IsNullOrEmpty(entity.PersonAlertId);
                    id = isAlertFlag ? entity.PersonAlertId : entity.PersonMessageId;
                    clearAlertMessage = entity;
                }

                await this.personManager.ClearAlertMessageAsync(clearAlertMessage, id, isAlertFlag, isOnlineMode.HasValue ? isOnlineMode.Value : true);
            });
        }
Exemplo n.º 2
0
 /// <summary>
 /// Creates the event.
 /// </summary>
 /// <param name="person">The person.</param>
 /// <param name="gangwayEventType">Type of the gangway event.</param>
 /// <param name="personEvent">The person event.</param>
 /// <param name="boardingDetail">The boarding detail.</param>
 /// <param name="clearAlertMessage">The clear alert message.</param>
 public static async void CreateEvent(PersonBase person, GangwayEventType gangwayEventType, PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
 {
     if (personEvent != null)
     {
         await GangwayRepositoryFactory.Retrieve().CreateEventAsync(personEvent, boardingDetail, clearAlertMessage);
     }
     else
     {
         var eventDetail = new EventDetail();
         eventDetail.GangwayEventProcessType = person.GangwayEventProcessType.HasValue ? person.GangwayEventProcessType.Value : GangwayEventProcessType.Manual;
         await GangwayRepositoryFactory.Retrieve().CreateEventAsync(MapPersonEvent(person, gangwayEventType, null, null, null, null, eventDetail), null, null);
     }
 }
Exemplo n.º 3
0
        /// <summary>
        /// Creates the event.
        /// </summary>
        /// <param name="person">The person.</param>
        /// <param name="alertId">The alert identifier.</param>
        /// <param name="gangwayEventType">Type of the gangway event.</param>
        /// <param name="boardingDetail">The boarding detail.</param>
        /// <param name="clearAlertMessage">The clear alert message.</param>
        /// <param name="photoAddress">The photo address.</param>
        /// <param name="mediaItemId">The media item identifier.</param>
        /// <returns>Return instance of Person Event.</returns>
        public static PersonEvent MapPersonEvent(PersonBase person, string alertId, GangwayEventType gangwayEventType, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage, string photoAddress, string mediaItemId)
        {
            // Fills event detail.
            var eventDetail = new EventDetail();

            if (person != null)
            {
                eventDetail.GangwayEventProcessType = person.GangwayEventProcessType.HasValue ? person.GangwayEventProcessType.Value : GangwayEventProcessType.Manual;
                eventDetail.AlertCode = alertId;

                var alertData = person.Alerts.FirstOrDefault(alert => alert.IsParentalAuthorizationAlert || alert.IsFolioAlert || alert.IsNotCheckedIn || alert.IsPortManningAlert);

                if (string.IsNullOrEmpty(alertId) && alertData != null)
                {
                    if (alertData != null && alertData.Message != null)
                    {
                        eventDetail.AlertDescription = alertData.Message.Description;
                    }
                }
                else if (gangwayEventType == GangwayEventType.AlertRemoved && !string.IsNullOrEmpty(alertId))
                {
                    eventDetail.AlertDescription = person.Alerts.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
                }
                else if (gangwayEventType == GangwayEventType.MessageRemoved && !string.IsNullOrEmpty(alertId))
                {
                    eventDetail.AlertDescription = person.Messages.Where(alert => alert.AlertId.Equals(alertId)).Select(a => a.Message.Description).FirstOrDefault();
                }

                if (person.CruiseDetail != null)
                {
                    eventDetail.ReservationNumber = person.CruiseDetail.ReservationNumber;
                }

                return MapPersonEvent(person, gangwayEventType, boardingDetail, clearAlertMessage, photoAddress, mediaItemId, eventDetail);
            }

            return null;
        }
Exemplo n.º 4
0
 /// <summary>
 /// Creates the person event.
 /// </summary>
 /// <param name="person">The person.</param>
 /// <param name="gangwayEventType">Type of the gangway event.</param>
 /// <param name="boardingDetail">The boarding detail.</param>
 /// <param name="clearAlertMessage">The clear alert message.</param>
 /// <param name="photoAddress">The photo address.</param>
 /// <param name="mediaItemId">The media item identifier.</param>
 /// <param name="eventDetail">The event detail.</param>
 /// <returns>Return instance of Person Event.</returns>
 private static PersonEvent MapPersonEvent(PersonBase person, GangwayEventType gangwayEventType, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage, string photoAddress, string mediaItemId, EventDetail eventDetail)
 {
     var workstation = DIContainer.Instance.Resolve<Workstation>();
     string eventTypeId = gangwayEventType.RetrieveEventTypeId();
     return new PersonEvent()
     {
         EventTypeId = eventTypeId,
         AlternateId = Guid.NewGuid().ToString(),
         PersonId = person.PersonId,
         PersonTypeId = person.PersonTypeId,
         ShipId = workstation.Ship != null ? workstation.Ship.ShipId : null,
         MachineName = workstation.MachineName,
         Location = workstation.GangwayLocation != null ? workstation.GangwayLocation.Name : null,
         Port = workstation.Port != null ? workstation.Port.Name : null,
         AddedBy = workstation.User != null ? workstation.User.UserFullName : null,
         EventDetails = eventDetail != null ? eventDetail.RetrieveXml() : null,
         EventDate = workstation.CurrentDateTime,
         EventDateGMT = DateTime.UtcNow,
         ApplicationId = CommonConstants.ApplicationId,
         VoyageId = person.CruiseDetail != null ? person.CruiseDetail.VoyageId : null,
         LinkId = person.LinkId,
         PersonStatusDetail = workstation.ConnectionMode == ConnectionMode.Offline ? boardingDetail : null,
         PersonNotificationDetail = workstation.ConnectionMode == ConnectionMode.Offline ? clearAlertMessage : null,
         PhotoAddress = photoAddress,
         MediaItemId = mediaItemId,
         MediaTypeId = CommonConstants.MediaItemTypeId
     };
 }
 public async Task OfflineModeClearPersonMessageAsync()
 {
     try
     {
         var clearAlertMessage = new ClearAlertMessage { PersonId = "1", PersonTypeId = "21", PersonMessageId = "1", ShipId = "1", StatusId = "2", StatusUpdateDate = DateTime.Now, StatusUpdatedBy = "test", VoyageId = "1", PersonEvent = new PersonEvent { AddedBy = "Test" } };
         await this.repository.ClearAlertMessageAsync(clearAlertMessage, clearAlertMessage.PersonMessageId, false, false);
     }
     finally
     {
         this.Dispose();
     }
 }
Exemplo n.º 6
0
 public async Task ClearPersonMessageAsync()
 {
     try
     {
         CommonDependencies();
         var clearAlertMessage = new ClearAlertMessage { PersonId = "1", PersonTypeId = "21", PersonMessageId = "1", ShipId = "1", StatusId = "2", StatusUpdateDate = DateTime.Now, StatusUpdatedBy = "test", VoyageId = "1" };
         await this.manager.ClearAlertMessageAsync(clearAlertMessage, "1", false, false);
     }
     finally
     {
         this.Dispose();
     }
 }
Exemplo n.º 7
0
        /// <summary>
        /// Function to acknowledge person messages.
        /// </summary>
        /// <param name="message">The message.</param>
        /// <param name="person">Instance of PersonBase</param>
        /// <returns>
        /// IObservable of list of Alert
        /// </returns>
        public static async Task<PersonMessage> AcknowledgePersonMessages(PersonMessage message, PersonBase person)
        {
            var workstation = DIContainer.Instance.Resolve<Workstation>();
            var clearAlertMessage = new ClearAlertMessage()
            {
                PersonMessageId = message.AlertId,
                PersonId = person.PersonId,
                PersonTypeId = person.PersonTypeId,
                StatusId = AlertMessageStatusType.ClearAlert.RetrieveStatusId(),
                ShipId = workstation.Ship.ShipId,
                StatusUpdateDate = workstation.CurrentDateTime,
                StatusUpdatedBy = workstation.User.UserId,
                VoyageId = workstation.Voyage.VoyageId
            };

            var personEvent = CreateEventService.MapPersonEvent(person, message.AlertId, GangwayEventType.MessageRemoved, null, clearAlertMessage, null, null);
            if (workstation.ConnectionMode != ConnectionMode.Offline)
            {
                clearAlertMessage.PersonEvent = personEvent;
            }

            await GangwayRepositoryFactory.Retrieve().ClearPersonAlertAndMessageAsync(clearAlertMessage, AlertMessageStatusType.AcknowledgeMessage, personEvent);

            return await Task.FromResult(message);
        }
        /// <summary>
        /// Creates the event.
        /// </summary>
        /// <param name="personEvent">The person event.</param>
        /// <param name="boardingDetail">The boarding detail.</param>
        /// <param name="clearAlertMessage">The clear alert message.</param>
        /// <returns>
        /// Task Containing string.
        /// </returns>
        public async Task<string> CreateEventAsync(PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
        {
            var command = this.Database.GetStoredProcCommand(InsertPersonEventDetailStoredProcedure)
                .AddParameter(MediaItemIdField, DbType.Int32, Convert.ToInt32(personEvent.MediaItemId))
                .AddParameter(MediaItemTypeIdField, DbType.Int32, Convert.ToInt32(personEvent.MediaTypeId))
                .AddParameter(PhotoURLField, DbType.String, personEvent.PhotoAddress)
                .AddParameter(() => boardingDetail != null, PersonStatusJSONField, DbType.String, JsonConvert.SerializeObject(boardingDetail))
                .AddParameter(PersonEventJSONField, DbType.String, JsonConvert.SerializeObject(personEvent))
                .AddParameter(() => clearAlertMessage != null, PersonNotificationJSONField, DbType.String, JsonConvert.SerializeObject(clearAlertMessage))
                .AddParameter(PersonEventDetailField, DbType.Xml, personEvent.RetrieveXml())
                .AddParameter(EventDetailsField, DbType.Xml, personEvent.EventDetails)
                .AddParameter(LinkIdField, DbType.String, string.IsNullOrEmpty(personEvent.LinkId) ? Guid.NewGuid().ToString() : personEvent.LinkId)
                .AddParameter(AlternateIdField, DbType.String, personEvent.AlternateId);

            return await this.ExecuteReaderAsync(command, GangwayEventDataMapper.MapGangwayEventStatusAsync);
        }
 public async Task ClearMessageTest()
 {
     try
     {
         var clearAlertMessage = new ClearAlertMessage { PersonId = "1", PersonTypeId = "21", PersonMessageId = "1", ShipId = "1", StatusId = "2", StatusUpdateDate = DateTime.Now, StatusUpdatedBy = "test", VoyageId = "1" };
         var actionResult = await this.controller.ClearAlert(clearAlertMessage);
         Assert.IsNotNull(actionResult);
     }
     finally
     {
         this.Dispose();
     }
 }
Exemplo n.º 10
0
        /// <summary>
        /// Function to remove person alerts.
        /// </summary>
        /// <param name="alert">List of alerts to remove</param>
        /// <param name="person">Instance of PersonBase</param>
        /// <returns>IObservable of list of Alert</returns>
        public static async Task<Alert> RemovePersonAlerts(Alert alert, PersonBase person)
        {
            var workstation = DIContainer.Instance.Resolve<Workstation>();
            ClearAlertMessage clearAlertMessage = null;
            PersonEvent personEvent = null;
            if (!alert.IsParentalAuthorizationAlert && !alert.IsFolioAlert && !alert.IsNotCheckedIn && !alert.IsPortManningAlert)
            {
                clearAlertMessage = new ClearAlertMessage()
                {
                    PersonAlertId = alert.AlertId,
                    PersonId = person.PersonId,
                    PersonTypeId = person.PersonTypeId,
                    StatusId = AlertMessageStatusType.ClearAlert.RetrieveStatusId(),
                    ShipId = workstation.Ship.ShipId,
                    StatusUpdateDate = workstation.CurrentDateTime,
                    StatusUpdatedBy = workstation.User.UserId,
                    VoyageId = workstation.Voyage.VoyageId
                };
            }

            personEvent = CreateEventService.MapPersonEvent(person, alert.AlertId, GangwayEventType.AlertRemoved, null, clearAlertMessage, null, null);
            if (clearAlertMessage != null && workstation.ConnectionMode != ConnectionMode.Offline)
            {
                clearAlertMessage.PersonEvent = personEvent;
            }

            if (clearAlertMessage != null)
            {
                await GangwayRepositoryFactory.Retrieve().ClearPersonAlertAndMessageAsync(clearAlertMessage, AlertMessageStatusType.ClearAlert, personEvent);
            }
            else
            {
                CreateEventService.CreateEvent(person, GangwayEventType.AlertRemoved, personEvent, null, null);
            }

            return await Task.FromResult(alert);
        }
 /// <summary>
 /// removes person alert message
 /// </summary>
 /// <param name="entity">The entity.</param>
 /// <param name="clearAlertMessageId">The clear alert message identifier.</param>
 /// <returns>
 /// the Task
 /// </returns>
 public async Task ClearPersonAlert(ClearAlertMessage entity, string clearAlertMessageId)
 {
     await this.personAlertClient.UpdatePersonAlertAsync(clearAlertMessageId, JsonConvert.SerializeObject(new Entities.PersonAlert { PersonAlertId = entity.PersonAlertId, ShipId = entity.ShipId, VoyageId = entity.VoyageId, StatusId = entity.StatusId, PersonId = entity.PersonId, PersonTypeId = entity.PersonTypeId, StatusUpdatedBy = entity.StatusUpdatedBy, StatusUpdatedDate = entity.StatusUpdateDate, MachineName = entity.PersonEvent.MachineName }));
 }
Exemplo n.º 12
0
 /// <summary>
 /// Clears the alert message asynchronous.
 /// </summary>
 /// <param name="entity">The entity.</param>
 /// <param name="clearAlertMessageId">The clear alert message identifier.</param>
 /// <param name="isAlert">if set to <c>true</c> [is alert].</param>
 /// <returns>Return nothing</returns>
 private async Task ClearAlertMessageAsync(ClearAlertMessage entity, string clearAlertMessageId, bool isAlert)
 {
     if (isAlert)
     {
         await this.personAlertClientRepository.ClearPersonAlert(entity, clearAlertMessageId);
     }
     else
     {
         await this.personAlertClientRepository.AcknowledgePersonMessage(entity, clearAlertMessageId);
     }
 }
Exemplo n.º 13
0
 /// <summary>
 /// removes person alert by alert id
 /// </summary>
 /// <param name="entity">The entity.</param>
 /// <param name="clearAlertMessageId">The clear alert message identifier.</param>
 /// <param name="isAlert">if set to <c>true</c> [is alert].</param>
 /// <param name="isOnlineMode">if set to <c>true</c> [is on line mode].</param>
 /// <returns>
 /// returns nothing
 /// </returns>
 public async Task ClearAlertMessageAsync(ClearAlertMessage entity, string clearAlertMessageId, bool isAlert, bool isOnlineMode)
 {
     if (!isOnlineMode)
     {
         //// Code for handle BT Sync duplicate records
         var response = await this.personEventClientRepository.CreateAsync(entity.PersonEvent);
         var result = response != null ? JsonConvert.DeserializeObject<bool>(response) : default(bool);
         if (result)
         {
             await this.ClearAlertMessageAsync(entity, clearAlertMessageId, isAlert);
         }
     }
     else
     {
         await this.ClearAlertMessageAsync(entity, clearAlertMessageId, isAlert);
         if (entity.PersonEvent != null)
         {
             await this.personEventClientRepository.CreateAsync(entity.PersonEvent);
         }
     }
 }
Exemplo n.º 14
0
 /// <summary>
 /// Clears the person alert.
 /// </summary>
 /// <param name="clearAlertMessage">Instance of ClearAlertMessage</param>
 /// <param name="alertMessageStatusType">The alert and message status type.</param>
 /// <param name="personEvent">The person event.</param>
 /// <returns>
 /// Task Instance.
 /// </returns>
 public async Task ClearPersonAlertAndMessageAsync(ClearAlertMessage clearAlertMessage, AlertMessageStatusType alertMessageStatusType, PersonEvent personEvent)
 {
     await this.personServiceRepository.ClearPersonAlertAndMessageAsync(clearAlertMessage, alertMessageStatusType);
 }
Exemplo n.º 15
0
 /// <summary>
 /// Clears the person alert.
 /// </summary>
 /// <param name="clearAlertMessage">Instance of ClearAlertMessage</param>
 /// <param name="alertMessageStatusType">The alert and message status type.</param>
 /// <returns>
 /// Task Instance.
 /// </returns>
 public async Task ClearPersonAlertAndMessageAsync(ClearAlertMessage clearAlertMessage, AlertMessageStatusType alertMessageStatusType)
 {
     var command = this.Database.GetStoredProcCommand(UpdatePersonNotificationStoredProcedure)
         .AddParameter(PersonNotificationDetail, DbType.String, clearAlertMessage.RetrieveXml());
     await this.ExecuteNonQueryAsync(command);
 }
Exemplo n.º 16
0
 /// <summary>
 /// Creates the event.
 /// </summary>
 /// <param name="personEvent">The person event.</param>
 /// <param name="boardingDetail">The boarding detail.</param>
 /// <param name="clearAlertMessage">The clear alert message.</param>
 /// <returns>
 /// Task Containing string.
 /// </returns>
 public async Task<string> CreateEventAsync(PersonEvent personEvent, BoardingDetail boardingDetail, ClearAlertMessage clearAlertMessage)
 {
     return await this.gangwayEventRepository.CreateEventAsync(personEvent);
 }
Exemplo n.º 17
0
 /// <summary>
 /// removes person alert by alert id
 /// </summary>
 /// <param name="entity">The entity.</param>
 /// <param name="clearAlertMessageId">The clear alert message identifier.</param>
 /// <param name="isAlert">if set to <c>true</c> [is alert].</param>
 /// <param name="isOnlineMode">if set to <c>true</c> [is on line mode].</param>
 /// <returns>
 /// returns nothing
 /// </returns>
 public async Task ClearAlertMessageAsync(ClearAlertMessage entity, string clearAlertMessageId, bool isAlert, bool isOnlineMode)
 {
     await this.personRepository.ClearAlertMessageAsync(entity, clearAlertMessageId, isAlert, isOnlineMode);
 }
 /// <summary>
 /// Clears the person alert.
 /// </summary>
 /// <param name="clearAlertMessage">Instance of ClearAlertMessage</param>
 /// <param name="alertMessageStatusType">The alert and message status type.</param>
 /// <returns>
 /// Task Instance.
 /// </returns>
 public async Task ClearPersonAlertAndMessageAsync(ClearAlertMessage clearAlertMessage, AlertMessageStatusType alertMessageStatusType)
 {
     await this.personsClient.ClearPersonAlert(JsonConvert.SerializeObject(clearAlertMessage), null, null, null, isOnlineMode: true);
 }
Exemplo n.º 19
0
 public async Task ClearPersonAlertAsync()
 {
     try
     {
         var clearAlertMessage = new ClearAlertMessage { PersonId = "1", PersonTypeId = "21", PersonAlertId = "1", ShipId = "1", StatusId = "2", StatusUpdateDate = DateTime.Now, StatusUpdatedBy = "test", VoyageId = "1", PersonEvent = new PersonEvent { } };
         await this.repository.ClearAlertMessageAsync(clearAlertMessage, clearAlertMessage.PersonAlertId, true, true);
     }
     finally
     {
         this.Dispose();
     }
 }