public UserController(IUserRepository userRepository, IAuthRepository authTokenRepository, IMapper mapper, IPasswordRepository passwordRepository)
{
_userRepository = userRepository;
_authTokenRepository = authTokenRepository;
_passwordRepository = passwordRepository;
_mapper = mapper;
}
public HubPageViewModel(INavigationService navigationService, IPasswordRepository passwordRepository)
{
_navigationService = navigationService;
_passwordRepository = passwordRepository;
_passwordGroups = new ObservableCollection<PasswordGroup>();
if (Windows.ApplicationModel.DesignMode.DesignModeEnabled)
{
PasswordGroups.Add(new PasswordGroup()
{
GroupKey = "A"
});
PasswordGroups.Add(new PasswordGroup()
{
GroupKey = "C"
});
PasswordGroups.Add(new PasswordGroup()
{
GroupKey = "D"
});
}
else
{
GetData();
}
AddNewPasswordCommand = new DelegateCommand(() => AddNewPassword());
DeleteCommand = new DelegateCommand(() => Delete());
CopyToClipboardCommand = new DelegateCommand(() => CopyToClipboard());
GoBackCommand = new DelegateCommand(() => _navigationService.GoBack(), () => _navigationService.CanGoBack());
}
public void SetUpModel( )
{
_engine = new PasswordDerivationEngine( PasswordGenerators.Generators );
_passwordRepository = new PasswordRepository( new InMemoryPasswordData( ) );
var digest = _engine.Derive( new PasswordRequest( "abij", "1234".ToSecureString( ), 3, PasswordGenerators.LegacyFull ) );
_original = new PasswordDigestDocumentBuilder
{
Digest = digest.Digest,
CreatedOn = new DateTime( 2011, 11, 1 ),
ModifiedOn = new DateTime( 2011, 11, 3 ),
MasterPasswordId = Guid.NewGuid( ),
Note = "AB IJ"
};
_passwordRepository.SavePassword( _original );
_timeProvider = new StubTimeProvider { Now = new DateTime( 2011, 11, 16 ) };
IMasterPasswordMatcher masterPasswordMatcher = new MasterPasswordMatcher( _engine, _passwordRepository );
_model = new PasswordEditorModel( _passwordRepository, _engine, masterPasswordMatcher, _timeProvider,
new BaselinePasswordDocument( _original ) );
}
//public static IMapper Mapper {get; private set;}
#endregion
#region Constructor
/// <summary>
/// Create a new instance of Password application service
/// </summary>
/// <param name="repository">Repository dependency</param>
public PasswordAppService(IPasswordRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository", ApplicationResources.exception_WithoutRepository);
}
_repositoryPassword = repository;
}
public AuthController(IAuthRepository authRepository, IMapper mapper, IPasswordRepository passwordRepositorio, IUserRepository userRepository, IEmailSenderRepository emailSenderRepository)
{
_authRepository = authRepository;
_emailSenderRepository = emailSenderRepository;
_mapper = mapper;
_passwordRepositorio = passwordRepositorio;
_userRepository = userRepository;
}
public VaultController(IOptions <SiteSettings> siteConfig, UserManager <finalUser> userManager, INoteRepository noteRepository, IPasswordRepository passwordRepository, IWebsiteRepository websiteRepository)
{
note_repo = noteRepository;
password_repo = passwordRepository;
website_repo = websiteRepository;
user_manager = userManager;
sitesettings = siteConfig.Value;
}
public void SetupPasswordCollection( )
{
_inMemoryPasswordData = new InMemoryPasswordData( );
_allPasswords = new[ ] { TestPasswords.Abcd, TestPasswords.Efgh, TestPasswords.Ijkl }.ToList( );
_inMemoryPasswordData.SavePasswords( _allPasswords );
_passwordRepository = new PasswordRepository( _inMemoryPasswordData );
}
public LoginWindow(IProfileRepository profileRepository, IPasswordRepository passwordRepository)
{
_profileRepository = profileRepository;
_passwordRepository = passwordRepository;
InitializeComponent();
transitioner.SelectedIndex = 0;
}
public TextFileRepository(IDbConnector connector, IPasswordRepository repo, IEncryptor encryptor)
{
_connector = connector;
_pwRepository = repo;
_encryptor = encryptor;
SourceFolder = _connector.GetAppSettingsValue("sourceFolder");
DestinationFolder = _connector.GetAppSettingsValue("destinationFolder");
_storedProc = _connector.GetAppSettingsValue("spUserId");
}
public StorePlainTextPasswordCommandHandler(IPasswordRepository passwordRepository)
{
if (passwordRepository == null)
{
throw new ArgumentNullException(nameof(passwordRepository));
}
_passwordRepository = passwordRepository;
}
internal DefaultPasswordManagerEditor( IPasswordDerivationEngine derivationEngine,
IPasswordManagerStorage passwordManagerStorage,
ITimeProvider timeProvider )
{
_passwordRepository = passwordManagerStorage.PasswordRepository;
_derivationEngine = derivationEngine;
_timeProvider = timeProvider;
_masterPasswordMatcher = passwordManagerStorage.MasterPasswordMatcher;
}
public void SetUpModel( )
{
_engine = new PasswordDerivationEngine( PasswordGenerators.Generators );
_passwordRepository = new PasswordRepository( new InMemoryPasswordData( ) );
IMasterPasswordMatcher masterPasswordMatcher = new MasterPasswordMatcher( _engine, _passwordRepository );
_model = new PasswordEditorModel( _passwordRepository, _engine, masterPasswordMatcher, new StubTimeProvider( ), new NewPasswordDocument( ) );
}
public MainWindow(IPasswordRepository passwordRepository, Profile profile, string password)
{
_passwordRepository = passwordRepository;
_profile = profile;
_password = password;
InitializeComponent();
RefreshPasswords();
}
public UserPasswordController(
IMapper mapper,
IUserRepository userRepository,
IPasswordRepository passwordRepository,
IUnitOfWork uow
)
{
this._uow = uow;
this._mapper = mapper;
this._userRepository = userRepository;
this._passwordRepository = passwordRepository;
}
public PasswordService(
ILogger <IPasswordRepository> logger,
IPasswordRepository passwordRepository,
IApiPasswordRequestModelValidator passwordModelValidator,
IBOLPasswordMapper bolpasswordMapper,
IDALPasswordMapper dalpasswordMapper)
: base(logger,
passwordRepository,
passwordModelValidator,
bolpasswordMapper,
dalpasswordMapper)
{
}
/// <summary>
/// Create a new instance of Password application service
/// </summary>
/// <param name="repository">Repository dependency</param>
/// <param name="uow">IUnitOfWorkAsync dependency</param>
public PasswordAppService(IPasswordRepository repository, IUnitOfWorkAsync uow)
{
if (repository == null)
{
throw new ArgumentNullException("repository", ApplicationResources.exception_WithoutRepository);
}
_repositoryPassword = repository;
if (uow == null)
{
throw new ArgumentNullException("uow", ApplicationResources.exception_WithoutRepository);
}
_unitOfWorkAsync = uow;
}
public StoreSecuredPasswordCommandHandler(IPasswordRepository passwordRepository, ISecureSensitiveData secureSensitiveData)
{
if (passwordRepository == null)
{
throw new ArgumentNullException(nameof(passwordRepository));
}
if (secureSensitiveData == null)
{
throw new ArgumentNullException(nameof(secureSensitiveData));
}
_passwordRepository = passwordRepository;
_secureSensitiveData = secureSensitiveData;
}
public AbstractPasswordService(
ILogger logger,
IPasswordRepository passwordRepository,
IApiPasswordRequestModelValidator passwordModelValidator,
IBOLPasswordMapper bolPasswordMapper,
IDALPasswordMapper dalPasswordMapper)
: base()
{
this.PasswordRepository = passwordRepository;
this.PasswordModelValidator = passwordModelValidator;
this.BolPasswordMapper = bolPasswordMapper;
this.DalPasswordMapper = dalPasswordMapper;
this.logger = logger;
}
public UserController(IConfiguration configuration,
ILogger logger,
IUserRepository repository,
IPasswordManager passwordManager,
IPasswordRepository passwordRepository,
IMapper mapper,
IHaveIBeenPwnedRestClient pwnedClient) : base(logger, mapper)
{
_configuration = configuration;
_repository = repository;
_passwordManager = passwordManager;
_passwordRepository = passwordRepository;
_pwnedClient = pwnedClient;
}
/// <summary>
/// Invoked when the application is launched normally by the end user. Other entry points
/// will be used when the application is launched to open a specific file, to display
/// search results, and so forth.
/// </summary>
/// <param name="args">Details about the launch request and process.</param>
protected override async void OnLaunched(LaunchActivatedEventArgs args)
{
Frame rootFrame = Window.Current.Content as Frame;
// Do not repeat app initialization when the Window already has content,
// just ensure that the window is active
if (rootFrame == null)
{
// Create a Frame to act as the navigation context and navigate to the first page
rootFrame = new Frame();
if (args.PreviousExecutionState != ApplicationExecutionState.Running)
{
//TODO: Load state from previously suspended application
Boolean loadState = (args.PreviousExecutionState == ApplicationExecutionState.Terminated);
ExtendedSplashScreen splashScreen = new ExtendedSplashScreen(args.SplashScreen, loadState);
Window.Current.Content = splashScreen;
}
Window.Current.Activate();
await System.Threading.Tasks.Task.Delay(5000);
// Place the frame in the current Window
Window.Current.Content = rootFrame;
}
_navigationService = CreateNavigationService(rootFrame);
_passwordRepository = CreatePasswordDataRepository();
//TODO Consider removing parameter
BootstrapApplication(_navigationService);
if (rootFrame.Content == null)
{
// When the navigation stack isn't restored navigate to the first page,
// configuring the new page by passing required information as a navigation
// parameter
if (!_navigationService.Navigate("Hub", args.Arguments))
{
throw new Exception("Failed to create initial page");
}
}
// Ensure the current window is active
Window.Current.Activate();
}
public PasswordEditorModel( IPasswordRepository passwordRepository,
IPasswordDerivationEngine derivationEngine,
IMasterPasswordMatcher masterPasswordMatcher,
ITimeProvider timeProvider,
IBaselinePasswordDocument original )
{
_passwordRepository = passwordRepository;
_derivationEngine = derivationEngine;
_masterPasswordMatcher = masterPasswordMatcher;
_timeProvider = timeProvider;
_derivedPasswords = _derivationEngine.PasswordGeneratorIds
.Select( g => new DerivedPasswordModel( _derivationEngine, g ) )
.ToList( );
_original = original;
UpdateFromOriginal( );
MasterPassword = new SecureString( );
}
public AddEditPasswordViewModel(INavigationService navigationService, IPasswordRepository passwordRepository)
{
_navigationService = navigationService;
_passwordRepository = passwordRepository;
SaveCommand = new DelegateCommand(() => Save(), () => CanSave);
CopyToClipboardCommand = new DelegateCommand(() => CopyToClipboard());
GoBackCommand = new DelegateCommand(() => navigationService.GoBack(), () => navigationService.CanGoBack());
KeyPressAction = (eventArgs) =>
{
switch (eventArgs.Key)
{
case VirtualKey.Enter:
{
if(CanSave)
SaveCommand.Execute();
}
break;
default:
break;
}
};
}
public LoginController(IConfiguration configuration, PassModelContext Passdb, UserModelContext userdb)
{
_configuration = configuration;
_pass = new PasswordRepository(Passdb);
_user = new UsernameRepository(userdb);
}
public PasswordService(IPasswordRepository repository, IMapper mapper, IConfiguration config) : base(repository, mapper)
{
PasswordRepository = repository;
CryptoPassword = config["Crypto:Password"];
}
public PasswordController(IPasswordRepository repo)
{
_repo = repo;
}
public MasterPasswordMatcher( IPasswordDerivationEngine passwordDerivationEngine, IPasswordRepository passwordRepository )
{
_passwordDerivationEngine = passwordDerivationEngine;
_passwordRepository = passwordRepository;
}
public PotentialLoginService(IPasswordRepository passwordRepository) => _passwordRepository = passwordRepository;
public AbstractApiPasswordRequestModelValidator(IPasswordRepository passwordRepository)
{
this.passwordRepository = passwordRepository;
}
public ApplicationOAuthProvider(IPasswordRepository passwordRepository)
{
this.passwordRepository = passwordRepository;
}
public UserRepository(IPasswordRepository passwordRepository, IConfigRepository configRepository)
{
this.passwordRepository = passwordRepository;
this.configRepository = configRepository;
}
public UserRepository(FcDbContext context, IPasswordRepository passwordRepository)
{
this._context = context;
this._passwordRepository = passwordRepository;
}
public PasswordService(IPasswordRepository passwordRepository, IPasswordExpiryService passwordExpiryService, ICryptoService cryptoService)
{
_passwordRepository = passwordRepository;
_passwordExpiryService = passwordExpiryService;
_cryptoService = cryptoService;
}
public void SetUpStore( )
{
_passwordRepository = new PasswordRepository( new InMemoryPasswordData( ) );
_passwordDerivationEngine = new PasswordDerivationEngine( PasswordGenerators.Generators );
_masterPasswordMatcher = new MasterPasswordMatcher( _passwordDerivationEngine, _passwordRepository );
}
public PasswordManager(IPasswordRepository passwordRepository, ILogger <PasswordManager> logger)
{
_passwordRepository = passwordRepository;
_logger = logger;
}
public PasswordCheckerService(IPasswordRepository passwordRepository, IPasswordValidator passwordValidator)
{
this.passwordRepository = passwordRepository ?? throw new ArgumentNullException(nameof(passwordRepository));
this.passwordValidator = passwordValidator ?? throw new ArgumentNullException(nameof(passwordValidator));
}
public FileTransferTimer(ITextFile textfile, IDbConnector connector, IPasswordRepository passwordRepository)
{
_textFile = textfile;
_connector = connector;
_password = passwordRepository;
}
public PasswordController(IOptions <SiteSettings> siteConfig, IPasswordRepository passwordRepository)
{
password_repo = passwordRepository;
sitesettings = siteConfig.Value;
}
/// <summary>Initializes a new instance of the <see cref="LoginService"/> class.</summary>
public LoginService(IPasswordRepository passwordRepository, ISecurityService securityService) // e.g. LoginService(IMyApiClient client)
{
_passwordRepository = passwordRepository;
_securityService = securityService;
}
public PasswordCheckerService(IPasswordRepository repository, IEnumerable <IPasswordChecker> checkers)
{
this.checkers = checkers;
this.repository = repository;
}
public PasswordAppService(IPasswordRepository repository)
{
__repository = repository;
}
