public async Task Sandbox_Special_Case_Guids(
string guid,
bool isSandbox,
HttpStatusCode expectedStatusCode,
CreateVacancyCommandResponse mediatorResponse,
CreateVacancyRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] VacancyController controller)
{
var id = Guid.Parse(guid);
var accountId = "ABC123";
var accountIdentifier = $"Employer-{accountId}-Product";
mockMediator.Setup(x =>
x.Send(It.Is <CreateVacancyCommand>(c =>
c.Id.Equals(id) &&
c.PostVacancyRequestData.Title.Equals(request.Title) &&
c.PostVacancyRequestData.EmployerAccountId.Equals(accountId.ToUpper()) &&
c.IsSandbox.Equals(isSandbox)
), CancellationToken.None))
.ReturnsAsync(mediatorResponse);
var controllerResult = await controller.CreateVacancy(accountIdentifier, id, request, isSandbox) as IStatusCodeActionResult;
controllerResult.StatusCode.Should().Be((int)expectedStatusCode);
}
public async Task Then_The_Request_Is_Handled_And_Response_Returned_And_Type_Set_For_Provider(
int ukprn,
Guid id,
CreateVacancyCommandResponse mediatorResponse,
CreateVacancyRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] VacancyController controller)
{
var accountIdentifier = $"Provider-{ukprn}-product";
mockMediator.Setup(x =>
x.Send(It.Is <CreateVacancyCommand>(c =>
c.Id.Equals(id) &&
c.AccountIdentifier.AccountType == AccountType.Provider &&
c.AccountIdentifier.Ukprn == ukprn &&
c.AccountIdentifier.AccountHashedId == null &&
c.PostVacancyRequestData.Title.Equals(request.Title) &&
c.PostVacancyRequestData.User.Ukprn.Equals(ukprn) &&
c.PostVacancyRequestData.OwnerType.Equals(OwnerType.Provider) &&
c.PostVacancyRequestData.ProviderContact.Name.Equals(request.SubmitterContactDetails.Name) &&
c.PostVacancyRequestData.ProviderContact.Phone.Equals(request.SubmitterContactDetails.Phone) &&
c.PostVacancyRequestData.ProviderContact.Email.Equals(request.SubmitterContactDetails.Email) &&
c.IsSandbox.Equals(false)
), CancellationToken.None))
.ReturnsAsync(mediatorResponse);
var controllerResult = await controller.CreateVacancy(accountIdentifier, id, request) as CreatedResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Created);
controllerResult.Value.Should().BeEquivalentTo(new { mediatorResponse.VacancyReference });
}
public async Task <IActionResult> Update(int id, [FromBody] CreateVacancyRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vacancy = new Vacancy
{
Id = id,
Title = request.Title,
Description = request.Description,
CompanyName = request.CompanyName,
SalaryValue = request.SalaryValue,
SalaryCurrency = request.SalaryCurrency,
TypeId = request.TypeId,
};
_appDbContext.Attach(vacancy);
_appDbContext.Entry(vacancy).Property(p => p.Title).IsModified = true;
_appDbContext.Entry(vacancy).Property(p => p.Description).IsModified = true;
_appDbContext.Entry(vacancy).Property(p => p.CompanyName).IsModified = true;
_appDbContext.Entry(vacancy).Property(p => p.SalaryValue).IsModified = true;
_appDbContext.Entry(vacancy).Property(p => p.SalaryCurrency).IsModified = true;
_appDbContext.Entry(vacancy).Property(p => p.TypeId).IsModified = true;
await _appDbContext.SaveChangesAsync();
return(Ok(vacancy.Id));
}
public async Task ValidateVacancy_Then_The_Request_Is_Sent_To_Mediator_Command(
Guid id,
long vacancyRef,
string userEmail,
long ukprn,
CreateVacancyRequest request,
CreateVacancyCommandResponse response,
[Frozen] Mock <IMediator> mediator,
[Greedy] VacanciesController controller)
{
response.ResultCode = ResponseCode.Created;
response.Data = vacancyRef;
mediator.Setup(x => x.Send(It.Is <CreateVacancyCommand>(c =>
c.Vacancy.Title.Equals(request.Title) &&
c.Vacancy.Id.Equals(id) &&
c.VacancyUserDetails.Email.Equals(userEmail) &&
c.VacancyUserDetails.Ukprn.Equals(ukprn) &&
c.ValidateOnly
), CancellationToken.None))
.ReturnsAsync(response);
var actual = await controller.Validate(id, request, userEmail, ukprn) as CreatedResult;
Assert.NotNull(actual);
actual.StatusCode.Should().Be((int)HttpStatusCode.Created);
var actualResult = actual.Value as long?;
Assert.NotNull(actualResult);
actualResult.Value.Should().Be((long)response.Data);
}
public static Vacancy MapFromCreateVacancyRequest(this CreateVacancyRequest request, Guid id)
{
return(new Vacancy
{
EmployerLocation = new Address
{
AddressLine1 = request.Address.AddressLine1,
AddressLine2 = request.Address.AddressLine2,
AddressLine3 = request.Address.AddressLine3,
AddressLine4 = request.Address.AddressLine4,
Postcode = request.Address.Postcode
},
Id = id,
Description = request.Description,
Title = request.Title,
EmployerName = request.EmployerName,
LegalEntityName = request.LegalEntityName,
ApplicationMethod = (ApplicationMethod?)request.ApplicationMethod,
ApplicationInstructions = request.ApplicationInstructions,
ApplicationUrl = request.ApplicationUrl,
Qualifications = request.Qualifications
.Select(c =>
new Qualification
{
Grade = c.Grade,
Subject = c.Subject,
Weighting = (QualificationWeighting?)c.Weighting,
QualificationType = c.QualificationType
})
.ToList(),
Wage = new Wage
{
WageType = (WageType)request.Wage.WageType,
WorkingWeekDescription = request.Wage.WorkingWeekDescription,
WeeklyHours = request.Wage.WeeklyHours,
Duration = request.Wage.Duration,
DurationUnit = (DurationUnit?)request.Wage.DurationUnit,
WageAdditionalInformation = request.Wage.WageAdditionalInformation,
FixedWageYearlyAmount = request.Wage.FixedWageYearlyAmount
},
ShortDescription = request.ShortDescription,
NumberOfPositions = request.NumberOfPositions,
OutcomeDescription = request.OutcomeDescription,
EmployerAccountId = request.EmployerAccountId,
AccountLegalEntityPublicHashedId = request.AccountLegalEntityPublicHashedId,
ClosingDate = request.ClosingDate,
StartDate = request.StartDate,
ProgrammeId = request.ProgrammeId,
EmployerNameOption = (EmployerNameOption?)request.EmployerNameOption,
AnonymousReason = request.AnonymousReason,
EmployerDescription = request.EmployerDescription,
TrainingDescription = request.TrainingDescription,
Skills = request.Skills,
DisabilityConfident = (DisabilityConfident)request.DisabilityConfident,
ThingsToConsider = request.ThingsToConsider,
CreatedByUser = request.User
});
}
public async Task Then_If_The_Format_Is_Not_Correct_For_The_AccountIdentifier_Then_Forbidden_Returned(
long accountIdentifier,
Guid id,
CreateVacancyRequest request,
[Greedy] VacancyController controller)
{
var controllerResult = await controller.CreateVacancy(accountIdentifier.ToString(), id, request) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.Forbidden);
}
public async Task Then_If_The_Ukprn_Is_Not_Correct_For_The_AccountIdentifier_Then_Forbidden_Returned(
Guid id,
CreateVacancyRequest request,
[Greedy] VacancyController controller)
{
var ukprn = "ABC123";
var accountIdentifier = $"Provider-{ukprn}-product";
var controllerResult = await controller.CreateVacancy(accountIdentifier, id, request) as BadRequestObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.Should().BeEquivalentTo("Account Identifier is not in the correct format.");
}
public void Then_The_Fields_Are_Correctly_Mapped_For_Employer(CreateVacancyRequest source)
{
source.Wage.WageType = WageType.FixedWage;
var actual = (PostVacancyRequestData)source;
actual.Should().BeEquivalentTo(source, options => options
.Excluding(c => c.SubmitterContactDetails)
.Excluding(c => c.ContractingParties)
);
actual.AccountLegalEntityPublicHashedId.Should().Be(source.ContractingParties.AccountLegalEntityPublicHashedId);
actual.User.Ukprn.Should().Be(source.ContractingParties.Ukprn);
actual.User.Email.Should().Be(source.SubmitterContactDetails.Email);
actual.User.Name.Should().Be(source.SubmitterContactDetails.Name);
}
public async Task <IActionResult> Create([FromRoute] Guid id, CreateVacancyRequest request, [FromQuery] string userEmail = null, [FromQuery] long?ukprn = null)
{
var resp = await _mediator.Send(new CreateVacancyCommand
{
Vacancy = request.MapFromCreateVacancyRequest(id),
VacancyUserDetails = new VacancyUser
{
Email = userEmail,
Ukprn = ukprn
}
});
return(GetApiResponse(resp));
}
public void Then_The_Request_Is_Mapped_To_The_Vacancy(CreateVacancyRequest request, Guid id)
{
request.Wage.WageType = WageType.NationalMinimumWageForApprentices;
request.Wage.DurationUnit = DurationUnit.Year;
request.ApplicationMethod = CreateVacancyApplicationMethod.ThroughExternalApplicationSite;
var actual = request.MapFromCreateVacancyRequest(id);
actual.Id.Should().Be(id);
actual.Should().BeEquivalentTo(request, options => options
.Excluding(c => c.User)
.Excluding(c => c.Address)
);
actual.EmployerLocation.Should().BeEquivalentTo(request.Address);
actual.CreatedByUser.Should().BeEquivalentTo(request.User);
}
public async Task Then_If_Exception_Internal_Server_Error_Is_Returned(
Guid id,
string errorContent,
CreateVacancyRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] VacancyController controller)
{
var accountId = "ABC123";
var accountIdentifier = $"Employer-{accountId}-product";
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateVacancyCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new Exception());
var controllerResult = await controller.CreateVacancy(accountIdentifier, id, request) as StatusCodeResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.InternalServerError);
}
public async Task Then_If_ContentException_Bad_Request_Is_Returned_And_Error_Keys_Mapped(
Guid id,
string errorContent,
CreateVacancyRequest request,
[Frozen] Mock <IMediator> mockMediator,
[Greedy] VacancyController controller)
{
var accountId = "ABC123";
var accountIdentifier = $"Employer-{accountId}-product";
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <CreateVacancyCommand>(),
It.IsAny <CancellationToken>()))
.ThrowsAsync(new HttpRequestContentException("Error", HttpStatusCode.BadRequest, @"{""errors"":[{""field"":""ProgrammeId"",""message"":""Training programme a does not exist.""},{""field"":""employerName"",""message"":""Employer name is not in the correct format.""},{""field"":""employerNameOption"",""message"":""Invalid employer name option.""}]}"));
var controllerResult = await controller.CreateVacancy(accountIdentifier, id, request) as ObjectResult;
controllerResult !.StatusCode.Should().Be((int)HttpStatusCode.BadRequest);
controllerResult.Value.Should().Be(@"{""errors"":[{""field"":""standardLarsCode"",""message"":""Training programme a does not exist.""},{""field"":""alternativeEmployerName"",""message"":""Employer name is not in the correct format.""},{""field"":""employerNameOption"",""message"":""Invalid employer name option.""}]}");
}
public async Task <IActionResult> Post([FromBody] CreateVacancyRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var vacancy = new Vacancy
{
Title = request.Title,
Description = request.Description,
CompanyName = request.CompanyName,
SalaryValue = request.SalaryValue,
SalaryCurrency = request.SalaryCurrency,
TypeId = request.TypeId,
OwnerId = UserHelper.GetUserId(HttpContext.User),
CreatedDate = DateTime.UtcNow
};
_appDbContext.Vacancies.Add(vacancy);
await _appDbContext.SaveChangesAsync().ConfigureAwait(true);
return(Ok(vacancy.Id));
}
public void Then_If_The_Wage_Is_Not_Fixed_Then_Value_Set_To_Null(WageType wageType, CreateVacancyRequest source)
{
source.Wage.WageType = wageType;
var actual = (PostVacancyRequestData)source;
actual.Wage.FixedWageYearlyAmount.Should().BeNull();
}
public async Task <IActionResult> CreateVacancy(
[FromHeader(Name = "x-request-context-subscription-name")] string accountIdentifier,
[FromRoute] Guid id,
[FromBody] CreateVacancyRequest request,
[FromHeader(Name = "x-request-context-subscription-is-sandbox")] bool?isSandbox = false)
{
try
{
var account = new AccountIdentifier(accountIdentifier);
if (isSandbox.HasValue && isSandbox.Value)
{
if (id == Guid.Empty)
{
return(new BadRequestObjectResult(new { errors = new[] { "Unable to create Vacancy. Vacancy already submitted" } }));
}
if (id == Guid.Parse("11111111-1111-1111-1111-111111111111"))
{
return(new StatusCodeResult((int)HttpStatusCode.TooManyRequests));
}
}
switch (account.AccountType)
{
case AccountType.Unknown:
return(new StatusCodeResult((int)HttpStatusCode.Forbidden));
case AccountType.Provider when account.Ukprn == null:
return(new BadRequestObjectResult("Account Identifier is not in the correct format."));
}
var postVacancyRequestData = (PostVacancyRequestData)request;
postVacancyRequestData.OwnerType = (OwnerType)account.AccountType;
var contactDetails = new ContactDetails
{
Email = request.SubmitterContactDetails.Email,
Name = request.SubmitterContactDetails.Name,
Phone = request.SubmitterContactDetails.Phone,
};
switch (account.AccountType)
{
case AccountType.Provider:
postVacancyRequestData.User.Ukprn = account.Ukprn.Value;
postVacancyRequestData.ProviderContact = contactDetails;
break;
case AccountType.Employer:
postVacancyRequestData.EmployerAccountId = account.AccountHashedId;
postVacancyRequestData.EmployerContact = contactDetails;
break;
}
var response = await _mediator.Send(new CreateVacancyCommand
{
Id = id,
AccountIdentifier = account,
PostVacancyRequestData = postVacancyRequestData,
IsSandbox = isSandbox ?? false
});
return(new CreatedResult("", new CreateVacancyResponse {
VacancyReference = response.VacancyReference
}));
}
catch (HttpRequestContentException e)
{
var content = e.ErrorContent
.Replace("ProgrammeId", "standardLarsCode", StringComparison.CurrentCultureIgnoreCase)
.Replace(@"EmployerName""", @"alternativeEmployerName""", StringComparison.CurrentCultureIgnoreCase);
return(StatusCode((int)e.StatusCode, content));
}
catch (SecurityException e)
{
return(new StatusCodeResult((int)HttpStatusCode.Forbidden));
}
catch (Exception e)
{
_logger.LogError(e, "Error creating vacancy");
return(new StatusCodeResult((int)HttpStatusCode.InternalServerError));
}
}
