/// <summary> /// Run the report. /// </summary> /// <param name="reportRunner"> /// A <see cref="IReportRunner{TReportResult}"/> to run the report. This cannot be null. /// </param> /// <param name="reportResultFormatter"> /// A <see cref="IReportResultFormatter{TReportResult}"/> to format the report results. This cannot be null. /// </param> /// <param name="credentialRepository"> /// Used to load previously saved credentials. Cannot be null. /// </param> /// <param name="options"> /// The command line options. Cannot be null. /// </param> /// <returns> /// The process return value. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="reportRunner"/>, <paramref name="reportResultFormatter"/>, <paramref name="credentialRepository"/> /// and <paramref name="options"/> cannot be null. /// </exception> private static int RunReport <TReportResult>(IReportRunner <TReportResult> reportRunner, IReportResultFormatter <TReportResult> reportResultFormatter, ICredentialRepository credentialRepository, CheckmarxReportOptions options) { if (reportRunner == null) { throw new ArgumentNullException(nameof(reportRunner)); } if (reportResultFormatter == null) { throw new ArgumentNullException(nameof(reportResultFormatter)); } if (credentialRepository == null) { throw new ArgumentNullException(nameof(credentialRepository)); } if (options == null) { throw new ArgumentNullException(nameof(options)); } string userName; string password; GetCredentials(credentialRepository, options.Server, options.UserName, options.Password, out userName, out password); using (Stream stream = string.IsNullOrWhiteSpace(options.OutputPath) ? Console.OpenStandardOutput() : new FileStream(options.OutputPath, FileMode.Create)) using (StreamWriter output = new StreamWriter(stream, Encoding.UTF8)) using (CheckmarxApiSession checkmarxApiSession = new CheckmarxApiSession(options.Server, userName, password)) { reportResultFormatter.Format(reportRunner.Run(checkmarxApiSession, options), output, options, userName); } return(ExitSuccess); }
public AuthenticationController(ILogger logger, ICorrelationIdHelper correlationIdHelper, IConfigurationManager configurationManager, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, ICredentialRepository credentialRepository, IAuthenticationHashHelper authenticationHashHelper) : base(logger, correlationIdHelper, configurationManager, authenticationTokenHelper) { QueryFactory = queryFactory; CredentialRepository = credentialRepository; AuthenticationHashHelper = authenticationHashHelper; }
public AgentManager(IAgentRepository agentRepository, IScheduleRepository scheduleRepository, IJobRepository jobRepository, IAspNetUsersRepository usersRepository, ICredentialRepository credentialRepository, IAgentHeartbeatRepository agentHeartbeatRepository, ApplicationIdentityUserManager userManager, IPersonRepository personRepository, IAgentGroupMemberRepository agentGroupMemberRepository, IJobManager jobManager, IWebhookPublisher webhookPublisher, IHttpContextAccessor httpContextAccessor, IAgentGroupRepository agentGroupRepository) { _agentRepo = agentRepository; _scheduleRepo = scheduleRepository; _jobRepo = jobRepository; _usersRepo = usersRepository; _credentialRepo = credentialRepository; _agentHeartbeatRepo = agentHeartbeatRepository; _userManager = userManager; _personRepo = personRepository; _agentGroupMemberRepository = agentGroupMemberRepository; _jobManager = jobManager; _agentGroupRepository = agentGroupRepository; _webhookPublisher = webhookPublisher; _caller = ((httpContextAccessor.HttpContext != null) ? httpContextAccessor.HttpContext.User : new ClaimsPrincipal()); }
/// <summary> /// Instantiate a new instance of the <see cref="AuthenticationService"/> class. /// </summary> public AuthenticationService(IEventStore <Guid> eventStore, ILogger logger, ICorrelationIdHelper correlationIdHelper, IAuthenticationTokenHelper <Guid> authenticationTokenHelper, IQueryFactory queryFactory, ICredentialRepository credentialRepository, IAuthenticationHashHelper authenticationHashHelper, ICommandPublisher <Guid> commandPublisher) : base(eventStore, logger, correlationIdHelper, authenticationTokenHelper) { CredentialRepository = credentialRepository; QueryFactory = queryFactory; AuthenticationHashHelper = authenticationHashHelper; CommandPublisher = commandPublisher; }
public void GivenIHaveACredentialRepository() { var utilityFactory = new XmlCredentialRepoBuilder { EncryptionKey = _key }; _credentialRepository = utilityFactory.BuildXmlCredentialRepo(); }
public UserRepository(ICredentialRepository credentialRepository, IEmployeeRepository employeeRepository, IPersonRepository personRepository) { _credentialRepository = credentialRepository; _employeeRepository = employeeRepository; _personRepository = personRepository; }
public SessionQuery(IUserRepository repository, ICredentialRepository CreRepo, IRestoreRepository ResRepo, IRoleRepository roleRepository) { _repository = repository; _CreRepo = CreRepo; _ResRepo = ResRepo; _RoleRepo = roleRepository; }
public CredentialService(ICredentialRepository iCredentialRepository) { if (iCredentialRepository == null) { throw new ArgumentNullException("ICredentialRepository Required"); } _iCredentialRepository = iCredentialRepository; }
public CredentialRepositoryChangedArgs(ICredentialRepository repository) { if (repository == null) { throw new ArgumentNullException(nameof(repository)); } Repository = repository; }
public CredentialTasks(ICredentialRepository credentialRepository, IUserGroupTask userGroupTask, IApplicationTask applicationTask, IAuditTasks auditTasks) { this.credentialRepository = credentialRepository; this.userGroupTask = userGroupTask; this.applicationTask = applicationTask; this.auditTasks = auditTasks; }
public AgentManager(IAgentRepository agentRepository, IScheduleRepository scheduleRepository, IJobRepository jobRepository, IAspNetUsersRepository usersRepository, ICredentialRepository credentialRepository, IAgentHeartbeatRepository agentHeartbeatRepository) { this.agentRepo = agentRepository; this.scheduleRepo = scheduleRepository; this.jobRepo = jobRepository; this.usersRepo = usersRepository; this.credentialRepo = credentialRepository; this.agentHeartbeatRepo = agentHeartbeatRepository; }
public void AddProvider(ICredentialRepository credentialProvider) { if (Contains(credentialProvider.Config.Id)) { return; } _credentialProviders.Add(credentialProvider); credentialProvider.CredentialsUpdated += RaiseCredentialsUpdatedEvent; credentialProvider.RepositoryConfigUpdated += OnRepoConfigChanged; RaiseRepositoriesUpdatedEvent(ActionType.Added, new[] { credentialProvider }); }
public UserManager(IHandler handler) { this.handler = handler; this.permissionRepository = handler.Storage.GetRepository <IPermissionRepository>(); this.roleRepository = handler.Storage.GetRepository <IRoleRepository>(); this.rolePermissionRepository = handler.Storage.GetRepository <IRolePermissionRepository>(); this.userRepository = handler.Storage.GetRepository <IUserRepository>(); this.userRoleRepository = handler.Storage.GetRepository <IUserRoleRepository>(); this.credentialTypeRepository = handler.Storage.GetRepository <ICredentialTypeRepository>(); this.credentialRepository = handler.Storage.GetRepository <ICredentialRepository>(); }
public void RemoveProvider(ICredentialRepository credentialProvider) { if (!Contains(credentialProvider.Config.Id)) { return; } credentialProvider.CredentialsUpdated -= RaiseCredentialsUpdatedEvent; credentialProvider.RepositoryConfigUpdated -= OnRepoConfigChanged; _credentialProviders.Remove(credentialProvider); RaiseRepositoriesUpdatedEvent(ActionType.Removed, new[] { credentialProvider }); }
public CredentialsController( ICredentialRepository repository, IMembershipManager membershipManager, ApplicationIdentityUserManager userManager, ICredentialManager credentialManager, IConfiguration configuration, IHttpContextAccessor httpContextAccessor) : base(repository, userManager, httpContextAccessor, membershipManager, configuration) { this.httpContextAccessor = httpContextAccessor; this.credentialManager = credentialManager; this.credentialManager.SetContext(SecurityContext); }
public DefaultUserManager(IHttpContextAccessor httpContextAccessor, IStorage storage) { this.httpContextAccessor = httpContextAccessor; this.storage = storage; this.permissionRepository = this.storage.GetRepository <IPermissionRepository>(); this.roleRepository = this.storage.GetRepository <IRoleRepository>(); this.rolePermissionRepository = this.storage.GetRepository <IRolePermissionRepository>(); this.userRepository = this.storage.GetRepository <IUserRepository>(); this.userRoleRepository = this.storage.GetRepository <IUserRoleRepository>(); this.credentialTypeRepository = this.storage.GetRepository <ICredentialTypeRepository>(); this.credentialRepository = this.storage.GetRepository <ICredentialRepository>(); }
public CredentialManager(ICredentialRepository repo, IPersonRepository personRepository, IAgentRepository agentRepository, IOrganizationSettingRepository organizationSettingRepository, IOrganizationManager organizationManager, IConfiguration configuration) { _repo = repo; _personRepository = personRepository; _agentRepository = agentRepository; _organizationSettingRepository = organizationSettingRepository; _organizationManager = organizationManager; _configuration = configuration; }
/// <summary> /// Use saved credentials if omitted. /// </summary> /// <param name="credentialRepository"> /// A <see cref="ICredentialRepository"/> to load saved credentials from. /// </param> /// <param name="server"> /// The server name. This cannot be null, empty or whitespace. /// </param> /// <param name="suppliedUserName"> /// The user name given on the command line. Use the stored one if null. /// </param> /// <param name="suppliedPassword"> /// The password given on the command line. Use the stored one if null. /// </param> /// <param name="userName"> /// Receives the user name. /// </param> /// <param name="password"> /// Received the password. /// </param> /// <exception cref="ArgumentException"> /// <paramref name="server"/> cannot be null, empty or whitespace. /// </exception> /// <exception cref="CredentialNotFoundException"> /// No credentials are specified or saved for that server. /// </exception> private static void GetCredentials(ICredentialRepository credentialRepository, string server, string suppliedUserName, string suppliedPassword, out string userName, out string password) { if (string.IsNullOrWhiteSpace(suppliedUserName) || string.IsNullOrWhiteSpace(suppliedPassword)) { credentialRepository.Load(server, out userName, out password); } else { userName = suppliedUserName; password = suppliedPassword; } }
public CredentialChangedEventArgs(ICredentialRecord credentialRecord, ICredentialRepository repository) { if (credentialRecord == null) { throw new ArgumentNullException(nameof(credentialRecord)); } if (repository == null) { throw new ArgumentNullException(nameof(repository)); } CredentialRecord = credentialRecord; Repository = repository; }
/// <summary> /// CredentialsController constructor /// </summary> /// <param name="repository"></param> /// <param name="membershipManager"></param> /// <param name="userManager"></param> /// <param name="credentialManager"></param> /// <param name="configuration"></param> /// <param name="httpContextAccessor"></param> /// <param name="webhookPublisher"></param> public CredentialsController( ICredentialRepository repository, IMembershipManager membershipManager, ApplicationIdentityUserManager userManager, ICredentialManager credentialManager, IConfiguration configuration, IHttpContextAccessor httpContextAccessor, IWebhookPublisher webhookPublisher, ICredentialRepository credentialRepository) : base(repository, userManager, httpContextAccessor, membershipManager, configuration) { _httpContextAccessor = httpContextAccessor; _credentialManager = credentialManager; _credentialManager.SetContext(SecurityContext); _webhookPublisher = webhookPublisher; _credentialRepository = credentialRepository; }
public IndexViewModel Create(int userId, string orderBy, string direction, int skip, int take, string filter) { ICredentialRepository credentialRepository = this.RequestHandler.Storage.GetRepository <ICredentialRepository>(); return(new IndexViewModel() { UserId = userId, Grid = new GridViewModelFactory(this.RequestHandler).Create( orderBy, direction, skip, take, credentialRepository.CountByUserId(userId, filter), new[] { new GridColumnViewModelFactory(this.RequestHandler).Create("Credential Type"), new GridColumnViewModelFactory(this.RequestHandler).Create("Identifier", "Identifier"), new GridColumnViewModelFactory(this.RequestHandler).CreateEmpty() }, credentialRepository.FilteredByUserIdRange(userId, orderBy, direction, skip, take, filter).ToList().Select(c => new CredentialViewModelFactory(this.RequestHandler).Create(c)), "_Credential" ) }); }
public IndexViewModel Build(int userId, string orderBy, string direction, int skip, int take) { ICredentialRepository credentialRepository = this.handler.Storage.GetRepository <ICredentialRepository>(); return(new IndexViewModel() { UserId = userId, Grid = new GridViewModelBuilder(this.handler).Build( orderBy, direction, skip, take, credentialRepository.CountByUserId(userId), new[] { new GridColumnViewModelBuilder(this.handler).Build("Credential Type"), new GridColumnViewModelBuilder(this.handler).Build("Identifier", "Identifier"), new GridColumnViewModelBuilder(this.handler).BuildEmpty() }, credentialRepository.Range(userId, orderBy, direction, skip, take).Select(c => new CredentialViewModelBuilder(this.handler).Build(c)), "_Credential" ) }); }
/// <summary> /// Save user credentials. /// </summary> /// <param name="credentialRepository"> /// The <see cref="ICredentialRepository"/> to save credentials to. /// </param> /// <param name="server"> /// The Checkmarx server name. Cannot be null, empty or whitespace. /// </param> /// <param name="userName"> /// The username to login with. Cannot be null, empty or whitespace. /// </param> /// <param name="password"> /// The password to login with. Cannot be null. /// </param> /// <returns> /// The process return value. /// </returns> /// <exception cref="ArgumentException"> /// <paramref name="server"/>, <paramref name="userName"/> and <paramref name="password"/> cannot /// be null, empty or whitespace. /// </exception> /// <exception cref="ArgumentNullException"> /// <paramref name="credentialRepository"/> cannot be null. /// </exception> private static int SaveCredentials(ICredentialRepository credentialRepository, string server, string userName, string password) { if (credentialRepository == null) { throw new ArgumentNullException(nameof(credentialRepository)); } if (string.IsNullOrWhiteSpace(server)) { throw new ArgumentException("Argument is null or whitespace", nameof(server)); } if (string.IsNullOrWhiteSpace(userName)) { throw new ArgumentException("Argument is null or whitespace", nameof(userName)); } if (string.IsNullOrWhiteSpace(password)) { throw new ArgumentException("Argument is null or whitespace", nameof(password)); } credentialRepository.Save(server, userName, password); return(ExitSuccess); }
public IActionResult ResetPassword(ResetPasswordViewModel resetPassword) { ICredentialRepository credentialRepository = this.Storage.GetRepository <ICredentialRepository>(); if (this.ModelState.IsValid) { string newPassword = new Random().Next(10000000, 99999999).ToString(); UserManager.ChangeSecretResult changeSecretResult = new UserManager(this).ChangeSecret("Email", resetPassword.Email, newPassword); if (changeSecretResult.Success) { this.emailSender.SendEmail(resetPassword.Email, "New password", newPassword, null); return(this.RedirectToAction("PasswordSent")); } else { this.ModelState.AddModelError(nameof(resetPassword.Email), string.Empty); } } return(this.CreateRedirectToSelfResult()); }
public CredentialService(ICustomFormsAuthentication customFormsAuthentication, IHashService hashService, ICredentialRepository credentialRepository) { this.CustomFormsAuthentication = customFormsAuthentication; this.CredentialRepository = credentialRepository; this.HashService = hashService; }
public AddImageRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository) : base(webRequestFactory, logProvider, credentialRepository) { }
/// <summary> /// Initializes a new instance of the <see cref="SymmetricCrypto"/> class. /// </summary> /// <param name="credentialRepository"> /// An object that can retrieve <see cref="ICredential"/> objects. /// </param> /// <param name="encoding"> /// The <see cref="Encoding"/> that is used to convert a <c>string</c> object to a /// <c>byte[]</c> value. /// </param> public SymmetricCrypto(ICredentialRepository credentialRepository, Encoding encoding = null) { _credentialRepository = credentialRepository; _encoding = encoding ?? Encoding.UTF8; }
protected BaseRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository) { _webRequestFactory = webRequestFactory; _log = logProvider.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType); _credentialRepository = credentialRepository; }
public void AddRepository(ICredentialRepository repository) { _repositoryList.AddProvider(repository); }
public void RemoveRepository(ICredentialRepository repository) { _repositoryList.RemoveProvider(repository); }
public CredentialManager(ICredentialRepository repo) { this.repo = repo; }
public TestRequest(IWebRequestFactory webRequestFactory, ILogProvider logProvider, ICredentialRepository credentialRepository) : base(webRequestFactory, logProvider, credentialRepository) { }
public UserController(ICredentialRepository credRepo, ILogger <UserController> logger) { _credRepo = credRepo; _logger = logger; }
public ReportController(ICredentialRepository credentialRepository) { _CredentialRepository = credentialRepository; }