コード例 #1
0
        /// <summary>
        /// Converts a List<Items> (shopping basket) to List of orderLines
        /// Ensures each item only listed once and allocates appropriate quantity.
        /// </summary>
        private List <OrderLines> ConvertToOrderLines(List <Items> basketObj)
        {
            List <OrderLines> orderLines = new List <OrderLines>();


            foreach (var item in basketObj)
            {
                OrderLines tempOrderLine     = new OrderLines(item);
                bool       itemAlreadyInList = false;

                if (orderLines.Count == 0)
                {
                    orderLines.Add(tempOrderLine);
                }
                else
                {
                    foreach (var ol in orderLines)
                    {
                        if (ol.ItemId == item.ItemId)
                        {
                            ol.Quantity++;
                            itemAlreadyInList = true;
                        }
                    }
                    if (!itemAlreadyInList)
                    {
                        orderLines.Add(new OrderLines(item));
                    }
                }
            }

            return(orderLines);
        }
        public bool CanPlaceOrder(decimal expectedTotalCost, decimal expectedShippingCost)
        {
            //An order must have at least one line
            if (!OrderLines.Any())
            {
                return(false);
            }

            //All products must be available to order
            foreach (var line in OrderLines)
            {
                if (!_productAvailabilityService.CheckProductAvailability(line.Product.Stockcode, line.Quantity))
                {
                    return(false);
                }
            }

            //The calculated costs must match the expected ones
            CalculateShippingCost();
            CalculateTotalCost();
            if (TotalCost != expectedTotalCost || ShippingCost != expectedShippingCost)
            {
                return(false);
            }

            //if all checks succeeded, return true
            return(true);
        }
コード例 #3
0
 /// <summary>
 /// Removes orderline from the current order
 /// </summary>
 /// <param name="orderLine"></param>
 public void RemoveOrderLine(OrderLine orderLine)
 {
     if (CanOrderBeChanged())
     {
         OrderLines.Remove(orderLine);
     }
 }
コード例 #4
0
        public int checkout(ShoppingCart cart)
        {
            var db = new DatabaseContext();

            var newOrder = new Orders()
            {
                OrderDate   = DateTime.Now,
                CustomersId = cart.userID
            };

            db.Orders.Add(newOrder);
            db.SaveChanges();


            foreach (var item in cart.shoppingCartItems)
            {
                var newItem = new OrderLines()
                {
                    ProductsId = item.product.itemnumber,
                    OrdersId   = newOrder.Id,
                    Quantity   = item.quantity
                };
                db.OrderLines.Add(newItem);
            }
            db.SaveChanges();

            return(newOrder.Id);
        }
コード例 #5
0
        public void Validate()
        {
            if (string.IsNullOrWhiteSpace(OrderNumber))
            {
                throw new ValidationErrorException(nameof(OrderNumber));
            }
            if (TotalValue < 0)
            {
                throw new ValidationErrorException(nameof(TotalValue));
            }
            if (Customer == null)
            {
                throw new ValidationErrorException(nameof(Customer));
            }
            Customer.Validate();

            if (ShippingAddress == null)
            {
                throw new ValidationErrorException(nameof(ShippingAddress));
            }
            ShippingAddress.Validate();

            if (OrderLines == null || !OrderLines.Any())
            {
                throw new ValidationErrorException(nameof(OrderLines));
            }

            OrderLines.ForEach(o => o.Validate());
        }
コード例 #6
0
        public static void Load(OrderLines instance)
        {
            var db = new DefaultConnection();

            foreach (var u in db.OrderLines)
            {
                BaseOrderLine l = null;
                if (u.LineType == "OrderLine")
                {
                    l = addOrderLine(u);
                }
                else if (u.LineType == "TaxOnLine")
                {
                    l = addTaxLine(u);
                }
                else if (u.LineType == "ChargeLine")
                {
                    l = addChargeLine(u);
                }
                if (l == null)
                {
                    continue;
                }
                instance.Add(l);
            }
        }
