Esempio n. 1
0
        public async Task <ActionResult> ReviewTireStorageOrder()
        {
            if (TempData.ContainsKey("TireStorageOrder"))
            {
                OrderTireStorageModelView pageCreateResult = new OrderTireStorageModelView();
                ClientsOfCarWashView      clientList       = new ClientsOfCarWashView();

                if (TempData.ContainsKey("Client") && TempData.ContainsKey("TireStorageOrder"))
                {
                    pageCreateResult = TempData["TireStorageOrder"] as OrderTireStorageModelView;
                    TempData.Keep("TireStorageOrder");

                    clientList = TempData["Client"] as ClientsOfCarWashView;
                    TempData.Keep("Client");
                }

                OrderTireStorageModelBll tireStorageBll = Mapper.Map <OrderTireStorageModelView, OrderTireStorageModelBll>(pageCreateResult);

                var reviwOrderModules = Mapper.Map <ReviwOrderModelBll, ReviwOrderModelView>(await _reviwOrder.ReviwOrder(tireStorageBll));
                var brigadeForToday   = Mapper.Map <IEnumerable <BrigadeForTodayView> >(await _brigadeForToday.GetDateTimeNow());

                ViewBag.Client         = clientList;
                ViewBag.Adninistrator  = brigadeForToday.Where(x => x.StatusId < 3);
                ViewBag.Brigade        = brigadeForToday.Where(x => x.StatusId == 3);
                ViewBag.CarWashWorkers = new SelectList(await _brigadeForToday.GetDateTimeNow(), "id", "IdCarWashWorkers");
                ViewBag.ReviwOrder     = reviwOrderModules;
                ViewBag.Services       = reviwOrderModules.tireStorageServices;
                ViewBag.Sum            = reviwOrderModules.priceDisk + reviwOrderModules.priceNumberOfPackets +
                                         reviwOrderModules.priceOfTire + reviwOrderModules.priceSilicone + reviwOrderModules.priceWheelWash;

                TempData["ReviwOrderMode"] = reviwOrderModules;
                TempData.Keep("Client");

                return(View(pageCreateResult));
            }

            return(RedirectToAction("CreateTireStorageOrder"));
        }
        public async Task <ReviwOrderModelBll> ReviwOrder(OrderTireStorageModelBll tireStorage)
        {
            var servicesTireStorage = await _tireStorageServices.GetTableAll();

            var detailing = await _detailings.GetPriceGroupWashServices(20);

            reviwOrder.tireStorageServices = new List <TireStorageServicesBll>();

            // наличие дисков
            if (tireStorage.discAvailability != null)
            {
                var resultPriceDisk = servicesTireStorage.Single(x => x.Id == 16);
                AddTireStoregeService(resultPriceDisk);
                reviwOrder.priceDisk = (double)tireStorage.quantity * resultPriceDisk.Price.Value;
            }

            // время хранения
            if (tireStorage.storageTime == 6)
            {
                // количество шин для хранения
                if (tireStorage.quantity == 4)
                {
                    TireStorageServicesBll priceResult = PriceRadius(tireStorage.radius, 4, servicesTireStorage, 6);
                    AddTireStoregeService(priceResult);
                    radius = priceResult.radius.Value;
                    reviwOrder.priceOfTire = priceResult.Price.Value;
                }
                else if (tireStorage.quantity < 4)
                {
                    TireStorageServicesBll priceResult = PriceRadius(tireStorage.radius, 1, servicesTireStorage);
                    AddTireStoregeService(priceResult);
                    radius = priceResult.radius.Value;
                    reviwOrder.priceOfTire = priceResult.Price.Value * (double)tireStorage.quantity;
                }
            }
            else
            {
                // количество шин для хранения если время хранение меньше 6 месяцев ()

                TireStorageServicesBll priceResult = PriceRadius(tireStorage.radius, 1, servicesTireStorage);
                AddTireStoregeService(priceResult);
                radius = priceResult.radius.Value;
                reviwOrder.priceOfTire = priceResult.Price.Value * (double)tireStorage.quantity;
            }

            // Мойка колес (шт)
            if (tireStorage.wheelWash != null)
            {
                if (tireStorage.wheelWash == 4)
                {
                    var wheelWashPrice = servicesTireStorage.Single(x => x.Id == 9);
                    AddTireStoregeService(wheelWashPrice);
                    reviwOrder.priceWheelWash = wheelWashPrice.Price.Value;
                    reviwOrder.IdWheelWash    = wheelWashPrice.Id;
                }
                else if (tireStorage.wheelWash < 4)
                {
                    var wheelWashPrice = servicesTireStorage.Single(x => x.Id == 9);
                    AddTireStoregeService(wheelWashPrice);
                    reviwOrder.priceWheelWash = wheelWashPrice.Price.Value * (double)tireStorage.wheelWash;
                    reviwOrder.IdWheelWash    = wheelWashPrice.Id;
                }
            }

            // Количество пакетов
            if (tireStorage.tireStorageBags != null)
            {
                var packets = servicesTireStorage.Single(x => x.Id == 7);
                AddTireStoregeService(packets);
                reviwOrder.priceNumberOfPackets = (double)tireStorage.tireStorageBags * packets.Price.Value;
            }

            // Селикон
            if (tireStorage.silicone != null)
            {
                if (tireStorage.silicone == 4)
                {
                    var siliconePrice = servicesTireStorage.Single(x => (x.radius == radius) && (x.amount == 4) && (x.ServicesName.Contains("обработать селиконом")));
                    AddTireStoregeService(siliconePrice);
                    reviwOrder.priceSilicone   = siliconePrice.Price.Value;
                    reviwOrder.IdpriceSilicone = siliconePrice.Id;
                }
                else if (tireStorage.silicone < 4)
                {
                    var siliconePrice = servicesTireStorage.Single(x => (x.radius == radius) && (x.amount == 1) && (x.ServicesName.Contains("обработать селиконом")));
                    AddTireStoregeService(siliconePrice);
                    reviwOrder.priceSilicone   = siliconePrice.Price.Value * (double)tireStorage.silicone;
                    reviwOrder.IdpriceSilicone = siliconePrice.Id;
                }
            }

            return(reviwOrder);
        }
