public IActionResult AddNewSkill(JobOfferDto jobOffer)
{
jobOffer.RelevantSkills.Add("");
if (jobOffer.Id != null)
{
return(View("EditJobOffer", jobOffer));
}
return(View("AddJobOffer", jobOffer));
}
/// <summary>
/// Creates jobOffer
/// </summary>
/// <param name="jobOffer">product</param>
public async Task <Guid> CreateJobOfferAsync(JobOfferDto jobOffer)
{
using (var uow = UnitOfWorkProvider.Create())
{
var jobOfferId = jobOfferService.Create(jobOffer);
await uow.Commit();
return(jobOfferId);
}
}
public async Task <IActionResult> DeleteJobOffer(JobOfferDto offer)
{
if (offer == null)
{
return(BadRequest());
}
await jobOfferFacade.DeleteAsync(offer);
return(RedirectToAction(nameof(Index)));
}
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 IActionResult AddNewQuestion(JobOfferDto jobOffer)
{
jobOffer.Questions.Add(new JobOfferQuestionDto {
Text = ""
});
if (jobOffer.Id != null)
{
return(View("EditJobOffer", jobOffer));
}
return(View("AddJobOffer", jobOffer));
}
public virtual async Task <IActionResult> Post([FromBody] JobOfferDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var a = _mapper.Map <JobOffer>(model);
var result = await _unitOfWork.Repository <JobOffer>().AddAsync(a);
await _unitOfWork.Commit();
return(Ok(result.Id));
}
public async Task <IActionResult> AddJobOffer(JobOfferDto jobOffer)
{
var user = await userFacade.GetByIdAsync(int.Parse(User.Identity.Name));
if (ModelState.IsValid && user.CompanyId == jobOffer.CompanyId)
{
await jobOfferFacade.CreateAsync(jobOffer);
return(RedirectToAction(nameof(Index)));
}
throw new ArgumentException();
}
public async Task <IActionResult> JobOfferDetail(int?id)
{
if (id == null)
{
return(BadRequest());
}
JobOfferDto offer = await jobOfferFacade.GetByIdWithQuestionsAsync(id.Value);
if (offer == null)
{
return(NotFound());
}
return(View(offer));
}
public async Task Post_ReturnsOfferId()
{
var uof = new Mock <IUnitOfWork>();
var mappingConfig = new MapperConfiguration(map => { map.AddProfile(new MappingProfile()); });
var mapper = mappingConfig.CreateMapper();
var controller = new JobOffersController(uof.Object, mapper);
var tag = new List <Tag>();
tag.Add(new Tag()
{
Description = "test", DateCreated = DateTime.Now
});
var jobOffer = new JobOfferDto()
{
AcademicRequirements = "Test",
CareerState = "Test",
ContactEmail = "*****@*****.**",
DateCareerFinish = DateTime.Now,
Department = new DepartmentDto()
{
Address = new AddressDto()
{
StreetName = "test", StreetNumber = "test", LocalityId = 1, ZipCode = "1512", Department = "asdasd", Additionals = null
}
},
Description = "Test",
DurationOffer = DateTime.Now,
Experience = false,
ExperimentalModel = "Test",
//JobType = 1,
PresentationLetter = false,
ProjectManager = "Test",
ResearchTopics = "Test",
Salary = (decimal)1.0,
//Tags = tag,
Title = "Test"
};
var result = await controller.Post(jobOffer);
var okResult = result as OkObjectResult;
Assert.NotNull(okResult);
Assert.Equal(200, okResult.StatusCode);
}
/// <summary>
/// Updates jobOffer
/// </summary>
/// <param name="jobOfferDto">JobOffer details</param>
public async Task <bool> EditJobOfferAsync(JobOfferDto jobOfferDto)
{
using (var uow = UnitOfWorkProvider.Create())
{
if (await jobOfferService.GetAsync(jobOfferDto.Id, false) == null)
{
return(false);
}
await jobOfferService.Update(jobOfferDto);
await uow.Commit();
return(true);
}
}
public async Task <IActionResult> AddJobOffer()
{
var user = await userFacade.GetByIdAsync(int.Parse(User.Identity.Name));
var model = new JobOfferDto
{
CompanyId = user.CompanyId.Value,
RelevantSkills = new List <string> {
""
},
Questions = new List <JobOfferQuestionDto> {
new JobOfferQuestionDto {
Text = ""
}
}
};
return(View(model));
}
public async Task <IActionResult> DeleteJobOffer(int?id)
{
if (id == null)
{
return(BadRequest());
}
JobOfferDto offer = await jobOfferFacade.GetByIdAsync(id.Value);
if (offer == null)
{
return(NotFound());
}
var user = await userFacade.GetByIdAsync(int.Parse(User.Identity.Name));
if (user.CompanyId != offer.CompanyId)
{
return(Forbid());
}
return(View(offer));
}
public async Task <IActionResult> Put(int id, [FromBody] JobOfferDto body)
{
if (body == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var jobOffer = await _unitOfWork.Repository <JobOffer>().GetByIdAsync(id);
if (jobOffer == null)
{
return(NotFound());
}
_mapper.Map(body, jobOffer);
_unitOfWork.Repository <JobOffer>().Update(jobOffer);
return(Ok(jobOffer));
}
public async Task DeleteAsync(JobOfferDto jobOfferDto)
{
await jobOfferService.DeleteAsync(jobOfferDto.Id ?? throw new NullReferenceException("JobOfferDto.Id can't be null!"));
await unitOfWork.SaveChangesAsync();
}
public async Task UpdateAsync(JobOfferDto jobOffer)
{
await jobOfferService.UpdateAsync(mapper.Map <JobOfferDto, JobOffer>(jobOffer));
await unitOfWork.SaveChangesAsync();
}
public async Task <IEnumerable <JobOfferDto> > GetByCompanyNameAsync(JobOfferDto jobOfferDto, bool ascendingOrder = true)
{
return(mapper.Map <IEnumerable <JobOffer>, IEnumerable <JobOfferDto> >(await jobOfferService.GetByCompanyNameAsync(jobOfferDto.Company?.Name, ascendingOrder)));
}
