public void DequeueListOutTest()
        {
            var messageCount = 2;

            UnityConfig.RegisterComponents(container =>
            {
                container.RegisterType <IWmsEnvironmentInfoProvider, SvcWmsEnvironmentInfoProvider>(
                    new ContainerControlledLifetimeManager());
                container.RegisterType <ILocalData, ThreadStaticLocalData>(new ContainerControlledLifetimeManager());
                WmsEnvironment.Init(container.Resolve <IWmsEnvironmentInfoProvider>(),
                                    container.Resolve <ILocalData>());

                var factory = container.Resolve <ISessionFactory>();
                var svc     = container.Resolve <QueueService>();

                using (var session = factory.OpenSession())
                {
                    var request = new DequeueListRequest
                    {
                        MessagesCount        = messageCount,
                        RequiresConfirmation = true,
                        EnableTypes          = "ORDER_RESERVE",
                        Selector             = "ROUTE=OMS"
                    };

                    var testResult = svc.DequeueListOut(request);
                    testResult.Should().NotBeNull();
                    testResult.Items.Should().NotBeNull();
                    testResult.Items.Count().ShouldBeEquivalentTo(messageCount);
                }
            });
        }
Exemple #2
0
        public DequeueListResponse DequeueListOut(DequeueListRequest requestList)
        {
            Contract.Requires(requestList != null);

            var enabledTypesList = new string[0];

            if (!string.IsNullOrEmpty(requestList.EnableTypes))
            {
                enabledTypesList = requestList.EnableTypes.Split(';');
            }

            var disableTypesList = new string[0];

            if (!string.IsNullOrEmpty(requestList.DisableTypes))
            {
                disableTypesList = requestList.DisableTypes.Split(';');
            }

            DequeueResponse dequeueResponse     = null;
            var             dequeueListResponse = new List <DequeueResponse>();

            using (var session = _sessionFactory.OpenSession())
            {
                try
                {
                    var queueOutList = GetIoQueueOutList(session, enabledTypesList, disableTypesList,
                                                         requestList.MessagesCount, requestList.Selector);

                    foreach (var queueOut in queueOutList)
                    {
                        var queueMessage = new QueueMessage
                        {
                            ID                    = queueOut.ID,
                            GroupCode             = queueOut.GroupCode,
                            Message               = queueOut.Message,
                            ProcessCode           = queueOut.ProcessCode,
                            QueueMessageStateCode = queueOut.QueueMessageState.ToString().ToUpper(),
                            QueueMessageTypeCode  = queueOut.QueueMessageType.Code,
                            RelatedQueue          = queueOut.QueueIn == null ? (Guid?)null : queueOut.QueueIn.ID,
                            Data                  = queueOut.Data != null?Encoding.UTF8.GetString(queueOut.Data) : null,
                                                        //DocNumber = queueOut.Order != null ? queueOut.Order.ID.ToString() : null,
                                                        Selector = queueOut.Selector,
                                                        Uri      = queueOut.Uri
                        };

                        dequeueResponse = new DequeueResponse
                        {
                            // если партнера нет - то так и передаем. (возможно стоит ругаться)
                            PartnerCode = queueOut.Mandant == null ? null : queueOut.Mandant.PartnerCode,
                            MessageType = queueOut.QueueMessageType.Code,
                            DateIns     = queueOut.DateIns,
                            Message     = queueMessage
                        };

                        dequeueListResponse.Add(dequeueResponse);

                        // фиксируем статус обработки
                        using (var transaction = session.BeginTransaction())
                        {
                            queueOut.QueueMessageState = requestList.RequiresConfirmation
                                ? QueueMessageStates.Processing
                                : QueueMessageStates.Completed;
                            dequeueResponse.Message.QueueMessageStateCode =
                                queueOut.QueueMessageState.ToString().ToUpper();
                            transaction.Commit();
                        }
                    }
                }
                catch (Exception ex)
                {
                    Log.Error("Dequeue out error:", ex);
                    if (dequeueResponse != null)
                    {
                        dequeueResponse.Message.QueueMessageStateCode = QueueMessageStates.Error.ToString().ToUpper();
                        dequeueResponse.Message.Message = ex.Message;
                        Log.Debug(dequeueResponse.DumpToXML());
                    }

                    throw new FaultException(new FaultReason("Process dequeue exception: " + ex.Message));
                }
            }
            return(new DequeueListResponse()
            {
                Items = dequeueListResponse.ToArray()
            });
        }