public async Task HandleAsync(MakeOrder message, ISagaContext context)
{
_logger.LogInformation($"Started a saga for order: {message.OrderId}, customer: {message.CustomerId}," +
$"parcels: {message.ParcelId}");
Data.ParcelIds.Add(message.ParcelId);
Data.OrderId = message.OrderId;
Data.CustomerId = message.CustomerId;
await _publisher.SendAsync(new CreateOrder(Data.OrderId, message.CustomerId), _accessor.CorrelationContext);
}
public async Task HandleAsync(TeamsCreated @event, ICorrelationContext context)
{
int[] playerIds = @event.Teams.SelectMany(inner => inner).ToArray();
var query = new PlayersQuery
{
LeagueId = new [] { @event.LeagueId },
PlayerId = playerIds,
QueryType = PlayersQueryType.Actual,
Page = 1,
Size = playerIds.Length
};
List <PlayerWithRateDto> playersInfo = (await _playersService.GetAsync(query)).ToList();
int teamNumber = 1;
foreach (var team in @event.Teams)
{
var body = CreateTeamAndRateBody(team, playersInfo, teamNumber);
InboxNotification notification = InboxNotificationBuilder
.Create()
.WithReceiver(team)
.WithSender("Notification service")
.WithTopic($"Teams for tour: {@event.TourId} in league: {@event.LeagueId} are formed!")
.WithBody($"{body}")
.Build();
await _busPublisher.SendAsync(notification, context);
teamNumber++;
}
int[] registeredPlayers =
(await _toursService.GetAsync(new RegisteredOnTourPlayers {
TourId = @event.TourId
}))
.Select(dto => dto.InternalId)
.ToArray();
int[] unhappyPlayers = registeredPlayers.Except(playerIds).ToArray();
if (unhappyPlayers.Length != 0)
{
InboxNotification notification = InboxNotificationBuilder
.Create()
.WithReceiver(unhappyPlayers)
.WithSender("Notification service")
.WithTopic($"Teams for tour: {@event.TourId} in league: {@event.LeagueId} are formed!")
.WithBody("Sorry you are out of the game. Try next time!")
.Build();
await _busPublisher.SendAsync(notification, context);
}
}
public async Task <IActionResult> Post(CreateCustomerCommand command)
{
var context = GetContext();
await _busPublisher.SendAsync(command, context);
return(Accepted());
}
public async Task HandleAsync(SynchronizationAcceptedEvent @event, ISagaContext sagaContext)
{
logger.LogInformation($"{nameof(@event)} ({sagaContext.CorrelationId}) {this.GetType()}");
await busPublisher.SendAsync(
new MergeSynchronizationDataCommand(),
CorrelationContext.Create(sagaContext.CorrelationId));
}
protected async Task <IActionResult> SendAsync <T>(T command,
Guid?resourceId = null, string resource = "") where T : IRequest
{
var context = GetContext <T>(resourceId, resource);
await _busPublisher.SendAsync(command, context);
return(Accepted(context));
}
/// <summary>
/// Method to publish a command to the bus. Some subscriber will handle the command.
/// </summary>
/// <typeparam name="T">Type of the command</typeparam>
/// <param name="command">Command to be sent to the bus</param>
/// <param name="resourceId"></param>
/// <param name="resource"></param>
/// <returns>Http Accepted</returns>
protected async Task <IActionResult> PublishAsync <T>(T command,
Guid?resourceId = null, string resource = "") where T : ICommand
{
ICorrelationContext context = CorrelationContext.Empty; //GetContext<T>(resourceId, resource); TODO: Implement GetContext
await _busPublisher.SendAsync(command, context);
return(Accepted(context));
}
public async Task <IActionResult> Post([FromBody] CreateReservation command)
{
var context = new CorrelationContext(Guid.NewGuid(), command.UserId, "reservations",
_tracer.ActiveSpan.Context.ToString());
await _busPublisher.SendAsync(command, context);
return(Accepted($"reservations/{context.Id}"));
}
public async Task <IActionResult> CreateItem(CreateOrderCommand command)
{
await _dispatcher.SendAsync(command);
await _busPublisher.SendAsync(command, CorrelationContext.Empty);
return(Accepted());
}
public async Task <ActionResult> CreatePersonReportsByLocation(CreatePersonReportsByLocationCommand command)
{
var context = CorrelationContext.Create(Guid.NewGuid(), command.PersonId);
await BusPublisher.SendAsync(command, context);
return(Accepted(context));
}
public async Task <IActionResult> CreateAddress([FromBody] CreateAddress command)
{
try
{
await _busPublisher.SendAsync(command.BindId(x => x.Id), CorrelationContext.Empty);
}
catch (Exception ex) { }
return(Accepted());
}
public async Task <bool> Handle(ReserveBookCommand request, CancellationToken cancellationToken)
{
var reservation = await _db.Reservations
.Include(x => x.Loans)
.Include(x => x.Member)
.FirstOrDefaultAsync(x => x.Number == request.Number, cancellationToken);
if (reservation == null)
{
reservation = new Reservation
{
RequestDate = _dateTimeService.Now(),
Status = StatusReservation.Opened,
Number = request.Number,
Member = await _db.Members.FirstOrDefaultAsync(x => x.DocumentId == request.MemberId, cancellationToken)
};
if (reservation.Member == null)
{
reservation.Member = new Member
{
DocumentId = request.MemberId,
Name = request.MemberName
};
}
await _db.AddAsync(reservation, cancellationToken);
}
reservation.Loans = new List <Loan>();
foreach (var item in request.Items)
{
var loan = new Loan
{
Copy = await _db.Copies.FirstOrDefaultAsync(x => x.Number == item.Number, cancellationToken),
DueDate = reservation.RequestDate.AddDays(7)
};
reservation.Loans.Add(loan);
}
await _db.SaveChangesAsync(cancellationToken);
var message = new PublishReservationEventCommand
{
ReservationId = reservation.Id
};
await _bus.SendAsync(ContextNames.Queue.Library, message);
return(true);
}
public async Task HandleAsync(TourRegistrationClosed message, ISagaContext context)
{
await _busPublisher.SendAsync(
new GenerateTeams(
message.TourId,
message.LeagueId,
message.PlayersInTeam,
message.TeamsInTour,
message.Pid,
message.GenerateTeamsStrategy),
CorrelationContext.Empty);
}
public async Task CompensateAsync(OrderCreated message, ISagaContext context)
{
var diff = DateTime.UtcNow.Subtract(Data.CustomerCreatedAt);
if (diff.TotalHours <= CreationHoursLimit)
{
await _busPublisher.SendAsync(new CreateOrderDiscount(
message.Id, message.CustomerId, 10), CorrelationContext.Empty);
Complete();
}
else
{
Reject();
}
}
public async Task HandleAsync(TourRegistrationOpened @event, ICorrelationContext context)
{
IEnumerable <PlayerInternalIdDto> playersDto =
await _leaguesService.GetLeagueJoinedPlayersAsync(new LeagueJoinedPlayersQuery(@event.LeagueId));
int[] playerIds = playersDto.Select(p => p.InternalId).ToArray();
InboxNotification notification = InboxNotificationBuilder
.Create()
.WithReceiver(playerIds)
.WithSender("Notification service")
.WithTopic("Tour registration opened!")
.WithBody($"Tour number: {@event.TourId}. Tour date: {@event.Date}")
.Build();
await _busPublisher.SendAsync(notification, context);
}
public async Task <bool> Handle(ExpireReservationCommand request, CancellationToken cancellationToken)
{
var reservation = await _db.Reservations.FirstOrDefaultAsync(x => x.Id == request.ReservationId, cancellationToken);
reservation.Status = StatusReservation.Expired;
await _db.SaveChangesAsync(cancellationToken);
var message = new PublishReservationEventCommand
{
ReservationId = reservation.Id
};
await _bus.SendAsync(ContextNames.Queue.Library, message);
return(true);
}
public async Task HandleAsync(ChangePasswordCommand command, ICorrelationContext context)
{
var user = await _userRepository.GetAsync(command.UserId);
if (user == null)
{
throw new DomainException(Codes.UserNotFound, string.Format(MessagesCode.UserNotFound, command.UserId));
}
if (!user.ValidatePassword(command.PasswordHash, _passwordHasher))
{
throw new DomainException(Codes.InvalidCurrentPassword, MessagesCode.InvalidCurrentPassword);
}
user.SetPassword(command.PasswordHash, _passwordHasher);
await _busPublisher.SendAsync(new ChangePasswordCommand(user.Id, user.PasswordHash), CorrelationContext.Empty);
}
public async Task HandleAsync(SignUpCommand command, ICorrelationContext context)
{
var user = await _userRepository.GetAsync(command.Email);
if (user != null)
{
throw new DomainException(Codes.EmailInUse, string.Format(MessagesCode.EmailInUse, command.Email));
}
if (string.IsNullOrWhiteSpace(command.Password))
{
throw new DomainException(Codes.InvalidPassword, MessagesCode.InvalidPassword);
}
user = new User(command.Email);
user.SetPassword(command.Password, _passwordHasher);
await _busPublisher.SendAsync(new SignedUpCommand(user.Email, user.PasswordHash), CorrelationContext.Empty);
}
public async Task <bool> Handle(CheckDueCommand request, CancellationToken cancellationToken)
{
var date = _dateTimeService.Now().Date.AddDays(1).AddSeconds(-1);
var expiredList = await _db.Reservations
.Where(x => x.Loans.Any(l => l.DueDate.Date <= date))
.ToListAsync(cancellationToken);
foreach (var item in expiredList)
{
var message = new ExpireReservationCommand
{
ReservationId = item.Id
};
await _bus.SendAsync(ContextNames.Queue.Library, message);
}
return(true);
}
public async Task <IActionResult> Post(GreetUser command)
{
await _busPublisher.SendAsync(command, GetContext());
return(Accepted());
}
public Task HandleAsync(DiscountCreated message, ISagaContext context)
{
return(_busPublisher.SendAsync(new SendEmailNotification("*****@*****.**",
"Discount", $"New discount: {message.Code}"),
CorrelationContext.Empty));
}
public Task CompensateAsync(DiscountCreated message, ISagaContext context)
{
return _busPublisher.SendAsync(new SendEmailNotification("*****@*****.**", "Discount", $"New Discount:{message.Code}"),
CorrelationContext.Empty);
}
public async Task <IActionResult> Add([FromBody] AddPaymentMethod command)
{
await _busPublisher.SendAsync <AddPaymentMethod>(command.BindId(x => x.Id), null);
return(Accepted());
}
public async Task <IActionResult> GetOrderSummary(RemoveItemFromOrder command)
{
await _busPublisher.SendAsync <RemoveItemFromOrder>(command, null);
return(Accepted());
}
public async Task <IActionResult> Post(CreateArticle command)
{
await _busPublisher.SendAsync(command);
return(Accepted());
}
public static async Task SendAsync <TMessage>(this IBusPublisher publisher, string queueName, TMessage message)
where TMessage : class, IBusMessage
{
await publisher.SendAsync(queueName, new[] { message });
}
public async Task <IActionResult> AddAddress(AddPendingRegistration command)
{
await _busPublisher.SendAsync(command.Bind(x => x.Id, Guid.NewGuid()), null);
return(Accepted());
}
public async Task <IActionResult> CreateBasket([FromBody] CreateBasket command)
{
await _busPublisher.SendAsync(command.Bind(x => x.BasketId, Guid.NewGuid()), null);
return(Accepted());
}
public Task SendAsync <T>(T command) where T : class, ICommand
{
return(_busPublisher.SendAsync(command, _accessor.CorrelationContext));
}
public async Task HandleAsync(OrderCanceled message, ISagaContext context)
{
await _busPublisher.SendAsync(new ReleaseProducts(message.Id, message.Products),
CorrelationContext.FromId(context.SagaId /* CorrelationId*/));
}
public async Task <IActionResult> ScheduleSynchronization(ScheduleSynchronizationCommand command)
{
await busPublisher.SendAsync(command, CorrelationContext.Create());
return(Accepted());
}
