public void GetByIdAsync_void_entities()
{
CreateMongoData();
var repository = new GenericMongoRepository<GameMongo>();
GameMongo game = repository.GetByIdAsync(MongoJsonTestData.Game.Id).Result;
Assert.IsNotNull(game);
}
public void GameMongoToSql()
{
// Arrange
string testGameId = MongoJsonTestData.Game.EntityId;
// Act
var gameMongoRepository = new GenericMongoRepository<GameMongo>();
var seasonMongoRepository = new GenericMongoRepository<SeasonMongo>();
GameMongo game = gameMongoRepository.GetByComplexIdAsync(testGameId).Result;
SeasonMongo season = seasonMongoRepository.GetByComplexIdAsync(game.SeasonId, game.ParentApiId).Result;
GameSql sqlEntity = EntityFactory.CreateGameSql(game, season);
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<GameSql>(context);
repo.Insert(sqlEntity);
repo.Save();
}
// Assert
GameSql sqlSavedEntity;
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<GameSql>(context);
sqlSavedEntity = repo.FindWhere(x => x.Id == testGameId).FirstOrDefault();
}
Assert.IsNotNull(sqlSavedEntity);
}
public void PlaySummaryMongoToSql()
{
// Arrange
string testId = MongoJsonTestData.Play.EntityId;
// Act
var playRepository = new GenericMongoRepository<PlayMongo>();
PlayMongo entity = playRepository.GetByComplexIdAsync(testId, MongoJsonTestData.Play.ParentApiId).Result;
var sqlEntity = EntityFactory.CreatePlaySummarySql(entity);
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<PlaySummarySql>(context);
repo.Insert(sqlEntity);
repo.Save();
}
// Assert
PlaySummarySql sqlSavedEntity;
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<PlaySummarySql>(context);
sqlSavedEntity = repo.FindWhere(x => x.Id == testId).FirstOrDefault();
}
Assert.IsNotNull(sqlSavedEntity);
}
public void GetAll_void_entities()
{
CreateMongoData();
var repository = new GenericMongoRepository<GameMongo>();
List<GameMongo> gameList = repository.GetAll();
Assert.IsNotNull(gameList);
Assert.IsTrue(gameList.Any());
}
public void FindByFilter_filter_entity()
{
CreateMongoData();
var repository = new GenericMongoRepository<GameMongo>();
var filter = Builders<GameMongo>.Filter.Eq(x => x.SeasonId, "http://api.sportsdatallc.org/nfl-t1/2014/REG/schedule.xml");
IList<GameMongo> game = repository.FindByFilter(filter).Result;
Assert.IsNotNull(game);
Assert.IsTrue(game.Any());
}
public IRepository <TEntity, TPrimaryKey> GetRepository <TEntity, TPrimaryKey>()
where TEntity : Identifiable <TPrimaryKey>, IEntity <TPrimaryKey>
{
// Checks if the Dictionary Key contains the Model class
if (_repositories.Keys.Contains(typeof(TEntity)))
{
Debug.WriteLine("Retrieving repository for ", typeof(TEntity).Name);
return(_repositories[typeof(TEntity)] as IRepository <TEntity, TPrimaryKey>);
}
if (typeof(TEntity).Name.Equals("SdtmRow") || typeof(TEntity) == (typeof(PlatformAnnotation)))
{
//var mongoClient = new MongoClient(_dbsettings.Value.MongoDBconnection);
//var mongodb = mongoClient.GetDatabase(_dbsettings.Value.noSQLDatabaseName);
var mongoRepository = new GenericMongoRepository <TEntity, TPrimaryKey>(_mongodb, "Biospeak_clinical");
_repositories.Add(typeof(TEntity), mongoRepository);
return(mongoRepository);
}
if (typeof(TEntity) == typeof(ExportFile))
{
//var mongoClient = new MongoClient(_dbsettings.Value.MongoDBconnection);
//var mongodb = mongoClient.GetDatabase(_dbsettings.Value.noSQLDatabaseName);
var mongoRepository = new GenericMongoRepository <TEntity, TPrimaryKey>(_mongodb, "exportFiles");
_repositories.Add(typeof(TEntity), mongoRepository);
return(mongoRepository);
}
if (typeof(TEntity) == typeof(AnalysisDataset))
{
//var mongoClient = new MongoClient(_dbsettings.Value.MongoDBconnection);
//var mongodb = mongoClient.GetDatabase(_dbsettings.Value.noSQLDatabaseName);
var mongoRepository = new GenericMongoRepository <TEntity, TPrimaryKey>(_mongodb, "analysisDatasets");
_repositories.Add(typeof(TEntity), mongoRepository);
return(mongoRepository);
}
if (typeof(TEntity) == typeof(CombinedQuery))
{
var mongoRepository = new GenericMongoRepository <TEntity, TPrimaryKey>(_mongodb, "userQueries");
_repositories.Add(typeof(TEntity), mongoRepository);
return(mongoRepository);
}
if (typeof(TEntity) == typeof(Observation))
{
var mongoClient = new MongoClient(_dbsettings.Value.MongoDBconnection);
var mongodb = mongoClient.GetDatabase(_dbsettings.Value.noSQLDatabaseName);
var MongoRepository = new GenericMongoRepository <TEntity, TPrimaryKey>(mongodb, "assayObservation");
_repositories.Add(typeof(TEntity), MongoRepository);
return(MongoRepository);
}
var repository = new GenericRepository <TEntity, TPrimaryKey>(this);
_repositories.Add(typeof(TEntity), repository);
return(repository);
}
public void Insert_void_entities()
{
var repository = new GenericMongoRepository<GameMongo>();
GameMongo entity = new GameMongo
{
IdInMongo = MongoJsonTestData.Game.Id,
AwayId = "testAwayId",
HomeId = "testHomeId"
};
repository.Insert(entity);
GameMongo savedEntity = repository.GetByIdAsync(entity.IdInMongo).Result;
Assert.IsNotNull(savedEntity);
Assert.AreEqual(savedEntity.AwayId, entity.AwayId);
Assert.AreEqual(savedEntity.HomeId, entity.HomeId);
}
public void TransferDataFromMongoDbToSqlServer()
{
var mongoClient = new MongoClient(MongoDbHost);
var mongoDatabase = mongoClient.GetDatabase(MongoDbName);
var hardDrivesMongoRepository = new GenericMongoRepository <HardDriveMongoModel>(mongoDatabase);
var memoriesMongoRepository = new GenericMongoRepository <MemoryMongoModel>(mongoDatabase);
var motherboardsMongoRepository = new GenericMongoRepository <MotherboardMongoModel>(mongoDatabase);
var processorsMongoRepository = new GenericMongoRepository <ProcessorMongoModel>(mongoDatabase);
var videoCardsMongoRepository = new GenericMongoRepository <VideoCardMongoModel>(mongoDatabase);
var computerShopsMongoRepository = new GenericMongoRepository <ComputerShopMongoModel>(mongoDatabase);
var computersMongoRepository = new GenericMongoRepository <ComputerMongoModel>(mongoDatabase);
var hardDrivesRepository = new GenericRepository <HardDrive>(dbContext);
var memoriesRepository = new GenericRepository <Memory>(dbContext);
var motherboardsRepository = new GenericRepository <Motherboard>(dbContext);
var processorsRepository = new GenericRepository <Processor>(dbContext);
var videoCardsRepository = new GenericRepository <VideoCard>(dbContext);
var computerShopsRepository = new GenericRepository <ComputerShop>(dbContext);
var computersRepository = new GenericRepository <Computer>(dbContext);
var migrator = new MongoToSqlMigrator();
migrator.TransferHardDriveDataToSQL(hardDrivesRepository, hardDrivesMongoRepository);
dbContext.SaveChanges();
migrator.TransferMemoryDataToSQL(memoriesRepository, memoriesMongoRepository);
dbContext.SaveChanges();
migrator.TransferMotherboardDataToSQL(motherboardsRepository, motherboardsMongoRepository);
dbContext.SaveChanges();
migrator.TransferProcessorDataToSQL(processorsRepository, processorsMongoRepository);
dbContext.SaveChanges();
migrator.TransferVideoCardDataToSQL(videoCardsRepository, videoCardsMongoRepository);
dbContext.SaveChanges();
migrator.TransferComputerShopDataToSQL(computerShopsRepository, computerShopsMongoRepository);
dbContext.SaveChanges();
migrator.TransferComputerDataToSQL(hardDrivesRepository, memoriesRepository, motherboardsRepository, processorsRepository, videoCardsRepository, computerShopsRepository, computersRepository, computersMongoRepository);
dbContext.SaveChanges();
}
public void PlayPlayerPartisipantsMontoToSql()
{
// Arrange
string testId = MongoJsonTestData.Play.EntityId;
// Act
var playRepository = new GenericMongoRepository<PlayMongo>();
var playerRepository = new GenericMongoRepository<PlayerMongo>();
PlayMongo play = playRepository.GetByComplexIdAsync(testId, MongoJsonTestData.Play.ParentApiId).Result;
var filter = Builders<PlayerMongo>.Filter.Eq(x => x.PlayId, play.EntityId) &
Builders<PlayerMongo>.Filter.Eq(x => x.ParentApiId, play.ParentApiId);
IList<PlayerMongo> players = playerRepository.FindByFilter(filter).Result;
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<PlayPlayerPartisipantsSql>(context);
IList<PlayPlayerPartisipantsSql> sqlEntity = EntityFactory.CreatePlayPlayerPartisipantsSql(play, players);
foreach (var item in sqlEntity)
{
repo.Insert(item);
}
repo.Save();
}
// Assert
IList<PlayPlayerPartisipantsSql> sqlSavedEntity;
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<PlayPlayerPartisipantsSql>(context);
sqlSavedEntity = repo.FindWhere(x => x.PlayId == play.EntityId).ToList();
}
Assert.IsNotNull(sqlSavedEntity);
Assert.AreEqual(2, sqlSavedEntity.Count());
}
public void TeamMongoToSql()
{
// Arrange
string testId = MongoJsonTestData.Team.EntityId;
// Act
var teamMongoRepository = new GenericMongoRepository<TeamMongo>();
var conferenceMongoRepository = new GenericMongoRepository<ConferenceMongo>();
var divisionMongoRepository = new GenericMongoRepository<DivisionMongo>();
TeamMongo team = teamMongoRepository.GetByComplexIdAsync(testId, MongoJsonTestData.Team.ParentApiId).Result;
var conferenceFilter = Builders<ConferenceMongo>.Filter.Eq(x => x.EntityId, team.ConvferenceId) &
Builders<ConferenceMongo>.Filter.Eq(x => x.ParentApiId, team.ParentApiId);
IList<ConferenceMongo> conference = conferenceMongoRepository.FindByFilter(conferenceFilter).Result;
var divisionFilter = Builders<DivisionMongo>.Filter.Eq(x => x.EntityId, team.DivisionId) &
Builders<DivisionMongo>.Filter.Eq(x => x.ParentApiId, team.ParentApiId);
IList<DivisionMongo> division = divisionMongoRepository.FindByFilter(divisionFilter).Result;
var sqlEntity = EntityFactory.CreateTeamSql(team, conference[0], division[0]);
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<TeamSql>(context);
repo.Insert(sqlEntity);
repo.Save();
}
// Assert
TeamSql sqlSavedEntity;
using (var context = new MySqlDbContext())
{
var repo = new GenericSqlRepository<TeamSql>(context);
sqlSavedEntity = repo.FindWhere(x => x.Id == testId).FirstOrDefault();
}
Assert.IsNotNull(sqlSavedEntity);
}
public void GenerateMongoDbData()
{
var mongoClient = new MongoClient(MongoDbHost);
var mongoDatabase = mongoClient.GetDatabase(MongoDbName);
var hardDrivesMongoRepository = new GenericMongoRepository <HardDriveMongoModel>(mongoDatabase);
var memoriesMongoRepository = new GenericMongoRepository <MemoryMongoModel>(mongoDatabase);
var motherboardsMongoRepository = new GenericMongoRepository <MotherboardMongoModel>(mongoDatabase);
var processorsMongoRepository = new GenericMongoRepository <ProcessorMongoModel>(mongoDatabase);
var videoCardsMongoRepository = new GenericMongoRepository <VideoCardMongoModel>(mongoDatabase);
var computerShopsMongoRepository = new GenericMongoRepository <ComputerShopMongoModel>(mongoDatabase);
var computersMongoRepository = new GenericMongoRepository <ComputerMongoModel>(mongoDatabase);
var writer = new MongoDbWriter();
writer.GenerateHardDrives(hardDrivesMongoRepository, RandomGenerator.Create);
writer.GenerateMemories(memoriesMongoRepository, RandomGenerator.Create);
writer.GenerateMotherboards(motherboardsMongoRepository, RandomGenerator.Create);
writer.GenerateProcessors(processorsMongoRepository, RandomGenerator.Create);
writer.GenerateVideoCards(videoCardsMongoRepository, RandomGenerator.Create);
writer.GenerateComputerShops(computerShopsMongoRepository, RandomGenerator.Create);
writer.GenerateComputers(hardDrivesMongoRepository, memoriesMongoRepository, motherboardsMongoRepository, processorsMongoRepository, videoCardsMongoRepository, computerShopsMongoRepository, computersMongoRepository, RandomGenerator.Create);
}
public void GenericMongoRepository_void_notNull()
{
var repository = new GenericMongoRepository<IMongoEntity>();
Assert.IsNotNull(repository);
}
public static void Main()
{
Database.SetInitializer(new MigrateDatabaseToLatestVersion <ComputersFactoryDbContext, Configuration>());
var dbContext = new ComputersFactoryDbContext();
var worker = new ComputersFactoryUnitOfWork(dbContext);
var mongoClient = new MongoClient(MongoDbHost);
var mongoDatabase = mongoClient.GetDatabase(MongoDbName);
var hardDrivesMongoRepository = new GenericMongoRepository <HardDriveMongoModel>(mongoDatabase);
var memoriesMongoRepository = new GenericMongoRepository <MemoryMongoModel>(mongoDatabase);
var motherboardsMongoRepository = new GenericMongoRepository <MotherboardMongoModel>(mongoDatabase);
var processorsMongoRepository = new GenericMongoRepository <ProcessorMongoModel>(mongoDatabase);
var videoCardsMongoRepository = new GenericMongoRepository <VideoCardMongoModel>(mongoDatabase);
var computerShopsMongoRepository = new GenericMongoRepository <ComputerShopMongoModel>(mongoDatabase);
var computersMongoRepository = new GenericMongoRepository <ComputerMongoModel>(mongoDatabase);
var writer = new MongoDbWriter();
var randomGenerator = RandomGenerator.Create;
writer.GenerateHardDrives(hardDrivesMongoRepository, randomGenerator);
writer.GenerateMemories(memoriesMongoRepository, randomGenerator);
writer.GenerateMotherboards(motherboardsMongoRepository, randomGenerator);
writer.GenerateProcessors(processorsMongoRepository, randomGenerator);
writer.GenerateVideoCards(videoCardsMongoRepository, randomGenerator);
writer.GenerateComputerShops(computerShopsMongoRepository, randomGenerator);
writer.GenerateComputers(hardDrivesMongoRepository, memoriesMongoRepository, motherboardsMongoRepository, processorsMongoRepository, videoCardsMongoRepository, computerShopsMongoRepository, computersMongoRepository, randomGenerator);
var hardDrivesRepository = new GenericRepository <HardDrive>(dbContext);
var memoriesRepository = new GenericRepository <Memory>(dbContext);
var motherboardsRepository = new GenericRepository <Motherboard>(dbContext);
var processorsRepository = new GenericRepository <Processor>(dbContext);
var videoCardsRepository = new GenericRepository <VideoCard>(dbContext);
var computerShopsRepository = new GenericRepository <ComputerShop>(dbContext);
var computersRepository = new GenericRepository <Computer>(dbContext);
var migrator = new MongoToSqlMigrator();
migrator.TransferHardDriveDataToSQL(hardDrivesRepository, hardDrivesMongoRepository);
RefreshContext(dbContext);
migrator.TransferMemoryDataToSQL(memoriesRepository, memoriesMongoRepository);
RefreshContext(dbContext);
migrator.TransferMotherboardDataToSQL(motherboardsRepository, motherboardsMongoRepository);
RefreshContext(dbContext);
migrator.TransferProcessorDataToSQL(processorsRepository, processorsMongoRepository);
RefreshContext(dbContext);
migrator.TransferVideoCardDataToSQL(videoCardsRepository, videoCardsMongoRepository);
RefreshContext(dbContext);
migrator.TransferComputerShopDataToSQL(computerShopsRepository, computerShopsMongoRepository);
RefreshContext(dbContext);
migrator.TransferComputerDataToSQL(hardDrivesRepository, memoriesRepository, motherboardsRepository, processorsRepository, videoCardsRepository, computerShopsRepository, computersRepository, computersMongoRepository);
RefreshContext(dbContext);
}
