public override string Import(string catalogId, string propertySetId, ImportItem[] systemValues, ImportItem[] customValues, IRepository repository) { var _error = string.Empty; _repository = (IOrderRepository)repository; var action = GetAction(systemValues.First(x => x.Name == "Action").Value); switch (action) { case ImportAction.Insert: var addItem = InitializeItem(null, systemValues); _repository.Add(addItem); break; case ImportAction.InsertAndReplace: var itemR = systemValues.FirstOrDefault(y => y.Name == "Code"); if (itemR != null) { var originalItem = _repository.Jurisdictions.Where(x => x.Code == itemR.Value).SingleOrDefault(); if (originalItem != null) _repository.Remove(originalItem); } var replaceItem = InitializeItem(null, systemValues); _repository.Add(replaceItem); break; case ImportAction.Update: var itemU = systemValues.FirstOrDefault(y => y.Name == "Code"); if (itemU != null) { var origItem = _repository.Jurisdictions.Where(x => x.Code == itemU.Value).SingleOrDefault(); if (origItem != null) { InitializeItem(origItem, systemValues); _repository.Update(origItem); } } break; case ImportAction.Delete: var itemD = systemValues.FirstOrDefault(y => y.Name == "Code"); if (itemD != null) { var deleteItem = _repository.Jurisdictions.Where(x => x.Code == itemD.Value).SingleOrDefault(); if (deleteItem != null) _repository.Remove(deleteItem); } break; } return _error; }
public async Task <OrderVm> PlaceOrderAsync(OrderVm order) { var vm = AutoMapper.Mapper.Map <OrderVm, Order>(order); long existingOrder = 0; var countTask = Task.Factory.StartNew(() => existingOrder = CountPendingOrders().Result); countTask.Wait(); vm.SetEstimatedReadyTime(existingOrder); var dm = await _orderRepository.Add(vm); dm.ProcessOrder(dm, _eventPublisher); return(AutoMapper.Mapper.Map <Order, OrderVm>(dm)); }
private void SaveModels(Quotation quotationLocal) { _quotationRepository.Add(quotationLocal); _orderDetailsRepository.Add(_OrderAndOrderDetailsVM.OrderDetailsModel); _orderRepository.Add(_OrderAndOrderDetailsVM.OrderModel); try { _queries.SaveChanges(); } catch (Exception ex) { } }
public OrderDto Add(int userId, OrderFormDto orderFormDto) { var order = _mapper.Map <Order>(orderFormDto); order.Send(new OrderRoute(userId, userId, order.Id, string.Empty)); _orderRepository.Add(order); _unitOfWork.Complete(); order = _orderRepository.GetById(order.Id); return(_mapper.Map <OrderDto>(order)); }
public Order Create(Order order) { try { _orderRepository.Add(order); _unitOfWork.Commit(); return(order); } catch (Exception ex) { throw; } }
public void Create(OrderViewModel orderVm) { var order = _mapper.Map <OrderViewModel, Order>(orderVm); var orderDetails = _mapper.Map <List <OrderDetailViewModel>, List <OrderDetail> >(orderVm.OrderDetails); foreach (var detail in orderDetails) { var product = _productRepository.FindById(detail.ProductId); detail.Price = product.Price; } order.OrderDetails = orderDetails; _orderRepository.Add(order); }
/// <summary> /// 处理建立订单命令 /// </summary> /// <param name="request">建立订单命令</param> /// <param name="cancellationToken">取消Token</param> /// <returns>处理结果</returns> public async Task <bool> Handle(CreateOrderCommand request, CancellationToken cancellationToken) { var address = new Address(request.Street, request.City, request.State, request.Country, request.ZipCode); var order = new Order(request.UserId, request.UserName, address, request.CardTypeId, request.CardNumber, request.CardSecurityNumber, request.CardHolderName, request.CardExpiration); foreach (var item in request.OrderItems) { order.AddOrderItem(item.ProductId, item.ProductName, item.UnitPrice, item.Discount, item.PictureUrl, item.Units); } _orderRepository.Add(order); return(await _orderRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken)); }
public void TestAdd() { Guid id = Guid.NewGuid(); var order = new Order(id) { Name = "Name", Code = "Code" }; _orderRepository.Add(order); _unitOfWork.Commit(); var result = _orderRepository.Single(t => t.Id == id); Assert.Equal(id, result.Id); }
public async Task <IActionResult> NewOrder(GeekBurguer.Orders.Contract.NewOrderMessage request) { try { await _orderRepository.Add(request); _logService.SendMessagesAsync("NewOrder"); return(Ok(request)); } catch (Exception) { return(BadRequest()); } }
/// <summary>AddOrder Handle</summary> /// <param name="request">The request</param> /// <param name="cancellationToken">Cancellation token</param> /// <returns>Response from the request</returns> public async Task <object> Handle(OrderAddCommandArgs request , CancellationToken cancellationToken) { if (!request.IsValid()) { return(await Task.FromResult(request.ValidationResult)); } Order order = new Order(request.Id, request.TotalPrice, request.OrderItems); Order result = repository.Add(order); await unitOfWork.Commit(); return(await Task.FromResult(result)); }
public void Setup() { var item1 = new OrderRecord() { Id = 1, Status = "Received" }; var item2 = new OrderRecord() { Id = 2, Status = "Received" }; var item3 = new OrderRecord() { Id = 3, Status = "Received" }; repository.Add(item1); repository.Add(item2); repository.Add(item3); }
public async Task Handle(OrderPlaced message, IMessageHandlerContext context) { var newOrder = new Order { OrderId = message.OrderId, CustomerId = message.CustomerId, Products = message.Products, State = OrderState.Received }; await orders.Add(newOrder); this.log.Info($"Order {message.OrderId} received. Waiting for confirmation."); }
public int Add(Order order) { if (order.Books.Any()) { AddBook(order); } var response = _orderRepository.Add(order); if (response != 0) { _logService.Log(order, "Add"); } return(response); }
public Order SetOrder(User user, decimal totalCost, string payment) { var paymentManager = new PaymentManager(_paymentRepository, _unitOfWork); var order = new Order() { User = user, TotalCost = (int)totalCost, Payment = paymentManager.GetPaymentByName(payment) }; _orderRepository.Add(order); _unitOfWork.Commit(); return(order); }
public AddOrderResponse Add(Order order) { AddOrderResponse response = new AddOrderResponse(); if (!ValidateOrder(order)) { response.Success = false; return(response); } response.order = _or.Add(order.OrderDate, order); response.Success = true; response.Message = ("Order successfully added to the repository."); return(response); }
public IActionResult Create(Order model) { Product prod = _productRepo.GetProduct(model.ProductID); Order newOrder = new Order { CustomerID = model.CustomerID, ProductID = model.ProductID, Amount = (float)Convert.ToDouble(prod.Amount), Date = DateTime.Now }; _OrderRepo.Add(newOrder); return(RedirectToAction("Details", new { id = newOrder.ID })); }
public IActionResult PostOrder([FromBody] Order Order) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _orderRepository.Add(Order); if (Order.Id == 0 || Order.Quantity <= 0) { return(CreatedAtRoute("GetForCustomer", new { customerId = Order.CustomerId }, new StringContent("Order was removed"))); } return(CreatedAtRoute("GetOneForCustomerAndProduct", new { customerId = Order.CustomerId, productId = Order.ProductId }, Mapper.Map <Order, Order>(Order))); }
public Order PlaceOrder(Cart cart) { var cartLineItemPrices = cart.CartLineItems.ToDictionary(cli => cli.Id, cli => _priceService.GetCartLineItemPrice(cli)); var order = new Order(Guid.NewGuid(), cart, cartLineItemPrices); var price = _priceService.GetTotalCartPrice(cart); order.Total = price; _orderRepository.Add(order); DomainEvents.Raise(new OrderPlacedEvent(order.Id, order.CustomerId)); return(order); }
public void Add(OrderViewModel order) { _unitOfWork.BeginTransaction(); foreach (var productId in order.Products) { var product = _productRepository.GetById(productId); var user = _userRepository.GetById(order.User.Id); var addOrder = new Order(Guid.NewGuid(), order.Quantity, user, product); _orderRepository.Add(addOrder); } _unitOfWork.Commit(); }
public Order Add(Order order) { try { order.OrderStatusId = (int)eOrderStatus.ChoXacNhan; _orderRepository.Add(order); _unitOfWork.Commit(); return(order); } catch (Exception ex) { throw ex; } }
public async Task <IActionResult> Post(CreatingOrderModel model) { if (ModelState.IsValid) { var client = await clientRepository.Read(model.CLientId); if (client == null) { return(NotFound($"Cliente com Id {model.CLientId} não foi encontrado.")); } var order = new Order { Client = client, Items = model.Items, Date = DateTime.Now, }; foreach (var item in model.Items) { var p = await productRepository.Read(item.ProductId); if (p == null) { return(NotFound($"Produto com Id {item.ProductId} não foi encontrado.")); } if (item.Quantity > p.Quantity) { return(BadRequest("Quantidade em estoque insuficiente.")); } item.Discound = p.Discount; item.Value = p.SalePrice; p.Quantity -= item.Quantity; var total = (p.SalePrice * item.Quantity); order.Value += total - (total * p.Discount); } client.Debt += order.Value; await orderRepository.Add(order); var url = Url.Action("Get", new { id = order.Id }); var created = Created(url, order); return(created); } return(BadRequest(ModelState)); }
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 async Task <Unit> Handle(PlaceOrderCommand request, CancellationToken cancellationToken) { // todo make idempotent var order = Order.Place(request.CustomerName, request.OrderLines .Select(l => Line.New(l.ProductName, l.Quantity)) .ToArray()); await _repository.Add(order); var eventTasks = order.Events.Select(e => _mediator.Publish(e, cancellationToken)); await Task.WhenAll(eventTasks); return(Unit.Value); }
public Order AddOrder(OrderViewModel orderView) { Order order = new Order { CustomerId = orderView.CustomerId, EmployeeId = orderView.EmployeeId, OrderId = orderView.OrderId, ShipAddress = orderView.ShipAddress, ShipName = orderView.ShipName }; _orderRepository.Add(order); _orderRepository.SaveChanges(); return(order); }
public IHttpActionResult Add(Order order) { var NameOfItem = order.NameOfItem; var Quantity = order.Quantity; if (NameOfItem.Equals(null) || Quantity.Equals(null)) { return(NotFound()); } else { //var ReturnofOrderRepository = _orderRepository.Add(order); return(ResponseMessage(Request.CreateResponse(HttpStatusCode.OK, _orderRepository.Add(order)))); } }
void SaveOrder(Order order) { var entityValidator = EntityValidatorFactory.CreateValidator(); if (entityValidator.IsValid(order))//if entity is valid save. { //add order and commit changes _orderRepository.Add(order); _orderRepository.UnitOfWork.Commit(); } else // if not valid throw validation errors { throw new ApplicationValidationErrorsException(entityValidator.GetInvalidMessages(order)); } }
public void Handle(CreateOrderRequest command) { OrderAggregate order = AggregateFactory.Create <OrderAggregate>(); order.AddCustomerDetail(command.CustomerDetail); order.AddOrderLineItems(command.OrderLines); using (IUnitOfWork uow = this.CreateUnitOfWork <OrderAggregate>()) { IOrderRepository repository = IoC.Container.Resolve <IOrderRepository>(uow); repository.Add(order); uow.Commit(); order.AddEvent(new OnOrderCreated(order.Id)); } order.PublishEvents(); }
public void CreateOrder(ShoppingCart cart, Customer customer) { double orderTotal = 0; foreach (var product in cart.Items.Keys) { cart.Location.Inventory[product] -= cart.Items[product]; orderTotal += product.Price * cart.Items[product]; } var order = new Orders(cart, customer, orderTotal); _order.Add(order); _location.Update(cart.Location); }
private async Task <Order> CreateNewOrder() { Order lastOrder = await _orderRepository.GetLastOrderAsync(); var order = new Order() { OrderDate = DateTime.Now.Date, OrderNumber = lastOrder.OrderNumber + 1, StateId = 1, ShippingDate = DateTime.Now.Date }; _orderRepository.Add(order); return(order); }
public async Task <Result> Handle(CreateOrderCommand message, CancellationToken cancellationToken) { var address = new Address(message.Street, message.City, message.Country, message.ZipCode); var order = new Order(message.UserId, message.UserName, address); foreach (var item in message.OrderItems) { order.AddOrderItem(item.ProductId, item.ProductName, item.UnitPrice, item.Discount, item.PictureUrl, item.Units); } _orderRepository.Add(order); await _orderRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken); return(Result.Success()); }
public bool Add(Order order) { var model = Order.Validate(order); if (model.Validations == null || model.Validations.ToArray().Length == 0) { return(_orderRepository.Add(order)); } else { this.Message = model.Validations; } return(false); }