コード例 #1
0
        private void AdjustStockItemQuantity(LineItem lineItem)
        {
            if (String.IsNullOrEmpty(lineItem.CatalogItemId) ||
                lineItem.CatalogItemId.StartsWith("@"))
            {
                return;
            }

            var catalogHelper = new CatalogClient(CatalogRepository, null, CustomerSessionService, CacheRepository, InventoryRepository);
            var item = catalogHelper.GetItem(lineItem.CatalogItemId);

			if (item != null && item.TrackInventory)
			{
                var repo = InventoryRepository;
                var inventory = catalogHelper.GetItemInventory(lineItem.CatalogItemId, lineItem.FulfillmentCenterId, false);
			    if (inventory != null)
			    {
				    if (AdjustStockInventoryQuantity(lineItem, inventory))
				    {
					    repo.UnitOfWork.Commit();
				    }
				    else
				    {
					    throw new InvalidWorkflowException(string.Format("Failed to adjust inventory for lineItem {0}", lineItem.LineItemId));
				    }
			    }
			}
        }
コード例 #2
0
		/// <summary>
		/// Populates the line item.
		/// </summary>
		/// <param name="entry">The entry.</param>
		/// <param name="lineItem">The line item.</param>
		private void PopulateLineItem(ref PromotionEntry entry, LineItem lineItem)
		{
			entry.Quantity = lineItem.Quantity;
			entry.Owner = lineItem;
			entry.Outline = lineItem.CatalogOutline;
			entry.EntryId = lineItem.CatalogItemId;
			entry.ParentEntryId = lineItem.ParentCatalogItemId;
			entry.EntryCode = lineItem.CatalogItemCode;

			// Save line item id, so it is easier to distinguish to which item discount is applied
			entry["LineItemId"] = lineItem.LineItemId;
			entry["ShippingAddressId"] = lineItem.ShippingAddressId;
			
			entry["MinQuantity"] = lineItem.MinQuantity;
			entry["MaxQuantity"] = lineItem.MaxQuantity;
			entry["LineItemDiscountAmount"] = lineItem.LineItemDiscountAmount;
			//entry["OrderLevelDiscountAmount"] = lineItem.OrderLevelDiscountAmount;
			entry["ShippingMethodName"] = lineItem.ShippingMethodName ?? string.Empty;
			entry["ExtendedPrice"] = lineItem.ExtendedPrice;
			entry["Description"] = lineItem.Description ?? string.Empty;
			entry["Status"] = lineItem.Status ?? string.Empty;
			entry["DisplayName"] = lineItem.DisplayName ?? string.Empty;
			entry["AllowBackordersAndPreorders"] = lineItem.AllowBackorders && lineItem.AllowPreorders;
			entry["InStockQuantity"] = lineItem.InStockQuantity;
			entry["PreorderQuantity"] = lineItem.PreorderQuantity;
			entry["BackorderQuantity"] = lineItem.BackorderQuantity;
			entry["InventoryStatus"] = lineItem.InventoryStatus;
		}
コード例 #3
0
        protected void RegisterWarning(string code, LineItem lineItem, string message)
        {
            var parameters = new Dictionary<string, string>
	            {
		            {"ItemId", lineItem.CatalogItemId},
		            {"LineItemId", lineItem.LineItemId},
		            {"DisplayName", lineItem.DisplayName},
		            {"Message", message}
	            };

	        RegisterWarning(code, parameters);
        }