コード例 #7
0
        public OrderLines Update(OrderLines orderlinesParam)
        {
            var orderline = _db.OrderLines.Find(orderlinesParam.Id);

            if (orderline == null)
            {
                throw new Exception("Product not found");
            }

            if (orderlinesParam.Order != orderline.Order)
            {
                // type has changed so check if the new type is already taken
                if (_db.OrderLines.Any(x => x.Order == orderlinesParam.Order))
                {
                    throw new Exception(orderlinesParam.Order + " is already taken");
                }
            }

            //productTypes.UpdatedBy = User.Identity.Name;
            orderline.UpdatedBy   = "Admin";
            orderline.UpdatedDate = DateTime.Now;
            orderline.Price       = orderlinesParam.Price;
            orderline.OrderIdFk   = orderlinesParam.OrderIdFk;
            orderline.Quantity    = orderlinesParam.Quantity;
            orderline.ProductIdFk = orderlinesParam.ProductIdFk;
            orderline.TotalPrice  = orderlinesParam.TotalPrice;
            orderline.IsActive    = orderlinesParam.IsActive;


            _db.OrderLines.Update(orderline);
            _db.SaveChanges();

            return(orderline);
        }
コード例 #8
0
        /// <summary>
        /// Get orderlines by order iD
        /// </summary>
        /// <param name="orderId"></param>
        /// <returns></returns>
        public List <OrderLines> GetLinesByOrderId(int orderId)
        {
            List <OrderLines> aLine = new List <OrderLines>();

            try
            {
                OracleCommand commn = dataConnection.ConnectToDatabase();
                commn.CommandText = "select o.orderlineid, p.productId, p.productname, o.quantity, o.UNITPRICE from product p inner join orderline o " +
                                    "on p.productid = o.productid where o.orderid=" + orderId;
                OracleDataReader odr = commn.ExecuteReader();
                while (odr.Read())
                {
                    OrderLines odrLine = new OrderLines();
                    odrLine.OrderLineId = odr.GetInt32(0);
                    odrLine.OrderId     = orderId;
                    odrLine.ProductId   = odr.GetInt32(1);
                    Product aProduct = new Product();
                    aProduct.ProductId   = odr.GetInt32(1);
                    aProduct.ProductName = odr.GetString(2);
                    odrLine.Quantity     = odr.GetInt32(3);
                    odrLine.UnitPrice    = odr.GetFloat(4);
                    odrLine.ProductInfo  = aProduct;
                    aLine.Add(odrLine);
                }
                dataConnection.CloseDatabase();
            }
            catch (Exception e)
            { }
            finally { dataConnection.CloseDatabase(); }
            return(aLine);
        }
コード例 #9
0
        // /OrderLines/Change [POST]
        public ActionResult Change([FromBody] OrderLines orderLines)
        {
            OrderLines orderLines2 = db.OrderLines.Find(orderLines.Id);

            if (orderLines2 == null)
            {
                return(Json(new JsonMessage("Failure", "Record that needs to be changed has been deleted"), JsonRequestBehavior.AllowGet));
            }
            orderLines2.OrderId   = orderLines.OrderId;
            orderLines2.LineNbr   = orderLines.LineNbr;
            orderLines2.Product   = orderLines.Product;
            orderLines2.Price     = orderLines.Price;
            orderLines2.Quantity  = orderLines.Quantity;
            orderLines2.LineTotal = orderLines.LineTotal;

            try
            {
                db.SaveChanges();
            }
            catch (Exception ex)
            {
                return(Json(new JsonMessage("Failure", ex.Message), JsonRequestBehavior.AllowGet));
            }
            return(Json(new JsonMessage("Success", "Order Lines was updated")));
        }
