public ResourceScopeService(IResourceScopeRepository resourceScopeRepository,
IResourceRepository resourceRepository, IScopeRepository scopeRepository)
{
this._resourceScopeRepository = resourceScopeRepository;
this._resourceRepository = resourceRepository;
this._scopeRepository = scopeRepository;
}
public DeleteScopeAction(
IScopeRepository scopeRepository,
IUmaServerEventSource umaServerEventSource)
{
_scopeRepository = scopeRepository;
_umaServerEventSource = umaServerEventSource;
}
public UpdateScopeService(
IScopeRepository scopeRepository,
IApplicationRepository applicationRepository)
{
_scopeRepository = scopeRepository;
_applicationRepository = applicationRepository;
}
public UpdateScopeAction(
IScopeRepository scopeRepository,
IScopeParameterValidator scopeParameterValidator)
{
_scopeRepository = scopeRepository;
_scopeParameterValidator = scopeParameterValidator;
}
public DeleteScopeOperation(
IScopeRepository scopeRepository,
IManagerEventSource managerEventSource)
{
_scopeRepository = scopeRepository;
_managerEventSource = managerEventSource;
}
/// <summary>
/// Create a new scopde domain service instance
/// </summary>
/// <param name="authenticatedUser">Authenticated user object</param>
/// <param name="uow">Unit of Work object</param>
/// <param name="repository">User repository service</param>
/// <param name="credentialRepository">Credential repository service</param>
/// <param name="tokenRepository">User credential token repository service</param>
/// <param name="scopeRepository">Scope repository</param>
/// <param name="roleRepository">Role repository</param>
/// <param name="securityOptions">Security options configuration</param>
/// <param name="credentialOptions">Credential options configuration</param>
/// <param name="localizer">Language string localizer</param>
public UserDomainService
(
IAuthenticatedUser authenticatedUser,
IUnitOfWork uow,
IUserRepository repository,
IUserCredentialRepository credentialRepository,
IUserCredentialTokenRepository tokenRepository,
IScopeRepository scopeRepository,
IRoleRepository roleRepository,
IOptions <SecurityOptions> securityOptions,
IOptions <CredentialOptions> credentialOptions,
IStringLocalizer <UserDomainService> localizer
) : base(repository, authenticatedUser)
{
_uow = uow;
_repository = repository;
_credentialRepository = credentialRepository;
_tokenRepository = tokenRepository;
_scopeRepository = scopeRepository;
_roleRepository = roleRepository;
_securityOptions = securityOptions?.Value;
_credentialOptions = credentialOptions?.Value;
_localizer = localizer;
}
public GetTokenViaImplicitWorkflowOperation(
IClientStore clientStore,
IConsentRepository consentRepository,
IAuthorizationCodeStore authorizationCodeStore,
ITokenStore tokenStore,
IScopeRepository scopeRepository,
IJwksStore jwksStore,
IEventPublisher eventPublisher,
ILogger logger)
{
_logger = logger;
_processAuthorizationRequest = new ProcessAuthorizationRequest(
clientStore,
consentRepository,
jwksStore,
logger);
_generateAuthorizationResponse = new GenerateAuthorizationResponse(
authorizationCodeStore,
tokenStore,
scopeRepository,
clientStore,
consentRepository,
jwksStore,
eventPublisher,
logger);
}
public HomeController(IPersonRepository personRepository, ISingletonRepository singletonRepository, IScopeRepository scopeRepository, ITransiantRepository transiantRepository)
{
PersonRepository = personRepository;
this.singletonRepository = singletonRepository;
this.scopeRepository = scopeRepository;
this.transiantRepository = transiantRepository;
}
public ClaimsService(IClaimRepository claimRepository, IScopeRepository scopeRepository,
IScopeClaimRepository scopeClaimRepository, IUserScopeClaimRepository userScopeClaimRepository)
{
_claimRepository = claimRepository;
_scopeRepository = scopeRepository;
_scopeClaimRepository = scopeClaimRepository;
_userScopeClaimRepository = userScopeClaimRepository;
}
public JsonPropertySerializer(IScopeRepository scopeStore, IClientRepository clientStore)
{
_serializerSettings = new JsonSerializerSettings();
_serializerSettings.Converters.Add(new ClaimConverter());
_serializerSettings.Converters.Add(new ClaimsPrincipalConverter());
_serializerSettings.Converters.Add(new ScopeConverter(scopeStore));
_serializerSettings.Converters.Add(new ClientConverter(clientStore));
}
public AssignmentPolicyService(IAssignmentPolicyRepository assignmentPolicyRepository, IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository,
IScopeRepository scopeRepository, IScopeService scopeService)
{
_assignmentPolicyRepository = assignmentPolicyRepository;
_assignmentPolicyPairingRepository = assignmentPolicyPairingRepository;
_scopeRepository = scopeRepository;
_scopeService = scopeService;
}
public UpdateClientAction(IClientRepository clientRepository, IGenerateClientFromRegistrationRequest generateClientFromRegistrationRequest, IScopeRepository scopeRepository,
IManagerEventSource managerEventSource)
{
_clientRepository = clientRepository;
_generateClientFromRegistrationRequest = generateClientFromRegistrationRequest;
_scopeRepository = scopeRepository;
_managerEventSource = managerEventSource;
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticateController"/> class.
/// </summary>
/// <param name="dataProtectionProvider">The data protection provider.</param>
/// <param name="urlHelperFactory">The URL helper factory.</param>
/// <param name="actionContextAccessor">The action context accessor.</param>
/// <param name="eventPublisher">The event publisher.</param>
/// <param name="authenticationService">The authentication service.</param>
/// <param name="authenticationSchemeProvider">The authentication scheme provider.</param>
/// <param name="resourceOwnerServices">The resource owner services.</param>
/// <param name="twoFactorAuthenticationHandler">The two factor authentication handler.</param>
/// <param name="subjectBuilder">The subject builder.</param>
/// <param name="authorizationCodeStore">The authorization code store.</param>
/// <param name="scopeRepository">The scope repository.</param>
/// <param name="tokenStore">The token store.</param>
/// <param name="consentRepository">The consent repository.</param>
/// <param name="confirmationCodeStore">The confirmation code store.</param>
/// <param name="clientStore">The client store.</param>
/// <param name="resourceOwnerRepository">The resource owner repository.</param>
/// <param name="jwksStore"></param>
/// <param name="accountFilters">The account filters.</param>
/// <param name="logger">The controller logger.</param>
/// <param name="runtimeSettings">The runtime settings.</param>
public AuthenticateController(
IDataProtectionProvider dataProtectionProvider,
IUrlHelperFactory urlHelperFactory,
IActionContextAccessor actionContextAccessor,
IEventPublisher eventPublisher,
IAuthenticationService authenticationService,
IAuthenticationSchemeProvider authenticationSchemeProvider,
IEnumerable <IAuthenticateResourceOwnerService> resourceOwnerServices,
ITwoFactorAuthenticationHandler twoFactorAuthenticationHandler,
ISubjectBuilder subjectBuilder,
IAuthorizationCodeStore authorizationCodeStore,
IScopeRepository scopeRepository,
ITokenStore tokenStore,
IConsentRepository consentRepository,
IConfirmationCodeStore confirmationCodeStore,
IClientStore clientStore,
IResourceOwnerRepository resourceOwnerRepository,
IJwksStore jwksStore,
IEnumerable <AccountFilter> accountFilters,
ILogger <AuthenticateController> logger,
RuntimeSettings runtimeSettings)
: base(
dataProtectionProvider,
urlHelperFactory,
actionContextAccessor,
eventPublisher,
authenticationService,
authenticationSchemeProvider,
twoFactorAuthenticationHandler,
authorizationCodeStore,
consentRepository,
scopeRepository,
tokenStore,
resourceOwnerRepository,
confirmationCodeStore,
clientStore,
jwksStore,
subjectBuilder,
accountFilters,
logger,
runtimeSettings)
{
_eventPublisher = eventPublisher;
_logger = logger;
var services = resourceOwnerServices.ToArray();
_resourceOwnerServices = services;
_localOpenIdAuthentication = new LocalOpenIdUserAuthenticationAction(
authorizationCodeStore,
services,
consentRepository,
tokenStore,
scopeRepository,
clientStore,
jwksStore,
eventPublisher,
logger);
}
public AddRoleScopeRelationService(
IFindRoleService findRoleService,
IRoleRepository roleRepository,
IScopeRepository scopeRepository)
{
_findRoleService = findRoleService;
_roleRepository = roleRepository;
_scopeRepository = scopeRepository;
}
public InsertScopeAction(
IScopeRepository scopeRepository,
IScopeParameterValidator scopeParameterValidator,
IUmaServerEventSource umaServerEventSource)
{
_scopeRepository = scopeRepository;
_scopeParameterValidator = scopeParameterValidator;
_umaServerEventSource = umaServerEventSource;
}
public PortfolioController(IContractRepository contractRepository, IPortfolioRepository portfolioRepository,
IScopeRepository scopeRepository,
IGeographicalZoneRepository zoneRepository)
{
this.contractRepository = contractRepository;
this.portfolioRepository = portfolioRepository;
this.scopeRepository = scopeRepository;
this.zoneRepository = zoneRepository;
}
public AgreementConsentService(
IEventService eventService,
IIdentityServerInteractionService interaction,
IScopeRepository scopeRepository)
{
this.eventService = eventService ?? throw new ArgumentNullException(nameof(eventService));
this.interaction = interaction ?? throw new ArgumentNullException(nameof(interaction));
this.scopeRepository = scopeRepository ?? throw new ArgumentNullException(nameof(scopeRepository));
}
public AcademicoController(IUserRepository userRepository, ITaskListRepository taskListRepository, ICardRepository cardRepository, IScopeRepository scopeRepository, IUserTasklistRepository userTasklistRepository, UserManager <User> userManager)
{
this.userRepository = userRepository;
this.taskListRepository = taskListRepository;
this.cardRepository = cardRepository;
this.scopeRepository = scopeRepository;
this.userTasklistRepository = userTasklistRepository;
this.userManager = userManager;
}
public GetScopesService(
IFindRoleService findRoleService,
IScopeRepository scopeRepository,
IApplicationRepository applicationRepository)
{
_findRoleService = findRoleService;
_scopeRepository = scopeRepository;
_applicationRepository = applicationRepository;
}
public ScopeConverter(IScopeRepository scopeRepo)
{
if (scopeRepo == null)
{
throw new ArgumentNullException(nameof(scopeRepo));
}
this._scopeRepo = scopeRepo;
}
public ScopeService(
IScopeRepository repository,
OpenIddictScopeManager <OpenIddictEntityFrameworkCoreScope> manager
)
{
_repository = repository
?? throw new ArgumentNullException(nameof(repository));
_manager = manager
?? throw new ArgumentNullException(nameof(manager));
}
public ClaimsPrincipalService(IUserScopeClaimRepository userScopeClaimRepository, IScopeClaimRepository scopeClaimRepository, IClaimRepository claimRepository,
IScopeRepository scopeRepository, IClaimsService claimService, IScopeService scopeService, IUserScopeRepository userScopeRepository, IUserClaimRepository userClaimRepository)
{
_userScopeClaimRepository = userScopeClaimRepository;
_scopeClaimRepository = scopeClaimRepository;
_claimRepository = claimRepository;
_scopeRepository = scopeRepository;
_claimService = claimService;
_scopeService = scopeService;
_userScopeRepository = userScopeRepository;
_userClaimRepository = userClaimRepository;
}
public DisplayConsentAction(
IScopeRepository scopeRepository,
IClientRepository clientRepository,
IConsentHelper consentHelper,
IGenerateAuthorizationResponse generateAuthorizationResponse,
IParameterParserHelper parameterParserHelper,
IActionResultFactory actionResultFactory)
{
_scopeRepository = scopeRepository;
_clientRepository = clientRepository;
_consentHelper = consentHelper;
_generateAuthorizationResponse = generateAuthorizationResponse;
_parameterParserHelper = parameterParserHelper;
_actionResultFactory = actionResultFactory;
}
public ClientRepository(
IClientFactory factory,
ISecretsRepository secretsRepo,
IScopeRepository scopeRepo,
IClaimRepository claimRepo,
IGrantTypeRepository grantRepo,
ResourceConfigDbContext context
)
{
_factory = factory;
_secretsRepo = secretsRepo;
_scopeRepo = scopeRepo;
_claimRepo = claimRepo;
_grantRepo = grantRepo;
ctx = context;
}
public MemoryRepository(ISingletonRepository singletonRepository, IScopeRepository scopeRepository, ITransiantRepository transiantRepository)
{
this.singletonRepository = singletonRepository;
this.scopeRepository = scopeRepository;
this.transiantRepository = transiantRepository;
people = new Dictionary <string, Person>();
new List <Person>
{
new Person {
id = 1, FullName = "Ali Alizade"
},
new Person {
id = 2, FullName = "Rebi poori"
}
}.ForEach(p => AddPerson(p));
}
public ComposerContext(
ICookieAccessor <ComposerCookieDto> cookieAccessor,
IScopeProvider scopeProvider,
HttpContextBase httpContextBase,
ICountryCodeProvider countryCodeProvider,
IWebsiteContext websiteContext,
IScopeRepository scopeRepository)
{
CookieAccessor = cookieAccessor ?? throw new ArgumentNullException(nameof(cookieAccessor));
ScopeProvider = scopeProvider ?? throw new ArgumentNullException(nameof(scopeProvider));
HttpContextBase = httpContextBase ?? throw new ArgumentNullException(nameof(httpContextBase));
CountryCodeProvider = countryCodeProvider ?? throw new ArgumentNullException(nameof(countryCodeProvider));
WebsiteContext = websiteContext ?? throw new ArgumentNullException(nameof(websiteContext));
EncryptionUtility = new EncryptionUtility();
ScopeRepository = scopeRepository ?? throw new ArgumentNullException(nameof(scopeRepository));
SetAuthenticated();
}
public AuthorizationActions(
IAuthorizationCodeStore authorizationCodeStore,
IClientStore clientStore,
ITokenStore tokenStore,
IScopeRepository scopeRepository,
IConsentRepository consentRepository,
IJwksStore jwksStore,
IEventPublisher eventPublisher,
IEnumerable <IAuthenticateResourceOwnerService> resourceOwnerServices,
ILogger logger)
{
_getAuthorizationCodeOperation = new GetAuthorizationCodeOperation(
authorizationCodeStore,
tokenStore,
scopeRepository,
clientStore,
consentRepository,
jwksStore,
eventPublisher,
logger);
_getTokenViaImplicitWorkflowOperation = new GetTokenViaImplicitWorkflowOperation(
clientStore,
consentRepository,
authorizationCodeStore,
tokenStore,
scopeRepository,
jwksStore,
eventPublisher,
logger);
_getAuthorizationCodeAndTokenViaHybridWorkflowOperation =
new GetAuthorizationCodeAndTokenViaHybridWorkflowOperation(
clientStore,
consentRepository,
authorizationCodeStore,
tokenStore,
scopeRepository,
jwksStore,
eventPublisher,
logger);
_authorizationCodeGrantTypeParameterValidator =
new AuthorizationCodeGrantTypeParameterAuthEdpValidator(clientStore, logger);
_eventPublisher = eventPublisher;
_logger = logger;
_resourceOwnerServices = resourceOwnerServices.ToArray();
}
public GenerateAuthorizationResponse(
IAuthorizationCodeStore authorizationCodeStore,
ITokenStore tokenStore,
IScopeRepository scopeRepository,
IClientStore clientStore,
IConsentRepository consentRepository,
IJwksStore jwksStore,
IEventPublisher eventPublisher,
ILogger logger)
{
_authorizationCodeStore = authorizationCodeStore;
_tokenStore = tokenStore;
_jwtGenerator = new JwtGenerator(clientStore, scopeRepository, jwksStore, logger);
_eventPublisher = eventPublisher;
_clientStore = clientStore;
_consentRepository = consentRepository;
_jwksStore = jwksStore;
}
public AuthenticateResourceOwnerOpenIdAction(
IAuthorizationCodeStore authorizationCodeStore,
ITokenStore tokenStore,
IScopeRepository scopeRepository,
IConsentRepository consentRepository,
IClientStore clientStore,
IJwksStore jwksStore,
IEventPublisher eventPublisher,
ILogger logger)
{
_authenticateHelper = new AuthenticateHelper(
authorizationCodeStore,
tokenStore,
scopeRepository,
consentRepository,
clientStore,
jwksStore,
eventPublisher,
logger);
}
public JwtGenerator(
IConfigurationService configurationService,
IClientRepository clientRepository,
IClientValidator clientValidator,
IJsonWebKeyRepository jsonWebKeyRepository,
IScopeRepository scopeRepository,
IClaimsMapping claimsMapping,
IParameterParserHelper parameterParserHelper,
IJwsGenerator jwsGenerator,
IJweGenerator jweGenerator)
{
_configurationService = configurationService;
_clientRepository = clientRepository;
_clientValidator = clientValidator;
_jsonWebKeyRepository = jsonWebKeyRepository;
_scopeRepository = scopeRepository;
_claimsMapping = claimsMapping;
_parameterParserHelper = parameterParserHelper;
_jwsGenerator = jwsGenerator;
_jweGenerator = jweGenerator;
}
public ScopeConverter(IScopeRepository scopeRepo)
{
if (scopeRepo == null) throw new ArgumentNullException(nameof(scopeRepo));
this._scopeRepo = scopeRepo;
}
public ScopeServiceLayer(IScopeRepository repo)
{
_repo = repo;
}
/// <summary>
/// Инициализирует новый экземпляр LocationController с внедрением зависемостей к хранилищам.</summary>
/// <param name="scopeRepository">Экземпляр класса ScopeRepository, предоставляющий доступ к хранилищу данных о списке сфер деятельности.</param>
public ScopeController(IScopeRepository scopeRepository)
{
this._scopeRepository = scopeRepository;
}
public ScopeStore(IScopeRepository scopeRepository)
{
_scopeRepository = scopeRepository;
}
