public CreateBatchCertificateRequestValidator( IStringLocalizer <BatchCertificateRequestValidator> localiser, IOrganisationQueryRepository organisationQueryRepository, IIlrRepository ilrRepository, ICertificateRepository certificateRepository, IStandardService standardService) { Include(new BatchCertificateRequestValidator(localiser, organisationQueryRepository, ilrRepository, standardService)); RuleFor(m => m.CertificateReference).Empty().WithMessage("Certificate reference must be empty").DependentRules(() => { RuleFor(m => m).CustomAsync(async(m, context, cancellation) => { var existingCertificate = await certificateRepository.GetCertificate(m.Uln, m.StandardCode); var sumbittingEpao = await organisationQueryRepository.GetByUkPrn(m.UkPrn); var learnerDetails = await ilrRepository.Get(m.Uln, m.StandardId.GetValueOrDefault()); if (existingCertificate != null && existingCertificate.Status != CertificateStatus.Deleted) { if (sumbittingEpao?.Id != existingCertificate.OrganisationId) { context.AddFailure(new ValidationFailure("CertificateData", $"Your organisation is not the creator of the EPA")); } else if (existingCertificate.Status == CertificateStatus.Draft) { var certData = JsonConvert.DeserializeObject <CertificateData>(existingCertificate.CertificateData); if (!string.IsNullOrEmpty(certData.OverallGrade) && certData.AchievementDate.HasValue && !string.IsNullOrEmpty(certData.ContactPostCode)) { context.AddFailure(new ValidationFailure("CertificateData", $"Certificate already exists: {existingCertificate.CertificateReference}")); } else if (!EpaOutcome.Pass.Equals(certData.EpaDetails?.LatestEpaOutcome, StringComparison.InvariantCultureIgnoreCase)) { context.AddFailure(new ValidationFailure("CertificateData", $"Latest EPA Outcome has not passed")); } } else { context.AddFailure(new ValidationFailure("CertificateData", $"Certificate already exists: {existingCertificate.CertificateReference}")); } } if (learnerDetails != null) { if (learnerDetails.CompletionStatus == (int)CompletionStatus.Withdrawn) { context.AddFailure(new ValidationFailure("LearnerDetails", "Cannot find the apprentice details")); } else if (learnerDetails.CompletionStatus == (int)CompletionStatus.TemporarilyWithdrawn) { context.AddFailure(new ValidationFailure("LearnerDetails", "Cannot find the apprentice details")); } } else { context.AddFailure(new ValidationFailure("LearnerDetails", $"Learner details for ULN: {m.Uln} not found")); } }); }); }
public UpdateBatchCertificateHandler(ICertificateRepository certificateRepository, IContactQueryRepository contactQueryRepository, ILogger <UpdateBatchCertificateHandler> logger, IStandardService standardService) { _certificateRepository = certificateRepository; _contactQueryRepository = contactQueryRepository; _logger = logger; _standardService = standardService; }
/// <summary> /// Constructor for using a required HTTP message handler for REST calls /// </summary> /// <param name="certificateRepository">certificate repository</param> /// <param name="restClientConfiguration">REST client configuration</param> public ClientTokenManager(ICertificateRepository certificateRepository, IClientTokenManagerConfiguration clientTokenManagerConfiguration, IRestClientConfiguration restClientConfiguration) : this(certificateRepository, clientTokenManagerConfiguration) { Verify.IsNotNull(nameof(restClientConfiguration), restClientConfiguration); _restClientConfiguration = restClientConfiguration; }
public MongoOperations( IBranchRepository branchRepository, ICertificateRepository certificateRepository, ICompanyRepository companyRepository, ICourseRepository courseRepository, IDegreeRepository degreeRepository, IExamRepository examRepository, IExamTermRepository examTermRepository, IExamResultRepository examResultRepository, IGivenCertificateRepository givenCertificateRepository, IGivenDegreeRepository givenDegreeRepository, IPersonalLogRepository personalLogRepository, IMeetingRepository meetingRepository, IUserRepository userRepository) { this.branchRepository = branchRepository; this.certificateRepository = certificateRepository; this.companyRepository = companyRepository; this.courseRepository = courseRepository; this.degreeRepository = degreeRepository; this.examRepository = examRepository; this.examTermRepository = examTermRepository; this.examResultRepository = examResultRepository; this.givenCertificateRepository = givenCertificateRepository; this.givenDegreeRepository = givenDegreeRepository; this.personalLogRepository = personalLogRepository; this.meetingRepository = meetingRepository; this.userRepository = userRepository; }
public StartPrivateCertificateHandler(ICertificateRepository certificateRepository, IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger) { _certificateRepository = certificateRepository; _organisationQueryRepository = organisationQueryRepository; _logger = logger; }
public PendingCertificatesController(ICertificateRepository certRepo, IConfigurationRepository configRepo, IAuthorizationLogic authorizationLogic, IAuditLogic auditLogic) { this.certificateRepository = certRepo; this.configurationRepository = configRepo; this.authorizationLogic = authorizationLogic; this.http = new HttpResponseHandler(this); this.audit = auditLogic; }
public CertificateService(ICertificateRepository certificateRepository, IReferenceGenerator referenceGenerator) { Check.If(certificateRepository).IsNotNull(); Check.If(referenceGenerator).IsNotNull(); _certificateRepository = certificateRepository; _referenceGenerator = referenceGenerator; }
public LinkViewModelService(IAsyncRepository <Link> linkRepository, ICertificateRepository certificateRepository, ICachedPublicViewModelService cacheService) { _linkRepository = linkRepository; _certificateRepository = certificateRepository; _cacheService = cacheService; }
/// <summary> /// Constructor to use default HTTP message handler for REST calls /// </summary> /// <param name="certificateRepository">certificate repository</param> public ClientTokenManager(ICertificateRepository certificateRepository, IClientTokenManagerConfiguration clientTokenManagerConfiguration) { Verify.IsNotNull(nameof(certificateRepository), certificateRepository); Verify.IsNotNull(nameof(clientTokenManagerConfiguration), clientTokenManagerConfiguration); _certificateRepository = certificateRepository; _clientTokenManagerConfiguration = clientTokenManagerConfiguration; }
public GetBatchCertificateHandler(ICertificateRepository certificateRepository, IContactQueryRepository contactQueryRepository, IStandardRepository standardRepository, IOrganisationQueryRepository organisationQueryRepository, ILogger <GetBatchCertificateHandler> logger) { _certificateRepository = certificateRepository; _contactQueryRepository = contactQueryRepository; _standardRepository = standardRepository; _organisationQueryRepository = organisationQueryRepository; _logger = logger; }
/// <summary> /// Create factory /// </summary> /// <param name="store"></param> /// <param name="repo"></param> /// <param name="keys"></param> /// <param name="factory"></param> /// <param name="logger"></param> public CertificateIssuer(ICertificateStore store, ICertificateRepository repo, IKeyStore keys, ICertificateFactory factory, ILogger logger) { _keys = keys ?? throw new ArgumentNullException(nameof(keys)); _store = store ?? throw new ArgumentNullException(nameof(store)); _repo = repo ?? throw new ArgumentNullException(nameof(repo)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _factory = factory ?? throw new ArgumentNullException(nameof(factory)); }
public GetBatchLearnerHandler(IMediator mediator, ILogger <GetBatchLearnerHandler> logger, ILearnerRepository learnerRepository, IOrganisationQueryRepository organisationRepository, IStandardService standardService, ICertificateRepository certificateRepository) { _mediator = mediator; _logger = logger; _learnerRepository = learnerRepository; _organisationRepository = organisationRepository; _standardService = standardService; _certificateRepository = certificateRepository; }
/// <summary> /// Create key vault service client /// </summary> /// <param name="config">Keyvault configuration.</param> /// <param name="provider"></param> /// <param name="certificates"></param> /// <param name="factory"></param> public KeyVaultServiceClient(ICertificateRepository certificates, ICertificateFactory factory, IKeyVaultConfig config, Auth.ITokenProvider provider) : this(certificates, factory, config, new KeyVaultClient(async(_, resource, scope) => { var token = await provider.GetTokenForAsync( resource, scope.YieldReturn()); return(token.RawToken); })) { }
public StudentPresentation(IStudentRepository studentRepository, IUniversityRepository universityRepository, IMapper mapper, ICertificateRepository certificateRepository) { _studentRepository = studentRepository; _universityRepository = universityRepository; _mapper = mapper; _certificateRepository = certificateRepository; }
/// <summary> /// Initializes a new instance of the <see cref="VerifySignatureConfig"/> class. /// </summary> /// <param name="allowUnknownRootCertificateAuthority">if set to <c>true</c> [allow unknown root certificate authority].</param> /// <param name="attachments">The attachments.</param> /// <param name="certificateRepository">The certificate repository used to retrieve the signing certificate that was referenced in the message.</param> public VerifySignatureConfig( bool allowUnknownRootCertificateAuthority, IEnumerable <Attachment> attachments, ICertificateRepository certificateRepository) { AllowUnknownRootCertificateAuthority = allowUnknownRootCertificateAuthority; Attachments = attachments ?? Enumerable.Empty <Attachment>(); CertificateRepository = certificateRepository ?? Registry.Instance.CertificateRepository; }
/// <summary> /// Initializes a new instance of the <see cref="SignAS4MessageStep"/> class. /// Create Signing Step with a given Certificate Store Repository /// </summary> /// <param name="repository"> /// </param> public SignAS4MessageStep(ICertificateRepository repository) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } _repository = repository; }
/// <summary> /// Initializes a new instance of the <see cref="EncryptAS4MessageStep"/> class /// </summary> /// <param name="certificateRepository"></param> public EncryptAS4MessageStep(ICertificateRepository certificateRepository) { if (certificateRepository == null) { throw new ArgumentNullException(nameof(certificateRepository)); } _certificateRepository = certificateRepository; }
public CertificatePrintStatusUpdateHandler(ICertificateRepository certificateRepository, IBatchLogQueryRepository batchLogQueryRepository, IMediator mediator, ILogger <CertificatePrintStatusUpdateHandler> logger) { _certificateRepository = certificateRepository; _batchLogQueryRepository = batchLogQueryRepository; _mediator = mediator; _logger = logger; }
public TokenClientActor(ActorKey actorKey, IActorManager actorManager, ICertificateRepository certificateRepository, IRestClientConfiguration restClientConfiguration) : base(actorKey, actorManager) { Verify.IsNotNull(nameof(certificateRepository), certificateRepository); Verify.IsNotNull(nameof(restClientConfiguration), restClientConfiguration); _certificateRepository = certificateRepository; _restClientConfiguration = restClientConfiguration; }
public GetCertificatesToBeApprovedHandler(ICertificateRepository certificateRepository, IAssessmentOrgsApiClient assessmentOrgsApiClient, IContactQueryRepository contactQueryRepository, ILogger <GetCertificatesToBeApprovedHandler> logger) { _certificateRepository = certificateRepository; _assessmentOrgsApiClient = assessmentOrgsApiClient; _contactQueryRepository = contactQueryRepository; _logger = logger; }
public StartCertificateHandler(ICertificateRepository certificateRepository, ILearnerRepository learnerRepository, IProvidersRepository providersRepository, IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger, IStandardService standardService) { _certificateRepository = certificateRepository; _learnerRepository = learnerRepository; _providersRepository = providersRepository; _organisationQueryRepository = organisationQueryRepository; _logger = logger; _standardService = standardService; }
public GetCertificatesToBeApprovedHandler(ICertificateRepository certificateRepository, IRoatpApiClient roatpApiClient, IContactQueryRepository contactQueryRepository, ILogger <GetCertificatesToBeApprovedHandler> logger) { _certificateRepository = certificateRepository; _roatpApiClient = roatpApiClient; _contactQueryRepository = contactQueryRepository; _logger = logger; }
public PrivateCertificateAuthorityController(ICertificateRepository certRepo, IConfigurationRepository configRepo, ICertificateProvider certProvider, IAuthorizationLogic authorizationLogic, IAuditLogic auditLogic, AdcsTemplateLogic templateLogic) { this.certificateRepository = certRepo; this.configurationRepository = configRepo; this.certificateProvider = certProvider; this.authorizationLogic = authorizationLogic; this.http = new HttpResponseHandler(this); this.audit = auditLogic; this.templateLogic = templateLogic; }
public void Setup() { this.webSiteTable = new AzureTable<WebSiteRow>(CloudStorageAccount.DevelopmentStorageAccount, "WebSitesTest"); this.bindingTable = new AzureTable<BindingRow>(CloudStorageAccount.DevelopmentStorageAccount, "BindingsTest"); this.certificateRepository = new CertificateRepository(CloudStorageAccount.DevelopmentStorageAccount, "CertificatesTest", "certificatestest"); this.webSiteTable.CreateIfNotExist(); this.bindingTable.CreateIfNotExist(); this.webSiteRepository = new WebSiteRepository(this.webSiteTable, this.bindingTable); this.controller = new WebSiteController(this.webSiteRepository, this.certificateRepository); }
public StartCertificateHandler(ICertificateRepository certificateRepository, IIlrRepository ilrRepository, IAssessmentOrgsApiClient assessmentOrgsApiClient, IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger, IStandardService standardService) { _certificateRepository = certificateRepository; _ilrRepository = ilrRepository; _assessmentOrgsApiClient = assessmentOrgsApiClient; _organisationQueryRepository = organisationQueryRepository; _logger = logger; _standardService = standardService; }
public GetLearnerDetailHandler(ILearnerRepository learnerRepository, ICertificateRepository certificateRepository, IStaffCertificateRepository staffCertificateRepository, ILogger <GetLearnerDetailHandler> logger, IOrganisationQueryRepository organisationRepository, IStandardRepository standardRepository) { _learnerRepository = learnerRepository; _certificateRepository = certificateRepository; _staffCertificateRepository = staffCertificateRepository; _logger = logger; _organisationRepository = organisationRepository; _standardRepository = standardRepository; }
public UpdateBatchLogReadyToPrintAddCertificatesHandler( ICertificateBatchLogRepository certificateBatchLogRepository, ICertificateRepository certificateRepository, IUnitOfWork unitOfWork, ILogger <UpdateBatchLogReadyToPrintAddCertificatesHandler> logger) { _certificateBatchLogRepository = certificateBatchLogRepository; _certificateRepository = certificateRepository; _unitOfWork = unitOfWork; _logger = logger; }
public PupilPresentation(IPupilRepository pupilRepository, IStudentRepository studentRepository, ISchoolRepository schoolRepository, IMapper mapper, IStudentPresentation studentPresentation, ICertificateRepository certificateRepository) { _pupilRepository = pupilRepository; _studentRepository = studentRepository; _schoolRepository = schoolRepository; _mapper = mapper; _studentPresentation = studentPresentation; _certificateRepository = certificateRepository; }
public CreateBatchCertificateHandler(ICertificateRepository certificateRepository, IIlrRepository ilrRepository, IOrganisationQueryRepository organisationQueryRepository, IContactQueryRepository contactQueryRepository, ILogger <CreateBatchCertificateHandler> logger, IStandardService standardService, IRoatpApiClient roatpApiClient) { _certificateRepository = certificateRepository; _ilrRepository = ilrRepository; _organisationQueryRepository = organisationQueryRepository; _contactQueryRepository = contactQueryRepository; _logger = logger; _standardService = standardService; _roatpApiClient = roatpApiClient; }
public CertificateService( IConfiguration configuration, ICertificateRepository certificateRepository, IHashValueComputationService hashValueComputationService, IEthereumService ethereumService ) { this.certificateRepository = certificateRepository; this.hashValueComputationService = hashValueComputationService; this.ethereumService = ethereumService; }
public DeletePersonalDataModel(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, IStringLocalizer <DeletePersonalData> localizer, ILogger <DeletePersonalDataModel> logger, ICertificateRepository repository) { _userManager = userManager; _signInManager = signInManager; _localizer = localizer; _logger = logger; _repository = repository; }
public CreateBatchCertificateHandler(ICertificateRepository certificateRepository, ILearnerRepository learnerRepository, IOrganisationQueryRepository organisationQueryRepository, IContactQueryRepository contactQueryRepository, ILogger <CreateBatchCertificateHandler> logger, IStandardService standardService, IProvidersRepository providersRepository) { _certificateRepository = certificateRepository; _learnerRepository = learnerRepository; _organisationQueryRepository = organisationQueryRepository; _contactQueryRepository = contactQueryRepository; _logger = logger; _standardService = standardService; _providersRepository = providersRepository; }
public SyncService(IWebSiteRepository sitesRepository, ICertificateRepository certificateRepository, ISyncStatusRepository syncStatusRepository, CloudStorageAccount storageAccount, string localSitesPath, string localTempPath, IEnumerable<string> directoriesToExclude) { this.sitesRepository = sitesRepository; this.certificateRepository = certificateRepository; this.syncStatusRepository = syncStatusRepository; this.localSitesPath = localSitesPath; this.localTempPath = localTempPath; this.directoriesToExclude = directoriesToExclude; this.entries = new Dictionary<string, FileEntry>(); this.siteDeployTimes = new Dictionary<string, DateTime>(); var sitesContainerName = RoleEnvironment.GetConfigurationSettingValue("SitesContainerName").ToLowerInvariant(); this.container = storageAccount.CreateCloudBlobClient().GetContainerReference(sitesContainerName); this.container.CreateIfNotExist(); }
public CertificateController(ICertificateRepository certificateRepository) { this.certificateRepository = certificateRepository; }
public WebSiteController(IWebSiteRepository webSiteRepository, ICertificateRepository certificateRepository) { this.webSiteRepository = webSiteRepository; this.certificateRepository = certificateRepository; }
public void Setup() { _mockDbSettings.Setup(x => x.ConnectionString).Returns("TestConectionString"); _mockContext.Setup(x => x.Properties).Returns(_mockDbSet.Object); _mockContext.Setup(x => x.SaveChanges()).Returns(1); _mockCertificateMapper.Setup(x => x.Map(It.IsAny<Certificate>(), It.IsAny<Certificate>())).Returns(true); _certificateRepository = new CertificateRepository(_mockContext.Object, _mockCertificateMapper.Object); }