Пример #1
0
 public void Add(IAggregateRoot entity, IUnitOfWorkRepository uowRepository)
 {
     if (!_addedEntities.ContainsKey(entity))
     {
         _addedEntities.Add(entity, uowRepository);
     }
 }
		public void RegisterDeletion(IAggregateRoot aggregateRoot, IUnitOfWorkRepository repository)
		{
			if (!_deletedAggregates.ContainsKey(aggregateRoot))
			{
				_deletedAggregates.Add(aggregateRoot, repository);
			}
		}
		public void RegisterUpdate(IAggregateRoot aggregateRoot, IUnitOfWorkRepository repository)
		{
			if (!_updatedAggregates.ContainsKey(aggregateRoot))
			{
				_updatedAggregates.Add(aggregateRoot, repository);
			}
		}
Пример #4
0
 public void RegistraRemovido(IPersistenciaBase entidade, IUnitOfWorkRepository unitofWorkRepository)
 {
     if (!entidadesDeletadas.ContainsKey(entidade))
     {
         entidadesDeletadas.Add(entidade, unitofWorkRepository);
     }
 }
Пример #5
0
 public void RegistraNovo(IPersistenciaBase entidade, IUnitOfWorkRepository unitofWorkRepository)
 {
     if (!entidadesAdicionadas.ContainsKey(entidade))
     {
         entidadesAdicionadas.Add(entidade, unitofWorkRepository);
     }
 }
Пример #6
0
 public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!addedEntities.ContainsKey(entity))
     {
         addedEntities.Add(entity, unitOfWorkRepository);
     }
 }
Пример #7
0
 public void RegisterAmended(IAggregateDataModel entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     if (!changedEntities.ContainsKey(entity))
     {
         changedEntities.Add(entity, unitofWorkRepository);
     }
 }
Пример #8
0
 public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!deletedEntities.ContainsKey(entity))
     {
         deletedEntities.Add(entity, unitOfWorkRepository);
     }
 }
Пример #9
0
 public void RegisterAmended(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!changedEntities.ContainsKey(objectEntity))
     {
         changedEntities.Add(objectEntity, unitOfWorkRepository);
     }
 }
Пример #10
0
 public void RegisterRemoved(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (!removedEntities.ContainsKey(objectEntity))
     {
         removedEntities.Add(objectEntity, unitOfWorkRepository);
     }
 }
Пример #11
0
        public Season CreateFirstSeason(Game game, List<Team> teams, IUnitOfWorkRepository repository)
        {
            // First check the number of teams can be evenly divided into the number of leagues.
             bool teamsOk = teams.Count % Constants.HowManyLeagues == 0;
             if (!teamsOk)
             {
            throw new Exception($"The number of teams must be divided by {Constants.HowManyLeagues}");
             }

             var newSeasonInfo = new NewSeasonInfo { Game = game, SeasonNumber = 0 };

             // Divide all teams between the four leagues based on the team rating.
             teams.Sort((team1, team2) => team2.Rating.CompareTo(team1.Rating));
             int countTeamsPerLeague = teams.Count / Constants.HowManyLeagues;
             newSeasonInfo.TeamsLeague1 = teams.Take(countTeamsPerLeague).ToList();
             newSeasonInfo.TeamsLeague2 = teams.Skip(countTeamsPerLeague).Take(countTeamsPerLeague).ToList();
             newSeasonInfo.TeamsLeague3 = teams.Skip(countTeamsPerLeague * 2).Take(countTeamsPerLeague).ToList();
             newSeasonInfo.TeamsLeague4 = teams.Skip(countTeamsPerLeague * 3).ToList();

             // The teams have been sorted on rating, so given them an initial league table position.
             AssignInitialLeagueTablePosition(teams);

             // In the first season there are no champion and cup winner yet, so pick the two best teams.
             newSeasonInfo.NationalChampion = teams[0];
             newSeasonInfo.NationalCupWinner = teams[1];

             // Now all teams have been placed in the right leagues, so create match schedules for all competitions.
             var seasonAndCompetitionSchedules = CreateSeasonAndCompetitionSchedules(newSeasonInfo);

             // Insert the season and all competition schedules.
             var season = InsertSeasonAndCompetitionSchedule(repository, seasonAndCompetitionSchedules);

             return season;
        }
 public void RegistroRemovido(IRaizDeAgregacao entidade,
 IUnitOfWorkRepository unitofWorkRepositorio)
 {
     if (!_entidadesDeletadas.ContainsKey(entidade))
     {
         _entidadesDeletadas.Add(entidade, unitofWorkRepositorio);
     }
 }
