private async Task SetAsWorkstationAccountAsync() { try { await EmployeeService.SetAsPrimaryAccountAsync(Account.Employee.Id, Account.Id); var employee = await EmployeeService.GetEmployeeByIdAsync(Account.Employee.Id); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(employee.Id)); await Refresh.InvokeAsync(this); await ToastService.ShowToastAsync("Account setted as primary.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.EmployeeId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { await ModalDialogService.CloseAsync(); Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); } }
private async Task CreateAccountAsync() { try { await ButtonSpinner.SpinAsync(async() => { await SharedAccountService.CreateSharedAccountAsync(SharedAccount); await ToastService.ShowToastAsync("Account created.", ToastType.Success); await SynchronizationService.UpdateSharedAccounts(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.Urls), ex.Message); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
public static async Task Main(string[] args) { var builder = new ConfigurationBuilder() .SetBasePath(Directory.GetCurrentDirectory()) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); var configuration = builder.Build(); var sw = new Stopwatch(); sw.Start(); using (var mservice = new MongoRepository <Token>()) { var tokens = mservice.GetAllAsync().Result; foreach (var token in tokens) { if (string.IsNullOrEmpty(token.CmcName)) { continue; } Console.WriteLine($"Getting the current price for token {token.Symbol}."); try { Pricing.PriceService.GetPriceLastAsync(token.CmcName, token.Symbol).Wait(); } catch (Exception ex) { Console.WriteLine($"Error while getting the current price for token {token.Symbol}. {ex.Message}"); } } Console.WriteLine($"Getting current the current price for the main currency."); try { Pricing.PriceService.GetPriceLastAsync(configuration["AppSettings:MainCurrencyName"].ToLower(), configuration["AppSettings:MainCurrencySymbol"]).Wait(); } catch (Exception ex) { Console.WriteLine($"Error while getting the current price for the main currency. {ex.Message}"); } } try { var synchronizationService = new SynchronizationService(); await synchronizationService.GetNewBlockSyncRequests(); await ProcessPendingBlockSyncRequests(); await synchronizationService.SyncPendingTransactionReceipts(); } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { sw.Stop(); } Console.WriteLine($"Finished in {sw.ElapsedMilliseconds} ms."); }
public ScheduleViewModel(SynchronizationService synchronizationService, Attendee attendee, ImageCache imageCache, SearchModel searchModel) { _synchronizationService = synchronizationService; _attendee = attendee; _imageCache = imageCache; _searchModel = searchModel; }
private async Task AddSharedAccoountAsync() { try { var account = await EmployeeService.AddSharedAccountAsync(EmployeeId, SelectedSharedAccount.Id); var employee = await EmployeeService.GetEmployeeByIdAsync(account.EmployeeId); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(employee.HardwareVaults.Select(x => x.Id).ToArray()); await Refresh.InvokeAsync(this); await ToastService.ShowToastAsync("Account added and will be recorded when the device is connected to the server.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, EmployeeId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { await ModalDialogService.CloseAsync(); Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); } }
private async Task EditAccoountOtpAsync() { try { await ButtonSpinner.SpinAsync(async() => { var vaults = await SharedAccountService.EditSharedAccountOtpAsync(Account, AccountOtp); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(vaults); await SynchronizationService.UpdateSharedAccounts(ExceptPageId); await ToastService.ShowToastAsync("Account OTP updated.", ToastType.Success); await ModalDialogService.CloseAsync(); }); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(SharedAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
/// <summary> /// Creates the instance. /// </summary> /// <param name="appSetting">The app setting.</param> /// <param name="oItemType">Type of the o item.</param> /// <returns></returns> public static RemoteProviderProxy CreateInstance(syncAppSetting appSetting, Outlook.OlItemType oItemType) { RemoteProviderProxy retVal = null; NetworkCredential cred = new NetworkCredential(); cred.UserName = appSetting.ibnPortalLogin; cred.Password = appSetting.ibnPortalPassword; SynchronizationService syncService = new SynchronizationService(); //enable session syncService.CookieContainer = new System.Net.CookieContainer(); string syncServiceUrl = appSetting.ibnPortalUrl; if (!syncServiceUrl.Contains(OutlookAddin.Resources.System_IbnSyncWebServicePath)) { Uri url = new Uri(syncServiceUrl); UriBuilder uriBuilder = new UriBuilder(); uriBuilder.Scheme = Uri.UriSchemeHttp; uriBuilder.Port = url.Port; uriBuilder.Host = url.Host; uriBuilder.Path = url.AbsolutePath + OutlookAddin.Resources.System_IbnSyncWebServicePath; syncServiceUrl = uriBuilder.ToString(); } syncService.Url = syncServiceUrl; //Authentificate syncService.SetCredentials(cred); //Set sync provider syncService.SetProviderTypeForSyncSession((OutlookAddin.SyncService.eSyncProviderType)oItemType); retVal = new RemoteProviderProxy(syncService); return retVal; }
private async Task EditAccountPasswordAsync() { try { await ButtonSpinner.SpinAsync(async() => { using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await EmployeeService.EditPersonalAccountPwdAsync(Account, _accountPassword); if (_accountPassword.UpdateActiveDirectoryPassword) { await LdapService.SetUserPasswordAsync(Account.EmployeeId, _accountPassword.Password, LdapSettings); } transactionScope.Complete(); } RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId)); await ToastService.ShowToastAsync("Account password updated.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.EmployeeId); await ModalDialogService.CloseAsync(); }); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task OpenDialogAddSharedAccountAsync() { if (!await VerifyAdUserAsync()) { return; } RenderFragment body = (builder) => { builder.OpenComponent(0, typeof(AddSharedAccount)); builder.AddAttribute(1, nameof(AddSharedAccount.EmployeeId), EmployeeId); builder.CloseComponent(); }; var instance = await ModalDialogService.ShowAsync("Add shared account", body, ModalDialogSize.Large); var result = await instance.Result; if (result.Succeeded) { await LoadEmployeeAsync(); await DataTableService.LoadTableDataAsync(); await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId); } }
private async Task InviteAdminAsync() { try { await ButtonSpinner.SpinAsync(async() => { var callBakcUrl = await ApplicationUserService.InviteAdministratorAsync(Invitation.Email, NavigationManager.BaseUri); await EmailSenderService.SendUserInvitationAsync(Invitation.Email, callBakcUrl); await ToastService.ShowToastAsync("Administrator invited.", ToastType.Success); await SynchronizationService.UpdateAdministrators(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Invitation.Email), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
/// <summary> /// Creates the instance. /// </summary> /// <param name="appSetting">The app setting.</param> /// <param name="oItemType">Type of the o item.</param> /// <returns></returns> public static RemoteProviderProxy CreateInstance(syncAppSetting appSetting, Outlook.OlItemType oItemType) { RemoteProviderProxy retVal = null; NetworkCredential cred = new NetworkCredential(); cred.UserName = appSetting.ibnPortalLogin; cred.Password = appSetting.ibnPortalPassword; SynchronizationService syncService = new SynchronizationService(); //enable session syncService.CookieContainer = new System.Net.CookieContainer(); string syncServiceUrl = appSetting.ibnPortalUrl; if (!syncServiceUrl.Contains(OutlookAddin.Resources.System_IbnSyncWebServicePath)) { Uri url = new Uri(syncServiceUrl); UriBuilder uriBuilder = new UriBuilder(); uriBuilder.Scheme = Uri.UriSchemeHttp; uriBuilder.Port = url.Port; uriBuilder.Host = url.Host; uriBuilder.Path = url.AbsolutePath + OutlookAddin.Resources.System_IbnSyncWebServicePath; syncServiceUrl = uriBuilder.ToString(); } syncService.Url = syncServiceUrl; //Authentificate syncService.SetCredentials(cred); //Set sync provider syncService.SetProviderTypeForSyncSession((OutlookAddin.SyncService.eSyncProviderType)oItemType); retVal = new RemoteProviderProxy(syncService); return(retVal); }
public static string GetSyncServiceIcon(SynchronizationService service, string serverInfo = null) { switch (service) { case SynchronizationService.None: return(string.Empty); case SynchronizationService.ToodleDo: return(syncToodleDoIconUri.ToString()); case SynchronizationService.Exchange: case SynchronizationService.ExchangeEws: if (!string.IsNullOrEmpty(serverInfo) && serverInfo.ToLower().Contains("office365")) { return(syncOffice365IconUri.ToString()); } else { return(syncExchangeIconUri.ToString()); } case SynchronizationService.OutlookActiveSync: return(syncOutlookIconUri.ToString()); case SynchronizationService.ActiveSync: return(syncActiveSyncIconUri.ToString()); case SynchronizationService.Vercors: return(syncVercorsIconUri.ToString()); default: throw new ArgumentOutOfRangeException(); } }
public MainViewModel(Community community, NavigationModel navigationModel, NewEntryModel newEntry, SynchronizationService synhronizationService) { _community = community; _navigationModel = navigationModel; _newEntry = newEntry; _synhronizationService = synhronizationService; }
private async Task AddAsync() { try { if (!Groups.Any(x => x.Checked)) { WarningMessage = "Please select at least one group."; return; } await LdapService.AddGroupsAsync(Groups.Where(x => x.Checked).ToList(), CreateEmployees); await ToastService.ShowToastAsync("Groups added.", ToastType.Success); await SynchronizationService.UpdateGroups(ExceptPageId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task SaveSettingsAsync() { try { var isValid = LdapSettingsContext.Validate(); if (!isValid) { return; } await LdapService.ValidateCredentialsAsync(LdapSettings); await AppSettingsService.SetLdapSettingsAsync(LdapSettings); await ToastService.ShowToastAsync("Domain settings updated.", ToastType.Success); await SynchronizationService.UpdateParameters(ExceptPageId); await ModalDialogService.CloseAsync(); } catch (LdapForNet.LdapInvalidCredentialsException) { ValidationErrorMessage.DisplayError(nameof(LdapSettings.Password), "Invalid password"); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task DeleteAdminAsync() { if (DataTableService.Entities.Count == 1) { return; } RenderFragment body = (builder) => { builder.OpenComponent(0, typeof(DeleteAdministrator)); builder.AddAttribute(1, nameof(DeleteAdministrator.ApplicationUserId), DataTableService.SelectedEntity.Id); builder.CloseComponent(); }; var instance = await ModalDialogService.ShowAsync("Delete Administrator", body, ModalDialogSize.Default); var result = await instance.Result; if (result.Succeeded) { await DataTableService.LoadTableDataAsync(); await SynchronizationService.UpdateAdministrators(PageId); } }
private async Task OpenModalDisableSsoAsync() { if (!await VerifyAdUserAsync()) { return; } RenderFragment body = (builder) => { builder.OpenComponent(0, typeof(EmployeeDisableSso)); builder.AddAttribute(1, nameof(EmployeeDisableSso.Employee), Employee); builder.CloseComponent(); }; var instance = await ModalDialogService.ShowAsync("Disable SSO", body); var result = await instance.Result; if (result.Succeeded) { await LoadEmployeeSsoState(); await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId); } }
public MainViewModel(Community community, SynchronizationService synhronizationService, NewGameSelectionModel newGameSelection) { _community = community; _synhronizationService = synhronizationService; _newGame = new NewGameViewModel(synhronizationService.Domain, newGameSelection); }
public async Task AddAsync() { try { if (!Employees.Any(x => x.Value == true)) { _notSelected = true; return; } var employeeIds = Employees.Where(x => x.Value).Select(x => x.Key.Id).ToList(); await GroupService.AddEmployeesToGroupAsync(employeeIds, GroupId); await ToastService.ShowToastAsync("Employee added.", ToastType.Success); await SynchronizationService.UpdateGroupDetails(ExceptPageId, GroupId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task DisableAlarmAsync() { try { var checkPassword = await UserManager.CheckPasswordAsync(ApplicationUser, UserConfirmPassword); if (!checkPassword) { throw new Exception("Invalid password"); } await RemoteWorkstationConnections.UnlockAllWorkstationsAsync(ApplicationUser.Email); await SynchronizationService.UpdateAlarm(ExceptPageId); await CallBack.InvokeAsync(this); await ToastService.ShowToastAsync("All workstations are unlocked.", ToastType.Success); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private void OpenProviderSettings(SynchronizationService synchronizationService, string parameter = null) { if (synchronizationService == SynchronizationService.None) { return; } switch (synchronizationService) { case SynchronizationService.ToodleDo: this.NavigationService.FlyoutTo(ViewLocator.SyncToodleDoSettingsPage, parameter); break; case SynchronizationService.Exchange: case SynchronizationService.ExchangeEws: this.NavigationService.FlyoutTo(ViewLocator.SyncExchangeSettingsPage, parameter); break; case SynchronizationService.OutlookActiveSync: this.NavigationService.FlyoutTo(ViewLocator.SyncOutlookActiveSyncSettingsPage, parameter); break; case SynchronizationService.ActiveSync: this.NavigationService.FlyoutTo(ViewLocator.SyncActiveSyncSettingsPage, parameter); break; case SynchronizationService.Vercors: this.NavigationService.FlyoutTo(ViewLocator.SyncVercorsSettingsPage, parameter); break; default: throw new ArgumentOutOfRangeException("synchronizationService"); } }
private async Task AddVaultAsync() { try { if (SelectedHardwareVault == null) { WarningMessage = "Please, select a vault."; return; } await WorkstationService.AddProximityVaultAsync(WorkstationId, SelectedHardwareVault.Id); await RemoteWorkstationConnectionsService.UpdateProximitySettingsAsync(WorkstationId, await WorkstationService.GetProximitySettingsAsync(WorkstationId)); await ToastService.ShowToastAsync("Vault added", ToastType.Success); await SynchronizationService.UpdateWorkstationDetails(ExceptPageId, WorkstationId); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task CreateAccountAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.CreatePersonalAccountAsync(PersonalAccount); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(EmployeeId)); await Refresh.InvokeAsync(this); await ToastService.ShowToastAsync("Account created.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, EmployeeId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Name), ex.Message); } catch (IncorrectUrlException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.Urls), ex.Message); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(PersonalAccount.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
private async Task EditAccountOtpAsync() { try { await ButtonSpinner.SpinAsync(async() => { await EmployeeService.EditPersonalAccountOtpAsync(Account, _accountOtp); RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId)); await ToastService.ShowToastAsync("Account OTP updated.", ToastType.Success); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, Account.EmployeeId); await ModalDialogService.CloseAsync(); }); } catch (IncorrectOtpException ex) { ValidationErrorMessage.DisplayError(nameof(AccountOtp.OtpSecret), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task OpenDialogRemoveHardwareVaultAsync(HardwareVault hardwareVault) { if (!await VerifyAdUserAsync()) { return; } RenderFragment body = (builder) => { builder.OpenComponent(0, typeof(DeleteHardwareVault)); builder.AddAttribute(1, nameof(DeleteHardwareVault.HardwareVaultId), hardwareVault.Id); builder.CloseComponent(); }; var instance = await ModalDialogService.ShowAsync("Delete hardware vault", body); var result = await instance.Result; if (result.Succeeded) { await LoadEmployeeAsync(); await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId); } }
private async Task EditAsync() { try { await ButtonSpinner.SpinAsync(async() => { await OrgStructureService.EditDepartmentAsync(Department); await ToastService.ShowToastAsync("Department updated.", ToastType.Success); await Refresh.InvokeAsync(this); await SynchronizationService.UpdateOrgSructureCompanies(ExceptPageId); await ModalDialogService.CloseAsync(); }); } catch (AlreadyExistException ex) { ValidationErrorMessage.DisplayError(nameof(Department.Name), ex.Message); } catch (Exception ex) { Logger.LogError(ex.Message); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CloseAsync(); } }
private async Task OpenDialogDeleteAccountAsync() { if (!await VerifyAdUserAsync()) { return; } RenderFragment body = (builder) => { builder.OpenComponent(0, typeof(DeleteAccount)); builder.AddAttribute(1, nameof(DeleteAccount.AccountId), DataTableService.SelectedEntity.Id); builder.CloseComponent(); }; var instance = await ModalDialogService.ShowAsync("Delete Account", body); var result = await instance.Result; if (result.Succeeded) { await DataTableService.LoadTableDataAsync(); await SynchronizationService.UpdateEmployeeDetails(PageId, EmployeeId); } }
public async Task DeleteVaultAsync() { try { var employeeId = HardwareVault.EmployeeId; await EmployeeService.RemoveHardwareVaultAsync(HardwareVault.Id, Reason, IsNeedBackup); await Refresh.InvokeAsync(this); RemoteDeviceConnectionsService.StartUpdateHardwareVaultStatus(HardwareVault.Id); await SynchronizationService.UpdateEmployeeDetails(ExceptPageId, employeeId); await SynchronizationService.HardwareVaultStateChanged(HardwareVault.Id); await ToastService.ShowToastAsync("Vault removed.", ToastType.Success); await ModalDialogService.CloseAsync(); } catch (Exception ex) { Logger.LogError(ex.Message, ex); await ToastService.ShowToastAsync(ex.Message, ToastType.Error); await ModalDialogService.CancelAsync(); } }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (DesignMode) _synchronizationService.Initialize(); else _synchronizationService.InitializeDesignMode(); }
public ViewModelLocator() { NavigationModel navigationModel = new NavigationModel(); _synchronizationService = new SynchronizationService(navigationModel); if (!DesignerProperties.IsInDesignTool) _synchronizationService.Initialize(); _main = new MainViewModel(_synchronizationService.Community, navigationModel, _synchronizationService); }
public SynchronizationPageViewModel() { _syncService = SynchronizationService.GetInstance(); StartSyncCommand = new DelegateCommand(async() => { await _syncService.StartSyncProcess(); }); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled) { _synchronizationService.Initialize(); } }
public MainViewModel(Attendee attendee, SynchronizationService synhronizationService, ImageCache imageCache, SearchModel searchModel, Clock clock) { _attendee = attendee; _synhronizationService = synhronizationService; _imageCache = imageCache; _searchModel = searchModel; _clock = clock; }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) { _synchronizationService.Initialize(); } }
public MainViewModel( Individual individual, SynchronizationService synhronizationService, MessageBoardSelectionModel selection) { _individual = individual; _synchronizationService = synhronizationService; _selection = selection; }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignMode) _synchronizationService.Initialize(); else _synchronizationService.InitializeDesignData(); _selection = new MessageBoardSelectionModel(); }
public MainViewModel( SynchronizationService synchronizationService, SearchModel search, SelectionModel selection) { _synchronizationService = synchronizationService; _search = search; _selection = selection; }
public AllSessionsViewModel( SynchronizationService synchronizationService, SearchModel search, Func<Track, TrackViewModel> newTrackViewModel) { _synchronizationService = synchronizationService; _search = search; _newTrackViewModel = newTrackViewModel; }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.GetIsInDesignMode(new DependencyObject())) _synchronizationService.Initialize(); MessageBoardSelectionModel messageBoardSelectionModel = new MessageBoardSelectionModel(); _main = new MainViewModel(_synchronizationService.Community, messageBoardSelectionModel, _synchronizationService); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) _synchronizationService.Initialize(); _selection = new MessageBoardSelectionModel(); _main = new MainViewModel(_synchronizationService.Individual, _synchronizationService, _selection); _join = new JoinMessageBoardViewModel(_selection, _synchronizationService.Individual); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) _synchronizationService.Initialize(); NewGameSelectionModel newGameSelection = new NewGameSelectionModel(); _main = new MainViewModel(_synchronizationService.Community, _synchronizationService, newGameSelection); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) _synchronizationService.Initialize(); _conferenceSelection = new ConferenceSelection(); _imageCache = new ImageCache(); _searchModel = new SearchModel(); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignMode) _synchronizationService.Initialize(); else _synchronizationService.InitializeDesignMode(); _selection = new MessageBoardSelectionModel(); _selection.SelectedShare = _synchronizationService.Individual.Shares .FirstOrDefault(); }
public ViewModelLocator() { _navigationModel = new NavigationModel(); _surveySnapshot = new SurveySnapshotModel(); _surveyNavigationModel = new SurveyNavigationModel(); _synchronizationService = new SynchronizationService(_navigationModel); if (!DesignerProperties.IsInDesignTool) { _synchronizationService.Initialize(); TemporarilyPreselectDallasTechFest(); } _main = new MainViewModel(_synchronizationService.Community, _navigationModel, _synchronizationService); }
public static AllSessionsViewModel CreateViewModel( SelectionModel selectionModel, SearchModel search, SynchronizationService synchronizationService) { Func<SessionPlace, SessionHeaderViewModel> newSessionHeaderViewModel = s => new SessionHeaderViewModel(s, selectionModel); Func<Track, TrackViewModel> newTrackViewModel = t => new TrackViewModel(t, search, newSessionHeaderViewModel); return new AllSessionsViewModel(synchronizationService, search, newTrackViewModel); }
public ViewModelLocator() { var navigationModel = new NavigationModel(); var newEntry = new NewEntryModel(); _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) { _synchronizationService.Initialize(); navigationModel.SelectedShare = _synchronizationService.Identity.ActiveShares .OrderBy(share => share.Company.Name.Value) .FirstOrDefault(); _main = new MainViewModel(_synchronizationService.Community, navigationModel, newEntry, _synchronizationService); } }
public MainViewModel(Community community, SynchronizationService synhronizationService, CompanySelectionModel companySelection, GameSelectionModel gameSelection) { _gameSelection = gameSelection; _community = community; _synhronizationService = synhronizationService; _companySelection = companySelection; if (synhronizationService.Individual != null) { _companySelectionVM = new CompanySelectionViewModel( synhronizationService.Individual, _companySelection); } }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); if (!DesignerProperties.IsInDesignTool) _synchronizationService.Initialize(); _imageCache = new ImageCache(); _searchModel = new SearchModel(); _clock = new Clock(); _main = new MainViewModel(_synchronizationService.Attendee, _synchronizationService, _imageCache, _searchModel, _clock); _schedule = new ScheduleViewModel(_synchronizationService, _synchronizationService.Attendee, _imageCache, _searchModel); _tracks = new TracksViewModel(_synchronizationService.Attendee, _imageCache, _searchModel); _search = new SearchViewModel(_synchronizationService.Attendee, _imageCache, _searchModel); _map = new MapViewModel(_synchronizationService.Attendee, _imageCache, _clock); _notices = new NoticesViewModel(_synchronizationService.Attendee, _imageCache, _clock); _settings = new SettingsViewModel(_synchronizationService.Individual, _synchronizationService.Attendee); }
public ViewModelLocator() { _synchronizationService = new SynchronizationService(); CompanySelectionModel companySelection = new CompanySelectionModel(); GameSelectionModel gameSelection = new GameSelectionModel(companySelection); if (!DesignerProperties.IsInDesignTool) { _synchronizationService.Initialize(); companySelection.SelectedCompany = _synchronizationService .Individual.Companies .Ensure() .FirstOrDefault(); } _main = new MainViewModel( _synchronizationService.Community, _synchronizationService, companySelection, gameSelection); }
private RemoteProviderProxy(SynchronizationService syncService) { _syncService = syncService; }
public MainViewModel(Community community, MessageBoardSelectionModel selection, SynchronizationService synchronizationService) { _selection = selection; _community = community; _synchronizationService = synchronizationService; }