コード例 #4
0
		[RepositoryTheory] // fixed be setting LineItemId explicitly
		public void Can_add_shipmentitem()
		{
			var order = TestOrderBuilder.BuildOrder()
				.WithAddresess()
				.WithShipment()
				.GetOrder();

			var repository = GetRepository();
			repository.Add(order);
			repository.UnitOfWork.Commit();

			RefreshRepository(ref repository);
			order = repository.Orders
				.ExpandAll()
				.Expand("RmaRequests/RmaReturnItems/RmaLineItems/LineItem")
				.Expand("RmaRequests/Order")
				.Expand("OrderForms/Shipments/OrderForm/OrderGroup")
				.Expand("OrderForms/Shipments/ShipmentItems/LineItem")
				.Expand("OrderForms/Shipments/ShipmentItems/Shipment/OrderForm/OrderGroup")
				.FirstOrDefault();

			// adding new LineItem first
			var newLineItem = new LineItem
			{
				CatalogItemId = "ItemId",
				CatalogItemCode = "ItemCode",
				Quantity = 1,
				PlacedPrice = 10,
				TaxTotal = 1
			};
			order.OrderForms[0].LineItems.Add(newLineItem);

			// adding new ShipmentItem
			var item = new ShipmentItem();
			item.LineItem = newLineItem;
			item.LineItemId = item.LineItem.LineItemId; // this line shouldn't be necessary. But it is.
			//item.Shipment = order.OrderForms[0].Shipments[0]; // this line of code was causing exception in original	code
			order.OrderForms[0].Shipments[0].ShipmentItems.Add(item);
			repository.UnitOfWork.Commit();

			RefreshRepository(ref repository);
			order = repository.Orders
				.ExpandAll()
				.Expand("OrderForms/Shipments/ShipmentItems")
				.Expand("OrderForms/LineItems")
				.FirstOrDefault();

			Assert.True(order.OrderForms[0].LineItems.Any(x => x.LineItemId == newLineItem.LineItemId));
			Assert.True(order.OrderForms[0].Shipments[0].ShipmentItems.Any(x => x.LineItemId == newLineItem.LineItemId));
		}
コード例 #5
0
		/// <summary>
		/// Returns the package option array when method id and package that needs to be send is passed.
		/// Use passed message string to pass errors back to the application if any occurred.
		/// </summary>
		/// <param name="shippingMethod">The shipping method.</param>
		/// <param name="items">The items.</param>
		/// <param name="message">The message.</param>
		/// <returns>
		/// empty array if no results found
		/// </returns>
		public ShippingRate GetRate(string shippingMethod, LineItem[] items, ref string message)
		{
			if (items == null || items.Length == 0)
				return null;

			IShippingRepository repository = ServiceLocator.Current.GetInstance<IShippingRepository>();
			ShippingOption[] options = repository.ShippingOptions.ExpandAll().ToArray();

			var method = (from o in options from m in o.ShippingMethods where m.ShippingMethodId.Equals(shippingMethod, StringComparison.OrdinalIgnoreCase) select m).SingleOrDefault();

			if (method != null)
			{
				return new ShippingRate(method.ShippingMethodId, method.Name, method.BasePrice, method.Currency);
			}
			else
			{
				message = "The shipping method could not be loaded.";
				return null;
			}
		}
コード例 #6
0
        public ShippingRate GetRate(string shippingMethod, LineItem[] items, ref string message)
        {
            if (items == null || items.Length == 0)
            {
                message = "No line items provided";
                return null;
            }


            var repository = ServiceLocator.Current.GetInstance<IShippingRepository>();
            var options = repository.ShippingOptions.ExpandAll().ToArray();

            var method = (from o in options from m in o.ShippingMethods where m.ShippingMethodId.Equals(shippingMethod, StringComparison.OrdinalIgnoreCase) select m).SingleOrDefault();

            if (method == null)
            {
                message = "The shipping method could not be loaded.";
                return null;
            }

            var retVal = new ShippingRate(method.ShippingMethodId, method.Name, method.BasePrice, method.Currency);

            var prop = method.ShippingOption.ShippingGatewayPropertyValues.FirstOrDefault(
                x => x.Name == UnitWeightPricePropertyName);

            if (prop != null && !string.IsNullOrWhiteSpace(prop.ShortTextValue) && decimal.TryParse(prop.ShortTextValue, NumberStyles.Number, CultureInfo.InvariantCulture, out defaultWeghtUnitPriceDecimal))
            {
                //just ok
            }

            //Calculate price for item weight
            foreach (var item in items)
            {
                retVal.Price += item.Weight * defaultWeghtUnitPriceDecimal * item.Quantity;
            }

            return retVal;
        }
