public void Adds_valid_entities_to_repositories()
{
friendlyUrlGen.Expect(x => x.GenerateUrl(Arg<string>.Is.Anything, Arg<string[]>.Is.Anything)).Return("aaaa").
Repeat.
Any();
var blogValidator = new BlogValidator();
var postValidator = new PostValidator();
var userValidator = new UserValidator();
blogRP.Expect(x => x.SaveBlog(Arg<Blog>.Is.Anything))
.Do(new Expect<Blog>(blogValidator.ValidateAndThrowException));
userRP.Expect(x => x.SaveUser(Arg<User>.Is.Anything))
.Do(new Expect<User>(userValidator.ValidateAndThrowException));
postRP.Expect(x => x.SavePost(Arg<Post>.Is.Anything))
.Do(new Expect<Post>(postValidator.ValidateAndThrowException));
var installer = new DefaultStartupInstaller(blogRP, postRP, userRP, friendlyUrlGen);
installer.Execute();
}
public SeriesModule(ICommandExecutor commandExecutor,
ISeriesService seriesService,
ISeriesStatisticsService seriesStatisticsService,
ISceneMappingService sceneMappingService,
IMapCoversToLocal coverMapper,
RootFolderValidator rootFolderValidator,
PathExistsValidator pathExistsValidator,
SeriesPathValidator seriesPathValidator,
SeriesExistsValidator seriesExistsValidator,
DroneFactoryValidator droneFactoryValidator
)
: base(commandExecutor)
{
_commandExecutor = commandExecutor;
_seriesService = seriesService;
_seriesStatisticsService = seriesStatisticsService;
_sceneMappingService = sceneMappingService;
_coverMapper = coverMapper;
GetResourceAll = AllSeries;
GetResourceById = GetSeries;
CreateResource = AddSeries;
UpdateResource = UpdateSeries;
DeleteResource = DeleteSeries;
SharedValidator.RuleFor(s => s.QualityProfileId).ValidId();
PutValidator.RuleFor(s => s.Path)
.Cascade(CascadeMode.StopOnFirstFailure)
.IsValidPath()
.SetValidator(rootFolderValidator)
.SetValidator(seriesPathValidator)
.SetValidator(droneFactoryValidator);
PostValidator.RuleFor(s => s.Path).IsValidPath().When(s => String.IsNullOrEmpty(s.RootFolderPath));
PostValidator.RuleFor(s => s.RootFolderPath).IsValidPath().When(s => String.IsNullOrEmpty(s.Path));
PostValidator.RuleFor(s => s.Title).NotEmpty();
PostValidator.RuleFor(s => s.TvdbId).GreaterThan(0).SetValidator(seriesExistsValidator);
}
protected void Page_Load(object sender, EventArgs e)
{
if (Page.IsPostBack)
{
PostValidator validator = new PostValidator();
Post entity = new Post()
{
// Map form fields to entity properties
Id = Convert.ToInt32(PostId.Value),
Title = PostTitle.Text.Trim(),
Body = PostBody.Text.Trim()
};
ValidationResult results = validator.Validate(entity);
if (results.IsValid)
{
// Save to the database and continue to the next page
}
else
{
BulletedList summary = (BulletedList)FindControl("ErrorSummary");
// Display errors to the user
foreach (var failure in results.Errors)
{
Label errorMessage = FindControl(failure.PropertyName + "Error") as Label;
if (errorMessage == null)
{
summary.Items.Add(new ListItem(failure.ErrorMessage));
}
else
{
errorMessage.Text = failure.ErrorMessage;
}
}
}
}
else
{
// Display form
}
}
static void Main()
{
IValidator <Post> valPost = new PostValidator();
IValidator <Task> valTask = new TaskValidator();
//PostsRepository repoPosts = new PostsRepository(valPost);
FilePostsRepository repoPosts = new FilePostsRepository(valPost, "D:/faculta/semIII/2_map/c#/PostsAndTasksApp/PostsAndTasksApp/Files/posts.txt");
FileTasksRepository repoTasks = new FileTasksRepository(valTask, "D:/faculta/semIII/2_map/c#/PostsAndTasksApp/PostsAndTasksApp/Files/tasks.txt");
JobDescriptionRepository repoJobDescription = new JobDescriptionRepository();
PostsService servicePosts = new PostsService(repoPosts);
TasksService serviceTasks = new TasksService(repoTasks);
JobDescriptionService serviceJobDescription = new JobDescriptionService(servicePosts, serviceTasks, repoJobDescription);
PostsController ctrlPosts = new PostsController(valPost, servicePosts);
TasksController ctrlTasks = new TasksController(valTask, serviceTasks);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
PositionsWin view = new PositionsWin(ctrlPosts, ctrlTasks, serviceJobDescription);
Application.Run(view);
}
protected ProviderModuleBase(IProviderFactory <TProvider, TProviderDefinition> providerFactory, string resource)
: base(resource)
{
_providerFactory = providerFactory;
Get("schema", x => GetTemplates());
Post("test", x => Test(ReadResourceFromRequest(true)));
Post("action/{action}", x => RequestAction(x.action, ReadResourceFromRequest(true)));
GetResourceAll = GetAll;
GetResourceById = GetProviderById;
CreateResource = CreateProvider;
UpdateResource = UpdateProvider;
DeleteResource = DeleteProvider;
SharedValidator.RuleFor(c => c.Name).NotEmpty();
SharedValidator.RuleFor(c => c.Name).Must((v, c) => !_providerFactory.All().Any(p => p.Name == c && p.Id != v.Id)).WithMessage("Should be unique");
SharedValidator.RuleFor(c => c.Implementation).NotEmpty();
SharedValidator.RuleFor(c => c.ConfigContract).NotEmpty();
PostValidator.RuleFor(c => c.Fields).NotNull();
}
public IActionResult CreatePost(string title, string content, Guid topicId, Guid userId)
{
var topic = getByIdTopicUseCase.GetById(topicId);
if (topic == null && getByIdUserUseCase.GetById(userId) == null)
{
return(BadRequest());
}
var user = getByIdUserUseCase.GetById(userId);
string author = user.Name;
var post = new Domain.Entities.Post(title, content, topic, user);
var validationResult = new PostValidator().Validate(post);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
addPostUseCase.Add(post);
return(new OkObjectResult(post));
}
public ReleaseModule(IFetchAndParseRss rssFetcherAndParser,
ISearchForNzb nzbSearchService,
IMakeDownloadDecision downloadDecisionMaker,
IPrioritizeDownloadDecision prioritizeDownloadDecision,
IDownloadService downloadService,
ICacheManager cacheManager,
Logger logger)
{
_rssFetcherAndParser = rssFetcherAndParser;
_nzbSearchService = nzbSearchService;
_downloadDecisionMaker = downloadDecisionMaker;
_prioritizeDownloadDecision = prioritizeDownloadDecision;
_downloadService = downloadService;
_logger = logger;
GetResourceAll = GetReleases;
Post["/"] = x => DownloadRelease(this.Bind <ReleaseResource>());
PostValidator.RuleFor(s => s.DownloadAllowed).Equal(true);
PostValidator.RuleFor(s => s.Guid).NotEmpty();
_remoteEpisodeCache = cacheManager.GetCache <RemoteEpisode>(GetType(), "remoteEpisodes");
}
public ReleaseModule(IFetchAndParseRss rssFetcherAndParser,
ISearchForNzb nzbSearchService,
IMakeDownloadDecision downloadDecisionMaker,
IPrioritizeDownloadDecision prioritizeDownloadDecision,
IDownloadService downloadService,
ICacheManager cacheManager,
Logger logger)
{
_rssFetcherAndParser = rssFetcherAndParser;
_nzbSearchService = nzbSearchService;
_downloadDecisionMaker = downloadDecisionMaker;
_prioritizeDownloadDecision = prioritizeDownloadDecision;
_downloadService = downloadService;
_logger = logger;
GetResourceAll = GetReleases;
Post("/", x => DownloadRelease(ReadResourceFromRequest()));
PostValidator.RuleFor(s => s.IndexerId).ValidId();
PostValidator.RuleFor(s => s.Guid).NotEmpty();
_remoteBookCache = cacheManager.GetCache <RemoteBook>(GetType(), "remoteBooks");
}
public ReleaseController(IFetchAndParseRss rssFetcherAndParser,
ISearchForReleases releaseSearchService,
IMakeDownloadDecision downloadDecisionMaker,
IPrioritizeDownloadDecision prioritizeDownloadDecision,
IDownloadService downloadService,
IMovieService movieService,
ICacheManager cacheManager,
IProfileService qualityProfileService,
Logger logger)
: base(qualityProfileService)
{
_rssFetcherAndParser = rssFetcherAndParser;
_releaseSearchService = releaseSearchService;
_downloadDecisionMaker = downloadDecisionMaker;
_prioritizeDownloadDecision = prioritizeDownloadDecision;
_downloadService = downloadService;
_movieService = movieService;
_logger = logger;
PostValidator.RuleFor(s => s.IndexerId).ValidId();
PostValidator.RuleFor(s => s.Guid).NotEmpty();
_remoteMovieCache = cacheManager.GetCache <RemoteMovie>(GetType(), "remoteMovies");
}
public IActionResult AddWithCustomeValidationResponse()
{
PostValidator validator = new PostValidator();
List <string> ValidationMessages = new List <string>();
var tester = new Post
{
Title = "Ok",
Description = "",
CreatedBy = "1",
};
var validationResult = validator.Validate(tester);
var response = new ResponseModel();
if (!validationResult.IsValid)
{
response.IsValid = false;
foreach (ValidationFailure failure in validationResult.Errors)
{
ValidationMessages.Add(failure.ErrorMessage);
}
response.ValidationMessages = ValidationMessages;
}
return(Ok(response));
}
public BookController(IAuthorService authorService,
IBookService bookService,
IAddBookService addBookService,
IEditionService editionService,
ISeriesBookLinkService seriesBookLinkService,
IAuthorStatisticsService authorStatisticsService,
IMapCoversToLocal coverMapper,
IUpgradableSpecification upgradableSpecification,
IBroadcastSignalRMessage signalRBroadcaster,
QualityProfileExistsValidator qualityProfileExistsValidator,
MetadataProfileExistsValidator metadataProfileExistsValidator)
: base(bookService, seriesBookLinkService, authorStatisticsService, coverMapper, upgradableSpecification, signalRBroadcaster)
{
_authorService = authorService;
_editionService = editionService;
_addBookService = addBookService;
PostValidator.RuleFor(s => s.ForeignBookId).NotEmpty();
PostValidator.RuleFor(s => s.Author.QualityProfileId).SetValidator(qualityProfileExistsValidator);
PostValidator.RuleFor(s => s.Author.MetadataProfileId).SetValidator(metadataProfileExistsValidator);
PostValidator.RuleFor(s => s.Author.RootFolderPath).IsValidPath().When(s => s.Author.Path.IsNullOrWhiteSpace());
PostValidator.RuleFor(s => s.Author.ForeignAuthorId).NotEmpty();
}
protected TResource ReadResourceFromRequest(bool skipValidate = false)
{
var resource = new TResource();
try
{
resource = Request.Body.FromJson <TResource>();
}
catch (JsonReaderException ex)
{
throw new BadRequestException(ex.Message);
}
if (resource == null)
{
throw new BadRequestException("Request body can't be empty");
}
var errors = SharedValidator.Validate(resource).Errors.ToList();
if (Request.Method.Equals("POST", StringComparison.InvariantCultureIgnoreCase) && !skipValidate && !Request.Url.Path.EndsWith("/test", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PostValidator.Validate(resource).Errors);
}
else if (Request.Method.Equals("PUT", StringComparison.InvariantCultureIgnoreCase))
{
errors.AddRange(PutValidator.Validate(resource).Errors);
}
if (errors.Any())
{
throw new ValidationException(errors);
}
return(resource);
}
public async Task <ActionResult <BoardDTO> > PostPost(string boardName, int threadId, [FromBody] CreatePostDTO post)
{
var result = new PostValidator().Validate(post);
if (!result.IsValid)
{
return(BadRequest(result.Errors));
}
if (!User.Identity.IsAuthenticated)
{
await CreateUser();
}
var postPost = new PostDTO()
{
Content = post.Content, Image = post.Image
};
postPost.UserIdentifier = User.FindFirst(ClaimTypes.NameIdentifier).Value;
postPost.ThreadId = threadId;
if (!string.IsNullOrEmpty(postPost.Image))
{
if (await _imageService.IsImageUniqueToThread(postPost.Image, boardName, threadId))
{
postPost = _imageService.SaveImage(postPost);
}
else
{
return(BadRequest("Duplicate Image Detected"));
}
}
return(await _postService.PostPost(boardName, threadId, postPost));
}
public override ValidationResult Validate()
{
var validation = new PostValidator();
return(validation.Validate(this));
}
public async Task<GenericOperationResult<bool>> AddPost(PostDto postDto, string host)
{
//Validate model
var result = new GenericOperationResult<bool>();
var postValidator = new PostValidator();
var res = postValidator.Validate(postDto);
if (res.IsValid)
{
try
{
int userId = int.Parse(httpContext.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier));
if (postDto.Image != null)
{
var path = await uploadFile.UploadImage(postDto.Image, host);
if (path != null)
{
postDto.ImageUrl = path;
}
else
{
result.Messages.Add("Invalid image type");
result.Status = OperationResultStatusEnum.Exception;
return result;
}
}
Post createPost = MapPost(postDto);
createPost.UserId = userId;
unitOfWork.PostRepository.Create(createPost);
if (unitOfWork.SaveChanges())
{
result.Data = true;
result.Messages.Add("your post has been added ");
result.Status = OperationResultStatusEnum.Succeeded;
return result;
}
else
{
result.Data = false;
result.Messages.Add("Sorry your post couldn't be uploaded try again!!");
result.Status = OperationResultStatusEnum.Failed;
return result;
}
}
catch (NullReferenceException nullEx)
{
throw new BusinessException("Null Refrence exception", nullEx);
}
catch (IndexOutOfRangeException outOfRangeEx)
{
throw new BusinessException("Out of range exception exception", outOfRangeEx);
}
catch (SqlException sqlEx)
{
throw new BusinessException("Sql Exception exception", sqlEx);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Data = false;
result.Messages = res.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Failed;
return result;
}
/// <summary>
/// Method to validate model
/// </summary>
/// <returns>Returns the result of validation</returns>
protected override FluentValidation.Results.ValidationResult Validate()
{
var validator = new PostValidator();
return(validator.Validate(this));
}
public NetImportModule(NetImportFactory netImportFactory) : base(netImportFactory, "netimport")
{
PostValidator.RuleFor(c => c.RootFolderPath).IsValidPath();
PostValidator.RuleFor(c => c.MinimumAvailability).NotNull();
PostValidator.RuleFor(c => c.ProfileId).NotNull();
}
public PostControl()
{
_postRepository = new PostRepository();
_validator = new PostValidator();
}
public PostValidatorTest()
{
_validator = new PostValidator();
}
public void Setup()
{
validator = new PostValidator();
}
public void CanSaveAllEntities()
{
using (var session = factory.OpenSession())
{
using (var tran = session.BeginTransaction())
{
var blog = new Blog();
var user = new User();
var post = new Post();
var tag = new Tag();
var postComment = new PostComment();
var configuration = new BlogConfiguration();
configuration.PageSize = 3;
configuration["osman"] = "mahmut";
user.UserName = "******";
user.Password = "******";
user.Email = "*****@*****.**";
user.Blogs.Add(blog);
blog.Configuration = configuration;
blog.Writers.Add(user);
blog.Title = "my blog";
blog.Name = "My Blog";
blog.Founder = user;
blog.Posts.Add(post);
blog.Host = "localhost";
post.Blog = blog;
post.Content = "hello";
post.Publisher = user;
post.DateCreated = DateTime.Now;
post.DatePublished = DateTime.Now.AddMinutes(3);
post.Title = "post title";
post.FriendlyTitle = post.Title.Replace(' ', '_').ToLower();
post.AddComment(postComment, null);
postComment.Post = post;
postComment.Date = DateTime.Now.AddMinutes(6);
postComment.Email = "*****@*****.**";
postComment.Name = "Some One";
postComment.Comment = "Some One wrote here!!";
tag.Name = "Tag";
tag.FriendlyName = "Tagged";
tag.Posts.Add(post);
post.Tags.Add(tag);
var blogVal = new BlogValidator();
blogVal.ValidateAndThrowException(blog);
var postVal = new PostValidator();
postVal.ValidateAndThrowException(post);
var postCommVal = new PostCommentValidator();
postCommVal.ValidateAndThrowException(postComment);
var userVal = new UserValidator();
userVal.ValidateAndThrowException(user);
var tagVal = new TagValidator();
tagVal.ValidateAndThrowException(tag);
session.Save(user);
session.Save(blog);
session.Save(post);
session.Save(postComment);
session.Save(tag);
tran.Commit();
}
}
using (var session = factory.OpenSession())
{
var item = session.CreateCriteria(typeof (Blog)).UniqueResult<Blog>();
var pageSize = item.Configuration.PageSize;
Assert.That(pageSize, Is.EqualTo(3));
}
}
