Example #1
0
        public void SendInputMessage(string tenantId, StockInputResponse inputResponse,
                                     List <RobotPack> inputRequestPackList, bool isLoaded)
        {
            if (isLoaded)
            {
                this.stock.LoadInput(inputResponse);
            }

            var inputRequestPackListIsEmpty = inputRequestPackList == null || inputRequestPackList.Count == 0;

            foreach (IConverterStream stream in this.converterStreamList)
            {
                if (tenantId != stream.TenantID)
                {
                    continue;
                }

                StockInputMessage inputMessage = new StockInputMessage(stream)
                {
                    IsNewDelivery = inputResponse.IsDeliveryInput
                };
                inputMessage.AdoptHeader(inputResponse);

                inputMessage.Articles.AddRange(inputResponse.Articles.ToArray());
                inputMessage.Packs.AddRange(inputResponse.Packs.ToArray());



                for (int i = 0; i < inputMessage.Packs.Count; i++)
                {
                    inputMessage.Packs[i].Depth  = 60;
                    inputMessage.Packs[i].Width  = 60;
                    inputMessage.Packs[i].Height = 60;



                    if (!inputRequestPackListIsEmpty)
                    {
                        inputMessage.Packs[i].Shape           = inputRequestPackList[i].Shape; //IT cannot define the shape.
                        inputMessage.Packs[i].MachineLocation =
                            inputRequestPackList[i].MachineLocation;                           //IT cannot define the Machine location.
                        inputMessage.Packs[i].TenantID =
                            inputRequestPackList[i].TenantID;                                  //IT cannot define the tenant.
                    }

                    inputMessage.Handlings.Add(inputMessage.Packs[i],
                                               isLoaded ? StockInputHandlingType.Completed : StockInputHandlingType.Aborted);
                }

                stream.Write(inputMessage);
            }
        }
Example #2
0
        /// <summary>
        /// Translates this object instance into a Mosaic message.
        /// </summary>
        /// <param name="converterStream">The converter stream instance which request the message conversion.</param>
        /// <returns>
        /// The Mosaic message representation of this object.
        /// </returns>
        public MosaicMessage ToMosaicMessage(IConverterStream converterStream)
        {
            StockInputMessage message = new StockInputMessage(converterStream);

            message.ID            = this.Id;
            message.Source        = this.Source;
            message.Destination   = this.Destination;
            message.IsNewDelivery = TypeConverter.ConvertBool(this.IsNewDelivery);

            if (this.Article.Count > 0)
            {
                foreach (var article in this.Article)
                {
                    var a = new Interfaces.Types.Articles.RobotArticle();
                    a.DosageForm         = TextConverter.UnescapeInvalidXmlChars(article.DosageForm);
                    a.Code               = TextConverter.UnescapeInvalidXmlChars(article.Id);
                    a.Name               = TextConverter.UnescapeInvalidXmlChars(article.Name);
                    a.PackagingUnit      = TextConverter.UnescapeInvalidXmlChars(article.PackagingUnit);
                    a.MaxSubItemQuantity = TypeConverter.ConvertInt(article.MaxSubItemQuantity);
                    message.Articles.Add(a);

                    foreach (var pack in article.Pack)
                    {
                        var p = new RobotPack
                        {
                            ID              = (long)TypeConverter.ConvertULong(pack.Id),
                            DeliveryNumber  = TextConverter.UnescapeInvalidXmlChars(pack.DeliveryNumber),
                            BatchNumber     = TextConverter.UnescapeInvalidXmlChars(pack.BatchNumber),
                            ExternalID      = TextConverter.UnescapeInvalidXmlChars(pack.ExternalId),
                            ExpiryDate      = TypeConverter.ConvertDate(pack.ExpiryDate),
                            StockInDate     = TypeConverter.ConvertDate(pack.StockInDate),
                            ScanCode        = TextConverter.UnescapeInvalidXmlChars(pack.ScanCode),
                            Depth           = TypeConverter.ConvertInt(pack.Depth),
                            Width           = TypeConverter.ConvertInt(pack.Width),
                            Height          = TypeConverter.ConvertInt(pack.Height),
                            Shape           = TypeConverter.ConvertEnum <PackShape>(pack.Shape, PackShape.Cuboid),
                            IsBlocked       = (TypeConverter.ConvertEnum <PackState>(pack.State, PackState.Available) != PackState.Available),
                            SubItemQuantity = TypeConverter.ConvertInt(pack.SubItemQuantity),
                            StockLocationID = string.IsNullOrEmpty(pack.StockLocationId) ? string.Empty : TextConverter.UnescapeInvalidXmlChars(pack.StockLocationId),
                            MachineLocation = string.IsNullOrEmpty(pack.MachineLocation) ? string.Empty : TextConverter.UnescapeInvalidXmlChars(pack.MachineLocation),
                            IsInFridge      = TypeConverter.ConvertBool(pack.IsInFridge)
                        };

                        message.Packs.Add(p);
                        message.Handlings.Add(p, pack.Handling.Input);
                    }
                }
            }

            return(message);
        }
