コード例 #1
0
        public bool AddtoCart(int id, int noOfAddedProduct = 1)
        {
            if (unitOfWork.ProductManager.GetById(id) != null)
            {
                if (unitOfWork.OrderManager.GetAll().Where(x => x.Fk_User == _userManager.GetUserId(HttpContext.User)).ToList().Count == 0)
                {
                    Order order = new Order();
                    order.Fk_User = _userManager.GetUserId(HttpContext.User);
                    unitOfWork.OrderManager.Add(order);
                }

                ProductsOrder productsOrder = new ProductsOrder();
                productsOrder.ProductId = id;
                productsOrder.Quantity  = noOfAddedProduct;
                productsOrder.OrderId   = unitOfWork.OrderManager.GetAll().Where(x => x.Fk_User == _userManager.GetUserId(HttpContext.User)).FirstOrDefault().Id;
                if (unitOfWork.ProductOrderManager.GetAll().Where(j => j.ProductId == id && j.OrderId == productsOrder.OrderId).ToList().Count > 0)
                {
                    var y = unitOfWork.ProductOrderManager.GetAll().Where(j => j.ProductId == id && j.OrderId == productsOrder.OrderId).FirstOrDefault();
                    y.Quantity = noOfAddedProduct;
                    unitOfWork.ProductOrderManager.Update(y);
                }
                else
                {
                    unitOfWork.ProductOrderManager.Add(productsOrder);
                }
                return(true);
            }
            return(false);
        }
コード例 #2
0
        public ActionResult DeleteItem(string Id)
        {
            string        ControllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
            ProductsOrder model          = new ProductsOrder()
            {
                Id = Int32.Parse(MyModels.Decode(Id, API.Models.Settings.SecretId + ControllerName).ToString())
            };

            try
            {
                if (model.Id > 0)
                {
                    model.ModifiedBy = int.Parse(HttpContext.Request.Headers["Id"]);
                    ProductsOrderService.DeleteItem(model);
                    TempData["MessageSuccess"] = "Xóa thành công";
                    return(Json(new MsgSuccess()));
                }
                else
                {
                    TempData["MessageError"] = "Xóa Không thành công";
                    return(Json(new MsgError()));
                }
            }
            catch
            {
                TempData["MessageSuccess"] = "Xóa không thành công";
                return(Json(new MsgError()));
            }
        }
コード例 #3
0
        public async Task CreateAsync(string deliveryAddress, string orderNote
                                      , string customerId, ICollection <string> itemIds)
        {
            Order order = new Order();

            order.Id              = Guid.NewGuid().ToString();
            order.OrderNote       = orderNote;
            order.DeliveryAddress = deliveryAddress;
            order.CustomerId      = customerId;
            order.CreatedAt       = DateTime.Now;

            foreach (var itemId in itemIds)
            {
                var item = await _itemService
                           .FindByIdAndCustomerIdAsync(itemId, customerId);

                var productOrder = new ProductsOrder();
                productOrder.OrderId         = order.Id;
                productOrder.ProductId       = item.ProductId;
                productOrder.ProductQuantity = item.Quantity;

                order.ProductsOrder.Add(productOrder);
            }

            await this.Repository.AddAsync(order);

            await this.Repository.SaveChangesAsync();
        }
コード例 #4
0
        public ActionResult ButtonAddCart(int id)
        {
            ProductsOrder produtoPedido = new ProductsOrder();

            produtoPedido.ProductID = id;

            return(View(produtoPedido));
        }
