コード例 #1
0
 public TagLibParserFactory(TagLibForParsing lib, ExpressionLib expressionLib, IResourceLocatorFactory factory, ITagValidator tagValidator)
 {
     _lib           = lib;
     _expressionLib = expressionLib;
     _factory       = factory;
     _tagValidator  = tagValidator;
 }
コード例 #2
0
        public UploadTagAttachmentCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync((command, token) => BeAnExistingTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}")
            .MustAsync((command, token) => NotHaveAttachmentWithFilenameAsync(command.TagId, command.FileName, token))
            .WithMessage(command => $"Tag already has an attachment with filename {command.FileName}! Please rename file or choose to overwrite")
            .When(c => !c.OverwriteIfExists, ApplyConditionTo.CurrentValidator);

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);
            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);
            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);
            async Task <bool> NotHaveAttachmentWithFilenameAsync(int tagId, string fileName, CancellationToken token)
            => !await tagValidator.AttachmentWithFilenameExistsAsync(tagId, fileName, token);
        }
コード例 #3
0
        public DeleteTagCommandValidator(
            ITagValidator tagValidator,
            IRowVersionValidator rowVersionValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => BeAnExistingTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => BeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is not voided! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeInUse(command.TagId, token))
            .WithMessage(command => $"Tag is in use! Tag={command.TagId}")
            .Must(command => HaveAValidRowVersion(command.RowVersion))
            .WithMessage(command => $"Not a valid row version! Row version={command.RowVersion}");

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);
            async Task <bool> BeAVoidedTagAsync(int tagId, CancellationToken token)
            => await tagValidator.IsVoidedAsync(tagId, token);
            async Task <bool> NotBeInUse(int tagId, CancellationToken token)
            => !await tagValidator.IsInUseAsync(tagId, token);

            bool HaveAValidRowVersion(string rowVersion)
            => rowVersionValidator.IsValid(rowVersion);
        }
コード例 #4
0
        public PreserveCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync((command, token) => BeAnExistingTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAVoidedTag(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}")
            .MustAsync((command, token) => PreservationIsStartedAsync(command.TagId, token))
            .WithMessage(command => $"Tag must have status {PreservationStatus.Active} to preserve! Tag={command.TagId}")
            .MustAsync((command, token) => BeReadyToBePreservedAsync(command.TagId, token))
            .WithMessage(command => $"Tag is not ready to be preserved! Tag={command.TagId}");

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAVoidedTag(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> PreservationIsStartedAsync(int tagId, CancellationToken token)
            => await tagValidator.VerifyPreservationStatusAsync(tagId, PreservationStatus.Active, token);

            async Task <bool> BeReadyToBePreservedAsync(int tagId, CancellationToken token)
            => await tagValidator.IsReadyToBePreservedAsync(tagId, token);
        }
コード例 #5
0
 public TagLibParserFactory(TagLibForParsing lib, ExpressionLib expressionLib, IResourceLocatorFactory factory, ITagValidator tagValidator)
 {
     _lib = lib;
     _expressionLib = expressionLib;
     _factory = factory;
     _tagValidator = tagValidator;
 }
        public UpdateActionCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator,
            IActionValidator actionValidator,
            IRowVersionValidator rowVersionValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}")
            .MustAsync(BeAnExistingActionAsync)
            .WithMessage(command => "Tag and/or action doesn't exist!")
            .MustAsync((command, token) => NotBeAClosedActionAsync(command.ActionId, token))
            .WithMessage(command => $"Action is closed! Action={command.ActionId}")
            .Must(command => HaveAValidRowVersion(command.RowVersion))
            .WithMessage(command => $"Not a valid row version! Row version={command.RowVersion}");

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);
            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);
            async Task <bool> BeAnExistingActionAsync(UpdateActionCommand command, CancellationToken token)
            => await tagValidator.ExistsActionAsync(command.TagId, command.ActionId, token);
            async Task <bool> NotBeAClosedActionAsync(int actionId, CancellationToken token)
            => !await actionValidator.IsClosedAsync(actionId, token);

            bool HaveAValidRowVersion(string rowVersion)
            => rowVersionValidator.IsValid(rowVersion);
        }
        public DuplicateAreaTagCommandValidator(ITagValidator tagValidator, IProjectValidator projectValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project is closed! Tag={command.TagId}")
            .MustAsync((command, token) => BeAnExistingSourceTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAnExistingTagWithinProjectAsync(command.GetTagNo(), command.TagId, token))
            .WithMessage(command => $"Tag already exists in scope for project! Tag={command.GetTagNo()}")
            .MustAsync((command, token) => IsReadyToBeDuplicatedAsync(command.TagId, token))
            .WithMessage(command => $"Tag can not be duplicated! Tag={command.TagId}");

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);

            async Task <bool> BeAnExistingSourceTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAnExistingTagWithinProjectAsync(string tagNo, int tagId, CancellationToken token)
            => !await tagValidator.ExistsAsync(tagNo, tagId, token);

            async Task <bool> IsReadyToBeDuplicatedAsync(int tagId, CancellationToken token)
            => await tagValidator.IsReadyToBeDuplicatedAsync(tagId, token);
        }
