public async Task <SalesOrderFormViewModel> GetSalesOrderForm(string salesOrderId)
        {
            var salesOrderForm = new SalesOrderFormViewModel()
            {
                SalesOrder       = Mapper.Map <SalesOrderViewModel>(await _salesOrderRepository.GetSalesOrder(salesOrderId)),
                Currencies       = Mapper.Map <IEnumerable <CurrencyViewModel> >(await _currencyRepository.GetCurrencyList()),
                BusinessPartners = Mapper.Map <IEnumerable <BusinessPartnerViewModel> >(await _businessPartnerRepository.GetBusinessPartnerList())
            };

            return(salesOrderForm);
        }
        public async Task <ActionResult> SaveSalesOrderRecord(SalesOrderFormViewModel salesOrderForm)
        {
            ArrayList errorList = new ArrayList();
            string    _viewMode = salesOrderForm.ViewMode;

            if (salesOrderForm.SalesOrder.SalesOrderDetails != null)
            {
                foreach (SalesOrderDetailViewModel salesOrderDetail in salesOrderForm.SalesOrder.SalesOrderDetails)
                {
                    if (salesOrderDetail.QuantityOnHand < salesOrderDetail.Quantity)
                    {
                        ModelState.AddModelError(string.Empty, "Item " + salesOrderDetail.Item.ItemName + " will be depleted!");
                    }
                }
            }

            if (TryValidateModel(salesOrderForm))
            {
                salesOrderForm.SalesOrder.UserId = User.Identity.GetUserId();
                salesOrderForm.SalesOrder.SalesOrderDetails?.Select
                    (detail =>
                {
                    detail.UserId       = User.Identity.GetUserId();
                    detail.SalesOrderId = salesOrderForm.SalesOrder.SalesOrderId;
                    return(detail);
                }).ToList();

                var recordsSaved = await _salesOrderService.SaveSalesOrder(salesOrderForm.SalesOrder);

                if (recordsSaved >= 1)
                {
                    var salesOrder = await _salesOrderService.GetSalesOrder(salesOrderForm.SalesOrder.SalesOrderId);

                    return(View("SalesOrderRecord", salesOrder));
                }
                ModelState.AddModelError(string.Empty, "There was a problem and the SalesOrder was not saved.");
            }

            foreach (ModelState modelState in ViewData.ModelState.Values)
            {
                foreach (ModelError error in modelState.Errors)
                {
                    errorList.Add(error.ErrorMessage);
                }
            }

            salesOrderForm = await _salesOrderService.GetSalesOrderForm(salesOrderForm.SalesOrder.SalesOrderId);

            salesOrderForm.ViewMode = _viewMode;


            return(View((salesOrderForm.ViewMode == "Create")? "~/Views/SalesOrder/CreateSalesOrder.cshtml" : "~/Views/SalesOrder/EditSalesOrderRecord.cshtml", salesOrderForm));
        }
        public async Task <SalesOrderFormViewModel> CreateSalesOrderForm(string userId)
        {
            string salesOrderId = await _salesOrderRepository.CreateSalesOrder(userId);

            var salesOrderForm = new SalesOrderFormViewModel()
            {
                SalesOrder       = Mapper.Map <SalesOrderViewModel>(await _salesOrderRepository.GetSalesOrder(salesOrderId)),
                Currencies       = Mapper.Map <IEnumerable <CurrencyViewModel> >(await _currencyRepository.GetCurrencyList()),
                BusinessPartners = Mapper.Map <IEnumerable <BusinessPartnerViewModel> >(await _businessPartnerRepository.GetBusinessPartnerList())
            };

            salesOrderForm.SalesOrder.SalesOrderStatus = "Open";

            return(salesOrderForm);
        }
Beispiel #4
0
        public async Task <IActionResult> InsertSales(SalesOrderFormViewModel viewModel)
        {
            using var beginTransaction = await _context.Database.BeginTransactionAsync();

            try
            {
                if (ModelState.IsValid)
                {
                    if (viewModel.debit != null)
                    {
                        viewModel.debit.TimeOfPayment = DateTime.Now;
                        viewModel.SalesOrder.Payment  = viewModel.debit;
                    }
                    else if (viewModel.Credit != null)
                    {
                        viewModel.SalesOrder.Payment = viewModel.Credit;
                    }
                    else if (viewModel.Ticket != null)
                    {
                        viewModel.SalesOrder.Payment = viewModel.Ticket;
                    }
                    else if (viewModel.Money != null)
                    {
                        viewModel.SalesOrder.Payment = viewModel.Money;
                    }
                    else if (viewModel.PayLater != null)
                    {
                        viewModel.SalesOrder.Payment = viewModel.PayLater;
                    }
                    else
                    {
                        return(Json("Error: Pendente a forma de Pagamento"));
                    }

                    viewModel.SalesOrder.SaleBoxId  = _openBox.GetSaleBox().Id;
                    viewModel.SalesOrder.InsertDate = DateTime.Now;

                    ICollection <SalesItem> SalesItem = new HashSet <SalesItem>();
                    foreach (var item in viewModel.SalesOrder.SalesItem)
                    {
                        if (!SalesItem.Contains(item))
                        {
                            SalesItem.Add(item);
                        }
                        else
                        {
                            SalesItem.First(x => x.StockId == item.StockId).Quantity += item.Quantity;
                        }
                    }
                    viewModel.SalesOrder.SalesItem = SalesItem;
                    await _inventoryManagement.StockManagementRemoveAsync(viewModel.SalesOrder.SalesItem, _employeeLogin.GetEmployee().BusinessId);

                    await _salesOrderRepository.InsertAsync(viewModel.SalesOrder);

                    TempData["MSG_S"] = Message.MSG_S_007;
                    await beginTransaction.CommitAsync();

                    return(Json("Ok"));
                }
                return(Json("Invalid"));
            }
            catch (Exception e)
            {
                await beginTransaction.RollbackAsync();

                return(Json("Error: " + e.Message));
            }
        }