public int CreateOrder(CreateOrderDTO createOrderDTO)
{
var products = createOrderDTO.OrderDetails.Select(x => x.ProductId).ToList();
var order = new Order()
{
OrderDate = DateTime.Now,
PaymentMethod = createOrderDTO.PaymentMethod,
OrderStatus = OrderStatus.InProgress.ToString(),
PaymentStatus = PaymentStatus.unPaid.ToString(),
Total = dBContext.Product.Where(x => products.Contains(x.Id)).Select(x => x.Price * createOrderDTO.OrderDetails.Where(z => z.ProductId == x.Id).Select(z => z.Quanitity).First() + x.ShippingCost).Sum(),
UserId = createOrderDTO.UserId,
};
dBContext.Order.Add(order);
dBContext.SaveChanges();
foreach (var item in createOrderDTO.OrderDetails)
{
var OrderDetails = new Entities.OrderDetails()
{
OrderId = order.Id,
ProductId = item.ProductId,
Quantity = item.Quanitity,
};
dBContext.OrderDetails.Add(OrderDetails);
}
dBContext.SaveChanges();
return(order.Id);
}
public bool IsCreatedToday(CreateOrderDTO dto, int pharmacyId)
{
return(WarehouseId == dto.WarehouseId &&
PharmacyId == pharmacyId &&
OrderStateId == OrderStateId.Created &&
CreationDate.Date == DateTime.Now.Date);
}
public static Helpers.Common.Result ReturnModelMessage(CreateOrderDTO insertOrder)
{
var result = new Helpers.Common.Result();
if (insertOrder.Name == "string".ToLower())
{
result.ModelMessageList.Add(o => o.Name, " Please Enter the Name", false);
return(result);
}
if (insertOrder.costPerItem == 0)
{
result.ModelMessageList.Add(o => o.Payment, " Please Enter the CostPer item, Even though it takes $20/Quantity", false);
return(result);
}
else if (insertOrder.Quantity == 0)
{
result.ModelMessageList.Add(o => o.Quantity, "Please Enter the Quantity", false);
return(result);
}
else if (insertOrder.Shipping.ShippingType == "string".ToLower())
{
result.ModelMessageList.Add(o => o.Shipping, " Please enter ShippingType", false);
return(result);
}
else
{
result.ModelMessageList.Add(o => o.Name, " Fields validation are done", true);
return(result);
}
}
/// <summary>
/// Creert een order uit het gegeven viewmodel
/// </summary>
/// <param name="dto">Viewmodel met de nodige data voor het aanmaken van een nieuw order</param>
/// <returns>Nieuw aangemaakt order</returns>
/// <exception cref="EntityNotFoundException">Wordt gegooid wanneer een persoon in het order of in een orderline niet gevonden werd.</exception>
public async Task <Order> CreateOrder(CreateOrderDTO dto, string userEmail)
{
var orderedBy = await _leidingRepository.FindByEmailAsync(userEmail);
if (orderedBy == null)
{
throw new EntityNotFoundException($"Besteller '{userEmail}' werd niet gevonden.");
}
var newOrder = Order.Create(orderedBy);
await _orderRepository.AddAsync(newOrder);
foreach (var lineModel in dto.Orderlines)
{
var drank = await _drankRepository.FindByIdAsync(lineModel.DrankId);
if (drank == null)
{
throw new EntityNotFoundException($"Drank met id {lineModel.DrankId} werd niet gevonden");
}
var orderedFor = await _leidingRepository.FindByIdAsync(lineModel.OrderedForId);
if (orderedFor == null)
{
throw new EntityNotFoundException($"Persoon met id {lineModel.OrderedForId} werd niet gevonden.");
}
var personCanOrder = orderedFor.Tak.TabIsAllowed;
if (!personCanOrder)
{
throw new InvalidOperationException($"Leden van {orderedFor.Tak.Naam} kunnen geen gebruik maken van de Poef.");
}
var orderline = Orderline.Create(drank, orderedFor, newOrder, lineModel.Quantity);
await _orderlineRepository.AddAsync(orderline);
//Create a transaction for the submitted order
var amount = orderline.DrinkPrice * orderline.Quantity;
amount = -amount;
var transaction = new Transaction(amount, $"{orderline.Quantity}x {orderline.Drank.Naam}");
var account = await _accountRepository.FindAccountAsync(orderedFor.Id, AccountType.Tab);
if (account == null)
{
account = await _accountService.CreateAccountAsync(orderedFor.Id);
}
account.AddTransaction(transaction);
}
await _orderRepository.SaveChangesAsync();
return(newOrder);
}
public Order CreateOrder(CreateOrderDTO order)
{
var cart = _context.Cart
.Include(x => x.CartProducts)
.FirstOrDefault(x => x.Id == order.CartId);
var orderToCreate = CreateEmptyOrder(order);
orderToCreate.Status = "Jauns";
foreach (var item in cart.CartProducts)
{
var orderItem = new OrderItem
{
OrderId = orderToCreate.Id,
Amount = item.Amount,
ProductId = item.ProductId
};
_context.Add(orderItem);
}
_context.SaveChanges();
var orderToReturn = _context.Order
.Include(x => x.Customer)
.Include(x => x.OrderItems)
.ThenInclude(x => x.Product)
.ThenInclude(x => x.ProductImages)
.FirstOrDefault(x => x.Id == orderToCreate.Id);
return(orderToReturn);
}
public ActionResult SaveNewOrder(CreateOrderDTO createOrderDTO)
{
if (!ModelState.IsValid)
{
List <SelectListItem> listProducts = new List <SelectListItem>();
foreach (var product in Gateway.GetAllProducts())
{
listProducts.Add(new SelectListItem()
{
Text = product.Name, Value = product.Id.ToString()
});
}
createOrderDTO.Products = listProducts;
return(View(ActionsOrder.CreateOrder.ToString(), createOrderDTO));
}
try
{
Gateway.SaveNewOrder(createOrderDTO, (long)Session["IdClientSelected"]);
return(RedirectToAction(ActionsOrder.Index.ToString()));
}
catch (Exception ex)
{
throw;
}
}
public ActionResult CreateOrder()
{
if (Session["IdClientSelected"] == null)
{
return(RedirectToAction(UserController.ActionsUser.ChangeUser.ToString(), ControllerHelpers.UserController, new { type = TypeOfMessageEnum.Error.ToString(), msg = Resources.GetMessage("ErrorMustSelectAClient") }));
}
try
{
List <SelectListItem> listProducts = new List <SelectListItem>();
foreach (var product in Gateway.GetAllProducts())
{
listProducts.Add(new SelectListItem()
{
Text = product.Name, Value = product.Id.ToString()
});
}
CreateOrderDTO createOrderDTO = new CreateOrderDTO(listProducts);
return(View(createOrderDTO));
}
catch (Exception ex)
{
throw;
}
}
public async Task Handle(UserCheckoutAcceptedEvent @event)
{
var dto = new CreateOrderDTO(@event.OrderItems, @event.UserId, @event.City, @event.Street,
@event.State, @event.Country, @event.ZipCode, @event.Description);
// IdentifiedCommand<> 必须保证只执行一次
await _commandBus.CreateOrder(dto);
}
public async Task <ActionResult> Create([FromBody] CreateOrderDTO orderDTO)
{
Order order = _mapper.Map <Order>(orderDTO);
await _orderRepository.CreateAsync(order);
return(CreatedAtRoute("GetOrderById", new { order.Id }, order));
}
public async Task <OrderDTO> CreateOrder(EventDTO eventData, CreateOrderDTO order)
{
// validate
var now = dateTimeProvider.Now;
await ValidateEventAvailability(now, order, eventData);
// create the order
var orderData = Mapper.Map <Order>(order);
InitializeOrder(eventData, orderData, now);
// calculate prices
await CalculatePrices(eventData, orderData, invalidateDiscountCoupon : true);
// assign order id
await GenerateOrderNumber(orderData);
// save
await collection.InsertOneAsync(orderData);
// create registrations
await CreateRegistrations(eventData, order, orderData);
// publish message
await orderCreatedPublisher.PublishEvent(new OrderCreated()
{
OrderId = orderData.Id, EventId = orderData.EventId
});
return(Mapper.Map <OrderDTO>(orderData));
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderDTO dto)
{
try
{
_orderDtoValidator.ValidateCreateOrderDto(dto);
var user = await GetCurrentUser();
if (user.PharmacyId == null)
{
return(ApiUnauthorized());
}
int pharmacyId = (int)user.PharmacyId;
await _ordersManager.TryCreateOrder(dto, pharmacyId);
return(Created());
}
catch (DtoValidationException ex)
{
return(ApiBadRequest(ex.Message, ex.Parameter));
}
catch (ResourceNotFoundException ex)
{
return(ApiNotFound(ex.Message, ex.Parameter));
}
catch (DuplicateObjectException ex)
{
return(ApiBadRequest(ApiErrorSlug.ObjectAlreadyExists, ex.Message));
}
}
public BaseDTO Create(object data)
{
Response response = new Response();
var type = new CreateOrderDTO();
if (data.GetType() == type.GetType())
{
var token = AuthorizationService.Authorize(_authParameters.ClientId, _authParameters.ClientSecret, _authParameters.StoreName);
var url = HelperFunctions.CreateUrlFromParts(_authParameters.StoreName, Constants.apiOrder, string.Empty, token.access_token);
var result = HelperFunctions.HttpPost(url, data).GetAwaiter().GetResult();
if (result != null)
{
return(result);
}
else
{
return(new BaseDTO()
{
code = (int)HttpStatusCode.BadRequest,
});
}
}
else
{
throw new System.Exception("Not suppoerted type of parameter");
}
}
public string CreateNewOrder(CreateOrderDTO dto)
{
var orderId = _orderRepository.CreatOrder(dto);
Console.WriteLine($"One order created: {JsonConvert.SerializeObject(dto)}");
return(orderId);
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderDTO dto)
{
// [FromRoute] Guid id
var request = new CreateOrder(dto.OrderId, dto.CustomerId, dto.ParcelId);
var result = await _mediator.Send(request);
return(Ok());
}
private async Task <Order> CreateNewOrder(CreateOrderDTO dto, IEnumerable <ProductBalance> productBalances,
int pharmacyId)
{
string pharmacyAddress = await GetPharmacyAddress(pharmacyId);
string warehouseAddress = await GetWarehouseAddress(dto.WarehouseId);
return(new Order(dto, pharmacyAddress, warehouseAddress, pharmacyId, productBalances));
}
public async Task <ActionResult <Order> > PostOrder(CreateOrderDTO orderDTO)
{
Order order = new Order(orderDTO.Date, orderDTO.CustomerId);
_context.Order.Add(order);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrder", new { id = order.Id }, order));
}
public async Task Cant_Place_Order_If_OrderedFor_Section_Cant_Use_Tab()
{
var section = new Tak()
{
TabIsAllowed = false
};
var person = new Leiding()
{
Tak = section
};
var account = new Account(AccountType.Tab);
person.Accounts = new List <Account> {
account
};
var order = Order.Create(person);
var orderline = Orderline.Create(_defaultDrank, person, order, 1);
var orderRepository = new Mock <IOrderRepository>();
var leidingRepo = new Mock <ILeidingRepository>();
leidingRepo.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).Returns(Task.FromResult <Leiding>(person));
leidingRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Leiding>(person));
var drankRepo = new Mock <IDrankRepository>();
drankRepo.Setup(x => x.FindByIdAsync(It.IsAny <int>())).Returns(Task.FromResult <Drank>(_defaultDrank));
var orderlineRepo = new Mock <IOrderlineRepository>();
var accountRepo = new Mock <IAccountRepository>();
accountRepo.Setup(x => x.FindAccountAsync(It.IsAny <int>(), AccountType.Tab))
.Returns(Task.FromResult <Account>(account));
var accountService = new Mock <IAccountService>();
var service = new OrderService(orderRepository.Object, leidingRepo.Object, drankRepo.Object, orderlineRepo.Object, accountRepo.Object, accountService.Object);
var orderlines = new List <CreateOrderlineDTO>();
orderlines.Add(item: new CreateOrderlineDTO
{
DrankId = 10,
OrderedForId = 10,
Quantity = 10
});
var orderDto = new CreateOrderDTO()
{
Orderlines = orderlines
};
await Assert.ThrowsAsync <InvalidOperationException>(() => service.CreateOrder(orderDto, String.Empty));
}
public void CreateOrder(CreateOrderDTO orderDto)
{
var items = new List <OrderItem>();
var user = this.context.Users.Include(x => x.CartItems).SingleOrDefault(x => x.Id == orderDto.UserId);
user.CartItems.ForEach(x =>
{
items.Add(new OrderItem()
{
ItemId = x.ItemId
});
});
if (orderDto.BillingAddres.Country == null)
{
orderDto.BillingAddres.Country = orderDto.ShippingAddres.Country;
}
if (orderDto.BillingAddres.ZipCode == null)
{
orderDto.BillingAddres.ZipCode = orderDto.ShippingAddres.ZipCode;
}
if (orderDto.BillingAddres.Street == null)
{
orderDto.BillingAddres.Street = orderDto.ShippingAddres.Street;
}
if (orderDto.BillingAddres.HouseNumberAndDoor == null)
{
orderDto.BillingAddres.HouseNumberAndDoor = orderDto.ShippingAddres.HouseNumberAndDoor;
}
var order = new Order()
{
UserId = orderDto.UserId,
OrderStatus = Dal.Enums.OrderStatus.New,
PaymentMethod = EnumExtensionMethods.GetValueFromDescription <PaymentMethod>(orderDto.PaymentMethod),
Items = items,
BillingAddress = orderDto.BillingAddres,
ShippingAddress = orderDto.ShippingAddres,
OrderDate = DateTime.Now,
DeliveryDate = null,
Comment = orderDto.Comment
};
this.context.Orders.Add(order);
this.context.SaveChanges();
order.Items.ForEach(x => x.OrderId = order.Id);
user.CartItems.ForEach(x =>
{
context.UserCartItems.Remove(x);
});
this.context.SaveChanges();
}
public async Task <IActionResult> Post([FromBody] CreateOrderDTO model)
{
try {
await this.m_orderService.CreateOrderAsync(model);
return(this.Ok());
} catch (Exception exception) {
return(this.BadRequest(exception.Message));
}
}
public async Task <IActionResult> CreateOrder([FromBody] CreateOrderDTO dto)
{
var userEmail = User.FindFirstValue(ClaimTypes.Email);
var newOrder = await _orderService.CreateOrder(dto, userEmail);
var model = _mapper.Map <BasicOrderDTO>(newOrder);
return(Ok(model));
}
private void CreateOrder()
{
var createOrderDto = new CreateOrderDTO
{
CustomerId = 1,
ArticlesIds = new[] { 1 }
};
_service.CreateOrder(createOrderDto);
}
public async Task CreateOrder(CreateOrderDTO dto)
{
var order = new Order(
dto.UserId,
new Address(dto.Street, dto.City, dto.State, dto.Country, dto.ZipCode),
dto.Description,
dto.OrderItems.Select(x => x.ToOrderItem()).ToList());
order.RegisterDomainEvent(new OrderStartedEvent(Session.UserId, order.Id));
await _writeRepository.InsertAsync(order);
}
public void Create(CreateOrderDTO dto)
{
var order = new Order
{
Description = dto.Description,
Model = dto.Model,
CustomerId = 1
};
_dbContext.Orders.Add(order);
_dbContext.SaveChanges();
}
public async Task <Order> CreateOrder(string UserName, CartViewModel Cart, OrderViewModel OrderModel)
{
var create_order_model = new CreateOrderDTO
{
Items = Cart.ToDTO(),
Order = OrderModel,
};
var response = await PostAsync($"{Address}/{UserName}", create_order_model).ConfigureAwait(false);
var order_dto = await response.EnsureSuccessStatusCode().Content.ReadFromJsonAsync <OrderDTO>().ConfigureAwait(false);
return(order_dto.FromDTO());
}
public async Task <Order> CreateOrder(string userName, CartWebModel cart, OrderWebModel orderModel)
{
var model = new CreateOrderDTO
{
Order = orderModel,
Items = cart.ToDTO(),
};
var response = await PostAsync($"{Address}/{userName}", model).ConfigureAwait(false);
var order = await response.EnsureSuccessStatusCode().Content.ReadFromJsonAsync <OrderDTO>().ConfigureAwait(false);
return(order.FromDTO());
}
public async Task <IActionResult> Create(CreateOrderDTO createDto)
{
var dto = await service.Create(createDto);
if (dto != null)
{
return(Ok(dto));
}
else
{
return(NoContent());
}
}
public Order(CreateOrderDTO dto, string addressFrom, string addressTo, int pharmacyId,
IEnumerable <ProductBalance> productBalances)
{
AddressFrom = addressFrom;
AddressTo = addressTo;
CreationDate = DateTime.Now;
DeliveryDate = DetermineDeliveryDate(CreationDate);
OrderStateId = OrderStateId.Created;
TotalSum = CalculateTotalAmount(productBalances);
WarehouseId = dto.WarehouseId;
PharmacyId = pharmacyId;
OrderProductBalances = productBalances.Select(pb => new OrderProductBalance(this, pb)).ToList();
}
public async Task <Order> CreateOrderAsync(CreateOrderDTO createOrder)
{
StripeConfiguration.ApiKey = "sk_test_9lbV8iZ2EjD5TiOzTAFURm7H00TCPFae4M";
List <OrderItem> orderItemsToAdd = new List <OrderItem>();
double totalPrice = 0;
foreach (var orderItem in createOrder.OrderItems)
{
var product = await _context.Products.FindAsync(orderItem.ProductId);
product.Stock -= orderItem.Count;
await _bus.Publish(new ProductUpdateStockMessage
{
SpecificProductId = product.Id,
Stock = product.Stock
});
totalPrice += product.Price * orderItem.Count;
orderItemsToAdd.Add(
new OrderItem
{
Count = orderItem.Count,
ProductId = product.Id,
ProductName = orderItem.ProductName,
ProductPrice = product.Price,
ProductSize = orderItem.ProductSize,
ImageUrl = orderItem.ImageUrl
}
);
}
var order = new Order
{
UserId = createOrder.UserId,
Address = createOrder.Address,
CreatedAt = DateTime.UtcNow.AddHours(7),
Email = createOrder.Email,
UserName = createOrder.UserName,
PhoneNumber = createOrder.PhoneNumber,
TotalPrice = totalPrice,
OrderItems = orderItemsToAdd,
Status = OrderStatus.New,
PaymentType = createOrder.PaymentType
};
await _context.Orders.AddAsync(order);
await _context.SaveChangesAsync();
return(order);
}
private async Task ValidateEventAvailability(DateTime now, CreateOrderDTO order, EventDTO eventData)
{
if (now < eventData.RegistrationBeginDate || now > eventData.RegistrationEndDate)
{
throw new RegistrationClosedException();
}
var count = await eventsApi.ApiRegistrationsByEventIdCountGetAsync(eventData.Id);
if (count + order.OrderItems.Count > eventData.MaxAttendeeCount)
{
throw new RegistrationCapExceededException();
}
}
private Order CreateEmptyOrder(CreateOrderDTO order)
{
var orderToCreate = new Order
{
CustomerId = order.CustomerId,
DeliveryAddress = order.DeliveryAddress,
TotalSum = order.TotalSum
};
_context.Add(orderToCreate);
_context.SaveChanges();
return(orderToCreate);
}
