public override void Patch(OperationEntity operation)
        {
            var target = operation as CustomerOrderEntity;

            if (target == null)
            {
                throw new ArgumentException(@"operation argument must be of type CustomerOrderEntity",
                                            nameof(operation));
            }

            target.CustomerId          = CustomerId;
            target.CustomerName        = CustomerName;
            target.StoreId             = StoreId;
            target.StoreName           = StoreName;
            target.OrganizationId      = OrganizationId;
            target.OrganizationName    = OrganizationName;
            target.EmployeeId          = EmployeeId;
            target.EmployeeName        = EmployeeName;
            target.IsPrototype         = IsPrototype;
            target.SubscriptionNumber  = SubscriptionNumber;
            target.SubscriptionId      = SubscriptionId;
            target.PurchaseOrderNumber = PurchaseOrderNumber;
            target.LanguageCode        = LanguageCode;

            // Checks whether calculation of sum is needed to pass the result to the property of base class before calling of base.Patch
            var needPatchPrices = !(GetNonCalculatablePrices().All(x => x == 0m) &&
                                    target.GetNonCalculatablePrices().Any(x => x != 0m));

            if (needPatchPrices)
            {
                target.Total                = Total;
                target.SubTotal             = SubTotal;
                target.SubTotalWithTax      = SubTotalWithTax;
                target.ShippingTotal        = ShippingTotal;
                target.ShippingTotalWithTax = ShippingTotalWithTax;
                target.PaymentTotal         = PaymentTotal;
                target.PaymentTotalWithTax  = PaymentTotalWithTax;
                target.HandlingTotal        = HandlingTotal;
                target.HandlingTotalWithTax = HandlingTotalWithTax;
                target.DiscountTotal        = DiscountTotal;
                target.DiscountTotalWithTax = DiscountTotalWithTax;
                target.DiscountAmount       = DiscountAmount;
                target.TaxTotal             = TaxTotal;
                target.TaxPercentRate       = TaxPercentRate;
            }

            if (!Addresses.IsNullCollection())
            {
                Addresses.Patch(target.Addresses, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
            }

            if (!Shipments.IsNullCollection())
            {
                foreach (var shipment in Shipments.Where(x => !x.Items.IsNullCollection()))
                {
                    //Need to remove all items from the shipment with references to non-existing line items.
                    //Left join shipment.Items with cart.Items to detect shipment items are referenced to no longer exist line items
                    var toRemoveItems = shipment.Items.GroupJoin(Items,
                                                                 shipmentItem => shipmentItem.LineItemId ?? shipmentItem.LineItem?.Id,
                                                                 lineItem => lineItem.Id,
                                                                 (shipmentItem, lineItem) => new
                    {
                        ShipmentItem = shipmentItem,
                        LineItem     = lineItem.SingleOrDefault()
                    })
                                        .Where(x => x.LineItem == null)
                                        .Select(x => x.ShipmentItem)
                                        .ToArray();
                    foreach (var toRemoveItem in toRemoveItems)
                    {
                        shipment.Items.Remove(toRemoveItem);
                    }

                    //Trying to set appropriator lineItem  from EF dynamic proxy lineItem to avoid EF exception (if shipmentItem.LineItem is new object with Id for already exist LineItem)
                    foreach (var shipmentItem in shipment.Items)
                    {
                        if (shipmentItem.LineItem != null)
                        {
                            shipmentItem.LineItem = target.Items.FirstOrDefault(x => x == shipmentItem.LineItem) ??
                                                    shipmentItem.LineItem;
                        }
                    }
                }

                Shipments.Patch(target.Shipments,
                                (sourceShipment, targetShipment) => sourceShipment.Patch(targetShipment));
            }

            if (!Items.IsNullCollection())
            {
                Items.Patch(target.Items, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
            }

            if (!InPayments.IsNullCollection())
            {
                InPayments.Patch(target.InPayments,
                                 (sourcePayment, targetPayment) => sourcePayment.Patch(targetPayment));
            }

            if (!Discounts.IsNullCollection())
            {
                var discountComparer = AnonymousComparer.Create((DiscountEntity x) => x.PromotionId);
                Discounts.Patch(target.Discounts, discountComparer,
                                (sourceDiscount, targetDiscount) => sourceDiscount.Patch(targetDiscount));
            }

            if (!TaxDetails.IsNullCollection())
            {
                var taxDetailComparer = AnonymousComparer.Create((TaxDetailEntity x) => x.Name);
                TaxDetails.Patch(target.TaxDetails, taxDetailComparer,
                                 (sourceTaxDetail, targetTaxDetail) => sourceTaxDetail.Patch(targetTaxDetail));
            }

            if (!DynamicPropertyObjectValues.IsNullCollection())
            {
                DynamicPropertyObjectValues.Patch(target.DynamicPropertyObjectValues, (sourceDynamicPropertyObjectValues, targetDynamicPropertyObjectValues) => sourceDynamicPropertyObjectValues.Patch(targetDynamicPropertyObjectValues));
            }

            base.Patch(operation);
        }
Example #2
0
        public override void Patch(OperationEntity operation)
        {
            var target = operation as ShipmentEntity;

            if (target == null)
            {
                throw new ArgumentException(@"operation argument must be of type ShipmentEntity", nameof(operation));
            }

            var isNeedPatch = !(GetNonCalculatablePrices().Any(x => x == 0m) && target.GetNonCalculatablePrices().Any(x => x != 0m));

            base.NeedPatchSum = isNeedPatch;
            base.Patch(operation);

            target.FulfillmentCenterId   = FulfillmentCenterId;
            target.FulfillmentCenterName = FulfillmentCenterName;
            target.OrganizationId        = OrganizationId;
            target.OrganizationName      = OrganizationName;
            target.EmployeeId            = EmployeeId;
            target.EmployeeName          = EmployeeName;
            target.ShipmentMethodCode    = ShipmentMethodCode;
            target.ShipmentMethodOption  = ShipmentMethodOption;
            target.Height      = Height;
            target.Length      = Length;
            target.Weight      = Weight;
            target.Height      = Height;
            target.Width       = Width;
            target.MeasureUnit = MeasureUnit;
            target.WeightUnit  = WeightUnit;
            target.Length      = Length;
            target.TaxType     = TaxType;

            if (isNeedPatch)
            {
                target.Price                 = Price;
                target.PriceWithTax          = PriceWithTax;
                target.DiscountAmount        = DiscountAmount;
                target.DiscountAmountWithTax = DiscountAmountWithTax;
                target.TaxPercentRate        = TaxPercentRate;
                target.TaxTotal              = TaxTotal;
                target.Total                 = Total;
                target.TotalWithTax          = TotalWithTax;
            }

            if (!InPayments.IsNullCollection())
            {
                InPayments.Patch(target.InPayments, (sourcePayment, targetPayment) => sourcePayment.Patch(targetPayment));
            }

            if (!Items.IsNullCollection())
            {
                Items.Patch(target.Items, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
            }

            if (!Discounts.IsNullCollection())
            {
                var discountComparer = AnonymousComparer.Create((DiscountEntity x) => x.PromotionId);
                Discounts.Patch(target.Discounts, discountComparer, (sourceDiscount, targetDiscount) => sourceDiscount.Patch(targetDiscount));
            }

            if (!Addresses.IsNullCollection())
            {
                Addresses.Patch(target.Addresses, (sourceAddress, targetAddress) => sourceAddress.Patch(targetAddress));
            }

            if (!Packages.IsNullCollection())
            {
                Packages.Patch(target.Packages, (sourcePackage, targetPackage) => sourcePackage.Patch(targetPackage));
            }

            if (!TaxDetails.IsNullCollection())
            {
                var taxDetailComparer = AnonymousComparer.Create((TaxDetailEntity x) => x.Name);
                TaxDetails.Patch(target.TaxDetails, taxDetailComparer, (sourceTaxDetail, targetTaxDetail) => sourceTaxDetail.Patch(targetTaxDetail));
            }
        }
Example #3
0
        public override void Patch(OperationEntity operation)
        {
            var target = operation as CustomerOrderEntity;

            if (target == null)
            {
                throw new ArgumentException(@"operation argument must be of type CustomerOrderEntity", nameof(operation));
            }

            target.CustomerId           = CustomerId;
            target.CustomerName         = CustomerName;
            target.StoreId              = StoreId;
            target.StoreName            = StoreName;
            target.OrganizationId       = OrganizationId;
            target.OrganizationName     = OrganizationName;
            target.EmployeeId           = EmployeeId;
            target.EmployeeName         = EmployeeName;
            target.DiscountAmount       = DiscountAmount;
            target.Total                = Total;
            target.SubTotal             = SubTotal;
            target.SubTotalWithTax      = SubTotalWithTax;
            target.ShippingTotal        = ShippingTotal;
            target.ShippingTotalWithTax = ShippingTotalWithTax;
            target.PaymentTotal         = PaymentTotal;
            target.PaymentTotalWithTax  = PaymentTotalWithTax;
            target.HandlingTotal        = HandlingTotal;
            target.HandlingTotalWithTax = HandlingTotalWithTax;
            target.DiscountTotal        = DiscountTotal;
            target.DiscountTotalWithTax = DiscountTotalWithTax;
            target.DiscountAmount       = DiscountAmount;
            target.TaxTotal             = TaxTotal;
            target.IsPrototype          = IsPrototype;
            target.SubscriptionNumber   = SubscriptionNumber;
            target.SubscriptionId       = SubscriptionId;
            target.LanguageCode         = LanguageCode;
            target.TaxPercentRate       = TaxPercentRate;

            if (!Addresses.IsNullCollection())
            {
                Addresses.Patch(target.Addresses, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
            }

            if (!Shipments.IsNullCollection())
            {
                Shipments.Patch(target.Shipments, (sourceShipment, targetShipment) => sourceShipment.Patch(targetShipment));
            }

            if (!Items.IsNullCollection())
            {
                Items.Patch(target.Items, (sourceItem, targetItem) => sourceItem.Patch(targetItem));
            }

            if (!InPayments.IsNullCollection())
            {
                InPayments.Patch(target.InPayments, (sourcePayment, targetPayment) => sourcePayment.Patch(targetPayment));
            }

            if (!Discounts.IsNullCollection())
            {
                var discountComparer = AnonymousComparer.Create((DiscountEntity x) => x.PromotionId);
                Discounts.Patch(target.Discounts, discountComparer, (sourceDiscount, targetDiscount) => sourceDiscount.Patch(targetDiscount));
            }
            if (!TaxDetails.IsNullCollection())
            {
                var taxDetailComparer = AnonymousComparer.Create((TaxDetailEntity x) => x.Name);
                TaxDetails.Patch(target.TaxDetails, taxDetailComparer, (sourceTaxDetail, targetTaxDetail) => sourceTaxDetail.Patch(targetTaxDetail));
            }

            base.Patch(operation);
        }