コード例 #8
0
        public RescheduleCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator,
            IRowVersionValidator rowVersionValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command.Tags)
            .Must(ids => ids != null && ids.Any())
            .WithMessage("At least 1 tag must be given!")
            .Must(BeUniqueTags)
            .WithMessage("Tags must be unique!")
            .MustAsync(BeInSameProjectAsync)
            .WithMessage("Tags must be in same project!")
            .MustAsync(NotBeAClosedProjectForTagAsync)
            .WithMessage("Project is closed!");

            RuleFor(command => command.Weeks)
            .InclusiveBetween(1, MaxRescheduleWeeks)
            .WithMessage($"Rescheduling must be in range of 1 to {MaxRescheduleWeeks} week(s)!");

            When(command => command.Tags.Any() && BeUniqueTags(command.Tags), () =>
            {
                RuleForEach(command => command.Tags)
                .MustAsync((_, tag, __, token) => BeAnExistingTagAsync(tag.Id, token))
                .WithMessage((_, tag) => $"Tag doesn't exist! Tag={tag.Id}")
                .MustAsync((_, tag, __, token) => NotBeAVoidedTagAsync(tag.Id, token))
                .WithMessage((_, tag) => $"Tag is voided! Tag={tag.Id}")
                .MustAsync((_, tag, __, token) => IsReadyToBeRescheduledAsync(tag.Id, token))
                .WithMessage((_, tag) => $"Tag can not be rescheduled! Tag={tag.Id}")
                .Must(tag => HaveAValidRowVersion(tag.RowVersion))
                .WithMessage((_, tag) => $"Not a valid row version! Row version={tag.RowVersion}");
            });

            bool BeUniqueTags(IEnumerable <IdAndRowVersion> tags)
            {
                var ids = tags.Select(x => x.Id).ToList();

                return(ids.Distinct().Count() == ids.Count);
            }

            async Task <bool> BeInSameProjectAsync(IEnumerable <IdAndRowVersion> tags, CancellationToken token)
            => await projectValidator.AllTagsInSameProjectAsync(tags.Select(t => t.Id), token);

            async Task <bool> NotBeAClosedProjectForTagAsync(IEnumerable <IdAndRowVersion> tags, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tags.First().Id, token);

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> IsReadyToBeRescheduledAsync(int tagId, CancellationToken token)
            => await tagValidator.IsReadyToBeRescheduledAsync(tagId, token);

            bool HaveAValidRowVersion(string rowVersion)
            => rowVersionValidator.IsValid(rowVersion);
        }
コード例 #9
0
 public TaggedCollection(ITagValidator <TKey, TValue> validator)
 {
     if (validator == null)
     {
         throw new ArgumentNullException("validator");
     }
     _validator = validator;
 }
コード例 #10
0
 public AbstractTagLibParser(TagLibForParsing lib, ExpressionLib expressionLib, ParseHelper helper, IResourceLocator locator, IResourceLocatorFactory factory, ITagValidator tagValidator)
 {
     _lib           = lib;
     _expressionLib = expressionLib;
     _helper        = helper;
     _locator       = locator;
     _factory       = factory;
     _tagValidator  = tagValidator;
 }
コード例 #11
0
ファイル: LinkValidators.cs プロジェクト: grexican/isnsfw
 public CreateLinkRequestValidator(ILinkRepository linkRepo, ITagValidator tagValidator)
 {
     _linkRepo = linkRepo;
     RuleFor(m => m.Key).MustBeValidKey().When(request => !request.Key.IsNullOrEmpty());
     RuleFor(m => m.Url).NotEmpty();
     RuleFor(m => m.Url).MustBeAUrl().When(request => !request.Url.IsNullOrEmpty());
     RuleFor(m => m.Tags).NotEmpty().WithMessage("At least one tag is required.");
     RuleForEach(m => m.Tags).Must(tagValidator.ValidateTagExists).WithMessage(m => $"Tag '{m}' not found.");
 }
コード例 #12
0
 public AbstractTagLibParser(TagLibForParsing lib, ExpressionLib expressionLib, ParseHelper helper, IResourceLocator locator, IResourceLocatorFactory factory, ITagValidator tagValidator)
 {
     _lib = lib;
     _expressionLib = expressionLib;
     _helper = helper;
     _locator = locator;
     _factory = factory;
     _tagValidator = tagValidator;
 }