コード例 #10
0
        public OrderLines UpdateOrderLines(OrderLines orderLines)
        {
            if (orderLines != null)
            {
                OrderLines orderLinesUpd = _DbModelEntities.OrderLines.FirstOrDefault(p => p.OrderLineID.Equals(orderLines.OrderLineID));
                if (orderLinesUpd != null)
                {
                    orderLinesUpd.Description    = orderLines.Description;
                    orderLinesUpd.PackageTypeID  = orderLines.PackageTypeID;
                    orderLinesUpd.Quantity       = orderLines.Quantity;
                    orderLinesUpd.UnitPrice      = orderLines.UnitPrice;
                    orderLinesUpd.TaxRate        = orderLines.TaxRate;
                    orderLinesUpd.PickedQuantity = orderLines.PickedQuantity;
                }
                else
                {
                    return(null);
                }

                _DbModelEntities.SaveChanges();

                return(orderLinesUpd);
            }

            return(null);
        }
コード例 #11
0
ファイル: Order.cs プロジェクト: pilotbe2man/sutekishop
        public virtual void AddLine(string productName, int quantity, Money price, string productUrlName, int productId, string sizeName)
        {
            if (productName == null)
            {
                throw new ArgumentNullException("productName");
            }
            if (quantity == 0)
            {
                throw new ArgumentException("quantity can not be zero");
            }
            if (productUrlName == null)
            {
                throw new ArgumentNullException("productUrlName");
            }
            if (sizeName == null)
            {
                throw new ArgumentNullException("sizeName");
            }

            var orderLine = new OrderLine
            {
                ProductName    = productName,
                Quantity       = quantity,
                Price          = price,
                Order          = this,
                ProductUrlName = productUrlName,
                ProductId      = productId,
                SizeName       = sizeName
            };

            OrderLines.Add(orderLine);
        }
コード例 #12
0
 public void AddOrderLine(Product p)
 {
     OrderLines.Add(new OrderLineViewModel(p));
     UpdateTotal();
     //refresh the commands
     RaisePropertyChanged(nameof(OnCancelCommand));
     RaisePropertyChanged(nameof(OnOrderCommand));
 }
 /// <summary>
 /// Adds the product.
 /// </summary>
 /// <param name="product">The product.</param>
 /// <param name="quantity">The quantity.</param>
 /// <param name="discount">The discount.</param>
 public void AddProduct(Product product, int quantity, decimal discount = 0)
 {
     if (OrderLines == null)
     {
         OrderLines = new List <OrderLine>();
     }
     OrderLines.Add(new OrderLine(this, product, quantity, discount));
 }
コード例 #14
0
        /// <summary>
        /// Obtenemos un registro por su ID de la tabla OrderLines
        /// </summary>
        /// <param name="OrderLineID"></param>
        /// <returns></returns>
        public OrderLines GetOrderLinesById(int orderLineID)
        {
            OrderLines orderLines = new OrderLines();

            orderLines = _DbModelEntities.OrderLines.FirstOrDefault(p => p.OrderLineID.Equals(orderLineID));

            return(orderLines);
        }
コード例 #15
0
 public void AddProduct(Products product, int quantity)
 {
     if (OrderLines == null)
     {
         OrderLines = new List <OrderLine>();
     }
     OrderLines.Add(new OrderLine(this, product, quantity));
 }
コード例 #16
0
        private void CalculateSubtotalPrice()
        {
            OrderLines.ForEach(line => line.CalculatePrice());
            var subtotal = OrderLines
                           .Aggregate(0.0, (i, line) => i + line.Price);

            SubtotalPrice = Math.Round(subtotal, 2);
        }
コード例 #17
0
        public void CleanUpOrderLines()
        {
            List <DisplayOrderLine> LinesToRemove = OrderLines.Where(ol => ol.Amount <= 0).ToList();

            foreach (DisplayOrderLine orderLine in LinesToRemove)
            {
                OrderLines.Remove(orderLine);
            }
        }
コード例 #18
0
 public void When_DeliverOrderCancelled_ThrowOrderCancelledException()
 {
     Given(
         new OrderCreated(id, basketId, shippingAddress),
         new OrderLineAdded(id, OrderLines.First()),
         new OrderReadyForShipping(id),
         new OrderCancelled(id));
     WhenThrows <DeliverOrder, InvalidOrderStateException>(new DeliverOrder(id));
 }
