public void AcceptTrainingRequestWorks()
{
var context = GetContext();
var trainerId = context.Trainers.First().Id;
var userId = context.Users.First().Id;
context.TrainingRequests.Add(new Domain.Entities.TrainingRequest
{
TrainerId = trainerId,
UserId = userId
});
context.SaveChanges();
var requestId = context.TrainingRequests.First().Id;
_trainerRepository = new Macrotracker.Users.Infrastructure.DataAccess.EfDataAccess.Repositories.EfTrainerRepository(context);
_trainerRepository.AcceptTrainingRequest(requestId);
context.TrainingRequests.Find(requestId).IsActive.Should().BeFalse();
context.Trainers
.Include(t => t.TrainerUsers)
.Where(t => t.Id == trainerId)
.First()
.TrainerUsers
.Any().Should().BeTrue();
}
public MainController(
IWindowFormsFactory formsFactory,
IPlayerRepository playerRepository,
ITrainerRepository trainerRepository,
IAdminRepository adminRepository,
ITrainingRepository trainingRepository,
ITeamRepository teamRepository,
ITransactionRepository transactionRepository,
IAdminController adminController,
IPlayerController playerController,
ITrainerController trainerController,
IAuthController authController
)
{
_formsFactory = formsFactory;
_playerRepository = playerRepository;
_trainerRepository = trainerRepository;
_adminRepository = adminRepository;
_trainingRepository = trainingRepository;
_teamRepository = teamRepository;
_transactionRepository = transactionRepository;
_adminController = adminController;
_playerController = playerController;
_trainerController = trainerController;
_authController = authController;
}
public SendTrainingRequestHandler(IUserRepository userRepo, ITrainerRepository trainerRepo, ITrainingRequestRepository requestRepo, IEventBus eventBus)
{
_userRepo = userRepo;
_trainerRepo = trainerRepo;
_requestRepo = requestRepo;
_eventBus = eventBus;
}
public void RemoveTrainerFromTeam(Trainer trainer, string teamName, ITrainerRepository trainerRepository)
{
if (teamName == "" && trainer.Teams.Count == 1)
{
teamName = GetTeamById(trainer.Teams[0].Id).Name;
}
Team toRemove = null;
foreach (Team t in _teamList)
{
if (t.Name.ToLower() == teamName.ToLower())
{
t.Trainers.Remove(trainer);
toRemove = t;
}
}
if (toRemove != null)
{
foreach (Trainer t in trainerRepository.GetAll())
{
if (t.Teams.Contains(toRemove) && t.Id == trainer.Id)
{
t.Teams.Remove(toRemove);
}
}
}
}
public void ThrowsExceptionWhenTrainerAndUserAreAlreadyConnected()
{
var context = GetContext();
var trainerId = context.Trainers.First().Id;
var userId = context.Users.First().Id;
context.TrainingRequests.Add(new Domain.Entities.TrainingRequest
{
TrainerId = trainerId,
UserId = userId
});
context.Trainers.Include(t => t.TrainerUsers)
.First()
.TrainerUsers
.Add(new Domain.TrainerUser
{
TrainerId = trainerId,
UserId = userId
});
context.SaveChanges();
var requestId = context.TrainingRequests.First().Id;
_trainerRepository = new Macrotracker.Users.Infrastructure.DataAccess.EfDataAccess.Repositories.EfTrainerRepository(context);
Assert.Throws <EntityAlreadyExistsException>(() => _trainerRepository.AcceptTrainingRequest(requestId));
}
public ClientService(IClientRepository ctx, IUserRepository ctxr, ICarnetRepository carnet, ITrainerRepository trainer)
{
_trainerRepository = trainer;
_clientRepository = ctx;
_ctxr = ctxr;
_carnetRepository = carnet;
}
public TrainerDetailViewModel(
IEventAggregator eventAggregator,
IDialogMessageService dialogMessageService,
ITrainerRepository trainerRepository)
: base(eventAggregator, dialogMessageService)
{
this.trainerRepository = trainerRepository;
}
public LessonService(ILesson lesson, ILessonRepository lessonRepository,
IStudentRepository studentRepository, ITrainerRepository trainerRepository)
{
_lesson = lesson;
_lessonRepository = lessonRepository;
_studentRepository = studentRepository;
_trainerRepository = trainerRepository;
}
public void DeleteTrainer(Trainer trainer, ITrainerRepository trainerRepository)
{
foreach (Team t in _teamList)
{
t.Trainers.Remove(trainer);
}
trainerRepository.Delete(trainer);
}
public TrainerAppService(ITrainerRepository trainerRepo,
IProgramRepository programRepo, ICompareAppService compareService,
IPersonRepository personRepo)
{
_trainerRepository = trainerRepo;
_programRepository = programRepo;
_compareAppService = compareService;
_personRepository = personRepo;
}
public void Homepage(IPlayerView form, IMainController inController, Player player, ITransactionRepository transactionRepository, ITrainerRepository trainerRepository, ITrainingRepository trainingRepository, ITeamRepository teamRepository)
{
ITransactionRepository transRep = transactionRepository;
ITrainingRepository trainRep = trainingRepository;
ITeamRepository teamRep = teamRepository;
ITrainerRepository trainerRep = trainerRepository;
form.ShowViewModaless(inController, player, transRep.GetAll(), trainRep.GetAll(), teamRep.GetAll(), trainerRep.GetAll());
}
public void Homepage(IAdminView form, IMainController inController, Admin admin, IPlayerRepository playerRepository, ITrainerRepository trainerRepository, ITeamRepository teamRepository, ITransactionRepository transactionRepository)
{
_form = form;
_playerRepository = playerRepository;
_trainerRepository = trainerRepository;
_teamRepository = teamRepository;
_transactionRepository = transactionRepository;
form.ShowViewModaless(inController, admin, playerRepository.GetAll(), trainerRepository.GetAll(), teamRepository.GetAll(), transactionRepository.GetAll());
}
public TrainerService(ITrainerRepository trainerRepository, IMapper mapper, IRateRepository rateRepository,
IFavouriteRepository favouriteRepository, ITrainingRepository trainingRepository)
{
_trainerRepository = trainerRepository;
_mapper = mapper;
_rateRepository = rateRepository;
_favouriteRepository = favouriteRepository;
_trainingRepository = trainingRepository;
}
public TrainersViewModel(
IEventAggregator eventAggregator,
IDialogMessageService dialogMessageService,
ITrainerRepository trainerRepository)
: base(eventAggregator, dialogMessageService)
{
this.trainerRepository = trainerRepository;
Title = "Все тренеры";
Trainers = new ObservableCollection <TrainerWrapper>();
}
public ExecutedDeltaAnalysisAppService(IProgramRepository programRepo,
ITrainingRepository trainingRepo, IModuleRepository moduleRepo,
ITraineeRepository traineeRepo, ITrainerRepository trainerRepository, IJobFunctionAppService jobFunctionService,
ICompetenceRepository competenceRepository, ICompareAppService compareService,
ITrainingStatusRepository trainingStatusRepository)
{
_programRepository = programRepo;
_trainingRepository = trainingRepo;
_moduleRepository = moduleRepo;
_traineeRepository = traineeRepo;
_trainerRepository = trainerRepository;
_jobFunctionAppService = jobFunctionService;
_competenceRepository = competenceRepository;
_compareAppService = compareService;
_trainingStatusRepository = trainingStatusRepository;
}
public TraineeAppService(ITraineeRepository traineeRepo, ITrainerRepository trainerRepository,
IJobFunctionRepository jobFunctionRepo,
ICompetenceRepository competenceRepo, IProgramRepository programRepo,
ITrainingRepository trainingRepo, ICompareAppService compareService,
IModuleRepository moduleRepo, IPersonRepository personRepo, ITokenAppService tokenAppService)
{
_traineeRepository = traineeRepo;
_trainerRepository = trainerRepository;
_jobFunctionRepository = jobFunctionRepo;
_competenceRepository = competenceRepo;
_programRepository = programRepo;
_trainingRepository = trainingRepo;
_compareAppService = compareService;
_moduleRepository = moduleRepo;
_personRepository = personRepo;
_tokenAppService = tokenAppService;
}
public TrainingAppService(ITrainingRepository trainingRepo,
IProgramRepository programRepo, IModuleRepository moduleRepo,
IConfigurationRepository configurationRepo,
ICompetenceRepository competenceRepo, ICompareAppService compareService,
ITraineeRepository traineeRepo, IPersonRepository personRepo,
ITrainerRepository trainerRepo, ITrainingStatusRepository trainingStatusRepo)
{
_trainingRepository = trainingRepo;
_programRepository = programRepo;
_moduleRepository = moduleRepo;
_configurationRepository = configurationRepo;
_competenceRepository = competenceRepo;
_compareAppService = compareService;
_traineeRepository = traineeRepo;
_personRepository = personRepo;
_trainerRepository = trainerRepo;
_trainingStatusRepository = trainingStatusRepo;
}
public UserService(IUserRepository repository, IMapper mapper, ITrainerRepository trainerRepository,
IClubRepository clubRepository, IFavouriteRepository favouriteRepository,
IRateRepository rateRepository, IBodyMeasurementRepository bodyMeasurementRepository,
ITrainingRepository trainingRepository, IReservationRepository reservationRepository,
IUserTrainingRepository userTrainingRepository, ITrainingService trainingService,
IChatRepository chatRepository)
{
_userRepository = repository;
_mapper = mapper;
_trainerRepository = trainerRepository;
_clubRepository = clubRepository;
_rateRepository = rateRepository;
_favouriteRepository = favouriteRepository;
_bodyMeasurementRepository = bodyMeasurementRepository;
_trainingRepository = trainingRepository;
_reservationRepository = reservationRepository;
_userTrainingRepository = userTrainingRepository;
_trainingService = trainingService;
_chatRepository = chatRepository;
}
public void AddTrainerToTeam(Trainer trainer, string teamName, ITrainerRepository trainerRepository)
{
Team newTeam = null;
foreach (Team t in _teamList)
{
if (t.Name.ToLower() == teamName.ToLower() && !t.Trainers.Contains(trainer))
{
t.Trainers.Add(trainer);
newTeam = t;
}
}
if (newTeam != null)
{
foreach (Trainer t in trainerRepository.GetAll())
{
if (t.Id == trainer.Id)
{
t.Teams.Add(newTeam);
}
}
}
}
public TrainersController(ITrainerRepository trainerRepository, IDexEntryRepository dexEntryRepository)
{
_trainerRepository = trainerRepository;
_dexEntryRepository = dexEntryRepository;
}
public TrainerService(IDatabaseContext ctx)
{
this._repTraining = RepositoryFactory.CreateTrainingRepository(ctx);
}
public TrainerService(ITrainerRepository trainerRepository, IUnitOfWork unitOfWork)
{
_trainerRepository = trainerRepository;
_unitOfWork = unitOfWork;
}
public TrainersController(ITrainerRepository _repository)
{
repository = _repository;
}
public bool VerifyRegisterInput(string email, string password, string firstName, string lastName, string role, string age, IPlayerRepository playerRepository, ITrainerRepository trainerRepository)
{
if (!ValidationFunctions.IsValidEmail(email))
{
return(false);
}
if (!ValidationFunctions.IsValidPassword(password))
{
return(false);
}
if (!ValidationFunctions.IsValidName(new string[] { firstName, lastName }))
{
return(false);
}
if (role == "Player" && !ValidationFunctions.IsValidAge(age))
{
return(false);
}
if (role == "")
{
return(false);
}
switch (role)
{
case "Player":
{
if (RegisterPlayer(email, password, firstName, lastName, age, playerRepository, trainerRepository))
{
return(true);
}
return(false);
}
case "Trainer":
{
if (RegisterTrainer(email, password, firstName, lastName, trainerRepository, playerRepository))
{
return(true);
}
return(false);
}
case "": return(false);
}
return(false);
}
public bool RegisterPlayer(string email, string password, string firstName, string lastName, string age, IPlayerRepository playerRepository, ITrainerRepository trainerRepository)
{
Player newPlayer = new Player(1, firstName, lastName, email, password, int.Parse(age), false);
Trainer checkEmailInUse = new Trainer(1, firstName, lastName, email, password, false);
if (!playerRepository.CheckPlayerExists(newPlayer) && !trainerRepository.CheckTrainerExists(checkEmailInUse))
{
playerRepository.Add(newPlayer);
return(true);
}
return(false);
}
public string LogInUser(string email, string password, IPlayerRepository playerRepository, ITrainerRepository trainerRepository, IAdminRepository adminRepository)
{
foreach (Player p in playerRepository.GetAll())
{
if (p.Email == email && p.Password == password)
{
return("player");
}
}
foreach (Trainer t in trainerRepository.GetAll())
{
if (t.Email == email && t.Password == password)
{
return("trainer");
}
}
foreach (Admin a in adminRepository.GetAll())
{
if (a.Email == email && a.Password == password)
{
return("admin");
}
}
return("");
}
public UpdateTrainerService(ITrainerRepository trainerRepository)
{
_trainerRepository = trainerRepository;
}
public TrainerService(ITrainerRepository repository)
{
_repository = repository;
}
public TrainerService(ITrainerRepository ctx)
{
_trainerRepository = ctx;
}
public TrainersController(ITrainerRepository db, IHostingEnvironment db2)
{
this.db = db;
this.db2 = db2;
}
public ListTrainersService(ITrainerRepository trainerRepository)
{
_trainerRepository = trainerRepository;
}
