public UserTokenService(
IUserTokenRepository repository,
ICommandBus commandBus,
ILogger <UserTokenService> logger
) : base(repository, commandBus, logger)
{
}
public UserActionsService(IUserRepository userRepository, IPhoneRepository phoneRepository, IUserTokenRepository userTokenRepository, ISecurityHelper securityHelper)
{
this.userRepository = userRepository;
this.phoneRepository = phoneRepository;
this.userTokenRepository = userTokenRepository;
this.securityHelper = securityHelper;
}
public AccountsController(
IUserRepository repo,
UserManager <SensateUser> userManager,
IEmailSender emailer,
IOptions <UserAccountSettings> options,
IPasswordResetTokenRepository tokens,
IChangeEmailTokenRepository emailTokens,
IChangePhoneNumberTokenRepository phoneTokens,
IUserTokenRepository tokenRepository,
ITextSendService text,
IUserService userService,
ICommandPublisher publisher,
IOptions <TextServiceSettings> text_opts,
IWebHostEnvironment env,
IHttpContextAccessor ctx,
ILogger <AccountsController> logger
) : base(repo, ctx)
{
this.m_userService = userService;
this._logger = logger;
this._manager = userManager;
this._mailer = emailer;
this._passwd_tokens = tokens;
this._email_tokens = emailTokens;
this._env = env;
this._tokens = tokenRepository;
this._phonetokens = phoneTokens;
this._settings = options.Value;
this._text = text;
this.m_publisher = publisher;
this._text_settings = text_opts.Value;
}
public TokenStoreService(
IUnitOfWork uow,
ISecurityService securityService,
IRolesService rolesService,
IUsersService userService,
IOptionsSnapshot <BearerTokensOptions> configuration)
{
_uow = uow;
_uow.CheckArgumentIsNull(nameof(_uow));
_securityService = securityService;
_securityService.CheckArgumentIsNull(nameof(_securityService));
_rolesService = rolesService;
_rolesService.CheckArgumentIsNull(nameof(rolesService));
_userService = userService;
_rolesService.CheckArgumentIsNull(nameof(userService));
_tokens = _uow.Repository <UserToken>() as IUserTokenRepository;
_users = _uow.Repository <User>() as IUserRepository;
_configuration = configuration;
_configuration.CheckArgumentIsNull(nameof(configuration));
}
public PostRefreshLoginRequestHandler(
IUserRepository userRepository,
ITokenService tokenService,
IUserTokenRepository userTokenRepository)
: base(tokenService, userTokenRepository)
{
fUserRepository = userRepository;
}
public AuthConsumerService(IUserTokenRepository userTokenRepository,
IServiceProviderRepository serviceProviderRepository,
IAuthProviderFactory authProviderFactory)
{
_userTokenRepository = userTokenRepository;
_authProviderFactory = authProviderFactory;
_serviceProviderRepository = serviceProviderRepository;
}
public TokenService(IOptionsSnapshot <JWTSettings> tokenSettings, UserManager <Entity.User> userManager, IUserTokenRepository repository, IMapper mapper, ILogger <TokenService> logger)
{
this.tokenSettings = tokenSettings.Value;
this.repository = repository;
this.userManager = userManager;
this.mapper = mapper;
this.logger = logger;
}
public SendEmailPasswordResetHandler(
IUserRepository userRepository,
IUserTokenRepository userTokenRepository
)
{
this.userRepository = userRepository;
this.userTokenRepository = userTokenRepository;
}
public AuthenticationService(IAuthenticationRepository authenticationRepository, IUserClaimRepository userClaimRepository,
IUserLoginRepository userLoginRepository, IUserTokenRepository userTokenRepository)
{
_userTokenRepository = userTokenRepository;
_userLoginRepository = userLoginRepository;
_authenticationRepository = authenticationRepository;
_userClaimRepository = userClaimRepository;
}
public AddNewUser(IUserRepository userRepository,
IUserTokenRepository userTokenRepository, IUnitOfWork unitOfWork, IHasher hasher = null)
{
this.userRepository = userRepository;
this.userTokenRepository = userTokenRepository;
_unitOfWork = unitOfWork;
this.hasher = hasher ?? new Hasher();
}
public OAuthController(
IUserRepository userRepository,
IUserTokenRepository userTokenRepository,
IConfiguration configuration)
{
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
_appSettings = configuration.GetSection("Settings").Get <Settings>();
}
private void resetRepositories()
{
_roleClaimRepository = null;
_roleRepository = null;
_userClaimRepository = null;
_userLoginRepository = null;
_userRepository = null;
_userTokenRepository = null;
}
public ForgotPasswordCommandHandler(ILogger <ForgotPasswordCommandHandler> logger, IAdminUnitOfWork adminUnitOfWork, IUserRepository userRepository, IUserTokenRepository userTokenRepository, IEmailSender emailSender)
{
this._logger = logger;
this._adminUnitOfWork = adminUnitOfWork;
this._userRepository = userRepository;
this._userTokenRepository = userTokenRepository;
this._emailSender = emailSender;
this._validationResult = new ValidationResult();
}
public ApplicationUserStore(IUserRepository userRepository, IUserLoginRepository userLoginRepository,
IUserRoleRepository userRoleRepository, IUserClaimRepository userClaimRepository, IUserTokenRepository userTokenRepository)
{
_userRepository = userRepository;
_userLoginRepository = userLoginRepository;
_userRoleRepository = userRoleRepository;
_userClaimRepository = userClaimRepository;
_userTokenRepository = userTokenRepository;
}
public EditUserPassword(
IUserTokenRepository userTokenRepository,
IUserRepository userRepository, IUnitOfWork unitOfWork, IHasher hasher = null)
{
this.userTokenRepository = userTokenRepository;
this.userRepository = userRepository;
_unitOfWork = unitOfWork;
this.hasher = hasher ?? new Hasher();
}
public ApplicationUserStoreMin(
IUserRepository userRepository,
IUserTokenRepository userTokenRepository,
IMapper mapper)
{
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
_mapper = mapper;
}
/// <summary>
/// Creates an UserService.
/// Please, do not instantiate this class, instead get it from dependency injection container
/// </summary>
/// <param name="appSettings"></param>
/// <param name="userRepository"></param>
/// <param name="userTokenRepository"></param>
/// <param name="userApiKeyRepository"></param>
public UserService(IAppSettings appSettings,
IUserRepository userRepository,
IUserTokenRepository userTokenRepository,
IUserApiKeyRepository userApiKeyRepository)
{
_appSettings = appSettings;
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
_userApiKeyRepository = userApiKeyRepository;
}
public PostPasswordLoginRequestHandler(
IUserRepository userRepository,
ISecretService secretService,
ITokenService tokenService,
IUserTokenRepository userTokenRepository)
: base(tokenService, userTokenRepository)
{
fUserRepository = userRepository;
fSecretService = secretService;
}
public AuthenService(IUserTokenRepository userTokenRepository,
IUserRepository userRepository,
IWebHostEnvironment hostingEnvironment,
IOptions <AppSettings> appSettings)
{
_userTokenRepository = userTokenRepository;
_userRepository = userRepository;
_hostingEnvironment = hostingEnvironment;
_appSettings = appSettings.Value;
}
public PersonAppService(IPersonRepository personRepo,
IUserTokenRepository userTokenRepo, IActivityRepository activityRepo,
ITokenAppService tokenService, IRoleDistributionRepository roleDistributionRepository)
{
_personRepository = personRepo;
_activityRepository = activityRepo;
_userTokenRepository = userTokenRepo;
_tokenAppService = tokenService;
_roleDistributionRepository = roleDistributionRepository;
}
public ResetPasswordCommandHandler(ILogger <ResetPasswordCommandHandler> logger, IAdminUnitOfWork adminUnitOfWork, IUserRepository userRepository,
IUserTokenRepository userTokenRepository, ResetPasswordCommandValidator validator, IUserPasswordService userPasswordService)
{
this._logger = logger;
this._adminUnitOfWork = adminUnitOfWork;
this._userRepository = userRepository;
this._userTokenRepository = userTokenRepository;
this._validator = validator;
this._userPasswordService = userPasswordService;
this._validationResult = new ValidationResult();
}
public TokenHandler(IOptions <TokenOptions> tokenOptionsSnapshot, SigningConfigurations signingConfigurations, IPasswordHasher passwordHaser, IUserTokenRepository userTokenRepository, IUnitOfWork unitOfWork, ILogServices logService)
{
_passwordHaser = passwordHaser;
_tokenOptions = tokenOptionsSnapshot.Value;
_signingConfigurations = signingConfigurations;
_userTokenRepository = userTokenRepository;
_unitOfWork = unitOfWork;
_logService = logService;
}
public ApplicationUserStoreFull(
IUserRepository userRepository,
IUserTokenRepository userTokenRepository,
IUserClaimRepository userClaimRepository,
IUserLoginRepository userLoginRepository,
IMapper mapper)
{
_userRepository = userRepository;
_userTokenRepository = userTokenRepository;
_userClaimRepository = userClaimRepository;
_userLoginRepository = userLoginRepository;
_mapper = mapper;
}
public TokenStoreService(
IUserTokenRepository userTokenRepository,
IOptionsSnapshot <BearerTokensOptions> configuration,
ITokenFactoryService tokenFactoryService)
{
_userTokenRepository = userTokenRepository;
_configuration = configuration;
_configuration.CheckArgumentIsNull(nameof(configuration));
_tokenFactoryService = tokenFactoryService;
_tokenFactoryService.CheckArgumentIsNull(nameof(tokenFactoryService));
}
public TokensController(
IUserTokenRepository tokens,
IOptions <UserAccountSettings> options,
IUserRepository users,
SignInManager <SensateUser> signInManager,
IApiKeyRepository keys,
IHttpContextAccessor ctx
) : base(users, ctx)
{
this._tokens = tokens;
this._signin_manager = signInManager;
this._settings = options.Value;
this._keys = keys;
}
public DashboardController(IUserRepository users,
ISensorStatisticsRepository stats,
ISensorRepository sensors,
IUserTokenRepository tokens,
IAuditLogRepository logs,
ICacheStrategy <string> cache,
IHttpContextAccessor ctx) : base(users, ctx)
{
this._stats = stats;
this._sensors = sensors;
this._logs = logs;
this._tokens = tokens;
this.m_cache = cache;
}
public UserService(IUserRepositry repositry,
UserManager <User> userManage,
RoleManager <Role> roleManager,
IConfiguration configuration,
IUserTokenRepository userTokenRepository,
IOptions <JwtIssuerSettings> jwtSettings,
SignInManager <User> signInManager) : base(repositry)
{
_userManager = userManage;
_roleManager = roleManager;
_signInManager = signInManager;
_jwtSettings = jwtSettings;
_userTokenRepository = userTokenRepository;
}
public void SetUp()
{
ConnectionProvider = new DataConnectionProvider(DataConnectionProvider.Connectionstring);
UserTokenRepository = new UserTokenRecordRepository(ConnectionProvider);
ServiceProviderRepository =new ServiceProviderRepository(ConnectionProvider);
AuthProviderFactory = new AuthProviderFactory(new[]
{
new FacebookAuthProviderInstance()
});
AuthConsumerService = new AuthConsumerService(UserTokenRepository,
ServiceProviderRepository, AuthProviderFactory);
new Registration().CreateTablesForTypes();
}
public TokenStoreService(
IUnitOfWork uow,
ISecurityService securityService,
IRepositoryWrapper repository,
IOptionsSnapshot <BearerTokensOptions> configuration)
{
this.uow = uow;
this.uow.CheckArgumentIsNull(nameof(TokenStoreService.uow));
this.securityService = securityService;
this.securityService.CheckArgumentIsNull(nameof(TokenStoreService.securityService));
this.rolesRepository = repository.Roles;
this.rolesRepository.CheckArgumentIsNull(nameof(rolesRepository));
this.userTokenRepository = repository.UserToken;
this.userTokenRepository.CheckArgumentIsNull(nameof(userTokenRepository));
this.configuration = configuration;
this.configuration.CheckArgumentIsNull(nameof(configuration));
}
public DropboxConnector(string clientId, string clientSecret, IUserTokenRepository repository)
{
if (repository == null) throw new ArgumentNullException("repository");
_repository = repository;
var token = _repository.TryRetrieveTokenFromDatabase(HardcodedUser.Id);
_accessToken = token.DropboxAccessToken;
var options = new Options
{
ClientId = clientId,
ClientSecret = clientSecret,
RedirectUri = "http://localhost:52110/dropbox/oauth",
UseSandbox = true,
AccessToken = _accessToken
};
_client = new Client(options);
}
public static void Instantiate(
IUserBaseRepository pIUserBaseRepository,
IJobRepository pJobRepository,
ICompanyRepository pCompanyRepository,
IUserTokenRepository pUserTokenRepository,
IRoleRepository pRoleRepository,
ICustomerRepository pCustomerRepository,
ICandidateRepository pCandidateRepository)
{
if (_instance != null)
{
return;
}
_instance = new RepositorySingleton();
pIUserBaseRepository.IsNullThrowException();
_userBaseRepository = pIUserBaseRepository;
pJobRepository.IsNullThrowException();
_jobRespository = pJobRepository;
pCompanyRepository.IsNullThrowException();
_companyRepository = pCompanyRepository;
pUserTokenRepository.IsNullThrowException();
_userTokenRepository = pUserTokenRepository;
pRoleRepository.IsNullThrowException();
_roleRepository = pRoleRepository;
pCustomerRepository.IsNullThrowException();
_customerRepository = pCustomerRepository;
pCandidateRepository.IsNullThrowException();
_candidateRepository = pCandidateRepository;
}
private static TokenResponse GenerateAccessTokenResponse(IUserTokenRepository userTokenRepository, IOAuth appSettingsOAuth, long userId, string userRole, string username)
{
string nonce = GenerateNonce();
string accessToken = GenerateAccessToken(
userId: userId,
userRole: userRole,
nonce: nonce,
secretKey: appSettingsOAuth.SecretKey,
issuer: appSettingsOAuth.Issuer,
expiresAfter: appSettingsOAuth.AccessTokenExpires);
string refreshToken = GenerateRefreshToken();
string checksum = (refreshToken + username).GetSHA256HashString();
userTokenRepository.Add(refreshToken, userId, nonce, appSettingsOAuth.RefreshTokenExpires, checksum);
userTokenRepository.RemoveExpired();
return(new TokenResponse
{
AccessToken = accessToken,
TokenType = "bearer",
ExpiresIn = appSettingsOAuth.AccessTokenExpires,
RefreshToken = refreshToken
});
}
public UserTokenProviderTest()
{
_userTokenRepository = A.Fake<IUserTokenRepository>();
_userTokenProvider = new UserTokenProvider(_userTokenRepository);
}
public UserController(IUserRepository repository, IUserTokenRepository tokenRepository)
{
this.repository = repository;
this.tokenRepository = tokenRepository;
}
protected PostLoginRequestHandlerBase(ITokenService tokenService, IUserTokenRepository userTokenRepository)
{
fTokenService = tokenService;
fUserTokenRepository = userTokenRepository;
}
