public List <KeyValuePair <string, string> > ValidateIndividualContestMember(IIndividualContestRegistration viewModel)
        {
            var result = new List <KeyValuePair <string, string> >();

            var currentUserId = _currentUserService.Id;

            if (viewModel.Participant1Id != currentUserId && viewModel.TrainerId != currentUserId && viewModel.ManagerId != currentUserId)
            {
                result.Add(KeyValuePair.Create(string.Empty, "Вы должны быть участником, тренером или руководителем, чтобы завершить регистрацию"));
            }

            return(result);
        }
        private async Task <List <KeyValuePair <string, string> > > ValidateIndividualContestRegistrationAsync(IIndividualContestRegistration viewModel, bool editRegistration)
        {
            var result = new List <KeyValuePair <string, string> >();

            var participantExists = !string.IsNullOrEmpty(viewModel.Participant1Id);

            if (!participantExists)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.Participant1Id), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.Participant1Id))));
            }

            if (editRegistration && !viewModel.Number.HasValue)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.Number), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.Number))));
            }

            var contest = await _readRepository.Set <Contest>().SingleAsync(c => c.Id == viewModel.ContestId);

            if (contest.IsProgrammingLanguageNeeded && string.IsNullOrEmpty(viewModel.ProgrammingLanguage))
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.ProgrammingLanguage), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.ProgrammingLanguage))));
            }

            var studyPlace = await _readRepository.Set <StudyPlace>().SingleAsync(s => s.Id == viewModel.StudyPlaceId);

            if (!viewModel.IsOutOfCompetition &&
                (contest.ParticipantType == ParticipantType.Pupil && studyPlace is Institution ||
                 contest.ParticipantType == ParticipantType.Student && studyPlace is School))
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.StudyPlaceId), "Тип учебного заведения не соответствует типу контеста"));
            }
            if (viewModel.CityId != studyPlace.CityId)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.CityId), "Выбранный город не соответствует городу учебного заведения"));
            }

            if (editRegistration)
            {
                var dbRegistration = await _readRepository.Set <Models.ContestRegistration>().Include(r => r.Participant1).SingleAsync(r => r.Id == viewModel.RegistrationId);

                if (dbRegistration.Participant1Id != viewModel.Participant1Id)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Participant1Id), "Нельзя менять пользователя при изменении регистрации"));
                }
            }
            else
            {
                var participantRegistred = await _readRepository.Set <Models.ContestRegistration>().AnyAsync(r => r.ContestId == contest.Id && r.Participant1Id == viewModel.Participant1Id);

                if (participantRegistred)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Participant1Id), "Указанный участник уже зарегистрирован в контесте"));
                }
            }

            if (viewModel.Participant1Id == viewModel.TrainerId)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.TrainerId), "Участник не может быть своим тренером"));
            }
            if (viewModel.Participant1Id == viewModel.ManagerId)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.ManagerId), "Участник не может быть своим руководителем"));
            }

            //var currentUserId = _currentUserService.Id;
            //if (!_currentUserService.IsAdmin && viewModel.Participant1Id != currentUserId && viewModel.TrainerId != currentUserId && viewModel.ManagerId != currentUserId)
            //    result.Add(KeyValuePair.Create(string.Empty, "Вы должны быть участником, тренером или руководителем, чтобы завершить регистрацию"));

            var participant = await _readRepository.Set <ApplicationUser>().SingleOrDefaultAsync(u => u.Id == viewModel.Participant1Id);

            var trainer = await _readRepository.Set <ApplicationUser>().SingleAsync(u => u.Id == viewModel.TrainerId);

            var manager = await _readRepository.Set <ApplicationUser>().SingleOrDefaultAsync(u => u.Id == viewModel.ManagerId);

            if (contest.ParticipantType == ParticipantType.Pupil && !viewModel.IsOutOfCompetition)
            {
                if (participantExists && participant.UserType != UserType.Pupil)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Participant1Id), "Только школьник может быть участником школьного контеста"));
                }
                if (!viewModel.Class.HasValue)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Class), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.Class))));
                }
            }

            if (contest.ParticipantType == ParticipantType.Student && !viewModel.IsOutOfCompetition)
            {
                if (participantExists && participant.UserType != UserType.Student)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Participant1Id), "Только студент может быть участником студенческого контеста"));
                }
                if (trainer.UserType == UserType.Pupil)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.TrainerId), "Школьник не может быть тренером на студенческом контесте"));
                }
                if (manager != null && manager.UserType == UserType.Pupil)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.ManagerId), "Школьник не может быть руководителем на студенческом контесте"));
                }

                if (!viewModel.Course.HasValue)
                {
                    result.Add(KeyValuePair.Create(nameof(viewModel.Course), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.Course))));
                }
            }

            if (contest.IsAreaRequired && !viewModel.ContestAreaId.HasValue)
            {
                result.Add(KeyValuePair.Create(nameof(viewModel.ContestAreaId), viewModel.GetRequredFieldErrorMessage(nameof(viewModel.ContestAreaId))));
            }

            return(result);
        }