public async Task <ActionResult <ActivityCodeDto> > CreateActivityCode(ActivityCodeCreateDto activityCode)
{
var response = await _activityCodeSvc.CreateActivityCodeAsync(activityCode);
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(CreatedAtRoute("GetActivityCode", new { response.id }, await _activityCodeSvc.GetActivityCodeAsync(response.id)));
}
public async Task <ActionResult <KeycloakClientDto> > CreateUserKeycloakClient()
{
var response = await _keyCloakService.CreateUserClientAsync();
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(CreatedAtRoute("GetUserKeycloakClient", await _keyCloakService.GetUserClientAsync()));
}
public async Task <ActionResult <UserDto> > CreateUser(UserCreateDto user)
{
var response = await _userService.CreateUserAsync(user);
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(CreatedAtRoute("GetUser", new { id = response.SystemUserId }, await _userService.GetUserAsync(response.SystemUserId)));
}
public async Task <ActionResult <RoleDto> > CreateRole(RoleCreateDto role)
{
var response = await _roleSvc.CreateRoleAsync(role);
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(CreatedAtRoute("GetRole", new { id = response.RoleId }, await _roleSvc.GetRoleAsync(response.RoleId)));
}
public async Task <IActionResult> ExportReport(string serviceAreas, string typeName, string format, DateTime fromDate, DateTime toDate, string cql_filter, string propertyName)
{
var serviceAreaNumbers = serviceAreas.ToDecimalArray();
if (serviceAreaNumbers.Length == 0)
{
serviceAreaNumbers = _currentUser.UserInfo.ServiceAreas.Select(x => x.ServiceAreaNumber).ToArray();
}
var invalidResult = ValidateQueryParameters(serviceAreaNumbers, typeName, format, fromDate, toDate);
if (invalidResult != null)
{
return(invalidResult);
}
var(mimeType, fileName, outputFormat, endpointConfigName) = GetContentType(format);
if (mimeType == null)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Invalid output format", "Please include a valid output format in the query string."));
}
var dateColName = GetDateColName(typeName);
var(result, exists) = await MatchExists(serviceAreaNumbers, fromDate, toDate, "text/csv;charset=UTF-8", dateColName, ExportQueryEndpointConfigName.WFS);
if (result != null)
{
return(result);
}
if (!exists)
{
return(NotFound());
}
var query = BuildQuery(serviceAreaNumbers, fromDate, toDate, outputFormat, dateColName, endpointConfigName, false);
var responseMessage = await _exportApi.ExportReport(query, endpointConfigName);
var bytes = await responseMessage.Content.ReadAsByteArrayAsync();
if (responseMessage.StatusCode == HttpStatusCode.OK)
{
return(File(bytes, responseMessage.Content.Headers.ContentType.ToString(), fileName));
}
else
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
(int)responseMessage.StatusCode, "Error from Geoserver", Encoding.UTF8.GetString(bytes)));
}
}
public async Task <IActionResult> CreateWorkReportAsync([FromForm] WorkRptUploadDto upload)
{
var result = await _workRptService.CreateWorkReportAsync(upload);
if (result.SubmissionObjectId == 0)
{
return(ValidationUtils.GetValidationErrorResult(result.Errors, ControllerContext));
}
return(Ok());
}
public async Task <IActionResult> CheckDuplicateAsync([FromForm] WorkRptUploadDto upload)
{
var(Errors, DuplicateRecordNumbers) = await _workRptService.CheckDuplicatesAsync(upload);
if (Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(Errors, ControllerContext));
}
//return Ok(JsonSerializer.Serialize(DuplicateRecordNumbers));
return(Ok(DuplicateRecordNumbers));
}
public async Task <ActionResult> DeleteActivityCode(decimal id)
{
var response = await _activityCodeSvc.DeleteActivityCodeAsync(id);
if (response.NotFound)
{
return(NotFound());
}
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(NoContent());
}
public async Task <ActionResult> RegenerateUserKeycloakClientSecret()
{
var response = await _keyCloakService.RegenerateUserClientSecretAsync();
if (response.NotFound)
{
return(NotFound());
}
if (!string.IsNullOrEmpty(response.Error))
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
StatusCodes.Status500InternalServerError, "Unable to regenerate Keycloak client secret", response.Error));
}
return(CreatedAtRoute("GetUserKeycloakClient", await _keyCloakService.GetUserClientAsync()));
}
public async Task <ActionResult <List <string> > > CheckResubmitAsync([FromForm] FileUploadDto upload)
{
var problem = IsServiceAreaAuthorized(_currentUser, upload.ServiceAreaNumber);
if (problem != null)
{
return(Unauthorized(problem));
}
var(errors, resubmittedRecordNumbers) = await _workRptService.CheckResubmitAsync(upload);
if (errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(errors, ControllerContext));
}
return(Ok(resubmittedRecordNumbers));
}
public async Task <IActionResult> CreateWorkReportAsync([FromForm] FileUploadDto upload)
{
var problem = IsServiceAreaAuthorized(_currentUser, upload.ServiceAreaNumber);
if (problem != null)
{
return(Unauthorized(problem));
}
var(submissionObjectId, errors) = await _workRptService.CreateReportAsync(upload);
if (errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(errors, ControllerContext));
}
return(CreatedAtRoute("GetSubmissionObject", new { id = submissionObjectId }, await _submissionService.GetSubmissionObjectAsync(submissionObjectId)));
}
private UnprocessableEntityObjectResult ValidateQueryParameters(decimal[] serviceAreaNumbers, string typeName, string outputFormat, DateTime fromDate, DateTime toDate)
{
var problem = AreServiceAreasAuthorized(_currentUser, serviceAreaNumbers);
if (problem != null)
{
return(ValidationUtils.GetValidationErrorResult(problem));
}
if (outputFormat == null)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Output format is missing", "Please include a valid output format in the query string."));
}
if (typeName == null)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Type name is missing", "Please include a valid type name in the query string."));
}
var dateFieldName = GetDateColName(typeName);
if (dateFieldName == null)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Type name is invalid", "Please include a valid type name in the query string."));
}
if (fromDate < Constants.MinDate)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Invalid fromDate", "Please include a valid fromDate in the query string."));
}
if (fromDate > toDate)
{
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
"Invalid toDate", "toDate must be greater than fromDate"));
}
return(null);
}
private async Task <(UnprocessableEntityObjectResult result, bool exists)> MatchExists(decimal[] serviceAreaNumbers, DateTime fromDate, DateTime toDate, string outputFormat, string dateColName, string endpointConfigName)
{
var query = BuildQuery(serviceAreaNumbers, fromDate, toDate, outputFormat, dateColName, ExportQueryEndpointConfigName.WFS, true);
var responseMessage = await _exportApi.ExportReport(query, endpointConfigName);
if (responseMessage.StatusCode != HttpStatusCode.OK)
{
var bytes = await responseMessage.Content.ReadAsByteArrayAsync();
return(ValidationUtils.GetValidationErrorResult(ControllerContext,
(int)responseMessage.StatusCode, "Error from Geoserver", Encoding.UTF8.GetString(bytes)), false);
}
var content = await responseMessage.Content.ReadAsStringAsync();
var features = JsonSerializer.Deserialize <FeatureCollection>(content);
return(null, features.numberMatched > 0);
}
public async Task <ActionResult> DeleteUser(decimal id, UserDeleteDto user)
{
if (id != user.SystemUserId)
{
throw new Exception($"The system user ID from the query string does not match that of the body.");
}
var response = await _userService.DeleteUserAsync(user);
if (response.NotFound)
{
return(NotFound());
}
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(NoContent());
}
public async Task <ActionResult> DeleteRole(decimal id, RoleDeleteDto role)
{
if (id != role.RoleId)
{
throw new Exception($"The system role ID from the query string does not match that of the body.");
}
var response = await _roleSvc.DeleteRoleAsync(role);
if (response.NotFound)
{
return(NotFound());
}
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(NoContent());
}
public async Task <ActionResult> UpdateActivityCode(decimal id, ActivityCodeUpdateDto activityCode)
{
if (id != activityCode.ActivityCodeId)
{
throw new Exception($"The Activity Code ID from the query string does not match that of the body.");
}
var response = await _activityCodeSvc.UpdateActivityCodeAsync(activityCode);
if (response.NotFound)
{
return(NotFound());
}
if (response.Errors.Count > 0)
{
return(ValidationUtils.GetValidationErrorResult(response.Errors, ControllerContext));
}
return(NoContent());
}