コード例 #7
0
        public ShippingRate[] GetShippingRates(string[] shippingMethods, LineItem[] items)
        {
            if (items == null || items.Length == 0)
                return null;

            if (shippingMethods == null || shippingMethods.Length == 0)
                return null;

            var options = GetAllShippingOptions();
            var methods = (from o in options from m in o.ShippingMethods where shippingMethods.Contains(m.ShippingMethodId, StringComparer.OrdinalIgnoreCase) select m).ToArray();

            if (methods.Length == 0)
                return null;

            var rates = new List<ShippingRate>();
            foreach (var method in methods)
            {
				var classType = method.ShippingOption.ShippingGateway.ClassType;//.GetParent()).ClassType;
                var type = Type.GetType(classType);
                if (type == null)
                {
                    throw new TypeInitializationException(classType, null);
                }

                var message = String.Empty;
                var provider = (IShippingGateway)Activator.CreateInstance(type);

                var rate = provider.GetRate(method.ShippingMethodId, items.ToArray(), ref message);
                if (rate != null)
                {
                    rates.Add(rate);
                }
            }

            return rates.ToArray();
        }
コード例 #8
0
		private LineItem Sku2LineItem(Item sku, decimal quantity)
		{
			var session = CustomerSessionService.CustomerSession;
			var price = PriceListRepository.FindLowestPrice(session != null ? session.Pricelists : null, sku.ItemId, quantity);
			var retVal = new LineItem
				{
					CatalogItemId = sku.ItemId,
					CatalogItemCode = sku.Code,
					DisplayName = sku.Name,
					Quantity = quantity,
					Catalog = sku.CatalogId,
					MaxQuantity = sku.MaxQuantity,
					MinQuantity = sku.MinQuantity,
					PlacedPrice = price != null ? (price.Sale ?? price.List) : 0,
					ListPrice = price != null ? (price.Sale ?? price.List) : 0,
                    CatalogOutline = OutlineBuilder.BuildCategoryOutline(CustomerSessionService.CustomerSession.CatalogId, sku.ItemId).ToString()
				};

			return retVal;
		}
コード例 #9
0
		private PromotionEntry GetPromotionEntryFromLineItem(LineItem lineItem)
		{
			var populate = PromotionEntryPopulate;
			var entry = new PromotionEntry(lineItem.Catalog, lineItem.CatalogItemId, lineItem.ExtendedPrice / lineItem.Quantity);
			populate.Populate(ref entry, lineItem);
			return entry;
		}
コード例 #10
0
		private void ChangeShipmentsLineItemQty(LineItem lineItem, decimal delta)
		{
			var order = CurrentOrderGroup;
			foreach (var form in order.OrderForms)
			{
				var allShipmentContainsLineItem = form.Shipments
					.Where(x => x.ShipmentItems.Select(si => si.LineItem).Contains(lineItem))
					.SelectMany(s => s.ShipmentItems);

				foreach (var shipmentLineItems in allShipmentContainsLineItem)
				{
					//Decrease qty in all shipment contains line item
					var shipmentQty = shipmentLineItems.Quantity;
					var newShipmentQty = shipmentQty - delta;
					newShipmentQty = newShipmentQty > 0 ? newShipmentQty : 0;
					//Set new line item qty in shipment
					shipmentLineItems.Quantity = newShipmentQty;
					delta -= Math.Min(delta, shipmentQty);

					if (delta == 0)
						break;
				}
			}
		}
コード例 #11
0
		private void DeleteLineItemFromShipments(LineItem lineItem)
		{
			var order = CurrentOrderGroup;
			foreach (var form in order.OrderForms)
			{
				var allShipmentItems = form.Shipments.SelectMany(s => s.ShipmentItems.ToArray()).Where(x => x.LineItem == lineItem);

				foreach (var shipmentLineItem in allShipmentItems)
				{
					shipmentLineItem.Shipment.ShipmentItems.Remove(shipmentLineItem);
				}
			}
		}
