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