コード例 #5
0
        public async Task <IActionResult> CheckOut(ProductsOrder model)
        {
            var recaptcha = await _recaptcha.Validate(Request);

            if (!recaptcha.success)
            {
                ModelState.AddModelError("Recaptcha", "Mã Captcha không chính xác. Vui lòng thử lại!");
            }
            else
            {
                if (ModelState.IsValid)
                {
                    model.Id     = 0;
                    model.Status = 0;
                    try
                    {
                        int PId = (int)(ProductsOrderService.SaveItem(model).N);

                        //Thêm detail
                        List <ProductsOrderDetail> listDT = new List <ProductsOrderDetail>();
                        //Kiem tra session
                        var str1 = HttpContext.Session.GetString("ProductOrderList");
                        if (!string.IsNullOrEmpty(str1))
                        {
                            listDT = JsonConvert.DeserializeObject <List <ProductsOrderDetail> >(str1);
                        }

                        foreach (var itemDT in listDT)
                        {
                            itemDT.ProductOrderId = PId;
                            itemDT.Id             = 0;
                            ProductsOrderDetailService.SaveItem(itemDT);
                        }

                        HttpContext.Session.SetString("ProductOrderList", "");
                        TempData["MessageSuccess"] = "Đặt hàng thành công. Chúng tôi sẽ liên hệ với bạn trong thời gian sớm nhất.";
                    }
                    catch
                    {
                        TempData["MessageError"] = "Đặt hàng thất bại. Xin vui lòng thử lại";
                    }
                    return(RedirectToAction("CheckOut"));
                }
            }

            ProductsOrderModel item = new ProductsOrderModel();

            item.ListDetail = new List <ProductsOrderDetail>();
            //Kiem tra session
            var str = HttpContext.Session.GetString("ProductOrderList");

            if (!string.IsNullOrEmpty(str))
            {
                item.ListDetail = JsonConvert.DeserializeObject <List <ProductsOrderDetail> >(str);
            }
            item.Item = model;
            return(View(item));
        }
コード例 #6
0
        public void CreateOrder(object parameter)
        {
            using (var context = new KursachDBContext())
            {
                Order lastOrder = context.Orders.OrderByDescending(o => o.Id).FirstOrDefault();

                int newId = 1;
                if (lastOrder != null)
                {
                    newId = lastOrder.Id + 1;
                }

                Order newOrder = new Order()
                {
                    Id          = newId,
                    Discount    = Cost > 30 ? 10 : 0,
                    IsCompleted = false,
                    IsGiven     = false,
                    OrderDate   = DateTime.Now
                };

                if (Cost > 50 && Cost < 100)
                {
                    newOrder.Discount = 5;
                }
                context.Orders.Add(newOrder);

                foreach (var product in OrderProducts)
                {
                    ProductsOrder currEntity = context.ProductsOrders.Create();
                    currEntity.OrderId   = newOrder.Id;
                    currEntity.ProductId = product.Id;

                    context.ProductsOrders.Add(currEntity);
                }

                context.SaveChanges();

                WorkerWindowViewModel.Instance.UpdateView();
                OrderWindowViewModel.Instance.UpdateOrder();

                CashRepairWindow wnd = new CashRepairWindow();
                try
                {
                    wnd.ShowDialog();
                }
                catch
                { }
                finally
                {
                    OrderProducts = new ObservableCollection <Product>();
                    OnProperyChanged(nameof(OrderProducts));
                }
            }
        }
コード例 #7
0
        public ActionResult Create([Bind(Include = "ProductID,OrderID,Quantidade,Preco_Produto")] ProductsOrder productsOrder)
        {
            if (ModelState.IsValid)
            {
                db.ProdutosPedidos.Add(productsOrder);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.OrderID   = new SelectList(db.Pedidos, "OrderID", "ID_Cliente", productsOrder.OrderID);
            ViewBag.ProductID = new SelectList(db.Produtos, "ProductID", "Nome_Produto", productsOrder.ProductID);
            return(View(productsOrder));
        }
コード例 #8
0
        // GET: ProductsOrders/Details/5


        // GET: ProductsOrders/Create
        public ActionResult Create(int id)
        {
            var order = db.Orders.Find(id);

            ViewBag.ProductID = new SelectList(db.Products.ToList().Where(x => !order.ProductsOrders.ToList().Any(y => x.ProductID == y.ProductID)).ToList(), "ProductID", "FullName", 0);;
            ProductsOrder pro = new ProductsOrder
            {
                Order   = order,
                OrderID = order.OrderID
            };

            return(View(pro));
        }
コード例 #9
0
        // GET: ProductsOrders/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            ProductsOrder productsOrder = db.ProdutosPedidos.Find(id);

            if (productsOrder == null)
            {
                return(HttpNotFound());
            }
            return(View(productsOrder));
        }