コード例 #13
0
 public CodeSnippetValidator(ILanguageValidator languageValidator, ITagValidator tagValidator)
 {
     this.RuleFor(x => x.Description).MaximumLength(CodeSnippet.DescriptionMaxLength);
     this.RuleFor(x => x.Description).NotEmpty().WithMessage(RequiredErrorMessage);
     // TODO: decide if we want to add validation logic for the largest size for Code sample (2 GBs).
     this.RuleFor(x => x.CodeSample).NotEmpty().WithMessage(RequiredErrorMessage);
     this.RuleFor(x => x.Language).NotNull().WithMessage("Please select a '{PropertyName}'.");
     this.RuleFor(x => x.Language).SetValidator(languageValidator).When(x => x.Language != null, ApplyConditionTo.CurrentValidator);
     this.RuleForEach(x => x.Tags).SetValidator(tagValidator).When(x => x.Tags != null, ApplyConditionTo.CurrentValidator);
 }
コード例 #14
0
        public BulkPreserveCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command.TagIds)
            .Must(ids => ids != null && ids.Any())
            .WithMessage("At least 1 tag must be given!")
            .Must(BeUniqueTags)
            .WithMessage("Tags must be unique!")
            .MustAsync(BeInSameProjectAsync)
            .WithMessage("Tags must be in same project!")
            .MustAsync(NotBeAClosedProjectForTagAsync)
            .WithMessage("Project is closed!");

            When(command => command.TagIds.Any() && BeUniqueTags(command.TagIds), () =>
            {
                RuleForEach(command => command.TagIds)
                .MustAsync((_, tagId, __, token) => BeAnExistingTagAsync(tagId, token))
                .WithMessage((_, id) => $"Tag doesn't exist! Tag={id}")
                .MustAsync((_, tagId, __, token) => NotBeAVoidedTagAsync(tagId, token))
                .WithMessage((_, id) => $"Tag is voided! Tag={id}")
                .MustAsync((_, tagId, __, token) => PreservationIsStartedAsync(tagId, token))
                .WithMessage((_, id) => $"Tag must have status {PreservationStatus.Active} to preserve! Tag={id}")
                .MustAsync((_, tagId, __, token) => BeReadyToBePreservedAsync(tagId, token))
                .WithMessage((_, id) => $"Tag is not ready to be bulk preserved! Tag={id}");
            });

            bool BeUniqueTags(IEnumerable <int> tagIds)
            {
                var ids = tagIds.ToList();

                return(ids.Distinct().Count() == ids.Count);
            }

            async Task <bool> BeInSameProjectAsync(IEnumerable <int> tagIds, CancellationToken token)
            => await projectValidator.AllTagsInSameProjectAsync(tagIds, token);

            async Task <bool> NotBeAClosedProjectForTagAsync(IEnumerable <int> tagIds, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagIds.First(), token);

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> PreservationIsStartedAsync(int tagId, CancellationToken token)
            => await tagValidator.VerifyPreservationStatusAsync(tagId, PreservationStatus.Active, token);

            async Task <bool> BeReadyToBePreservedAsync(int tagId, CancellationToken token)
            => await tagValidator.IsReadyToBePreservedAsync(tagId, token);
        }
        public StartPreservationCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command.TagIds)
            .Must(ids => ids != null && ids.Any())
            .WithMessage("At least 1 tag must be given!")
            .Must(BeUniqueTags)
            .WithMessage("Tags must be unique!")
            .MustAsync(BeInSameProjectAsync)
            .WithMessage("Tags must be in same project!")
            .MustAsync(NotBeAClosedProjectForTagAsync)
            .WithMessage("Project is closed!");

            When(command => command.TagIds.Any() && BeUniqueTags(command.TagIds), () =>
            {
                RuleForEach(command => command.TagIds)
                .MustAsync((_, tagId, __, token) => BeAnExistingTagAsync(tagId, token))
                .WithMessage((_, id) => $"Tag doesn't exist! Tag={id}")
                .MustAsync((_, tagId, __, token) => NotBeAVoidedTagAsync(tagId, token))
                .WithMessage((_, id) => $"Tag is voided! Tag={id}")
                .MustAsync((_, tagId, __, token) => IsReadyToBeStartedAsync(tagId, token))
                .WithMessage((_, id) => $"Preservation on tag can not be started! Tag={id}")
                .MustAsync((_, tagId, __, token) => HaveAtLeastOneNonVoidedRequirementAsync(tagId, token))
                .WithMessage((_, id) => $"Tag do not have any non voided requirement! Tag={id}");
            });

            bool BeUniqueTags(IEnumerable <int> tagIds)
            {
                var ids = tagIds.ToList();

                return(ids.Distinct().Count() == ids.Count);
            }

            async Task <bool> BeInSameProjectAsync(IEnumerable <int> tagIds, CancellationToken token)
            => await projectValidator.AllTagsInSameProjectAsync(tagIds, token);

            async Task <bool> NotBeAClosedProjectForTagAsync(IEnumerable <int> tagIds, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagIds.First(), token);

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> IsReadyToBeStartedAsync(int tagId, CancellationToken token)
            => await tagValidator.IsReadyToBeStartedAsync(tagId, token);

            async Task <bool> HaveAtLeastOneNonVoidedRequirementAsync(int tagId, CancellationToken token)
            => await tagValidator.HasANonVoidedRequirementAsync(tagId, token);
        }