コード例 #12
0
		private decimal GetNewLineItemQty(LineItem lineItem, List<string> changeQtyReason, out bool isUsingBackordersAndPreorders)
		{
			isUsingBackordersAndPreorders = false;
			var newLineItemQty = lineItem.Quantity;
			if (newLineItemQty < lineItem.MinQuantity || newLineItemQty > lineItem.MaxQuantity)
			{
				newLineItemQty = Math.Max(lineItem.MinQuantity, newLineItemQty);
				if (newLineItemQty != lineItem.Quantity)
				{
					changeQtyReason.Add("by Min Quantity setting");
				}
				newLineItemQty = Math.Min(lineItem.MaxQuantity, newLineItemQty);
				if (newLineItemQty != lineItem.Quantity)
				{
					changeQtyReason.Add("by Max Quantity setting");
				}
			}

			if (lineItem.InventoryStatus == InventoryStatus.Enabled.ToString())
			{
				// Check Inventory
				// item exists with appropriate quantity
				if (lineItem.InStockQuantity < newLineItemQty)
				{
					if (lineItem.InStockQuantity > 0) // there still exist items in stock
					{
						// check if we can backorder some items
						if (lineItem.AllowBackorders)
						{
							isUsingBackordersAndPreorders = true;
							//Increase stock qty by backorder qty if 
							var availStockAndBackorderQty = lineItem.InStockQuantity + lineItem.BackorderQuantity;
							if (availStockAndBackorderQty < newLineItemQty)
							{
								newLineItemQty = availStockAndBackorderQty;
								changeQtyReason.Add("by BackOrder quantity");
							}
						}
						else
						{
							newLineItemQty = lineItem.InStockQuantity;
						}
					}
					else if (lineItem.InStockQuantity == 0)
					{
						if (lineItem.AllowPreorders && lineItem.PreorderQuantity > 0)
						{
							isUsingBackordersAndPreorders = true;
							if (lineItem.PreorderQuantity < newLineItemQty)
							{
								newLineItemQty = lineItem.PreorderQuantity;
								changeQtyReason.Add("by Preorder quantity");
							}
						}
						else if (lineItem.AllowBackorders && lineItem.BackorderQuantity > 0)
						{
							isUsingBackordersAndPreorders = true;
							if (lineItem.BackorderQuantity < newLineItemQty)
							{
								newLineItemQty = lineItem.BackorderQuantity;
								changeQtyReason.Add("by BackOrder quantity");
							}
						}
						else
						{
							newLineItemQty = 0;
						}
					}
				}
			}
			return newLineItemQty;
		}
コード例 #13
0
        /// <summary>
        /// Gets the line item adjusted quantity.
        /// </summary>
        /// <param name="lineItem">The line item.</param>
        /// <returns></returns>
        private static decimal GetLineItemAdjustedQuantity(LineItem lineItem)
        {
			//Need to find a way to determine if item was added removed or modified
			//Should return positive qty if item was removed, negative if added and exact qty when modified
            var retVal = -lineItem.Quantity;
            return retVal;
        }
