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);
}