コード例 #10
0
        public ActionResult DeleteConfirmed(int?id, int?idp)
        {
            int           np  = 0;
            ProductsOrder aux = null;

            foreach (var i in db.ProdutosPedidos)
            {
                if (i.OrderID == id)
                {
                    np++;
                }
                if (i.ProductID == idp && i.OrderID == id)
                {
                    aux = i;
                }
            }
            foreach (var i in db.Produtos)
            {
                if (i.ProductID == aux.ProductID)
                {
                    i.Stock += aux.Quantidade;
                }
            }
            db.ProdutosPedidos.Remove(aux);
            db.SaveChanges();
            int cont = 0;
            var pedi = db.ProdutosPedidos.Include(c => c.Pedido).Where(model => model.Pedido.PedidoEmAberto == true);

            foreach (var i in pedi)
            {
                if (i.Pedido == aux.Pedido)
                {
                    cont++;
                }
            }
            if (cont == 0)
            {
                foreach (var i in db.Pedidos)
                {
                    if (i.OrderID == aux.OrderID && np < 2)
                    {
                        i.PedidoEmAberto = false;
                        db.Pedidos.Remove(i);
                    }
                }
            }
            db.SaveChanges();
            return(RedirectToAction("Cart"));
        }
コード例 #11
0
 public ActionResult Create(ProductsOrder product)
 {
     try
     {
         db.ProductsOrders.Add(product);
         db.SaveChanges();
         _App.ui.Message.SuccessAddNew();
         return(RedirectToAction("Index", new { id = product.OrderID }));
     }
     catch (Exception e)
     {
         throw e;
         //  return View();
     }
 }
コード例 #12
0
        public NewOrderMessage ConvertToNewOrderMessage()
        {
            NewOrderMessage newOrder = new NewOrderMessage()
            {
                OrderId       = OrderId,
                ProductionIds = ProductionIds,
                Products      = ProductsOrder.Select(p => new ProductMessage()
                {
                    ProductId = p.ProductId
                }).ToList(),
                Total = this.ProductsOrder.Sum(p => p.Price)
            };

            return(newOrder);
        }