Esempio n. 3
0
        public async Task <ActionResult> ReviewTireStorageOrder(double?sum, int?idPaymentState, int?idStatusOrder, int?StockNumber)
        {
            if (StockNumber != null)
            {
                if (TempData.ContainsKey("TireStorageOrder") && TempData.ContainsKey("ReviwOrderMode"))
                {
                    var pageCreateResult  = TempData["TireStorageOrder"] as OrderTireStorageModelView;
                    var reviwOrderModules = TempData["ReviwOrderMode"] as ReviwOrderModelView;

                    OrderTireStorageModelBll orderTireStorage = Mapper.Map <OrderTireStorageModelView, OrderTireStorageModelBll>(pageCreateResult);
                    ReviwOrderModelBll       orderModelBll    = Mapper.Map <ReviwOrderModelView, ReviwOrderModelBll>(reviwOrderModules);

                    int idOrder = await _createOrder.SaveOrderTireFitting(reviwOrderModules.priceOfTire, reviwOrderModules.priceOfTire, idPaymentState.Value, idStatusOrder.Value, orderTireStorage.ClientId.Value, 5);

                    int idStorageFee = await _order.CreateStorageFee(orderTireStorage.storageTime.Value, sum);

                    if (reviwOrderModules.priceSilicone != 0 || reviwOrderModules.priceWheelWash != 0)
                    {
                        idOrderServices = await _createOrder.SaveOrderTireFitting(sum.Value, sum.Value, idPaymentState.Value, 1, orderTireStorage.ClientId.Value, 2);

                        if (reviwOrderModules.priceSilicone != 0)
                        {
                            var AdditionalTireStorageServicesEntity = new AdditionalTireStorageServicesView
                            {
                                clientsOfCarWashId     = orderTireStorage.ClientId.Value,
                                orderServicesCarWashId = idOrderServices.Value,
                                tireStorageServicesd   = orderModelBll.IdpriceSilicone,
                                Price = orderModelBll.priceSilicone
                            };

                            await _additionalTireStorageServices.Insert(TransformAnEntity(AdditionalTireStorageServicesEntity));
                        }

                        if (reviwOrderModules.priceWheelWash != 0)
                        {
                            var AdditionalTireStorageServicesEntity = new AdditionalTireStorageServicesView
                            {
                                clientsOfCarWashId     = orderTireStorage.ClientId.Value,
                                orderServicesCarWashId = idOrderServices.Value,
                                tireStorageServicesd   = orderModelBll.IdWheelWash,
                                Price = orderModelBll.priceWheelWash
                            };

                            await _additionalTireStorageServices.Insert(TransformAnEntity(AdditionalTireStorageServicesEntity));
                        }
                    }

                    var tireStorage = new TireStorageBll
                    {
                        serviceCostTirePackages = orderModelBll.priceNumberOfPackets,
                        dateOfAdoption          = orderTireStorage.dateOfAdoption,
                        quantity               = orderTireStorage.quantity,
                        radius                 = orderTireStorage.radius,
                        firm                   = orderTireStorage.firm,
                        discAvailability       = orderTireStorage.discAvailability,
                        storageFeeId           = idStorageFee,
                        tireStorageBags        = orderTireStorage.tireStorageBags,
                        wheelWash              = orderTireStorage.wheelWash,
                        IdOrderServicesCarWash = idOrder,
                        silicone               = orderTireStorage.silicone,
                        RelatedOrders          = idOrderServices,
                        stockNumber            = StockNumber
                    };

                    await _tireStorage.Insert(tireStorage);

                    await _wage.AdminWageTireStorage(idOrder, pageCreateResult.quantity.Value);
                }

                return(RedirectToAction("OrderTireStorage", "Order", new RouteValueDictionary(new
                {
                    typeOfOrder = 5,
                    statusOrder = 5
                })));
            }
            else
            {
                if (TempData.ContainsKey("Client"))
                {
                    TempData.Keep("Client");
                }

                if (TempData.ContainsKey("TireStorageOrder"))
                {
                    TempData.Keep("TireStorageOrder");
                }

                TempData.Keep("ReviwOrderMode");

                return(RedirectToAction("ReviewTireStorageOrder"));
            }
        }