コード例 #19
0
ファイル: Order.cs プロジェクト: MarkusMokler/photomsmsk-by
 public void Add(Event newevent)
 {
     OrderLines = OrderLines ?? new List <OrderLine>();
     OrderLines.Add(new EventOrderLine(newevent)
     {
         ID = Guid.NewGuid()
     });
     Total += newevent.Price;
 }
コード例 #20
0
        public void addNewOrderLine(OrderLines orderLine)
        {
            using (var connection = new SqlConnection(ConnectionString))
            {
                connection.Open();

                connection.Execute(@"insert into OrderLines(OrderId, ProductId) values (@OrderId,@ProductId)", orderLine);
            }
        }
コード例 #21
0
 public OrderLines Create(OrderLines orderlines)
 {
     orderlines.CreatedBy   = "Admin";
     orderlines.CreatedDate = DateTime.Now;
     orderlines.IsActive    = true;
     _db.OrderLines.Add(orderlines);
     _db.SaveChanges();
     return(orderlines);
 }
コード例 #22
0
ファイル: Order.cs プロジェクト: adobski/blueprism
        public void AddOrderLine(OrderLine orderLine)
        {
            OrderLines.Add(orderLine);

            Status = OrderStatus.SelectingProducts;

            DefaultPrice += orderLine.TotalDefaultCost;
            ActualPrice  += orderLine.TotalActualCost;
        }
コード例 #23
0
ファイル: Order.cs プロジェクト: adobski/blueprism
        public void RemoveOrderLine(OrderLine orderLine)
        {
            var itemToRemove = OrderLines.Single(o => o.Id == orderLine.Id);

            DefaultPrice -= orderLine.TotalDefaultCost;
            ActualPrice  -= orderLine.TotalActualCost;

            OrderLines.Remove(itemToRemove);
        }
コード例 #24
0
ファイル: Order.cs プロジェクト: thekokii/MvcWebshop
 public void CartToOrder(ICollection <CartLine> cartLines)
 {
     foreach (var item in cartLines)
     {
         OrderLines.Add(new OrderLine {
             Product = item.Product, Quantity = item.Quantity
         });
     }
 }
コード例 #25
0
        public void MakeOrder(IEnumerable <CartItem> items, OrderDetails ord)
        {
            var orderDto = new Orders();


            PropertyCopier <OrderDetails, Orders> .Copy(ord, orderDto);

            using (var connection = new MySqlConnection(_connectionString))
            {
                connection.Open();
                using (var transaction = connection.BeginTransaction())
                {
                    try
                    {
                        var orderId = InsertOrder(orderDto, connection, transaction);

                        foreach (var cartItem in items)
                        {
                            var orderLineFoodItemDto = new OrderLines();
                            PropertyCopier <CartItem, OrderLines> .Copy(cartItem, orderLineFoodItemDto);

                            orderLineFoodItemDto.OrderId = orderId;

                            for (int i = 0; i < cartItem.Quantity; i++)
                            {
                                var parentId = InsertOrder(orderLineFoodItemDto, connection, transaction);

                                foreach (var cartItemIngredient in cartItem.Ingredients)
                                {
                                    var orderLineIngredientDto = new OrderLines();
                                    PropertyCopier <CartItemIngredient, OrderLines> .Copy(cartItemIngredient, orderLineIngredientDto);

                                    orderLineIngredientDto.OrderId  = orderId;
                                    orderLineIngredientDto.ParentId = parentId;

                                    InsertOrder(orderLineIngredientDto, connection, transaction);
                                }
                            }
                        }


                        transaction.Commit();
                    }
                    catch (Exception)
                    {
                        transaction.Rollback();

                        throw;
                    }
                    finally
                    {
                        connection.Close();
                    }
                }
            }
        }