コード例 #16
0
        public TagProvider([NotNull] ITagRepository tagRepository, [NotNull] ITagValidator tagValidator)
        {
            if (tagRepository == null)
            {
                throw new ArgumentNullException(nameof(tagRepository));
            }
            if (tagValidator == null)
            {
                throw new ArgumentNullException(nameof(tagValidator));
            }

            _tagRepository = tagRepository;
            _tagValidator  = tagValidator;
        }
        public UploadFieldValueAttachmentCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator,
            IFieldValidator fieldValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync(BeAnExistingRequirementAsync)
            .WithMessage(command => "Tag and/or requirement doesn't exist!")
            .MustAsync(BeAnExistingFieldForRequirementAsync)
            .WithMessage(command => "Field doesn't exist in requirement!")
            .MustAsync((command, token) => NotBeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}")
            .MustAsync((command, token) => HasRequirementWithActivePeriodAsync(command.TagId, command.RequirementId, token))
            .WithMessage(command =>
                         $"Tag doesn't have this requirement with active period! Tag={command.TagId}. Requirement={command.RequirementId}")
            .MustAsync((command, token) => BeAFieldForAttachmentAsync(command.FieldId, token))
            .WithMessage(command => $"Field values can not be recorded for field type! Field={command.FieldId}")
            .MustAsync((command, token) => NotBeAVoidedFieldAsync(command.FieldId, token))
            .WithMessage(command => $"Field is voided! Field={command.FieldId}");

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);

            async Task <bool> BeAnExistingRequirementAsync(UploadFieldValueAttachmentCommand command, CancellationToken token)
            => await tagValidator.ExistsRequirementAsync(command.TagId, command.RequirementId, token);

            async Task <bool> BeAnExistingFieldForRequirementAsync(UploadFieldValueAttachmentCommand command, CancellationToken token)
            => await tagValidator.ExistsFieldForRequirementAsync(command.TagId, command.RequirementId, command.FieldId, token);

            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> HasRequirementWithActivePeriodAsync(int tagId, int requirementId, CancellationToken token)
            => await tagValidator.HasRequirementWithActivePeriodAsync(tagId, requirementId, token);

            async Task <bool> NotBeAVoidedFieldAsync(int fieldId, CancellationToken token)
            => !await fieldValidator.IsVoidedAsync(fieldId, token);

            async Task <bool> BeAFieldForAttachmentAsync(int fieldId, CancellationToken token)
            => await fieldValidator.IsValidForAttachmentAsync(fieldId, token);
        }
コード例 #18
0
        public AutoScopeTagsCommandValidator(
            ITagValidator tagValidator,
            IStepValidator stepValidator,
            IProjectValidator projectValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command.TagNos)
            .Must(r => r.Any())
            .WithMessage("At least 1 tag must be given!")
            .Must(BeUniqueTagNos)
            .WithMessage("Tags must be unique!");

            RuleForEach(command => command.TagNos)
            .MustAsync((command, tagNo, _, token) => NotBeAnExistingTagWithinProjectAsync(tagNo, command.ProjectName, token))
            .WithMessage((command, tagNo) => $"Tag already exists in scope for project! Tag={tagNo}");

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAnExistingAndClosedProjectAsync(command.ProjectName, token))
            .WithMessage(command => $"Project is closed! Project={command.ProjectName}")
            .MustAsync((command, token) => BeAnExistingStepAsync(command.StepId, token))
            .WithMessage(command => $"Step doesn't exist! Step={command.StepId}")
            .MustAsync((command, token) => NotBeAVoidedStepAsync(command.StepId, token))
            .WithMessage(command => $"Step is voided! Step={command.StepId}");

            bool BeUniqueTagNos(IEnumerable <string> tagNos)
            {
                var lowerTagNos = tagNos.Select(t => t.ToLower()).ToList();

                return(lowerTagNos.Distinct().Count() == lowerTagNos.Count);
            }

            async Task <bool> NotBeAnExistingTagWithinProjectAsync(string tagNo, string projectName, CancellationToken token) =>
            !await tagValidator.ExistsAsync(tagNo, projectName, token);

            async Task <bool> NotBeAnExistingAndClosedProjectAsync(string projectName, CancellationToken token)
            => !await projectValidator.IsExistingAndClosedAsync(projectName, token);

            async Task <bool> BeAnExistingStepAsync(int stepId, CancellationToken token)
            => await stepValidator.ExistsAsync(stepId, token);

            async Task <bool> NotBeAVoidedStepAsync(int stepId, CancellationToken token)
            => !await stepValidator.IsVoidedAsync(stepId, token);
        }
