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."); }