Пример #13
0
 /// <summary>
 /// Registers an <see cref="IEntity" /> instance to be added through this <see cref="Umbraco.Core.Persistence.UnitOfWork" />
 /// </summary>
 /// <param name="entity">The <see cref="IEntity" /></param>
 /// <param name="repository">The <see cref="IUnitOfWorkRepository" /> participating in the transaction</param>
 public void RegisterAdded(IEntity entity, IUnitOfWorkRepository repository)
 {
     _operations.Enqueue(new Operation
     {
         Entity = entity,
         Repository = repository,
         Type = TransactionType.Insert
     });
 }
Пример #14
0
 public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository repository)
 {
     List<IAggregateRoot> items = null;
     if (!add.TryGetValue(repository, out items))
     {
         items = new List<IAggregateRoot>();
         add.Add(repository, items);
     }
     items.Add(entity);
 }
Пример #15
0
		/// <summary>
		/// Registers an <see cref="IEntity" /> instance to be removed through this <see cref="UnitOfWork" />
		/// </summary>
		/// <param name="entity">The <see cref="IEntity" /></param>
		/// <param name="repository">The <see cref="IUnitOfWorkRepository" /> participating in the transaction</param>
		public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository)
		{
			_operations.Add(
				new Operation
					{
						Entity = entity,
						ProcessDate = DateTime.Now,
						Repository = repository,
						Type = TransactionType.Delete
					});
		}
Пример #16
0
        public void CreateNextSeason(string previousSeasonId, IUnitOfWorkRepository repository)
        {
            Season previousSeason;
             using (var seasonRepository = _repositoryFactory.CreateSeasonRepository())
             {
            previousSeason = seasonRepository.GetOne(previousSeasonId);
             }

             if (previousSeason.SeasonStatus != SeasonStatus.Ended)
             {
            throw new ConflictException("Season must be ended before a new one can be created");
             }

             var newSeasonInfo = new NewSeasonInfo
             {
            Game = previousSeason.Game,
            SeasonNumber = previousSeason.GameOrder + 1
             };

             // Determine which teams promote and relegate.
             IEnumerable<Team> allTeamsSortedOnLeagueAndPosition;
             using (var teamRepository = _repositoryFactory.CreateTeamRepository())
             {
            allTeamsSortedOnLeagueAndPosition = teamRepository.GetTeamsByGame(previousSeason.GameId).OrderBy(x => x.CurrentLeagueCompetition.Order).ThenBy(x => x.CurrentLeaguePosition);
             }

             var teamsGroupedPerLeague = allTeamsSortedOnLeagueAndPosition.GroupBy(t => t.CurrentLeagueCompetitionId).Select(grp => grp.ToList()).ToList();
             var newLeagues = _leagueManager.PromoteAndRelegateTeams(teamsGroupedPerLeague);

             newSeasonInfo.TeamsLeague1 = newLeagues[0];
             newSeasonInfo.TeamsLeague2 = newLeagues[1];
             newSeasonInfo.TeamsLeague3 = newLeagues[2];
             newSeasonInfo.TeamsLeague4 = newLeagues[3];

             // Determine champion of the highest league.
             newSeasonInfo.NationalChampion = teamsGroupedPerLeague[0][0];

             // Determine cup winner.
             using (var matchRepository = new RepositoryFactory().CreateMatchRepository())
             {
            var cupFinal = matchRepository.GetNationalCupFinal(previousSeason.Id);
            newSeasonInfo.NationalCupWinner = cupFinal.GetWinner();
             }

             // Now all teams have been placed in the right leagues, so create match schedules for all competitions.
             var seasonAndCompetitionSchedules = CreateSeasonAndCompetitionSchedules(newSeasonInfo);

             // Insert the season and all competition schedules.
             InsertSeasonAndCompetitionSchedule(repository, seasonAndCompetitionSchedules);
        }
Пример #17
0
        public void RegisterNew(IEntity entity, IUnitOfWorkRepository repository)
        {
            Debug.Assert(entity != null);
            if (dirtyEntities.ContainsKey(repository))
                Debug.Assert(!dirtyEntities[repository].Contains(entity), "object dirty");
            if (removedEntities.ContainsKey(repository))
                Debug.Assert(!removedEntities[repository].Contains(entity), "object removed");
            if (newEntities.ContainsKey(repository))
                Debug.Assert(!newEntities[repository].Contains(entity), "object already registered new");

            if (!newEntities.ContainsKey(repository))
                newEntities.Add(repository, new List<IEntity>());
            newEntities[repository].Add(entity);
        }
