Example #1
0
 /// <summary>
 /// Initialises a new instance of the <see cref="DriverService"/> class.
 /// </summary>
 /// <param name="driverRepository">The driver repository.</param>
 /// <param name="raceRepository">The race repository.</param>
 /// <param name="driverObservation">The driver observation.</param>
 /// <param name="mapper">The driver object mapper.</param>
 public DriverService(IDriverRepository driverRepository, IRaceRepository raceRepository, IDriverObservation driverObservation, DriverMapper mapper)
 {
     _driverRepository  = driverRepository;
     _raceRepository    = raceRepository;
     _driverObservation = driverObservation;
     _mapper            = mapper;
 }
Example #2
0
 public Statistician(IRaceRepository raceRepository, ISeasonRepository seasonRepository, IDriverRepository driverRepository, IDriverContractRepository contractRepository)
 {
     _raceRepository = raceRepository;
     _seasonRepository = seasonRepository;
     _driverRepository = driverRepository;
     _contractRepository = contractRepository;
 }
Example #3
0
 public StatisticManager(
     ILapStatisticRepository lapStatisticRepository,
     IRaceRepository raceRepository)
 {
     this._lapStatisticRepository = lapStatisticRepository;
     this._raceRepository         = raceRepository;
 }
Example #4
0
 public RaceController(IRaceRepository raceRepository, UserManager <ApplicationUser> userManager, IRaceOrganizerRepository raceOrganizerRepository)
 {
     _raceRepository          = raceRepository;
     _raceOrganizerRepository = raceOrganizerRepository;
     _userManager             = userManager;
     _idRaceOrganizer         = 0;
 }
Example #5
0
 public RaceService(IRaceFileReader raceFileProcessor,
                    IRaceRepository raceRepository,
                    IRaceQuery raceQuery,
                    IRaceTypeRepository raceTypeRepository,
                    IRaceTypeQuery raceTypeQuery,
                    IUserRepository userRepository,
                    IUserQuery userQuery,
                    ILapRepository lapRepository,
                    IDriverResultRepository driverResultRepository,
                    IDriverResultQuery driverResultQuery,
                    IOptions <FileServerSettings> fileServerOptions,
                    IOptions <RaceFileSettings> raceFileOptions,
                    IMapper mapper)
 {
     this._raceFileReader         = raceFileProcessor;
     this._raceRepository         = raceRepository;
     this._raceQuery              = raceQuery;
     this._raceTypeRepository     = raceTypeRepository;
     this._raceTypeQuery          = raceTypeQuery;
     this._userRepository         = userRepository;
     this._userQuery              = userQuery;
     this._lapRepository          = lapRepository;
     this._driverResultRepository = driverResultRepository;
     this._driverResultQuery      = driverResultQuery;
     this._fileServerSettings     = fileServerOptions.Value;
     this._raceFileSettings       = raceFileOptions.Value;
     this._mapper = mapper;
 }
Example #6
0
 public RaceFinishedHandler(
     IRaceRepository raceRepository,
     EventDispatcher eventDispatcher)
 {
     this._raceRepository  = raceRepository;
     this._eventDispatcher = eventDispatcher;
 }
 public LapCompletedHandler(
     IRaceRepository raceRepository,
     ILapStatisticRepository lapStatisticRepository)
 {
     this._raceRepository         = raceRepository;
     this._lapStatisticRepository = lapStatisticRepository;
 }
        public void Simple_Status_Candidate()
        {
            IRaceRepository           raceRepository           = Substitute.For <IRaceRepository>();
            IPoliticalPartyRepository politicalPartyRepository = Substitute.For <IPoliticalPartyRepository>();
            var f              = new Fixture();
            var race           = f.Create <Race>();
            var politicalParty = f.Create <PoliticalParty>();
            var candidate      = Create();

            raceRepository.GetById(Arg.Any <Guid>()).Returns(race);
            politicalPartyRepository.GetById(Arg.Any <Guid>()).Returns(politicalParty);
            var candidateRepository = new CandidateRepository(ContextConnection(), politicalPartyRepository, raceRepository);

            candidateRepository.Save(candidate);
            candidateRepository.SetInactive(candidate);
            var inactive = candidateRepository.GetById(candidate.Id);

            Assert.That(inactive.Status == EntityStatus.Inactive);

            candidateRepository.SetActive(candidate);
            var active = candidateRepository.GetById(candidate.Id);

            Assert.That(active.Status == EntityStatus.Active);

            candidateRepository.SetAsDeleted(candidate);
            var deleted = candidateRepository.GetById(candidate.Id);

            Assert.That(deleted.Status == EntityStatus.Deleted);
        }