コード例 #19
0
        public CreateActionCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator)
        {
            CascadeMode = CascadeMode.Stop;

            RuleFor(command => command)
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync((command, token) => BeAnExistingTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}");

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);
            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);
            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);
        }
コード例 #20
0
        public CreateAreaTagCommandValidator(
            ITagValidator tagValidator,
            IStepValidator stepValidator,
            IProjectValidator projectValidator,
            IRequirementDefinitionValidator requirementDefinitionValidator)
        {
            CascadeMode = CascadeMode.Stop;

            WhenAsync((command, token) => BeASupplierStepAsync(command.StepId, token), () =>
            {
                RuleFor(command => command)
                .MustAsync((command, token) => RequirementUsageIsForAllJourneysAsync(command.Requirements, token))
                .WithMessage(_ => "Requirements must include requirements to be used both for supplier and other than suppliers!")
                .When(command => command.TagType != TagType.PoArea, ApplyConditionTo.CurrentValidator)
                .MustAsync((command, token) => RequirementUsageIsForSupplierAsync(command.Requirements, token))
                .WithMessage(_ => "Requirements must include requirements to be used for supplier!")
                .When(command => command.TagType == TagType.PoArea, ApplyConditionTo.CurrentValidator)
                .MustAsync((command, token) => RequirementUsageIsNotForOtherThanSupplierAsync(command.Requirements, token))
                .WithMessage(_ => "Requirements can not include requirements for other than suppliers!")
                .When(command => command.TagType == TagType.PoArea, ApplyConditionTo.CurrentValidator);
            }).Otherwise(() =>
            {
                RuleFor(command => command)
                .Must(command => command.TagType != TagType.PoArea)
                .WithMessage(_ => $"Step for a {TagType.PoArea.GetTagNoPrefix()} tag needs to be for supplier!")
                .MustAsync((command, token) => RequirementUsageIsForJourneysWithoutSupplierAsync(command.Requirements, token))
                .WithMessage(_ => "Requirements must include requirements to be used for other than suppliers!")
                .MustAsync((command, token) => RequirementUsageIsNotForSupplierOnlyAsync(command.Requirements, token))
                .WithMessage(_ => "Requirements can not include requirements just for suppliers!");
            });

            RuleFor(command => command)
            .Must(command => BeUniqueRequirements(command.Requirements))
            .WithMessage(_ => "Requirement definitions must be unique!")
            .MustAsync((command, token) => NotBeAnExistingAndClosedProjectAsync(command.ProjectName, token))
            .WithMessage(command => $"Project is closed! Project={command.ProjectName}")
            .MustAsync((command, token) => NotBeAnExistingTagWithinProjectAsync(command.GetTagNo(), command.ProjectName, token))
            .WithMessage(command => $"Tag already exists in scope for project! Tag={command.GetTagNo()}")
            .MustAsync((command, token) => BeAnExistingStepAsync(command.StepId, token))
            .WithMessage(command => $"Step doesn't exist! Step={command.StepId}")
            .MustAsync((command, token) => NotBeAVoidedStepAsync(command.StepId, token))
            .WithMessage(command => $"Step is voided! Step={command.StepId}");

            RuleForEach(command => command.Requirements)
            .MustAsync((_, req, _, token) => BeAnExistingRequirementDefinitionAsync(req, token))
            .WithMessage((_, req) => $"Requirement definition doesn't exist! Requirement definition={req.RequirementDefinitionId}")
            .MustAsync((_, req, _, token) => NotBeAVoidedRequirementDefinitionAsync(req, token))
            .WithMessage((_, req) => $"Requirement definition is voided! Requirement definition={req.RequirementDefinitionId}");

            bool BeUniqueRequirements(IEnumerable <RequirementForCommand> requirements)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(reqIds.Distinct().Count() == reqIds.Count);
            }

            async Task <bool> RequirementUsageIsForAllJourneysAsync(IEnumerable <RequirementForCommand> requirements, CancellationToken token)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(await requirementDefinitionValidator.UsageCoversBothForSupplierAndOtherAsync(reqIds, token));
            }

            async Task <bool> RequirementUsageIsForSupplierAsync(IEnumerable <RequirementForCommand> requirements, CancellationToken token)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(await requirementDefinitionValidator.UsageCoversForSuppliersAsync(reqIds, token));
            }

            async Task <bool> RequirementUsageIsForJourneysWithoutSupplierAsync(IEnumerable <RequirementForCommand> requirements, CancellationToken token)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(await requirementDefinitionValidator.UsageCoversForOtherThanSuppliersAsync(reqIds, token));
            }

            async Task <bool> RequirementUsageIsNotForOtherThanSupplierAsync(IEnumerable <RequirementForCommand> requirements, CancellationToken token)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(!await requirementDefinitionValidator.HasAnyForForOtherThanSuppliersUsageAsync(reqIds, token));
            }

            async Task <bool> RequirementUsageIsNotForSupplierOnlyAsync(IEnumerable <RequirementForCommand> requirements, CancellationToken token)
            {
                var reqIds = requirements.Select(dto => dto.RequirementDefinitionId).ToList();

                return(!await requirementDefinitionValidator.HasAnyForSupplierOnlyUsageAsync(reqIds, token));
            }

            async Task <bool> NotBeAnExistingAndClosedProjectAsync(string projectName, CancellationToken token)
            => !await projectValidator.IsExistingAndClosedAsync(projectName, token);

            async Task <bool> NotBeAnExistingTagWithinProjectAsync(string tagNo, string projectName, CancellationToken token)
            => !await tagValidator.ExistsAsync(tagNo, projectName, token);

            async Task <bool> BeAnExistingStepAsync(int stepId, CancellationToken token)
            => await stepValidator.ExistsAsync(stepId, token);

            async Task <bool> NotBeAVoidedStepAsync(int stepId, CancellationToken token)
            => !await stepValidator.IsVoidedAsync(stepId, token);

            async Task <bool> BeASupplierStepAsync(int stepId, CancellationToken token)
            => await stepValidator.IsForSupplierAsync(stepId, token);

            async Task <bool> BeAnExistingRequirementDefinitionAsync(RequirementForCommand requirement, CancellationToken token)
            => await requirementDefinitionValidator.ExistsAsync(requirement.RequirementDefinitionId, token);

            async Task <bool> NotBeAVoidedRequirementDefinitionAsync(RequirementForCommand requirement, CancellationToken token)
            => !await requirementDefinitionValidator.IsVoidedAsync(requirement.RequirementDefinitionId, token);
        }
