public async Task <IActionResult> Index(PersonFilterValuesViewModel filter)
        {
            var currentUser = await _userManager.GetUserAsync(HttpContext.User);

            ViewBag.ConnectPerson = _appUserService.GetConnectPersonCompanyViewModel(currentUser.Id);
            ViewBag.Filter        = filter;

            IEnumerable <AppUser> users = (await _userManager.GetUsersInRoleAsync(RoleEnum.User.ToString())).AsQueryable().Include(user => user.CompanyAppUsers).ThenInclude(companyAppUser => companyAppUser.Company).Include(user => user.AppUserSkills).ThenInclude(appUserSkill => appUserSkill.Skill).Include(user => user.AppUserCertificates).ThenInclude(appUserCertificate => appUserCertificate.Certificate);

            return(View(_appUserService.Filter(users, filter)));
        }
        public IActionResult JobDetails(PersonFilterValuesViewModel filter)
        {
            var currentUser = _userManager.GetUserAsync(HttpContext.User);

            ViewBag.ConnectPerson = _appUserService.GetConnectPersonCompanyViewModel(currentUser.Result.Id);
            ViewBag.Filter        = filter;

            var job = _jobService.GetJobDetailsViewModel(filter.JobId);
            IEnumerable <AppUser> users = _userManager.Users.Include(user => user.CompanyAppUsers).ThenInclude(companyAppUser => companyAppUser.Company).Include(user => user.AppUserSkills).ThenInclude(appUserSkill => appUserSkill.Skill).Include(user => user.AppUserCertificates).ThenInclude(appUserCertificate => appUserCertificate.Certificate)
                                          .Where(user => job.AppUsers.Any(appUser => appUser.Id == user.Id));

            users        = _appUserService.Filter(users, filter);
            job.AppUsers = Mapping.Map <IEnumerable <AppUser>, List <AppUserViewModel> >(users);

            return(View(job));
        }
Beispiel #3
0
        public IEnumerable <AppUser> Filter(IEnumerable <AppUser> result, PersonFilterValuesViewModel filter)
        {
            // sort by location
            if (!string.IsNullOrEmpty(filter.Location))
            {
                result = result.Where(user => user.Location != null && user.Location.Trim().Contains(filter.Location.Trim(), StringComparison.InvariantCultureIgnoreCase));
            }

            // sort by industry
            if (filter.Industries != null && filter.Industries.Count() != 0)
            {
                result = result.Where(user => filter.Industries.Contains(user.Industry.GetDescription(), StringComparer.InvariantCultureIgnoreCase));
            }

            // sort by jobTypes
            if (filter.JobTypes != null && filter.JobTypes.Count() != 0)
            {
                result = result.Where(user => filter.JobTypes.Contains(user.JobType.GetDescription(), StringComparer.InvariantCultureIgnoreCase));
            }

            // sort by skills
            if (filter.Skills != null && filter.Skills.Count() != 0)
            {
                result = result.Where(user => user.AppUserSkills.Any(appUserSkill => filter.Skills.Any(skill => skill.Equals(appUserSkill.Skill.Name, StringComparison.InvariantCultureIgnoreCase))));
            }

            // sort by experience
            if (filter.Experience != null && filter.Experience.Count() != 0)
            {
                result = result.Where(user => filter.Experience.Contains(user.Experience.GetDescription(), StringComparer.InvariantCultureIgnoreCase));
            }

            // sort by certificates
            if (filter.Certificates != null && filter.Certificates.Count() != 0)
            {
                result = result.Where(user => user.AppUserCertificates.Any(appUserCertificates => filter.Certificates.Any(certificate => certificate.Equals(appUserCertificates.Certificate.Name, StringComparison.InvariantCultureIgnoreCase))));
            }

            // sort by company names
            if (filter.CompanyNames != null && filter.CompanyNames.Count() != 0)
            {
                result = result.Where(user => user.CompanyAppUsers.Any(companyAppUser => filter.CompanyNames.Any(companyName => companyName.Equals(companyAppUser.Company.Name, StringComparison.InvariantCultureIgnoreCase))));
            }

            return(result);
        }
        public IActionResult Applicants(PersonFilterValuesViewModel filter)
        {
            var currentUserId    = User.FindFirstValue(ClaimTypes.NameIdentifier);
            var currentCompanyId = _companyService.GetCurrentUserCompany(currentUserId).Id;

            ViewBag.ConnectPerson = _appUserService.GetConnectPersonCompanyViewModel(currentUserId);
            ViewBag.Filter        = filter;

            var applicants = _companyService.GetAllApplicants(currentCompanyId);

            // filter users
            var users = _appUserService.Filter(applicants.Select(applicant => applicant.AppUser), filter);

            // sort result
            applicants = applicants.Where(applicant => users.Any(user => user.Id == applicant.Id));

            return(View(new ApplicantsListsViewModel(applicants)));
        }