public static IWindsorContainer Create()
{
var container = new WindsorContainer();
var collectionResolver = new CollectionResolver(container.Kernel);
container.Kernel
.Resolver
.AddSubResolver(collectionResolver);
container.Register
(Component.For <IArenaParser>()
.ImplementedBy <ArenaParser>(),
Component.For <IGridSizeParser>()
.ImplementedBy <GridSizeParser>(),
Component.For <IPositionParser>()
.ImplementedBy <PositionParser>(),
Component.For <IRobotParser>()
.ImplementedBy <RobotParser>(),
Component.For <IRouteParser>()
.ImplementedBy <RouteParser>(),
Classes.FromAssemblyContaining <IRouteStepResolver>()
.BasedOn <IRouteStepResolver>()
.WithServiceFirstInterface(),
Classes.FromAssemblyContaining <ICardinalCompassPointResolver>()
.BasedOn <ICardinalCompassPointResolver>()
.WithServiceFirstInterface());
return(container);
}
public Task InsertOneAsync <T>(T document)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.InsertOneAsync(document));
}
public Task <DeleteResult> DeleteManyAsync <T>(Expression <Func <T, bool> > filter)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.DeleteManyAsync(filter));
}
private async Task CreateCollectionAsync(Type collectionType, IMongoDatabase db)
{
var name = CollectionResolver.GetName(collectionType);
await db.CreateCollectionAsync(name);
await Indexes.CreateForTypeAsync(collectionType, db);
}
public Task <DeleteResult> DeleteOneAsync <T>(FilterDefinition <T> filter)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.DeleteOneAsync(filter));
}
public async Task UpdateAsync(Guid id, PlayerUpdate update)
{
if (id == Guid.Empty)
{
throw new ArgumentException("", nameof(id));
}
if (update == null)
{
throw new ArgumentNullException(nameof(update), "Player update model must be provided.");
}
var collectionName = CollectionResolver.GetName <PlayerDocument>();
Logger.LogDebug($"Updating player '{id}'..");
var updateDefinition = Builders <PlayerDocument> .Update
.Set(p => p.Number, update.Number)
.Set(p => p.Position, update.Position)
.Set(p => p.Status, update.Status);
UpdateResult result = await GetMongoDbContext().UpdateOneAsync(p => p.Id == id, updateDefinition);
if (result.MatchedCount != 1)
{
throw new InvalidOperationException($"Failed to update player '{id}' because it doesn't exist.");
}
}
public Task InsertManyAsync <T>(List <T> documents)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.InsertManyAsync(documents));
}
public async Task <bool> HasBeenInitializedAsync()
{
var requiredInitChecks = new List <Func <Task <bool> > >
{
async() =>
{
var existingCollections = (await GetDatabase().ListCollectionNames().ToListAsync()).ToHashSet(StringComparer.OrdinalIgnoreCase);
return(CollectionResolver.GetAllNames().All(n => existingCollections.Contains(n)));
},
async() =>
{
var existingTeams = (await Team.GetExistingTeamIdsAsync()).ToHashSet();
return(Teams.GetAll().Select(t => t.Id).All(id => existingTeams.Contains(id)));
}
};
foreach (var checkFunc in requiredInitChecks)
{
if (!await checkFunc())
{
return(false);
}
}
return(true);
}
public override void PreBuildUp(IBuilderContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
Type typeToBuild = context.BuildKey.Type;
if (typeToBuild.IsGenericType)
{
Type openGeneric = typeToBuild.GetGenericTypeDefinition();
if (openGeneric == typeof(IEnumerable <>) ||
openGeneric == typeof(ICollection <>) ||
openGeneric == typeof(IList <>))
{
Type elementType = typeToBuild.GetGenericArguments()[0];
MethodInfo resolverMethod = genericResolveCollectionMethod.MakeGenericMethod(elementType);
CollectionResolver resolver = (CollectionResolver)Delegate.CreateDelegate(typeof(CollectionResolver), resolverMethod);
context.Existing = resolver(context);
context.BuildComplete = true;
}
}
}
private void RegisterGenericContainerControlledCollection(Type itemType,
ContainerControlledItem[] controlledItems, bool appending)
{
CollectionResolver resolver = this.GetContainerControlledResolver(itemType);
resolver.AddControlledRegistrations(itemType, controlledItems, append: appending);
}
public Task <ReplaceOneResult> ReplaceOneAsync <T>(Expression <Func <T, bool> > filter, T document,
UpdateOptions updateOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.ReplaceOneAsync(filter, document, updateOptions));
}
public Task <UpdateResult> UpdateAsync <T>(Expression <Func <T, bool> > filter, UpdateDefinition <T> updateDefinition,
UpdateOptions updateOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
return(collection.UpdateManyAsync(filter, updateDefinition, updateOptions));
}
public async Task <List <Player> > GetAllAsync()
{
var collectionName = CollectionResolver.GetName <PlayerDocument>();
List <PlayerDocument> documents = await GetMongoDbContext().FindAsync <PlayerDocument>();
Logger.LogDebug($"Retrieved all players from '{collectionName}' collection.");
return(documents.Select(PlayerDocument.ToCoreEntity).ToList());
}
public async Task <List <WeekInfo> > GetAsync()
{
var collectionName = CollectionResolver.GetName <UpdateLogDocument>();
var logs = await GetMongoDbContext().FindAsync <UpdateLogDocument>();
Logger.LogDebug($"Retrieved updated weeks from '{collectionName}' collection.");
return(logs.Select(l => new WeekInfo(l.Season, l.Week)).ToList());
}
public async Task <T> FindOneAsync <T>(Expression <Func <T, bool> > filter,
FindOptions <T> findOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
var asyncCursor = await collection.FindAsync(filter, findOptions).ConfigureAwait(false);
return(await asyncCursor.SingleOrDefaultAsync().ConfigureAwait(false));
}
public async Task <List <TProjection> > FindAsync <T, TProjection>(Expression <Func <T, bool> > filter,
FindOptions <T, TProjection> findOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
IAsyncCursor <TProjection> asyncCursor = await collection.FindAsync(filter, findOptions).ConfigureAwait(false);
return(await asyncCursor.ToListAsync().ConfigureAwait(false));
}
private async Task <List <Type> > GetMissingCollectionTypesAsync(IMongoDatabase db)
{
HashSet <string> existing = (await db.ListCollectionNames().ToListAsync())
.Where(n => n.StartsWith(Collection.FfdbPrefix))
.ToHashSet();
return(CollectionResolver.GetDocumentTypes()
.Where(t => !existing.Contains(
CollectionResolver.GetName(t)))
.ToList());
}
public async Task <bool> HasUpdatedWeekAsync(WeekInfo week)
{
var collectionName = CollectionResolver.GetName <UpdateLogDocument>();
var builder = Builders <UpdateLogDocument> .Filter;
var filter = builder.Eq(l => l.Season, week.Season)
& builder.Eq(l => l.Week, week.Week);
UpdateLogDocument log = await GetMongoDbContext().FindOneAsync(filter);
return(log != null);
}
public static Task CreateIndexAsync(IMongoDatabase database)
{
var keys = Builders <TeamDocument> .IndexKeys.Ascending(t => t.Id);
var model = new CreateIndexModel <TeamDocument>(keys);
var collection = CollectionResolver.Get <TeamDocument>(database);
collection.Indexes.CreateOne(model);
return(collection.Indexes.CreateOneAsync(model));
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
container.Register(Component.For <IProcessEngine>().ImplementedBy <ProcessEngine>(),
Component.For <IDataExtractor>().ImplementedBy <DataExtractor>(),
Component.For <IFileHandlerResolver>().ImplementedBy <FileHandlerResolver>(),
Classes.FromThisAssembly().IncludeNonPublicTypes().BasedOn <IFileHandler>()
.WithService.FromInterface());
var collectionResolver = new CollectionResolver(container.Kernel);
container.Kernel.Resolver.AddSubResolver(collectionResolver);
}
public Task <DeleteResult> DeleteManyAsync <T>(FilterDefinition <T> filter = null)
where T : DocumentBase
{
if (filter == null)
{
// empty filter to delete all
filter = new BsonDocumentFilterDefinition <T>(new MongoDB.Bson.BsonDocument());
}
var collection = CollectionResolver.Get <T>(_database);
return(collection.DeleteManyAsync(filter));
}
public async Task <List <TeamWeekStats> > GetAsync(WeekInfo week)
{
var collectionName = CollectionResolver.GetName <WeekStatsTeamDocument>();
var builder = Builders <WeekStatsTeamDocument> .Filter;
var filter = builder.Eq(s => s.Season, week.Season)
& builder.Eq(s => s.Week, week.Week);
List <WeekStatsTeamDocument> documents = await GetMongoDbContext().FindAsync(filter);
Logger.LogDebug($"Retrieved team week stats for week '{week}' from '{collectionName}' collection.");
return(documents.Select(WeekStatsTeamDocument.ToCoreEntity).ToList());
}
public async Task <List <string> > GetPlayerNflIdsAsync(WeekInfo week)
{
var collectionName = CollectionResolver.GetName <WeekStatsPlayerDocument>();
MongoDbContext mongoDbContext = GetMongoDbContext();
List <Guid> ids = await GetPlayerIdsAsync(week, mongoDbContext);
Dictionary <Guid, string> idNflMap = await GetIdNflMapAsync(mongoDbContext);
return(ids
.Where(id => idNflMap.ContainsKey(id))
.Select(id => idNflMap[id])
.ToList());
}
public async Task AddAsync(WeekInfo week)
{
var collectionName = CollectionResolver.GetName <UpdateLogDocument>();
var log = new UpdateLogDocument
{
Season = week.Season,
Week = week.Week,
UpdateTime = DateTime.UtcNow
};
await GetMongoDbContext().InsertOneAsync(log);
Logger.LogDebug($"Successfully added update log for {week} to '{collectionName}' collection.");
}
public async Task AddAsync(PlayerAdd player)
{
if (player == null)
{
throw new ArgumentNullException(nameof(player), "Player add model must be provided.");
}
var collectionName = CollectionResolver.GetName <PlayerDocument>();
PlayerDocument document = PlayerDocument.FromCoreAddEntity(player);
await GetMongoDbContext().InsertOneAsync(document);
Logger.LogDebug($"Added player '{player.NflId}' as '{document.Id}' to '{collectionName}' collection.");
}
public Task <UpdateResult> UpdateAsync <T>(UpdateDefinition <T> updateDefinition,
FilterDefinition <T> filter = null,
UpdateOptions updateOptions = null)
where T : DocumentBase
{
if (filter == null)
{
//empty filter
filter = new BsonDocumentFilterDefinition <T>(new BsonDocument());
}
var collection = CollectionResolver.Get <T>(_database);
return(collection.UpdateManyAsync(filter, updateDefinition, updateOptions));
}
public async Task <T> FindOneAsync <T>(FilterDefinition <T> filter = null,
FindOptions <T> findOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
if (filter == null)
{
// provide empty filter to fetch all
filter = new BsonDocumentFilterDefinition <T>(new MongoDB.Bson.BsonDocument());
}
var asyncCursor = await collection.FindAsync(filter, findOptions).ConfigureAwait(false);
return(await asyncCursor.SingleOrDefaultAsync().ConfigureAwait(false));
}
public async Task <List <TProjection> > FindAsync <T, TProjection>(FilterDefinition <T> filter = null,
FindOptions <T, TProjection> findOptions = null)
where T : DocumentBase
{
var collection = CollectionResolver.Get <T>(_database);
if (filter == null)
{
//empty filter
filter = new BsonDocumentFilterDefinition <T>(new BsonDocument());
}
IAsyncCursor <TProjection> asyncCursor = await collection.FindAsync(filter, findOptions).ConfigureAwait(false);
return(await asyncCursor.ToListAsync().ConfigureAwait(false));
}
public static Task CreateIndexAsync(IMongoDatabase database)
{
// compound index
var keys = Builders <UpdateLogDocument> .IndexKeys
.Ascending(t => t.Week)
.Ascending(t => t.Season);
var options = new CreateIndexOptions {
Unique = true
};
var model = new CreateIndexModel <UpdateLogDocument>(keys, options);
var collection = CollectionResolver.Get <UpdateLogDocument>(database);
return(collection.Indexes.CreateOneAsync(model));
}
public async Task AddAsync(List <TeamWeekStats> stats)
{
if (stats == null)
{
throw new ArgumentNullException(nameof(stats), "Stats must be provided.");
}
var collectionName = CollectionResolver.GetName <WeekStatsTeamDocument>();
Logger.LogDebug($"Adding {stats.Count} team week stats to '{collectionName}' collection..");
List <WeekStatsTeamDocument> documents = stats.Select(WeekStatsTeamDocument.FromCoreEntity).ToList();
await GetMongoDbContext().InsertManyAsync(documents);
Logger.LogDebug($"Added team week stats to '{collectionName}' collection.");
}
