public ActionResult Create(ResumeViewModel viewModel)
{
try
{
if (!ModelState.IsValid)
{
return(View(viewModel));
}
var resume = new ResumeDTO
{
ResumeName = viewModel.ResumeName,
ResumeDescript = viewModel.ResumeDescript,
EmployeeId = viewModel.EmployeeId,
CategoryId = viewModel.CategoryId
};
resumeService.AddResume(resume);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
return(View(viewModel));
}
public void EditResume(ResumeDTO resumeDTO)
{
if (resumeDTO == null)
{
throw new ArgumentNullException(nameof(resumeDTO));
}
Resume resume = Database.Resumes.Get(resumeDTO.Id);
if (resume == null)
{
throw new ArgumentOutOfRangeException("Not found resume");
}
if (Database.Headings.Get(resumeDTO.HeadingId) == null)
{
throw new ArgumentOutOfRangeException("Invalid argument rubricId");
}
resume.Title = resumeDTO.Title;
resume.Name = resumeDTO.Name;
resume.Birthday = resumeDTO.Birthday;
resume.Phone = resumeDTO.Phone;
resume.Email = resumeDTO.Email;
resume.Portfolio = resumeDTO.Portfolio;
resume.Payment = resumeDTO.Payment;
resume.Skills = resumeDTO.Skills;
//resume.UserId = resumeDTO.UserId;
Database.Resumes.Update(resume);
Database.Save();
}
private static Resume DTOToResume(ResumeDTO resumeDTO) =>
new Resume
{
ResumeId = resumeDTO.ResumeId,
Name = resumeDTO.Name,
CandidateId = resumeDTO.CandidateId
};
public async Task <ActionResult <ResumeDTO> > PatchResume(long id, ResumeDTO resumeDTO)
{
User user = await userManager.FindByNameAsync(User.Identity.Name);
if (resumeDTO == null)
{
return(BadRequest());
}
if (id != resumeDTO.ResumeId)
{
return(BadRequest());
}
if (!ResumeExists(id))
{
return(NotFound());
}
// Check to ensure you're not editing resumes for other people unless admin
if (!(await userManager.IsInRoleAsync(user, UserRoles.Admin)))
{
Resume resume = await _context.Resumes.FindAsync(id);
if (resume.CandidateId != user.Id)
{
return(Unauthorized("Cannot change the candidate of a resume"));
}
}
_context.Resumes.Update(DTOToResume(resumeDTO));
await _context.SaveChangesAsync();
return(Ok(resumeDTO));
}
public static ResumeDTO parseResume(Resume input)
{
ResumeDTO resume = new ResumeDTO()
{
AboutMe = input.AboutMe,
Address = input.Address,
Brief = input.Brief,
Email = input.Email,
Flags = input.Flags,
Interests = input.Interests,
Name = input.Name,
Surname = input.Surname,
Title = input.Title,
Visas = input.Visas,
Educations = input.ResumeEducations.Select(e => e.Education).ToList(),
Jobs = input.ResumeJobs.Select(j => j.Job).ToList(),
Skills = input.ResumeSkills.Select(sk => sk.Skill).ToList(),
Socials = input.ResumeSocials.Select(so => so.Social).ToList(),
SpokenLanguages = input.ResumeSpokenLanguages.Select(sp => sp.SpokenLanguages).ToList(),
Experiences = parseExperiences(input.ResumeJobs.Select(j => j.Job)),
DateCreated = input.DateCreated,
Comments = input.Comments
};
return(resume);
}
public ActionResult Delete(int id)
{
ResumeDTO resume = resumeService.GetResume(id);
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ResumeDTO, ResumeViewModel>()).CreateMapper();
var resumeView = mapper.Map <ResumeDTO, ResumeViewModel>(resume);
return(View(resumeView));
}
public void UpdateResume(int id, ResumeDTO resumeDto)
{
var resumeForUpdate = GetResumeByID(id);
if (resumeForUpdate != null)
{
_unitOfWork.Resumes.Update(_resumeUpdateMapper.Map <ResumeDTO, Resume>(resumeDto));
}
}
public void EditResume_NullElement_ShouldThrowException()
{
//arrange
var Resume = new ResumeDTO {
Id = It.IsAny <int>()
};
//act & assert
NUnit.Framework.Assert.Throws <ArgumentOutOfRangeException>(() => resumeService.EditResume(Resume));
}
public ActionResult Edit(int id)
{
ResumeDTO resume = resumeService.GetResume(id);
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ResumeDTO, ResumeViewModel>()).CreateMapper();
var resumeView = mapper.Map <ResumeViewModel>(resume);
ViewBag.CategoryId = new SelectList(categoryService.GetCategories(), "CategoryId", "CategoryName", resumeView.CategoryId);
ViewBag.EmployeeId = new SelectList(employeeService.GetEmployees(), "EmployeeId", "EmployeeLastName", resumeView.EmployeeId);
return(View(resumeView));
}
public void CreateResume_TryToCreateResume_ShouldRepositoryCreateOnce()
{
var Resume = new ResumeDTO {
Id = It.IsAny <int>()
};
// act
resumeService.CreateResume(Resume);
//assert
resumeRepository.Verify(x => x.Create(It.IsAny <Resume>()));
}
public IActionResult Get(int id)
{
var resume = _resumeService.Get(id);
if (resume == null)
{
return(NotFound());
}
var resumeDTO = new ResumeDTO(resume);
return(Ok(resumeDTO));
}
public void AddResume(ResumeDTO resumeDto)
{
_unitOfWork.Resumes.Create(new Resume
{
Info = resumeDto.Info,
Position = resumeDto.Position,
PreferablySalary = resumeDto.PreferablySalary,
ResumeTitile = resumeDto.ResumeTitile,
Vacancies = new List <Vacansy>()
});
_unitOfWork.Save();
}
public void EditResume_EditResume_ShoudRepositoryEditOnce()
{//
//arrange
var resume = new ResumeDTO {
Id = It.IsAny <int>(), City = It.IsAny <string>()
};
resumeRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new Resume {
Id = It.IsAny <int>(), City = It.IsAny <string>()
});
//act & assert
NUnit.Framework.Assert.Throws <ArgumentOutOfRangeException>(() => resumeService.EditResume(resume));
}
public void CreateResume_TryToCreateResume_ShouldRepositoryCreateOnce()
{
var Resume = new ResumeDTO {
Id = It.IsAny <int>()
};
uow.Setup(x => x.Rubrics.Get(It.IsAny <int>())).Returns(new Rubric()
{
});
// act
resumeService.CreateResume(Resume);
//assert
resumeRepository.Verify(x => x.Create(It.IsAny <Resume>()));
}
public void RemoveResume(ResumeDTO resumeDTO)
{
if (resumeDTO == null)
{
throw new ArgumentNullException(nameof(resumeDTO));
}
if (Database.Resumes.Get(resumeDTO.Id) == null)
{
throw new ArgumentOutOfRangeException("Not found resume");
}
Database.Resumes.Delete(resumeDTO.Id);
Database.Save();
}
public IActionResult Post([FromBody] Resume resume)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var createdResume = _resumeService.Create(resume);
if (createdResume == null)
{
return(BadRequest());
}
var createdResumeDTO = new ResumeDTO(createdResume);
return(Ok(createdResumeDTO));
}
public IActionResult Put([FromBody] Resume resume)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var updatedResume = _resumeService.Update(resume);
if (updatedResume == null)
{
return(NotFound());
}
var updatedResumeDTO = new ResumeDTO(updatedResume);
return(Ok(updatedResumeDTO));
}
public void RemoveResume_DeleteNullValue()
{
var resume = new ResumeDTO {
Id = It.IsAny <int>(), Name = It.IsAny <string>()
};
resumeRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new Resume {
Id = It.IsAny <int>(), Name = It.IsAny <string>()
});
//act
resumeService.RemoveResume(resume);
//assert
resumeRepository.Verify(x => x.Delete(It.IsAny <int>()));
}
public void EditResume_EditResume_ShoudRepositoryEditOnce()
{//
//arrange
var resume = new ResumeDTO {
Id = It.IsAny <int>(), City = It.IsAny <string>()
};
resumeRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new Resume {
Id = It.IsAny <int>(), City = It.IsAny <string>()
});
resumeRepository.Setup(x => x.Get(It.IsAny <int>())).Returns(new Resume());
uow.Setup(x => x.Rubrics.Get(It.IsAny <int>())).Returns(new Rubric());
// act
resumeService.EditResume(resume);
//assert
resumeRepository.Verify(x => x.Update(It.IsAny <Resume>()));
}
public void UpdateResume(ResumeDTO resumeDTO)
{
Resume resume = Database.Resumes.Get(resumeDTO.ResumeId);
if (resume == null)
{
throw new ValidationException("Резюме не найдено", "");
}
resume.ResumeName = resumeDTO.ResumeName;
resume.ResumeDescript = resumeDTO.ResumeDescript;
resume.EmployeeId = resumeDTO.EmployeeId;
resume.Date = DateTime.Now;
resume.CategoryId = resumeDTO.CategoryId;
// resume.Employee.EmployeeId = resumeDTO.Employee.EmployeeId;
Database.Resumes.Update(resume);
Database.Save();
}
public void CreateResume(ResumeDTO resumeDTO)
{
if (resumeDTO == null)
{
throw new ArgumentNullException(nameof(resumeDTO));
}
if (resumeDTO.Id != 0 && Database.Resumes.Get(resumeDTO.Id) != null)
{
throw new ArgumentOutOfRangeException("Found duplicate id resume");
}
if (Database.Rubrics.Get(resumeDTO.RubricId) == null)
{
throw new ArgumentOutOfRangeException("Invalid argument rubricId");
}
Database.Resumes.Create(Mapper.Map <ResumeDTO, Resume>(resumeDTO));
Database.Save();
}
public void AddResume(ResumeDTO resumeDTO)
{
Employee employee = Database.Employees.Get(resumeDTO.EmployeeId);
if (employee == null)
{
throw new ValidationException("Чуловек не найден", "");
}
Resume resume = new Resume
{
Date = DateTime.UtcNow,
ResumeName = resumeDTO.ResumeName,
EmployeeId = employee.EmployeeId,
ResumeDescript = resumeDTO.ResumeDescript,
CategoryId = resumeDTO.CategoryId
};
Database.Resumes.Create(resume);
Database.Save();
}
public IHttpActionResult Add(ResumeViewModel resumeView)
{
ResumeDTO resumeDTO = Mapper.Map <ResumeViewModel, ResumeDTO>(resumeView);
resumeDTO.User = userService.GetUsers().Where(x => x.UserName == User.Identity.Name).FirstOrDefault();
try
{
resumeService.CreateResume(resumeDTO);
return(Ok("Resume is created"));
}
catch (ArgumentNullException)
{
return(BadRequest("Not correct input data"));
}
catch (ArgumentOutOfRangeException ex)
{
return(BadRequest(ex.ParamName));
}
}
public void EditResume(ResumeDTO resumeDTO)
{
if (resumeDTO == null)
{
throw new ArgumentNullException(nameof(resumeDTO));
}
Resume resume = Database.Resumes.Get(resumeDTO.Id);
if (resume == null)
{
throw new ArgumentOutOfRangeException("Not found resume");
}
if (Database.Rubrics.Get(resumeDTO.RubricId) == null)
{
throw new ArgumentOutOfRangeException("Invalid argument rubricId");
}
resume.Title = resumeDTO.Title;
resume.Surname = resumeDTO.Surname;
resume.Name = resumeDTO.Name;
resume.MiddleName = resumeDTO.MiddleName;
resume.Birthday = resumeDTO.Birthday;
resume.Gender = resumeDTO.Gender;
resume.City = resumeDTO.City;
resume.Phone = resumeDTO.Phone;
resume.Email = resumeDTO.Email;
resume.Skype = resumeDTO.Skype;
resume.RubricId = resumeDTO.RubricId;
resume.Portfolio = resumeDTO.Portfolio;
resume.DesiredPosition = resumeDTO.DesiredPosition;
resume.Payment = resumeDTO.Payment;
resume.Skills = resumeDTO.Skills;
//resume.UserId = resumeDTO.UserId;
Database.Resumes.Update(resume);
Database.Save();
}
private List <ResumeDTO> ConvertResumeList(List <Resume> resumeList)
{
var convertedResumeList = new List <ResumeDTO>();
resumeList.ForEach(resume =>
{
var convertedResume = new ResumeDTO
{
contact_info = new ContactInfoDTO {
name = new Models.Name
{
formatted_name = resume.contact_info.name.formatted_name
}
},
};
ExperienceDTO previewsExperience = null;
convertedResume.experience = new List <ExperienceDTO>();
resume.experience.ForEach(experience =>
{
var experienceDto = new ExperienceDTO();
experienceDto.title = experience.title;
experienceDto.start_date = experience.start_date;
experienceDto.end_date = experience.end_date;
if (previewsExperience != null)
{
previewsExperience.GapDaysBetweenJobs = (int)(experience.start_date - previewsExperience.end_date).TotalDays;
}
previewsExperience = experienceDto;
convertedResume.experience.Add(experienceDto);
});
convertedResumeList.Add(convertedResume);
});
return(convertedResumeList);
}
public async Task <ActionResult <ResumeDTO> > PostResume(ResumeDTO resumeDTO)
{
User user = await userManager.FindByNameAsync(User.Identity.Name);
if (resumeDTO == null)
{
return(BadRequest());
}
// Assign resume to logged in user
Resume resume = DTOToResume(resumeDTO);
if ((resume.CandidateId != user.Id) && !(await userManager.IsInRoleAsync(user, UserRoles.Admin)))
{
return(Unauthorized("Cannot create a resume for another candidate"));
}
resume.CandidateId = user.Id;
_context.Resumes.Add(resume);
await _context.SaveChangesAsync();
return(CreatedAtAction("PostResume", resumeDTO));
}
// PUT: api/Resume/5
public void Put(int id, [FromBody] ResumeDTO resumeDTO)
{
_resumeService.UpdateResume(id, resumeDTO);
}
// POST: api/Resume
public void Post([FromBody] ResumeDTO resumeDTO)
{
_resumeService.AddResume(resumeDTO);
}
public static void WriteHardResume(string dateFolder, Resume resume)
{
ResumeFiles files = new ResumeFiles(dateFolder);
string ymlPath = files.HardResume;
// write to json
string jsonDCircle = JsonConvert.SerializeObject(
resume,
new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
Formatting = Formatting.Indented,
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
}
);
string jsonPath = ymlPath.Replace("yml", "json");
Resume resumeDCircle = JsonConvert.DeserializeObject <Resume>(jsonDCircle);
ResumeDTO parsed = parseResume(resumeDCircle);
string json = JsonConvert.SerializeObject(
parsed,
new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
Formatting = Formatting.Indented,
ContractResolver = new DefaultContractResolver
{
NamingStrategy = new CamelCaseNamingStrategy()
}
}
);
using (StreamWriter w = new StreamWriter(jsonPath))
{
w.Write(json);
Console.WriteLine("##############################");
Console.WriteLine($"JSON wrote at {jsonPath}");
}
//write to yml
var serializer = new YamlDotNet.Serialization.SerializerBuilder()
.DisableAliases()
.Build();
string yaml;
using (StringWriter w = new StringWriter())
{
serializer.Serialize(w, parsed);
yaml = w.ToString();
}
using (StreamWriter w2 = new StreamWriter(ymlPath))
{
w2.Write(yaml);
Console.WriteLine("##############################");
Console.WriteLine($"YML wrote at {ymlPath}");
}
// write to javascript
string javascript = "exports.hardResume = " + json;
string jsPath = files.JavaScriptPath;
Console.WriteLine(jsPath);
using (StreamWriter w3 = new StreamWriter(jsPath))
{
w3.Write(javascript);
Console.WriteLine("##############################");
Console.WriteLine($"JS wrote at {jsPath}");
}
}
