public IActionResult OnGetAction(Guid customerId, decimal shippingFee, int addressId) { int a = AddressId; DAL.Data.Entities.Order order = new DAL.Data.Entities.Order { Status = OrderStatus.Pending, OrderDate = DateTime.Now, DeliveryDate = DateTime.Now.AddDays(3), ShippingFee = shippingFee, AddressId = addressId }; _orderRepository.Add(order); DAL.Data.Entities.Cart cart = _cartRepository.Find(c => c.CustomerId == customerId); IEnumerable <CartDetail> items = _cartDetailRepository.GetSome(i => i.CartId == cart.Id); foreach (CartDetail item in items) { OrderItem OrderItem = new OrderItem { Quantity = item.Quantity, ItemId = item.ItemId, OrderId = order.Id, Amount = _itemRepository.Find(item.ItemId).Price *item.Quantity }; _orderItemRepository.Add(OrderItem); } _cartDetailRepository.DeleteRange(items); return(RedirectToPage("./Success")); }
public async Task <IActionResult> AddOrder(decimal totalPrice) { _cart = HttpHelper.HttpContext.Session.GetObjectFromJson <List <Item> >("Cart"); string userId = (await userManager.GetUserAsync(HttpContext.User))?.Id; Order newOrder = new Order { User = await userManager.FindByIdAsync(userId), Date = DateTime.Now, TotalPrice = totalPrice / 100 }; _orderRepository.Add(newOrder); foreach (Item item in _cart) { var lastOrderItemId = _orderItemRepository.GetLastId(); lastOrderItemId += 1; OrderItem newOrderItem = new OrderItem { Id = lastOrderItemId, Order = newOrder }; _orderItemRepository.Add(newOrderItem); } return(View("AddOrderSuccesfull")); }
public async Task <IActionResult> MakeOrder(CreateOrderViewModel viewModel) { if (ModelState.IsValid) { OrderModel order = new OrderModel(); string items_string_list = ""; //When Created Id is +1 so in order of asigning it to the order item it needs to be decleared here int orderId = _orderRepository.OrdersCount(); orderId++; //Add right order items to the database for (int i = 0; i < viewModel.OrderItems.Count; i++) { viewModel.OrderItems[i].OrderId = orderId; order.FullItemsAmmount += viewModel.OrderItems[i].Ammount; _orderItemRepository.Add(viewModel.OrderItems[i]); items_string_list += $"Product: {viewModel.OrderItems[i].ProductName} | Quantity: {viewModel.OrderItems[i].Ammount} \n"; } order.OrderDate = DateTime.Now; order.SupplierName = viewModel.SupplierName; _orderRepository.AddOrder(order); SuppliersModel supplier = _supplierRepository.GetSupplier(viewModel.SupplierId); //Send email with order //await PostMail(supplier, order, items_string_list); return(RedirectToAction("DisplayOrders")); } return(View()); }
public Guid Create(OrderItemViewModel model) { _unitOfWork.BeginTransaction(); var order = _orderRepository.GetById(model.Order.Id); if (order == null) { _unitOfWork.Commit(); throw new Exception(ExceptionMessages.OrderException.NOT_FOUND); } var product = _productRepository.GetById(model.Product.Id); if (product == null) { _unitOfWork.Commit(); throw new Exception(ExceptionMessages.ProductException.NOT_FOUND); } var orderItem = new OrderItem(order, product, model.Quantity); _orderItemRepository.Add(orderItem); _unitOfWork.Commit(); return(orderItem.Id); }
public ActionResult <OrderItem> Create([FromBody] OrderItem orderItem) { if (ModelState.IsValid) { OrderItemRepository.Add(orderItem); } return(CreatedAtAction(nameof(GetOrderItem), new { orderItem.OrderId }, orderItem)); }
public void Add(OrderItem orderItem) { _orderItemRepository.Add(orderItem); if (onItemAdded != null) { onItemAdded(); } }
public int ConfirmOrder(ref Cart cart) { var orderId = 0; using (var transacton = _ordersRepository.DataContext.Database.BeginTransaction()) { try { var order = new Order { MemberId = cart.MemberId, OrderValue = cart.CartTotalPriceOut, CreationDate = DateTime.Now }; _ordersRepository.Add(order); _ordersRepository.DataContext.SaveChanges(); var orderOrderStatus = new OrderOrderStatus { OrderId = order.OrderId, OrderOrderStatusId = (int)OrderStatusType.Confirmed, CreationDate = DateTime.Now }; _orderOrderStatusRepository.Add(orderOrderStatus); _orderOrderStatusRepository.DataContext.SaveChanges(); order.LatestOrderStatusId = orderOrderStatus.OrderOrderStatusId; _ordersRepository.DataContext.SaveChanges(); if (order.OrderId > 0 && cart.Items != null) { foreach (var item in cart.Items) { var orderItem = new OrderItem { OrderId = order.OrderId, ProductId = item.ProductId, ProductCount = item.ProductCount, PriceOut = item.PriceOut, TotalPriceOut = item.TotalPriceOut, CreationDate = DateTime.Now }; _orderItemRepository.Add(orderItem); _orderItemRepository.DataContext.SaveChanges(); } } transacton.Commit(); ClearCart(ref cart); orderId = order.OrderId; } catch (Exception) { transacton.Rollback(); } } return(orderId); }
public async Task <IActionResult> PostOrderItem([FromBody] OrderItem orderItem) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _orderItems.Add(orderItem); return(CreatedAtAction("GetOrderItem", new { id = orderItem.OrderItemId }, orderItem)); }
public IActionResult Create([FromBody] OrderItem order) { if (order == null) { return(BadRequest()); } _orderRepository.Add(order); return(CreatedAtRoute("GetOrder", new { id = order.IdOrder }, order)); }
public void Pay(List <OrderItemAddToOrderViewModel> model, Guid userId) { _unitOfWork.BeginTransaction(); //sum price int orderPrice = 0; foreach (var item in model) { int quantity = item.Quantity; int price = (int)item.Product.Price; orderPrice += price * quantity; } //get user from cookie var user = _userRepository.GetById(userId); if (user == null) { _unitOfWork.Commit(); throw new Exception(ExceptionMessages.UserException.NOT_FOUND); } //create new empty order var order = new Order(user, OrderStatus.PAID, DateTime.Now, orderPrice); _orderRepository.Add(order); //add order items in created order foreach (var item in model) { var product = _productRepository.GetById(item.Product.Id); if (product == null) { _unitOfWork.Commit(); throw new Exception(ExceptionMessages.ProductException.NOT_FOUND); } var orderItem = new OrderItem(order, product, item.Quantity); if (orderItem.Quantity > product.Quantity) { _unitOfWork.Rollback(); throw new Exception(ExceptionMessages.OrderItemException.OUT_OF_STOCK); } _orderItemRepository.Add(orderItem); product.Quantity = product.Quantity - orderItem.Quantity; _productRepository.Update(product); } _unitOfWork.Commit(); }
public OrderItem RecordOrderItem(License license, PurchaseRecord purchaseRecord, int itemNumber) { OrderItem item = new OrderItem() { OrderItemNo = itemNumber, PurchaseRecordId = purchaseRecord.Id, ActivationKey = license.ActivationKey, LicenseId = license.LicenseId }; _orderItemRepository.Add(item); return(item); }
public string GenerateOrders(int count) { var products = inventoryRepository.Fetch(0, int.MaxValue); if (null == products || products.Count == 0) { return("Products must first be added to the catalog."); } var contractors = contractorRepository.Fetch(0, int.MaxValue); if (null == contractors || contractors.Count == 0) { return("Products with Contractors must first be added to the catalog."); } var users = userRepository.GetUsers(); if (null == users || users.Count == 0) { return("Users must first be added to the system."); } Random random = new Random((int)DateTime.Now.Ticks); StringBuilder result = new StringBuilder(); int orderCount = 0; int orderItemCount = 0; HashSet <int> includedItems = new HashSet <int>(); for (int i = 0; i < count; i++) { orderCount++; int itemCount = random.Next(10) + 1; Order order = BuildRandomOrder(random, users); orderRepository.Add(order); includedItems.Clear(); for (int j = 0; j < itemCount; j++) { orderItemCount++; var product = GetNextProduct(products, random, includedItems); OrderItem item = new OrderItem(); item.OrderId = order.Id; item.Price = product.ContractPrice; item.ProductId = product.Id; item.Quantity = 1 + random.Next(6); orderItemRepository.Add(item); } } result.AppendFormat("Added {0} orders\r\n", orderCount); result.AppendFormat("Added {0} order items\r\n", orderItemCount); return(result.ToString()); }
public OrderDTO SubmitOrder(OrderDTO model, string operatorId) { using (ITransactionCoordinator coordinator = new TransactionCoordinator(_dbUnitOfWork, _eventBus)) { var orderItems = model.OrderItems?.Select(item => new OrderItem { Count = item.Count, ObjectId = item.ObjectId, ObjectNo = item.ObjectNo, OrderId = item.OrderId, PreviewPictureUrl = item.PreviewPictureUrl, SelectedProperties = item.SelectedProperties, Title = item.Title, TradeUnitPrice = item.TradeUnitPrice })?.ToList(); var obj = OrderFactory.CreateOrder( model.TotalAmount, model.ShippingCost, model.PreferentialAmount, model.Tax, model.PayAmount, model.CustomerName, model.CustomerMobile, model.InvoiceType, model.CustomerAddress, orderItems, operatorId, model.Mark, model.OrganizationId, model.InvoiceRemark, model.Remark, model.ActivityId, model.Title); _orderRepository.Add(obj); orderItems.ForEach(oi => { oi.OrderId = obj.Id; _orderItemRepository.Add(oi); }); obj.ConfirmSubmited(); coordinator.Commit(); model.Id = obj.Id; return(model); } }
public async Task <Response> Create(CreateOrderItemRequest request) { try { var item = _mapper.Map <OrderItem>(request); _repository.Add(item); if (await _repository.SaveChangesAsync()) { var response = _mapper.Map <OrderItemResponse>(item); return(OkResponse(null, response)); } return(BadRequestResponse("Erro desconhecido.")); } catch (Exception ex) { return(BadRequestResponse(ex.Message)); } }
public IActionResult Create([FromBody] JObject data) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } Order model = data["order"].ToObject <Order>(); _service.Add(model); var list_item = data["order_item"].ToList(); foreach (var item in list_item) { OrderItem model_item = item.ToObject <OrderItem>(); _service_item.Add(model_item); Product model_product = _service_product.GetSingleByCondition(c => c.ProductID == model_item.ProductID); model_product.Quantity -= model_item.Quantity; _service_product.Update(model_product); } return(Ok(model)); }
public void Add(OrderItemDTO orderItemDto) { var orderItem = Mapper.Map <OrderItemDTO, OrderItem>(orderItemDto); _repository.Add(orderItem); }
public void Post([FromBody] OrderItem value) => _orderItemRepository.Add(value);
public void Add(OrderItem obj) { _OrderItemRepository.Add(obj); }
//------------------OrderItems methods public void AddOrderItem(OrderItem orderItem) { m_orderItemsRepository.Add(orderItem); }
public void CreateOrderItem(OrderItem orderItem) { orderItemRepository.Add(orderItem); SaveOrderItem(); }
public int AddOrderItem(OrderItem entity) { return(_orderItemRepository.Add(entity)); }
public Order Create(int shoppingCartId, int userId, OrderPaymentMethod paymentMethod, string address1, string address2, string address3, string city, string state, string postalCode, string emailAddress) { var cart = _shoppingCartRepository.Get(shoppingCartId); if (cart == null) { throw new Exception("Shopping cart not found."); } if (userId != cart.UserId) { throw new Exception("Shopping cart not found."); } var cartItems = _shoppingCartItemRepository.Fetch(shoppingCartId); if (cartItems == null || !cartItems.Any()) { throw new Exception("No items found in shopping cart."); } Order newOrder = new Order() { Items = new List <OrderItem>(), CreateDate = DateTime.UtcNow, PaymentMethod = paymentMethod, Status = OrderStatus.Placed, UserId = cart.UserId, Address1 = address1, Address2 = address2, Address3 = address3, City = city, State = state, PostalCode = postalCode, EmailAddress = emailAddress }; foreach (var item in cartItems) { OrderItem orderItem = new OrderItem() { ProductId = item.ProductId, Quantity = item.Quantity, Price = item.Price }; newOrder.Items.Add(orderItem); } _orderRepository.Add(newOrder); foreach (var orderItem in newOrder.Items) { orderItem.OrderId = newOrder.Id; _orderItemRepository.Add(orderItem); } foreach (var cartItem in cartItems) { _shoppingCartItemRepository.Delete(cartItem.Id); } return(newOrder); }