private void SyncInventoryItem()
        {
            var derivation    = new Derivations.Default.Derivation(this.Strategy.Session);
            var facility      = this.Facility ?? this.Part.DefaultFacility;
            var unitOfMeasure = this.UnitOfMeasure ?? this.Part.UnitOfMeasure;

            if (this.Part.InventoryItemKind.IsSerialised && (this.Quantity < -1 || this.Quantity > 1))
            {
                var message = "Invalid transaction";
                derivation.Validation.AddError(this, this.Meta.SerialisedItem, message);
            }

            if (this.Part.InventoryItemKind.IsSerialised)
            {
                var inventoryItems = this.SerialisedItem.SerialisedInventoryItemsWhereSerialisedItem;
                inventoryItems.Filter.AddEquals(M.InventoryItem.Part, this.Part);
                inventoryItems.Filter.AddEquals(M.InventoryItem.Facility, facility);
                var inventoryItem = inventoryItems.First;

                if (inventoryItem == null)
                {
                    var builder = new SerialisedInventoryItemBuilder(this.Strategy.Session)
                                  .WithFacility(facility)
                                  .WithUnitOfMeasure(unitOfMeasure)
                                  .WithSerialisedItem(this.SerialisedItem)
                                  .WithPart(this.Part)
                                  .WithSerialisedInventoryItemState(this.SerialisedInventoryItemState);

                    if (this.ExistLot)
                    {
                        builder.WithLot(this.Lot);
                    }

                    this.InventoryItem = builder.Build();
                }
            }
            else if (this.Part.InventoryItemKind.IsNonSerialised)
            {
                var inventoryItems = this.Part.InventoryItemsWherePart;
                inventoryItems.Filter.AddEquals(M.InventoryItem.Facility, facility);
                var inventoryItem = inventoryItems.First;

                if (inventoryItem == null)
                {
                    var builder = new NonSerialisedInventoryItemBuilder(this.Strategy.Session)
                                  .WithFacility(facility)
                                  .WithUnitOfMeasure(unitOfMeasure)
                                  .WithPart(this.Part)
                                  .WithNonSerialisedInventoryItemState(this.NonSerialisedInventoryItemState);

                    if (this.ExistLot)
                    {
                        builder.WithLot(this.Lot);
                    }

                    this.InventoryItem = builder.Build();
                }
            }
        }
Esempio n. 2
0
        public void GivenInventoryItem_WhenBuild_ThenPreviousObjectStateIsNull()
        {
            var item = new NonSerialisedInventoryItemBuilder(this.Session)
                       .WithPart(new NonUnifiedPartBuilder(this.Session)
                                 .WithProductIdentification(new PartNumberBuilder(this.Session)
                                                            .WithIdentification("1")
                                                            .WithProductIdentificationType(new ProductIdentificationTypes(this.Session).Part).Build())
                                 .WithInventoryItemKind(new InventoryItemKinds(this.Session).NonSerialised)
                                 .Build())
                       .Build();

            this.Session.Derive();

            Assert.Null(item.PreviousNonSerialisedInventoryItemState);
        }
        public void GivenInventoryItem_WhenBuild_ThenLastObjectStateEqualsCurrencObjectState()
        {
            var item = new NonSerialisedInventoryItemBuilder(this.Session)
                       .WithPart(new NonUnifiedPartBuilder(this.Session)
                                 .WithProductIdentification(new PartNumberBuilder(this.Session)
                                                            .WithIdentification("1")
                                                            .WithProductIdentificationType(new ProductIdentificationTypes(this.Session).Part).Build())
                                 .WithInventoryItemKind(new InventoryItemKinds(this.Session).NonSerialised)
                                 .Build())
                       .Build();

            this.Session.Derive();

            Assert.Equal(new NonSerialisedInventoryItemStates(this.Session).Good, item.NonSerialisedInventoryItemState);
            Assert.Equal(item.LastNonSerialisedInventoryItemState, item.NonSerialisedInventoryItemState);
        }
        public void GivenInventoryItemForPart_WhenDerived_ThenNameIsPartName()
        {
            var part = new NonUnifiedPartBuilder(this.Session)
                       .WithProductIdentification(new PartNumberBuilder(this.Session)
                                                  .WithIdentification("1")
                                                  .WithProductIdentificationType(new ProductIdentificationTypes(this.Session).Part).Build())
                       .WithInventoryItemKind(new InventoryItemKinds(this.Session).NonSerialised)
                       .Build();

            var item = new NonSerialisedInventoryItemBuilder(this.Session)
                       .WithPart(part)
                       .Build();

            this.Session.Derive();

            Assert.Equal(part.Name, item.Name);
        }
        public void GivenInventoryItemForPart_WhenDerived_ThenUnitOfMeasureIsPartUnitOfMeasure()
        {
            var uom  = new UnitsOfMeasure(this.Session).Centimeter;
            var part = new NonUnifiedPartBuilder(this.Session)
                       .WithProductIdentification(new PartNumberBuilder(this.Session)
                                                  .WithIdentification("1")
                                                  .WithProductIdentificationType(new ProductIdentificationTypes(this.Session).Part).Build())
                       .WithInventoryItemKind(new InventoryItemKinds(this.Session).NonSerialised)
                       .WithUnitOfMeasure(uom)
                       .Build();

            var item = new NonSerialisedInventoryItemBuilder(this.Session)
                       .WithPart(part)
                       .Build();

            this.Session.Derive();

            Assert.Equal(part.UnitOfMeasure, item.UnitOfMeasure);
        }
