Example #1
0
        public OrderLineItem CreateLineItem(Guid productId, decimal quantity, decimal value, string description, int lineItemSuquenceNo, decimal lineItemVatValue, OrderLineItemType lineItemType, decimal productDiscount, DiscountType discountType)
        {
            Product product = _productRepository.GetById(productId);
            var li = DocumentLineItemPrivateConstruct<OrderLineItem>(Guid.NewGuid());
            li.Product = product;
            li.Qty = quantity;
            li.Value = value;
            li.Description = description;
            li.LineItemSequenceNo = lineItemSuquenceNo;
            li.LineItemVatValue = lineItemVatValue;
            li.LineItemType = lineItemType;
            li.ProductDiscount = productDiscount;
            li.DiscountType = discountType;

            return li;
        }
        public void AddLineItem(Guid productId, string productDesc, decimal unitPrice, decimal vatValue,
                                decimal vatAmount, decimal qty,
                                decimal totalPrice, bool sellInBulk, bool isEditable, Guid lineItemId,
                                Guid parentProductId, OrderLineItemType orderLineItemType, DiscountType discounType,
                                decimal productDiscount, string productType = "")
        {
            using(StructureMap.IContainer cont = NestedContainer)
            {
                if (loadingFromDb)
                {
                    ReceiveReturnable = unitPrice < 0;
                }
                //are we receiving returnables ...
                if (!loadingFromDb)
                {
                    if (ReceiveReturnable)
                    {
                        vatAmount = -vatAmount;
                        totalPrice = -totalPrice;
                        vatValue = -vatValue;
                    }
                }

                int sequenceNo = 1;
                if (LineItems.Count > 0)
                {
                    sequenceNo = LineItems.Max(n => n.SequenceNo) + 1;
                }

                bool isReturnableProduct = false;
                if (!LoadForViewing)
                {
                    isReturnableProduct = Using<IProductRepository>(cont).GetById(productId).GetType() ==
                                          typeof (ReturnableProduct);
                }

                //Check the line item exists by product
                EditPOSSaleLineItem li = null;
                if (ReceiveReturnable)
                {
                    if (LineItems.Any(n => n.ProductId == productId && n.IsReceivedReturnable == true))
                    {
                        li = LineItems.FirstOrDefault(n => n.ProductId == productId && n.IsReceivedReturnable == true);
                    }
                }
                else
                {
                    if (
                        LineItems.Any(
                            n =>
                            n.ProductId == productId && !n.IsReceivedReturnable &&
                            n.OrderLineItemType == orderLineItemType))
                    {
                        li =
                            LineItems.FirstOrDefault(
                                n =>
                                n.ProductId == productId && !n.IsReceivedReturnable &&
                                n.OrderLineItemType == orderLineItemType);
                    }
                }

                //if found update it
                if (li != null)
                {
                    li.Qty += qty;
                    li.VatAmount += vatAmount;
                    li.LineItemVatValue += vatValue;
                    li.TotalPrice += totalPrice;
                    li.ProductDiscount = productDiscount;
                    li.LineItemTotalProductDiscount += (productDiscount*qty);
                }
                else
                {
                    li = new EditPOSSaleLineItem(Using<IOtherUtilities>(cont))
                             {
                                 SequenceNo = sequenceNo,
                                 ProductId = productId,
                                 Product = productDesc,
                                 UnitPrice = unitPrice < 0 ? -unitPrice : unitPrice,
                                 //display +ve value for received returnables
                                 LineItemVatValue = vatValue,
                                 VatAmount = vatAmount,
                                 Qty = qty,
                                 TotalPrice = totalPrice,
                                 LineItemId = (Guid) lineItemId,
                                 IsReceivedReturnable = ReceiveReturnable,
                                 CanEditLineItem = true,
                                 CanRemoveLineItem = true,
                                 ProductType = productType,
                                 OrderLineItemType = orderLineItemType,
                                 LineItemDiscountType = discounType,
                                 ProductDiscount = productDiscount,
                                 LineItemTotalProductDiscount = (productDiscount*qty),
                             };
                    if (li.OrderLineItemType == OrderLineItemType.Discount)
                    {
                        li.CanEditLineItem = false;
                        li.CanRemoveLineItem = false;
                    }

                    if (!ReceiveReturnable)
                    {
                        if (isReturnableProduct && li.TotalPrice >= 0) li.CanEditLineItem = false;
                        if (isReturnableProduct && li.TotalPrice >= 0) li.CanRemoveLineItem = false;

                        if (li.LineItemDiscountType == DiscountType.FreeOfChargeDiscount)
                        {
                            li.CanEditLineItem = true;
                            li.CanRemoveLineItem = true;
                        }
                    }

                    if (Status != "New")
                    {
                        li.CanEditLineItem = false;
                        li.CanRemoveLineItem = false;
                    }
                    LineItems.Add(li);
                }
                CalcTotals();
            }
        }
        public void AddLineItem(Guid productId, string productDesc, decimal unitPrice, decimal vatValue,
                                decimal vatAmount, decimal qty, decimal totalPrice, bool isEditable, string liProdType,
                                Guid lineItemID, decimal productDiscount, OrderLineItemType orderLineItemType,
                                DiscountType discountType)
        {
            using (var container = NestedContainer)
            {
                IConfigService _configService = Using<IConfigService>(container);
                var _inventoryService = Using<IInventoryRepository>(container);
                IProductRepository _productService = Using<IProductRepository>(container);
                IOtherUtilities _otherUtilities = Using<IOtherUtilities>(container);

                ApproveSalesmanOrderItem li = null;
                Inventory availableInv = _inventoryService.GetByProductIdAndWarehouseId(productId, _configService.Load().CostCentreId);
                Product product = null;

                if (liProdType == "ReturnableProduct") //#$@$%#^!!
                {
                    if (availableInv != null)
                        if (availableInv.Balance < 0)
                            availableInv.Balance = 0;
                    product = _productService.GetById(productId);
                }


                int sequenceNo = 1;
                if (LineItems.Count > 0)
                {
                    sequenceNo = LineItems.Max(n => n.SequenceNo) + 1;
                }
                if (!LoadForProcessing)
                    isEditable = false;
                //Check the line item exists by productId and update it ..
                if (LineItems.Any(n => n.ProductId == productId && n.OrderLineItemType == orderLineItemType)) //
                {
                    li = LineItems.FirstOrDefault(n => n.ProductId == productId); //lineItem to update ..
                    if (_order.Status == DocumentStatus.Confirmed ||
                        (_order.Status == DocumentStatus.OrderPendingDispatch && ProcessingBackOrder))
                        // editing at confirm order and at process back order
                    {
                        if (!LoadForViewing)
                        {
                            li.Qty += qty;
                            li.TotalLineItemVatAmount += vatAmount;
                            li.LineItemVatValue = vatValue;
                            li.TotalPrice += totalPrice;
                            li.LineItemTotalProductDiscount += (productDiscount*qty);
                            li.ProcessedQty = (li.Qty - li.BackOrder);
                            li.ProcessedQty = li.ProcessedQty < 0 ? 0 : li.ProcessedQty;
                        }
                    }
                    else if (_order.Status == DocumentStatus.OrderPendingDispatch ||
                             _order.Status == DocumentStatus.OrderDispatchedToPhone ||
                             _order.Status == DocumentStatus.Closed ||
                             _order.Status == DocumentStatus.Cancelled ||
                             _order.Status == DocumentStatus.Rejected)
                        //load awaiting stock etc ...
                    {
                        if (!ProcessingBackOrder)
                        {
                            var item = _order.LineItems.FirstOrDefault(n => n.Id == lineItemID);
                            try
                            {
                                switch (item.LineItemType)
                                {
                                    case OrderLineItemType.BackOrder:
                                        li.BackOrder += qty;
                                        li.ProcessedQty = li.Qty - li.BackOrder;
                                        break;
                                    case OrderLineItemType.LostSale:
                                        li.LostSale = qty;
                                        break;
                                    case OrderLineItemType.ProcessedBackOrder:
                                        li.BackOrder -= qty;
                                        li.ProcessedQty = li.Qty - li.BackOrder;
                                        break;
                                }
                            }
                            catch
                            {
                            }
                        }
                    }
                }
                else
                {
                    #region New LineItem

                    li = new ApproveSalesmanOrderItem(_otherUtilities)
                             {
                                 SequenceNo = sequenceNo,
                                 ProductId = productId,
                                 Product = productDesc,
                                 UnitPrice = unitPrice,
                                 LineItemVatValue = vatValue,
                                 TotalLineItemVatAmount = vatAmount,
                                 Qty = qty,
                                 TotalPrice = totalPrice,
                                 IsEditable = isEditable,
                                 LineItemId = (Guid) lineItemID,
                                 AvailableProductInv = availableInv == null ? 0 : availableInv.Balance,
                                 LiProductType = liProdType,
                                 CanEdit = isEditable,
                                 CanRemove = isEditable,
                                 ProductType = liProdType,
                                 OrderLineItemType = orderLineItemType,
                                 ProductDiscount = productDiscount,
                                 LineItemTotalProductDiscount = productDiscount*qty,
                                 LineItemDiscountType = discountType,
                                 HlnkDeleteContent = GetLocalText("sl.approveOrder.lineItemsGrid.deleteLineItem"),
                             };

                    if (liProdType == "ReturnableProduct") li.CanEdit = false;
                    if (liProdType == "ReturnableProduct") li.CanRemove = false;

                    if (liProdType == "ReturnableProduct" && ((ReturnableProduct) product).Capacity > 1)
                        //cn: containers to be edited independently
                    {
                        li.CanEdit = true;
                        li.CanRemove = true;
                    }

                    //overriding editing determiners!!
                    if (li.OrderLineItemType == OrderLineItemType.Discount)
                    {
                        li.CanEdit = false;
                        li.CanRemove = false;
                    }

                    if (Status != "New" && Status != "Confirmed")
                    {
                        li.CanEdit = false;
                        li.CanRemove = false;
                    }

                    if (LoadForViewing)
                    {
                        li.CanEdit = false;
                        li.CanRemove = false;
                    }
                    LineItems.Add(li);

                    #endregion
                }
                CanProcessBackOrder = li.BackOrder > 0;
                CalcTotals();
            }
        }
        OrderLineItem CreateNewLineItem(Guid lineItemId, ApproveSalesmanOrderItem item, OrderLineItemType orderLineItemType = OrderLineItemType.PostConfirmation)
        {
            using (var container = NestedContainer)
            {
                IProductRepository _productService = Using<IProductRepository>(container);
               

                lineItemId = lineItemId == Guid.Empty ? Guid.NewGuid() : lineItemId;
                var oli = new OrderLineItem(lineItemId)
                              {
                                  Description = item.Product,
                                  Product = _productService.GetById(item.ProductId),
                                  Qty = item.Qty,
                                  IsNew = true,
                                  LineItemSequenceNo = item.SequenceNo
                              };
                oli.Value = item.UnitPrice;
                oli.LineItemVatValue = item.LineItemVatValue;
                oli.LineItemType = orderLineItemType;
                oli.ProductDiscount = item.ProductDiscount;
                oli.LineItemType = orderLineItemType;
                oli.DiscountType = item.LineItemDiscountType;

                return oli;
            }
        }
        private List<OrderLineItem> AddLineItem(List<OrderLineItem> items, Guid productId, decimal qty, decimal vat, decimal unitprice, decimal productDiscout, OrderLineItemType type, DiscountType discointType)
        {
            items.Add(new OrderLineItem(Guid.NewGuid())
            {
                Product = _productRepository.GetById(productId),
                LineItemSequenceNo = 1,
                Qty = qty,// orderLineItemsViewModel.quantity,
                LineItemVatValue = vat,//vatClass != null ? vatClass.CurrentRate : 0,// orderLineItemsViewModel.LineItemVatTotal,
                Value = unitprice,//pricingTier!=null?item.Product.ProductPrice(pricingTier):0,// orderLineItemsViewModel.LineItemTotal,
                ProductDiscount = productDiscout,
                LineItemType = type,
                DiscountType = discointType,
            });
            return items;

        }