コード例 #14
0
        /// <summary>
        /// Adds the specified order group to the existing cart.
        /// </summary>
        /// <param name="orderGroup">The order group.</param>
        /// <param name="lineItemRollup">if set to <c>true</c> [line item rollup].</param>
        /// <exception cref="System.ArgumentNullException">orderGroup</exception>
        public virtual void Add(OrderGroup orderGroup, bool lineItemRollup)
        {
            if (orderGroup == null)
            {
                throw new ArgumentNullException("orderGroup");
            }

            if ((orderGroup.OrderForms != null) && (orderGroup.OrderForms.Count != 0))
            {
                // need to set meta data context before cloning
                foreach (var form in orderGroup.OrderForms)
                {
                    var orderForm = Cart.OrderForms.FirstOrDefault(f => f.Name.Equals(form.Name, StringComparison.OrdinalIgnoreCase));
                    if (orderForm == null)
                    {
                        orderForm = new OrderForm { Name = form.Name };
                        Cart.OrderForms.Add(orderForm);
                    }

                    orderForm.OrderGroupId = Cart.OrderGroupId;
                    orderForm.OrderGroup = Cart;

                    var count = form.LineItems.Count;
                    for (var i = 0; i < count; i++)
                    {
                        var newLineItem = new LineItem();

                        // preserve the new id
                        var id = newLineItem.LineItemId;
                        newLineItem.InjectFrom(form.LineItems[i]);
                        newLineItem.LineItemId = id;

                        Add(orderForm, newLineItem, lineItemRollup);
                    }
                }
            }
        }
コード例 #15
0
        /// <summary>
        /// Populates the inventory information.
        /// </summary>
        /// <param name="inventory">The inventory.</param>
        /// <param name="lineItem">The line item.</param>
		private void PopulateInventoryInfo(Inventory inventory, LineItem lineItem)
		{
			
			if (inventory == null)
			{
				return;
			}

			// Inventory info
			lineItem.AllowBackorders = inventory.AllowBackorder &&
					 inventory.BackorderAvailabilityDate.HasValue &&
					 inventory.BackorderAvailabilityDate.Value <= DateTime.Now;

			lineItem.AllowPreorders = inventory.AllowPreorder &&
								inventory.PreorderAvailabilityDate.HasValue &&
								inventory.PreorderAvailabilityDate.Value <= DateTime.Now;


			//Init quantities once
			lineItem.BackorderQuantity = lineItem.BackorderQuantity == 0 ? inventory.BackorderQuantity : lineItem.BackorderQuantity;
			lineItem.InStockQuantity = lineItem.InStockQuantity == 0 ? inventory.InStockQuantity - inventory.ReservedQuantity : lineItem.InStockQuantity;
			lineItem.PreorderQuantity = lineItem.PreorderQuantity == 0  ? inventory.PreorderQuantity : lineItem.PreorderQuantity;
			lineItem.InventoryStatus = ((InventoryStatus)inventory.Status).ToString();
		}
コード例 #16
0
        /// <summary>
        /// Populates the variation information.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="lineItem">The line item.</param>
	    private void PopulateVariationInfo(Item item, LineItem lineItem)
		{
			if (item == null)
			{
				return;
			}

			lineItem.MaxQuantity = item.MaxQuantity;
			lineItem.MinQuantity = item.MinQuantity;

			var priceListHelper = new PriceListClient(PricelistRepository, CustomerSessionService, PriceListEvaluator, PriceListEvalContext, CacheRepository);

			var itemPrice = priceListHelper.GetLowestPrice(item.ItemId, lineItem.Quantity);

			if (itemPrice == null)
			{
				RemoveLineItem(lineItem);
				return;
			}

			// Get old and new prices for comparison.
			var oldPrice = lineItem.ListPrice;

            // new logic is to have the price always be replaced
            var newPrice = itemPrice.Sale ?? itemPrice.List;

			newPrice = Math.Round(newPrice, 2); // Comparison. The LineItem.ListPrice property rounds values.

			// Get old and new currencies for comparison.
			var oldCurrencyCode = CurrentOrderGroup.BillingCurrency;
			var newCurrencyCode = CustomerSessionService.CustomerSession.Currency;
			if (string.IsNullOrEmpty(oldCurrencyCode))
			{
				oldCurrencyCode = newCurrencyCode;
			}

			// Check for price changes OR currency changes.
			if (oldPrice == newPrice && oldCurrencyCode == newCurrencyCode)
			{
				return;
			}

			// Set new price and currency vales on line item.
			lineItem.ListPrice = newPrice;
            lineItem.PlacedPrice = newPrice;
            lineItem.ExtendedPrice = lineItem.PlacedPrice * lineItem.Quantity;
			CurrentOrderGroup.BillingCurrency = newCurrencyCode;
		}