Example #9
0
 public RaceService(IMapper mapper, IRaceRepository raceRepository, IBonusService bonusService,
                    IAbilityService abilityService) : base(mapper)
 {
     _raceRepository = raceRepository;
     _bonusService   = bonusService;
     _abilityService = abilityService;
 }
Example #10
0
        public UnitOfWork(CharacterContext context, SpellsContext spellsContext, ItemsContext itemsContext, PlayableClassContext playableClassContext, RaceContext raceContext)
        {
            _context           = context;
            Characters         = RepositoryFactory.GetCharacterRepository(context);
            HealthRecords      = RepositoryFactory.GetHealthRepository(context);
            CurrencyRecords    = RepositoryFactory.GetCurrencyRepository(context);
            ProficiencyRecords = RepositoryFactory.GetIsProficientRepository(context);
            Notes = RepositoryFactory.GetNotesRepository(context);
            Stats = RepositoryFactory.GetStatsRepository(context);

            _spellsContext = spellsContext;
            Spells         = RepositoryFactory.GetSpellsRepository(spellsContext);

            _itemsContext = itemsContext;
            Items         = RepositoryFactory.GetItemsRepository(itemsContext);

            _playableClassContext = playableClassContext;
            Classes           = RepositoryFactory.GetPlayableClassRepository(playableClassContext);
            ClassAbilities    = RepositoryFactory.GetClassAbilityRepository(playableClassContext);
            Subclasses        = RepositoryFactory.GetSubclassRepository(playableClassContext);
            SubclassAbilities = RepositoryFactory.GetSubclassAbilityRepository(playableClassContext);

            _raceContext = raceContext;
            Races        = RepositoryFactory.GetRacesRepository(raceContext);
        }
Example #11
0
 public static CharactersVM CreateCharacterVm(IRaceRepository raceRepository)
 {
     return(new CharactersVM()
     {
         Character = new Character(),
         RaceSelectList = new SelectList(raceRepository.Get(), "RaceId", "Name")
     });
 }
Example #12
0
 public static CharactersVM EditCharacterVm(IRaceRepository raceRepository, Character c)
 {
     return(new CharactersVM()
     {
         Character = c,
         RaceSelectList = new SelectList(raceRepository.Get(), "RaceId", "Name")
     });
 }
        public void SetUp()
        {
            _raceRepository = MockRepository.GenerateMock<IRaceRepository>();
            _seasonRepository = MockRepository.GenerateMock<ISeasonRepository>();
            _driverRepository = MockRepository.GenerateMock<IDriverRepository>();
            _contractRepository = MockRepository.GenerateMock<IDriverContractRepository>();

            _statistician = new Statistician(_raceRepository, _seasonRepository, _driverRepository, _contractRepository);
        }
 public TeamController(ITeamRepository TeamRepository, ITeamRaceRepository TeamRaceRepository, IRaceRepository RaceRepository,
                       IEmployeeRepository EmployeeRepository, ITeamComponentRepository TeamComponentRepository)
 {
     ITeamRepository          = TeamRepository;
     ITeamRaceRepository      = TeamRaceRepository;
     IRaceRepository          = RaceRepository;
     IEmployeeRepository      = EmployeeRepository;
     ITeamComponentRepository = TeamComponentRepository;
 }
        private static IRaceRepository _raceRepository; // = new RaceRepository();

        public ElectionMonitoringController(IRaceResultService raceResultRepository,
                                            IRegionRepository regionRepository, IRaceRepository raceRepository)
        {
            Guard.ArgumentNotNull(raceRepository, "raceRepository");
            Guard.ArgumentNotNull(regionRepository, "regionRepository");
            Guard.ArgumentNotNull(raceResultRepository, "raceResultRepository");

            _raceResultRepository = raceResultRepository;
            _regionRepository = regionRepository;
            _raceRepository = raceRepository;
        }
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);

            _raceRepository = new RaceRepository();

            ImageButton save = Panel1.Menu.NewImageButton();
            save.ImageUrl = umbraco.GlobalSettings.Path + "/images/editor/save.gif";
            save.AlternateText = "Save";
            save.Click += new ImageClickEventHandler(SaveRecord);
        }
        private static IRaceRepository _raceRepository;          // = new RaceRepository();

        public ElectionMonitoringController(IRaceResultService raceResultRepository,
                                            IRegionRepository regionRepository, IRaceRepository raceRepository)
        {
            Guard.ArgumentNotNull(raceRepository, "raceRepository");
            Guard.ArgumentNotNull(regionRepository, "regionRepository");
            Guard.ArgumentNotNull(raceResultRepository, "raceResultRepository");

            _raceResultRepository = raceResultRepository;
            _regionRepository     = regionRepository;
            _raceRepository       = raceRepository;
        }
