public async Task <ActionResult> JobOfferList(JobOfferListModel model) { if (!model.ApplyFavorite) { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); if (model.ApplyKeywords) { model.Filter.KeywordNumbers = applicant.KeywordNumbers; } var result = await JobOfferFacade.GetJobOffersAsync(model.Filter); model.JobOffers = new List <JobOfferDto>(result.Items); } else { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); var result = await JobOfferFacade.GetFavoriteJobOffersAsync(applicant.Id); model = new JobOfferListModel { JobOffers = new List <JobOfferDto>(result.Items), ApplyFavorite = true }; } return(View(model)); }
public JobOfferController(JobOfferFacade jobOfferFacade, CompanyFacade companyFacade, UserFacade userFacade, JobSeekerFacade jobSeekerFacade) { this.jobOfferFacade = jobOfferFacade; this.companyFacade = companyFacade; this.userFacade = userFacade; this.jobSeekerFacade = jobSeekerFacade; }
public async Task <ActionResult> Recommended() { var user = await UserFacade.GetUserByEmail(User.Identity.Name); var offers = await JobOfferFacade.GetRecommendedOffersForUser(user.Id, 10); return(View(offers)); }
public async Task <ActionResult> OffersOfCurrentEmployer() { var employer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); var offers = await JobOfferFacade.GetAllOffersOfEmployer(employer.Id); return(View("Index", offers)); }
public async Task <ActionResult> JobOfferEdit(JobOfferEditModel model) { await JobOfferFacade.EditJobOfferAsync(model.JobOffer); await JobOfferFacade.EditJobOffersKeywordsAsync(model.JobOffer.Id, model.Keywords); return(RedirectToAction("JobOfferList", "Company")); }
public async Task <ActionResult> FavoriteJobDelete(Guid jobOfferId) { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); Guid favoriteJobId = await JobOfferFacade.GetFavoriteByApplicantAndOffer(applicant.Id, jobOfferId); await JobOfferFacade.DeleteFavoriteJobOfferAsync(favoriteJobId); return(RedirectToAction("JobOfferList", "Applicant")); }
public async Task <ActionResult> JobOfferList() { var result = await JobOfferFacade.GetAllJobOffersAsync(); var model = new JobOfferListModel { JobOffers = new List <JobOfferDto>(result.Items) }; return(View(model)); }
public async Task <ActionResult> ApplicationCreate(Guid jobOfferId) { var jobOffer = await JobOfferFacade.GetJobOfferAsync(jobOfferId); var model = new ApplicationDto { JobOffer = jobOffer, JobOfferId = jobOfferId }; return(View(model)); }
public void JobOfferFacadeTest() { var unit = new UnitOfWork(GetInMemoryOptions()); Seeder.Seed(unit); var jobOfferService = new JobOfferService(unit, new JobOfferQueryObject(unit)); var jobOfferFacade = new JobOfferFacade(unit, jobOfferService, mapper); var o = new JobOfferDto() { Name = "Lol" }; jobOfferFacade.CreateAsync(o).Wait(); var s = unit.JobOfferQuery.FilterByName("Lol").ExecuteAsync().Result.First(); Assert.NotNull(s.Id); Assert.NotNull(jobOfferService.GetByIdAsync(s.Id ?? -1).Result); s.Id = null; s.Name = "new lol"; // Null ID get IMPOSSIBLE due to GetById accepting only int // Null ID edit/update var excp2 = Assert.Throws <AggregateException>(() => jobOfferFacade.UpdateAsync(mapper.Map <JobOfferDto>(s)).Wait()); Assert.Contains("The property 'Id' on entity type 'JobOffer' is part of a key " + "and so cannot be modified or marked as modified.", excp2.Message); // Null ID delete excp2 = Assert.Throws <AggregateException>(() => jobOfferFacade.DeleteAsync(mapper.Map <JobOfferDto>(s)).Wait()); Assert.Contains("JobOfferDto.Id can't be null!", excp2.Message); // Addition with conflicting ID // This invalidates the database var id1 = unit.JobOfferRepository.GetById(1); Assert.NotNull(id1); // makes sure company with id 1 is already in database var excp = Assert.Throws <AggregateException>(() => jobOfferFacade.CreateAsync(new JobOfferDto() { Id = 1 }).Wait()); Assert.Contains("The instance of entity type 'JobOffer' cannot be tracked " + "because another instance with the same key value for {'Id'} is already being tracked.", excp.Message); unit.Dispose(); }
public async Task <ActionResult> JobOfferCreate(JobOfferEditModel model) { var company = await CompanyFacade.GetCompanyAccordingToUsernameAsync(User.Identity.Name); model.JobOffer.CompanyId = company.Id; Guid id = await JobOfferFacade.CreateJobOfferAsync(model.JobOffer); await JobOfferFacade.EditJobOffersKeywordsAsync(id, model.Keywords); return(RedirectToAction("JobOfferList", "Company")); }
public async Task <ActionResult> JobOfferDetail(Guid id) { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); var model = new JobOfferDetailModel { JobOffer = await JobOfferFacade.GetJobOfferAsync(id), AlreadyApplied = await ApplicationFacade.CheckIfApplied(applicant.Id, id), AlreadyFavorite = await JobOfferFacade.CheckIfFavorite(applicant.Id, id) }; return(View(model)); }
public async Task <ActionResult> FavoriteJobCreate(Guid jobOfferId) { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); var favoriteJob = new FavoriteJobDto { JobOfferId = jobOfferId, ApplicantId = applicant.Id }; await JobOfferFacade.CreateFavoriteJobAsync(favoriteJob); return(RedirectToAction("JobOfferList", "Applicant")); }
public async Task <ActionResult> Delete(int id) { var offer = await JobOfferFacade.GetOffer(id); var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); if (currentEmployer.Id != offer.EmployerId) { throw new ArgumentException(); } return(View(offer)); }
public async Task <ActionResult> Delete(int id, FormCollection collection) { var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); try { await JobOfferFacade.DeleteJobOffer(id, currentEmployer); return(RedirectToAction("OffersOfCurrentEmployer")); } catch { return(View()); } }
public async Task <ActionResult> JobOfferEdit(Guid id) { var jobOffer = await JobOfferFacade.GetJobOfferAsync(id); var model = new JobOfferEditModel { JobOffer = jobOffer, Keywords = new List <bool>() }; for (int i = 0; i < Enum.GetNames(typeof(Keyword)).Length; i++) { model.Keywords.Add(jobOffer.KeywordNumbers.Contains(i)); } return(View(model)); }
public async Task <ActionResult> ApplicationsByJobOffer(int id) { var emoloyer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); var job = await JobOfferFacade.GetOffer(id); if (job.Employer.Id != emoloyer.Id) { throw new ArgumentException(); } var aplications = await JobApplicationFacade.GetByJobOffer(id); return(View("Index", aplications.Items)); }
public async Task <ActionResult> JobOfferList() { var company = await CompanyFacade.GetCompanyAccordingToUsernameAsync(User.Identity.Name); var filter = new JobOfferFilterDto { CompanyId = company.Id }; var result = await JobOfferFacade.GetJobOffersAsync(filter); var model = new JobOfferListModel { Filter = filter, JobOffers = new List <JobOfferDto>(result.Items) }; return(View(model)); }
public async Task <ActionResult> Create(int jobOfferId) { var offer = await JobOfferFacade.GetOffer(jobOfferId); var user = User.Identity.Name.IsNullOrEmpty() ? new ApplicantDto() : await UserFacade.GetUserByEmail(User.Identity.Name); var model = new JobApplicationCreateDto { Applicant = user, JobOffer = offer, JobOfferId = offer.Id }; return(View(model)); }
public async Task <ActionResult> ApplicationCreate(ApplicationDto model) { var applicant = await ApplicantFacade.GetApplicantAccordingToUsernameAsync(User.Identity.Name); model.ApplicantId = applicant.Id; model.State = ApplicationState.Undecided; await ApplicationFacade.CreateApplicationAsync(model); Guid favoriteJobId = await JobOfferFacade.GetFavoriteByApplicantAndOffer(applicant.Id, model.JobOfferId); if (favoriteJobId != Guid.Empty) { await JobOfferFacade.DeleteFavoriteJobOfferAsync(favoriteJobId); } return(RedirectToAction("ApplicationList", "Applicant")); }
public async Task <ActionResult> Edit(int id, JobOfferCreateViewModel model) { var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); if (ModelState.IsValid) { model.JobOfferCreateDto.EmployerId = currentEmployer.Id; await JobOfferFacade.EditJobOffer(model.JobOfferCreateDto, currentEmployer); return(RedirectToAction("OffersOfCurrentEmployer")); } model.AllSkills = await SkillSelectListHelper.Get(); model.Employer = currentEmployer; return(View(model)); }
private static async Task TestRecommendedJobs(Mapper mapper) { JobOfferFacade jobOfferFacade = new JobOfferFacade(Provider, mapper, new JobOfferService(mapper, new JobOfferRepository(Provider), new JobOfferQueryObject(mapper, new EntityFrameworkQuery <JobOffer>(Provider)), new SkillRepository(Provider)), new SkillService(mapper, new SkillRepository(Provider), new SkillQueryObject(mapper, new EntityFrameworkQuery <SkillTag>(Provider))), new JobOfferRecommendationService(), new UserService(mapper, new UserRepository(Provider), new UserQueryObject(mapper, new EntityFrameworkQuery <User>(Provider)), new SkillRepository(Provider))); var results = await jobOfferFacade.GetRecommendedOffersForUser(1, 10); foreach (var resultsItem in results) { Console.WriteLine(resultsItem.Name); } }
public async Task <ActionResult> Edit(int id) { var jobOfferCreateDto = new JobOfferCreateDto(await JobOfferFacade.GetOffer(id)); var currentEmployer = await EmployerFacade.GetEmployerByEmail(User.Identity.Name); if (currentEmployer.Id != jobOfferCreateDto.EmployerId) { throw new ArgumentException(); } var model = new JobOfferCreateViewModel { AllSkills = await SkillSelectListHelper.Get(), Employer = currentEmployer, JobOfferCreateDto = jobOfferCreateDto }; return(View(model)); }
public async Task <ActionResult> Create(JobApplicationCreateDto application) { if (ModelState.IsValid) { await JobApplicationFacade.CreateApplication(application); return(RedirectToAction("Details", "JobOffer", new { id = application.JobOfferId })); } var offer = await JobOfferFacade.GetOffer(application.JobOfferId); application.JobOffer = offer; application.JobOfferId = offer.Id; application.Applicant = User.Identity.Name.IsNullOrEmpty() ? new ApplicantDto() : await UserFacade.GetUserByEmail(User.Identity.Name); return(View(application)); }
private static async Task TestCreateOffer(Mapper mapper) { JobOfferFacade jobOfferFacade = new JobOfferFacade(Provider, mapper, new JobOfferService(mapper, new JobOfferRepository(Provider), new JobOfferQueryObject(mapper, new EntityFrameworkQuery <JobOffer>(Provider)), new SkillRepository(Provider)), new SkillService(mapper, new SkillRepository(Provider), new SkillQueryObject(mapper, new EntityFrameworkQuery <SkillTag>(Provider))), new JobOfferRecommendationService(), new UserService(mapper, new UserRepository(Provider), new UserQueryObject(mapper, new EntityFrameworkQuery <User>(Provider)), new SkillRepository(Provider))); await jobOfferFacade.CreateJobOffer(new JobOfferCreateDto { Description = "desc1", EmployerId = 1, Location = "loc1", Name = "name1", Questions = new[] { "q1", "q2", "q3" }, SkillNames = new[] { "Java", "Php" }, }); var results = await jobOfferFacade.GetAllOffersOfEmployer(1); foreach (var resultsItem in results) { Console.WriteLine(resultsItem.Name); } var results1 = await jobOfferFacade.GetOffersBySkill(1); foreach (var resultsItem in results1) { Console.WriteLine(resultsItem.Name); } }
public async Task <ActionResult> OffersOfEmployer(int id) { var offers = await JobOfferFacade.GetAllOffersOfEmployer(id); return(View("Index", offers)); }
// GET: JobOffer public async Task <ActionResult> Index() { var offers = (await JobOfferFacade.GetAllOffers()).Items; return(View(offers)); }
public async Task <ActionResult> OffersBySkill(int id) { var offers = await JobOfferFacade.GetOffersBySkill(id); return(View("Index", offers)); }
public async Task <ActionResult> Details(int id) { var offer = await JobOfferFacade.GetOffer(id); return(View(offer)); }
public JobOfferListController(JobOfferFacade jobOfferFacade) { this.jobOfferFacade = jobOfferFacade; }