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"));
                    }
                });
            });
        }
Example #2
0
 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;
 }
Example #5
0
 public StartPrivateCertificateHandler(ICertificateRepository certificateRepository,
                                       IOrganisationQueryRepository organisationQueryRepository, ILogger <StartCertificateHandler> logger)
 {
     _certificateRepository       = certificateRepository;
     _organisationQueryRepository = organisationQueryRepository;
     _logger = logger;
 }
Example #6
0
 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;
        }
Example #8
0
 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;
 }
Example #11
0
 /// <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));
 }
Example #12
0
 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);
 })) {
 }
Example #14
0
 public StudentPresentation(IStudentRepository studentRepository,
                            IUniversityRepository universityRepository, IMapper mapper,
                            ICertificateRepository certificateRepository)
 {
     _studentRepository    = studentRepository;
     _universityRepository = universityRepository;
     _mapper = mapper;
     _certificateRepository = certificateRepository;
 }
Example #15
0
 /// <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;
 }
Example #16
0
        /// <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;
 }
Example #19
0
        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;
        }
Example #20
0
 public GetCertificatesToBeApprovedHandler(ICertificateRepository certificateRepository,
                                           IAssessmentOrgsApiClient assessmentOrgsApiClient,
                                           IContactQueryRepository contactQueryRepository,
                                           ILogger <GetCertificatesToBeApprovedHandler> logger)
 {
     _certificateRepository   = certificateRepository;
     _assessmentOrgsApiClient = assessmentOrgsApiClient;
     _contactQueryRepository  = contactQueryRepository;
     _logger = logger;
 }
Example #21
0
 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;
 }
Example #22
0
 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;
 }
Example #27
0
 public UpdateBatchLogReadyToPrintAddCertificatesHandler(
     ICertificateBatchLogRepository certificateBatchLogRepository,
     ICertificateRepository certificateRepository,
     IUnitOfWork unitOfWork,
     ILogger <UpdateBatchLogReadyToPrintAddCertificatesHandler> logger)
 {
     _certificateBatchLogRepository = certificateBatchLogRepository;
     _certificateRepository         = certificateRepository;
     _unitOfWork = unitOfWork;
     _logger     = logger;
 }
Example #28
0
 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;
 }
Example #29
0
 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;
 }
Example #30
0
 public CertificateService(
     IConfiguration configuration,
     ICertificateRepository certificateRepository,
     IHashValueComputationService hashValueComputationService,
     IEthereumService ethereumService
     )
 {
     this.certificateRepository       = certificateRepository;
     this.hashValueComputationService = hashValueComputationService;
     this.ethereumService             = ethereumService;
 }
Example #31
0
 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;
 }
Example #32
0
 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);
        }