Esempio n. 6
0
        private void SyncInventoryItem(IDerivation derivation)
        {
            var facility      = this.Facility ?? this.Part.DefaultFacility;
            var unitOfMeasure = this.UnitOfMeasure ?? this.Part.UnitOfMeasure;

            if (this.Part.InventoryItemKind.IsSerialized && this.Quantity <= 0)
            {
                var message = "Invalid transaction";
                derivation.Validation.AddError(this, this.Meta.SerialisedItem, message);
            }

            if (this.Part.InventoryItemKind.IsSerialized && this.Quantity > 0)
            {
                var builder = new SerialisedInventoryItemBuilder(this.strategy.Session)
                              .WithFacility(facility)
                              .WithUnitOfMeasure(unitOfMeasure)
                              .WithSerialisedItem(this.SerialisedItem)
                              .WithPart(this.Part)
                              .WithSerialisedInventoryItemState(this.SerialisedInventoryItemState);

                if (this.ExistLot)
                {
                    builder.WithLot(this.Lot);
                }

                this.InventoryItem = builder.Build();
            }
            else if (this.Part.InventoryItemKind.IsNonSerialized)
            {
                var builder = new NonSerialisedInventoryItemBuilder(this.strategy.Session)
                              .WithFacility(facility)
                              .WithUnitOfMeasure(unitOfMeasure)
                              .WithPart(this.Part)
                              .WithNonSerialisedInventoryItemState(this.NonSerialisedInventoryItemState);

                if (this.ExistLot)
                {
                    builder.WithLot(this.Lot);
                }

                this.InventoryItem = builder.Build();
            }
        }
        public void GivenInventoryItem_WhenBuild_ThenPostBuildRelationsMustExist()
        {
            var item = new NonSerialisedInventoryItemBuilder(this.Session)
                       .WithPart(new NonUnifiedPartBuilder(this.Session)
                                 .WithProductIdentification(new PartNumberBuilder(this.Session)
                                                            .WithIdentification("1")
                                                            .WithProductIdentificationType(new ProductIdentificationTypes(this.Session).Part).Build())
                                 .WithInventoryItemKind(new InventoryItemKinds(this.Session).NonSerialised)
                                 .Build())
                       .Build();

            Session.Derive();

            Assert.Equal(0M, item.AvailableToPromise);
            Assert.Equal(0M, item.QuantityCommittedOut);
            Assert.Equal(0M, item.QuantityExpectedIn);
            Assert.Equal(0M, item.QuantityOnHand);
            Assert.Equal(new NonSerialisedInventoryItemStates(this.Session).Good, item.NonSerialisedInventoryItemState);
            Assert.Equal(new Facilities(this.Session).FindBy(M.Facility.FacilityType, new FacilityTypes(this.Session).Warehouse), item.Facility);
        }
        public void BaseOnDeriveInventoryItem(IDerivation derivation)
        {
            if (this.ExistShipmentItem && this.ShipmentItem.ExistOrderShipmentsWhereShipmentItem)
            {
                var purchaseShipment     = (PurchaseShipment)this.ShipmentItem.ShipmentWhereShipmentItem;
                var internalOrganisation = purchaseShipment.ShipFromParty as InternalOrganisation;
                var purchaseOrderItem    = this.ShipmentItem.OrderShipmentsWhereShipmentItem[0].OrderItem as PurchaseOrderItem;

                var facility = purchaseOrderItem?.PurchaseOrderWherePurchaseOrderItem.Facility;
                if (facility == null)
                {
                    facility = internalOrganisation?.StoresWhereInternalOrganisation.Count == 1 ? internalOrganisation.StoresWhereInternalOrganisation.Single().DefaultFacility : null;
                }

                if (purchaseOrderItem != null && purchaseOrderItem.ExistPart)
                {
                    if (!this.ExistInventoryItem || !this.InventoryItem.Part.Equals(purchaseOrderItem.Part))
                    {
                        var part           = purchaseOrderItem.Part;
                        var inventoryItems = part.InventoryItemsWherePart;
                        inventoryItems.Filter.AddEquals(M.InventoryItem.Facility, facility);
                        var inventoryItem = inventoryItems.First;

                        if (inventoryItem == null)
                        {
                            inventoryItem = new NonSerialisedInventoryItemBuilder(this.Strategy.Session)
                                            .WithFacility(facility)
                                            .WithUnitOfMeasure(part.UnitOfMeasure)
                                            .WithPart(part)
                                            .Build();
                        }

                        this.InventoryItem = inventoryItem;
                    }
                }
            }
        }