コード例 #21
0
ファイル: Formatter.cs プロジェクト: rslijp/sharptiles
 public Formatter SetTagValidator(ITagValidator tagValidator)
 {
     _tagValidator = tagValidator;
     return this;
 }
コード例 #22
0
ファイル: Formatter.cs プロジェクト: rolandzwaga/sharptiles
 public Formatter SetTagValidator(ITagValidator tagValidator)
 {
     _tagValidator = tagValidator;
     return(this);
 }
コード例 #23
0
 public StrictResolveTagLibParser(TagLibForParsing lib, ExpressionLib expressionLib, ParseHelper helper, IResourceLocator locator, IResourceLocatorFactory factory, ITagValidator tagValidator)
     : base(lib, expressionLib, helper, locator, factory, tagValidator)
 {
 }
コード例 #24
0
 public RelaxedResolveTagLibParser(TagLibForParsing lib, ExpressionLib expressionLib,ParseHelper helper, IResourceLocator locator, IResourceLocatorFactory factory, ITagValidator tagValidator)
     : base(lib, expressionLib, helper, locator,factory,tagValidator)
 {
 }
コード例 #25
0
 public void SetUp() => _target = new TagValidator();
        public UpdateTagStepAndRequirementsCommandValidator(
            IProjectValidator projectValidator,
            ITagValidator tagValidator,
            IStepValidator stepValidator,
            IRequirementDefinitionValidator requirementDefinitionValidator,
            IRowVersionValidator rowVersionValidator)
        {
            CascadeMode = CascadeMode.Stop;

            WhenAsync((command, token) => IsASupplierStepAsync(command.StepId, token), () =>
            {
                WhenAsync((command, token) => NotBeAPoAreaTagAsync(command.TagId, token), () =>
                {
                    RuleFor(command => command)
                    .MustAsync((_, command, token) =>
                               RequirementUsageIsForAllJourneysAsync(
                                   command.TagId,
                                   command.UpdatedRequirements.Where(u => !u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.UpdatedRequirements.Where(u => u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.NewRequirements.Select(r => r.RequirementDefinitionId).ToList(),
                                   token))
                    .WithMessage(_ => "Requirements must include requirements to be used both for supplier and other than suppliers!");
                }).Otherwise(() =>
                {
                    RuleFor(command => command)
                    .MustAsync((_, command, token) =>
                               RequirementUsageIsForSupplierAsync(
                                   command.TagId,
                                   command.UpdatedRequirements.Where(u => !u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.UpdatedRequirements.Where(u => u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.NewRequirements.Select(r => r.RequirementDefinitionId).ToList(),
                                   token))
                    .WithMessage(_ => "Requirements must include requirements to be used for supplier!")
                    .MustAsync((command, token) => RequirementUsageIsNotForOtherThanSupplierAsync(
                                   command.TagId,
                                   command.UpdatedRequirements.Where(u => !u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.UpdatedRequirements.Where(u => u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                                   command.NewRequirements.Select(r => r.RequirementDefinitionId).ToList(),
                                   token))
                    .WithMessage(_ => "Requirements can not include requirements for other than suppliers!");
                });
            }).Otherwise(() =>
            {
                RuleFor(command => command)
                .MustAsync((command, token) => NotBeAPoAreaTagAsync(command.TagId, token))
                .WithMessage(_ => $"Step for a {TagType.PoArea.GetTagNoPrefix()} tag needs to be for supplier!")
                .MustAsync((_, command, token) =>
                           RequirementUsageIsForJourneysWithoutSupplierAsync(
                               command.TagId,
                               command.UpdatedRequirements.Where(u => !u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                               command.UpdatedRequirements.Where(u => u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                               command.NewRequirements.Select(r => r.RequirementDefinitionId).ToList(),
                               token))
                .WithMessage(_ => "Requirements must include requirements to be used for other than suppliers!");
            });

            WhenAsync((command, token) => IsAnAreaTagAsync(command.TagId, token), () =>
            {
                RuleFor(command => command)
                .Must(command => !string.IsNullOrEmpty(command.Description))
                .WithMessage(_ => "Description can not be blank!");
            }).Otherwise(() =>
            {
                RuleFor(command => command)
                .MustAsync((command, token)
                           => NotChangeDescriptionAsync(command.TagId, command.Description, token))
                .WithMessage(_ => "Tag must be an area tag to update description!");
            });

            RuleFor(command => command)
            .MustAsync((_, command, token) =>
                       RequirementsMustBeUniqueAfterUpdateAsync(
                           command.TagId,
                           command.NewRequirements.Select(r => r.RequirementDefinitionId).ToList(),
                           token))
            .WithMessage(_ => "Requirements must be unique!")
            .MustAsync((command, token) => NotBeAClosedProjectForTagAsync(command.TagId, token))
            .WithMessage(command => $"Project for tag is closed! Tag={command.TagId}")
            .MustAsync((command, token) => BeAnExistingTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag doesn't exist! Tag={command.TagId}")
            .MustAsync((command, token) => NotBeAVoidedTagAsync(command.TagId, token))
            .WithMessage(command => $"Tag is voided! Tag={command.TagId}")
            .MustAsync((command, token) => NotChangedToAVoidedStepAsync(command.TagId, command.StepId, token))
            .WithMessage(command => $"Step is voided! Step={command.StepId}")
            .Must(command => HaveAValidRowVersion(command.RowVersion))
            .WithMessage(command => $"Not a valid row version! Row version={command.RowVersion}");

            RuleForEach(command => command.UpdatedRequirements)
            .MustAsync((command, req, _, token) => BeAnExistingTagRequirementAsync(command.TagId, req.TagRequirementId, token))
            .WithMessage((_, req) => $"Requirement doesn't exist! Requirement={req.TagRequirementId}");

            RuleForEach(command => command.DeletedRequirements)
            .MustAsync((command, req, _, token) => BeAnExistingTagRequirementAsync(command.TagId, req.TagRequirementId, token))
            .WithMessage((_, req) => $"Requirement doesn't exist! Requirement={req.TagRequirementId}")
            .MustAsync((command, req, _, token) => BeAVoidedTagRequirementAsync(
                           command.TagId,
                           req.TagRequirementId,
                           command.UpdatedRequirements.Where(u => u.IsVoided).Select(u => u.TagRequirementId).ToList(),
                           token))
            .WithMessage((_, req) => $"Requirement is not voided! Requirement={req.TagRequirementId}");

            RuleForEach(command => command.NewRequirements)
            .MustAsync((_, req, _, token) => BeAnExistingRequirementDefinitionAsync(req.RequirementDefinitionId, token))
            .WithMessage((_, req) =>
                         $"Requirement definition doesn't exist! Requirement definition={req.RequirementDefinitionId}")
            .MustAsync((_, req, _, token) => NotBeAVoidedRequirementDefinitionAsync(req.RequirementDefinitionId, token))
            .WithMessage((_, req) =>
                         $"Requirement definition is voided! Requirement definition={req.RequirementDefinitionId}");

            async Task <bool> RequirementsMustBeUniqueAfterUpdateAsync(
                int tagId,
                List <int> requirementDefinitionIdsToBeAdded,
                CancellationToken token)
            => requirementDefinitionIdsToBeAdded.Count == 0 ||
            await tagValidator.AllRequirementsWillBeUniqueAsync(tagId, requirementDefinitionIdsToBeAdded, token);

            async Task <bool> RequirementUsageIsNotForOtherThanSupplierAsync(
                int tagId,
                List <int> tagRequirementIdsToBeUnvoided,
                List <int> tagRequirementIdsToBeVoided,
                List <int> requirementDefinitionIdsToBeAdded,
                CancellationToken token)
            => !await tagValidator.RequirementHasAnyForOtherThanSuppliersUsageAsync(
                tagId,
                tagRequirementIdsToBeUnvoided,
                tagRequirementIdsToBeVoided,
                requirementDefinitionIdsToBeAdded,
                token);

            async Task <bool> RequirementUsageIsForSupplierAsync(
                int tagId,
                List <int> tagRequirementIdsToBeUnvoided,
                List <int> tagRequirementIdsToBeVoided,
                List <int> requirementDefinitionIdsToBeAdded,
                CancellationToken token)
            => await tagValidator.RequirementUsageWillCoverForSuppliersAsync(
                tagId,
                tagRequirementIdsToBeUnvoided,
                tagRequirementIdsToBeVoided,
                requirementDefinitionIdsToBeAdded,
                token);

            async Task <bool> RequirementUsageIsForAllJourneysAsync(
                int tagId,
                List <int> tagRequirementIdsToBeUnvoided,
                List <int> tagRequirementIdsToBeVoided,
                List <int> requirementDefinitionIdsToBeAdded,
                CancellationToken token)
            => await tagValidator.RequirementUsageWillCoverBothForSupplierAndOtherAsync(
                tagId,
                tagRequirementIdsToBeUnvoided,
                tagRequirementIdsToBeVoided,
                requirementDefinitionIdsToBeAdded,
                token);

            async Task <bool> RequirementUsageIsForJourneysWithoutSupplierAsync(
                int tagId,
                List <int> tagRequirementIdsToBeUnvoided,
                List <int> tagRequirementIdsToBeVoided,
                List <int> requirementDefinitionIdsToBeAdded,
                CancellationToken token)
            => await tagValidator.RequirementUsageWillCoverForOtherThanSuppliersAsync(
                tagId,
                tagRequirementIdsToBeUnvoided,
                tagRequirementIdsToBeVoided,
                requirementDefinitionIdsToBeAdded,
                token);

            async Task <bool> IsASupplierStepAsync(int stepId, CancellationToken token)
            => await stepValidator.IsForSupplierAsync(stepId, token);

            async Task <bool> NotBeAClosedProjectForTagAsync(int tagId, CancellationToken token)
            => !await projectValidator.IsClosedForTagAsync(tagId, token);

            async Task <bool> IsAnAreaTagAsync(int tagId, CancellationToken token)
            => await tagValidator.VerifyTagIsAreaTagAsync(tagId, token);

            async Task <bool> BeAnExistingTagAsync(int tagId, CancellationToken token)
            => await tagValidator.ExistsAsync(tagId, token);

            async Task <bool> NotBeAVoidedTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.IsVoidedAsync(tagId, token);

            async Task <bool> NotBeAPoAreaTagAsync(int tagId, CancellationToken token)
            => !await tagValidator.VerifyTagTypeAsync(tagId, TagType.PoArea, token);

            async Task <bool> NotChangedToAVoidedStepAsync(int tagId, int stepId, CancellationToken token)
            => await tagValidator.HasStepAsync(tagId, stepId, token) ||
            !await stepValidator.IsVoidedAsync(stepId, token);

            async Task <bool> BeAnExistingRequirementDefinitionAsync(int requirementDefinitionId, CancellationToken token)
            => await requirementDefinitionValidator.ExistsAsync(requirementDefinitionId, token);

            async Task <bool> NotBeAVoidedRequirementDefinitionAsync(int requirementDefinitionId, CancellationToken token)
            => !await requirementDefinitionValidator.IsVoidedAsync(requirementDefinitionId, token);

            async Task <bool> BeAnExistingTagRequirementAsync(int tagId, int tagRequirementId, CancellationToken token)
            => await tagValidator.HasRequirementAsync(tagId, tagRequirementId, token);

            async Task <bool> BeAVoidedTagRequirementAsync(
                int tagId,
                int tagRequirementId,
                List <int> tagRequirementIdsToBeVoided,
                CancellationToken token)
            {
                if (tagRequirementIdsToBeVoided.Contains(tagRequirementId))
                {
                    return(true);
                }

                return(await tagValidator.IsRequirementVoidedAsync(tagId, tagRequirementId, token));
            }

            bool HaveAValidRowVersion(string rowVersion)
            => rowVersionValidator.IsValid(rowVersion);

            async Task <bool> NotChangeDescriptionAsync(int tagId, string description, CancellationToken token)
            => description == null || await tagValidator.VerifyTagDescriptionAsync(tagId, description, token);
        }