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;
}
