public async Task <Invoice> UpdateInvoice(Invoice invoice, Domain.Entities.Order order)
{
ApplicationContext applicationContext = new()
{
ReturnUrl = Path.Combine(_paymentProviderOptions.ReturnUrl, order.Id),
CancelUrl = _paymentProviderOptions.CancelUrl
};
PaypalOrder paypalOrder = await _paypalService.GetOrder(invoice.Transaction);
PaypalOrder paypalOrderNew = await _paypalService.CreatePaypalOrder(paypalOrder.PurchaseUnits.Select(x => new PurchaseUnitRequest()
{
AmountWithBreakdown = x.AmountWithBreakdown,
CustomId = x.CustomId,
Description = x.Description
}), applicationContext);
await _paypalService.CancelInvoice(invoice.Transaction);
Uri uri = new(paypalOrderNew.Links.Single(l => l.Rel == "approve").Href);
invoice.Link = uri;
invoice.Transaction = paypalOrderNew.Id;
return(invoice);
}
}
public async Task Consume(ConsumeContext <IAvailableDriverFound> context)
{
var message = context.Message;
var order = new Domain.Entities.Order(message.CustomerId, message.DriverId);
order.SetExecutionCountry(_orderService.GetExecutionCountry(message.DestinationPoint.Country));
order.SetPaymentAmount(_orderService.GetPaymentAmount(
string.Join(" ", message.StartPoint.Street, message.StartPoint.HouseNumber),
message.StartPoint.City,
message.StartPoint.State,
string.Join(" ", message.DestinationPoint.Street, message.DestinationPoint.HouseNumber),
message.DestinationPoint.City,
message.DestinationPoint.State,
message.DestinationPoint.Country));
var money = _mapper.Map <Money>(order.PaymentAmount);
order.AddDomainEvent(new OrderCreated(
message.CustomerId,
message.DriverId,
money,
message.CustomerDetails,
message.DriverDetails,
message.StartPoint,
message.DestinationPoint));
_unitOfWork.Add(order);
await _unitOfWork.CommitAsync();
}
public async Task <Invoice> CreateInvoice(Domain.Entities.Order order)
{
List <PurchaseUnitRequest> purchaseUnits = new();
purchaseUnits.Add(new()
{
CustomId = order.Id,
Description = "Venta de Productos",
AmountWithBreakdown = new AmountWithBreakdown()
{
CurrencyCode = order.Currency.ToString(),
Value = Convert.ToInt32(order.TotalAmount).ToString()
}
});
ApplicationContext applicationContext = new()
{
ReturnUrl = Path.Combine(_paymentProviderOptions.ReturnUrl, order.Id),
CancelUrl = _paymentProviderOptions.CancelUrl
};
PaypalOrder payPalOrder = await _paypalService.CreatePaypalOrder(purchaseUnits, applicationContext);
Uri uri = new(payPalOrder.Links.Single(l => l.Rel == "approve").Href);
return(new()
{
Link = uri,
Transaction = payPalOrder.Id,
PaymentProvider = PaymentProvider.PayPal,
OrderId = order.Id
});
}
public async Task <Order> Set(Order order)
{
var updated = await
Redis
.StringSetAsync(order.Id.ToString(), JsonConvert.SerializeObject(order));
if (!updated)
{
return(null);
}
return(await Get(order.Username));
}
public CompleteOrderTestFixtures(QueryTestFixture fixture)
{
Context = fixture.Context;
Order = new Domain.Entities.Order()
{
Id = Guid.NewGuid(),
AcceptedByUserId = Guid.NewGuid(),
Complete = false
};
Context.Order.Add(Order);
Context.SaveChanges();
}
public AcceptOrderTestsFixture(QueryTestFixture fixture)
{
Context = fixture.Context;
AcceptedOrder = new Domain.Entities.Order()
{
Id = Guid.NewGuid(),
AcceptedByUserId = Guid.NewGuid()
};
PendingOrder = new Domain.Entities.Order()
{
Id = Guid.NewGuid(),
};
Context.Order.Add(AcceptedOrder);
Context.Order.Add(PendingOrder);
Context.SaveChanges();
}
private async Task SendMail(Domain.Entities.Order order)
{
var email = new Email
{
To = order.EmailAddress,
Subject = $"Order {order.Id} confirmation",
Body = "Order was created"
};
try
{
await _emailService.SendEmail(email);
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to send confirmation email for order: {order.Id}");
}
}
private async Task SendMail(Domain.Entities.Order order)
{
var email = new Email()
{
To = "*****@*****.**", Body = $"Order was created.", Subject = "Order was created"
};
try
{
await _emailService.SendEmail(email);
_logger.LogInformation($"Order was successfully created.");
}
catch (Exception ex)
{
_logger.LogError($"Order {order.Id} failed due to an error with the mail service: {ex.Message}");
}
}
public async Task <int> Handle(CreateOrderComamand request, CancellationToken cancellationToken)
{
var order = new Domain.Entities.Order
{
Status = Domain.Enums.OrderStatus.Created,
CreatedDate = DateTime.UtcNow,
CustomerId = 1,
OrderItems = request.OrderItems.Select(s => new Domain.Entities.OrderItem
{
Count = s.Count,
PricePerUnit = 100,
ProductId = 1,//s.ProductId,
SellerId = 11
}).ToList()
};
await _context.Orders.AddAsync(order);
await _context.SaveChangesAsync(cancellationToken);
return(order.Id);
}
public async Task <IActionResult> Post(Domain.Entities.Order order)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
await context.Orders.AddAsync(order);
await context.SaveChangesAsync();
var emailBody = JsonSerializer.Serialize(order);
await this.emailService.SendEmailAsync("*****@*****.**", "*****@*****.**", "A new order has been creation", emailBody);
}
catch (Exception ex)
{
await this.emailService.SendEmailAsync("*****@*****.**", "*****@*****.**", "Create Order Exception", ex.ToString());
}
return(CreatedAtAction(nameof(Get), new { id = order.Id }, order));
}
public async Task <Unit> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var user = await _context.User.FirstOrDefaultAsync(u => u.Id == request.CreatedByUserId, cancellationToken);
if (user == null)
{
throw new NotFoundException(nameof(user), request.CreatedByUserId.ToString());
}
var address = await _context.Address.FirstOrDefaultAsync(a => a.Id == request.AddressId, cancellationToken);
if (address == null)
{
throw new NotFoundException(nameof(address), request.AddressId.ToString());
}
var entity = new Domain.Entities.Order
{
Address = address,
CreatedBy = request.CreatedByUserId,
Description = request.Description,
Registration = request.Registration,
Make = request.Make,
Model = request.Model,
Trim = request.Trim,
Tyre = request.Tyre,
Year = request.Year,
Availability = _mapper.Map <IEnumerable <Availability> >(request.Availability)
};
_context.Order.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public void CreateOrder(OrderDto orderDto)
{
UseDb(uow =>
{
var orderItems = new List <OrderItem>(orderDto.Items.Count);
foreach (var x in orderDto.Items)
{
for (int i = 0; i < x.Quantity; i++)
{
orderItems.Add(new OrderItem
{
PizzaId = x.PizzaId,
IsModified = x.IsModified,
StartTime = x.StartTime,
EndTime = x.EndTime,
Price = x.Price
});
}
}
var entity = new Domain.Entities.Order
{
UserId = orderDto.UserId,
Price = orderItems.Sum(x => x.Price),
PizzaHouseId = orderDto.PizzaHouseId,
TimeToTake = orderDto.TimeToTake,
Status = orderDto.Status,
Items = orderItems
};
uow.Orders.Create(entity);
uow.Save();
});
}
public static OrderDto Create(Domain.Entities.Order order)
{
return(Projection.Compile().Invoke(order));
}
public async Task <Domain.Entities.UserOrder> LinkUserToOrderAsync(Guid userId, Domain.Entities.Order order)
{
var userOrder = new Domain.Entities.UserOrder
{
UserId = userId,
Order = order
};
try
{
userOrder = await _unitOfWork.UserOrderRepository.CreateAsync(userOrder);
await _unitOfWork.SaveChangesAsync();
}
catch (Exception ex) when
(ex is DbUpdateException || ex is ArgumentNullException)
{
throw new FailedToAddDatabaseResourceException("Failed to link user to order");
}
return(userOrder);
}
public ProductIdOrderProductMustBeUnique(Domain.Entities.Order order, Guid productId)
{
this.order = order;
this.productId = productId;
}