コード例 #13
0
        public async Task <ProductsOrder> CreateProductsOrder(ProductsOrder order, string cartId)
        {
            if (!ValidateOrder(order))
            {
                throw new ArgumentException("Invalid order");
            }

            var baseOrder = CreateOrder(order);

            baseOrder.Items = order.Items?.Select(item => item.ToDto());

            var mutationResult = await _repository.CreateOrder(baseOrder);

            if (mutationResult == null)
            {
                return(default);
コード例 #14
0
        public ActionResult Delete(ProductsOrder pro)
        {
            try
            {
                // TODO: Add delete logic here
                var or  = pro.OrderID;
                var old = db.ProductsOrders.Find(pro.POID);

                db.ProductsOrders.Remove(old);
                db.SaveChanges();
                _App.ui.Message.SuccessDelete();
                return(RedirectToAction("Index", new { id = or }));
            }
            catch
            {
                return(View(pro));
            }
        }
コード例 #15
0
        public ActionResult SaveItem(ProductsOrder model)
        {
            string             ControllerName = this.ControllerContext.RouteData.Values["controller"].ToString();
            int                IdDC           = Int32.Parse(MyModels.Decode(model.Ids, API.Models.Settings.SecretId + ControllerName).ToString());
            ProductsOrderModel data           = new ProductsOrderModel()
            {
                Item = model
            };

            if (ModelState.IsValid)
            {
                if (model.Id == IdDC)
                {
                    model.ModifiedBy = int.Parse(HttpContext.Request.Headers["Id"]);
                    ProductsOrderService.SaveItem(model);
                    if (model.Id > 0)
                    {
                        TempData["MessageSuccess"] = "Cập nhật thành công";
                    }
                    else
                    {
                        TempData["MessageSuccess"] = "Thêm mới thành công";
                    }

                    string Str_Url = HttpContext.Session.GetString("STR_Action_Link_" + ControllerName);
                    if (Str_Url != null && Str_Url != "")
                    {
                        return(Redirect("/Admin/" + this.ControllerContext.RouteData.Values["controller"].ToString() + "/Index" + Str_Url));
                    }
                    else
                    {
                        return(RedirectToAction("Index"));
                    }
                }
            }
            else
            {
                //data.ListStart = ProductsOrderService.GetListStart();
            }
            return(View(data));
        }
コード例 #16
0
        public ActionResult Edit(ProductsOrder product)
        {
            try
            {
                // TODO: Add update logic here
                var old = db.ProductsOrders.Find(product.POID);
                old.ProductID       = product.ProductID;
                old.Price           = product.Price;
                old.Qantaty         = product.Qantaty;
                old.CosePrice       = product.CosePrice;
                old.Notes           = product.Notes;
                db.Entry(old).State = System.Data.Entity.EntityState.Modified;
                db.SaveChanges();

                _App.ui.Message.SuccessUpdate();
                return(RedirectToAction("Index", new { id = product.OrderID }));
            }
            catch
            {
                return(View());
            }
        }
コード例 #17
0
        // GET: ProductsOrders/Edit/5
        public ActionResult Edit(int?id, int?idp)
        {
            ProductsOrder aux = null;

            if (id == null && idp == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            //ProductsOrder productsOrder = db.ProdutosPedidos.Find(id,idp);
            foreach (var i in db.ProdutosPedidos)
            {
                if (i.ProductID == idp && i.OrderID == id)
                {
                    aux = i;
                }
            }
            if (aux == null)
            {
                return(HttpNotFound());
            }
            ViewBag.OrderID   = new SelectList(db.Pedidos, "OrderID", "ID_Cliente", aux.OrderID);
            ViewBag.ProductID = new SelectList(db.Produtos, "ProductID", "Nome_Produto", aux.ProductID);
            return(View(aux));
        }
コード例 #18
0
        public ActionResult ButtonAddCart([Bind(Include = "ProductID,Quantidade")] ProductsOrder ProdPedido)
        {
            //Products produto = db.Produtos.Find(ProdPedido.ProductID);
            var produto = db.Produtos.Include(p => p.Company).FirstOrDefault(x => x.ProductID == ProdPedido.ProductID);

            Order aux = null;

            if (produto.Stock < ProdPedido.Quantidade)
            {
                ModelState.AddModelError("Quantidade", "This company already have this product!");
            }
            if (ModelState.IsValid)
            {
                int flag = 0;
                //ProdPedido.ProductID = produto.ProductID;
                var pedi = db.Pedidos.Where(p => p.PedidoEmAberto == true).Include(p => p.Empresa);

                var existePedidoParaEmpresa = pedi.Any(p => p.Empresa.CompanyId == produto.CompanyId);

                if (pedi != null)
                {
                    foreach (var i in pedi) // percorrer os pedidos em aberto
                    {
                        // Se encontrar algum pedido da empresa
                        if (i.Empresa.CompanyId == produto.Company.CompanyId)
                        {
                            //Se o pedido tiver aberto, adicionamos
                            aux = i;
                            Order ped = i;
                            ped.EstadoID      = 1;
                            ProdPedido.Pedido = ped;

                            flag = 2; //verificar se o produto ja existe nos pedidos em aberto
                        }
                    }
                }
                double pr = 0;
                //Se nao houver nenhum pedido da empresa desejada
                if (flag == 0)
                {
                    Order   novopedido = new Order();
                    Company empresa    = db.Empresas.Find(produto.CompanyId);
                    novopedido.Empresa    = empresa;
                    novopedido.ID_Cliente = User.Identity.GetUserId();
                    pr = produto.Preco_Produto * (1 - produto.Taxa_Promocao);
                    novopedido.Preco_Total   += pr * ProdPedido.Quantidade;
                    novopedido.PedidoEmAberto = true;
                    novopedido.Data_Venda     = DateTime.Now;
                    novopedido.EntregaID      = 2;
                    novopedido.EstadoID       = 1;
                    ProdPedido.OrderID        = novopedido.OrderID;
                    ProdPedido.Preco_Produto  = pr; //Guardar o preço c/ promoção
                    db.Pedidos.Add(novopedido);
                    db.ProdutosPedidos.Add(ProdPedido);
                }
                if (flag == 2)
                {
                    int existe  = 0;
                    var prodped = db.ProdutosPedidos.Include(p => p.Produto).Include(p => p.Pedido).Where(p => p.Pedido.PedidoEmAberto == true);
                    foreach (var d in prodped)
                    {
                        if (d.Produto == produto)
                        {
                            existe        = 1;
                            d.Quantidade += ProdPedido.Quantidade;
                            Order p = d.Pedido;
                            pr             = produto.Preco_Produto * (1 - produto.Taxa_Promocao);
                            p.Preco_Total += pr * ProdPedido.Quantidade;
                            // p.Preco_Total += produto.Preco_Produto * ProdPedido.Quantidade;
                            d.Pedido = p;
                            //d.Pedido.Preco_Total += produto.Preco_Produto * ProdPedido.Quantidade;
                            db.Entry(d).State = EntityState.Modified;
                        }
                    }
                    if (existe == 0)
                    {
                        ProdPedido.Produto             = produto;
                        ProdPedido.Preco_Produto       = produto.Preco_Produto * (1 - produto.Taxa_Promocao);
                        ProdPedido.Pedido.Preco_Total += produto.Preco_Produto * ProdPedido.Quantidade;
                        db.ProdutosPedidos.Add(ProdPedido);
                        //Temos de adicionar o produto se nao houver o que ele quer adicionar
                    }
                }

                produto.Stock          -= ProdPedido.Quantidade;
                db.Entry(produto).State = EntityState.Modified;
                db.SaveChanges();
            }

            return(RedirectToAction("ListCostumerProducts"));
        }
コード例 #19
0
        protected Order createOrder()
        {
            if (Session["ID"] != null)
            {
                try
                {
                    int userId = Convert.ToInt32(Session["ID"].ToString());
                    using (AABZContext context = new AABZContext())
                    {
                        Order order = new Order();//build order
                        //get user cart
                        Model.Cart cart = (from c in context.Carts
                                           where c.user_id == userId
                                           select c).FirstOrDefault();
                        //get user
                        User usr = (from u in context.Users
                                    where u.Id == userId
                                    select u).First();
                        order.User = usr;//set order user

                        List <UserInfo> ui = (from info in context.UserInfoes
                                              where info.user_id == userId
                                              select info).ToList();
                        if (ui.Count == 1 && ui.ElementAt(0).isBilling)//if one address and is billing
                        {
                            UserInfo usrinfo = ui.ElementAt(0);
                            order.BillingAddress   = usrinfo;
                            order.billing_address  = usrinfo.Id;
                            order.ShippingAddress  = usrinfo;
                            order.shipping_address = usrinfo.Id;
                        }
                        else
                        {
                            foreach (UserInfo info in ui)//for each address assign apropriately
                            {
                                if (info.isBilling)
                                {
                                    order.BillingAddress  = info;
                                    order.billing_address = info.Id;
                                }
                                else
                                {
                                    order.ShippingAddress  = info;
                                    order.shipping_address = info.Id;
                                }
                            }
                        }
                        context.Orders.Add(order);
                        context.SaveChanges();

                        ProductsOrder po = new ProductsOrder();
                        //for each product in cart create product order and add to order
                        List <ProductsOrder> orders = new List <ProductsOrder>();
                        foreach (ProductsCart pc in cart.products_cart)
                        {
                            po            = new ProductsOrder();
                            po.order_id   = order.Id;
                            po.Product    = pc.Product;
                            po.product_id = pc.product_id;
                            po.quantity   = pc.quantity;
                            po.price      = pc.Product.price * pc.quantity;
                            po.Order      = order;
                            context.PoductsOrders.Add(po);
                            orders.Add(po);
                        }
                        order.ProductsOrders = orders;
                        //create payment
                        Payment payment = new Payment();
                        payment.cc_name   = txtCcName.Text;
                        payment.cc_number = txtCcNumber.Text;
                        payment.cc_month  = Convert.ToInt32(drpCcMonth.SelectedValue);
                        payment.cc_year   = Convert.ToInt32(drpCcYear.SelectedValue);
                        payment.cc_ccv    = Convert.ToInt32(txtCcCvv.Text);
                        order.Payments    = payment;//set payment
                        payment.Order     = order;

                        /*
                         * if (ui.isBilling)
                         * {
                         *  order.BillingAddress = ui;
                         * }
                         * else
                         * {
                         *  UserInfo ui2 = new UserInfo();
                         *  ui2.User = ui.User;
                         *  ui2.address_1 = txtAddress1.Text;
                         *  ui2.address_2 = txtAddress2.Text;
                         *  ui2.city = txtCity.Text;
                         *  ui2.state = txtState.Text;
                         *  ui2.zipcode = txtZipCode.Text;
                         *  ui2.phone = ui.phone;
                         *  order.BillingAddress = ui2;
                         * }
                         */

                        payment.order_id = order.Id;
                        context.Payments.Add(payment);
                        context.SaveChanges();
                        return(order);
                    }
                }catch (DbEntityValidationException e)
                {
                    return(null);
                }
            }
            else
            {
                return(null);
            }
        }
コード例 #20
0
        public ActionResult Edit([Bind(Include = "ProductID,OrderID,Quantidade,Preco_Produto")] ProductsOrder productsOrder)
        {
            int quantidade_anterior = 0;

            foreach (var i in db.ProdutosPedidos)
            {
                if (i.ProductID == productsOrder.ProductID && i.OrderID == productsOrder.OrderID)
                {
                    quantidade_anterior = i.Quantidade;
                }
            }
            foreach (var i in db.Produtos)
            {
                if (productsOrder.ProductID == i.ProductID)
                {
                    if (productsOrder.Quantidade == 0)
                    {
                        ModelState.AddModelError("Quantidade", "Instead, please remove the product from the cart");
                    }
                    if (quantidade_anterior < productsOrder.Quantidade)
                    {
                        if (i.Stock < productsOrder.Quantidade)
                        {
                            ModelState.AddModelError("Quantidade", "Quantity invalid!");
                        }
                    }
                    else
                    {
                        if (i.Stock + quantidade_anterior < productsOrder.Quantidade)
                        {
                            ModelState.AddModelError("Quantidade", "Quantity invalid!");
                        }
                    }
                }
            }
            if (ModelState.IsValid)
            {
                double aux     = 0;
                double aux_tot = 0;
                foreach (var i in db.Produtos)
                {
                    if (productsOrder.ProductID == i.ProductID)
                    {
                        i.Stock += quantidade_anterior;
                        i.Stock -= productsOrder.Quantidade;
                        aux_tot  = quantidade_anterior * (i.Preco_Produto * (1 - i.Taxa_Promocao));
                        aux      = (i.Preco_Produto * (1 - i.Taxa_Promocao)) * productsOrder.Quantidade;
                    }
                }
                foreach (var i in db.Pedidos)
                {
                    if (i.OrderID == productsOrder.OrderID)
                    {
                        i.Preco_Total -= aux_tot;
                        i.Preco_Total += aux;
                    }
                }
                foreach (var i in db.ProdutosPedidos)
                {
                    if (i.ProductID == productsOrder.ProductID && i.OrderID == productsOrder.OrderID)
                    {
                        i.Quantidade = productsOrder.Quantidade;
                    }
                }
                //db.Entry(productsOrder).State = EntityState.Modified;
                db.SaveChanges();
                return(RedirectToAction("Cart"));
            }
            ViewBag.OrderID   = new SelectList(db.Pedidos, "OrderID", "ID_Cliente", productsOrder.OrderID);
            ViewBag.ProductID = new SelectList(db.Produtos, "ProductID", "Nome_Produto", productsOrder.ProductID);
            return(View(productsOrder));
        }