コード例 #17
0
        /// <summary>
        /// Removes the line item.
        /// </summary>
        /// <param name="lineItem">The line item.</param>
        private void RemoveLineItem(LineItem lineItem)
        {
	        foreach (var form in CurrentOrderGroup.OrderForms.Where(form => form.LineItems.Contains(lineItem)))
	        {
		        form.LineItems.Remove(lineItem);

                foreach (var shipmentLineItem in form.Shipments.SelectMany(s => s.ShipmentItems.ToArray()).Where(x => x.LineItem == lineItem))
                {
                    shipmentLineItem.Shipment.ShipmentItems.Remove(shipmentLineItem);
                }
	        }
        }
コード例 #18
0
        /// <summary>
        /// Removes the specified line item.
        /// </summary>
        /// <param name="lineItem">The line item.</param>
        public virtual void Remove(LineItem lineItem)
        {
            //We must also remove shipmentItems that are not used when item is removed
            foreach (var shipmentItem in lineItem.OrderForm.Shipments.SelectMany(s => s.ShipmentItems)
                                                 .Where(si => si.LineItemId == lineItem.LineItemId).ToList())
            {
                shipmentItem.Shipment.ShipmentItems.Remove(shipmentItem);
                OrderRepository.Remove(shipmentItem);
            }

            lineItem.OrderForm.LineItems.Remove(lineItem);
            OrderRepository.Remove(lineItem);
        }
コード例 #19
0
		public LineItem[] GenerateLineItemsConstant()
		{
			var retVal = new List<LineItem>();

			var items = new[]{ 
                new { Name = "Apple 30 GB iPod with Video Playback Black (5th Generation)", Price = 100m, Quantity = 1 },
                new { Name = "Sony MDR-IF240RK Wireless Headphone System", Price = 10.11m, Quantity = 8 },
                new { Name = "Samsung DVD-HD841 Up-Converting DVD Player", Price = 1000m, Quantity = 3 },
                new { Name = "Apple QuickTake 200 - Digital camera - compact - 0.35 Mpix - supported memory: SM", Price = 250m, Quantity = 2 },
                new { Name = "Samsung YP-T9JAB 4 GB Digital Multimedia Player (Black)", Price = 340m, Quantity = 1 },
                new { Name = "EFC-1B1NBECXAR Carrying Case for 10.1", Price = 222m, Quantity = 6 },
                new { Name = "Sony SGPFLS1 Tablet S LCD Protection Sheet", Price = 3422m, Quantity = 2 }
            };

			for (var i = 0; i < items.Count(); i++)
			{
				var lineItem = new LineItem { DisplayName = items[i].Name, Quantity = items[i].Quantity, ListPrice = items[i].Price };
				lineItem.PlacedPrice = lineItem.ListPrice;
				lineItem.ExtendedPrice = lineItem.PlacedPrice * items[i].Quantity;
				lineItem.CatalogItemId = "v-b0000u9h40";
				lineItem.CatalogItemCode = "v-b0000u9h40";

				retVal.Add(lineItem);
			}
			return retVal.ToArray();
		}
