public async Task <bool> RequirementUsageWillCoverForSuppliersAsync(
int tagId,
List <int> tagRequirementIdsToBeUnvoided,
List <int> tagRequirementIdsToBeVoided,
List <int> requirementDefinitionIdsToBeAdded,
CancellationToken token)
{
List <int> requirementDefinitionIds;
Tag tag;
(tag, requirementDefinitionIds) = await GetNonVoidedRequirementDefinitionIds(
tagId,
tagRequirementIdsToBeUnvoided,
tagRequirementIdsToBeVoided,
requirementDefinitionIdsToBeAdded,
token);
if (tag == null)
{
return(false);
}
return(await _requirementDefinitionValidator.UsageCoversForSuppliersAsync(requirementDefinitionIds, token));
}
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);
}