コード例 #26
0
        /// <summary>
        /// Creates a new order line for the provided item in the order header.
        /// </summary>
        /// <param name="itemToAdd"></param>
        public void CreateOrderLineForItem(Item itemToAdd)
        {
            OrderLine orderLine = new OrderLine()
            {
                Item = itemToAdd,
                Qty  = 1
            };

            OrderLines.Add(orderLine);
        }
コード例 #27
0
        public async Task <OrderLines> AddAsyncOrderLine(OrderLines entity)
        {
            if (entity != null)
            {
                _dbContext.OrderLines.Add(entity);
                await _dbContext.SaveChangesAsync();
            }

            return(entity);
        }
コード例 #28
0
        public Order AddOrderLine(Guid itemId, int quantity, Money price)
        {
            if (OrderLines == null)
            {
                OrderLines = new List <OrderLine>();
            }

            OrderLines.Add(new OrderLine(itemId, quantity, price));
            return(this);
        }
コード例 #29
0
 public override Model.Order ToModel()
 {
     return(new Model.BreadOrder()
     {
         Id = Id,
         CustomerName = CustomerName,
         CustomerAddress = CustomerAddress,
         OrderLines = OrderLines.Select(o => o.ToModel()).ToList()
     });
 }
コード例 #30
0
        public OrderViewModel(IFormatProvider currencyFormat, PurchaseOrderModel order)
            : this(currencyFormat)
        {
            OrderNumber = order.TrackingNumber;
            OrderDate   = order.Created;
            Status      = order.Status;

            TotalLineItemsAmount = order.OrderForms.First().LineItems.Sum(i => i.ExtendedPrice);
            TotalAmount          = order.Total;
            Shipping             = order.ShippingTotal;

            // TODO: Make taxes work as it should, instead of flat hard codet 25% tax
            if (order.TaxTotal == 0 && order.Total > 0)
            {
                order.TaxTotal = ((decimal)0.25) * order.Total;
            }
            Tax = order.TaxTotal;


            Discount = order.OrderForms.First().LineItems.Sum(i => i.LineItemDiscountAmount + i.OrderLevelDiscountAmount) + order.OrderForms.First().Shipments.First().ShippingDiscountAmount;
            if (order.OrderForms.Any() && order.OrderForms.First().Payments.Any())
            {
                PaymentMethod = order.OrderForms.First().Payments.First().PaymentMethodName;
            }

            Email          = order.BillingEmail;
            Phone          = order.BillingPhone;
            BillingAddress = new Address(order.OrderAddresses.FirstOrDefault(a => a.Name == Constants.Order.BillingAddressName));
            var shippingAddress = order.OrderAddresses.FirstOrDefault(a => a.Name == Constants.Order.ShippingAddressName);
            ShippingAddress  = new Address(shippingAddress);
            DeliveryLocation = "";
            if (shippingAddress != null && !string.IsNullOrWhiteSpace(shippingAddress.DeliveryServicePoint))
            {
                DeliveryLocation = shippingAddress.DeliveryServicePoint;
            }

            foreach (var item in order.OrderForms.First().LineItems)
            {
                OrderLines.Add(new OrderLineViewModel(item));
            }

            // discounts
            var discounts = CartService.GetAllDiscounts(order);
            DiscountCodes = discounts.Where(x => !string.IsNullOrEmpty(x.DiscountCode)).Select(x => x.DiscountCode).ToList();

            ShippingTrackingNumber = "";
            if (order.OrderForms.Any() &&
                order.OrderForms.First().Shipments != null &&
                order.OrderForms.First().Shipments.Any())
            {
                ShippingTrackingNumber = order.OrderForms.First().Shipments.First().ShipmentTrackingNumber;
            }

            ErpOrderNumber = order.BackendOrderNumber;
        }
コード例 #31
0
ファイル: Order.cs プロジェクト: thibautdavid/netpatterns
 public Order()
 {
     orderLines = new OrderLines();
 }