public TemplateCreateCommandValidator(
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
AsyncPolicy policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
RuleFor(x => x.Description).Length(0, 1000);
RuleFor(x => x.FundingStreamId)
.NotEmpty()
.WithMessage("Missing funding stream id")
.MustAsync(async(command, propertyValue, context, cancellationToken) =>
{
FundingStream fundingStream = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingStreamById(command.FundingStreamId));
return(fundingStream != null);
})
.WithMessage("Funding stream id does not exist");
RuleFor(x => x.FundingPeriodId)
.NotEmpty()
.WithMessage("Missing funding period id")
.MustAsync(async(command, propertyValue, context, cancellationToken) =>
{
FundingPeriod fundingPeriod = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingPeriodById(command.FundingPeriodId));
return(fundingPeriod != null);
})
.WithMessage("Funding period id does not exist");
}
public TemplatesReIndexerService(ISearchRepository <TemplateIndex> searchRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IPolicyRepository policyRepository,
ITemplateRepository templateRepository,
IJobManagement jobManagement,
ILogger logger) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.TemplatesSearchRepository,
nameof(policyResiliencePolicies.TemplatesSearchRepository));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository,
nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(templateRepository, nameof(templateRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.TemplatesRepository,
nameof(policyResiliencePolicies.TemplatesRepository));
Guard.ArgumentNotNull(jobManagement, nameof(jobManagement));
Guard.ArgumentNotNull(logger, nameof(logger));
_searchRepository = searchRepository;
_searchRepositoryResilience = policyResiliencePolicies.TemplatesSearchRepository;
_templatesRepository = templateRepository;
_templatesRepositoryResilience = policyResiliencePolicies.TemplatesRepository;
_jobManagement = jobManagement;
_logger = logger;
}
public FundingTemplateService(
ILogger logger,
IFundingTemplateRepository fundingTemplateRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IFundingTemplateValidationService fundingTemplateValidationService,
ICacheProvider cacheProvider,
ITemplateMetadataResolver templateMetadataResolver,
ITemplateBuilderService templateBuilderService,
IMapper mapper)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingTemplateRepository, nameof(fundingTemplateRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingTemplateRepository, nameof(policyResiliencePolicies.FundingTemplateRepository));
Guard.ArgumentNotNull(fundingTemplateValidationService, nameof(fundingTemplateValidationService));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(templateMetadataResolver, nameof(templateMetadataResolver));
Guard.ArgumentNotNull(templateBuilderService, nameof(templateBuilderService));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_logger = logger;
_fundingTemplateRepository = fundingTemplateRepository;
_fundingTemplateRepositoryPolicy = policyResiliencePolicies.FundingTemplateRepository;
_fundingTemplateValidationService = fundingTemplateValidationService;
_cacheProvider = cacheProvider;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_templateMetadataResolver = templateMetadataResolver;
_templateBuilderService = templateBuilderService;
_mapper = mapper;
}
public TemplateBlobService(
IPolicyResiliencePolicies policyResiliencePolicies,
IFundingTemplateRepository fundingTemplateRepository,
ICacheProvider cacheProvider,
ILogger logger)
{
_fundingTemplateRepository = fundingTemplateRepository;
_fundingTemplateRepositoryPolicy = policyResiliencePolicies.FundingTemplateRepository;
_cacheProvider = cacheProvider;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_logger = logger;
}
public FundingSchemaService(
ILogger logger,
IFundingSchemaRepository fundingSchemaRepository,
IPolicyResiliencePolicies policyResiliencePolicies)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingSchemaRepository, nameof(fundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingSchemaRepository, nameof(policyResiliencePolicies.FundingSchemaRepository));
_logger = logger;
_fundingSchemaRepository = fundingSchemaRepository;
_fundingSchemaRepositoryPolicy = policyResiliencePolicies.FundingSchemaRepository;
}
public FundingTemplateValidationService(
IFundingSchemaRepository fundingSchemaRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IPolicyRepository policyRepository)
{
Guard.ArgumentNotNull(fundingSchemaRepository, nameof(fundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.FundingSchemaRepository, nameof(policyResiliencePolicies.FundingSchemaRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
_fundingSchemaRepository = fundingSchemaRepository;
_fundingSchemaRepositoryPolicy = policyResiliencePolicies.FundingSchemaRepository;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
}
public TemplateSearchService(ILogger logger,
ISearchRepository <TemplateIndex> searchRepository,
IPolicyResiliencePolicies resiliencePolicies,
IJobsApiClient jobs)
{
Guard.ArgumentNotNull(searchRepository, nameof(searchRepository));
Guard.ArgumentNotNull(jobs, nameof(jobs));
Guard.ArgumentNotNull(resiliencePolicies, nameof(resiliencePolicies));
Guard.ArgumentNotNull(resiliencePolicies?.JobsApiClient, nameof(resiliencePolicies.JobsApiClient));
Guard.ArgumentNotNull(logger, nameof(logger));
_logger = logger;
_searchRepository = searchRepository;
_jobs = jobs;
_jobsClientPolicy = resiliencePolicies.JobsApiClient;
}
public FundingDateService(
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
ILogger logger,
IValidator <FundingDate> fundingDateValidator,
IMapper mapper)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies, nameof(policyResiliencePolicies));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(fundingDateValidator, nameof(fundingDateValidator));
Guard.ArgumentNotNull(mapper, nameof(mapper));
_policyRepository = policyRepository;
_logger = logger;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_fundingDateValidator = fundingDateValidator;
_mapper = mapper;
}
public FundingPeriodService(ILogger logger,
ICacheProvider cacheProvider,
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IValidator <FundingPeriodsJsonModel> fundingPeriodJsonModelValidator)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(fundingPeriodJsonModelValidator, nameof(fundingPeriodJsonModelValidator));
_logger = logger;
_cacheProvider = cacheProvider;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_fundingPeriodJsonModelValidator = fundingPeriodJsonModelValidator;
}
public FundingConfigurationService(
ILogger logger,
ICacheProvider cacheProvider,
IMapper mapper,
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IValidator <FundingConfiguration> fundingConfigurationValidator)
{
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(cacheProvider, nameof(cacheProvider));
Guard.ArgumentNotNull(mapper, nameof(mapper));
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(fundingConfigurationValidator, nameof(fundingConfigurationValidator));
Guard.ArgumentNotNull(policyResiliencePolicies?.CacheProvider, nameof(policyResiliencePolicies.CacheProvider));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
_logger = logger;
_cacheProvider = cacheProvider;
_cacheProviderPolicy = policyResiliencePolicies.CacheProvider;
_mapper = mapper;
_policyRepository = policyRepository;
_policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
_fundingConfigurationValidator = fundingConfigurationValidator;
}
public SaveFundingDateValidator(
IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies
)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
ResiliencePolicy policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
RuleFor(model => model.FundingStreamId)
.NotEmpty()
.WithMessage("No funding stream id was provided to SaveFundingDate")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (!string.IsNullOrWhiteSpace(model.FundingStreamId))
{
FundingStream fundingStream = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingStreamById(model.FundingStreamId));
if (fundingStream == null)
{
context.AddFailure("Funding stream not found");
}
}
});
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("No funding period id was provided to SaveFundingDate")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (!string.IsNullOrWhiteSpace(model.FundingPeriodId))
{
FundingPeriod fundingPeriod = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingPeriodById(model.FundingPeriodId));
if (fundingPeriod == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.Patterns)
.NotEmpty()
.WithMessage("No funding date pattern was provided to SaveFundingDate")
.Custom((name, context) =>
{
FundingDate model = context.ParentContext.InstanceToValidate as FundingDate;
if (model.Patterns == null)
{
return;
}
foreach (FundingDatePattern fundingDatePattern in model.Patterns)
{
if (fundingDatePattern.Occurrence == default ||
string.IsNullOrEmpty(fundingDatePattern.Period) ||
fundingDatePattern.PeriodYear == default ||
fundingDatePattern.PaymentDate == default)
{
context.AddFailure("FundingDatePattern information missing");
}
}
if (model.Patterns.GroupBy(x => new { x.Period, x.PeriodYear, x.Occurrence }).Any(_ => _.Count() > 1))
{
context.AddFailure("Duplicate funding data pattern");
}
});
}
public SaveFundingConfigurationValidator(IPolicyRepository policyRepository,
IPolicyResiliencePolicies policyResiliencePolicies,
IFundingTemplateService fundingTemplateService)
{
Guard.ArgumentNotNull(policyRepository, nameof(policyRepository));
Guard.ArgumentNotNull(fundingTemplateService, nameof(fundingTemplateService));
Guard.ArgumentNotNull(policyResiliencePolicies?.PolicyRepository, nameof(policyResiliencePolicies.PolicyRepository));
ResiliencePolicy policyRepositoryPolicy = policyResiliencePolicies.PolicyRepository;
RuleFor(_ => _.ApprovalMode)
.Must(_ => _ != ApprovalMode.Undefined)
.WithMessage("No valid approval mode was selected");
RuleFor(model => model.FundingStreamId)
.NotEmpty()
.WithMessage("No funding stream id was provided to SaveFundingConfiguration")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
if (!string.IsNullOrWhiteSpace(model.FundingStreamId))
{
FundingStream fundingStream = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingStreamById(model.FundingStreamId));
if (fundingStream == null)
{
context.AddFailure("Funding stream not found");
}
}
});
RuleFor(model => model.FundingPeriodId)
.NotEmpty()
.WithMessage("No funding period id was provided to SaveFundingConfiguration")
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
if (!string.IsNullOrWhiteSpace(model.FundingPeriodId))
{
FundingPeriod fundingPeriod = await policyRepositoryPolicy.ExecuteAsync(() => policyRepository.GetFundingPeriodById(model.FundingPeriodId));
if (fundingPeriod == null)
{
context.AddFailure("Funding period not found");
}
}
});
RuleFor(model => model.DefaultTemplateVersion)
.CustomAsync(async(name, context, cancellationToken) =>
{
FundingConfiguration model = context.ParentContext.InstanceToValidate as FundingConfiguration;
string fundingStreamId = model.FundingStreamId;
string defaultTemplateVersion = model.DefaultTemplateVersion;
string fundingPeriodId = model.FundingPeriodId;
if (!string.IsNullOrWhiteSpace(fundingStreamId) && !string.IsNullOrWhiteSpace(fundingPeriodId) && !string.IsNullOrWhiteSpace(defaultTemplateVersion))
{
if (!await fundingTemplateService.TemplateExists(fundingStreamId, fundingPeriodId, defaultTemplateVersion))
{
context.AddFailure("Default template not found");
}
}
});
RuleFor(_ => _.UpdateCoreProviderVersion)
.Must(v => v == UpdateCoreProviderVersion.Manual)
.When(_ => _.ProviderSource != CalculateFunding.Models.Providers.ProviderSource.FDZ, ApplyConditionTo.CurrentValidator)
.WithMessage(x => $"UpdateCoreProviderVersion - {x.UpdateCoreProviderVersion.ToString()} is not valid for provider source - {x.ProviderSource}");
}
