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); } }
public void RegistraRemovido(IPersistenciaBase entidade, IUnitOfWorkRepository unitofWorkRepository) { if (!entidadesDeletadas.ContainsKey(entidade)) { entidadesDeletadas.Add(entidade, unitofWorkRepository); } }
public void RegistraNovo(IPersistenciaBase entidade, IUnitOfWorkRepository unitofWorkRepository) { if (!entidadesAdicionadas.ContainsKey(entidade)) { entidadesAdicionadas.Add(entidade, unitofWorkRepository); } }
public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository) { if (!addedEntities.ContainsKey(entity)) { addedEntities.Add(entity, unitOfWorkRepository); } }
public void RegisterAmended(IAggregateDataModel entity, IUnitOfWorkRepository unitofWorkRepository) { if (!changedEntities.ContainsKey(entity)) { changedEntities.Add(entity, unitofWorkRepository); } }
public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitOfWorkRepository) { if (!deletedEntities.ContainsKey(entity)) { deletedEntities.Add(entity, unitOfWorkRepository); } }
public void RegisterAmended(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository) { if (!changedEntities.ContainsKey(objectEntity)) { changedEntities.Add(objectEntity, unitOfWorkRepository); } }
public void RegisterRemoved(IAggregateRoot objectEntity, IUnitOfWorkRepository unitOfWorkRepository) { if (!removedEntities.ContainsKey(objectEntity)) { removedEntities.Add(objectEntity, unitOfWorkRepository); } }
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); } }
/// <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 }); }
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); }
/// <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 }); }
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); }
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); }
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); } }
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); } }
public LocalPolicyRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
public BehaviorStatRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
public SMSChargeSetRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
public NoticeRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
public void RegisterRemove(T entity, IUnitOfWorkRepository<T> repository) { repository.PersistRemoveItem(entity); }
public void RegisterAdd(T entity, IUnitOfWorkRepository<T> repository) { repository.PersistNewItem(entity); }
/// <summary> /// 注册新增实体工作单元仓储接口 /// </summary> /// <param name="entity">待新增实体接口</param> /// <param name="repository">工作单元仓储接口</param> public void RegisterAdded(IEntity entity, IUnitOfWorkRepository repository) { this.m_addedEntities.Add(entity, repository); }
public void RegisterAdded(IEntity entity, IUnitOfWorkRepository repository) { Debug.WriteLine("RegisterAdded called..."); this.addedEntities.Add(entity, repository); }
public void RegisterAmended(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistUpdateOf(entity); }
public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistCreationOf(entity); }
public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository) { this.deletedEntities.Add(entity, repository); }
public void RegisterChanged(IEntity entity, IUnitOfWorkRepository repository) { this.changedEntities.Add(entity, repository); }
public void RegisterRemoved(IEntity entity, IUnitOfWorkRepository repository) { Debug.WriteLine("RegisterRemoved called..."); }
public void RegisterNew(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { SessionFactory.GetCurrentSession().Save(entity); }
public InsurancePurchaseByBussinessmanRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
/// <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 }); }
public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { SessionFactory.GetCurrentSession().Delete(entity); }
public ClienteModel(IUnitOfWorkRepository unitOfWork) { _unitOfWork = unitOfWork; }
public void RegisterUpdate(T entity, IUnitOfWorkRepository<T> repository) { repository.PersistUpdateItem(entity); }
public PostMatchManager(IUnitOfWorkRepository repository, ISeasonManager seasonManager) { _repository = repository; _seasonManager = seasonManager; }
public Repository(IUnitOfWorkRepository unitOfWork) { _unitOfWork = unitOfWork; }
public UnitOfWorkService(IUnitOfWorkRepository unitOfWorkRepository) { _unitOfWorkRepository = unitOfWorkRepository; }
private void PerformActionsAfterMatchesHaveBeenPlayed(List<Match> matches, IUnitOfWorkRepository repository) { }
public void RegisterDelete(IAggregateRoot entity, IUnitOfWorkRepository repository) { SessionFactory.GetCurrentSession().Delete(entity); }
public PlatformRefundOrderRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) : base(uow, uowr) { }
internal Removal(IAggregateRoot aggregateRoot, IUnitOfWorkRepository unitOfWorkRepository) : base( aggregateRoot, unitOfWorkRepository) { }
public RepositoryContextAdapter(IUnitOfWorkRepository repository, RepositoryRegistry repositoryRegistry) { this.repository = repository; this.repositoryRegistry = repositoryRegistry; }
public object RegisterAdd(IAggregateRoot entity, IUnitOfWorkRepository repository) { return SessionFactory.GetCurrentSession().Save(entity); }
public BaseRepository(IUnitOfWork uow, IUnitOfWorkRepository uowr) { this._uow = uow; this._uowr = uowr; }
public void RegisterRemoved(IAggregateRoot entity, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistDeletionOf(entity); }
public void RegisterAdded(EntityBase entity, IUnitOfWorkRepository repository) { this.addedEntities.Add(entity, repository); }
public void RegisterNewRange(IEnumerable <IAggregateRoot> entities, IUnitOfWorkRepository unitofWorkRepository) { unitofWorkRepository.PersistCreationRangeOf(entities); }
public UnitOfWork(MsSqlContext context) { this._context = context; this._transaction = this._context.Database.BeginTransaction(); this._repositories = this._repositories = new UnitOfWorkRepository(this._context); }
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); } }
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)); }
public RepositoryContextAdapter ConvertContextOfRepository(IUnitOfWorkRepository repository) { return(new RepositoryContextAdapter(repository, repositoryRegistry)); }