Example #18
0
 public TournamentService(
     ITournamentRepository tournamentRepository,
     IRaceRepository raceRepository,
     ITeamRepository teamRepository,
     IDivisionRepository divisionRepository)
 {
     _tournamentRepository = tournamentRepository;
     _raceRepository       = raceRepository;
     _teamRepository       = teamRepository;
     _divisionRepository   = divisionRepository;
 }
Example #19
0
 public RaceController(
     IPointRepository pointRepository,
     IRaceRepository raceRepository,
     ISeasonRepository seasonRepository,
     IOrganizationRepository organizationRepository)
 {
     _pointRepository        = pointRepository;
     _raceRepository         = raceRepository;
     _seasonRepository       = seasonRepository;
     _organizationRepository = organizationRepository;
 }
 public PlayerCharacterService(
     IPlayerCharacterRepository playerCharacterRepository,
     IUserRepository userRepository,
     IClassRepository classRepository,
     IRaceRepository raceRepository
     )
 {
     _playerCharacterRepository = playerCharacterRepository;
     _userRepository            = userRepository;
     _classRepository           = classRepository;
     _raceRepository            = raceRepository;
 }
Example #21
0
 public EventDispatcher(
     IRaceRepository raceRepository,
     ITeamRepository teamRepository,
     IActiveTeamRepository activeTeamRepository,
     ILapStatisticRepository lapStatisticRepository)
 {
     this._raceStartedHandler      = new RaceStartedHandler(raceRepository, this);
     this._raceEndedHandler        = new RaceFinishedHandler(raceRepository, this);
     this._teamRaceStartedHandler  = new TeamRaceStartedHandler(teamRepository, activeTeamRepository);
     this._teamRaceFinishedHandler = new TeamRaceFinishedHandler(teamRepository, activeTeamRepository);
     this._lapCompletedHandler     = new LapCompletedHandler(raceRepository, lapStatisticRepository);
     this._teamCreatedHandler      = new TeamCreatedHandler(raceRepository);
 }
Example #22
0
 public UnitOfWork(DataContext context,
                   IPetRepository petRepository,
                   IRaceRepository races,
                   IImageRepository images,
                   IAccountRepository accounts,
                   IMessageRepository messages)
 {
     _context = context;
     Pets     = petRepository;
     Races    = races;
     Images   = images;
     Accounts = accounts;
     Messages = messages;
 }
Example #23
0
 public MapController(UserManager <ApplicationUser> userManager,
                      IActivityRepository activityRepository,
                      IRaceRepository raceRepository,
                      IRunnerRepository runnerRepository,
                      ITelemetryRepository telemetryRepository,
                      IConfiguration configuration)
 {
     _configuration       = configuration;
     _userManager         = userManager;
     _activityRepository  = activityRepository;
     _raceRepository      = raceRepository;
     _runnerRepository    = runnerRepository;
     _telemetryRepository = telemetryRepository;
     _idRunner            = 0;
 }
