public TokenResponseGenerator(ITokenService tokenService, IRefreshTokenService refreshTokenService, IScopeStore scopes, ICustomTokenResponseGenerator customResponseGenerator)
{
_tokenService = tokenService;
_refreshTokenService = refreshTokenService;
_scopes = scopes;
_customResponseGenerator = customResponseGenerator;
}
public AuthorizeResponseGenerator(ITokenService tokenService, IAuthorizationCodeStore authorizationCodes, ITokenHandleStore tokenHandles, ICoreSettings settings)
{
_tokenService = tokenService;
_authorizationCodes = authorizationCodes;
_tokenHandles = tokenHandles;
_settings = settings;
}
public AuthorizeResponseGenerator(ILogger<AuthorizeResponseGenerator> logger, ITokenService tokenService, IAuthorizationCodeStore authorizationCodes, IEventService events)
{
_logger = logger;
_tokenService = tokenService;
_authorizationCodes = authorizationCodes;
_events = events;
}
public TokenResponseGenerator(ITokenService tokenService, IRefreshTokenService refreshTokenService, IScopeStore scopes, ILoggerFactory loggerFactory)
{
_tokenService = tokenService;
_refreshTokenService = refreshTokenService;
_scopes = scopes;
_logger = loggerFactory.CreateLogger<TokenResponseGenerator>();
}
public UserController(IUserService userService, ITokenService tokenService)
{
Auxilium.Validation.Validate.NotNull(userService);
Auxilium.Validation.Validate.NotNull(tokenService);
_userService = userService;
_tokenService = tokenService;
}
public ServiceFactory(IClientService clientService, ITokenService tokenService, IResourceOwnerService resourceOwnerService, IAuthorizationGrantService authorizationGrantService)
{
ClientService = clientService;
TokenService = tokenService;
ResourceOwnerService = resourceOwnerService;
AuthorizationGrantService = authorizationGrantService;
}
public TokenResponseGenerator(ITokenService tokenService, IRefreshTokenService refreshTokenService, ITokenHandleStore tokenHandles, CoreSettings settings, IAuthorizationCodeStore codes)
{
_settings = settings;
_tokenService = tokenService;
_refreshTokenService = refreshTokenService;
_tokenHandles = tokenHandles;
}
public EntryService()
{
_tokenService = new TokenService();
}
public AuthorizationController(IUserService userService, ITokenService tokenService, ICryptographyService cryptographyService)
{
this.userService = userService;
this.tokenService = tokenService;
this.cryptographyService = cryptographyService;
}
/// <summary>
/// Initializes a new instance of the <see cref="AuthenticationService"/> class.
/// </summary>
/// <param name="tokenService">Service used to make token calls.</param>
/// <param name="requestService">Service used to make request calls.</param>
internal AuthenticationService(ITokenService tokenService, IRequestService requestService)
{
this.tokenService = tokenService ?? throw new ArgumentNullException(nameof(tokenService));
this.requestService = requestService ?? throw new ArgumentNullException(nameof(requestService));
}
public TokenController(ITokenService _token)
{
this._token = _token;
}
public UserIdentityExtensionConfigProvider(ITokenService tokenService) => this.tokenService = tokenService;
public OrganisationsApiClient(HttpClient httpClient, ITokenService tokenService, ILogger <ApiClientBase> logger) : base(httpClient, tokenService, logger)
{
}
public TokenController(IApiUserService apiUserService, ITokenService tokenService, ILogger logger)
{
_apiUserService = apiUserService;
_tokenService = tokenService;
_logger = logger;
}
public AccountController(UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, ITokenService tokenService, IUnitOfWork unitOfWork, IMapper mapper, IEmailSender emailSender)
{
_emailSender = emailSender;
_unitOfWork = unitOfWork;
_signInManager = signInManager;
_userManager = userManager;
_mapper = mapper;
_tokenService = tokenService;
}
public static UserDto MapToDto(this AppUser user, ITokenService tokenService) => new UserDto
{
Email = user.Email,
Token = tokenService.CreateToken(user),
DisplayName = user.DisplayName
};
public LoginBusinessImplementation(TokenConfiguration configuration, IUserRepository repository, ITokenService tokenService)
{
_configuration = configuration;
_repository = repository;
_tokenService = tokenService;
}
public AuthorizeResponseGenerator(ITokenService tokenService, IAuthorizationCodeStore authorizationCodes, IEventService events)
{
_tokenService = tokenService;
_authorizationCodes = authorizationCodes;
_events = events;
}
public AuthenticationController(ILoginService loginService, IRegistrationService registrationService, IUserService userService, IRoleService roleService, ITokenService tokenService)
{
_loginService = loginService;
_registrationService = registrationService;
_userService = userService;
_roleService = roleService;
_tokenService = tokenService;
}
public DoController(ITokenService tokenService, IAzureTopicClient azureTopicClient, ILogger <DoController> logger)
{
_tokenService = tokenService;
_azureTopicClient = azureTopicClient;
_logger = logger;
}
public UserService(UserManager <ApplicationUser> userManager, SignInManager <ApplicationUser> signInManager, ITokenService tokenService)
{
_userManager = userManager;
_signInManager = signInManager;
_tokenService = tokenService;
}
public TokenApiController(UserManager <User> userManager, ITokenService tokenService)
{
_userManager = userManager;
_tokenService = tokenService;
}
public AccountController(Security.Application.IAccountService applicationService, ITokenService tokenService)
{
_accountService = applicationService;
_tokenService = tokenService;
}
public JwtUserTokenService(
ITokenService tokenService)
{
_tokenService = tokenService;
}
public MhTasksController(IMhTaskService mhTaskService, ITokenService tokenService, IRequestClient <IFeedMessage> requestClient) : base(tokenService)
{
_mhTaskService = mhTaskService;
_requestClient = requestClient;
}
public LoginController(DatabaseContext context, ITokenService tokenService)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
TokenService = tokenService ?? throw new ArgumentNullException(nameof(tokenService));
}
public UserIdentityBindingProvider(ITokenService tokenService) => this.tokenService = tokenService;
public AccountController(DataContext datacontext, ITokenService tokenService)
{
_dataContext = datacontext;
_tokenSevice = tokenService;
}
public JwtController(ITokenService tokenService)
{
_tokenService = tokenService;
}
public AuthorizeResponseGenerator(ITokenService tokenService, IAuthorizationCodeStore authorizationCodes)
{
_tokenService = tokenService;
_authorizationCodes = authorizationCodes;
}
public GoogleService(IUnitOfWork unitOfWork, ILoggerManager logger, SignInManager <ApplicationUser> signInManager, ITokenService tokenService, IRoleService roleService)
: base(logger, unitOfWork)
{
_signInManager = signInManager;
_tokenService = tokenService;
_roleService = roleService;
}
public AuthController(IConfiguration configuration, IPasswordHasher passwordHasher, ITokenService tokenService)
{
if (_repository == null)
{
_repository = new UserRepository();
}
_configuration = configuration;
_passwordHasher = passwordHasher;
_tokenService = tokenService;
}
public AuthController(IMembershipService membershipService, ITokenService tokenService)
{
this.membershipService = membershipService;
this.tokenService = tokenService;
}
public StartupPageViewModel(INavigationService navigationService, IFitMeetRestService fitMeetRestServices, ITokenService tokenService) : base(navigationService, fitMeetRestServices)
{
_tokenService = tokenService;
}
public SessionTokenAuthenticationMessageHandler(ITokenService tokenService, IUserService userService)
{
_tokenService = tokenService;
_userService = userService;
}
public App(AppOptions appOptions)
{
_appOptions = appOptions ?? new AppOptions();
_userService = ServiceContainer.Resolve <IUserService>("userService");
_broadcasterService = ServiceContainer.Resolve <IBroadcasterService>("broadcasterService");
_messagingService = ServiceContainer.Resolve <IMessagingService>("messagingService");
_stateService = ServiceContainer.Resolve <IStateService>("stateService");
_lockService = ServiceContainer.Resolve <ILockService>("lockService");
_syncService = ServiceContainer.Resolve <ISyncService>("syncService");
_tokenService = ServiceContainer.Resolve <ITokenService>("tokenService");
_cryptoService = ServiceContainer.Resolve <ICryptoService>("cryptoService");
_cipherService = ServiceContainer.Resolve <ICipherService>("cipherService");
_folderService = ServiceContainer.Resolve <IFolderService>("folderService");
_settingsService = ServiceContainer.Resolve <ISettingsService>("settingsService");
_collectionService = ServiceContainer.Resolve <ICollectionService>("collectionService");
_searchService = ServiceContainer.Resolve <ISearchService>("searchService");
_authService = ServiceContainer.Resolve <IAuthService>("authService");
_platformUtilsService = ServiceContainer.Resolve <IPlatformUtilsService>("platformUtilsService");
_storageService = ServiceContainer.Resolve <IStorageService>("storageService");
_secureStorageService = ServiceContainer.Resolve <IStorageService>("secureStorageService");
_passwordGenerationService = ServiceContainer.Resolve <IPasswordGenerationService>(
"passwordGenerationService");
_i18nService = ServiceContainer.Resolve <II18nService>("i18nService") as MobileI18nService;
_deviceActionService = ServiceContainer.Resolve <IDeviceActionService>("deviceActionService");
_cozyClientService = ServiceContainer.Resolve <ICozyClientService>("cozyClientService");
Bootstrap();
_broadcasterService.Subscribe(nameof(App), async(message) =>
{
if (message.Command == "showDialog")
{
var details = message.Data as DialogDetails;
var confirmed = true;
var confirmText = string.IsNullOrWhiteSpace(details.ConfirmText) ?
AppResources.Ok : details.ConfirmText;
Device.BeginInvokeOnMainThread(async() =>
{
if (!string.IsNullOrWhiteSpace(details.CancelText))
{
confirmed = await Current.MainPage.DisplayAlert(details.Title, details.Text, confirmText,
details.CancelText);
}
else
{
await Current.MainPage.DisplayAlert(details.Title, details.Text, confirmText);
}
_messagingService.Send("showDialogResolve", new Tuple <int, bool>(details.DialogId, confirmed));
});
}
else if (message.Command == "locked")
{
await LockedAsync(!(message.Data as bool?).GetValueOrDefault());
}
else if (message.Command == "lockVault")
{
await _lockService.LockAsync(true);
}
else if (message.Command == "logout")
{
Device.BeginInvokeOnMainThread(async() =>
await LogOutAsync((message.Data as bool?).GetValueOrDefault()));
}
else if (message.Command == "loggedOut")
{
// Clean up old migrated key if they ever log out.
await _secureStorageService.RemoveAsync("oldKey");
}
else if (message.Command == "resumed")
{
if (Device.RuntimePlatform == Device.iOS)
{
ResumedAsync();
}
}
else if (message.Command == "slept")
{
if (Device.RuntimePlatform == Device.iOS)
{
await SleptAsync();
}
}
else if (message.Command == "migrated")
{
await Task.Delay(1000);
await SetMainPageAsync();
}
else if (message.Command == "popAllAndGoToTabGenerator" ||
message.Command == "popAllAndGoToTabMyVault")
{
Device.BeginInvokeOnMainThread(async() =>
{
if (Current.MainPage is TabsPage tabsPage)
{
while (tabsPage.Navigation.ModalStack.Count > 0)
{
await tabsPage.Navigation.PopModalAsync(false);
}
if (message.Command == "popAllAndGoToTabMyVault")
{
_appOptions.MyVaultTile = false;
tabsPage.ResetToVaultPage();
}
else
{
_appOptions.GeneratorTile = false;
tabsPage.ResetToGeneratorPage();
}
}
});
}
});
}
/// <summary>
/// Public constructor to initialize product service instance
/// </summary>
public AuthenticateController(ITokenService tokenService, IUserSession userSession)
{
_tokenService = tokenService;
_userSession = userSession;
}
// constructor
public AccountController(DataContext context, ITokenService tokenService)
{
this._context = context;
this._tokenService = tokenService;
}
public AuthorizeResponseGenerator(ITokenService tokenService, IAuthorizationCodeStore authorizationCodes, IEventService events)
{
_tokenService = tokenService;
_authorizationCodes = authorizationCodes;
_events = events;
}
public TokensController(
ITokenService tokenService)
{
_tokenService = tokenService;
}
public AuthController(IIdentityService identityService,
ITokenService tokenService)
{
_identityService = identityService;
_tokenService = tokenService;
}
public GetTokenQueryHandler(IIdentityService identityService, ITokenService tokenService)
{
_identityService = identityService;
_tokenService = tokenService;
}
public TokenResponseGenerator(ITokenService tokenService, IRefreshTokenService refreshTokenService)
{
_tokenService = tokenService;
_refreshTokenService = refreshTokenService;
}
public AccountController(DataContext context, ITokenService tokenService, IMapper mapper)
{
_context = context;
_tokenService = tokenService;
_mapper = mapper;
}
public AccountController(DataContext context, ITokenService tokenService)
{
_tokenService = tokenService;
_context = context;
}
public AccountController(UserManager <AppUser> userManager, SignInManager <AppUser> signInManager, ITokenService tokenService, IMapper mapper)
{
this._userManager = userManager;
this._signInManager = signInManager;
_tokenService = tokenService;
_mapper = mapper;
}
public TokenController(ITokenService tokenProcess)
{
this.tokenService = tokenProcess;
}
public OrganisationsApiClient(string baseUri, ITokenService tokenService,
ILogger <OrganisationsApiClient> logger) : base(baseUri, tokenService, logger)
{
}
public TokenResponseGenerator(ITokenService tokenService, IRefreshTokenService refreshTokenService, IScopeStore scopes)
{
_tokenService = tokenService;
_refreshTokenService = refreshTokenService;
_scopes = scopes;
}
public TokenController(ITokenService tokenService)
{
this.tokenService = tokenService;
}
