Beispiel #1
0
        public ActionResult Edit([Bind(Include = "Id,ProductId,OrderedAmount,AvailabeAmount,DeliveredAmount,AcceptedAmount,Comment,OrderId")] OrderProduct updated)
        {
            if (updated.AcceptedAmount > updated.DeliveredAmount)
            {
                ModelState.AddModelError("AcceptedAmount", "Mottaget antal är större än leveransantal.");
            }
            if (updated.AcceptedAmount < 0)
            {
                ModelState.AddModelError("AcceptedAmount", "Mottaget antal är mindre än 0.");
            }
            if (ModelState.IsValid)
            {
                orderProductRepo.UpdateItem(updated);
                var order = orderRepo.GetItem((int)updated.OrderId);
                switch (order.OrderStatus)
                {
                case OrderStatus.Behandlar:
                    return(RedirectToAction("PrepareOrder", "Orders", new { id = updated.OrderId }));

                case OrderStatus.Plockar:
                    return(View());

                case OrderStatus.Fraktar:
                    return(View());

                case OrderStatus.Levererad:
                    return(RedirectToAction("FinalizeDelivery", "Orders", new { id = updated.OrderId }));

                case OrderStatus.Fakturerar:
                    return(View());

                case OrderStatus.Arkiverad:
                    return(View());

                default:
                    return(View());
                }
            }
            ViewBag.OrderId   = new SelectList(orderRepo.GetItems(), "Id", "Id", updated.OrderId);
            ViewBag.ProductId = new SelectList(productRepo.GetItems(), "Id", "Name", updated.ProductId);
            return(View(updated));
        }
Beispiel #2
0
        /// <summary>
        /// Förbereder order med produkterna i en viewmodel innan man går vidare att skapa en plocksedel.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult PrepareOrder(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            var order = orderRepo.GetItem((int)id);

            if (order == null)
            {
                return(HttpNotFound());
            }

            var orderVM = new OrderVM
            {
                Id                  = order.Id,
                OrderDate           = order.OrderDate,
                CustomerId          = order.CustomerId,
                PlannedDeliveryDate = order.PlannedDeliveryDate,
                AddressId           = order.AddressId,
                Comment             = order.Comment
            };

            // Kolla alkolicens
            if (licenseRepo.GetItems().SingleOrDefault(x => x.CustomerId == order.CustomerId && x.StartDate.CompareTo(order.OrderDate) <= 0 && x.EndDate.CompareTo(order.OrderDate) >= 0) == null)
            {
                ModelState.AddModelError("", "Kunden har ingen alkohollicens.");
                orderVM.CannotContinueRegsitration = true;
            }

            var priceList = priceListRepository.GetItems().Where(x => x.CustomerGroupId == order.Customer.CustomerGroupId);

            var orderProductVMs = new List <OrderProductVM>();
            var backOrder       = new Order
            {
                CustomerId          = order.CustomerId,
                AddressId           = order.AddressId,
                Comment             = "*Restorder* " + order.Comment,
                OrderDate           = DateTime.Now.Date,
                DesiredDeliveryDate = order.DesiredDeliveryDate,
                OrderStatus         = OrderStatus.Behandlar,
                OrderProducts       = new List <OrderProduct>()
            };

            // Kolla lagersaldot och försök att reservera.
            foreach (var op in order.OrderProducts)
            {
                // Kolla om produkten säljs.
                if (op.Product.ProductStatus != ProductStatus.Normal)
                {
                    backOrder.OrderProducts.Add(CreateBackOrder(op));
                    continue;
                }

                // Försök att reservera om det går.
                ReserveItem(op);
                // Få fram plockordrar på nytt.
                var pickList = pickingOrderRepo.GetItems().Where(x => x.OrderProductId == op.Id);
                // Ta fram reserverat antal och uppdatera availableAmount
                op.AvailabeAmount = pickList.Sum(x => x.ReservedAmount);
                orderProductRepo.UpdateItem(op);
                // Räkna fram priset.
                float productTotalPrice = 0;
                float unitPrice         = 0;
                var   productPrice      = priceList.SingleOrDefault(x => x.ProductId == op.ProductId);
                if (productPrice == null)
                {
                    ModelState.AddModelError("", $"Kunden har inget pris för {op.Product.ShortDescription}.");
                    orderVM.CannotContinueRegsitration = true;
                }
                else
                {
                    var limit = 0;
                    switch (productPrice.Product.StoragePackage)
                    {
                    case StoragePackage.Back:
                        limit = 384;
                        break;

                    case StoragePackage.Kartong:
                        limit = 240;
                        break;

                    case StoragePackage.Flak:
                        limit = 480;
                        break;
                    }
                    unitPrice         = productPrice.Price * (op.AvailabeAmount > limit ? (1 - productPrice.RebatePerPallet * .01f) : 1);
                    productTotalPrice = op.AvailabeAmount * unitPrice;
                }

                // Om man har lyckats reservera varor i lagret.
                if (op.AvailabeAmount > 0)
                {
                    var opvm = new OrderProductVM
                    {
                        Id             = op.Id,
                        ProductId      = (int)op.ProductId,
                        OrderedAmount  = op.OrderedAmount,
                        AvailabeAmount = op.AvailabeAmount,
                        Price          = productTotalPrice,
                        UnitPrice      = unitPrice,
                        Comment        = op.Comment
                    };
                    orderProductVMs.Add(opvm);

                    // Skapa rest order om lagret inte har tillräckligt många varor.
                    if (op.OrderedAmount > op.AvailabeAmount)
                    {
                        // Sparar undan restorder tills vidare.
                        backOrder.OrderProducts.Add(CreateBackOrder(op));
                        // Uppdatera beställt antal till det reserverade eftersom resten finns på restorder.
                        op.OrderedAmount = op.AvailabeAmount;
                        // Uppdatera databasen.
                        orderProductRepo.UpdateItem(op);
                    }
                }
            }
            orderVM.OrderProducts = orderProductVMs;

            // Jämför kreditgräns.
            var totalPrice = orderProductVMs.Sum(x => x.Price);

            if (order.Customer.CreditLimit != -1 && totalPrice > order.Customer.CreditLimit)
            {
                orderVM.CannotContinueRegsitration = true;
                ModelState.AddModelError("Price", $"Kundens kredigräns är överstigen ({order.Customer.CreditLimit}).");
            }
            orderVM.Price = totalPrice;

            if (totalPrice == 0)
            {
                orderVM.CannotContinueRegsitration = true;
                ModelState.AddModelError("", "Det finns ingen plockorder att skapa.");
            }
            else
            {
                if (backOrder.OrderProducts.Count > 0)
                {
                    orderRepo.CreateItem(backOrder);
                    ModelState.AddModelError("", "Restorder har genererats.");
                }
            }

            return(View(orderVM));
        }