public UserProfile SaveUserProfile(string authToken, UserProfile userProfile)
{
MongoHelpers.SaveData(userProfile.City);
userProfile.CityId = userProfile.City.Id;
MongoHelpers.SaveData(userProfile);
return(userProfile);
}
public async Task <List <Product> > FindAllAsync(Expression <Func <Product, bool> > predicate = null)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var games = (await _productsCollection.FindAsync(filter)).ToList();
return(games);
}
public async Task <OrderDetails> FindSingleAsync(Expression <Func <OrderDetails, bool> > predicate)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var details = (await _orderDetailsCollection.FindAsync(filter)).FirstOrDefault();
return(details);
}
public async Task <List <Publisher> > FindAllAsync(Expression <Func <Publisher, bool> > predicate = null)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var publishers = (await _publishersCollection.FindAsync(filter)).ToList();
return(publishers);
}
public async Task <List <OrderDetails> > FindAllAsync(Expression <Func <OrderDetails, bool> > predicate = null)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var details = (await _orderDetailsCollection.FindAsync(filter)).ToList();
return(details);
}
public async Task <Publisher> FindSingleAsync(Expression <Func <Publisher, bool> > predicate)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var publisher = (await _publishersCollection.FindAsync(filter)).FirstOrDefault();
return(publisher);
}
public void GetConnectionUsingSettingsFromConnectionString()
{
var settings = new SettingsHolder();
settings.Set(MongoPersistenceConstants.ConnectionStringKey, "mongodb://ultratinef:27017");
var readonlySettings = (ReadOnlySettings)settings;
var result = MongoHelpers.GetConnectionString(readonlySettings);
result.Should().Be("mongodb://ultratinef:27017");
}
public ObservableCollection <Race> GetRaces(string authToken)
{
if (!IsTokenValid(authToken))
{
return(null);
}
var races = new ObservableCollection <Race>();
MongoHelpers.LoadData <Race>().ToList().ForEach(races.Add);
return(races);
}
public ObservableCollection <CityInit> GetCityCoordinates(double latitude, double longitude, double radius)
{
var ci = new ObservableCollection <CityInit>();
MongoHelpers.LoadData <City>().ToObservableCollection().ForEach(c => ci.Add(new CityInit()
{
CityId = c.Id,
Latitude = c.Latitude,
Longitude = c.Longitude,
Name = c.Name
})); //.Where(c => c.Latitude is between latitude +- radius && c.Longtitude is between longitude +- radius )
return(ci);
}
public async Task UpdateKeyAsync(string productId, string key)
{
var existingProduct = await GetById(productId);
var oldValueInstance = existingProduct.Clone();
existingProduct.Key = key;
var filter = MongoHelpers.GetDocumentFilter <Product>(p => p.Id == productId);
await _productsCollection.ReplaceOneAsync(filter, existingProduct);
var entry = new LogEntry <Product>(Operation.Update, oldValueInstance, existingProduct);
_logger.Log(entry);
}
public async Task UpdateUnitsInStockAsync(string key, short unitsInStock)
{
var existingProduct = await FindSingleAsync(p => p.Key == key);
var oldValueInstance = existingProduct.Clone();
existingProduct.UnitsInStock = unitsInStock;
var filter = MongoHelpers.GetDocumentFilter <Product>(p => p.Key == key);
await _productsCollection.ReplaceOneAsync(filter, existingProduct);
var entry = new LogEntry <Product>(Operation.Update, oldValueInstance, existingProduct);
_logger.Log(entry);
}
public async Task <Order> FindSingleAsync(Expression <Func <Order, bool> > predicate)
{
var filter = MongoHelpers.GetDocumentFilter(predicate);
var order = (await _ordersCollection.FindAsync(filter)).FirstOrDefault();
if (order == null)
{
return(null);
}
await SetupDetails(new[] { order });
await SetupGameDetails(order.Details);
return(order);
}
public UserProfile Login(string email, string password)
{
if (MongoHelpers.IsUserValid(email, password))
{
var userProfile = MongoHelpers.LoadData <UserProfile>().FirstOrDefault(u => u.Email == email);
if (userProfile != null)
{
var city = MongoHelpers.LoadData <City>().FirstOrDefault(c => c.Id == userProfile.CityId);
if (city != null)
{
userProfile.City = city;
}
return(userProfile);
}
return(MongoHelpers.CreateUserProfile(Membership.GetUser(email)));
}
return(MongoHelpers.CreateUserProfile(MongoHelpers.Register(email, password)));
}
internal static void SetupDatabase()
{
BsonClassMap.RegisterClassMap <Entity <Guid> >(cm =>
{
cm.AutoMap();
cm.MapIdMember(c => c.Id);
cm.AddKnownType(typeof(Entity));
});
BsonClassMap.RegisterClassMap <Entity>(cm =>
{
cm.AutoMap();
cm.SetIsRootClass(true);
});
MongoHelpers.AutoRegisterClassMap <Level>(c => new Level(c.Id, c.Description, c.Generators, c.NextLevels));
MongoHelpers.AutoRegisterClassMap <Topic>(c => new Topic(c.Id, c.Name, c.Description, c.Levels));
MongoHelpers.AutoRegisterClassMap <TemplateTaskGenerator>(c => new TemplateTaskGenerator(c.Id, c.PossibleAnswers,
c.Text, c.Hints,
c.Answer, c.Streak, c.Question));
MongoHelpers.AutoRegisterClassMap <TaskGenerator>(cm => cm.SetIsRootClass(true));
MongoHelpers.AutoRegisterClassMap <TaskInfoEntity>(c => new TaskInfoEntity(c.Question, c.Answer, c.Hints, c.HintsTaken,
c.ParentGeneratorId, c.IsSolved, c.Id));
MongoHelpers.AutoRegisterClassMap <UserEntity>(c => new UserEntity(c.Id, c.UserProgressEntity));
MongoHelpers.AutoRegisterClassMap <LevelProgressEntity>(cm =>
{
MongoHelpers.MapDictionary <LevelProgressEntity, Guid, int>(cm, c => c.CurrentLevelStreaks);
cm.MapCreator(c => new LevelProgressEntity(c.LevelId, c.CurrentLevelStreaks, c.Id));
});
MongoHelpers.AutoRegisterClassMap <TopicProgressEntity>(cm =>
{
MongoHelpers.MapDictionary <TopicProgressEntity, Guid, LevelProgressEntity>(cm, c => c.LevelProgressEntities);
cm.MapCreator(c => new TopicProgressEntity(c.LevelProgressEntities, c.TopicId, c.Id));
});
MongoHelpers.AutoRegisterClassMap <UserProgressEntity>(cm =>
{
MongoHelpers.MapDictionary <UserProgressEntity, Guid, TopicProgressEntity>(cm, c => c.TopicsProgress);
cm.MapCreator(c => new UserProgressEntity(c.CurrentTopicId, c.CurrentLevelId, c.UserId,
c.TopicsProgress, c.CurrentTask, c.Id));
});
}
public ObservableCollection <Building> GetBuildings(string authToken)
{
var buildings = MongoHelpers.LoadData <Building>().ToObservableCollection();
//var city = MongoHelpers.LoadData<City>().FirstOrDefault(c => c.Id == cityId);
//if (city != null)
//{
// city.BuildingInCityIds.ForEach(bId =>
// {
// var building = MongoHelpers.LoadData<Building>().FirstOrDefault(b => b.Id == bId);
// if (building != null)
// {
// buildings.Add(building);
// }
// });
//}
return(buildings);
}
public DocumentStorageImpl(IDocumentStorageProviderFactory storageProviderFactory,
IDocumentStorageIdProvider storageIdProvider,
IDocumentStorageHeaderProvider storageHeaderProvider,
IDocumentStorageFilterProvider storageFilterProvider,
IDocumentStorageInterceptorProvider storageInterceptorProvider,
string documentType = null)
{
if (string.IsNullOrEmpty(documentType))
{
documentType = MongoHelpers.GetDefaultDocumentType <TDocument>();
}
DocumentType = documentType;
_storageProvider = new Lazy <IDocumentStorageProvider <TDocument> >(() => storageProviderFactory.GetStorageProvider <TDocument>(documentType));
_storageIdProvider = storageIdProvider;
_storageHeaderProvider = storageHeaderProvider;
_storageFilterProvider = storageFilterProvider;
_storageInterceptor = storageInterceptorProvider.GetInterceptor <TDocument>(documentType);
}
protected void Page_Load(object sender, EventArgs e)
{
var resources = new ObservableCollection <Resource>();
resources.Add(new Resource()
{
Name = "Gold",
});
resources.Add(new Resource()
{
Name = "Aluminium",
});
resources.Add(new Resource()
{
Name = "Helium-3",
});
resources.ForEach(r => MongoHelpers.SaveData(r));
var buildings = new ObservableCollection <Building>();
for (var i = 0; i < 3; i++)
{
var b = new Building();
b.Name = "name" + i;
b.Resources = new ObservableCollection <ResourceInBuilding>()
{
new ResourceInBuilding()
{
ResourceId = resources[i].Id, ProducePerTurn = 0, UsefullType = UsefullTypes.ForBuilding
}
};
b.BuildsRequested = i * 12;
b.BuildsCompleted = 0;
buildings.Add(b);
}
buildings.ForEach(b => MongoHelpers.SaveData(b));
}
static UserRepository()
{
MongoHelpers.AutoRegisterClassMap <Container>();
MongoHelpers.AutoRegisterClassMap <TAuth>();
MongoHelpers.AutoRegisterClassMap <TToken>();
}
public void GetConnectionStringFromConfigUsingValidConnectionString()
{
var result = MongoHelpers.GetConnectionStringFromConfig("NServiceBus/Persistence/MongoDB");
result.Should().Be("mongodb://localhost:27017");
}
public void GetConnectionStringFromConfigUsingInValidConnectionStringName()
{
Action sut = () => MongoHelpers.GetConnectionStringFromConfig("My.MissingPersistence");
sut.ShouldThrow <ConfigurationErrorsException>();
}
public bool SaveCity(string authToken, City city)
{
return(MongoHelpers.SaveData(city).Ok);
}
public bool SaveBuildingInCity(string authToken, BuildingInCity buildingInCity)
{
return(MongoHelpers.SaveData(buildingInCity).Ok);
}
public Building SaveBuilding(string authToken, Building building)
{
MongoHelpers.SaveData(building);
return(building);
}
public City GetCity(string authToken, string cityId)
{
var city = MongoHelpers.LoadData <City>().FirstOrDefault(c => c.Id == cityId);
return(city);
}
