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 <Payload <Book> > AddBookByIsbnAsync(
AddBookByIsbnInput input,
[Service] IGetClaimsProvider claimsProvider,
[Service] IBookApiService apiService,
[ScopedService] BookRefDbContext context)
{
if (context.Books.Any(e => e.Identifier == input.Isbn))
{
return(new Payload <Book>(BuildSingleError(new BookException($"Book with isbn '{input.Isbn}' already in database."))));
}
var apiResult = apiService.FindBook(input.Isbn);
if (apiResult.IsNone)
{
return(new Payload <Book>(BuildSingleError(new BookException($"{input.Isbn} not found in service"))));
}
apiResult = new BookService().MatchAuthors(context.Authors.ToList(), apiResult);
var book = apiResult.IfNone(new Book("", "", ""));
var validationResult = new BookValidator().Validate(book);
if (!validationResult.IsValid)
{
return(new Payload <Book>(BuildErrorList(validationResult.Errors)));
}
context.Books.Add(book);
await context.SaveChangesAsync();
return(new Payload <Book>(book));
}
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());
}
public void IsValidCityForBookTest()
{
BookValidator vld = new BookValidator();
string city = "Саратов";
Assert.AreEqual(true, vld.IsValidCity(city));
}
public void IsInValidCityForBookTest()
{
BookValidator vld = new BookValidator();
string city = null;
Assert.AreEqual(false, vld.IsValidCity(city));
}
public Task <CreateBookOutput> Execute(CreateBookInput data)
{
var book = new Book(data.Name, data.Author, data.Description, data.Category, data.PublishingCompany);
var resultValidation = new BookValidator().Validate(book);
throw new System.NotImplementedException();
}
public void SecondBookISBNNumberValidatorTest()
{
BookValidator bookValidator = new BookValidator();
bool expected = false;
var actual = bookValidator.HasThirteenDigitsInISBNNumber("123456789123");
Assert.AreEqual(expected, actual);
}
public CreateBookViewModel(IBookRepository bookRepository)
{
BookRepository = bookRepository;
EditableBook = new Book()
{
ReleaseDate = DateTime.Now
};
BookValidator = new BookValidator(EditableBook);
}
static Validators()
{
AuthorValidator = new AuthorValidator();
BookValidator = new BookValidator();
PublisherValidator = new PublisherValidator();
PaperValidator = new PaperValidator();
PatentValidator = new PatentValidator();
PaperIssueValidator = new PaperIssueValidator();
}
/// <summary>
/// Tells if title contain substring.
/// </summary>
/// <param name="bookToCheck">Book to check.</param>
/// <returns>True if if title contain substring, otherwise - null.</returns>
/// <exception cref="ArgumentException">Thrown if book to check is null.</exception>
public bool IsMatch(Book bookToCheck)
{
BookValidator.CheckOnNull(bookToCheck);
if (bookToCheck.Name.ToLower().Contains(this.searchSubstring.ToLower()))
{
return(true);
}
return(false);
}
private void BookValidation(Book book)
{
BookValidator bookValidator = new BookValidator();
var result = bookValidator.Validate(book);
if (result.Errors.Count > 0)
{
throw new ValidationException(result.Errors);
}
}
/// <summary>
/// Tells if book is newer.
/// </summary>
/// <param name="bookToCheck">Book to check.</param>
/// <returns>True if book is published later than in given year.</returns>
/// <exception cref="ArgumentException">Thrown if book to check is null.</exception>
public bool IsMatch(Book bookToCheck)
{
BookValidator.CheckOnNull(bookToCheck);
if (bookToCheck.PublicationYear > this.year)
{
return(true);
}
return(false);
}
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 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 <IActionResult> Create([FromBody] Book book)
{
var validator = new BookValidator();
var brokenRules = validator.GetBrokenRules(book);
if (brokenRules.Any())
{
return(BadRequest(brokenRules.Select(b => b.Rule)));
}
await _applicationService.Add(book);
return(CreatedAtRoute(nameof(GetById), book.Id));
}
public void SecondIsBookNameInLibraryTest()
{
BookValidator bookValidator = new BookValidator();
bool expected = false;
string bookName = "Star book";
List <Book> books = new List <Book>
{
new Book("Book about nothing", "Richards", "9994443332221"),
new Book("Lord of the rings", "tolkien", "1111222233334")
};
var actual = bookValidator.IsBookNameInBooks(bookName, books);
Assert.AreEqual(expected, actual);
}
public Form1()
{
_bookService = new BookService();
_cartService = new CartService();
_genreService = new GenreService();
_bookValidator = new BookValidator();
_pageNumber = 1;
_messages = new List <string>();
_rowsPerPage = 20;
_genreId = (long?)null;
_name = "";
InitializeComponent();
}
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 long Create(Book book)
{
long pulledDownNumber = 0;
var bookValidator = new BookValidator(book);
book.PulledDownNumber = GenerateNextPulledDownNumber();
if (bookValidator.IsValid())
{
_bookRepository.Create(book);
pulledDownNumber = book.PulledDownNumber;
}
return(pulledDownNumber);
}
public void FirstIsBookInAvailableBooksTest()
{
BookValidator bookValidator = new BookValidator();
bool expected = true;
string bookName = "Star book";
List <Book> books = new List <Book>
{
new Book("Book about nothing", "Richards", "9994443332221"),
new Book("Star book", "galikowski", "1234567891111"),
new Book("Lord of the rings", "tolkien", "1111222233334")
};
var actual = bookValidator.IsBookNameInAvailableBooks(bookName, books);
Assert.AreEqual(expected, actual);
}
protected static void WithService(Action <BookService> func, string type = null)
{
Utils.WithTestDatabase((uow) =>
{
var mapper = AutoMapperConfig.CreateMapper((cfg) => cfg.AddProfile(new MappingProfile()));
var config = new ConfigurationBuilder().Build();
var validator = new BookValidator();
TestService service;
service = type switch
{
"TestCallbackService" => new TestCallbackService(uow, mapper, validator),
_ => new TestService(uow, mapper, validator),
};
service.Repo.DeleteAll();
func(service);
});
}
public async Task <Payload <Book> > AddBookAsync(
AddBookInput input,
[Service] IGetClaimsProvider claimsProvider,
[ScopedService] BookRefDbContext context)
{
var book = new Book(input.Identifier, input.Title, claimsProvider.Username)
{
Subtitle = input.Subtitle
};
var validationResult = new BookValidator().Validate(book);
if (!validationResult.IsValid)
{
return(new Payload <Book>(BuildErrorList(validationResult.Errors)));
}
context.Books.Add(book);
await context.SaveChangesAsync();
return(new Payload <Book>(book));
}
public void SecondIsBookInAvailableBooksTest()
{
BookValidator bookValidator = new BookValidator();
bool expected = false;
string bookName = "Star book";
List <Book> books = new List <Book>
{
new Book("Book about nothing", "Richards", "9994443332221"),
new Book("Star book", "galikowski", "1234567891111"),
new Book("Lord of the rings", "tolkien", "1111222233334")
};
books.First(x => (x.BookName == bookName));
foreach (var item in books.Where(x => (x.BookName == bookName)))
{
item.IdPerson = 1;
}
var actual = bookValidator.IsBookNameInAvailableBooks(bookName, books);
Assert.AreEqual(expected, actual);
}
public object Put(BookModels request)
{
ValidationResult validations = new BookValidator().Validate(request);
if (!validations.IsValid)
{
return(validations.Errors);
}
request.Description = HttpContext.Current.Server.HtmlEncode(request.Description);
if (request.CategoryId <= 0)
{
request.CategoryId = LookupRepository.Insert(new CategoryModels
{
Name = request.CategoryText,
SortOrder = 0
});
}
BookRepository.Update(request);
return(request.Id);
}
public BookService(IBookRepository bookRepository)
{
_bookRepository = bookRepository;
_validator = new BookValidator();
}
public void Setup()
{
bookValidator = new BookValidator();
}
public object Post(BookModels request)
{
ValidationResult validations = new BookValidator().Validate(request);
if (!validations.IsValid)
{
request.ResponseResult.ResultStatus = ResultStatuses.Error;
foreach (var item in validations.Errors)
{
request.ResponseResult.Messages.Add(item.ErrorMessage);
}
return request;
}
if (request.InsertMode)
{
if (request.UserId <= 0)
{
var userAuth = this.GetSession();
request.UserId = userAuth.Id.To<int>();
}
}
request.Description = HttpContext.Current.Server.HtmlEncode(request.Description);
if (request.Description.Length > 1500)
{
request.Description = request.Description.Substring(0, 1500);
}
if (request.CategoryId <= 0)
{
request.CategoryId = LookupRepository.Insert(new CategoryModels
{
Name = request.CategoryText,
SortOrder = 0
});
}
if (request.Id > 0)
{
BookRepository.Update(request);
}
else
{
BookRepository.Insert(request);
}
var liveMode = ServiceStack.Configuration.ConfigUtils.GetAppSetting("AppMode");
if (request.InsertMode && liveMode.Equals("Live", StringComparison.InvariantCultureIgnoreCase))
{
// send a notification email
EmailService.SendSmtpEmail(new EmailServiceModels
{
Subject = "A New Book has been submitted and Needs your attention",
To = new List<string>() { "*****@*****.**", "*****@*****.**", "*****@*****.**" },
IsBodyHtml = false,
Body = string.Format("{0} has uploaded a book named {1}. You will need to upload the book to gumroad.", request.Author, request.Title),
Attachments = new List<string>() { string.Format("C:\\websites\\{0}", request.BookUrl) }
});
}
return null;
}
public BookController(IBookContainersDAL ibookContainerDAL)
{
bookValidator = new BookValidator();
bookContainer = new BookContainer(ibookContainerDAL);
}
/// <summary>
/// Method that returns the result of comparison of years.
/// </summary>
/// <param name="firstBook">First book.</param>
/// <param name="secondBook">Second book.</param>
/// <returns>Returns 0 of publication years are the same.
/// Returns 1 if first book was published earlier than second. Otherwise it returns -1.</returns>
public int Compare(Book firstBook, Book secondBook)
{
BookValidator.CheckOnNull(firstBook);
BookValidator.CheckOnNull(secondBook);
return(secondBook.AmountOfPages - firstBook.AmountOfPages);
}
public object Put(BookModels request)
{
ValidationResult validations = new BookValidator().Validate(request);
if (!validations.IsValid)
{
return validations.Errors;
}
request.Description = HttpContext.Current.Server.HtmlEncode(request.Description);
if (request.CategoryId <= 0)
{
request.CategoryId = LookupRepository.Insert(new CategoryModels
{
Name = request.CategoryText,
SortOrder = 0
});
}
BookRepository.Update(request);
return request.Id;
}
