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