public AccountsViewModel(ISessionService sessionService, IAccountsRepository accountsRepository) { _accountsRepository = accountsRepository; _sessionService = sessionService; Title = "Accounts"; Accounts = _accounts.CreateDerivedCollection(CreateAccountItem); this.WhenAnyValue(x => x.ActiveAccount) .Select(x => x == null ? string.Empty : x.Key) .Subscribe(x => { foreach (var account in Accounts) account.Selected = account.Id == x; }); var canDismiss = this.WhenAnyValue(x => x.ActiveAccount).Select(x => x != null); DismissCommand = ReactiveCommand.Create(canDismiss).WithSubscription(x => Dismiss()); GoToAddAccountCommand = ReactiveCommand.Create() .WithSubscription(_ => NavigateTo(this.CreateViewModel<NewAccountViewModel>())); // Activate immediately since WhenActivated triggers off Did* instead of Will* in iOS UpdateAccounts(); this.WhenActivated(d => UpdateAccounts()); }
public TransactionsService(ApplicationDbContext context, IMapper mapper, ITransactionsRepository <TransactionsModel> repo, IAccountsRepository <AccountsModel> accountsRepo, IDateTimeHelper dateTimeHelper) { _repo = repo; _mapper = mapper; _accountsRepo = accountsRepo; _dateTimeHelper = dateTimeHelper; }
public void AccountsRepository_UnitOfWork_Instantiation_Test() { IUnitOfWork unitOfWork = new Social.Data.UnitOfWork.Implementation.UnitOfWork(); IAccountsRepository repository = unitOfWork.AccountsRepository; Assert.IsNotNull(repository); }
/// <summary> /// Ctor /// </summary> /// <param name="logger"></param> /// <param name="configuration"></param> /// <param name="jwtApp"></param> /// <param name="accountRepository"></param> public AuthsController(ILogger <AuthsController> logger, IConfiguration configuration, IJwtRepository jwtApp, IAccountsRepository accountRepository) { _configuration = configuration; _jwtApp = jwtApp; _accountRepository = accountRepository; _logger = logger; }
public async Task ShouldBeAbleToUpdateAccountAsync() { // Arrange using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); _service = new Service.Service.AccountsService(dbContext, _mapper); Account accountEntity = new Account() { Name = "Client", Balance = 2, IsActive = true, Type = AccountType.CreditCard, ClientId = 1, }; dbContext.Accounts.Add(accountEntity); dbContext.SaveChanges(); AccountDTO accountDto = new AccountDTO() { Name = "Client", Balance = 2, IsActive = true, Type = AccountType.CreditCard, ClientId = 1, }; //Act var response = _service.PutAccount(accountEntity.Id, accountDto); // Assert Assert.AreEqual(accountDto.Name, response.Name); }
public PaysServiceImpl(IPaysRepository paysRepository, IUserRepository userRepository, IWalletRepository walletRepository, IAccountsRepository accountsRepository) { this.paysRepository = paysRepository; this.userRepository = userRepository; this.walletRepository = walletRepository; this.accountsRepository = accountsRepository; }
public AccountsFactory(IAccountsRepository accountsRepository, IInputHelper inputHelper, IConsoleHelper consoleHelper) { _accountsRepository = accountsRepository; _inputHelper = inputHelper; _consoleHelper = consoleHelper; }
public async Task ChangeUserPasswordCommand_UserPasswordAndSaltChanged() { // Arrange const string userName = "******"; Guid userId = Guid.NewGuid(); const string userPassword = "******"; const string passwordSalt = "SaltySalt"; User user = new User(userId, userName, "Dirk", "Gently", "*****@*****.**", userPassword, passwordSalt, "555-1234"); IAccountsRepository accountsRepository = _container.Resolve <IAccountsRepository>(); await accountsRepository.Add(user); // Act ICommandBus commandBus = _container.Resolve <ICommandBus>(); const string newPassword = "******"; await commandBus.Send(new ChangeUserPasswordCommand { UserId = userId, Password = newPassword }); IAccountsPerspective accountsPerspective = _container.Resolve <IAccountsPerspective>(); AccountWithCredentialsModel userWithCredentials = await accountsPerspective.GetUserWithCredentials(userName); // Assert userWithCredentials.PasswordHash .Should().NotBeNullOrWhiteSpace("Password should be hashed and contained") .And.NotBe(userPassword) .And.NotBe(newPassword); userWithCredentials.PasswordSalt .Should().NotBeEmpty() .And.NotBe(passwordSalt); }
public JWTAuthenticationStateProvider(IJSRuntime js, HttpClient httpClient, IAccountsRepository accountsRepository) { this.js = js; this.httpClient = httpClient; this.accountsRepository = accountsRepository; }
public AccountsService( IAccountsRepository accountsRepository, IMetersRepository metersRepository) { _AccountsRepository = accountsRepository; _MetersRepository = metersRepository; }
public async Task ShouldBeAbleToAddAccountAsync() { // Arrange using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); _service = new Service.Service.AccountsService(dbContext, _mapper); AccountDTO account = new AccountDTO() { Name = "blhs", // Balance = 1,5 , // Type = , IsActive = true, ClientId = 1 }; //Act var response = _service.SaveAccount(account); var item = dbContext.Accounts.Find(response.Id); // Assert Assert.AreEqual(item.Name, response.Name); Assert.AreEqual(item.Balance, response.Balance); Assert.AreEqual(item.Type, response.Type); Assert.AreEqual(item.IsActive, response.IsActive); Assert.AreEqual(item.ClientId, response.ClientId); }
public WebhookController( ILogger <WebhookController> logger, IAccountsRepository accountsRepository) { _logger = logger; _accountsRepository = accountsRepository; }
public OAuthFlowLoginViewModel( IAccountsRepository accountsRepository, IActionMenuFactory actionMenuService, IAlertDialogFactory alertDialogService) { _accountsRepository = accountsRepository; _alertDialogService = alertDialogService; Title = "Login"; var oauthLogin = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<OAuthTokenLoginViewModel>())); var canLogin = this.WhenAnyValue(x => x.Code).Select(x => !string.IsNullOrEmpty(x)); var loginCommand = ReactiveCommand.CreateAsyncTask(canLogin,_ => Login(Code)); loginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage())); LoginCommand = loginCommand; ShowLoginOptionsCommand = ReactiveCommand.CreateAsyncTask(sender => { var actionMenu = actionMenuService.Create(); actionMenu.AddButton("Login via Token", oauthLogin); return actionMenu.Show(sender); }); _loginUrl = this.WhenAnyValue(x => x.WebDomain) .IsNotNull() .Select(x => x.TrimEnd('/')) .Select(x => string.Format(x + "/login/oauth/authorize?client_id={0}&redirect_uri={1}&scope={2}", ClientId, Uri.EscapeDataString(RedirectUri), Uri.EscapeDataString(string.Join(",", OctokitClientFactory.Scopes)))) .ToProperty(this, x => x.LoginUrl); WebDomain = DefaultWebDomain; }
public TransactionServices(IAccountsRepository accountsRepository, IDispositionsRepository dispositionsRepository, ITransactionsRepository transactionsRepository, AccountServices accountServices) { _accountsRepository = accountsRepository; _dispositionsRepository = dispositionsRepository; _transactionsRepository = transactionsRepository; _accountServices = accountServices; }
private static byte[] arcDeclined = FormattingUtils.Formatting.HexStringToByteArray("3035"); //declined code public TransactionController( ITransactionsRepository transactionRepository, IAccountsRepository accountsRepository) { _transactionRepository = transactionRepository; _accountsRepository = accountsRepository; }
public Accounts (UIWindow window, IAccountsRepository repository): base(new RootElement(""),true) { this.repository = repository; Style = UITableViewStyle.Plain; EnableSearch = true; }
public AccountViewModel(IEventAggregator eventAggregator, IAccountsRepository accountsRepository, PostingsViewModel postingsViewModel) { if (eventAggregator == null) { throw new ArgumentNullException("eventAggregator"); } if (accountsRepository == null) { throw new ArgumentNullException("accountsRepository"); } if (postingsViewModel == null) { throw new ArgumentNullException("postingsViewModel"); } EventAggregator = eventAggregator; AccountsRepository = accountsRepository; PostingsVM = postingsViewModel; PostingsVM.ConductWith(this); PostingsVM.Parent = this; //TODO: Subscription required to listen on any new/updated/deleted postings so that account could update in balance locally. //TODO: This should be implemented later. EventAggregator.Subscribe(this); Translator.CultureChanged += (sender, args) => { NotifyOfPropertyChange(() => FirstPostingDate); NotifyOfPropertyChange(() => LastPostingDate); }; }
public async Task PutAccount_ShouldWork() { using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); accountsRepository = new AccountsService(dbContext, mapper); //Arrange var accountDto = new AccountDTO { Id = 1, Name = "Updated Account", Type = AccountType.CreditCard, Balance = 529m, IsActive = true, ClientId = 2 }; //Actual var actual = accountsRepository.PutAccount(accountDto.Id, accountDto); //Assert Assert.Equal(accountDto.Name, actual.Name); Assert.Equal(accountDto.Type, actual.Type); Assert.Equal(accountDto.Balance, actual.Balance); Assert.Equal(accountDto.IsActive, actual.IsActive); Assert.Equal(accountDto.ClientId, actual.ClientId); }
public async Task PutAccount_ShouldNotWork() { using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); accountsRepository = new AccountsService(dbContext, mapper); //Arrange var accountDto = new AccountDTO { Id = 62, Name = "Updated Account", Type = AccountType.CreditCard, Balance = 529m, IsActive = true, ClientId = 2 }; //Actual //Assert var exception = Assert.Throws <Exception> (() => accountsRepository.PutAccount(accountDto.Id, accountDto)); Assert.Equal("Account not found", exception.Message); }
public async Task ShouldBeAbleToAddAccountAsync() { // Arrange using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); _accountService = new BankApplication.Service.Service.AccountsService(dbContext, _mapper); AccountDTO account = new AccountDTO() { Name = "Account", Balance = 000, Type = AccountType.SavingsAccount, IsActive = false, ClientId = 4 }; //Act var response = _accountService.SaveAccount(account); var item = dbContext.Accounts.Find(response.Id); // Assert Assert.AreEqual(item.Name, response.Name); Assert.AreEqual(item.Balance, response.Balance); Assert.AreEqual(item.Type, response.Type); Assert.AreEqual(item.IsActive, response.IsActive); Assert.AreEqual(item.ClientId, response.ClientId); }
public AccountService( IAccountsRepository accountsRepository, IMapper mapper) { _accountsRepository = accountsRepository; _mapper = mapper; }
public StoreRepository(ApiDbContext context, IAccountsRepository accountRepository, ITransactionsRepository transactionRepository, ICardsRepository cardsRepository) { _context = context; _accountRepository = accountRepository; _transactionRepository = transactionRepository; _cardsRepository = cardsRepository; }
public AccountSettingManager(IAccountsService accountsService, IProjectsService projectsService, ITemplatesService templateService, ICacheManager cacheManager) : base(accountsService, projectsService, templateService, cacheManager) { _accountsRepository = new AccountsRepository(); }
public AccountsViewModel(ISessionService sessionService, IAccountsRepository accountsRepository) { _accountsRepository = accountsRepository; _sessionService = sessionService; Title = "Accounts"; Items = _accounts.CreateDerivedCollection(CreateAccountItem); this.WhenAnyValue(x => x.ActiveAccount) .Select(x => x == null ? string.Empty : x.Key) .Subscribe(x => { foreach (var account in Items) { account.Selected = account.Id == x; } }); var canDismiss = this.WhenAnyValue(x => x.ActiveAccount).Select(x => x != null); DismissCommand = ReactiveCommand.Create(canDismiss).WithSubscription(x => Dismiss()); GoToAddAccountCommand = ReactiveCommand.Create() .WithSubscription(_ => NavigateTo(this.CreateViewModel <NewAccountViewModel>())); // Activate immediately since WhenActivated triggers off Did* instead of Will* in iOS UpdateAccounts(); this.WhenActivated(d => UpdateAccounts()); }
public OAuthTokenLoginViewModel( ILoginService loginFactory, IAccountsRepository accountsRepository, IAlertDialogFactory alertDialogFactory) { Title = "Login"; var canLogin = this.WhenAnyValue(y => y.Token, (x) => !string.IsNullOrEmpty(x)); LoginCommand = ReactiveCommand.CreateAsyncTask(canLogin, async _ => { try { using (alertDialogFactory.Activate("Logging in...")) { var account = await loginFactory.Authenticate(ApiDomain, WebDomain, Token, false); await accountsRepository.SetDefault(account); return account; } } catch (UnauthorizedException) { throw new Exception("The provided token is invalid! Please try again or " + "create a new token as this one might have been revoked."); } }); LoginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage())); }
public AccountController(ILanguagesRepository languagesRepository, IAccountsRepository repository, IWardsRepository wardsRepository, ISpecialtiesRepository specialtiesRepository) { this._languagesRepository = languagesRepository; this._repository = repository; this._wardsRepository = wardsRepository; this._specialtiesRepository = specialtiesRepository; }
public NotificationsController(INotificationsRepository r, IAccountsRepository a, UserManager <ApplicationUser> uManager) { notifications = r; accounts = a; userManager = uManager; }
public AuthenticationController(IAuthenticationService authenticationService, IAccountsRepository accountsRepository) { Contract.Requires(authenticationService != null); Contract.Requires(accountsRepository != null); this.authenticationService = authenticationService; this.accountsRepository = accountsRepository; }
public OAuthTokenLoginViewModel( ILoginService loginFactory, IAccountsRepository accountsRepository, IAlertDialogFactory alertDialogFactory) { Title = "Login"; var canLogin = this.WhenAnyValue(y => y.Token, (x) => !string.IsNullOrEmpty(x)); LoginCommand = ReactiveCommand.CreateAsyncTask(canLogin, async _ => { try { using (alertDialogFactory.Activate("Logging in...")) { var account = await loginFactory.Authenticate(ApiDomain, WebDomain, Token, false); await accountsRepository.SetDefault(account); return(account); } } catch (UnauthorizedException) { throw new Exception("The provided token is invalid! Please try again or " + "create a new token as this one might have been revoked."); } }); LoginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage())); }
public async Task SaveAccount_ShouldWork() { using var factory = new SQLiteDbContextFactory(); await using var dbContext = factory.CreateContext(); accountsRepository = new AccountsService(dbContext, mapper); //Arrange var expectedCount = await dbContext.Accounts.CountAsync() + 1; var accountDto = new AccountDTO { Name = "New Account", Type = AccountType.SavingsAccount, Balance = 924m, IsActive = true, ClientId = 1 }; //Actual var actual = accountsRepository.SaveAccount(accountDto); var actualCount = await dbContext.Accounts.CountAsync(); //Assert Assert.NotNull(actual); Assert.Equal(expectedCount, actualCount); Assert.Equal(accountDto.Name, actual.Name); Assert.Equal(accountDto.Type, actual.Type); Assert.Equal(accountDto.Balance, actual.Balance); Assert.Equal(accountDto.IsActive, actual.IsActive); Assert.Equal(accountDto.ClientId, actual.ClientId); }
public SettingsViewModel(ISessionService applicationService, IFeaturesService featuresService, IAccountsRepository accountsService, IEnvironmentalService environmentalService, IPushNotificationRegistrationService pushNotificationsService) { Title = "Account Settings"; _sessionService = applicationService; _featuresService = featuresService; _accountsService = accountsService; _environmentService = environmentalService; _pushNotificationsService = pushNotificationsService; AccountImageUrl = applicationService.Account.AvatarUrl; GoToDefaultStartupViewCommand = ReactiveCommand.Create(); GoToDefaultStartupViewCommand.Subscribe(_ => { var vm = this.CreateViewModel<DefaultStartupViewModel>(); vm.WhenAnyValue(x => x.SelectedStartupView) .Subscribe(x => DefaultStartupViewName = x); NavigateTo(vm); }); GoToSyntaxHighlighterCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<SyntaxHighlighterViewModel>(); vm.SaveCommand.Subscribe(__ => SyntaxHighlighter = vm.SelectedTheme); NavigateTo(vm); }); DeleteAllCacheCommand = ReactiveCommand.Create(); GoToSourceCodeCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<RepositoryViewModel>(); vm.Init("thedillonb", "codehub"); NavigateTo(vm); }); ShowOrganizationsInEvents = applicationService.Account.ShowOrganizationsInEvents; this.WhenAnyValue(x => x.ShowOrganizationsInEvents).Skip(1).Subscribe(x => { applicationService.Account.ShowOrganizationsInEvents = x; accountsService.Update(applicationService.Account); }); ExpandOrganizations = applicationService.Account.ExpandOrganizations; this.WhenAnyValue(x => x.ExpandOrganizations).Skip(1).Subscribe(x => { applicationService.Account.ExpandOrganizations = x; accountsService.Update(applicationService.Account); }); ShowRepositoryDescriptionInList = applicationService.Account.ShowRepositoryDescriptionInList; this.WhenAnyValue(x => x.ShowRepositoryDescriptionInList).Skip(1).Subscribe(x => { applicationService.Account.ShowRepositoryDescriptionInList = x; accountsService.Update(applicationService.Account); }); }
public SettingsViewModel(ISessionService applicationService, IFeaturesService featuresService, IAccountsRepository accountsService, IEnvironmentalService environmentalService, IPushNotificationRegistrationService pushNotificationsService) { Title = "Account Settings"; _sessionService = applicationService; _featuresService = featuresService; _accountsService = accountsService; _environmentService = environmentalService; _pushNotificationsService = pushNotificationsService; AccountImageUrl = applicationService.Account.AvatarUrl; GoToDefaultStartupViewCommand = ReactiveCommand.Create(); GoToDefaultStartupViewCommand.Subscribe(_ => { var vm = this.CreateViewModel <DefaultStartupViewModel>(); vm.WhenAnyValue(x => x.SelectedStartupView) .Subscribe(x => DefaultStartupViewName = x); NavigateTo(vm); }); GoToSyntaxHighlighterCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <SyntaxHighlighterViewModel>(); vm.SaveCommand.Subscribe(__ => SyntaxHighlighter = vm.SelectedTheme); NavigateTo(vm); }); DeleteAllCacheCommand = ReactiveCommand.Create(); GoToSourceCodeCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel <RepositoryViewModel>(); vm.Init("thedillonb", "codehub"); NavigateTo(vm); }); ShowOrganizationsInEvents = applicationService.Account.ShowOrganizationsInEvents; this.WhenAnyValue(x => x.ShowOrganizationsInEvents).Skip(1).Subscribe(x => { applicationService.Account.ShowOrganizationsInEvents = x; accountsService.Update(applicationService.Account); }); ExpandOrganizations = applicationService.Account.ExpandOrganizations; this.WhenAnyValue(x => x.ExpandOrganizations).Skip(1).Subscribe(x => { applicationService.Account.ExpandOrganizations = x; accountsService.Update(applicationService.Account); }); ShowRepositoryDescriptionInList = applicationService.Account.ShowRepositoryDescriptionInList; this.WhenAnyValue(x => x.ShowRepositoryDescriptionInList).Skip(1).Subscribe(x => { applicationService.Account.ShowRepositoryDescriptionInList = x; accountsService.Update(applicationService.Account); }); }
public StartupManager(ILog log, IAuditRepository auditRepository, IEodTaxFileMissingRepository taxFileMissingRepository, IComplexityWarningRepository complexityWarningRepository, IAccountsRepository accountsRepository) { _log = log; _auditRepository = auditRepository; _taxFileMissingRepository = taxFileMissingRepository; _complexityWarningRepository = complexityWarningRepository; _accountsRepository = accountsRepository; }
public AccountServiceTests(TestFixture <Startup> fixture) { Contract.Requires(fixture != null); accountsRepository = (IAccountsRepository)fixture.Server.Host.Services.GetService(typeof(IAccountsRepository)); accountsService = (IAccountsService)fixture.Server.Host.Services.GetService(typeof(IAccountsService)); blockedUsersRepository = (IBlockedUsersRepository)fixture.Server.Host.Services.GetService(typeof(IBlockedUsersRepository)); }
public static void Initialize(IAccountsCache cache) { _instance = new BrightstarAccountsRepository( RoleEnvironment.GetConfigurationSettingValue(AzureConstants.SuperUserAccountPropertyName), RoleEnvironment.GetConfigurationSettingValue(AzureConstants.SuperUserKeyPropertyName), cache ); }
public SrvClientManager(IClientAccountsRepository tradersRepository, ISrvSmsConfirmator srvSmsConfirmator, IPersonalDataRepository personalDataRepository, ISrvLykkeWallet srvLykkeWallet, IAccountsRepository accountsRepository) { _tradersRepository = tradersRepository; _srvSmsConfirmator = srvSmsConfirmator; _personalDataRepository = personalDataRepository; _srvLykkeWallet = srvLykkeWallet; _accountsRepository = accountsRepository; }
public StartupViewModel( ISessionService sessionService, IAccountsRepository accountsService, IAlertDialogFactory alertDialogFactory, IDefaultValueService defaultValueService) { _sessionService = sessionService; _accountsService = accountsService; _alertDialogFactory = alertDialogFactory; _defaultValueService = defaultValueService; StartupCommand = ReactiveCommand.CreateAsyncTask(x => Load()); }
public SyntaxHighlighterViewModel(ISessionService applicationService, IAccountsRepository accountsRepository, IFilesystemService filesystemService) { Title = "Syntax Highlighter"; var path = System.IO.Path.Combine("WebResources", "styles"); Themes = filesystemService.GetFiles(path) .Where(x => x.EndsWith(".css", StringComparison.Ordinal)) .Select(x => System.IO.Path.GetFileNameWithoutExtension(x)) .ToList(); SelectedTheme = applicationService.Account.CodeEditTheme ?? "idea"; SaveCommand = ReactiveCommand.CreateAsyncTask(async t => { applicationService.Account.CodeEditTheme = SelectedTheme; await accountsRepository.Update(applicationService.Account); }); }
public EnterpriseOAuthTokenLoginViewModel( ILoginService loginFactory, IAccountsRepository accountsRepository, IAlertDialogFactory alertDialogFactory) { Title = "Login"; LoginCommand = ReactiveCommand.CreateAsyncTask(async _ => { if (string.IsNullOrEmpty(Domain)) throw new ArgumentException("Must have a valid GitHub domain"); if (string.IsNullOrEmpty(Token)) throw new ArgumentException("Must have a valid Token"); Uri domainUri; if (!Uri.TryCreate(Domain, UriKind.Absolute, out domainUri)) throw new Exception("The provided domain is not a valid URL."); var apiUrl = Domain; if (apiUrl != null) { if (!apiUrl.EndsWith("/", StringComparison.Ordinal)) apiUrl += "/"; if (!apiUrl.Contains("/api/")) apiUrl += "api/v3/"; } try { using (alertDialogFactory.Activate("Logging in...")) { var account = await loginFactory.Authenticate(apiUrl, Domain, Token, true); await accountsRepository.SetDefault(account); return account; } } catch (UnauthorizedException) { throw new Exception("The provided token is invalid! Please try again or " + "create a new token as this one might have been revoked."); } }); LoginCommand.Subscribe(x => MessageBus.Current.SendMessage(new LogoutMessage())); }
public DefaultStartupViewModel(ISessionService sessionService, IAccountsRepository accountsService) { Title = "Default Startup View"; var menuViewModelType = typeof(MenuViewModel); SelectedStartupView = sessionService.Account.DefaultStartupView; this.WhenAnyValue(x => x.SelectedStartupView).Skip(1).Subscribe(x => { sessionService.Account.DefaultStartupView = x; accountsService.Update(sessionService.Account); Dismiss(); }); StartupViews = new ReactiveList<string>(from p in menuViewModelType.GetRuntimeProperties() let attr = p.GetCustomAttributes(typeof(PotentialStartupViewAttribute), true).ToList() where attr.Count == 1 && attr[0] is PotentialStartupViewAttribute select ((PotentialStartupViewAttribute)attr[0]).Name); }
public AddEnterpriseAccountViewModel( ILoginService loginFactory, IAccountsRepository accountsRepository, IAlertDialogFactory alertDialogFactory, IActionMenuFactory actionMenuFactory) : base(alertDialogFactory) { _loginFactory = loginFactory; _accountsRepository = accountsRepository; var gotoOAuthToken = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<EnterpriseOAuthTokenLoginViewModel>(); vm.Domain = Domain; NavigateTo(vm); }); ShowLoginOptionsCommand = ReactiveCommand.CreateAsyncTask(sender => { var actionMenu = actionMenuFactory.Create(); actionMenu.AddButton("Login via Token", gotoOAuthToken); return actionMenu.Show(sender); }); }
public static void Migrate(IAccountsRepository accounts) { var accountsDir = AccountPreferencesService.AccountsDir; if (!Directory.Exists(accountsDir)) return; var accountsDb = Path.Combine(accountsDir, "accounts.db"); if (!File.Exists(accountsDb)) return; var db = new SQLiteConnection(accountsDb); foreach (var account in db.Table<GitHubAccount>()) { // Create a new account accounts.Insert(new CodeHub.Core.Data.GitHubAccount { AvatarUrl = account.AvatarUrl, Username = account.Username, ShowOrganizationsInEvents = account.ShowOrganizationsInEvents, ShowRepositoryDescriptionInList = account.ShowRepositoryDescriptionInList, IsPushNotificationsEnabled = account.IsPushNotificationsEnabled, ExpandOrganizations = account.ExpandOrganizations, IsEnterprise = account.IsEnterprise, Domain = account.Domain, WebDomain = account.WebDomain, OAuth = account.OAuth, PinnnedRepositories = account.PinnnedRepositories.Select(x => new CodeHub.Core.Data.PinnedRepository() { Name = x.Name, Owner = x.Owner, Slug = x.Slug }).ToList() }); } File.Delete(accountsDb); }
public AssetsController(IAccountsRepository accountsRepository) { _accountsRepository = accountsRepository; }
public UserController(IAccountsContext context, IAccountsRepository<User> userRepository) { _context = context; _userRepository = userRepository; }
public MenuViewModel(ISessionService sessionService, IAccountsRepository accountsService) { _applicationService = sessionService; GoToNotificationsCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<NotificationsViewModel>(); vm.NotificationCount.Subscribe(x => Notifications = x); NavigateTo(vm); }); GoToAccountsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<AccountsViewModel>())); GoToProfileCommand = ReactiveCommand.Create(); GoToProfileCommand .Select(_ => this.CreateViewModel<UserViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToMyIssuesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<MyIssuesViewModel>())); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType<RepositoryIdentifier>().Subscribe(x => { var vm = this.CreateViewModel<RepositoryViewModel>(); vm.RepositoryOwner = x.Owner; vm.RepositoryName = x.Name; NavigateTo(vm); }); GoToSettingsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<SettingsViewModel>())); GoToNewsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<NewsViewModel>())); GoToOrganizationsCommand = ReactiveCommand.Create(); GoToOrganizationsCommand .Select(_ => this.CreateViewModel<OrganizationsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToTrendingRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<RepositoriesTrendingViewModel>())); GoToExploreRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<ExploreViewModel>())); GoToOrganizationEventsCommand = ReactiveCommand.Create(); GoToOrganizationEventsCommand .OfType<Octokit.Organization>() .Select(x => this.CreateViewModel<UserEventsViewModel>().Init(x.Login)) .Subscribe(NavigateTo); GoToOrganizationCommand = ReactiveCommand.Create(); GoToOrganizationCommand .OfType<Octokit.Organization>() .Select(x => this.CreateViewModel<OrganizationViewModel>().Init(x.Login)) .Subscribe(NavigateTo); GoToOwnedRepositoriesCommand = ReactiveCommand.Create(); GoToOwnedRepositoriesCommand .Select(_ => this.CreateViewModel<UserRepositoriesViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToStarredRepositoriesCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<RepositoriesStarredViewModel>())); GoToWatchedRepositoriesCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<RepositoriesWatchedViewModel>())); GoToPublicGistsCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<PublicGistsViewModel>())); GoToStarredGistsCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<StarredGistsViewModel>())); GoToMyGistsCommand = ReactiveCommand.Create(); GoToMyGistsCommand .Select(_ => this.CreateViewModel<UserGistsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToMyEvents = ReactiveCommand.Create(); GoToMyEvents .Select(_ => this.CreateViewModel<UserEventsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToFeedbackCommand = ReactiveCommand.Create(); GoToFeedbackCommand .Select(x => this.CreateViewModel<WebBrowserViewModel>()) .Select(x => x.Init("https://codehub.uservoice.com")) .Subscribe(NavigateTo); DeletePinnedRepositoryCommand = ReactiveCommand.Create(); DeletePinnedRepositoryCommand.OfType<PinnedRepository>() .Subscribe(x => { sessionService.Account.PinnnedRepositories.Remove(x); accountsService.Update(sessionService.Account); }); LoadCommand = ReactiveCommand.CreateAsyncTask(_ => { var notifications = sessionService.GitHubClient.Notification.GetAllForCurrent(); notifications.ToBackground(x => Notifications = x.Count); var organizations = sessionService.GitHubClient.Organization.GetAllForCurrent(); organizations.ToBackground(x => Organizations = x); return Task.WhenAll(notifications, organizations); }); }
public ListController(IAccountsRepository accountsRepository) { _accountsRepository = accountsRepository; }
public SessionService(IAccountsRepository accountsRepository, IAnalyticsService analyticsService) { _accountsRepository = accountsRepository; _analyticsService = analyticsService; }
public SrvLykkeWalletMock(IMockLykkeWalletRepository mockLykkeWalletRepository, IAccountsRepository accountsRepository) { _mockLykkeWalletRepository = mockLykkeWalletRepository; _accountsRepository = accountsRepository; }
public AccountsController(IAccountsRepository repository) { AccountsRepository = repository; }
public MenuViewModel(ISessionService sessionService, IAccountsRepository accountsService) { _sessionService = sessionService; this.WhenAnyValue(x => x.Account) .Select(x => new GitHubAvatar(x.AvatarUrl)) .ToProperty(this, x => x.Avatar, out _avatar); GoToNotificationsCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<NotificationsViewModel>(); vm.NotificationCount.Subscribe(x => Notifications = x); NavigateTo(vm); }); GoToAccountsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<AccountsViewModel>())); GoToProfileCommand = ReactiveCommand.Create(); GoToProfileCommand .Select(_ => this.CreateViewModel<UserViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToMyIssuesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<MyIssuesViewModel>())); GoToRepositoryCommand = ReactiveCommand.Create(); GoToRepositoryCommand.OfType<RepositoryIdentifier>() .Select(x => this.CreateViewModel<RepositoryViewModel>().Init(x.Owner, x.Name)) .Subscribe(NavigateTo); GoToSettingsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<SettingsViewModel>())); GoToNewsCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<NewsViewModel>())); GoToOrganizationsCommand = ReactiveCommand.Create(); GoToOrganizationsCommand .Select(_ => this.CreateViewModel<OrganizationsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToTrendingRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<RepositoriesTrendingViewModel>())); GoToExploreRepositoriesCommand = ReactiveCommand.Create().WithSubscription(_ => NavigateTo(this.CreateViewModel<ExploreViewModel>())); GoToOrganizationEventsCommand = ReactiveCommand.Create(); GoToOrganizationEventsCommand .OfType<Octokit.Organization>() .Select(x => this.CreateViewModel<UserEventsViewModel>().Init(x.Login)) .Subscribe(NavigateTo); GoToOrganizationCommand = ReactiveCommand.Create(); GoToOrganizationCommand .OfType<Octokit.Organization>() .Select(x => this.CreateViewModel<OrganizationViewModel>().Init(x.Login)) .Subscribe(NavigateTo); GoToOwnedRepositoriesCommand = ReactiveCommand.Create(); GoToOwnedRepositoriesCommand .Select(_ => this.CreateViewModel<UserRepositoriesViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToStarredRepositoriesCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<RepositoriesStarredViewModel>())); GoToWatchedRepositoriesCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<RepositoriesWatchedViewModel>())); GoToPublicGistsCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<PublicGistsViewModel>())); GoToStarredGistsCommand = ReactiveCommand.Create().WithSubscription( _ => NavigateTo(this.CreateViewModel<StarredGistsViewModel>())); GoToMyGistsCommand = ReactiveCommand.Create(); GoToMyGistsCommand .Select(_ => this.CreateViewModel<UserGistsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToMyEvents = ReactiveCommand.Create(); GoToMyEvents .Select(_ => this.CreateViewModel<UserEventsViewModel>()) .Select(x => x.Init(Account.Username)) .Subscribe(NavigateTo); GoToFeedbackCommand = ReactiveCommand.Create(); GoToFeedbackCommand.Subscribe(_ => { var vm = sessionService.Account.IsEnterprise ? (IBaseViewModel)this.CreateViewModel<EnterpriseSupportViewModel>() : this.CreateViewModel<SupportViewModel>(); NavigateTo(vm); }); DeletePinnedRepositoryCommand = ReactiveCommand.Create(); DeletePinnedRepositoryCommand.OfType<PinnedRepository>() .Subscribe(x => { sessionService.Account.PinnnedRepositories.Remove(x); accountsService.Update(sessionService.Account); }); ActivateCommand = ReactiveCommand.Create(); ActivateCommand.Subscribe(x => { var startupViewModel = sessionService.StartupViewModel; sessionService.StartupViewModel = null; if (startupViewModel != null) NavigateTo(startupViewModel); else GoToDefaultTopView.ExecuteIfCan(); }); LoadCommand = ReactiveCommand.CreateAsyncTask(_ => { var notifications = sessionService.GitHubClient.Notification.GetAllForCurrent(); notifications.ToBackground(x => Notifications = x.Count); var organizations = sessionService.GitHubClient.Organization.GetAllForCurrent(); organizations.ToBackground(x => Organizations = x); return Task.WhenAll(notifications, organizations); }); }
public RepositoryViewModel(ISessionService applicationService, IAccountsRepository accountsService, IActionMenuFactory actionMenuService) { ApplicationService = applicationService; _accountsService = accountsService; var validRepositoryObservable = this.WhenAnyValue(x => x.Repository).Select(x => x != null); this.WhenAnyValue(x => x.RepositoryName).Subscribe(x => Title = x); this.WhenAnyValue(x => x.Repository).Subscribe(x => { Stargazers = x != null ? (int?)x.StargazersCount : null; Watchers = x != null ? (int?)x.SubscribersCount : null; }); this.WhenAnyValue(x => x.Repository.Description) .Select(x => Emojis.FindAndReplace(x)) .ToProperty(this, x => x.Description, out _description); ToggleStarCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.IsStarred).Select(x => x.HasValue), t => ToggleStar()); ToggleWatchCommand = ReactiveCommand.CreateAsyncTask( this.WhenAnyValue(x => x.IsWatched, x => x.HasValue), t => ToggleWatch()); GoToOwnerCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository).Select(x => x != null)); GoToOwnerCommand.Select(_ => Repository.Owner).Subscribe(x => { if (string.Equals(x.Type, "organization", StringComparison.OrdinalIgnoreCase)) { var vm = this.CreateViewModel<OrganizationViewModel>(); vm.Init(RepositoryOwner); NavigateTo(vm); } else { var vm = this.CreateViewModel<UserViewModel>(); vm.Init(RepositoryOwner); NavigateTo(vm); } }); PinCommand = ReactiveCommand.Create(validRepositoryObservable); PinCommand.Subscribe(x => PinRepository()); GoToForkParentCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && x.Fork && x.Parent != null)); GoToForkParentCommand.Subscribe(x => { var vm = this.CreateViewModel<RepositoryViewModel>(); vm.RepositoryOwner = Repository.Parent.Owner.Login; vm.RepositoryName = Repository.Parent.Name; vm.Repository = Repository.Parent; NavigateTo(vm); }); GoToStargazersCommand = ReactiveCommand.Create(); GoToStargazersCommand.Subscribe(_ => { var vm = this.CreateViewModel<RepositoryStargazersViewModel>(); vm.Init(RepositoryOwner, RepositoryName); NavigateTo(vm); }); GoToWatchersCommand = ReactiveCommand.Create(); GoToWatchersCommand.Subscribe(_ => { var vm = this.CreateViewModel<RepositoryWatchersViewModel>(); vm.Init(RepositoryOwner, RepositoryName); NavigateTo(vm); }); GoToEventsCommand = ReactiveCommand.Create(); GoToEventsCommand.Subscribe(_ => { var vm = this.CreateViewModel<RepositoryEventsViewModel>(); vm.Init(RepositoryOwner, RepositoryName); NavigateTo(vm); }); GoToIssuesCommand = ReactiveCommand.Create(); GoToIssuesCommand .Select(_ => this.CreateViewModel<IssuesViewModel>()) .Select(x => x.Init(RepositoryOwner, RepositoryName)) .Subscribe(NavigateTo); GoToReadmeCommand = ReactiveCommand.Create(); GoToReadmeCommand .Select(_ => this.CreateViewModel<ReadmeViewModel>()) .Select(x => x.Init(RepositoryOwner, RepositoryName)) .Subscribe(NavigateTo); GoToBranchesCommand = ReactiveCommand.Create(); GoToBranchesCommand .Select(_ => this.CreateViewModel<CommitBranchesViewModel>()) .Select(x => x.Init(RepositoryOwner, RepositoryName)) .Subscribe(NavigateTo); GoToCommitsCommand = ReactiveCommand.Create(); GoToCommitsCommand.Subscribe(_ => { if (Branches != null && Branches.Count == 1) { var vm = this.CreateViewModel<CommitsViewModel>(); var branch = Repository == null ? null : Repository.DefaultBranch; NavigateTo(vm.Init(RepositoryOwner, RepositoryName, branch)); } else { GoToBranchesCommand.ExecuteIfCan(); } }); GoToPullRequestsCommand = ReactiveCommand.Create(); GoToPullRequestsCommand.Subscribe(_ => { var vm = this.CreateViewModel<PullRequestsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; NavigateTo(vm); }); GoToSourceCommand = ReactiveCommand.Create(); GoToSourceCommand.Subscribe(_ => { var vm = this.CreateViewModel<BranchesAndTagsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; NavigateTo(vm); }); GoToContributors = ReactiveCommand.Create(); GoToContributors.Subscribe(_ => { var vm = this.CreateViewModel<RepositoryContributorsViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; NavigateTo(vm); }); GoToForksCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<RepositoryForksViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; NavigateTo(vm); }); GoToReleasesCommand = ReactiveCommand.Create().WithSubscription(_ => { var vm = this.CreateViewModel<ReleasesViewModel>(); vm.RepositoryOwner = RepositoryOwner; vm.RepositoryName = RepositoryName; NavigateTo(vm); }); ShareCommand = ReactiveCommand.Create(validRepositoryObservable); ShareCommand.Subscribe(sender => actionMenuService.ShareUrl(sender, Repository.HtmlUrl)); var canShowMenu = this.WhenAnyValue(x => x.Repository, x => x.IsStarred, x => x.IsWatched) .Select(x => x.Item1 != null && x.Item2 != null && x.Item3 != null); ShowMenuCommand = ReactiveCommand.CreateAsyncTask(canShowMenu, sender => { var menu = actionMenuService.Create(); menu.AddButton(IsPinned ? "Unpin from Slideout Menu" : "Pin to Slideout Menu", PinCommand); menu.AddButton(IsStarred.Value ? "Unstar This Repo" : "Star This Repo", ToggleStarCommand); menu.AddButton(IsWatched.Value ? "Unwatch This Repo" : "Watch This Repo", ToggleWatchCommand); menu.AddButton("Show in GitHub", GoToHtmlUrlCommand); menu.AddButton("Share", ShareCommand); return menu.Show(sender); }); var gotoWebUrl = new Action<string>(x => { var vm = this.CreateViewModel<WebBrowserViewModel>(); vm.Init(x); NavigateTo(vm); }); GoToHtmlUrlCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.HtmlUrl))); GoToHtmlUrlCommand.Select(_ => Repository.HtmlUrl).Subscribe(gotoWebUrl); GoToHomepageCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Repository, x => x != null && !string.IsNullOrEmpty(x.Homepage))); GoToHomepageCommand.Select(_ => Repository.Homepage).Subscribe(gotoWebUrl); LoadCommand = ReactiveCommand.CreateAsyncTask(async _ => { var t1 = applicationService.Client.ExecuteAsync(ApplicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].Get()); applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReadme()) .ToBackground(x => Readme = x.Data); applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetBranches()) .ToBackground(x => Branches = x.Data); applicationService.GitHubClient.Activity.Watching.CheckWatched(RepositoryOwner, RepositoryName) .ToBackground(x => IsWatched = x); applicationService.GitHubClient.Activity.Starring.CheckStarred(RepositoryOwner, RepositoryName) .ToBackground(x => IsStarred = x); applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetContributors()) .ToBackground(x => Contributors = x.Data.Count); // applicationService.GitHubClient.Repository.GetAllLanguages(RepositoryOwner, RepositoryName) // .ToBackground(x => Languages = x.Count); applicationService.Client.ExecuteAsync(applicationService.Client.Users[RepositoryOwner].Repositories[RepositoryName].GetReleases()) .ToBackground(x => Releases = x.Data.Count); Repository = (await t1).Data; }); }
public LoginService(IAccountsRepository accounts) { _accounts = accounts; }
public FundController(IAccountsRepository accountsRepository, ISrvLykkeWallet srvLykkeWallet) { _accountsRepository = accountsRepository; _srvLykkeWallet = srvLykkeWallet; }
public AccountantService(IAccountsRepository accountsRepository, ITransactionsRepository transactionsRepository) { this._transactionsRepository = transactionsRepository; this._accountsRepository = accountsRepository; }
public AccountController(IAccountsContext context, IAccountsRepository<User> accountsRepository) { _context = context; _accountsRepository = accountsRepository; }
public Login (UIWindow window, IAccountsRepository repository) { this.repository = repository; _window = window; }