Example #1
0
        public IActionResult Post([FromBody] SendMessageModel model)
        {
            Guard.AgainstNull(model, nameof(model));

            IQueue queue = null;

            try
            {
                queue = _queueManager.CreateQueue(model.DestinationQueueUri);

                var transportMessage = _transportMessageFactory.Create(new object(), c => c.WithRecipient(queue));

                transportMessage.AssemblyQualifiedName = model.MessageType;
                transportMessage.MessageType           = model.MessageType;
                transportMessage.Message = Encoding.UTF8.GetBytes(model.Message);

                using (var stream = _serializer.Serialize(transportMessage))
                {
                    queue.Enqueue(transportMessage, stream);
                }
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
            finally
            {
                queue?.AttemptDispose();
            }

            return(Ok());
        }
Example #2
0
        public IActionResult Transfer([FromBody] MessageTransferModel model)
        {
            try
            {
                IQueue queue            = null;
                var    previousQueueUri = string.Empty;

                foreach (var messageId in model.MessageIds)
                {
                    var action = model.Action.ToLower();

                    if (action.Equals("remove"))
                    {
                        using (_databaseContextFactory.Create())
                        {
                            _inspectionQueue.Remove(messageId);
                        }

                        continue;
                    }

                    var inspectionMessage = _inspectionQueue.Get(messageId);

                    TransportMessage transportMessage;

                    try
                    {
                        transportMessage = GetTransportMessage(inspectionMessage.Stream);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex.AllMessages());

                        return(StatusCode((int)HttpStatusCode.InternalServerError, ex));
                    }

                    var queueUri = string.Empty;
                    var stream   = inspectionMessage.Stream;

                    switch (action)
                    {
                    case "copy":
                    case "move":
                    {
                        queueUri = model.DestinationQueueUri;

                        break;
                    }

                    case "returntosourcequeue":
                    {
                        queueUri = inspectionMessage.SourceQueueUri;

                        break;
                    }

                    case "sendtorecipientqueue":
                    {
                        queueUri = transportMessage.RecipientInboxWorkQueueUri;

                        break;
                    }

                    case "stopignoring":
                    {
                        queueUri = transportMessage.RecipientInboxWorkQueueUri;

                        transportMessage.IgnoreTillDate = DateTime.MinValue;
                        stream = _serializer.Serialize(transportMessage);

                        break;
                    }
                    }

                    if (!string.IsNullOrEmpty(queueUri))
                    {
                        if (!queueUri.Equals(previousQueueUri))
                        {
                            queue?.AttemptDispose();

                            queue = _queueManager.CreateQueue(queueUri);

                            previousQueueUri = queueUri;
                        }

                        queue?.Enqueue(transportMessage, stream);

                        if (!action.Equals("copy"))
                        {
                            _inspectionQueue.Remove(messageId);
                        }
                    }
                }

                queue?.AttemptDispose();

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }