protected virtual void ValidateBusinessRules(UploadedFileResource resource, IList <ValidationError> errors)
{
// Check if Code2 and Code3 are unique
//var code2Check = Items().Where(r => r.Code2 == resource.Code2);
//var code3Check = Items().Where(r => r.Code3 == resource.Code3);
var filename2check = Items().Where(r => r.ImageFilename == resource.ImageFilename);
// Check if Id is unique for new resource
if (resource.RowVersion.IsNullOrEmpty())
{
if (Items().Where(r => r.Id == resource.Id).Count() > 0)
{
errors.Add(new ValidationError($"{resource.Id} is already taken", nameof(resource.Id)));
}
}
else
{
// Existing resource, skip resource itself in unique check
//code2Check = code2Check.Where(r => r.Code2 == resource.Code2 && r.Id != resource.Id);
//code3Check = code3Check.Where(r => r.Code3 == resource.Code3 && r.Id != resource.Id);
filename2check = filename2check.Where(r => r.ImageFilename == resource.ImageFilename && r.Id != resource.Id);
}
// set error message
//if (code2Check.Count() > 0)
// errors.Add(new ValidationError($"{resource.Code2} already exist", nameof(resource.Code2)));
//if (code3Check.Count() > 0)
// errors.Add(new ValidationError($"{resource.Code3} already exist", nameof(resource.Code3)));
if (filename2check.Count() > 0)
{
errors.Add(new ValidationError($"{resource.ImageFilename} already exist", nameof(resource.ImageFilename)));
}
}
public async Task <IActionResult> Post([FromBody] UploadedFileResource resource)
{
try
{
// Create rescource
var serviceResult = await ResourceService.InsertAsync(resource);
// if return error message if needed
if (serviceResult.Errors.Count > 0)
{
return(BadRequest(serviceResult));
}
// On succes return url with id and newly created resource
return(CreatedAtAction(nameof(Get), new { id = serviceResult.Resource.Id }, serviceResult.Resource));
}
catch (Exception ex)
{
var result = new ResourceResult <UploadedFileResource>(resource);
while (ex != null)
{
result.Exceptions.Add(ex.Message);
}
return(BadRequest(result));
}
}
public async Task <ResourceResult <UploadedFileResource> > UpsertAsync(UploadedFileResource resource)
{
var result = new ResourceResult <UploadedFileResource>();
// Beautify before validation and make validation more succesfull
BeautifyResource(resource);
// save beautify effect effect
result.Resource = resource;
// Apply simple validation on attribute level
ValidateAttributes(resource, result.Errors);
// Apply complex business rules validation
ValidateBusinessRules(resource, result.Errors);
// Save is only usefull when error free
if (result.Errors.Count == 0)
{
// Convert resource to entity
var entity = mapper.Map <UploadedFile>(resource);
// save entity
await EntityContext.UpsertAsync(entity);
// convert save result back to resource and get database created values like auto incremental field and timestamps.
result.Resource = mapper.Map <UploadedFileResource>(entity);
}
return(result);
}
public UploadedFileResource Create()
{
var result = new UploadedFileResource()
{
CreatedAt = DateTime.Now
};
return(result);
}
protected virtual void BeautifyResource(UploadedFileResource resource)
{
// Only letter are allowed in codes
//resource.Code2 = resource.Code2?.ToUpperInvariant()?.ToLetter();
//resource.Code3 = resource.Code3?.ToUpperInvariant()?.ToLetter();
//resource.Name = resource.Name?.Trim();
resource.ImageFilename = resource.ImageFilename?.Trim();
resource.Comments = resource.Comments?.Trim();
}
/// <summary>
/// Perform basic validation
/// </summary>
/// <param name="resource"></param>
/// <param name="errors"></param>
protected void ValidateAttributes(UploadedFileResource resource, IList <ValidationError> errors)
{
var validationContext = new System.ComponentModel.DataAnnotations.ValidationContext(resource);
var validationResults = new List <ValidationResult>();;
Validator.TryValidateObject(resource, validationContext, validationResults, true);
foreach (var item in validationResults)
{
errors.Add(new ValidationError(item.ErrorMessage, item.MemberNames?.FirstOrDefault() ?? ""));
}
}
public async Task <ResourceResult <UploadedFileResource> > InsertAsync(UploadedFileResource resource)
{
// Fields are set by persistance service
resource.CreatedBy = null;
resource.ModifiedAt = null;
resource.ModifiedBy = null;
resource.RowVersion = null;
return(await UpsertAsync(resource));
}
protected virtual void ValidateDelete(UploadedFileResource resource, IList <ValidationError> errors)
{
//if (resource.Code2.EqualsEx("NL"))
//{
// errors.Add(new ValidationError("It's not allowed to delete the Low Lands! ;-)"));
//}
//if (resource.Code2.EqualsEx("BE"))
//{
// errors.Add(new ValidationError("Without Belgium no great Beer!"));
//}
if (resource.ImageFilename.EqualsEx("TEST"))
{
errors.Add(new ValidationError("This is default record"));
}
}
public async Task<IActionResult> UpdateUploadedFile(int id, [FromBody]UploadedFileResource uploadedFileResource)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var uploadedFile = await uploadedFileRepository.GetUploadedFile(id);
if (uploadedFile == null)
return NotFound();
mapper.Map<UploadedFileResource, UploadedFile>(uploadedFileResource, uploadedFile);
await unitOfWork.Complete();
var result = mapper.Map<UploadedFile, UploadedFileResource>(uploadedFile);
return Ok(result);
}
public async Task <IActionResult> Put([FromBody] UploadedFileResource resource)
{
try
{
var currentResource = await ResourceService.FindAsync(resource.Id);
if (currentResource == null)
{
return(NotFound());
}
var serviceResult = await ResourceService.UpdateAsync(resource);
if (serviceResult.Errors.Count > 0)
{
return(BadRequest(serviceResult));
}
return(Ok(serviceResult.Resource));
}
catch (Exception ex)
{
var result = new ResourceResult <UploadedFileResource>(resource);
while (ex != null)
{
result.Exceptions.Add(ex.Message);
if (ex is ConcurrencyException)
{
return(StatusCode(HttpStatusCode.Conflict.ToInt32(), result));
}
ex = ex.InnerException;
}
return(BadRequest(result));
}
}
public async Task<IActionResult> CreateUploadedFile([FromBody]UploadedFileResource uploadedFileResource)
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var uploadedFile = mapper.Map<UploadedFileResource, UploadedFile>(uploadedFileResource);
var group = await groupRepository.GetGroup(uploadedFileResource.GroupId);
uploadedFile.Group = group;
uploadedFileRepository.AddUploadedFile(uploadedFile);
await unitOfWork.Complete();
uploadedFile = await uploadedFileRepository.GetUploadedFile(uploadedFile.UploadedFileId);
var result = mapper.Map<UploadedFile, UploadedFileResource>(uploadedFile);
return Ok(result);
}
public IActionResult Get(String code)
{
if (code.IsNullOrEmpty())
{
return(BadRequest());
}
code = code.ToUpper();
UploadedFileResource result = null;
switch (code.Length)
{
case 2:
result = ResourceService.Items().Where(c => c.ImageFilename == code).FirstOrDefault();
break;
case 3:
result = ResourceService.Items().Where(c => c.ImageFilePath == code).FirstOrDefault();
break;
}
return((result == null) ? NotFound() as IActionResult : Json(result));
}
public async Task <ResourceResult <UploadedFileResource> > UpdateAsync(UploadedFileResource resource)
{
return(await UpsertAsync(resource));
}
