public async Task <IActionResult> Put([FromRoute] int id, [FromBody] UpdateToDoRequest toDoRequest)
{
if (id != toDoRequest.Id)
{
var error = new ValidationError("To Do", "Id from route does not match Id from route");
var validation = new ValidationResultModel(new[] { error });
return(BadRequest(validation));
}
var isOwner = await repository.UserOwnsPostAsync(id, HttpContext.GetUserId());
if (!isOwner)
{
var error = new ValidationError("To Do", "You do not own the ToDo acticity you're trying to update");
var validation = new ValidationResultModel(new[] { error });
return(Unauthorized(validation));
}
if (toDoRequest.Status == Status.Done && toDoRequest.DateCompleted == null)
{
var error = new ValidationError("To Do", "Set Date Completed when Task Status is Completed. Preferably Utc");
var validation = new ValidationResultModel(new[] { error });
return(BadRequest(validation));
}
var toDo = toDoRequest.GetToDo();
toDo = await repository.UpdateToDoAsync(id, toDo);
if (toDo != null)
{
return(Ok(toDo.GetToDoResponse()));
}
return(NotFound());
}
public async Task <ValidationResultModel <ProductResponse> > Save(CreateProductRequest model)
{
var result = new ValidationResultModel <ProductResponse>();
if (!result.Succeeded)
{
return(result);
}
Products product = null;
if (!string.IsNullOrWhiteSpace(model.Id))
{
product = (await _productRepository.GetProducts(new GetProductRequest {
Id = model.Id
})).Single();
}
var productDbModel = model.Map <CreateProductRequest, Products>(product);
productDbModel = await _productRepository.Save(productDbModel);
//Save Revision with RabbitMQ
await _rabbitMqService.RabbitMqSender(product, RabbitMqConstants.ProductRevisionQueue);
result.Model = productDbModel.Map <Products, ProductResponse>();
return(result);
}
/// <summary>
/// The method would validate the resultant model
/// </summary>
/// <param name="modelState">The model state</param>
/// <param name="errorMessage">The error message to be thrown if validation fails</param>
public static ValidationResultModel ToValidationResultModel(this Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary modelState, string errorMessage = "Validation Failed")
{
if (modelState != null)
{
if (modelState.IsValid)
{
return(new ValidationResultModel {
IsValid = true
});
}
var result = new ValidationResultModel
{
Message = errorMessage,
Errors = modelState.Keys
.Where(key => modelState[key].ValidationState == Microsoft.AspNetCore.Mvc.ModelBinding.ModelValidationState.Invalid)
.SelectMany(key => modelState[key].ToValidationResults(key))
.ToList()
};
if (!result.Errors.Any())
{
result.IsValid = true;
}
return(result);
}
return(null);
}
public async Task <ValidationResultModel> ValidateAdd(CityModel model)
{
var result = new ValidationResultModel();
// Simple validation of string length and such like, assumes
// we are not using standard MVC model validation
if (model.Name == null)
{
// Failed as it is required
result.AddMessage("Name", $"Value is required");
}
if (model.Name?.Length > NameMaxLength)
{
// Failed as it is too long
result.AddMessage("Name", $"Maximum length of {NameMaxLength}");
}
if (model.State == null)
{
// Failed as it is required
result.AddMessage("State", $"Value is required");
}
if (model.State?.Length > StateMaxLength)
{
// Failed as it is too long
result.AddMessage("State", $"Maximum length of {StateMaxLength}");
}
if (model.CountryCode == null)
{
// Failed as it is required
result.AddMessage("CountryCode", $"Value is required");
}
if (model.CountryCode?.Length != 3)
{
// Failed as it is too long
result.AddMessage("CountryCode", $"Invalid CountryCode, must be three characters");
}
else if (!await _countrySearch.IsCountryCodeValid(model.CountryCode))
{
// Failed as not found in datasource
result.AddMessage("CountryCode", $"Invalid CountryCode, not found on database");
}
if (model.TouristRating.HasValue && (model.TouristRating.Value < 0 || model.TouristRating.Value > 5))
{
// Failed as it is required
result.AddMessage("TouristRating", $"Value is invalid, must be a number between 1 and 5");
}
return(await Task.FromResult(result));
}
/// <summary>
/// constructor to initialise properties
/// </summary>
public GetClinicalDocument_Step()
{
_server = new TestServer(
WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
);
_client = _server.CreateClient();
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_validationResultModel = new ValidationResultModel();
}
public IError OnError(IError error)
{
if (!(error.Exception is ValidationException exception))
{
return(error);
}
var validationResult = new ValidationResultModel(exception.Errors.Select(x => x.ErrorMessage));
return(error.AddExtension("ValidationError", validationResult));
}
public IActionResult Delete(long id)
{
_phonebookService.Delete(id);
var phonebook = new Domain.Phonebook()
{
Id = id
};
var model = new ValidationResultModel();
model.IsActionSuccessful = true;
return(Json(model));
}
public ValidationResultModel Validate(CityDomain cityDomain, PlayerTurnModel turnModel)
{
ValidationResultModel valid = new ValidationResultModel()
{
HasErrors = false
};
StringBuilder sb = new StringBuilder();
if (turnModel.BushelsToFeed > cityDomain.BushelsCount)
{
sb.Append("You do not have as many bushels").Append(_separator);
valid.HasErrors = true;
}
if (turnModel.AcrChange < 0 && -turnModel.AcrChange > cityDomain.AcresCount)
{
sb.Append("You do not have as many acres for sale!").Append(_separator);
valid.HasErrors = true;
}
if (turnModel.AcrChange > 0 && cityDomain.BushelsCount / cityDomain.AcrCost < turnModel.AcrChange)
{
sb.Append("You do not have as many bushels to buy as many acres!").Append(_separator);
valid.HasErrors = true;
}
if (turnModel.AcresToPlant > cityDomain.AlivePeople * 10)
{
sb.Append("You do not have so many people to sow such a count of acres!").Append(_separator);
valid.HasErrors = true;
}
if (turnModel.BushelsToFeed < 0)
{
sb.Append("You can not enter a negative value in the field for food!").Append(_separator);
valid.HasErrors = true;
}
if (turnModel.AcresToPlant < 0)
{
sb.Append("You can not enter a negative value in the field for sowing acres!").Append(_separator);
valid.HasErrors = true;
}
if (valid.HasErrors)
{
valid.ErrorMessage = sb.ToString();
}
return(valid);
}
public async Task <ValidationResultModel <ProviderResponse> > Save(CreateProviderRequest model)
{
var result = new ValidationResultModel <ProviderResponse>();
if (result.Succeeded)
{
var providerDbModel = model.Map <CreateProviderRequest, Providers>();
providerDbModel = await _providerRepository.Save(providerDbModel);
result.Model = providerDbModel.Map <Providers, ProviderResponse>();
}
return(result);
}
public async Task <ValidationResultModel <CategoryResponse> > Save(CreateCategoryRequest model)
{
var result = new ValidationResultModel <CategoryResponse>();
if (result.Succeeded)
{
var categoryDbModel = model.Map <CreateCategoryRequest, Categories>();
categoryDbModel = await _categoryRepository.Save(categoryDbModel);
result.Model = categoryDbModel.Map <Categories, CategoryResponse>();
}
return(result);
}
public static bool IsModelValid <T>(T item, out ValidationResultModel <T> resultModel)
where T : new()
{
resultModel = new ValidationResultModel <T> {
Model = item
};
ICollection <ValidationResult> results;
var isValid = IsModelValid(item, out results);
resultModel.Results = results;
return(isValid);
}
public async Task <ValidationResultModel <ReviewResponse> > Save(CreateReviewRequest model)
{
var result = new ValidationResultModel <ReviewResponse>();
if (result.Succeeded)
{
var reviewDbModel = model.Map <CreateReviewRequest, Reviews>();
reviewDbModel = await _reviewRepository.Save(reviewDbModel);
result.Model = reviewDbModel.Map <Reviews, ReviewResponse>();
}
return(result);
}
protected ActionResult CustomResponseModel(ValidationResultModel validationResult)
{
if (validationResult != null)
{
foreach (var error in validationResult.Errors)
{
AddError(error.ErrorMessage);
}
return(Ok(validationResult));
}
else
{
return(CustomResponse());
}
}
/// <summary>
/// Save Clinical Document Constructor
/// </summary>
public SaveClinicalDocument_Step()
{
_server = new TestServer(
WebHost.CreateDefaultBuilder()
.UseStartup <Startup>()
);
_client = _server.CreateClient();
_client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
_documentDetailRequest_Contract = new DocumentDetailRequest
{
AccountNumber = "1234567",
DocumentName = "OpsReport",
DocumentType = "JPEG",
FacilityCode = "SJPR",
MimeType = "image/jpeg",
SourceSystem = "GCR",
Document = Convert.FromBase64String("")
};
_validationResultModel = new ValidationResultModel();
}
public async Task <ValidationResultModel> ValidateAdd(DataModel model)
{
var result = new ValidationResultModel();
// Simple validation of string length and such like, assumes
// we are not using standard MVC model validation
if (model.Name == null)
{
// Failed as it is required
result.AddMessage("EntityName", $"Value is required");
}
if (model.Name?.Length > EntityNameMaxLength)
{
// Failed as it is required
result.AddMessage("EntityName", $"Maximum length of {EntityNameMaxLength}");
}
return(await Task.FromResult(result));
}
public Task <ValidationResultModel <TResult> > BuildAsync <TResult>(TResult result)
{
if (_domainNotificationService.HasNotifications())
{
return(Task.FromResult(ValidationResultModel <TResult> .Instantiate(_domainNotificationService
.GetNotifications()
.Select(n =>
{
var resource = _localization.GetResource(n.Key, n.Value);
if (!string.IsNullOrEmpty(resource))
{
return new NotificationModel(n.Key, resource, n.Type);
}
else
{
return new NotificationModel(n.Key, n.Value, n.Type);
}
}).ToList(), result)));
}
return(Task.FromResult(ValidationResultModel <TResult> .Instantiate(result)));
}
public ErrorResponse(ErrorCode code, string message, ValidationResultModel validationResult)
: this(new ErrorData((int)code, message, validationResult))
{
}
public Task <ValidationResultModel <Exception> > BuildAsync(Exception ex)
{
return(Task.FromResult(ValidationResultModel <Exception> .Instantiate(ex)));
}
public ValidationResultModel <Exception> Build(Exception ex)
{
return(ValidationResultModel <Exception> .Instantiate(ex));
}
public ErrorData(int code, string message, ValidationResultModel validationResult)
{
Code = code;
Message = message;
ValidationResult = validationResult;
}
/// <summary>
/// 导入模型验证数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="stream">文件流</param>
/// <returns></returns>
public Task <ImportModel <T> > Import <T>(Stream stream) where T : class, new()
{
IList <ValidationResultModel> validationResultModels = new List <ValidationResultModel>();
using (var excelPackage = new ExcelPackage(stream))
{
bool hasValidTemplate = ParseTemplate <T>(excelPackage, out var columnHeaders);
IList <T> importDataModels = new List <T>();
if (!hasValidTemplate)
{
return(Task.FromResult(new ImportModel <T>
{
HasValidTemplate = hasValidTemplate,
Data = importDataModels,
ValidationResults = validationResultModels
}));
}
importDataModels = ParseData <T>(excelPackage, columnHeaders);
string keyName = "Invalid";
for (var i = 0; i < importDataModels.Count; i++)
{
var validationResultModel = new ValidationResultModel
{
Index = i + 1
};
var isValid = ValidatorHelper.TryValidate(importDataModels[i], out var validationResults);
if (isValid)
{
continue;
}
if (!validationResultModel.Errors.ContainsKey(keyName))
{
validationResultModel.Errors.Add(keyName, "导入数据无效");
}
foreach (var validationResult in validationResults)
{
var key = validationResult.MemberNames.First();
var column = columnHeaders.FirstOrDefault(a => a.PropertyName.Equals(key));
if (column != null)
{
key = column.ExporterHeader.Name;
}
var value = validationResult.ErrorMessage;
if (validationResultModel.FieldErrors.ContainsKey(key))
{
validationResultModel.FieldErrors[key] = validationResultModel.FieldErrors[key] + "," + value;
}
else
{
validationResultModel.FieldErrors.Add(key, value);
}
}
if (validationResultModel.Errors.Count > 0)
{
validationResultModels.Add(validationResultModel);
}
}
return(Task.FromResult(new ImportModel <T>
{
HasValidTemplate = hasValidTemplate,
Data = importDataModels,
ValidationResults = validationResultModels
}));
}
}
public void ThenInResponseBodyOfGETAPICall(string errorMessage)
{
_validationResultModel = JsonConvert.DeserializeObject <ValidationResultModel>(_responseMessage.Content.ReadAsStringAsync().Result);
Assert.Contains(errorMessage, _validationResultModel.Errors.FirstOrDefault().Message);
}