Пример #18
0
        public void RegisterDirty(IEntity entity, IUnitOfWorkRepository repository)
        {
            Debug.Assert(entity.Id != null, "id null");
            if (removedEntities.ContainsKey(repository))
                Debug.Assert(!removedEntities[repository].Contains(entity), "object removed");

            if ((!dirtyEntities.ContainsKey(repository) || (dirtyEntities.ContainsKey(repository) && !dirtyEntities[repository].Contains(entity)))
                && (!newEntities.ContainsKey(repository) || (newEntities.ContainsKey(repository) && !newEntities[repository].Contains(entity))))
            {
                if (!dirtyEntities.ContainsKey(repository))
                    dirtyEntities.Add(repository, new List<IEntity>());
                dirtyEntities[repository].Add(entity);
            }
        }
Пример #19
0
 public void RegisterAdd(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository)
 {
     if (_ItemQueue == null)
         _ItemQueue = new Queue<UnitItem>();
     UnitItem unitItem=new UnitItem()
     { Entity = entity, UnitOfWorkRepository = unitOfWorkRepository, Operator = UnitOperator.Add };
     if (_ItemQueue.Contains(unitItem))
     {
         throw new Exception("exist Entity in RegistorAdd!");
     }
     else
     {
         _ItemQueue.Enqueue(unitItem);
     }
 }
Пример #20
0
 public LocalPolicyRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr)
     : base(uow, uowr)
 {
 }
Пример #21
0
 public BehaviorStatRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr)
 {
 }
Пример #22
0
 public SMSChargeSetRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr)
     : base(uow, uowr)
 {
 }
Пример #23
0
 public NoticeRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr)
     : base(uow, uowr)
 {
 }
Пример #24
0
 public void RegisterRemove(T entity, IUnitOfWorkRepository<T> repository)
 {
     repository.PersistRemoveItem(entity);
 }
Пример #25
0
 public void RegisterAdd(T entity, IUnitOfWorkRepository<T> repository)
 {
     repository.PersistNewItem(entity);
 }
Пример #26
0
 /// <summary>
 /// 注册新增实体工作单元仓储接口
 /// </summary>
 /// <param name="entity">待新增实体接口</param>
 /// <param name="repository">工作单元仓储接口</param>
 public void RegisterAdded(IEntity entity, IUnitOfWorkRepository repository)
 {
     this.m_addedEntities.Add(entity, repository);
 }
Пример #27
0
 public void RegisterAdded(IEntity entity, IUnitOfWorkRepository repository)
 {
     Debug.WriteLine("RegisterAdded called...");
     this.addedEntities.Add(entity, repository);
 }
Пример #28
0
 public void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistUpdateOf(entity);
 }
Пример #29
0
 public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistCreationOf(entity);
 }
Пример #30
0
 public void RegisterRemoved(IEntity entity,
                             IUnitOfWorkRepository repository)
 {
     this.deletedEntities.Add(entity, repository);
 }
Пример #31
0
 public void RegisterChanged(IEntity entity,
                             IUnitOfWorkRepository repository)
 {
     this.changedEntities.Add(entity, repository);
 }
Пример #32
0
 public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository)
 {
     Debug.WriteLine("RegisterRemoved called...");
 }
Пример #33
0
 public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     SessionFactory.GetCurrentSession().Save(entity);
 }
Пример #34
0
 public InsurancePurchaseByBussinessmanRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr)
     : base(uow, uowr)
 {
 }
Пример #35
0
 /// <summary>
 /// Registers an <see cref="IEntity" /> instance to be changed through this <see cref="UnitOfWork" />
 /// </summary>
 /// <param name="entity">The <see cref="IEntity" /></param>
 /// <param name="repository">The <see cref="IUnitOfWorkRepository" /> participating in the transaction</param>
 public void RegisterChanged(IEntity entity, IUnitOfWorkRepository repository)
 {
     _operations.Enqueue(
         new Operation
         {
             Entity = entity,
             Repository = repository,
             Type = TransactionType.Update
         });
 }
