public async Task <IActionResult> ClaimTeam([FromBody] int teamId)
{
if (_userManager.Users.Any(u => u.TeamId == teamId))
{
return(BadRequest("Team is already claimed"));
}
var user = await _userManager.GetAppUser(HttpContext.User);
if (await _userManager.IsInRoleAsync(user, "TeamManager"))
{
_dispatcher.Dispatch(new TeamUnClaimedEvent(user.TeamId));
}
else
{
await _userManager.AddToRoleAsync(user, "TeamManager");
_timerService.AddTeamManager(user.Id);
}
user.TeamId = teamId;
await _userManager.UpdateAsync(user);
_dispatcher.Dispatch(new TeamClaimedEvent(teamId));
return(Ok());
}
private void SaveChangesWithEvents(IDomainEventDispatcher domainEventDispatcher)
{
System.Collections.Generic.IEnumerable <EntityEntry> modified = ChangeTracker.Entries().Where(e => e.State == EntityState.Modified || e.State == EntityState.Added);
foreach (EntityEntry item in modified)
{
if (item.Entity is IDateTracking changedOrAddedItem)
{
if (item.State == EntityState.Added)
{
changedOrAddedItem.DateCreated = DateTime.Now;
}
changedOrAddedItem.DateModified = DateTime.Now;
}
}
var entities = ChangeTracker.Entries().Select(e => e.Entity);
entities
.Where(e =>
!e.GetType().BaseType.IsGenericType&&
typeof(AggregateRootBase).IsAssignableFrom(e.GetType()))
.Select(aggregateRoot =>
{
var events = ((IAggregateRoot)aggregateRoot).GetUncommittedEvents();
foreach (var domainEvent in events)
{
domainEventDispatcher.Dispatch(domainEvent);
}
((IAggregateRoot)aggregateRoot).GetUncommittedEvents().Clear();
return(aggregateRoot);
})
.ToArray();
entities
.Where(e =>
e.GetType().BaseType.IsGenericType&&
typeof(AggregateRootWithIdBase <>).IsAssignableFrom(e.GetType().BaseType.GetGenericTypeDefinition()))
.Select(aggregateRoot =>
{
//todo: need a better code to avoid dynamic
var events = ((dynamic)aggregateRoot).GetUncommittedEvents();
foreach (var domainEvent in events)
{
domainEventDispatcher.Dispatch(domainEvent);
}
((dynamic)aggregateRoot).GetUncommittedEvents().Clear();
return(aggregateRoot);
})
.ToArray();
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
{
if (_dispatcher is not null)
{
var membersWithAddressUpdatedEvents = ChangeTracker.Entries <Member>()
.Select(e => e.Entity)
.Where(e => e.Events.Any(x => x.GetType() == typeof(MemberAddressUpdatedEvent)))
.ToArray();
foreach (var member in membersWithAddressUpdatedEvents)
{
var addressUpdatedEvents = member.Events
.Where(e => e.GetType() == typeof(MemberAddressUpdatedEvent))
.ToArray();
member.Events
.Where(e => e.GetType() == typeof(MemberAddressUpdatedEvent))
.ToList()
.Clear();
foreach (var addressUpdatedEvent in addressUpdatedEvents)
{
await _dispatcher.Dispatch(addressUpdatedEvent).ConfigureAwait(false);
}
}
}
int result = await base.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
// ignore events if no dispatcher provided
if (_dispatcher == null)
{
return(result);
}
// dispatch events only if save was successful
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
await _dispatcher.Dispatch(domainEvent).ConfigureAwait(false);
}
}
return(result);
}
protected async Task DispatchEvents(T aggregateRoot)
{
foreach (var domainEvent in aggregateRoot.GetDomainEvents())
{
await _domainEventDispatcher.Dispatch(domainEvent);
}
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
{
int result = await base.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
// ignore events if no dispatcher provided
if (_dispatcher == null)
{
return(result);
}
// dispatch events only if save was successful
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
await _dispatcher.Dispatch(domainEvent).ConfigureAwait(false);
}
}
return(result);
}
public override int SaveChanges()
{
UpdateAuditEntities();
//return base.SaveChanges();
var result = base.SaveChanges();
// dispatch events only if save was successful
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
_dispatcher.Dispatch(domainEvent);
}
}
return(result);
}
public override async Task <int> SaveChangesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
//DateTime now = DateTime.UtcNow;
//foreach (ObjectStateEntry entry in (this as IObjectContextAdapter).ObjectContext.ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified))
//{
// if (!entry.IsRelationship)
// {
// IHasLastModified lastModified = entry.Entity as IHasLastModified;
// if (lastModified != null)
// lastModified.LastModified = now;
// }
//}
int result = await base.SaveChangesAsync();
// dispatch events only if save was successful
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
_dispatcher.Dispatch(domainEvent);
}
}
return(result);
}
public override int SaveChanges()
{
int result = base.SaveChanges();
// ignore events if no dispatcher provided
if (_dispatcher == null)
{
return(result);
}
// dispatch events only if save was successful
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
_dispatcher.Dispatch(domainEvent);
}
}
return(result);
}
async Task FlushDomainEvents(CancellationToken token)
{
var passCount = 0;
// Handling of events could Raise more events, so keep going until nothing left
while (true)
{
passCount++;
var domainEventsThisPass = dbContext.ChangeTracker
.Entries()
.Select(e => e.Entity)
.OfType <IDomainEntity>()
.SelectMany(e => e.DomainEvents.GetAndClear())
.ToArray();
if (domainEventsThisPass.Length == 0)
{
break;
}
foreach (var domainEvent in domainEventsThisPass)
{
await domainEventDispatcher.Dispatch(domainEvent, token);
}
log.Information("Flushed domain events; pass {Pass}, {EventCount} events", passCount, domainEventsThisPass.Length);
}
}
private void QueueToRanking(Family family)
{
var classification = _scoreFamilyServiceManager.CalculateScore(family);
var @event = new FamilyScoreCalculatedEvent(family.Id, classification.Score, classification.TotalCriterias);
_domainEventDispatcher.Dispatch(@event);
}
private void StartGameWeek()
{
var season = _repository.Get(new CurrentSeason());
var firstGameNotCompleted = _repository.List <Game>()
.OrderBy(g => g.Date)
.FirstOrDefault(g => !g.IsCompleted);
if (firstGameNotCompleted == null)
{
season.CompletePhase();
_repository.Update(season);
return;
}
season.SetDate(firstGameNotCompleted.Date);
if (season.CurDate == season.NextPhase.Date)
{
season.CompletePhase();
_repository.Update(season);
return;
}
_repository.Update(season);
_dispatcher.Dispatch(new GameWeekStartedEvent());
}
public async Task <IActionResult> OnPostAsync(string captcha, string inviteCode, string email, string?returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (!await _captchaValidator.IsCaptchaPassedAsync(captcha))
{
ModelState.AddModelError("captcha", "Captcha validation failed");
}
if (ModelState.IsValid)
{
if (Input is null)
{
throw new Exception("Input is null.");
}
var user = new ApplicationUser {
UserName = email, Email = email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var newUserEvent = new NewUserRegisteredEvent(email,
Request.HttpContext.Connection.RemoteIpAddress !.ToString());
await _dispatcher.Dispatch(newUserEvent);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var userId = user.Id;
var emailConfirmationResult = await _userManager.ConfirmEmailAsync(user, code);
if (!emailConfirmationResult.Succeeded)
{
throw new InvalidOperationException($"Error confirming email for user with ID '{userId}':");
}
await _newMemberService.MemberSetupAsync(userId, Input.FirstName !, Input.LastName !, inviteCode !, email);
_logger.LogInformation($"Adding user {user.Email} to Member Role");
var roles = await _roleManager.Roles.ToListAsync();
var memberRole = roles.FirstOrDefault(r => r.Name == "Member");
if (memberRole != null)
{
await _userRoleMembershipService.AddUserToRoleAsync(userId, memberRole.Id);
}
return(RedirectToRoute("/User/MyProfile"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public void DispatchAndClearAccumulatedEvents(IDomainEventDispatcher eventDispatcher)
{
foreach (var domainEvent in this._events)
{
eventDispatcher.Dispatch(domainEvent);
}
this._events.Clear();
}
public void DispatchDomainEvents(IDomainEventDispatcher dispatcher)
{
foreach (var domainEvent in _domainEvents)
{
dispatcher.Dispatch(domainEvent);
}
_domainEvents.Clear();
}
protected void DispatchEvents(TAggregate entity)
{
Guard.ArgNotNull(entity, nameof(entity));
foreach (IDomainEvent domainEvent in entity.DomainEvents)
{
Dispatcher.Dispatch(domainEvent);
}
}
public async Task <IActionResult> OnPostAsync(string captcha, string?returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (!await _captchaValidator.IsCaptchaPassedAsync(captcha))
{
ModelState.AddModelError("captcha", "Captcha validation failed");
}
if (ModelState.IsValid)
{
if (Input is null)
{
throw new Exception("Input is null.");
}
var user = new ApplicationUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var newUserEvent = new NewUserRegisteredEvent(Input.Email !,
Request.HttpContext.Connection.RemoteIpAddress !.ToString());
await _dispatcher.Dispatch(newUserEvent);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
if (string.IsNullOrEmpty(callbackUrl))
{
throw new Exception("Callback URL is null or empty.");
}
if (string.IsNullOrEmpty(Input.Email))
{
throw new Exception("Email is required.");
}
await _emailService.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
return(LocalRedirect("~/Identity/Account/EmailVerificationRequired"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task Commit()
{
foreach (var item in _items)
{
await _domainEventDispatcher.Dispatch(item).ConfigureAwait(false);
}
_items.Clear();
}
/// <summary>
/// Dispatch an domain event
/// </summary>
/// <typeparam name="T">Type of domain event</typeparam>
/// <param name="domainEvent">Event to dispatch</param>
/// <remarks>The domain event will either be dispatched synchronusly or async depending on the used implementation.</remarks>
public static void Publish <T>(T domainEvent) where T : class, IDomainEvent
{
if (_domainEventDispatcher == null)
{
throw new InvalidOperationException(
"A domain event dispatcher has not been specified. Read the class documentation for the DomainEvent class.");
}
_domainEventDispatcher.Dispatch(domainEvent);
}
private void PostCommit(object entity)
{
if (!(entity is Entity domainEntity))
{
return;
}
eventDispatcher.Dispatch(domainEntity.DomainEvents);
domainEntity.ClearDomainEvents();
}
private void DomainDispatcher(TEntity entity)
{
var readOnlyCollection = entity.GetUncommittedEvents();
foreach (var @event in readOnlyCollection)
{
_domainEventDispatcher.Dispatch(@event);
}
entity.ClearDomainEvents();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation("StartupNotificationService.StartAsync called");
//if (!_notificationSent)
//{
await _dispatcher.Dispatch(new AppStartedEvent(DateTime.Now));
// _notificationSent = true;
//}
}
private async void RaiseDailyCheckInitiatedEvent()
{
await _dispatcher.Dispatch(new DailyCheckInitiatedEvent());
_logger.LogInformation("Daily Check Event Raised");
DailyCheck dailyCheck = new DailyCheck();
dailyCheck.Date = DateTime.Now;
await _repository.AddAsync(dailyCheck);
}
public async Task <InfoDto> Handle(FilmInfoLookupQuery query, CancellationToken cancellationToken = default)
{
var dto = await _databaseContext.FilmFiles
.Where(ff => ff.Id == query.FileId)
.ProjectTo <InfoDto>(_mapper.ConfigurationProvider)
.SingleAsync(cancellationToken);
dto.FilePath = await _eventDispatcher.Dispatch(new StreamUrlQuery(StreamKind.Film, dto.Id));
return(dto);
}
/// <summary>
/// Source: https://github.com/ardalis/CleanArchitecture/blob/master/src/CleanArchitecture.Infrastructure/Data/AppDbContext.cs
/// </summary>
private void SaveChangesWithEvents(IDomainEventDispatcher domainEventDispatcher)
{
var entities = ChangeTracker.Entries().Select(e => e.Entity);
entities
.Where(e =>
!e.GetType().BaseType.IsGenericType&&
typeof(AggregateRootBase).IsAssignableFrom(e.GetType()))
.Select(aggregateRoot =>
{
var events = ((IAggregateRoot)aggregateRoot).GetUncommittedEvents();
foreach (var domainEvent in events)
{
domainEventDispatcher.Dispatch(domainEvent);
}
((IAggregateRoot)aggregateRoot).GetUncommittedEvents().Clear();
return(aggregateRoot);
})
.ToArray();
entities
.Where(e =>
e.GetType().BaseType.IsGenericType&&
typeof(AggregateRootWithIdBase <>).IsAssignableFrom(e.GetType().BaseType.GetGenericTypeDefinition()))
.Select(aggregateRoot =>
{
//todo: need a better code to avoid dynamic
var events = ((dynamic)aggregateRoot).GetUncommittedEvents();
foreach (var domainEvent in events)
{
domainEventDispatcher.Dispatch(domainEvent);
}
((dynamic)aggregateRoot).GetUncommittedEvents().Clear();
return(aggregateRoot);
})
.ToArray();
}
public override async Task <int> SaveChangesAsync(CancellationToken token = default)
{
var result = await base.SaveChangesAsync(token);
var entitiesWithEvents = ChangeTracker.Entries <BaseEntity>()
.Select(e => e.Entity)
.Where(e => e.Events.Any())
.ToArray();
foreach (var entity in entitiesWithEvents)
{
var events = entity.Events.ToArray();
entity.Events.Clear();
foreach (var domainEvent in events)
{
_dispatcher.Dispatch(domainEvent);
}
}
DetachAllEntities();
return(result);
}
public async Task AddUserToRoleAsync(string userId, string roleId)
{
var user = await _userManager.Users.FirstOrDefaultAsync(x => x.Id == userId);
if (user == null)
{
throw new UserNotFoundException(userId);
}
var role = await _roleManager.Roles.FirstOrDefaultAsync(x => x.Id == roleId);
if (role == null)
{
throw new RoleNotFoundException(roleId);
}
await _userManager.AddToRoleAsync(user, role.Name);
var userAddedToRoleEvent = new UserAddedToRoleEvent(user.Email, role.Name);
await _dispatcher.Dispatch(userAddedToRoleEvent);
}
private async Task PublishDomainEventAsync(TEntity entity)
{
var events = entity.GetUncommittedEvents().ToArray();
if (events.Length > 0)
{
foreach (var domainEvent in events)
{
await _domainEventDispatcher.Dispatch(domainEvent);
}
}
}
public IActionResult Error()
{
var feature = HttpContext
.Features
.Get <IExceptionHandlerPathFeature>();
if (feature != null)
{
var exceptionEvent = new SiteErrorOccurredEvent(feature.Error);
_dispatcher.Dispatch(exceptionEvent);
}
return(View());
}
private void UpdateRecords()
{
foreach (Game game in _games)
{
if (game.IsTie)
{
game.HomeTeam.Record.Ties++;
game.AwayTeam.Record.Ties++;
}
else if (game.Winner == game.HomeTeam)
{
game.HomeTeam.Record.Wins++;
game.AwayTeam.Record.Losses++;
}
else if (game.Winner == game.AwayTeam)
{
game.HomeTeam.Record.Losses++;
game.AwayTeam.Record.Wins++;
}
}
_repository.UpdateRange(_teams);
_dispatcher.Dispatch(new TeamRecordsChangedEvent());
}
private void DispatchEvents(AggregateRoot aggregateRoot)
{
if (aggregateRoot == null)
{
return;
}
foreach (var domainEvent in aggregateRoot.DomainEvents)
{
_domainEventDispatcher.Dispatch(domainEvent);
}
aggregateRoot.ClearEvents();
}