public async Task <IActionResult> UpdateCandidate([FromRoute] Guid organizationId, [FromRoute] Guid candidateId,
[FromBody] CandidateInput model)
{
var candidate =
await _candidateService.UpdateCandidate(_projectManager, candidateId,
model);
return(Ok(candidate));
}
public async Task <IActionResult> CreateExternalCandidate(
[FromRoute] Guid organizationId,
[FromRoute] Guid externalId,
[FromBody] CandidateInput model)
{
var am = await _candidateService.CreateExternalCandidate(_recruiter, externalId, model);
return(Ok(am));
}
public Task <CandidateResult> CreateExternalCandidate(IOrganizationRecruiter re, Guid providerOrganizationId, CandidateInput model)
{
_logger.LogInformation(GetLogMessage("For Email: {email}; with code: {code}"), model.EmailAddress,
model.ReferralCode);
return(CreateCandidate(re, providerOrganizationId, model));
}
private async Task <CandidateResult> CreateCandidate(IOrganizationRecruiter re, Guid providerOrganizationId, CandidateInput input)
{
_logger.LogInformation(GetLogMessage("RE: {0}"), re.OrganizationId);
var retVal = new CandidateResult();
var isExternal = providerOrganizationId != re.OrganizationId;
_logger.LogDebug(GetLogMessage("External Lead: {0}"), isExternal);
var recruiter = await _recruiterRepository.Queryable()
.Include(x => x.Recruiter)
.ThenInclude(x => x.Person)
.Where(x => x.RecruiterId == re.RecruiterId && x.OrganizationId == re.OrganizationId)
.FirstAsync();
var recruiterBonus = recruiter.RecruiterBonus;
var recruitingAgencyBonus = 0m;
var recruitingAgencyStream = 0m;
var recruiterStream = recruiter.RecruiterStream;
_logger.LogDebug(
GetLogMessage(
$@"Recruiter Found: {recruiter.Recruiter.Person.DisplayName}"));
if (isExternal)
{
var recruitingAgreement = await _recruitingAgreements.Queryable()
.Where(x => x.ProviderOrganizationId == providerOrganizationId &&
x.RecruitingOrganizationId == re.OrganizationId)
.FirstOrDefaultAsync();
if (recruitingAgreement == null)
{
retVal.ErrorMessage = "Recruiting agreement doesn't exist between recruiting and provider organization";
return(retVal);
}
if (recruitingAgreement.Status != AgreementStatus.Approved)
{
retVal.ErrorMessage = "Recruiting agreement is not approved";
return(retVal);
}
_logger.LogTrace(
GetLogMessage(
$@"Recruiting Agreement found to be valid"));
recruiterBonus = recruitingAgreement.RecruiterBonus;
recruitingAgencyBonus = recruitingAgreement.RecruitingAgencyBonus;
recruitingAgencyStream = recruitingAgreement.RecruitingAgencyStream;
recruiterStream = recruitingAgreement.RecruiterStream;
}
var candidate = new Candidate
{
Iso2 = input.Iso2,
ProvinceState = input.ProvinceState,
RecruiterStream = recruiterStream,
RecruiterBonus = recruiterBonus,
RecruitingAgencyStream = recruitingAgencyStream,
RecruitingAgencyBonus = recruitingAgencyBonus,
ProviderOrganizationId = providerOrganizationId,
RecruiterOrganizationId = re.OrganizationId,
RecruiterId = re.RecruiterId,
UpdatedById = _userInfo.UserId,
CreatedById = _userInfo.UserId,
ObjectState = ObjectState.Added,
Status = CandidateStatus.New,
StatusTransitions = new List <CandidateStatusTransition>()
{
new CandidateStatusTransition()
{
Status = CandidateStatus.New,
ObjectState = ObjectState.Added
}
}
}.InjectFrom(input) as Candidate;
var candidateResult = Repository.Insert(candidate, true);
_logger.LogDebug(GetLogMessage("{0} records updated in database."), candidateResult);
if (candidateResult > 0)
{
retVal.Succeeded = true;
retVal.CandidateId = candidate.Id;
await Task.Run(() =>
{
RaiseEvent(new CandidateCreatedEvent
{
CandidateId = candidate.Id
});
});
}
return(retVal);
}
public async Task <CandidateResult> UpdateCandidate(IOrganizationProjectManager pm, Guid candidateId, CandidateInput model)
{
var entity = await Repository.Queryable().ForOrganizationProjectManager(pm)
.FirstOrDefaultAsync(n => n.Id == candidateId);
if (entity == null)
{
return(null);
}
entity.InjectFrom(model);
return(await UpdateCandidate(entity));
}
public async Task <CandidateResult> UpdateCandidate(IProviderAgencyOwner ao, Guid candidateId, CandidateInput model)
{
var entity = await Repository.Queryable().ForAgencyOwner(ao)
.FirstOrDefaultAsync(n => n.Id == candidateId);
if (entity == null)
{
return(null);
}
entity.InjectFrom(model);
return(await UpdateCandidate(entity));
}
public async Task <CandidateResult> UpdateCandidate(IOrganizationRecruiter re, Guid candidateId, CandidateInput model)
{
var entity = await Repository.Queryable()
.ForOrganizationRecruiter(re)
.GetById(candidateId).FirstOrDefaultAsync();
if (entity == null)
{
return(null);
}
entity.InjectFrom(model);
return(await UpdateCandidate(entity));
}
/// <summary>
/// To add additional optional information, such as a government id, after the candidate has been created.
/// </summary>
/// <param name="candidateId"></param>
/// <param name="input"></param>
/// <returns></returns>
public static Task <Candidate> UpdateCandidateAsync(string candidateId, CandidateInput input)
{
return(AccurateCrudOperations.UpdateAsync <CandidateInput, Candidate>("candidate/" + candidateId, input));
}
/// <summary>
/// This is used create a new candidate to use in any number of background check orders and searches.
/// The candidate can be created with a minimum set of information, and additional information can be added via API later,
/// or in the INTERACTIVE workflow, the applicant may add the needed personal information directly through a secure web form.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static Task <Candidate> CreateCandidateAsync(CandidateInput input)
{
return(AccurateCrudOperations.CreateAsync <CandidateInput, Candidate>("candidate", input));
}
