public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync(cancellationToken);
var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
await _messageOutbox.Send(orderStatusChangedTosubmittedIntegrationEvent);
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync();
var orderStatusChangedTosubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
await _orderingIntegrationEventService.PublishThroughEventBusAsync(orderStatusChangedTosubmittedIntegrationEvent);
_logger.CreateLogger(nameof(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {orderStartedEvent.Order.Id}.");
}
public async Task Handle(OrderStartedDomainEvent @event, CancellationToken cancellationToken)
{
//Side effects of creating an order is to create a buyer (if it does not exist)
//var buyer = new BuyerInfo(@event.UserName, @event.UserId, @event.Order.Id, doesBuyerExistService);
//buyer=buyerRepository.Upsert(buyer);
var buyer = await buyerRepository.FindAsync(@event.UserId);
if (buyer == null)
{
logger.LogInformation("buyer didn't exist");
buyer = new Buyer(@event.UserName, @event.UserId, @event.Order.Id);
logger.LogInformation("buyer instantiated");
buyer = buyerRepository.Add(buyer);
}
//Probably the wrong way
buyer.AddDomainEvent(new BuyerCreatedDomainEvent(@event.Order.Id, buyer.Id, buyer.Name, buyer.IdentityGuid));
logger.LogInformation("BuyerCreatedDomainEvent added to list of buyer events");
await buyerRepository.UnitOfWork.SaveChangesAsync();
logger.LogInformation("SaveChanges called on buyer");
}
/// <summary>
/// 处理
/// </summary>
/// <param name="orderStartedDomainEvent">订单已开始领域事件</param>
/// <param name="cancellationToken">取消Token</param>
/// <returns>任务</returns>
public async Task Handle(OrderStartedDomainEvent orderStartedDomainEvent, CancellationToken cancellationToken)
{
var buyer = await _buyerRepository.FindAsync(orderStartedDomainEvent.UserId);
var existBuyer = buyer != null;
if (!existBuyer)
{
buyer = new Buyer(orderStartedDomainEvent.UserId, orderStartedDomainEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(orderStartedDomainEvent.CardTypeId,
$"Payment Mehtod on {DateTime.Now}",
orderStartedDomainEvent.CardNumber,
orderStartedDomainEvent.CardSecurityNumber,
orderStartedDomainEvent.CardHolderName,
orderStartedDomainEvent.CardExpiration,
orderStartedDomainEvent.Order.Id);
_ = existBuyer ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
//分发领域事件
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync();
}
public void RegisterOrder(OrderRequest request)
{
// #TODO error handling, e.g. network failure
buyerRepository.Add(request.Buyer);
RegisterOrder(request.Buyer.ID, request.Seller.ID, request.Items, request.DeliveryMethod);
}
/// <summary>
/// Request new Quotation
/// </summary>
/// <param name="model"></param>
public void RequestQuote(QuotationViewModel model)
{
Buyer buyer = new Buyer();
if (model.BuyerId != null)
{
// retrieve existing buyer
buyer = _buyerRepository.GetById(model.BuyerId.Value);
}
else
{
// create a new buyer and add it to the db
buyer = _buyerRepository.Add(new Buyer(model.FullName, model.ContactEmail, model.PhoneNumber)
{
ShippingAddress = new Address(model.StreetAddress, model.City, model.State, model.Country, model.ZipCode),
BillingAddress = new Address(model.StreetAddress, model.City, model.State, model.Country, model.ZipCode)
});
}
List <OrderItem> orderItems = model.OrderItems
.Select(o => new OrderItem {
PartNumber = o.PartNumber, Quantity = o.Quantity
}).ToList();
_orderService.CreateOrder(buyer.Id, orderItems);
}
public void AddBuyer(Buyer buyer)
{
if (buyer == null)
{
throw new ArgumentNullException(nameof(buyer));
}
var currentBuyer = _buyerRepository.GetById(buyer.Id);
if (currentBuyer != null)
{
throw new Exception("Buyer already exist.");
}
currentBuyer.Name = "joao";
buyer.AddContact(new Contact()
{
Description = "michel"
});
_buyerRepository.Add(buyer);
_unityOfWork.Commit();
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = _buyerRepository.Find(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer != null);
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
_buyerRepository.UnitOfWork.SaveEntities();
//Not showing the implementation of this event handler in other aggregate roots
var statusChangedToSubmittedIntegrationEvent
= new OrderStatusChangedToSubmittedIntegrationEvent(
orderStartedEvent.Order.Id, orderStartedEvent.Order.OrderStatus.Name, buyer.Name);
_orderingIntegrationEventService.PublishThroughEventBus(statusChangedToSubmittedIntegrationEvent);
_logger.LogInformation($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: " +
$"{orderStartedEvent.Order.Id}.");
}
public ValidationResult Add(Buyer buyer)
{
if (!buyer.IsValid)
{
return(buyer.ValidationErrors.ToValidationResult());
}
_validationResult.Entity = _repository.Add(buyer);
return(_validationResult);
}
public IActionResult Create([FromBody] Buyer value)
{
if (value == null)
{
return(BadRequest());
}
_repository.Add(value);
// return CreatedAtRoute("GetBuyer", new { id = value.UserId }, value);
return(new NoContentResult());
}
public DataAgent <long> AddBuyer(BuyerInputModel buyerInputModel)
{
var dto = _mapper.Map <BuyerDto>(buyerInputModel);
dto.BuyerStatus = new BuyerStatusDto {
Id = (int)BuyerStatus.Regular
};
var creationResult = _buyerRepo.Add(dto);
return(creationResult);
}
public override async Task Handle(BuyerCreatedIntegrationEvent notification, CancellationToken cancellationToken)
{
var buyer = new Buyer(notification.Id, notification.Cpf, notification.Name);
_buyerRepository.Add(buyer);
if (!await _uow.Commit())
{
_logger.LogCritical($"Ocorreu um erro ao criar um novo comprador via evento id = {notification.Id}");
}
}
public async Task Handle(OrderStartedDomainEvent domainEvent, CancellationToken cancellationToken)
{
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Handling OrderStartedDomainEvent domain event: {0}",
JsonConvert.SerializeObject(domainEvent));
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Looking for buyer: {0}", domainEvent.Buyer);
Buyer buyer = _buyerRepository.FindByNameAsync(domainEvent.Buyer);
var isBuyerExisted = buyer != null;
if (isBuyerExisted)
{
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Buyer found in persistance.", domainEvent.Buyer);
}
else
{
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Buyer NOT found in persistance. Creating new Buyer instance...", domainEvent.Buyer);
buyer = new Buyer(domainEvent.Buyer, domainEvent.Buyer);
}
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Payment method is being validated...");
try
{
buyer.ValidatePaymentMethod(orderId: domainEvent.Order.Id, cardNumber: domainEvent.CardNumber, cardHolderName: domainEvent.CardHolderName,
cvv: domainEvent.Cvv, cardTypeId: domainEvent.CardTypeId, expiration: domainEvent.Expiration);
}
catch (OrderDomainException e)
{
_logger.LogError(e.Message);
throw e;
}
if (isBuyerExisted)
{
_buyerRepository.Update(buyer);
}
else
{
_buyerRepository.Add(buyer);
}
_logger.LogInformation(" [x] OrderStartedDomainEventHandler.Handle(): Payment method is validated!");
await _buyerRepository.UnitOfWork.SaveEntitiesAsync();
}
public async Task <bool> Handle(CreateOrderCommand message)
{
// Add/Update the Buyer AggregateRoot
// DDD patterns comment: Add child entities and value-objects through the Order Aggregate-Root
// methods and constructor so validations, invariants and business logic
// make sure that consistency is preserved across the whole aggregate
var cardTypeId = message.CardTypeId != 0 ? message.CardTypeId : 1;
var buyerGuid = _identityService.GetUserIdentity();
var buyer = await _buyerRepository.FindAsync(buyerGuid);
if (buyer == null)
{
buyer = new Buyer(buyerGuid);
}
var payment = buyer.AddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
message.CardNumber,
message.CardSecurityNumber,
message.CardHolderName,
message.CardExpiration);
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveChangesAsync();
// Create the Order AggregateRoot
// DDD patterns comment: Add child entities and value-objects through the Order Aggregate-Root
// methods and constructor so validations, invariants and business logic
// make sure that consistency is preserved across the whole aggregate
var order = new Order(buyer.Id, payment.Id, new Address(message.Street, message.City, message.State, message.Country, message.ZipCode));
foreach (var item in message.OrderItems)
{
order.AddOrderItem(item.ProductId, item.ProductName, item.UnitPrice, item.Discount, item.PictureUrl, item.Units);
}
_orderRepository.Add(order);
var result = await _orderRepository.UnitOfWork
.SaveChangesAsync();
return(result > 0);
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId, orderStartedEvent.UserName);
}
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync(cancellationToken);
}
public IActionResult AddBuyer(int productId)
{
string UserID = User.GetUserIdToken();
var model = _buyerRepository.GetByCondition(a => a.UserId == UserID && a.UserProductId == productId);
if (model.Count() == 0)
{
_buyerRepository.Add(new Buys()
{
UserId = UserID,
IsSold = false,
UserProductId = productId
});
_buyerRepository.SaveAll();
return(Ok());
}
return(NoContent());
}
public async Task <bool> Handle(CreateBuyerCommand createBuyerCommand)
{
// Create Order domain aggregate
Buyer buyer = new Buyer(createBuyerCommand.OrderId,
createBuyerCommand.UserName,
createBuyerCommand.FirstName,
createBuyerCommand.LastName,
createBuyerCommand.Address,
createBuyerCommand.City,
createBuyerCommand.State,
createBuyerCommand.PostalCode,
createBuyerCommand.Country,
createBuyerCommand.Phone,
createBuyerCommand.Email);
//Add Order to DataStore
await repository.Add(buyer);
return(true);
}
public async Task Handle(OrderStartedDomainEvent notification, CancellationToken cancellationToken)
{
var cardTypeId = (notification.CardTypeId != 0) ? notification.CardTypeId : 1;
var userGuid = _identityService.GetUserIdentity();
var buyer = await _buyerRepository.FindAsync();
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(userGuid);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
notification.CardNumber,
notification.CardSecurityNumber,
notification.CardHolderName,
notification.CardExpiration,
notification.Order.Id);
var buyerUpdated = buyerOriginallyExisted ?
_buyerRepository.Update(buyer) :
_buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveChangesAsync(cancellationToken);
var orderStatusChangedToSubmittedIntegrationEvent = new OrderStatusChangedToSubmittedIntegrationEvent(
notification.Order.Id, notification.Order.OrderStatus.Name, buyer.Name);
await _orderIntegrationEventService.AddAndSaveEventAsync(orderStatusChangedToSubmittedIntegrationEvent);
_logger.CreateLogger <ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler>()
.LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated " +
$"for order id {notification.Order.Id}");
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var userGuid = _identityService.GetUserIdentity();
var buyer = await _buyerRepository.FindAsync(userGuid);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(userGuid);
}
buyer.VerifyOrAddPaymentMethod(cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
orderStartedEvent.CardNumber,
orderStartedEvent.CardSecurityNumber,
orderStartedEvent.CardHolderName,
orderStartedEvent.CardExpiration,
orderStartedEvent.Order.Id);
var buyerUpdated = buyerOriginallyExisted ? _buyerRepository.Update(buyer) : _buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync();
_logger.CreateLogger(nameof(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {orderStartedEvent.Order.Id}.");
}
public async Task Handle(OrderStartedDomainEvent notification)
{
var guid = _identityService.GetUserIdentity();
var buyer = await _buyerRepository.FindAsync(guid);
var buyerOriginallyExisted = (buyer != null);
if (!buyerOriginallyExisted)
{
buyer = new Buyer(guid);
}
buyer.VerifyOrAddPaymentMethod(
notification.CardNumber,
notification.CardSecurityNumber,
notification.CardHolder,
notification.CardExpiration,
notification.Order.Id);
var buyerUpdated = buyerOriginallyExisted ? _buyerRepository.Update(buyer) : _buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork.SaveEntitiesAsync();
_logger.CreateLogger(typeof(ValidateOrAddBuyerOnOrderStartedEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {notification.Order.Id}.");
}
public async Task Handle(OrderStartedDomainEvent notification, CancellationToken cancellationToken)
{
var cardTypeId = notification.CardTypeId != 0 ? notification.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(notification.UserId);
bool buyerOriginallyExisted = buyer != null;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(notification.UserId, notification.UserName);
}
buyer.VerifyOrAddPaymentMethod(
cardTypeId,
$"Payment Method on {DateTime.UtcNow}",
notification.CardNumber,
notification.CardSecurityNumber,
notification.CardHolderName,
notification.CardExpiration,
notification.Order.Id);
var buyerUpdated = buyerOriginallyExisted ? _buyerRepository.Update(buyer) : _buyerRepository.Add(buyer);
_ = await _buyerRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
Log(notification, buyerUpdated);
}
public async Task Handle(OrderStartedDomainEvent orderStartedEvent, CancellationToken cancellationToken)
{
var cardTypeId = (orderStartedEvent.CardTypeId != 0) ? orderStartedEvent.CardTypeId : 1;
var buyer = await _buyerRepository.FindAsync(orderStartedEvent.UserId);
bool buyerOriginallyExisted = (buyer == null) ? false : true;
if (!buyerOriginallyExisted)
{
buyer = new Buyer(orderStartedEvent.UserId);
}
var buyerUpdated = buyerOriginallyExisted ? _buyerRepository.Update(buyer) : _buyerRepository.Add(buyer);
await _buyerRepository.UnitOfWork
.SaveEntitiesAsync();
_logger.CreateLogger(nameof(ValidateOrAddBuyerAggregateWhenOrderStartedDomainEventHandler)).LogTrace($"Buyer {buyerUpdated.Id} and related payment method were validated or updated for orderId: {orderStartedEvent.Order.Id}.");
}