Example #3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="InputMessage"/> class.
        /// </summary>
        /// <param name="message">The message to use for initialization.</param>
        public InputMessage(MosaicMessage message)
        {
            StockInputMessage msg = (StockInputMessage)message;

            this.Id            = msg.ID;
            this.Source        = msg.Source;
            this.Destination   = msg.Destination;
            this.IsNewDelivery = msg.IsNewDelivery.ToString();

            var articles = msg.Articles.Distinct();

            if (articles.Count() > 0)
            {
                this.Article = new List <Article>(articles.Count());

                foreach (var article in articles)
                {
                    var a = new Article
                    {
                        DosageForm         = TextConverter.EscapeInvalidXmlChars(article.DosageForm),
                        Id                 = TextConverter.EscapeInvalidXmlChars(article.Code),
                        Name               = TextConverter.EscapeInvalidXmlChars(article.Name),
                        PackagingUnit      = TextConverter.EscapeInvalidXmlChars(article.PackagingUnit),
                        MaxSubItemQuantity = article.MaxSubItemQuantity > 0 ? article.MaxSubItemQuantity.ToString() : null,
                        Pack               = new List <Types.Pack>()
                    };

                    for (int i = 0; i < msg.Packs.Count; ++i)
                    {
                        if (msg.Packs[i].RobotArticleCode != article.Code)
                        {
                            continue;
                        }

                        a.Pack.Add(new Pack()
                        {
                            Index           = i.ToString(),
                            Id              = ((ulong)msg.Packs[i].ID).ToString(),
                            DeliveryNumber  = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].DeliveryNumber),
                            BatchNumber     = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].BatchNumber),
                            ExternalId      = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].ExternalID),
                            ExpiryDate      = TypeConverter.ConvertDateNull(msg.Packs[i].ExpiryDate),
                            StockInDate     = TypeConverter.ConvertDateNull(msg.Packs[i].StockInDate),
                            ScanCode        = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].ScanCode),
                            Depth           = msg.Packs[i].Depth.ToString(),
                            Width           = msg.Packs[i].Width.ToString(),
                            Height          = msg.Packs[i].Height.ToString(),
                            Shape           = msg.Packs[i].Shape.ToString(),
                            State           = msg.Packs[i].IsBlocked ? PackState.NotAvailable.ToString() : PackState.Available.ToString(),
                            IsInFridge      = msg.Packs[i].IsInFridge.ToString(),
                            SubItemQuantity = msg.Packs[i].SubItemQuantity.ToString(),
                            StockLocationId = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].StockLocationID),
                            MachineLocation = TextConverter.EscapeInvalidXmlChars(msg.Packs[i].MachineLocation),
                            Handling        = new Handling()
                            {
                                Input = msg.Handlings[msg.Packs[i]], Text = string.Empty
                            }
                        });
                    }

                    this.Article.Add(a);
                }
            }
        }