Example #24
0
        public RaceManager(
            IRaceRepository raceRepository,
            ITeamRepository teamRepository,
            IActiveTeamRepository activeTeamRepository,
            ILapStatisticRepository lapStatisticRepository)
        {
            this._raceRepository       = raceRepository;
            this._teamRepository       = teamRepository;
            this._activeTeamRepository = activeTeamRepository;

            this._eventDispatcher = new EventDispatcher(
                raceRepository,
                teamRepository,
                activeTeamRepository,
                lapStatisticRepository);
        }
        public void SimpeHydrate_Candidate()
        {
            IRaceRepository           raceRepository           = Substitute.For <IRaceRepository>();
            IPoliticalPartyRepository politicalPartyRepository = Substitute.For <IPoliticalPartyRepository>();
            var f              = new Fixture();
            var race           = f.Create <Race>();
            var politicalParty = f.Create <PoliticalParty>();
            var candidate      = Create();

            raceRepository.GetById(Arg.Any <Guid>()).Returns(race);
            politicalPartyRepository.GetById(Arg.Any <Guid>()).Returns(politicalParty);
            var candidateRepository = new CandidateRepository(ContextConnection(), politicalPartyRepository, raceRepository);
            var id = candidateRepository.Save(candidate);

            Assert.IsNotNull(id);
            Assert.AreEqual(id, candidate.Id);
        }
        public void SimpeDeHydrateAll_Candidate()
        {
            IRaceRepository           raceRepository           = Substitute.For <IRaceRepository>();
            IPoliticalPartyRepository politicalPartyRepository = Substitute.For <IPoliticalPartyRepository>();
            var f              = new Fixture();
            var race           = f.Create <Race>();
            var politicalParty = f.Create <PoliticalParty>();
            var candidate      = Create();

            raceRepository.GetById(Arg.Any <Guid>()).Returns(race);
            politicalPartyRepository.GetById(Arg.Any <Guid>()).Returns(politicalParty);
            var candidateRepository = new CandidateRepository(ContextConnection(), politicalPartyRepository, raceRepository);

            candidateRepository.Save(candidate);
            var owner = candidateRepository.GetAll();

            Assert.That(owner.Any());
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack) {

                _raceRepository = new RaceRepository();

                var races = _raceRepository.GetAll();

                RaceList.DataSource = races;
                RaceList.DataValueField = "Id";
                RaceList.DataTextField = "Name";
                RaceList.DataBind();

                var item = RaceList.Items.FindByValue(_raceId);
                if (item != null) item.Selected = true;

            }
        }
        public void SetData(int raceId, string type)
        {
            Type = type;
            RaceId = raceId;
            _raceRepository = new RaceRepository();
            var race = _raceRepository.GetById(raceId);

            var model = new List<ResultViewModel>();

            if (race != null)
            {
                if (type == "Race")
                {
                    model.AddRange(from result in race.GetRaceResults()
                                   let qualiResult = race.GetQualifyingResult(result.Entry)
                                   select new ResultViewModel
                                              {
                                                  Name = result.Entrant.Driver.Name, Time = result.Entry.FastestLap.ToLapTime(true), Position = result.GetPositionString(true),
                                                  Points = result.Points.ToString(), GridPosition = qualiResult.Position.ToString(),
                                                  TotalPoints = (result.Points + qualiResult.Points).ToString(), HasQualifyingPoints = result.Entry.PointsSystem.GivesPointsForQualifying,
                                                  HasFastestLap = race.GotFastestLap(result.Entrant.Driver),
                                                  RaceTime = result.Entry.RaceTime
                                              });
                }
                else
                {
                    model.AddRange(race.GetQualificationResults().Select(result => new ResultViewModel
                                                                                       {
                                                                                           Name = result.Entrant.Driver.Name, Time = result.LapTime.ToLapTime(true),
                                                                                           Position = result.GetQualifyingPositionString(true), Points = result.Points.ToString(),
                                                                                           HasQualifyingPoints = result.Entry.PointsSystem.GivesPointsForQualifying
                                                                                       }));
                }
            }

            InlineResultRepeater.DataSource = model;
            InlineResultRepeater.DataBind();
        }
Example #29
0
 public ResultController(
     IRaceRepository raceRepository)
 {
     _raceRepository = raceRepository;
 }
 private void CheckDependancies()
 {
     if (_raceRepository == null) _raceRepository = new RaceRepository();
 }
 public GetBetListQueryHandler(IRaceRepository raceRepository)
 {
     this.raceRepository = raceRepository;
 }
 private void CheckDependancies()
 {
     if (_statistician == null) _statistician = new CachedStatistician();
     if (_circuitRepository == null) _circuitRepository = new CircuitRepository();
     if (_raceRepository == null) _raceRepository = new RaceRepository();
 }
Example #33
0
 public RacersController(IRaceRepository NewRaceRepository)
 {
     CurrentRaceRepository = NewRaceRepository;
 }
Example #34
0
 public RaceService(IRaceRepository race, IConfiguration configuration)
 {
     _race          = race ?? throw new ArgumentNullException(nameof(race));
     _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
 }
 public loadResultsRaceEntries(BaseTree tree)
     : base(tree)
 {
     _raceRepository = new RaceRepository();
 }
Example #36
0
 public RaceController(IRaceRepository raceRepository)
 {
     repository = raceRepository;
 }
Example #37
0
 public AdminController(IRaceRepository repo)
 {
     repository = repo;
 }
Example #38
0
 public RaceManager(IRaceRepository NewRaceRepository, IAccessorToRaceInfo NewAccessorToRaceInfo)
 {
     CurrentRaceRepository = NewRaceRepository;
     CurrentAccessorToRaceInfo = NewAccessorToRaceInfo;
 }
 public CharacterController(ICharacterRepository characterRepo, IRaceRepository raceRepo)
 {
     this.characterRepository = characterRepo;
     this.raceRepository      = raceRepo;
 }
Example #40
0
 public RaceService(IRaceRepository raceRepository)
 {
     this.raceRepository = raceRepository;
 }
Example #41
0
 public RaceController(IRaceRepository RaceRepository, ITeamRaceRepository TeamRaceRepository, ITeamRepository TeamRepository)
 {
     IRaceRepository     = RaceRepository;
     ITeamRaceRepository = TeamRaceRepository;
     ITeamRepository     = TeamRepository;
 }
Example #42
0
 public RaceController(IRaceRepository repo)
 {
     this.repo = repo;
 }
Example #43
0
 public raceEntryTasks()
 {
     _repository = new RaceRepository();
 }