Пример #36
0
 public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     SessionFactory.GetCurrentSession().Delete(entity);
 }
Пример #37
0
 public ClienteModel(IUnitOfWorkRepository unitOfWork)
 {
     _unitOfWork = unitOfWork;
 }
Пример #38
0
 public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistCreationOf(entity);
 }
Пример #39
0
 public void RegisterUpdate(T entity, IUnitOfWorkRepository<T> repository)
 {
     repository.PersistUpdateItem(entity);
 }
Пример #40
0
 public PostMatchManager(IUnitOfWorkRepository repository, ISeasonManager seasonManager)
 {
     _repository = repository;
      _seasonManager = seasonManager;
 }
Пример #41
0
 public Repository(IUnitOfWorkRepository unitOfWork)
 {
     _unitOfWork = unitOfWork;
 }
Пример #42
0
 public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository)
 {
     Debug.WriteLine("RegisterRemoved called...");
 }
 public UnitOfWorkService(IUnitOfWorkRepository unitOfWorkRepository)
 {
     _unitOfWorkRepository = unitOfWorkRepository;
 }
Пример #44
0
 private void PerformActionsAfterMatchesHaveBeenPlayed(List<Match> matches, IUnitOfWorkRepository repository)
 {
 }
Пример #45
0
 public void RegisterDelete(IAggregateRoot entity, IUnitOfWorkRepository repository)
 {
     SessionFactory.GetCurrentSession().Delete(entity);
 }
Пример #46
0
 public PlatformRefundOrderRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr)
 {
 }
Пример #47
0
 internal Removal(IAggregateRoot aggregateRoot, IUnitOfWorkRepository unitOfWorkRepository) : base(
         aggregateRoot, unitOfWorkRepository)
 {
 }
Пример #48
0
 public RepositoryContextAdapter(IUnitOfWorkRepository repository, RepositoryRegistry repositoryRegistry)
 {
     this.repository         = repository;
     this.repositoryRegistry = repositoryRegistry;
 }
Пример #49
0
 public object RegisterAdd(IAggregateRoot entity, IUnitOfWorkRepository repository)
 {
     return SessionFactory.GetCurrentSession().Save(entity);
 }
Пример #50
0
 public BaseRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr)
 {
     this._uow  = uow;
     this._uowr = uowr;
 }
Пример #51
0
 public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistDeletionOf(entity);
 }
Пример #52
0
 public void RegisterAdded(EntityBase entity,
                           IUnitOfWorkRepository repository)
 {
     this.addedEntities.Add(entity, repository);
 }
Пример #53
0
 public void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistUpdateOf(entity);
 }
Пример #54
0
 public void RegisterNewRange(IEnumerable <IAggregateRoot> entities, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistCreationRangeOf(entities);
 }
Пример #55
0
 public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository)
 {
     unitofWorkRepository.PersistDeletionOf(entity);
 }
Пример #56
0
 public UnitOfWork(MsSqlContext context)
 {
     this._context      = context;
     this._transaction  = this._context.Database.BeginTransaction();
     this._repositories = this._repositories = new UnitOfWorkRepository(this._context);
 }
Пример #57
0
 public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository)
 {
     Debug.Assert(entity.Id != null, "id null");
     if (newEntities.ContainsKey(repository) && newEntities[repository].Remove(entity)) return;
     if (dirtyEntities.ContainsKey(repository)) dirtyEntities[repository].Remove(entity);
     if (!removedEntities.ContainsKey(repository) || (removedEntities.ContainsKey(repository) && !removedEntities[repository].Contains(entity)))
     {
         if (!removedEntities.ContainsKey(repository))
             removedEntities.Add(repository, new List<IEntity>());
         removedEntities[repository].Add(entity);
     }
 }
Пример #58
0
 public void AddRepo(IUnitOfWorkRepository repository)
 {
     Repositories.Add(repository);
 }
 /// <summary>
 /// Registers an entity to be removed when commited.
 /// </summary>
 /// <param name="entity">Entity.</param>
 /// <param name="repository">Repository.</param>
 public virtual void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository repository)
 {
     Entities.Add(new EntityRepositoryPair(new UnitOfWorkEntity(entity, UnitOfWorkEntityState.Removed), repository));
 }
Пример #60
0
 public RepositoryContextAdapter ConvertContextOfRepository(IUnitOfWorkRepository repository)
 {
     return(new RepositoryContextAdapter(repository, repositoryRegistry));
 }