Example #1
0
        private void SubmitMessageToVIS(byte[] msg)
        {
            PublishedRtzMessageService service = new PublishedRtzMessageService(_dbContext, _logContext);

            var messageType = _dbContext.MessageType.Where(m => m.Name == "RTZ").FirstOrDefault();
            //var parsedMsg = Serialization.Deserialize<Route>(Serialization.ByteArrayToString(msg));

            var         parser      = RtzParserFactory.Create(Serialization.ByteArrayToString(msg));
            string      routeStatus = parser.RouteStatus;
            RouteStatus status;

            if (string.IsNullOrEmpty(routeStatus))
            {
                status = RouteStatus.Unknown;
            }
            else
            {
                status = (RouteStatus)Enum.Parse(typeof(RouteStatus), routeStatus);
            }
            var entityToInsert = new PublishedRtzMessage
            {
                Message               = msg,
                MessageID             = "urn:mrn:stm:voyage:id:vis1:0001",
                MessageLastUpdateTime = DateTime.UtcNow,
                MessageStatus         = status,
                MessageType           = messageType,
                MessageValidFrom      = DateTime.UtcNow.AddDays(-3),
                MessageValidTo        = DateTime.UtcNow.AddDays(3),
                PublishTime           = DateTime.UtcNow.AddHours(-3)
            };

            try
            {
                service.Insert(entityToInsert);
                _dbContext.SaveChanges();
            }
            catch (Exception)
            {
                throw;
            }
        }
Example #2
0
        public void TestGetPublishedMessages()
        {
            var messages = _dbContext.PublishedRtzMessage.Where(m => (int)m.MessageStatus < 8).ToList();

            foreach (var msg in messages)
            {
                var result = new PublishedRtzMessage
                {
                    Message               = msg.Message,
                    MessageID             = msg.MessageID,
                    MessageLastUpdateTime = msg.MessageLastUpdateTime,
                    MessageStatus         = msg.MessageStatus,
                    MessageType           = msg.MessageType,
                    MessageValidFrom      = msg.MessageValidFrom,
                    MessageValidTo        = msg.MessageValidTo,
                    PublishTime           = msg.PublishTime
                };
                string status = msg.MessageStatus.ToString();
                string type   = msg.MessageType != null ? msg.MessageType.Name : string.Empty;
            }
        }
        public ResponseObj PublishMessage([FromUri] string dataId,
                                          [FromUri] string messageType,
                                          [FromBody] string message)
        {
            try
            {
                // Check incoming args
                if (!FormatValidation.IsValidUvid(dataId))
                {
                    throw CreateHttpResponseException(HttpStatusCode.BadRequest, string.Format("Invalid UVID format."));
                }
                if (string.IsNullOrEmpty(dataId))
                {
                    throw CreateHttpResponseException(HttpStatusCode.BadRequest, string.Format("Missing required parameter dataId."));
                }
                if (string.IsNullOrEmpty(messageType))
                {
                    throw CreateHttpResponseException(HttpStatusCode.BadRequest, string.Format("Missing required parameter messageType."));
                }
                if (string.IsNullOrEmpty(message))
                {
                    throw CreateHttpResponseException(HttpStatusCode.BadRequest, string.Format("Missing required parameter message."));
                }

                // Check if correct messageType e.g. only RTZ accepted
                var msgType = _messageTypeService.Get(m => m.Name == messageType).FirstOrDefault();
                if (msgType == null ||
                    string.IsNullOrEmpty(msgType.Name) ||
                    msgType.Name.ToLower() != "rtz")
                {
                    throw CreateHttpResponseException(HttpStatusCode.BadRequest, string.Format("Unsupported or unknown message type."));
                }

                var messageToUpdate = _publishedMessageService.Get(m => m.MessageID == dataId).FirstOrDefault();

                var responsObj = new ResponseObj(dataId);

                CheckRouteStatus(message, dataId);

                if (messageToUpdate == null) //New message
                {
                    var newMessage = new PublishedRtzMessage();
                    newMessage.Message     = Serialization.StrToByteArray(message);
                    newMessage.MessageID   = dataId;
                    newMessage.MessageType = msgType;
                    newMessage.PublishTime = DateTime.UtcNow;

                    _publishedMessageService.Insert(newMessage);
                }
                else
                {
                    messageToUpdate.Message     = Serialization.StrToByteArray(message);
                    messageToUpdate.PublishTime = DateTime.UtcNow;

                    _publishedMessageService.Update(messageToUpdate);
                }

                //Notify subscribers if messageStatus not inactive
                var parser = RtzParserFactory.Create(message);

                string routeInfo   = parser.RouteInfo;
                string routeStatus = parser.RouteStatus;
                if (!string.IsNullOrEmpty(routeInfo) && !string.IsNullOrEmpty(routeStatus))
                {
                    _publishedMessageService.SendMessageToSubsribers(message, dataId);
                }

                SetLastInteractionTime();
                // Save to DB
                _context.SaveChanges();

                return(responsObj);
            }
            catch (HttpResponseException ex)
            {
                log.Error(ex.Message, ex);

                throw;
            }
            catch (Exception ex)
            {
                log.Error(ex.Message, ex);

                var errorMessage = "VIS internal server error. " + ex.Message;
                throw CreateHttpResponseException(HttpStatusCode.InternalServerError, errorMessage);
            }
        }