コード例 #20
0
        /// <summary>
        /// Creates the line item.
        /// </summary>
        /// <param name="item">The entry.</param>
        /// <param name="parent">Parent item</param>
        /// <param name="quantity">The quantity.</param>
        /// <returns>LineItem.</returns>
        private LineItem CreateLineItem(Item item, Item parent, decimal quantity)
        {
            var lineItem = new LineItem();

            if (parent != null)
            {
                lineItem.DisplayName = item.DisplayName(String.Format("{0}: {1}", parent.Name, item.Name));
                lineItem.ParentCatalogItemId = parent.ItemId;

                //Build options
                var relations = CatalogClient.GetItemRelations(parent.ItemId);

                var relationGroups = relations.Select(rel => rel.GroupName).Distinct();
                foreach (var prop in item.ItemPropertyValues.LocalizedProperties().Where(p => relationGroups.Contains(p.Name)))
                {
                    var option = new LineItemOption
                        {
                            LineItemId = item.ItemId,
                            OptionName = prop.Name,
                            OptionValue = prop.ToString()
                        };
                    lineItem.Options.Add(option);
                }
            }
            else
            {
                lineItem.DisplayName = item.DisplayName();
                lineItem.ParentCatalogItemId = String.Empty;
            }

            lineItem.CatalogItemId = item.ItemId;
            lineItem.CatalogItemCode = item.Code;
            var price = PriceListClient.GetLowestPrice(item.ItemId, quantity, false);

            if (price != null)
            {
                lineItem.ListPrice = price.Sale ?? price.List;
                lineItem.PlacedPrice = price.Sale ?? price.List;
                lineItem.ExtendedPrice = lineItem.PlacedPrice * quantity;
            }

            lineItem.MaxQuantity = item.MaxQuantity;
            lineItem.MinQuantity = item.MinQuantity;
            lineItem.Quantity = quantity;
            lineItem.Weight = item.Weight;
            lineItem.Catalog = CustomerSession.CatalogId;
            lineItem.FulfillmentCenterId = StoreHelper.StoreClient.GetCurrentStore().FulfillmentCenterId;
            //lineItem.CatalogOutline = CatalogOutlineBuilder.BuildCategoryOutline(CatalogClient.CatalogRepository, CustomerSession.CatalogId, item);
            lineItem.CatalogOutline = CatalogOutlineBuilder.BuildCategoryOutline(CustomerSessionService.CustomerSession.CatalogId, item.ItemId).ToString();

            return lineItem;
        }
コード例 #21
0
        private static bool AdjustStockInventoryQuantity(LineItem lineItem, Inventory inventory)
        {
            var delta = GetLineItemAdjustedQuantity(lineItem);

			var allowBackorder = inventory.AllowBackorder && 
				inventory.BackorderAvailabilityDate.HasValue && 
				inventory.BackorderAvailabilityDate.Value <= DateTime.Now;

			var allowPreorder = inventory.AllowPreorder &&
				inventory.PreorderAvailabilityDate.HasValue &&
				inventory.PreorderAvailabilityDate.Value <= DateTime.Now;

	        var inventoryAdjusted = false;

            //arrival
            if (delta > 0)
            {
                // need distribute delta between InStock, Backorder, Preorder.
                if (lineItem.InStockQuantity > 0)
                {                                 
	                var inStock = delta;

	                if (allowPreorder)
	                {
						var preorderdelta = Math.Min(delta, lineItem.PreorderQuantity - inventory.PreorderQuantity);
		                inventory.PreorderQuantity += preorderdelta;
						inStock -= preorderdelta;
	                }
	                if (allowBackorder)
	                {
						var backorderDelta = Math.Min(delta, lineItem.BackorderQuantity - inventory.BackorderQuantity);
		                inventory.BackorderQuantity += backorderDelta;
		                inStock -= backorderDelta;
	                }
					inventory.InStockQuantity += inStock;
					inventoryAdjusted = true;
                } //need distribute delta between Preorder and Backorder
                else if (lineItem.InStockQuantity == 0)
                {
                    if (lineItem.PreorderQuantity > 0 && allowPreorder)
                    {
                        inventory.PreorderQuantity += delta;
						inventoryAdjusted = true;
                    }
                    else if (lineItem.BackorderQuantity > 0 && allowBackorder)
                    {
                        inventory.BackorderQuantity += delta;
						inventoryAdjusted = true;
                    }
                }
            }//consumption
            else
            {
                delta = Math.Abs(delta);
                var instock = inventory.InStockQuantity - inventory.ReservedQuantity;
                if (instock >= delta) // Adjust the main inventory
                {
                    inventory.InStockQuantity -= delta;
					inventoryAdjusted = true;
                }
                else if (instock > 0) // there still exist items in stock
                {
	                if (allowBackorder)
	                {
		                // Calculate difference between currently available and backorder
		                var backorderDelta = delta - instock;

		                if (inventory.BackorderQuantity >= backorderDelta)
		                {
			                // Update inventory
			                inventory.InStockQuantity -= instock;
			                inventory.BackorderQuantity -= backorderDelta;
							inventoryAdjusted = true;
		                }
	                }
                }
                else if (instock == 0)
                {
					if (allowBackorder && inventory.BackorderQuantity >= delta)
					{
						inventory.BackorderQuantity -= delta;
						inventoryAdjusted = true;
					}
					else if (allowPreorder && inventory.PreorderQuantity >= delta)
					{
						inventory.PreorderQuantity -= delta;
						inventoryAdjusted = true;
					}
                }
            }

			return inventoryAdjusted;
        }
