Exemplo n.º 1
0
 public static Dto.Model.Order MapToDto(this Domain.Entities.Order order, List <Dto.Model.OrderProduct> items)
 {
     return(new Dto.Model.Order()
     {
         ID = order.ID,
         UpdatedTime = order.UpdatedTime,
         AddressID = order.AddressID,
         CreatedTime = order.CreatedTime,
         Status = order.Status,
         Items = items
     });
 }
        public ActionResult CheckOut(Order model)
        {
            var order = new Order();
            if (TryUpdateModel(order))
            {
                string cartId = ShoppingCart.GetCartId(HttpContext);

                ServiceLocator.FSharpBus.DispacthCommand(MessageBus.Command.NewSubmitOrderCommand(new Guid(cartId),
                    order));

                return RedirectToAction("Complete", "StoreEDAFSharp", new {id = order.Id});
            }
            return View();
        }
Exemplo n.º 3
0
 public void AddOrderDetails(Order order, Cart cart)
 {
     var cartItems = cart.lineCollection.ToList();
     foreach (var item in cartItems)
     {
         var orderDetail = new OrderDetail
         {
             OrderId = order.OrderId,
             ProductId = item.Product.ProductId,
             Quantity = item.Quantity
         };
         db.OrderDetails.Add(orderDetail);
     }
     db.SaveChanges();
 }
        public AddEditOrderPresenter(AddEditOrderView view, int orderId)
        {
            this.view = view;

            goods.AddRange(modelProxy.GoodsModel.GetAll().Where(x => x.IsActive == true));

            if (orderId >= 0)
            {
                order = modelProxy.OrderModel.GetById(orderId);
            }
            else
            {
                order = new Domain.Entities.Order();
            }
        }
Exemplo n.º 5
0
        private static List<Order> AddTenOrders()
        {
            List<Order> orderCollection = new List<Order>();

            for (int i = 0; i < 9; i++)
            {
                Order order = new Order();
                order.Customer = customerCollection[i];
                order.comments.Add(new Comment() { Message = "commentfromOrder" + i, });
                order.Operator = userCollection[i];
                order.goodsList.Add(goodsRowCollection[i]);

                orderCollection.Add(order);
            }
            return orderCollection;
        }
Exemplo n.º 6
0
        public ActionResult CheckOut(Order model)
        {
            var order = new Order();
            if (TryUpdateModel(order))
            {
                order.OrderDate = DateTime.Now;
                storetUnitOfWork.Order.Add(order);
                storetUnitOfWork.Commit();

                ShoppingCart cart = ShoppingCart.GetCart(HttpContext, storetUnitOfWork);
                cart.CreateOrder(order);

                return RedirectToAction("Complete", "Store", new {id = order.Id});
            }
            return View();
        }
        public AddEditOrderPresenter(AddEditOrderView view, int orderId)
        {
            this.view = view;
            this.orderId = orderId;
            vm = new List<AddEditViewModel>();

            if (orderId >= 0)
            {
                order = orderModel.GetById(orderId);
                foreach (GoodsRow row in order.GoodsList)
                {
                    vm.Add(new AddEditViewModel() { Id = row.Id, Good = row.Goods, Count = row.Count, TotalCost = row.TotalPrice });
                }
            }
            else
            {
                order = new Domain.Entities.Order();
            }
        }
Exemplo n.º 8
0
        public Order ReceiveOrder(Cart cart, string username)
        {
            var order = new Order{
                Username = username,
                OrderDate = DateTime.Now,
                Status = "Received",
                Total = cart.ComputeTotal(),
                //CompleteDate = new DateTime(1900,1,1)
            };

               db.Orders.Add(order);

               AddOrderDetails(order, cart);
               db.SaveChanges();

               cart.Clear();

               return order;
        }
        public Order CreateOrder(Domain.Entities.Order order, List <Application.Dto.Model.OrderProduct> orderProducts)
        {
            using (var connection = new NpgsqlConnection(_connectionString))
            {
                connection.Open();
                using (NpgsqlTransaction transaction = connection.BeginTransaction())
                {
                    try
                    {
                        var parameters = new
                        {
                            addressId   = order.AddressID,
                            createdTime = DateTime.UtcNow,
                            status      = order.Status
                        };

                        order.ID = connection.ExecuteScalar <int>(
                            sql: $"insert into retail.order (address_id, created_time, updated_time, status) values (@addressId, @createdTime, @updatedTime, @status) RETURNING id;",
                            param: parameters,
                            transaction: transaction);

                        var products = orderProducts.Select(op => new { OrderID = order.ID, ProductID = op.ID, Quantity = op.Quantity }).ToArray();
                        connection.Execute(
                            sql: $"insert into retail.orderproduct (order_id, product_id, quantity) values (@OrderID, @ProductID, @Quantity);",
                            param: products,
                            transaction: transaction);

                        _productRepository.BulkUpdateProductQuantity(orderProducts);

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

            return(order);
        }
            public async Task <Unit> Handle(PurchaseProductCommand request, CancellationToken cancellationToken)
            {
                var entity = await _context.Products.FindAsync(request.ProductId);

                if (entity == null)
                {
                    throw new NotFoundException("Product", request.ProductId);
                }

                if (entity.Count == 0 || entity.Count < request.Count)
                {
                    throw new AvailabilityException("Product", request.ProductId);
                }

                entity.Count -= request.Count;

                var newOrder = new Domain.Entities.Order
                {
                    OrderId   = Guid.NewGuid(),
                    UserId    = request.UserId,
                    ProductId = entity.ProductId,
                    Date      = DateTime.UtcNow,
                    Count     = request.Count,
                    State     = OrderState.CREATED
                };

                _context.Orders.Add(newOrder);

                int value = await _context.SaveChangesAsync(cancellationToken);

                if (value > 0)
                {
                    return(Unit.Value);
                }

                throw new Application.ExceptionHandler.
                      ExceptionHandler(System.Net.HttpStatusCode.Conflict,
                                       new { message = "Buy product conflict" });
            }
 public void SaveAndNew()
 {
     Save();
     order = new Domain.Entities.Order();
 }
Exemplo n.º 12
0
 public OrderSubmittedEvent(Order order, Guid? id = null)
 {
     Order = order;
     Id = id ?? Guid.NewGuid();
 }
Exemplo n.º 13
0
        public void CreateOrder(Order order)
        {
            decimal orderTotal = 0;

            List<Cart> cartItems = GetCartItems();

            // Iterate over the items in the cart, adding the order details for each
            foreach (Cart item in cartItems)
            {
                var orderDetail = new OrderDetail
                {
                    ProductId = item.ProductId,
                    OrderId = order.Id,
                    UnitPrice = item.Product.Price,
                    Quantity = item.Count
                };

                // Set the order total of the shopping cart
                orderTotal += (item.Count*item.Product.Price);

                _storetUnitOfWork.OrderDetails.Add(orderDetail);
            }

            // Set the order's total to the orderTotal count
            order.Total = orderTotal;

            _storetUnitOfWork.Commit();
            EmptyCart();
        }
Exemplo n.º 14
0
 public SubmitOrderCommand(string cartId, Order order)
 {
     _cartId = cartId;
     Order = order;
     Id = Guid.NewGuid();
 }
 public void SaveAndNew()
 {
     Save();
     order = new Domain.Entities.Order();
     NotifyPropertyChanged("SaveAndNew");
 }
Exemplo n.º 16
0
 public bool ship(Order order)
 {
     throw new NotImplementedException();
 }