public HttpStatusCode Update([FromBody] Category category)
{
var validationResult = new CategoryValidator(ValidateFor.Update).Validate(category);
if (!validationResult.IsValid)
{
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "Data is invalid",
Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors))
});
}
using (var session = Raven.Instance.Store.OpenSession())
{
var cat = session.Load <Category>(category.Id);
if (cat == null)
{
return(HttpStatusCode.NotFound);
}
cat.Name = category.Name;
session.SaveChanges();
return(HttpStatusCode.OK);
}
}
private void ValidateCategoryProperties(IEnumerable <Category> categories)
{
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
//Validate categories
var validator = new CategoryValidator();
foreach (var category in categories)
{
validator.ValidateAndThrow(category);
}
var groups = categories.GroupBy(x => x.CatalogId);
foreach (var group in groups)
{
LoadDependencies(group, PreloadCategories(group.Key));
ApplyInheritanceRules(group);
foreach (var category in group)
{
var validatioResult = _hasPropertyValidator.Validate(category);
if (!validatioResult.IsValid)
{
throw new Exception($"Category properties has validation error: {string.Join(Environment.NewLine, validatioResult.Errors.Select(x => x.ToString()))}");
}
}
}
}
public MovieImportService()
{
this.categoryService = new CategoryService();
this.categoryValidator = new CategoryValidator(categoryService);
this.movieService = new MovieService();
this.movieValidator = new MovieValidator(movieService);
}
public static void ImportMovie(MovieDTO movieDto)
{
string movieName = movieDto.Name;
InputDataValidator.ValidateStringMaxLength(movieName, Constants.MaxMovieNameLength);
float?rating = movieDto.Rating;
InputDataValidator.ValidateFloatInRange(rating, Constants.MinRatingValue, Constants.MaxRatingValue);
int releaseYear = movieDto.ReleaseYear;
MovieValidator.ValidateMovieDoesNotExist(movieName, releaseYear);
List <string> categories = movieDto.Categories.Select(c => c.Name).ToList();
CategoryValidator.CheckCategoriesExist(categories);
string directorName = movieDto.DirectorName;
int length = movieDto.Length;
AgeRestriction ageRestriction = (AgeRestriction)Enum.Parse(typeof(AgeRestriction), movieDto.AgeRestriction);
string synopsis = movieDto.Synopsis;
string releaseCountry = movieDto.ReleaseCountry;
byte[] image = movieDto.Image;
MovieService.AddMovie(movieName, rating, length, directorName, releaseYear, ageRestriction, synopsis,
releaseCountry, image);
MovieImportService.AddCategoriesToMovie(movieName, releaseYear, categories);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.MoviesAddedSuccess, movieName));
}
public CategoryManagerTest()
{
var testRepo = new TestCategoryRepository();
var validator = new CategoryValidator();
_mng = new CategoryManager(testRepo, validator);
}
public void ReturnCategory_WhenValidUser_CallsUpdateCategory()
{
var updatedCategory = new Category
{
Id = 1,
UserId = 1,
Description = "Test",
Code = "test"
};
var result = new Category
{
Id = updatedCategory.Id
};
var userHelper = A.Fake <IUserHelper>();
A.CallTo(() => userHelper.MatchingUsers(A <HttpContext> .Ignored, updatedCategory.UserId)).Returns(true);
var categoryRepository = A.Fake <ICategoryRepository>();
A.CallTo(() => categoryRepository.CategoryExists(updatedCategory.Id)).Returns(true);
A.CallTo(() => categoryRepository.GetCategory(updatedCategory.Id)).Returns(result);
var validator = new CategoryValidator();
var controller = new CategoriesController(categoryRepository, null, userHelper, validator);
var response = controller.UpdateCategory(updatedCategory);
A.CallTo(() => categoryRepository.Update(updatedCategory)).MustHaveHappened();
Assert.AreEqual(result.Id, response.Value.Id);
}
public void ReturnCategory_OnCallToAddCategory()
{
var newCategory = new Category
{
Description = "Test",
Code = "test"
};
var result = new Category
{
UserId = newCategory.UserId
};
var userHelper = A.Fake <IUserHelper>();
var categoryRepository = A.Fake <ICategoryRepository>();
A.CallTo(() => categoryRepository.GetCategory(A <int> .Ignored)).Returns(result);
var validator = new CategoryValidator();
var controller = new CategoriesController(categoryRepository, null, userHelper, validator);
var response = controller.AddCategory(newCategory);
A.CallTo(() => categoryRepository.Add(newCategory)).MustHaveHappened();
Assert.AreEqual(result.UserId, response.Value.UserId);
}
public void ReturnBadRequest_WhenCategoryDoesNotExist_OnCallToUpdateCategory()
{
var updatedCategory = new Category
{
Id = 1,
UserId = 1,
Description = "Test",
Code = "test"
};
var userHelper = A.Fake <IUserHelper>();
A.CallTo(() => userHelper.MatchingUsers(A <HttpContext> .Ignored, updatedCategory.UserId)).Returns(true);
var categoryRepository = A.Fake <ICategoryRepository>();
A.CallTo(() => categoryRepository.CategoryExists(updatedCategory.Id)).Returns(false);
var validator = new CategoryValidator();
var controller = new CategoriesController(categoryRepository, null, userHelper, validator);
var response = controller.UpdateCategory(updatedCategory);
Assert.AreEqual((int)HttpStatusCode.BadRequest, ((BadRequestObjectResult)response.Result).StatusCode);
Assert.AreEqual($"Category with Id {updatedCategory.Id} does not exist.", ((BadRequestObjectResult)response.Result).Value);
}
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
var validator = new CategoryValidator();
var result = validator.Validate(this);
return(result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName })));
}
public ActionResult AddCategory(Category p)
{
CategoryValidator categoryValidator = new CategoryValidator();
ValidationResult results = categoryValidator.Validate(p);
if (results.IsValid)
{
cm.CategoryAdd(p);
return(RedirectToAction("GetCatgoryList"));
}
else
{
foreach (var item in results.Errors)
{
ModelState.AddModelError(item.PropertyName, item.ErrorMessage);
}
}
return(View());
////cm.CategoryAddBL(p);
return(RedirectToAction("GetCatgoryList"));
{
}
}
public Categories1Controller()
{
IRepository <Category, int> repo = new CategoryRepository();
IValidator validator = new CategoryValidator();
_mng = new CategoryManager(repo, validator);
}
private async Task CorrectFlow()
{
Category = Builder <Category>
.CreateNew()
.Build();
await CategoryValidator.SetValidatorSuccess();
}
public AddCategoryViewModel()
{
_categoryValidator = new CategoryValidator();
_category = new Category();
_categoryRepository = new CategoryRepository();
AddCategoryCommand = new Command(async() => await AddCategory());
}
public DeleteCategoryService(
IDefaultDbContext context,
CategoryValidator entityValidator,
DeleteCategorySpecificationsValidator domainValidator
) : base(entityValidator, domainValidator)
{
Context = context;
}
public Category(string name, decimal discount)
{
Name = name;
Discount = discount;
var validator = new CategoryValidator();
validator.ValidateAndThrow(this);
}
private void CategoryValidation(Category category)
{
CategoryValidator categoryValidator = new CategoryValidator();
var result = categoryValidator.Validate(category);
if (result.Errors.Count > 0)
{
throw new ValidationException(result.Errors);
}
}
public static void ImportCategory(CategoryDTО categoryDtо)
{
string categoryName = categoryDtо.Name;
InputDataValidator.ValidateStringMaxLength(categoryName, Constants.MaxCategoryNameLength);
CategoryValidator.ValidateCategoryDoesNotExist(categoryName);
CategoryService.AddCategory(categoryName);
Console.WriteLine(string.Format(Constants.ImportSuccessMessages.CategoryAddedSuccess, categoryName));
}
public static Category mapModel(Category oldCategory, Category newCategory)
{
if (!CategoryValidator.validateCategory(newCategory))
{
return(null);
}
oldCategory.IDCategory = newCategory.IDCategory;
oldCategory.Name = newCategory.Name;
oldCategory.Description = newCategory.Description;
return(oldCategory);
}
public void CanValidateNameChangedAndNotExists()
{
_methodProvider.Setup(p => p.GetMethodUpperName()).Returns("PUT");
_categoryValidator = new CategoryValidator(_validationService.Object, _methodProvider.Object);
var result = _categoryValidator.TestValidate(new CategoryDto
{
Id = _categories[1].Id,
Name = "Food"
});
result.ShouldHaveValidationErrorFor(c => c.Name);
}
public void CanValidateIdExists()
{
_methodProvider.Setup(p => p.GetMethodUpperName()).Returns("PUT");
_categoryValidator = new CategoryValidator(_validationService.Object, _methodProvider.Object);
var result = _categoryValidator.TestValidate(new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Beauty"
});
result.ShouldHaveValidationErrorFor(c => c.Id);
}
public async Task Return_Success_When_Category_Is_Updated()
{
//Arrange
var logic = Create();
//Act
var result = await logic.Update(Category);
//Assert
result.Should()
.BeSuccess(Category);
CategoryValidator.Verify(v => v.ValidateAsync(Category, It.IsAny <CancellationToken>()), Times.Once);
Repository.Verify(r => r.SaveChanges(), Times.Once);
}
/*[Authorize("Bearer")]*/
public IActionResult CreateCategory(string name)
{
var category = new Domain.Entities.Category(name);
var validationResult = new CategoryValidator().Validate(category);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
addCategoryUseCase.Add(category);
return(new OkObjectResult(category));
}
public void AddCategoryToXML(String categoryName) //method to add a new category to the XML file
{
CategoryValidator validator = new CategoryValidator();
validator.Validate(categoryName, "category");
String path = (Environment.CurrentDirectory + "/categories.xml");
var serializer = new XmlSerializer(typeof(List <Category>));
using (var stream = new StreamWriter("categories.xml"))
{
Category category = new Category(categoryName);
CategoryList.Add(category);
serializer.Serialize(stream, CategoryList);
}
}
public CategoryDetailsViewModel(int selectedCategoryId)
{
_categoryValidator = new CategoryValidator();
_category = new Category()
{
Id = selectedCategoryId
};
_categoryRepository = new CategoryRepository();
UpdateCategoryCommand = new Command(async() => await UpdateCategory());
DeleteCategoryCommand = new Command(async() => await DeleteCategory());
FetchCategoryDetails();
GetAllProducts();
}
public async Task <ResultResponse> Create(string title)
{
Category category = new Category(title);
CategoryValidator validations = new CategoryValidator();
ValidationResult resultValidator = validations.Validate(category);
ResultResponse resultResponse = new ResultResponse(resultValidator);
if (resultValidator.IsValid)
{
await _unitOfWork.categoryRepository.Create(category);
}
return(resultResponse);
}
public async Task <ActionResult <Transaction> > PostTransaction(Transaction transaction)
{
CategoryValidator validator = new CategoryValidator();
if (validator.CategoryIsValid(transaction))
{
_context.Transactions.Add(transaction);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTransaction", new { id = transaction.Id }, transaction));
}
string errorMessage = validator.Message(transaction.Direction);
return(BadRequest(new { error = errorMessage }));
}
public static void AddCategory(Categories categories)
{
CategoryValidator categoryValidator = new CategoryValidator();
var result = categoryValidator.Validate(categories);
if (result.Errors.Count > 0)
{
throw new ValidationException(result.Errors);
}
else
{
ReadWriteData.WriteDataTest <Categories>(categories, "category");
}
FactoryObject.SetCategory();
}
public async Task Return_Errors_When_Validation_Fails()
{
//Arrange
const string warning = "You cannot update Category";
var logic = Create();
await CategoryValidator.SetValidatorFailure(warning);
//Act
var result = await logic.Update(Category);
//Assert
result.Should()
.BeFailure(warning);
CategoryValidator.Verify(v => v.ValidateAsync(Category, It.IsAny <CancellationToken>()), Times.Once());
Repository.Verify(r => r.SaveChanges(), Times.Never);
}
public async Task <ResultResponse> Update(CategoryModelRequest request)
{
Category category = new Category(request.Title);
category.Id = request.Id;
CategoryValidator validations = new CategoryValidator();
ValidationResult resultValidator = validations.Validate(category);
ResultResponse resultResponse = new ResultResponse(resultValidator);
if (resultValidator.IsValid)
{
await _unitOfWork.categoryRepository.Update(category);
}
return(resultResponse);
}
public CategoryValidatorTests()
{
_validationService = new Mock <ICategoryValidationService>();
_methodProvider = new Mock <IMethodProvider>();
_categoryValidator = new CategoryValidator(_validationService.Object, _methodProvider.Object);
_categories = new List <CategoryDto>
{
new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Food"
},
new CategoryDto
{
Id = Guid.NewGuid(),
Name = "Sport"
}
};
_validationService.Setup(s => s.CategoryExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(_categories.Any(c => c.Id == id)));
_validationService.Setup(s => s.CategoryIdNotExistsAsync(It.IsAny <Guid>(), CancellationToken.None))
.Returns((Guid id, CancellationToken token) =>
Task.FromResult(_categories.All(c => c.Id != id)));
_validationService.Setup(s => s.CategoryNameNotExistsAsync(It.IsAny <string>(), CancellationToken.None))
.Returns((string name, CancellationToken token) =>
Task.FromResult(_categories.All(c => c.Name != name)));
_validationService.Setup(s => s.CategoryNameChangedAndNotExistsAsync(It.IsAny <Guid>(),
It.IsAny <string>(), CancellationToken.None))
.Returns((Guid id, string name, CancellationToken token) =>
{
var category = _categories.First(c => c.Id == id);
if (category.Name == name)
{
return(Task.FromResult(true));
}
return(Task.FromResult(_categories.All(c => c.Name != name)));
});
}
public HttpResponseMessage CreateCategory([FromBody]Category category)
{
var validationResult = new CategoryValidator(ValidateFor.Create).Validate(category);
if (!validationResult.IsValid)
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "Data is invalid",
Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors))
});
using (var session = Raven.Instance.Store.OpenSession())
{
session.Store(category);
session.SaveChanges();
var response = this.Request.CreateResponse<Category>(HttpStatusCode.Created, category);
return response;
}
}
public HttpStatusCode Update([FromBody]Category category)
{
var validationResult = new CategoryValidator(ValidateFor.Update).Validate(category);
if (!validationResult.IsValid)
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "Data is invalid",
Content = new StringContent(JsonConvert.SerializeObject(validationResult.Errors))
});
using (var session = Raven.Instance.Store.OpenSession())
{
var cat = session.Load<Category>(category.Id);
if (cat == null)
return HttpStatusCode.NotFound;
cat.Name = category.Name;
session.SaveChanges();
return HttpStatusCode.OK;
}
}
public CategoryService(ITransactionsProvider db)
{
this._db = db;
this._validator = new CategoryValidator();
}
public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
{
var validator = new CategoryValidator();
var result = validator.Validate(this);
return result.Errors.Select(item => new ValidationResult(item.ErrorMessage, new[] { item.PropertyName }));
}
public new void Setup()
{
_validator = new CategoryValidator(_localizationService, null);
}