コード例 #22
0
        /// <summary>
        /// Adds the specified form.
        /// </summary>
        /// <param name="form">The form.</param>
        /// <param name="value">The value.</param>
        /// <param name="lineItemRollup">if set to <c>true</c> [line item rollup].</param>
        /// <returns>System.Int32.</returns>
        /// <exception cref="System.ArgumentNullException">value</exception>
        public virtual int Add(OrderForm form, LineItem value, bool lineItemRollup)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            LineItem existingItem = null;

            foreach (var item in form.LineItems)
            {
                if (ReferenceEquals(value, item))
                {
                    return form.LineItems.IndexOf(value);
                }

                if (item.CatalogItemId == value.CatalogItemId)
                {
                    existingItem = item;
                    break;
                }
            }

            if (lineItemRollup && (existingItem != null))
            {
                existingItem.Quantity += value.Quantity;
                return form.LineItems.IndexOf(existingItem);
            }
            value.OrderFormId = form.OrderFormId;
            value.OrderForm = form;
            form.LineItems.Add(value);
            return form.LineItems.IndexOf(value);
        }
コード例 #23
0
		public LineItem[] GenerateLineItems(int count)
		{
			var retVal = new List<LineItem>();

			var names = new[] { "Apple 30 GB iPod with Video Playback Black (5th Generation)",
									   "Sony MDR-IF240RK Wireless Headphone System",
									   "Samsung DVD-HD841 Up-Converting DVD Player", 
									   "Apple QuickTake 200 - Digital camera - compact - 0.35 Mpix - supported memory: SM", 
									   "Samsung YP-T9JAB 4 GB Digital Multimedia Player (Black)", 
									   "EFC-1B1NBECXAR Carrying Case for 10.1", 
										"Sony SGPFLS1 Tablet S LCD Protection Sheet", 
										"Galaxy Tab 8.9 3G Android Honeycomb Tablet (16GB, 850/1900 3G)",
										"Samsung Galaxy Tab Gt-p7500 16gb, Wi-fi + 3g Unlocked"};
			var codes = new[] { "v-0239432c",
									   "MDR-IF240RK",
									   "DVD-HD841", 
									   "v-b12223cc2", 
									   "YP-T9JAB0012", 
									   "EFC-1B1NBECXAR", 
										"v-bc22234088d", 
										"v-2112393vd0",
										"v-b85699233c"};

			var rnd = new Random();
			for (var i = 0; i < count; i++)
			{
				var lineItem = new LineItem();
				var index = rnd.Next(names.Length);

				lineItem.DisplayName = names[index];
				lineItem.Quantity = 1 + rnd.Next(19);
				lineItem.ListPrice = rnd.Next(200);
				lineItem.PlacedPrice = lineItem.ListPrice;
				lineItem.CatalogItemCode = codes[index];
				lineItem.CatalogItemId = codes[index];

				retVal.Add(lineItem);
			}
			return retVal.ToArray();
		}