public DownloadVM( IDiversityServiceClient Service, IConnectivityService Connectivity, IFieldDataService Storage, IKeyMappingService Mappings, EventHierarchyLoader HierarchyLoader, [Dispatcher] IScheduler Dispatcher ) { this.Service = Service; this.Connectivity = Connectivity; this.Storage = Storage; this.Mappings = Mappings; this.HierarchyLoader = HierarchyLoader; QueryResult = new ReactiveCollection<Event>(); _IsOnlineAvailable = Connectivity.Status().Select(s => s == ConnectionStatus.Wifi).Do(_ => { this.GetType(); }, ex => { }, () => { }) .ToProperty(this, x => x.IsOnlineAvailable); SearchEvents = new ReactiveAsyncCommand(this.WhenAny(x => x.IsOnlineAvailable, x => x.Value)); SearchEvents.ShowInFlightNotification(Notifications, DiversityResources.Download_SearchingEvents); SearchEvents.ThrownExceptions .ShowServiceErrorNotifications(Notifications) .ShowErrorNotifications(Notifications) .Subscribe(); SearchEvents .RegisterAsyncObservable(query => Service.GetEventsByLocality(query as string ?? string.Empty) .TakeUntil(this.OnDeactivation()) ) .Do(_ => QueryResult.Clear()) .Subscribe(QueryResult.AddRange); CancelDownload = new ReactiveCommand(); DownloadElement = new ReactiveAsyncCommand(this.WhenAny(x => x.IsOnlineAvailable, x => x.Value)); DownloadElement.ThrownExceptions .ShowServiceErrorNotifications(Notifications) .ShowErrorNotifications(Notifications) .Subscribe(); DownloadElement .RegisterAsyncObservable(ev => IfNotDownloadedYet(ev as Event) .Select(HierarchyLoader.downloadAndStoreDependencies) .SelectMany(dl => dl.TakeUntil(CancelDownload)) .Scan(0, (acc, _) => ++acc) .Do(_ElementsDownloadedSubject.OnNext) ); _IsDownloading = DownloadElement.ItemsInflight .Select(x => x > 0) .ToProperty(this, x => x.IsDownloading); this.OnDeactivation() .Subscribe(_ => Messenger.SendMessage(EventMessage.Default, MessageContracts.INIT)); _ElementsDownloadedSubject = new Subject<int>(); _ElementsDownloaded = _ElementsDownloadedSubject.ToProperty(this, x => x.ElementsDownloaded, 0, Dispatcher); }
public DataClient (IMapperService mapperService, IConnectivityService connectivityService, ISerializerService serializerService, IHttpService httpService, IAppConfig appConfig) { _mapperService = mapperService.ThrowIfNull ("mapperService"); _connectivityService = connectivityService.ThrowIfNull ("connectivityService"); _serializerService = serializerService.ThrowIfNull ("serializerService"); _httpService = httpService.ThrowIfNull ("httpService"); _appConfig = appConfig.ThrowIfNull ("appConfig"); }
public BaseServiceClient(string url, string sessionId, IPackageInfo packageInfo, IConnectivityService connectivityService, ILogger logger) { _url = url; _sessionId = sessionId; _packageInfo = packageInfo; _connectivityService = connectivityService; Logger = logger; }
public SetupVM( ISettingsService Settings, IConnectivityService Connectivity, [Dispatcher] IScheduler Dispatcher, IDiversityServiceClient Repository ) { this.Repository = Repository; this.Settings = Settings; // On First Page Visit (App Launch) // If There already is a configuration (Settings) // Go To Home Page this.FirstActivation() .SelectMany(_ => Settings.CurrentSettings()) .Select(x => (x != null) ? Page.Home : Page.SetupWelcome) .ToMessage(Messenger); _IsOnlineAvailable = this.ObservableToProperty(Connectivity.WifiAvailable(), x => x.IsOnlineAvailable, false, Dispatcher); // Show current login data in case of Reset Settings.SettingsObservable() .Subscribe(SetLogin); // Command To begin Setup this.ShowLogin = new ReactiveCommand(); ShowLogin.Select(_ => Page.SetupLogin) .ToMessage(Messenger); // Command Condition var userPassAndWifi = Observable.CombineLatest( Connectivity.WifiAvailable(), this.WhenAny(x => x.UserName, x => x.GetValue()).Select(string.IsNullOrWhiteSpace), this.WhenAny(x => x.Password, x => x.GetValue()).Select(string.IsNullOrWhiteSpace), (wifi, a, b) => wifi & !(a | b)); // Command and Errorhandling this.GetRepositories = new ReactiveAsyncCommand(userPassAndWifi); GetRepositories.ShowInFlightNotification(Notifications, DiversityResources.Setup_Info_ValidatingLogin); GetRepositories.ThrownExceptions .ShowServiceErrorNotifications(Notifications) .ShowErrorNotifications(Notifications) .Subscribe(); var loginAndRepo = GetRepositories.RegisterAsyncObservable(GetRepositoriesObservable).Publish().PermaRef(); // Page Navigation if Login Successful // i.e. Any repositories have been returned loginAndRepo .Snd() .Subscribe(NavigateOrNotifyInvalidCredentials); // Repo Selection this.Database = new ListSelectionHelper<string>(Dispatcher); loginAndRepo .Select(t => t.Item2) .Merge(EmptyProjectsOnLoginStart()) .Subscribe(Database.ItemsObserver); // Settings Propagation LatestLogin = loginAndRepo .Fst() .MostRecent(null) .GetEnumerator(); // Command Condition var repoSelected = Database.SelectedItemObservable .Select(repo => repo != NoRepo) .AndNoItemsInFlight(GetRepositories); // Command and Errorhandling this.GetProjects = new ReactiveAsyncCommand(repoSelected); GetProjects.ShowInFlightNotification(Notifications, DiversityResources.Setup_Info_GettingProjects); GetProjects.ThrownExceptions .ShowServiceErrorNotifications(Notifications) .ShowErrorNotifications(Notifications) .Subscribe(); var loginAndProjects = GetProjects.RegisterAsyncObservable(GetProjectsObservable).Publish().PermaRef(); // Page Navigation loginAndProjects .Select(_ => Page.SetupProject) .ToMessage(Messenger); // Project Selection Project = new ListSelectionHelper<Project>(Dispatcher); loginAndProjects .Snd() .Merge( EmptyReposOnRepoChange() ) .Subscribe(Project.ItemsObserver); // Settings Propagation LatestLoginWithRepo = loginAndProjects .Fst() .MostRecent(null) .GetEnumerator(); // Command Condition var projectSelected = Project.SelectedItemObservable .Select(p => p != NoProject) .AndNoItemsInFlight(GetProjects); // Command and Errorhandling this.GetProfile = new ReactiveAsyncCommand(projectSelected); GetProfile.ShowInFlightNotification(Notifications, DiversityResources.Setup_Info_GettingProfile); GetProfile.ThrownExceptions .ShowServiceErrorNotifications(Notifications) .ShowErrorNotifications(Notifications) .Subscribe(); var loginWithProfile = GetProfile.RegisterAsyncObservable(GetProfileObservable).Publish().PermaRef(); // Page Navigation loginWithProfile .Select(_ => Page.SetupGPS) .ToMessage(Messenger); // Settings Propagation LatestLoginWithProfile = loginWithProfile .MostRecent(null) .GetEnumerator(); // Command And Page Navigation this.Save = new ReactiveAsyncCommand(); Save.RegisterAsyncObservable(SaveSettings) .Select(_ => Page.SetupVocabulary) .ToMessage(Messenger); }
public SettingsVM( ISettingsService Settings, ICleanupData Cleanup, IConnectivityService Connectivity ) { this.Cleanup = Cleanup; this.Settings = Settings; this.Connectivity = Connectivity; this.WhenAny(x => x.Model, x => x.Value) .Where(x => x != null) .Select(m => m.UseGPS) .Subscribe(x => UseGPS = x); Reset = new ReactiveAsyncCommand(Connectivity.WifiAvailable()); Reset.RegisterAsyncTask(OnReset); var setting_changed = this.WhenAny(x => x.UseGPS, x => x.Model, (gps, model) => (model.Value != null) ? model.Value.UseGPS != gps.Value : false); Save = new ReactiveCommand(setting_changed); Messenger.RegisterMessageSource( Save .Do(_ => saveModel()) .Select(_ => Page.Previous) ); RefreshVocabulary = new ReactiveCommand(Connectivity.WifiAvailable()); RefreshVocabulary .Subscribe(_ => { Messenger.SendMessage(Page.SetupVocabulary); }); ManageTaxa = new ReactiveCommand(); Messenger.RegisterMessageSource( ManageTaxa .Select(_ => Page.TaxonManagement) ); UploadData = new ReactiveCommand(); Messenger.RegisterMessageSource( UploadData .Select(_ => Page.Upload) ); DownloadData = new ReactiveCommand(); Messenger.RegisterMessageSource( DownloadData .Select(_ => Page.Download) ); Info = new ReactiveCommand(); Messenger.RegisterMessageSource( Info .Select(_ => Page.Info) ); ImportExport = new ReactiveCommand(); Messenger.RegisterMessageSource( ImportExport .Select(_ => Page.ImportExport) ); Settings .SettingsObservable() .Subscribe(x => Model = x); }
private TaskHelper() { loggingService = Prism.PrismApplicationBase.Current.Container.Resolve <ILoggingService>(); connectivityService = Prism.PrismApplicationBase.Current.Container.Resolve <IConnectivityService>(); dialogService = App.Current.Container.Resolve <IDialogService>(); }
private SettingsViewModel NewViewModel(IDesktopServiceSettings desktopServiceSettings = null, IDialogInteractionService dialogInteractionService = null, IConnectivityService connectivityService = null) { return(new SettingsViewModel( desktopServiceSettings ?? Mock.Of <IDesktopServiceSettings>(), dialogInteractionService ?? Mock.Of <IDialogInteractionService>(), connectivityService ?? Mock.Of <IConnectivityService>())); }
public TaskHelperFactory(IDialogsService dialogsService, IConnectivityService connectivityService) { this.dialogsService = dialogsService; this.connectivityService = connectivityService; }
public ExportDataServiceClient(string url, string sessionId, IPackageInfo packageInfo, IConnectivityService connectivityService) : base(url, sessionId, packageInfo, connectivityService, null) { }
public MapManagementVM( IConnectivityService Network, IMapTransferService MapService, IMapStorageService MapStorage, INotificationService Notifications, [Dispatcher] IScheduler Dispatcher ) { Contract.Requires(Network != null); Contract.Requires(MapService != null); Contract.Requires(MapStorage != null); Contract.Requires(Notifications != null); this.Network = Network; this.MapService = MapService; this.MapStorage = MapStorage; this.FirstActivation() .Subscribe(_ => getMaps.Execute(null)); MapList = getMaps.RegisterAsyncFunction(_ => MapStorage.getAllMaps().Select(m => new MapVM(m))) .SelectMany(vms => vms.ToList()) .ObserveOn(Dispatcher) .CreateCollection(); MapList.ItemsAdded .Subscribe(item => _local_map_register.Add(item.ServerKey, Unit.Default)); MapList.ItemsRemoved .Subscribe(item => _local_map_register.Remove(item.ServerKey)); SelectMap = new ReactiveCommand<MapVM>(vm => !vm.IsDownloading); SelectMap .Select(vm => vm as IElementVM<Map>) .ToMessage(Messenger, MessageContracts.VIEW); SelectMap .Select(_ => Page.Previous) .ToMessage(Messenger); DeleteMap = new ReactiveCommand<MapVM>(vm => !vm.IsDownloading); DeleteMap .Do(vm => MapList.Remove(vm)) .Select(vm => vm.Model) .Where(map => map != null) .Subscribe(map => MapStorage.deleteMap(map)); _IsOnlineAvailable = this.ObservableToProperty( this.OnActivation() .SelectMany(Network.WifiAvailable().TakeUntil(this.OnDeactivation())) .Do(x => { }) , x => x.IsOnlineAvailable, false); SearchMaps = new ReactiveAsyncCommand(_IsOnlineAvailable); _SearchResults = this.ObservableToProperty<MapManagementVM, IReactiveCollection<MapVM>>( SearchMaps.RegisterAsyncFunction(s => searchMapsImpl(s as string)) .ObserveOn(Dispatcher) .Select(result => { try { return new ReactiveCollection<MapVM>(result.Select(x => new MapVM(null) { ServerKey = x })) as IReactiveCollection<MapVM>; } catch (Exception) { return null; } }), x => x.SearchResults); DownloadMap = new ReactiveCommand<MapVM>(vm => canBeDownloaded(vm as MapVM), Observable.Empty<Unit>()); DownloadMap .Where(downloadMap.CanExecute) .CheckConnectivity(Network, Notifications) .Do(vm => vm.IsDownloading = true) .Do(_ => CurrentPivot = Pivot.Local) .Do(vm => MapList.Add(vm)) .Subscribe(downloadMap.Execute); downloadMap.RegisterAsyncObservable(vm => { var vm_t = vm as MapVM; if (vm_t == null) return Observable.Empty<System.Tuple<MapVM, Map>>(); else return MapService.downloadMap(vm_t.ServerKey) .ShowServiceErrorNotifications(Notifications) .Catch((WebException ex) => { Notifications.showNotification(DiversityResources.MapManagement_Message_NoPermissions); return Observable.Empty<Map>(); }) .Select(map => System.Tuple.Create(vm_t, map)); }) .ObserveOn(Dispatcher) .Select(t => { if (t.Item1 != null) // VM { if (t.Item2 != null) // Map { t.Item1.SetModel(t.Item2); } else { MapList.Remove(t.Item1); } } return t.Item1; }).Subscribe(_ => SelectMap.RaiseCanExecuteChanged()); }
public ShowMatchesViewModel(IMatchDataService matchDataService, IMvxMessenger messenger, IMvxWebBrowserTask webBrowser, IConnectivityService connectivityService, IDialogService dialogService) { _connectivityService = connectivityService; _dialogService = dialogService; _webBrowser = webBrowser; _comboCalcService = new CombinationCalculator(); matchOutcomes = new Dictionary <Match, string>(); _matchDataService = matchDataService; _token = messenger.Subscribe <OutcomeSelectedMessage>(UpdateVendorValue); Messenger = messenger; DirectToWebPageCommand = new MvxCommand(() => { if (_connectivityService.CheckOnline()) { try { _webBrowser.ShowWebPage(VendorValue.Vendor.Url); } catch (Exception) { _dialogService.ShowAlert("Ups, something went wrong when trying to redirct", "Couldn't redirct", "OK"); } } else { _dialogService.ShowAlert("Please connect to internet and try again", "Couldn't redirct. No Internet Connection", "OK"); } }); }
public MainViewModel(RCViewModel rcViewModel, IConfigReaderService configReaderService, ILogService logService, IRCService rcService, ICCService ccService, IConnectivityService connectivityService) { x = rcViewModel; _configReaderService = configReaderService; _logService = logService; _rcService = rcService; _ccService = ccService; _connectivityService = connectivityService; _connectivityService.MessageReceived += OnMessageReceived; BindingOperations.EnableCollectionSynchronization(Logs, _lock); try { SubnetworkConfig = configReaderService.ReadSubnetworkConfig(); } catch (Exception e) { _logService.LogError("WRONG CONFIG: " + e.Message); } if (SubnetworkConfig.IsDomain) { _connectivityService.ConnectToNCCorDomain("127.0.0.1", SubnetworkConfig.NCCPort, SubnetworkConfig.Name); _connectivityService.StartListening("127.0.0.1", SubnetworkConfig.ServerPort); } else { //_cableCloudConnectionService.StartClient("127.0.0.1", SubnetworkConfig.CableCloudPort, SubnetworkConfig.Name); _connectivityService.ConnectToNCCorDomain("127.0.0.1", SubnetworkConfig.ClientPort, SubnetworkConfig.Name); _connectivityService.StartListening("127.0.0.1", SubnetworkConfig.ServerPort); } Task.Run(async() => { while (true) { await CheckList(); Thread.Sleep(50); } }); }
public LoginService(ISessionManager sessionManager, IUIServices uiServices, IPolicyWrapper <User> policies, IBaseRepository <User> userRepository, IConnectivityService connectivityService) { _sessionManager = sessionManager; _uiServices = uiServices; _policies = policies; _userRepository = userRepository; _connectivityService = connectivityService; _api = RestService.For <ILoginApi>(Constants.DEFAULT_API_ENDPOINT); }
protected async Task <bool> CannotReachHostAsync(IConnectivityService connectivityService) { return(!(await connectivityService.IsRemoteReachableAsync(Todo.Common.Helpers.Preferences.ApiBaseAddress))); }
private TaskHelper() { connectivityService = DependencyService.Get <IConnectivityService>(); loggingService = DependencyService.Get <ILoggingService>(); }
public BaseServiceClient(IConnectivityService connectivityService) { }
//internal static string AccessToken; protected BaseService(ISettings settings) { _settings = settings; //_eventLogger = Mvx.Resolve<IEventLogger>(); _connectivityService = Mvx.Resolve <IConnectivityService>(); }
public CraftyClicksService(IAppSettings settingsService, IConnectivityService connectivityService) : base(connectivityService) { _settingsService = settingsService; }
public FoursquareProvider(IAppSettings settings, ILogger logger, IConnectivityService connectivityService) : base(connectivityService) { _settings = settings; _logger = logger; }
public ProfileViewModel(IDialogService dialogService, INavigationService navigationService, IConnectivityService connectivityService, IPhotoService photoService) { this.dialogService = dialogService; this.navigationService = navigationService; this.connectivityService = connectivityService; this.photoService = photoService; UserPhotos = new ObservableRangeCollection <Photo>(); }
public POIServiceClient(string url, string sessionId, IPackageInfo packageInfo, IConnectivityService connectivityService, ILogger logger) : base(url, sessionId, packageInfo, connectivityService, logger) { }
public CustomNativeMessageHandler(IConnectivityService connectivityService) { _connectivityService = connectivityService; }
public LoginDialogManager(IRegionManager regionManager, IAppSettings appSettings, IUserSession userSession, IMenuRegistry menuRegistry, IBusyService busyService, IUserService userService, IConnectivityService connectivityService) : base(regionManager, appSettings) { _userSession = userSession; _appSettings = appSettings; _menuRegistry = menuRegistry; _busyService = busyService; _userService = userService; _connectivityService = connectivityService; ApplicationCommands.LoginFailed.RegisterCommand(new DelegateCommand <string>(LoginFailed)); ApplicationCommands.LoginSucceeded.RegisterCommand(new DelegateCommand <object>(LoginSucceeded)); ApplicationCommands.UserLoggedOut.RegisterCommand(new DelegateCommand <object>(LogOutUser)); }
public CustomNativeMessageHandler(IConnectivityService connectivityService, bool throwOnCaptiveNetwork, bool customSSLVerification, bool enableRc4Compatibility, NativeCookieHandler cookieHandler = null) : base(throwOnCaptiveNetwork, customSSLVerification, enableRc4Compatibility, cookieHandler) { _connectivityService = connectivityService; }
public TaxonManagementVM( IConnectivityService Connectivity, ITaxonService Taxa, IDiversityServiceClient Service, INotificationService Notification ) { this.Connectivity = Connectivity; this.Service = Service; this.Taxa = Taxa; this.Notification = Notification; _IsOnlineAvailable = this.ObservableToProperty(Connectivity.WifiAvailable(), x => x.IsOnlineAvailable); var localLists = this.FirstActivation() .SelectMany(_ => Taxa.getTaxonSelections() .ToObservable(ThreadPoolScheduler.Instance) .Select(list => new TaxonListVM(list))) .Publish(); LocalLists = localLists .ObserveOnDispatcher() .CreateCollection(); var onlineLists = localLists .IgnoreElements() //only download lists once the local ones are loaded .Concat(Observable.Return(null as TaxonListVM)) .CombineLatest(this.OnActivation(), (_, _2) => _2) .CheckConnectivity(Connectivity, Notification) .SelectMany(_ => { return Service.GetTaxonLists() .DisplayProgress(Notification, DiversityResources.TaxonManagement_State_DownloadingLists) .TakeUntil(this.OnDeactivation()); }) .ObserveOnDispatcher() .SelectMany(lists => lists.Where(list => !LocalLists.Any(loc => loc.Model == list)) // Filter lists already present locally .Select(list => new TaxonListVM(list)) ) .Publish(); PersonalLists = onlineLists.Where(vm => !vm.Model.IsPublicList) .CreateCollection(); PublicLists = onlineLists.Where(vm => vm.Model.IsPublicList) .CreateCollection(); onlineLists.Connect(); localLists.Connect(); Select = new ReactiveCommand<TaxonListVM>(vm => !vm.IsSelected && !vm.IsDownloading); Select.Subscribe(taxonlist => { foreach (var list in LocalLists) { if (list.Model.TaxonomicGroup == taxonlist.Model.TaxonomicGroup) list.Model.IsSelected = false; } Taxa.selectTaxonList(taxonlist.Model); }); Download = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Download .CheckConnectivity(Connectivity, Notification) .Subscribe(taxonlist => { if (Taxa.getTaxonTableFreeCount() > 0) { CurrentPivot = Pivot.Local; taxonlist.IsDownloading = true; makeListLocal(taxonlist); DownloadTaxonList(taxonlist) .DisplayProgress(Notification, DiversityResources.TaxonManagement_State_DownloadingList) .ObserveOnDispatcher() .ShowServiceErrorNotifications(Notification) .Subscribe(_ => { //Download Succeeded taxonlist.IsDownloading = false; if (Select.CanExecute(taxonlist)) Select.Execute(taxonlist); }, _ => //Download Failed { taxonlist.IsDownloading = false; removeLocalList(taxonlist); }, () => { }); } }); Delete = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Delete .Subscribe(taxonlist => { removeLocalList(taxonlist); }); Refresh = new ReactiveCommand<TaxonListVM>(vm => !vm.IsDownloading); Refresh .Subscribe(taxonlist => { if (Delete.CanExecute(taxonlist)) //Deletes synchronously Delete.Execute(taxonlist); if (Download.CanExecute(taxonlist)) Download.Execute(taxonlist); }); //Download all only on Personal pivot var canDownloadAll = this.WhenAny(x => x.CurrentPivot, x => x.GetValue()) .Select(p => p == Pivot.Personal) .CombineLatest(Connectivity.WifiAvailable(), (p, wi) => p && wi); DownloadAll = new ReactiveCommand(canDownloadAll, initialCondition: false); DownloadAll .SelectMany(_ => PersonalLists.ToArray()) .Where(vm => Download.CanExecute(vm)) .Subscribe(Download.Execute); }
public PhotoDetailsViewModel(INavigationService navigationService, IDialogService dialogService, IConnectivityService connectivityService, IPhotoService photoService) { this.navigationService = navigationService; this.dialogService = dialogService; this.connectivityService = connectivityService; this.photoService = photoService; }
public CheckoutViewModel(IConnectivityService connectivityService, INavigationService navigationService, IDialogService dialogService, IOrderDataService orderDataService, IPreferencesService preferencesService) : base(connectivityService, navigationService, dialogService) { _orderDataService = orderDataService; _preferencesService = preferencesService; }
public CmtPaymentClient(string baseUrl, string sessionId, CmtPaymentSettings cmtSettings, IIPAddressManager ipAddressManager, IPackageInfo packageInfo, ILogger logger, IConnectivityService connectivityService) : base(baseUrl, sessionId, packageInfo, connectivityService) { _ipAddressManager = ipAddressManager; _logger = logger; CmtPaymentServiceClient = new CmtPaymentServiceClient(cmtSettings, null, packageInfo, logger, connectivityService); }
private DataClient CreateDataClient(IMapperService mapperService, IConnectivityService connectivityService, ISerializerService serializerService, IHttpService httpService, IAppConfig appConfig) { return new DataClient (mapperService, connectivityService, serializerService, httpService, appConfig); }
public CompanyServiceClient(string url, string sessionId, IPackageInfo packageInfo, ICacheService cacheService, IConnectivityService connectivityService, ILogger logger) : base(url, sessionId, packageInfo, connectivityService, logger) { _cacheService = cacheService; }