static Functions()
{
context = new EscarGoContext();
_competitorRepository = new CompetitorRepositoryAsync(context);
_storage = new TableStorageRepository();
_raceRepository = new RaceRepositoryAsync(context);
}
public static async Task Sync(ISessionizeApiClient apiClient, ITableStorageRepository <SessionEntity> sessionRepo, ITableStorageRepository <PresenterEntity> presenterRepo, ILogger log, IDateTimeProvider dateTimeProvider, string conferenceInstance)
{
var sessionizeData = await apiClient.GetAllData();
log.LogInformation("Retrieved {sessionCount} sessions, {presenterCount} presenters from Sessionize API {sessionizeApiUrl}", sessionizeData.Sessions.Length, sessionizeData.Speakers.Length, apiClient.GetUrl());
var sourceData = SessionizeAdapter.SessionizeAdapter.Convert(sessionizeData, dateTimeProvider);
log.LogInformation("Sessionize data successfully adapted to DDD domain model: {sessionCount} sessions and {presenterCount} presenters", sourceData.Item1.Length, sourceData.Item2.Length);
var destinationSessions = (await sessionRepo.GetAllAsync(conferenceInstance)).ToArray();
var destinationPresenters = (await presenterRepo.GetAllAsync(conferenceInstance)).ToArray();
log.LogInformation("Existing read model retrieved: {sessionCount} sessions and {presenterCount} presenters", destinationSessions.Length, destinationPresenters.Length);
await PerformSync(conferenceInstance, sessionRepo, presenterRepo, sourceData.Item1, sourceData.Item2, destinationSessions, destinationPresenters, log, dateTimeProvider);
}
public IUnitOfWork Open(string connectionString = null)
{
if (string.IsNullOrEmpty(connectionString))
{
connectionString = ConnectionString;
}
if (string.IsNullOrEmpty(connectionString))
{
throw new ArgumentNullException("UnitOfWork.Open - Connection String is NULL.");
}
Db = connectionString.OpenDbConnection();
Query = new Query(Db);
Repository = new OrmLiteRepository(Db);
TableStorageRepository = new OrmLiteTableStorageRepository(Db);
return(this);
}
public LookupRepository(ITableStorageRepository <LookupEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public NinjaRepository(INinjaMappingService ninjaMappingService, ITableStorageRepository <NinjaEntity> ninjaEntityTableStorageRepository)
{
_ninjaMappingService = ninjaMappingService ?? throw new ArgumentNullException(nameof(ninjaMappingService));
_ninjaEntityTableStorageRepository = ninjaEntityTableStorageRepository ?? throw new ArgumentNullException(nameof(ninjaEntityTableStorageRepository));
}
public CompetitorRepositoryCQRS(EscarGoContext context) : base(context)
{
_storageRepository = new TableStorageRepository();
}
public ChampionStatsRepository(ITableStorageRepository <ChampionStatsEntity> table)
{
_table = table ?? throw new NotImplementedException(nameof(table));
}
public TableStorageService(ITableStorageRepository tableStorageRepository)
{
_tableStorageRepository = tableStorageRepository;
}
public MailController(ITableStorageRepository repository)
{
_repository = repository;
}
public BlacklistRepository(ITableStorageRepository <BlacklistEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public RequestedSummonerRepository(ITableStorageRepository <SummonerRequestEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public RedisRepository(ITableStorageRepository tableStorageRepository)
{
_tableStorageRepository = tableStorageRepository;
}
public PolicyController(ITableStorageRepository <PolicyServerMap> policyServerModelRepository)
{
_policyServerModelRepository = policyServerModelRepository;
}
public TeamCaptainRepository(ITableStorageRepository <TeamCaptainEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public CustomerController(ITableStorageRepository <Customers> tableStorageRepository)
{
_tableStorageRepository = tableStorageRepository;
}
public Crud(ITableStorageRepository <StoredJsonEntity> tableStorageRepository)
{
_tableStorageRepository = tableStorageRepository;
}
public UserService(ITableStorageRepository <UserEntity> userRepository, IUserOperationQueuesService queuesService, IMapper mapper)
{
_userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
_queuesService = queuesService ?? throw new ArgumentNullException(nameof(queuesService));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public AlternateAccountRepository(ITableStorageRepository <AlternateAccountEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public BoardsController(ITableStorageRepository <BoardEntity> boardRepository)
{
_boardRepository = boardRepository ?? throw new ArgumentNullException(nameof(boardRepository));
}
public DivisionRepository(ITableStorageRepository <DivisionEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public SeasonInfoRepository(ITableStorageRepository <SeasonInfoEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public AchievementRepository(ITableStorageRepository <AchievementEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public Retweeter(ITableStorageRepository tableStorageRepository, ITwitterRepository twitterRepository)
{
_tableStorageRepository = tableStorageRepository;
_twitterRepository = twitterRepository;
}
public ProductCommandRepository(ITableStorageRepository tableStorageRepository, ILogger logger)
{
_tableStorageRepository = tableStorageRepository ?? throw new ArgumentNullException(nameof(tableStorageRepository));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public PlayerStatsRepository(ITableStorageRepository <PlayerStatsEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
private static async Task PerformSync(string conferenceInstance,
ITableStorageRepository <SessionEntity> sessionRepo,
ITableStorageRepository <PresenterEntity> presenterRepo,
Session[] sourceSessions,
Presenter[] sourcePresenters,
IList <SessionEntity> destinationSessions,
IList <PresenterEntity> destinationPresenters,
ILogger log,
IDateTimeProvider dateTimeProvider)
{
// Diff presenters
var newPresenters = sourcePresenters.Except(destinationPresenters.Select(x => x.GetPresenter()), new PresenterSync()).ToArray();
var deletedPresenters = destinationPresenters.Select(x => x.GetPresenter()).Except(sourcePresenters, new PresenterSync()).ToArray();
var existingPresenters = destinationPresenters.Join(sourcePresenters,
dest => dest.ExternalId,
src => src.ExternalId,
(dest, src) => new { dest, src }).ToArray();
var editedPresenters = existingPresenters.Where(x => !x.dest.GetPresenter().DataEquals(x.src)).ToArray();
// Update presenter ids on sessions
sourceSessions.ToList().ForEach(s => s.PresenterIds = s.PresenterIds.Select(pId =>
existingPresenters
.Where(x => x.src.Id == pId)
.Select(x => x.dest.Id)
.Cast <Guid?>()
.SingleOrDefault() ?? pId)
.ToArray());
// Sync presenters
if (newPresenters.Any())
{
log.LogInformation("Adding new presenters to read model: {newPresenterIds}", (object)newPresenters.Select(x => x.Id).ToArray());
}
await Task.WhenAll(newPresenters.Select(p => presenterRepo.CreateAsync(new PresenterEntity(p, conferenceInstance))));
if (deletedPresenters.Any())
{
log.LogInformation("Deleting presenters from read model: {deletedPresenterIds}", (object)deletedPresenters.Select(x => x.Id).ToArray());
await Task.WhenAll(deletedPresenters.Select(p => presenterRepo.DeleteAsync(conferenceInstance, p.Id.ToString())));
}
if (editedPresenters.Any())
{
log.LogInformation("Updating presenters in read model: {editedPresenterIds}", (object)editedPresenters.Select(x => x.dest.Id).ToArray());
}
await Task.WhenAll(editedPresenters.Select(x => presenterRepo.UpdateAsync(x.dest.Update(x.src, dateTimeProvider))));
if (!newPresenters.Any() && !deletedPresenters.Any() && !editedPresenters.Any())
{
log.LogInformation("Presenters up to date in read model");
}
// Exclude cancelled sessions
sourceSessions = sourceSessions.Where(s => !s.Title.Contains("[Cancelled]")).ToArray();
// Diff speakers
var newSessions = sourceSessions.Except(destinationSessions.Select(x => x.GetSession()), new SessionSync()).ToArray();
var deletedSessions = destinationSessions.Select(x => x.GetSession()).Except(sourceSessions, new SessionSync()).ToArray();
var existingSessions = destinationSessions.Join(sourceSessions,
dest => dest.ExternalId,
src => src.ExternalId,
(dest, src) => new { dest, src }).ToArray();
var editedSessions = existingSessions.Where(x => !x.dest.GetSession().DataEquals(x.src)).ToArray();
// Sync speakers
if (newSessions.Any())
{
log.LogInformation("Adding new sessions to read model: {newSessionIds}", (object)newSessions.Select(x => x.Id).ToArray());
}
await Task.WhenAll(newSessions.Select(s => sessionRepo.CreateAsync(new SessionEntity(s, conferenceInstance))));
if (deletedSessions.Any())
{
log.LogInformation("Deleting sessions from read model: {deletedSessionIds}", (object)deletedSessions.Select(x => x.Id).ToArray());
await Task.WhenAll(deletedSessions.Select(s => sessionRepo.DeleteAsync(conferenceInstance, s.Id.ToString())));
}
if (editedSessions.Any())
{
log.LogInformation("Editing sessions in read model: {editedSessionIds}", (object)editedSessions.Select(x => x.dest.Id).ToArray());
}
await Task.WhenAll(editedSessions.Select(x => sessionRepo.UpdateAsync(x.dest.Update(x.src, dateTimeProvider))));
if (!newSessions.Any() && !deletedSessions.Any() && !editedSessions.Any())
{
log.LogInformation("Sessions up to date in read model");
}
}
public CardService(ITableStorageRepository <CardEntity> cardRepository, IMapper mapper)
{
_cardRepository = cardRepository ?? throw new ArgumentNullException(nameof(cardRepository));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public ProductQueryRepository(ITableStorageRepository tableStoragerRepository)
{
_tableStorageRepository = tableStoragerRepository ?? throw new ArgumentNullException(nameof(tableStoragerRepository));
}
public MatchDetailRepository(ITableStorageRepository <MatchDetailEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public GoogleDriveFolderRepository(ITableStorageRepository <GoogleDriveFolderEntity> table)
{
_table = table ?? throw new ArgumentNullException(nameof(table));
}
public DbLogService(ITableStorageRepository <MessageLogEntity> tableStorageRepository, ILogLevelMapper logLevelMapper, string createdBy)
{
_tableStorageRepository = tableStorageRepository ?? throw new ArgumentNullException(nameof(tableStorageRepository));
_logLevelMapper = logLevelMapper ?? throw new ArgumentNullException(nameof(logLevelMapper));
_createdBy = createdBy ?? throw new ArgumentNullException(nameof(createdBy));
}
