public async Task <ApiValidationResult> ResumeJob(string tenantId, string jobId)
{
var jobData = await JobStore.Load(tenantId, jobId);
if (jobData == null)
{
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobId));
}
if (jobData.Status.State == JobState.InProgress)
{
return(ApiValidationResult.Ok());
}
var changeableStates = new[] { JobState.Draining, JobState.Paused };
if (changeableStates.Any(s => s == jobData.Status.State))
{
var updated = await JobStore.UpdateState(tenantId, jobId, jobData.Status.State, JobState.InProgress);
if (updated)
{
await JobNotification.NotifyJobUpdated(jobId);
return(ApiValidationResult.Ok());
}
}
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobState));
}
public IActionResult Publish([FromBody] PublishInput input)
{
Logger.LogDebug($"PublishMessageController - Publish method called with this input: {input}");
if (input == null)
{
return(BadRequest(new ApiValidationError(nameof(input), ErrorKeys.ParameterNull)));
}
if (input.Payload == null)
{
return(BadRequest(new ApiValidationError(nameof(PublishInput.Payload), ErrorKeys.ParameterNull)));
}
if (string.IsNullOrWhiteSpace(input.Category))
{
return(BadRequest(new ApiValidationError(nameof(PublishInput.Category), ErrorKeys.ParameterNull)));
}
if (!input.ValidateTags())
{
return(BadRequest(new ApiValidationError(nameof(PublishInput.Tags), ErrorKeys.ParameterNull)));
}
var result = _publishMessageLogic.ProduceMessage(input);
if (!string.IsNullOrEmpty(result.Error))
{
return(BadRequest(new { Message = result.Error }));
}
return(Ok(ApiValidationResult.Ok()));
}
/// <summary>Validates the specified API request context resolver.</summary>
/// <param name="apiRequestContextResolver">The API request context resolver.</param>
/// <returns></returns>
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver apiRequestContextResolver)
{
var context = apiRequestContextResolver?.GetContext();
var suggestedStatusCode = context.Configuration.ValidationErrorConfiguration.UriBindingErrorStatusCode;
return(Task.FromResult(ApiValidationResult.Single("VALIDATOR-3", suggestedHttpStatusCode: suggestedStatusCode)));
}
private ApiValidationResult ValidateForPurgeJobQueue(string jobId)
{
if (string.IsNullOrWhiteSpace(jobId))
{
return(ApiValidationResult.Failure(nameof(jobId), ErrorKeys.ArgumentCanNotBeEmpty));
}
return(ApiValidationResult.Ok());
}
public IActionResult InsertIncomingMessages([FromBody] object input)
{
if (!_hostingEnvironment.IsDevelopment())
{
return(NotFound());
}
return(Ok(ApiValidationResult.Ok()));
}
protected IHttpActionResult ValidationResult(ApiValidationResult result)
{
if (result.Success)
{
return(Ok());
}
return(new ValidationErrorResult(result, this));
}
public static string ToDebugMessage(this ApiValidationResult result)
{
if (result.Success)
{
return("OK");
}
return($"Failure with {result.Errors.Count} errors: {string.Join("; ", result.Errors.Select(e => e.ToDebugMessage()))}");
}
public async Task <ApiValidationResult> StopJob(string tenantId, string jobId)
{
var jobData = await JobStore.Load(tenantId, jobId);
if (jobData == null)
{
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobId));
}
if (jobData.Status.State == JobState.Stopped)
{
return(ApiValidationResult.Ok());
}
if (jobData.Configuration.IsIndefinite)
{
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobAction));
}
if (jobData.Configuration.PreprocessorJobIds.SafeAny())
{
foreach (var preprocessorJobId in jobData.Configuration.PreprocessorJobIds)
{
var preprocessorJobStatus = await JobStore.LoadStatus(tenantId, preprocessorJobId);
if (preprocessorJobStatus.State < JobState.Completed)
{
return(ApiValidationResult.Failure(ErrorKeys.JobActionHasPreprocessorDependency,
new[] { preprocessorJobId }));
}
}
}
var changeableStates = new[] { JobState.InProgress, JobState.Draining, JobState.Paused };
if (changeableStates.Any(s => s == jobData.Status.State))
{
var updated = await JobStore.UpdateState(tenantId, jobId, jobData.Status.State, JobState.Stopped);
if (updated)
{
await JobNotification.NotifyJobUpdated(jobId);
var jobStepSource = GetJobQueue(jobData);
if (jobStepSource != null)
{
await jobStepSource.Purge();
}
return(ApiValidationResult.Ok());
}
}
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobState));
}
/// <summary>Validates the specified API request context resolver.</summary>
/// <param name="contextResolver">The API request context resolver.</param>
/// <returns></returns>
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver contextResolver)
{
var context = contextResolver?.GetContext();
var suggestedStatusCode = context.Configuration.ValidationErrorConfiguration.UriBindingErrorStatusCode;
var results = new List <ApiValidationResult>();
results.Add(ApiValidationResult.Failure("VALIDATOR-4.1", suggestedHttpStatusCode: suggestedStatusCode));
results.Add(ApiValidationResult.Failure("VALIDATOR-4.2", suggestedHttpStatusCode: suggestedStatusCode));
return(Task.FromResult(results as IList <ApiValidationResult>));
}
public async Task <ApiValidationResult> CallApiValidation(Guid Id, Page page, List <Answer> answers)
{
if (page.Questions.Any(q => q.Input.Validations.Any(v => v.Name == _clientApiCallValidationName)))
{
_logger.LogInformation("Page has question with api validation");
var validationResult = new ApiValidationResult()
{
IsValid = true
};
var apiBaseUri = new Uri(_config.AssessorApiAuthentication.ApiBaseAddress, UriKind.Absolute);
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = apiBaseUri;
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _tokenService.GetToken());
_logger.LogInformation("Auth set");
foreach (var questionWithClientApiCall in page.Questions.Where(q => q.Input.Validations.Any(v => v.Name == _clientApiCallValidationName)))
{
_logger.LogInformation("Question with api call: " + questionWithClientApiCall.QuestionId);
foreach (var apiCallValidation in questionWithClientApiCall.Input.Validations.Where(v => v.Name == _clientApiCallValidationName))
{
_logger.LogInformation("Validation call: " + apiBaseUri.ToString() + apiCallValidation.Value);
var result = await(await httpClient.GetAsync($"{apiCallValidation.Value}/{Id}?q={answers.Single(a => a.QuestionId == questionWithClientApiCall.QuestionId).Value}"))
.Content.ReadAsAsync <ApiValidationResult>();
_logger.LogInformation("Api call result: Valid:" + result.IsValid);
if (!result.IsValid)
{
validationResult.IsValid = false;
result.ErrorMessages.ForEach(m =>
{
_logger.LogInformation("Api call result: Error message:" + m.Value);
validationResult.ErrorMessages.Add(new KeyValuePair <string, string>(questionWithClientApiCall.QuestionId, m.Value));
});
}
}
}
}
return(validationResult);
}
return(new ApiValidationResult()
{
IsValid = true
});
}
/// <summary>Validates the specified API request context resolver.</summary>
/// <param name="contextResolver">The API request context resolver.</param>
/// <returns></returns>
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver contextResolver)
{
var context = contextResolver.GetContext();
var body = context.Request.InvocationContext.Models <DataAnnotationsBodyModel>().FirstOrDefault();
var uri = context.Request.InvocationContext.Models <DataAnnotationsUriModel>().FirstOrDefault();
if (body.Value != uri.Value)
{
return(Task.FromResult(ApiValidationResult.Single("Body value and Uri value must be the same")));
}
return(Task.FromResult(ApiValidationResult.Success()));
}
public static string ToErrorString(this ApiValidationResult validationResult)
{
if (validationResult.Success)
{
return(string.Empty);
}
var result = new StringBuilder();
if (!string.IsNullOrWhiteSpace(validationResult.Message))
{
result.Append(validationResult.Message).Append("; ");
}
result.Append(string.Join("; ", validationResult.Errors.Select(e => e.ToErrorString())));
return(result.ToString());
}
public async Task <ApiValidationResult> PurgeJobQueue(string tenantId, string jobId)
{
var jobData = await JobStore.Load(tenantId, jobId);
if (jobData == null)
{
return(ApiValidationResult.Failure(ErrorKeys.InvalidJobId));
}
var jobStepSource = GetJobQueue(jobData);
if (jobStepSource == null)
{
return(ApiValidationResult.Failure(ErrorKeys.UnknownInternalServerError));
}
await jobStepSource.Purge();
return(ApiValidationResult.Ok());
}
protected IHttpActionResult ValidationError(string error)
{
return(new ValidationErrorResult(ApiValidationResult.Failure(error), this));
}
protected IHttpActionResult ValidationError(IEnumerable <ApiValidationError> errors)
{
return(new ValidationErrorResult(ApiValidationResult.Failure(errors), this));
}
protected IHttpActionResult ValidationError(string errorKey, IEnumerable <string> errorParams = null)
{
return(new ValidationErrorResult(errorParams == null
? ApiValidationResult.Failure(errorKey)
: ApiValidationResult.Failure(errorKey, errorParams), this));
}
protected IHttpActionResult ValidationError(string propertyPath, string errorKey)
{
return(new ValidationErrorResult(ApiValidationResult.Failure(propertyPath, errorKey), this));
}
/// <summary>Validates the specified API request context resolver.</summary>
/// <param name="contextResolver">The API request context resolver.</param>
/// <returns></returns>
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver contextResolver)
{
return(Task.FromResult(ApiValidationResult.Single("VALIDATOR-5", suggestedHttpStatusCode: 404)));
}
public InvalidAppIdException(ApiValidationResult response)
{
Response = response;
}
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver contextResolver)
{
return(Task.FromResult(ApiValidationResult.Single("VALIDATOR-1")));
}
/// <summary>Validates the specified API request context resolver.</summary>
/// <param name="contextResolver">The API request context resolver.</param>
/// <returns></returns>
public Task <IList <ApiValidationResult> > Validate(IApiRequestContextResolver contextResolver)
{
return(Task.FromResult(ApiValidationResult.Success()));
}
public static ApiValidationResult ToValidationResult(this HttpResponseMessage response)
{
return(response.IsSuccessStatusCode
? ApiValidationResult.Ok()
: ApiValidationResult.Failure(response.ToValidationError()));
}
