public ActionResult <CandidateDTO> Post([FromBody] CandidateDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(mapper.Map <CandidateDTO>(service.Save(mapper.Map <Candidate>(value)))));
}
public CandidateDTO FindOne(long id)
{
CandidateDTO dto = new CandidateDTO();
CandidateEntity entity = _humanManagerContext.Candidates.Find(id);
dto = _mapper.Map <CandidateDTO>(entity);
return(dto);
}
private static void CreateNewVacanciesProgress(Candidate destination, CandidateDTO source, IRepository <Vacancy> vacancyRepo)
{
source.VacanciesProgress.Where(x => x.IsNew()).ToList().ForEach(newVacancyStageInfo =>
{
var toDomain = new VacancyStageInfo();
toDomain.Update(vacancyRepo.GetByID(newVacancyStageInfo.VacancyId.Value), newVacancyStageInfo);
destination.VacanciesProgress.Add(toDomain);
});
}
public Response <CandidateDTO> Post([FromBody] VCI.DTO.Request.Candidate candidate)
{
Response <CandidateDTO> Result = new Response <CandidateDTO>();
CandidateDTO CandidateCreated;
BlobStorageBLL BlobStorage = new BlobStorageBLL();
Uri profileFoto;
ProfessionalTitleDTO ProfessionalTitle;
try
{
CandidateCreated = new CandidateDTO(candidate);
//Aqui se guarda la foto de perfil y los archivos de los titulos profesionales
candidate.ProfileFoto.Name = string.Format("{0}_profilefoto", candidate.Identification);
profileFoto = BlobStorage.SaveFile(candidate.Identification, candidate.ProfileFoto);
if (profileFoto == null)
{
Result.Error = Error.Random;
return(Result);
}
CandidateCreated.ProfileFoto = profileFoto;
int cont = 0;
if (candidate.ProfessinalTitles != null)
{
foreach (var aux in candidate.ProfessinalTitles)
{
if (string.IsNullOrEmpty(aux.Base64) || string.IsNullOrEmpty(aux.Format))
{
Result.Error = Error.AllProfessionalTitlesRequiredFile;
return(Result);
}
ProfessionalTitle = new ProfessionalTitleDTO();
ProfessionalTitle.Name = aux.Title;
aux.Name = string.Format("ProfessionalTitle_{0}", cont);
ProfessionalTitle.URL = BlobStorage.SaveFile(candidate.Identification, aux);
if (ProfessionalTitle.URL == null)
{
Result.Error = Error.InternalError;
return(Result);
}
CandidateCreated.ProfessionalTitles.Add(ProfessionalTitle);
cont++;
}
}
//Se guarda el candidato en la base de datos
CandidateCreated = CandidateBLL.Instance.Create(CandidateCreated);
Result.Result = CandidateCreated;
Result.Success = true;
}catch
{
Result.Error = Error.InternalError;
}
return(Result);
}
private static void CreateNewLanguageSkills(Candidate destination, CandidateDTO source)
{
source.LanguageSkills.Where(x => x.IsNew()).ToList().ForEach(newLanguageSkill =>
{
var toDomain = new LanguageSkill();
toDomain.Update(newLanguageSkill);
destination.LanguageSkills.Add(toDomain);
});
}
public CandidateDTO Add(CandidateDTO candidateToAdd)
{
Candidate _candidate = new Candidate();
_candidate.Update(candidateToAdd, uow);
uow.CandidateRepo.Insert(_candidate);
uow.Commit();
return(DTOService.ToDTO <Candidate, CandidateDTO>(_candidate));
}
public CandidateDTO Update(CandidateDTO entity)
{
Candidate _candidate = uow.CandidateRepo.GetByID(entity.Id);
_candidate.Update(entity, uow);
uow.CandidateRepo.Update(_candidate);
uow.Commit();
return(DTOService.ToDTO <Candidate, CandidateDTO>(_candidate));
}
private static void CreateNewSocials(Candidate destination, CandidateDTO source)
{
source.SocialNetworks.Where(x => x.IsNew()).ToList().ForEach(newSocial =>
{
var toDomain = new CandidateSocial();
toDomain.Update(newSocial);
destination.SocialNetworks.Add(toDomain);
});
}
private static void CreateNewEvents(Candidate destination, CandidateDTO source)
{
source.Events.Where(x => x.IsNew()).ToList().ForEach(newEvent =>
{
var toDomain = new Event();
toDomain.Update(newEvent);
destination.Events.Add(toDomain);
});
}
private static void CreateNewPhoneNumbers(Candidate destination, CandidateDTO source)
{
source.PhoneNumbers.Where(x => x.IsNew()).ToList().ForEach(newPhoneNumber =>
{
var toDomain = new PhoneNumber();
toDomain.Update(newPhoneNumber);
destination.PhoneNumbers.Add(toDomain);
});
}
public ActionResult <CandidateDTO> Post([FromBody] CandidateDTO value)
{
var candidate = _mapper.Map <Candidate>(value);
_service.Save(candidate);
var candidateDTO = _mapper.Map <CandidateDTO>(candidate);
return(Ok(candidateDTO));
}
public IHttpActionResult Post([FromBody] CandidateDTO newCandidate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var addedCandidate = service.Add(newCandidate);
return(Json(addedCandidate, BOT_SERIALIZER_SETTINGS));
}
public ActionResult<Api<CandidateDTO>> GetOne(long id)
{
CandidateDTO dto = _candidateService.FindOne(id);
Api<CandidateDTO> result = new Api<CandidateDTO>(200, dto, "Success", null);
return Ok(result);
}
public async Task <Boolean> Update(CandidateDTO candidato)
{
var JScandidato = JsonConvert.SerializeObject(candidato);
HttpContent content = new StringContent(JScandidato);
content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
var response = Client.PutAsync("Candidate", content).Result;
return(response.IsSuccessStatusCode);
}
public IHttpActionResult Put(int id, [FromBody] CandidateDTO changedCandidate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var updatedCandidate = service.Update(changedCandidate);
return(Json(updatedCandidate, BOT_SERIALIZER_SETTINGS));
}
public bool RegisterCandidate(CandidateDTO candidateDTO)
{
int result = _engine.ExecNonQueryProc("InsertCandidateSP",
new object[]
{
"voterId", candidateDTO.VoterId,
"positionId", candidateDTO.PositionId
});
return((result > 0) ? true : false);
}
/// <summary>
/// Thêm mới
/// </summary>
/// <param name="DTO"></param>
/// <returns></returns>
public bool Insert(CandidateDTO DTO)
{
try
{
return(dao.Insert(convertData.ConvertToEF(DTO)));
}
catch (Exception)
{
return(false);
}
}
public IHttpActionResult SaveCandidate(CandidateDTO candidateDto)
{
var candidate = _mapper.ConvertCandidateDtoToDbModel(candidateDto);
var success = Task.Run(() => _canidateService.SaveCandidate(candidate)).Result;
if (success)
{
return(Ok());
}
return(BadRequest());
}
public CandidateDTO GetById(int id)
{
var candidate = _candidateRepository.GetById(id);
var candidateDto = new CandidateDTO();
candidateDto.Id = candidate.Id;
candidateDto.Name = candidate.Name;
candidateDto.Image = candidate.Image;
return(candidateDto);
}
public async void CreateAsync(CandidateDTO candidateDTO)
{
if (await _context.Database.EnsureCreatedAsync())
{
await _context.Database.EnsureCreatedAsync();
var candidate = Mapper.Map <CandidateDTO, Candidate>(candidateDTO);
await _context.Candidates.AddAsync(candidate);
await _context.SaveChangesAsync();
}
}
public void Update(CandidateDTO candidate)
{
Candidate candidateDB = _mapper.Map <Candidate>(candidate);
_unitOfWork.CandidateRepository.Update(candidateDB);
_candidateKnowledgeService.Update(candidateDB.Id, candidateDB.Knowledges);
_candidateBestTimeService.Update(candidateDB.Id, candidateDB.BestTimes);
_candidateWorkingTimeService.Update(candidateDB.Id, candidateDB.WorkingTimes);
_unitOfWork.Commit();
}
public async Task CandidatePutApiTestAsync()
{
var result = await _httpClient.GetStringAsync("/candidate/" + candidateId);
CandidateDTO candidate = JsonConvert.DeserializeObject <CandidateDTO>(result);
var content = new StringContent(JsonConvert.SerializeObject(candidate), Encoding.UTF8, "application/json");
var resultPost = await _httpClient.PutAsync("/candidate", content);
Assert.AreEqual(resultPost.StatusCode, HttpStatusCode.OK);
}
public ActionResult <CandidateDTO> Post([FromBody] CandidateDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var candidate = _mapper.Map <Candidate>(value);
var retorno = _candidateService.Save(candidate);
return(Ok(_mapper.Map <CandidateDTO>(retorno)));
}
public IHttpActionResult Insert(CandidateDTO candidato)
{
try
{
_service.Insert(candidato);
return(Ok());
}
catch (Exception e)
{
return(BadRequest("Error al recuperar los datos"));
}
}
public ActionResult <CandidateDTO> Post([FromBody] CandidateDTO value)
{
if (value != default)
{
var obj = mapper.Map <Candidate>(value);
obj = service.Save(obj);
var listDTO = mapper.Map <CandidateDTO>(obj);
return(Ok(listDTO));
}
return(NoContent());
}
public async Task <CandidateDTO> GetCandidateDTO(int id)
{
using (var httpClient = new HttpClient(_clientHandler))
{
using (var response = await httpClient.GetAsync("https://localhost:44304/api/CandidateDTO/" + id))
{
string apiResponse = await response.Content.ReadAsStringAsync();
_oCandidate = JsonConvert.DeserializeObject <CandidateDTO>(apiResponse);
}
}
return(_oCandidate);
}
public ActionResult <CandidateDTO> Get(int userId, int accelerationId, int companyId)
{
Candidate candidate = _candidateService.FindById(userId, accelerationId, companyId);
CandidateDTO candidateDto = null;
if (candidate != null)
{
candidateDto = _mapper.Map <CandidateDTO>(candidate);
}
return(candidateDto);
}
public static void Update(this Candidate destination, CandidateDTO source, IUnitOfWork uow)
{
destination.State = source.State;
destination.FirstName = source.FirstName;
destination.MiddleName = source.MiddleName;
destination.LastName = source.LastName;
destination.IsMale = source.IsMale;
destination.BirthDate = source.BirthDate;
destination.Email = source.Email;
destination.Skype = source.Skype;
destination.PositionDesired = source.PositionDesired;
destination.SalaryDesired = source.SalaryDesired;
destination.TypeOfEmployment = source.TypeOfEmployment;
destination.StartExperience = source.StartExperience;
destination.Practice = source.Practice;
destination.Description = source.Description;
destination.CityId = source.CityId;
destination.RelocationAgreement = source.RelocationAgreement;
destination.Education = source.Education;
destination.IndustryId = source.IndustryId;
destination.MainSourceId = source.MainSourceId;
destination.LevelId = source.LevelId;
destination.CurrencyId = source.CurrencyId;
destination.ClosedVacancies.Clear();
destination.ClosedVacancies = source.ClosedVacanciesIds.Select(x => uow.VacancyRepo.GetByID(x)).ToList();
PerformRelocationPlacesSaving(destination, source, uow.CityRepo);
PerformSocialSaving(destination, source, uow.CandidateSocialRepo);
PerformLanguageSkillsSaving(destination, source, uow.LanguageSkillRepo);
PerformSourcesSaving(destination, source, uow.CandidateSourceRepo);
PerformVacanciesProgressSaving(destination, source, uow.VacancyStageInfoRepo, uow.VacancyRepo);
destination.VacanciesProgress.ToList().ForEach((vsi) =>
{
if (uow.StageRepo.GetByID(vsi.StageId).StageType == Domain.Entities.Enum.StageType.HireStage)
{
var linkedVacancy = uow.VacancyRepo.GetByID(vsi.VacancyId);
linkedVacancy.ClosingCandidateId = vsi.CandidateId;
uow.VacancyRepo.Update(linkedVacancy);
}
});
PerformTagsSaving(destination, source, uow.TagRepo);
PerformPhoneNumbersSaving(destination, source, uow.PhoneNumberRepo);
PerformSkillsSaving(destination, source, uow.SkillRepo);
PerformPhotoSaving(destination, source, uow.FileRepo);
PerformFilesSaving(destination, source, uow.FileRepo);
PerformCommentsSaving(destination, source, uow.CommentRepo);
PerformEventsSaving(destination, source, uow.EventRepo);
}
public ActionResult <CandidateDTO> Post([FromBody] CandidateDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
Candidate candidate = _mapper.Map <Candidate>(value);
_candidateService.Save(candidate);
CandidateDTO candidateDTO = _mapper.Map <CandidateDTO>(candidate);
return(Ok(candidateDTO));
}
}
public ActionResult <CandidateDTO> Put([FromBody] CandidateDTO value)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var acceleration = _mapper.Map <Acceleration>(value);
var retorno = _accelerationService.Save(acceleration);
return(Ok(_mapper.Map <AccelerationDTO>(retorno)));
}
