static void Main(string[] args)
{
BookValidator bookValidator = new BookValidator();
bool validBook = bookValidator.Validate("books.xml", "BookSchema.xsd");
System.Console.WriteLine(validBook);
bool inValidBook = bookValidator.Validate("invalid-books.xml", "BookSchema.xsd");
System.Console.WriteLine(inValidBook);
}
public void ValidEntities()
{
Book book = new Book()
{
Title = "Lord of the Rings",
Author = "J. R. R. Tolkien",
Image = "lotr.png",
UserId = new Guid("5489A967-9320-4350-E6FC-08D5CC8498F3")
};
ValidationResult result = bookValidator.Validate(book);
Assert.True(result.IsValid);
}
public void ValidEntities()
{
Book book = new Book()
{
Title = "Lord of the Rings",
Author = "J. R. R. Tolkien",
Image = "lotr.png",
ImageBytes = Encoding.UTF8.GetBytes("STRINGBASE64"),
FreightOption = FreightOption.World,
UserId = new Guid("5489A967-9320-4350-E6FC-08D5CC8498F3"),
};
ValidationResult result = bookValidator.Validate(book);
Assert.True(result.IsValid);
}
private static void ValidateBook(Book book)
{
var validator = new BookValidator();
var results = validator.Validate(book);
if (results.IsValid)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Book are successfully validated.");
Console.ForegroundColor = ConsoleColor.Gray;
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Failed. Errors:");
Console.ForegroundColor = ConsoleColor.DarkRed;
foreach (ValidationFailure failure in results.Errors)
{
Console.WriteLine(failure.ErrorMessage);
}
Console.ForegroundColor = ConsoleColor.Gray;
}
Console.WriteLine();
}
public async Task AddBook(BookDto input)
{
List <string> errorList = new List <string>();
var book = new Book
{
Name = input.Name.Remove(),
PriceBorrow = input.PriceBorrow,
CategoryId = input.CategoryId,
PublisherId = input.PublisherId,
AuthorId = input.AuthorId,
YearPublic = input.YearPublic
};
BookValidator validator = new BookValidator();
ValidationResult validationResult = validator.Validate(book);
if (!validationResult.IsValid)
{
foreach (var failure in validationResult.Errors)
{
errorList.Add(string.Format("{0}", failure.ErrorMessage));
}
string errorString = string.Join(" ", errorList.ToArray());
throw new UserFriendlyException(errorString);
}
await _bookRepository.InsertAsync(book);
}
public async Task UpdateBook(BookDto input)
{
List <string> errorList = new List <string>();
var data = await GetBookById(input.Id);
data.Name = input.Name.Remove();
data.CategoryId = input.CategoryId;
data.PublisherId = input.PublisherId;
data.AuthorId = input.AuthorId;
data.YearPublic = input.YearPublic;
BookValidator validator = new BookValidator();
ValidationResult validationResult = validator.Validate(data);
if (!validationResult.IsValid)
{
foreach (var failure in validationResult.Errors)
{
errorList.Add(string.Format("{0}", failure.ErrorMessage));
}
string errorString = string.Join(" ", errorList.ToArray());
throw new UserFriendlyException(errorString);
}
await _bookRepository.UpdateAsync(data);
}
private bool ClientValidator(Book book)
{
var bookValidator = new BookValidator();
book.ValidationResult = bookValidator.Validate(book);
return(book.ValidationResult.Errors.Any());
}
private void BookValidation(Book book)
{
BookValidator bookValidator = new BookValidator();
var result = bookValidator.Validate(book);
if (result.Errors.Count > 0)
{
throw new ValidationException(result.Errors);
}
}
public IActionResult AddBook([FromBody] Book book)
{
var validator = new BookValidator();
if (validator.Validate(book).IsValid)
{
_bookService.AddBook(book);
return(Ok());
}
return(BadRequest());
}
public IActionResult UpdateBook([FromBody] Book book, int id)
{
var validator = new BookValidator();
if (validator.Validate(book).IsValid)
{
book.Id = id;
_bookService.UpdateBook(book);
return(Ok());
}
return(BadRequest());
}
public async Task <Result <Book> > CreateBook(Book newBook)
{
ValidationResult validationResult = _validator.Validate(newBook);
if (!validationResult.IsValid)
{
return(Result.Failure(newBook, validationResult.Errors.Select(s => s.ErrorMessage).ToList()));
}
var bookFromEF = await _bookRepository.AddAsync(newBook);
return(Result.Success(bookFromEF));
}
public async Task <IActionResult> Save(BookViewModel bookViewModel)
{
var validator = new BookValidator();
var results = validator.Validate(bookViewModel);
results.AddToModelState(ModelState, null);
if (ModelState.IsValid)
{
var result = await _testService.PostAsync("api/books", bookViewModel);
return(RedirectToAction("GetBooks", "Home"));
}
return(View("Create"));
}
public async Task <IActionResult> Save()
{
string targetFilePath = null;
BookDTO dto = null;
if (!MultipartRequestHelper.IsMultipartContentType(Request.ContentType))
{
return(BadRequest($"Requisição precisa ser 'multipart'."));
}
var boundary = MultipartRequestHelper.GetBoundary(MediaTypeHeaderValue.Parse(Request.ContentType), MaxBoundaryLengthLimit);
var reader = new MultipartReader(boundary, HttpContext.Request.Body);
var section = await reader.ReadNextSectionAsync();
while (section != null)
{
ContentDispositionHeaderValue contentDisposition;
var hasContentDispositionHeader = ContentDispositionHeaderValue.TryParse(section.ContentDisposition, out contentDisposition);
var key = HeaderUtilities.RemoveQuotes(contentDisposition.Name);
if (hasContentDispositionHeader)
{
if (MultipartRequestHelper.HasFileContentDisposition(contentDisposition))
{
if (key.ToString() == "file")
{
var imageValidator = new ImageValidator();
var fileName = HeaderUtilities.RemoveQuotes(contentDisposition.FileName).ToString();
var imageValidationResult = imageValidator.Validate(fileName);
if (imageValidationResult.HasError)
{
return(BadRequest(imageValidationResult.ErrorMessage));
}
targetFilePath = Path.GetTempFileName();
using (var targetStream = System.IO.File.Create(targetFilePath))
{
await section.Body.CopyToAsync(targetStream);
}
}
}
else if (MultipartRequestHelper.HasFormDataContentDisposition(contentDisposition))
{
if (key.ToString() == "value")
{
using (var streamReader = new StreamReader(section.Body))
{
var json = await streamReader.ReadToEndAsync();
dto = JsonConvert.DeserializeObject <BookDTO>(json);
}
}
}
}
section = await reader.ReadNextSectionAsync();
}
var validationContext = new ValidationContext(bookFacade, authorService, publisherService);
var bookValidator = new BookValidator(validationContext);
var validationResult = bookValidator.Validate(dto);
if (validationResult.HasError)
{
return(BadRequest(validationResult.ErrorMessage));
}
var bookFound = await bookFacade.FindById(dto.Id);
if (bookFound == null && dto.Id != 0)
{
return(NotFound($"Nenhum livro encontrado com o ID: {dto.Id}."));
}
try
{
var book = dto.FromBookViewItem(new DefaultValidationResultDataLookUp(validationResult));
book = await bookFacade.Save(book, targetFilePath);
return(Ok(await book.ToBookViewItem(serviceDataLookUp)));
}
catch (BookSaveException ex)
{
try
{
System.IO.File.Delete(targetFilePath);
}
catch
{
//Ignore
}
return(BadRequest(ex.Message));
}
catch (ImageSaveException ex)
{
return(BadRequest(ex.Message));
}
}
