public SetupMultipleProgramService(ILogger <SetupMultipleProgramService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IAuthorizationCodeRepository authorizationCodeRepository,
IBranchRepository branchRepository,
IChallengeTaskRepository challengeTaskRepository,
IProgramRepository programRepository,
IRoleRepository roleRepository,
ISystemRepository systemRepository,
IPointTranslationRepository pointTranslationRepository,
IUserRepository userRepository) : base(logger, dateTimeProvider)
{
_authorizationCodeRepository = authorizationCodeRepository
?? throw new ArgumentNullException(nameof(authorizationCodeRepository));
_branchRepository = branchRepository
?? throw new ArgumentNullException(nameof(branchRepository));
_challengeTaskRepository = challengeTaskRepository
?? throw new ArgumentNullException(nameof(challengeTaskRepository));
_programRepository = programRepository
?? throw new ArgumentNullException(nameof(programRepository));
_roleRepository = roleRepository
?? throw new ArgumentNullException(nameof(roleRepository));
_systemRepository = systemRepository
?? throw new ArgumentNullException(nameof(systemRepository));
_pointTranslationRepository = pointTranslationRepository
?? throw new ArgumentNullException(nameof(pointTranslationRepository));
_userRepository = userRepository
?? throw new ArgumentNullException(nameof(userRepository));
}
public AuthorizationCodeStore(
IAuthorizationCodeRepository repository,
IClientRepository clientRepository,
IPropertySerializer propertySerializer) : base(repository)
{
_clientRepository = clientRepository;
_propertySerializer = propertySerializer;
}
public AuthorizationCodeService(ILogger <AuthorizationCodeService> logger,
GRA.Abstract.IDateTimeProvider dateTimeProvider,
IUserContextProvider userContextProvider,
IAuthorizationCodeRepository authorizationCodeRepository)
: base(logger, dateTimeProvider, userContextProvider)
{
SetManagementPermission(Model.Permission.ManageRoles);
_authorizationCodeRepository = authorizationCodeRepository
?? throw new ArgumentNullException(nameof(authorizationCodeRepository));
}
public OAuthController(AuthUnitOfWork <User> authUnitOfWork,
//IClientRepository clientRepository, IConsentRepository<User> consentRepository,
IAuthorizationCodeRepository <User> authorizationCodeRepository, JwtSecurityTokenHelper tokenHelper)
{
_authUnitOfWork = authUnitOfWork;
//_clientRepository = clientRepository;
//_consentRepository = consentRepository;
_authorizationCodeRepository = authorizationCodeRepository;
_tokenHelper = tokenHelper;
}
public UserService(ILogger <UserService> logger,
IUserContextProvider userContextProvider,
GRA.Abstract.IPasswordValidator passwordValidator,
IAuthorizationCodeRepository authorizationCodeRepository,
IBadgeRepository badgeRepository,
IBookRepository bookRepository,
IBranchRepository branchRepository,
IMailRepository mailRepository,
INotificationRepository notificationRepository,
IPrizeWinnerRepository prizeWinnerRepository,
IProgramRepository programRepository,
IRequiredQuestionnaireRepository requireQuestionnaireRepository,
IRoleRepository roleRepository,
ISchoolRepository schoolRepository,
ISiteRepository siteRepository,
IStaticAvatarRepository staticAvatarRepository,
ISystemRepository systemRepository,
IUserLogRepository userLogRepository,
IUserRepository userRepository,
IVendorCodeRepository vendorCodeRepository,
ActivityService activityService,
SampleDataService configurationService,
SchoolService schoolService)
: base(logger, userContextProvider)
{
_passwordValidator = Require.IsNotNull(passwordValidator, nameof(passwordValidator));
_authorizationCodeRepository = Require.IsNotNull(authorizationCodeRepository,
nameof(authorizationCodeRepository));
_badgeRepository = Require.IsNotNull(badgeRepository, nameof(badgeRepository));
_bookRepository = Require.IsNotNull(bookRepository, nameof(bookRepository));
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_mailRepository = Require.IsNotNull(mailRepository, nameof(mailRepository));
_notificationRepository = Require.IsNotNull(notificationRepository,
nameof(notificationRepository));
_prizeWinnerRepository = Require.IsNotNull(prizeWinnerRepository,
nameof(prizeWinnerRepository));
_programRepository = Require.IsNotNull(programRepository, nameof(programRepository));
_requireQuestionnaireRepository = Require.IsNotNull(requireQuestionnaireRepository,
nameof(requireQuestionnaireRepository));
_roleRepository = Require.IsNotNull(roleRepository, nameof(roleRepository));
_schoolRepository = Require.IsNotNull(schoolRepository, nameof(schoolRepository));
_siteRepository = Require.IsNotNull(siteRepository, nameof(siteRepository));
_staticAvatarRepository = Require.IsNotNull(staticAvatarRepository,
nameof(staticAvatarRepository));
_systemRepository = Require.IsNotNull(systemRepository, nameof(systemRepository));
_userLogRepository = Require.IsNotNull(userLogRepository, nameof(userLogRepository));
_userRepository = Require.IsNotNull(userRepository, nameof(userRepository));
_vendorCodeRepository = Require.IsNotNull(vendorCodeRepository, nameof(vendorCodeRepository));
_activityService = Require.IsNotNull(activityService, nameof(activityService));
_configurationService = Require.IsNotNull(configurationService,
nameof(configurationService));
_schoolService = Require.IsNotNull(schoolService, nameof(schoolService));
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="appSettings"><see cref="IAppSettings"/></param>
/// <param name="accessTokenRepository"><see cref="IAccessTokenRepository"/></param>
/// <param name="authorizationCodeRepository"><see cref="IAuthorizationCodeRepository"/></param>
/// <param name="applicationRepository"><see cref="IApplicationRepository"/></param>
/// <param name="accountService"><see cref="IAccountService"/></param>
public AuthorizeService(
IAppSettings appSettings,
IAccessTokenRepository accessTokenRepository,
IAuthorizationCodeRepository authorizationCodeRepository,
IApplicationRepository applicationRepository,
IAccountService accountService)
{
_appSettings = appSettings;
_accessTokenRepository = accessTokenRepository;
_authorizationCodeRepository = authorizationCodeRepository;
_applicationRepository = applicationRepository;
_accountService = accountService;
}
public AuthorizeService(
IFindApplicationService findApplicationService,
IAuthenticateUserService authenticateUserService,
IAuthorizationCodeRepository authorizationCodeRepository,
IPasswordGenerator passwordGenerator,
OAuth2Settings settings)
{
_findApplicationService = findApplicationService;
_authenticateUserService = authenticateUserService;
_authorizationCodeRepository = authorizationCodeRepository;
_passwordGenerator = passwordGenerator;
_settings = settings;
}
public AuthorizationCodeTokenGenerator(
IAuthenticateClientService authenticateClientService,
IFindApplicationService applicationService,
IRefreshTokenGenerator refreshTokenGenerator,
IAuthorizationCodeRepository authorizationCodeRepository,
IAccessTokenRepository accessTokenRepository,
IRefreshTokenRepository refreshTokenRepository,
IJwtTokenFactory jwtTokenFactory)
{
_authenticateClientService = authenticateClientService;
_findApplicationService = applicationService;
_refreshTokenGenerator = refreshTokenGenerator;
_authorizationCodeRepository = authorizationCodeRepository;
_accessTokenRepository = accessTokenRepository;
_refreshTokenRepository = refreshTokenRepository;
_jwtTokenFactory = jwtTokenFactory;
}
public OAuthService(IClientAuthRepository clientRepository,
IServerAccessGrantRepository serverAccessRepository,
IUserProxyRepository userProxRepository,
IAuthorizationCodeRepository authCodeRepository)
{
this.clientRepository = clientRepository;
this.serverAccessRepository = serverAccessRepository;
this.userProxRepository = userProxRepository;
this.authCodeRepository = authCodeRepository;
serverAccessGrantCache = CacheDomain.CreateSingleKey <ServerAccessGrant, string>(
o => o.AccessToken,
GetServerAccessGrantInner,
null,
SERVER_ACCESSGRANT_CACHENAME,
SERVER_ACCESS_GRANT_CACHEFORMAT);
}
public TokenCleanup(DocumentDbServiceOptions options, int interval = 60)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (interval < 1)
{
throw new ArgumentException("interval must be more than 1 second");
}
var connectionSettings = options.ToConnectionSettings();
this._interval = TimeSpan.FromSeconds(interval);
_refreshTokenRepository = new RefreshTokenRepository(options.CollectionNameResolver, connectionSettings);
_authorizationCodeRepository = new AuthorizationCodeRepository(options.CollectionNameResolver, connectionSettings);
_tokenHandleRepository = new TokenHandleRepository(options.CollectionNameResolver, connectionSettings);
}
public SetupMultipleProgramService(ILogger <SetupMultipleProgramService> logger,
IAuthorizationCodeRepository authorizationCodeRepository,
IBranchRepository branchRepository,
IChallengeTaskRepository challengeTaskRepository,
IProgramRepository programRepository,
IRoleRepository roleRepository,
ISystemRepository systemRepository,
IPointTranslationRepository pointTranslationRepository) : base(logger)
{
_authorizationCodeRepository = Require.IsNotNull(authorizationCodeRepository,
nameof(authorizationCodeRepository));
_branchRepository = Require.IsNotNull(branchRepository, nameof(branchRepository));
_challengeTaskRepository = Require.IsNotNull(challengeTaskRepository,
nameof(challengeTaskRepository));
_programRepository = Require.IsNotNull(programRepository,
nameof(programRepository));
_roleRepository = Require.IsNotNull(roleRepository, nameof(roleRepository));
_systemRepository = Require.IsNotNull(systemRepository, nameof(systemRepository));
_pointTranslationRepository = Require.IsNotNull(pointTranslationRepository,
nameof(pointTranslationRepository));
}
public GetTokenByAuthorizationCodeGrantTypeAction(
IClientValidator clientValidator,
IAuthorizationCodeRepository authorizationCodeRepository,
IConfigurationService configurationService,
IGrantedTokenGeneratorHelper grantedTokenGeneratorHelper,
IGrantedTokenRepository grantedTokenRepository,
IAuthenticateClient authenticateClient,
IClientHelper clientHelper,
ISimpleIdentityServerEventSource simpleIdentityServerEventSource,
IAuthenticateInstructionGenerator authenticateInstructionGenerator,
IGrantedTokenHelper grantedTokenHelper)
{
_clientValidator = clientValidator;
_authorizationCodeRepository = authorizationCodeRepository;
_configurationService = configurationService;
_grantedTokenGeneratorHelper = grantedTokenGeneratorHelper;
_grantedTokenRepository = grantedTokenRepository;
_authenticateClient = authenticateClient;
_clientHelper = clientHelper;
_simpleIdentityServerEventSource = simpleIdentityServerEventSource;
_authenticateInstructionGenerator = authenticateInstructionGenerator;
_grantedTokenHelper = grantedTokenHelper;
}
public GenerateAuthorizationResponse(
IAuthorizationCodeRepository authorizationCodeRepository,
IParameterParserHelper parameterParserHelper,
IJwtGenerator jwtGenerator,
IGrantedTokenGeneratorHelper grantedTokenGeneratorHelper,
IGrantedTokenRepository grantedTokenRepository,
IConsentHelper consentHelper,
ISimpleIdentityServerEventSource simpleIdentityServerEventSource,
IAuthorizationFlowHelper authorizationFlowHelper,
IClientHelper clientHelper,
IGrantedTokenHelper grantedTokenHelper)
{
_authorizationCodeRepository = authorizationCodeRepository;
_parameterParserHelper = parameterParserHelper;
_jwtGenerator = jwtGenerator;
_grantedTokenGeneratorHelper = grantedTokenGeneratorHelper;
_grantedTokenRepository = grantedTokenRepository;
_consentHelper = consentHelper;
_simpleIdentityServerEventSource = simpleIdentityServerEventSource;
_authorizationFlowHelper = authorizationFlowHelper;
_clientHelper = clientHelper;
_grantedTokenHelper = grantedTokenHelper;
}
public AuthorizationCodeArchiver(IAuthorizationCodeRepository repository)
{
_repository = repository;
}
