Example #1
0
        /// <summary>
        /// Invoked when the application is about to start when it's launched normally by end user.
        /// Override this method to implement state restoration and other application-level initialization.
        /// </summary>
        /// <param name="args"></param>
        protected override async void OnApplicationStarting(LaunchActivatedEventArgs args)
        {
            // By default, RootFrame will automatically instantiate a new Frame object when it's accessed for the first time
            // To specify a custom frame, please override the RootFrame property.

            // Obtains the registered application state service
            IApplicationStateService stateService = this.GetService <IApplicationStateService>();

            // Associate the frame with an ApplicationStateService key
            stateService.RegisterFrame(this.RootFrame, "AppFrame");

            if (args.PreviousExecutionState == ApplicationExecutionState.Terminated)
            {
                // Restore the saved session state only when appropriate
                try
                {
                    await stateService.RestoreAsync();
                }
                catch (ApplicationStateServiceException)
                {
                    //Something went wrong restoring state.
                    //Assume there is no state and continue
                }
            }
        }
        protected PlaylistsPageViewPresenterBase(
            IApplicationResources resources,
            IPlaylistsService playlistsService,
            INavigationService navigationService,
            IPlayQueueService playQueueService,
            ISongsCachingService cachingService,
            IApplicationStateService stateService,
            IRadioStationsService radioStationsService,
            ISettingsService settingsService)
        {
            this.resources            = resources;
            this.playlistsService     = playlistsService;
            this.navigationService    = navigationService;
            this.playQueueService     = playQueueService;
            this.cachingService       = cachingService;
            this.stateService         = stateService;
            this.radioStationsService = radioStationsService;
            this.settingsService      = settingsService;

            Func <bool> canExecute = () => this.BindingModel.SelectedItems.Count > 0 &&
                                     this.BindingModel.SelectedItems.All(x => (x.Playlist.PlaylistType == PlaylistType.UserPlaylist && !((UserPlaylist)x.Playlist).IsShared));

            this.PlayCommand       = new DelegateCommand(this.Play);
            this.QueueCommand      = new DelegateCommand(this.Queue, canExecute);
            this.DownloadCommand   = new DelegateCommand(this.Download, canExecute);
            this.UnPinCommand      = new DelegateCommand(this.UnPin, canExecute);
            this.StartRadioCommand = new DelegateCommand(this.StartRadio, () => this.BindingModel != null && this.BindingModel.SelectedItems.Count == 1);
        }
Example #3
0
        public TerminalViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;

            var canStamp = this.WhenAnyValue(f => f.RfidKey, (string rfidKey) => string.IsNullOrWhiteSpace(rfidKey) == false);
            this.Stamp = UwCoreCommand.Create(canStamp, this.StampImpl)
                .HandleExceptions()
                .ShowLoadingOverlay("Stempeln...");

            this.StampMode = TerminalStampMode.Normal;
            this.WhenAnyValue(f => f.StampMode)
                .Subscribe(stampMode =>
                {
                    if (stampMode == TerminalStampMode.Normal)
                    {
                        //Stop the timer
                        this._resetModeTimer?.Change(TimeSpan.FromMilliseconds(-1), TimeSpan.FromSeconds(10));
                    }
                    else
                    {
                        //Start the timer
                        this._resetModeTimer?.Change(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
                    }
                });

            this._timer = new Timer(this.Tick, null, TimeSpan.Zero, TimeSpan.FromMilliseconds(100));
            this._resetModeTimer = new Timer(this.ResetModeTick, null, TimeSpan.FromMilliseconds(-1), TimeSpan.FromSeconds(10));

            this.DisplayName = "Terminal";
        }
        public AttendingUserDetailsViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, IContactsService contactsService, IDialogService dialogService, IPhoneService phoneService, IEmailService emailService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(contactsService, nameof(contactsService));
            Guard.NotNull(dialogService, nameof(dialogService));
            Guard.NotNull(phoneService, nameof(phoneService));
            Guard.NotNull(emailService, nameof(emailService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;
            this._contactsService = contactsService;
            this._dialogService = dialogService;
            this._phoneService = phoneService;
            this._emailService = emailService;

            this.LoadAttendingUser = UwCoreCommand.Create(this.LoadAttendingUserImpl)
                .HandleExceptions()
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.Employee"));
            this.LoadAttendingUser.ToProperty(this, f => f.AttendingUser, out this._attendingUserHelper);
            
            var canCall = Observable
                .Return(this._phoneService.CanCall)
                .CombineLatest(this.WhenAnyValue(f => f.AttendingUser), (serviceCanCall, user) => 
                    serviceCanCall && string.IsNullOrWhiteSpace(user?.PhoneNumber) == false);
            this.Call = UwCoreCommand.Create(canCall, this.CallImpl)
                .HandleExceptions();

            var canSendMail = this.WhenAnyValue(f => f.AttendingUser, selector: user => string.IsNullOrWhiteSpace(user?.EmailAddress) == false);
            this.SendMail = UwCoreCommand.Create(canSendMail, this.SendMailImpl)
                .HandleExceptions();

            this.AddAsContact = UwCoreCommand.Create(this.AddAsContactImpl)
                .HandleExceptions();
        }
Example #5
0
 public SetSelectedRowsCommandHandler(
     IApplicationStateService stateService,
     IEventBus eventBus)
 {
     _stateService = stateService;
     _eventBus     = eventBus;
 }
Example #6
0
        protected override void SaveState(IApplicationStateService applicationStateService)
        {
            base.SaveState(applicationStateService);

            applicationStateService.Set(nameof(this.StartDate), this.StartDate, ApplicationState.Temp);
            applicationStateService.Set(nameof(this.EndDate), this.EndDate, ApplicationState.Temp);
        }
Example #7
0
        public LoginViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, IShell shell, IDialogService dialogService, IBiometricsService biometricsService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(shell, nameof(shell));
            Guard.NotNull(dialogService, nameof(dialogService));
            Guard.NotNull(biometricsService, nameof(biometricsService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;
            this._shell = shell;
            this._dialogService = dialogService;
            this._biometricsService = biometricsService;
            
            var canLogin = this.WhenAnyValue(f => f.EmailAddress, f => f.Password, (email, password) =>
                string.IsNullOrWhiteSpace(email) == false && string.IsNullOrWhiteSpace(password) == false);
            this.Login = UwCoreCommand.Create(canLogin, this.LoginImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.LoggingIn"))
                .HandleExceptions()
                .TrackEvent("Login");
            
            var deviceAvailable = this._biometricsService.BiometricAuthDeviceIsAvailableAsync().ToObservable();
            var userAvailable = this._biometricsService.HasUserForBiometricAuthAsync().ToObservable();
            var canRememberedLogin = deviceAvailable
                .CombineLatest(userAvailable, (deviceAvail, userAvail) => deviceAvail && userAvail)
                .ObserveOnDispatcher();
            this.RememberedLogin = UwCoreCommand.Create(canRememberedLogin, this.RememberedLoginImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.LoggingIn"))
                .HandleExceptions()
                .TrackEvent("LoginRemembered");

            this.DisplayName = CTime2Resources.Get("Navigation.Login");
        }
Example #8
0
        public PlayerMorePopupViewBindingModel(
            IMediaElementContainer mediaElementContainer,
            IPlayQueueService playQueueService,
            IEventAggregator eventAggregator,
            IApplicationStateService stateService,
            IApplicationResources applicationResources,
            IDispatcher dispatcher)
        {
            this.mediaElementContainer = mediaElementContainer;
            this.playQueueService      = playQueueService;
            this.eventAggregator       = eventAggregator;
            this.stateService          = stateService;
            this.applicationResources  = applicationResources;
            this.dispatcher            = dispatcher;

            this.RegisterForDispose(this.eventAggregator.GetEvent <QueueChangeEvent>().Subscribe(
                                        async(e) => await this.dispatcher.RunAsync(() =>
            {
                this.RaisePropertyChanged(() => this.IsShuffleEnabled);
                this.RaisePropertyChanged(() => this.IsRepeatAllEnabled);
            })));

            this.RegisterForDispose(this.eventAggregator.GetEvent <ApplicationStateChangeEvent>().Subscribe(
                                        async(e) => await this.dispatcher.RunAsync(() => this.RaisePropertyChanged(() => this.IsOnlineMode))));
        }
Example #9
0
        public YourTimesViewModel(IApplicationStateService applicationStateService, ICTimeService cTimeService, ISharingService sharingService)
        {
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(sharingService, nameof(sharingService));

            this._applicationStateService = applicationStateService;
            this._cTimeService = cTimeService;
            this._sharingService = sharingService;

            this.WhenAnyValue(f => f.StartDate, f => f.EndDate)
                .Select(f => CTime2Resources.GetFormatted("MyTimes.TitleFormat", this.StartDate, this.EndDate))
                .Subscribe(name => this.DisplayName = name);

            this.LoadTimes = UwCoreCommand.Create(this.LoadTimesImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.Times"))
                .HandleExceptions()
                .TrackEvent("LoadTimes");
            this.LoadTimes.ToProperty(this, f => f.Times, out this._timesHelper);

            this.Share = UwCoreCommand.Create(this.ShareImpl)
                .HandleExceptions()
                .TrackEvent("ShareMyTimes");

            this.StartDate = DateTimeOffset.Now.StartOfMonth();
            this.EndDate = DateTimeOffset.Now.WithoutTime();
        }
 public LastFmCurrentSongPublisher(
     IApplicationStateService stateService,
     ILastfmWebService webService)
 {
     this.stateService = stateService;
     this.webService   = webService;
 }
Example #11
0
 /// <summary>
 /// <see cref="WebApiServiceBase"/> クラスの新しいインスタンスを作成します。
 /// </summary>
 /// <param name="http">シングルトン <see cref="HttpClient"/>。</param>
 /// <param name="applicationState">シングルトン <see cref="ApplicationStateService"/>。</param>
 public WebApiServiceBase(
     HttpClient http,
     IApplicationStateService applicationState
     )
 {
     this._http             = http;
     this._applicationState = applicationState;
 }
Example #12
0
        public EmployeeGroupService(IEventAggregator eventAggregator, IApplicationStateService applicationStateService)
        {
            Guard.NotNull(eventAggregator, nameof(eventAggregator));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));

            this._eventAggregator = eventAggregator;
            this._applicationStateService = applicationStateService;
        }
 public AlbumArtCacheService(
     ILogManager logManager,
     IApplicationStateService stateService,
     ICachedAlbumArtsRepository cachedAlbumArtsRepository)
 {
     this.logger       = logManager.CreateLogger("AlbumArtCacheService");
     this.stateService = stateService;
     this.cachedAlbumArtsRepository = cachedAlbumArtsRepository;
 }
Example #14
0
 /// <summary>
 /// <see cref="CustomerMaintenanceSettingApiService"/> クラスの新しいインスタンスを作成します。
 /// </summary>
 /// <param name="http">シングルトン <see cref="HttpClient"/>。</param>
 /// <param name="applicationState">シングルトン <see cref="ApplicationStateService"/>。</param>
 public CustomerMaintenanceSettingApiService(
     HttpClient http,
     IApplicationStateService applicationState
     ) : base(
         http: http,
         applicationState: applicationState
         )
 {
 }
Example #15
0
 public RemoveFilterCommandHandler(
     IApplicationStateService stateService,
     IFilterRepository repository,
     IEventBus eventBus)
 {
     _stateService = stateService;
     _repository   = repository;
     _eventBus     = eventBus;
 }
 public SelectFilterTreeNodeCommandHandler(
     IFilterRepository repository,
     IApplicationStateService service,
     IEventBus eventBus)
 {
     _repository = repository;
     _service    = service;
     _eventBus   = eventBus;
 }
Example #17
0
        public BandService(IApplicationStateService applicationStateService, ICTimeService cTimeService)
        {
            this._applicationStateService = applicationStateService;
            this._cTimeService = cTimeService;

            BackgroundTileEventHandler.Instance.TileOpened += this.OnTileOpened;
            BackgroundTileEventHandler.Instance.TileButtonPressed += this.OnTileButtonPressed;
            BackgroundTileEventHandler.Instance.TileClosed += this.OnTileClosed;
        }
Example #18
0
 public UploadImagePageViewModel(IApplicationStateService applicationStateService)
 {
     ApplicationStateService = applicationStateService;
     UploadMediaCommand      = new DelegateCommand(UploadMedia, CanUploadMedia);
     ApplicationStateService.PropertyChanged += (s, e) => UploadMediaCommand.RaiseCanExecuteChanged();
     PostCommand = new DelegateCommand(PostPicture, CanPostPicture);
     ApplicationStateService.PropertyChanged += (s, e) => PostCommand.RaiseCanExecuteChanged();
     MapViewChangedCommand = new DelegateCommand <LocationRect>(ChangeLocation);
 }
        public static bool IsOnline(this IApplicationStateService @this)
        {
            if (@this == null)
            {
                throw new ArgumentNullException("this");
            }

            return(@this.CurrentState == ApplicationState.Online);
        }
Example #20
0
 public NavigationPaneViewModel(
     IStartMenuViewModel startMenuViewModel,
     INavigationTreeViewModel navigationTreeViewModel,
     IApplicationStateService stateService)
 {
     _startMenuViewModel      = startMenuViewModel;
     _navigationTreeViewModel = navigationTreeViewModel;
     _stateService            = stateService;
 }
 public CloseProjectCommandHandler(
     IEventBus eventBus,
     IApplicationStateService stateService,
     IDataContext dataContext)
 {
     _dataContext  = dataContext;
     _eventBus     = eventBus;
     _stateService = stateService;
 }
Example #22
0
            public ForTypeApplicationStateService(IApplicationStateService parent, Type forType, string additionalPrefix = null)
            {
                Guard.NotNull(parent, nameof(parent));
                Guard.NotNull(forType, nameof(forType));

                this._parent           = parent;
                this._forType          = forType;
                this._additionalPrefix = additionalPrefix;
            }
Example #23
0
 /// <summary>
 /// <see cref="ProductCategoriesApiService"/> クラスの新しいインスタンスを作成します。
 /// </summary>
 /// <param name="http">シングルトン <see cref="HttpClient"/>。</param>
 /// <param name="applicationState">シングルトン <see cref="ApplicationStateService"/>。</param>
 public ProductCategoriesApiService(
     HttpClient http,
     IApplicationStateService applicationState
     ) : base(
         http: http,
         applicationState: applicationState
         )
 {
 }
Example #24
0
 /// <summary>
 /// <see cref="JWTApiService"/> クラスの新しいインスタンスを作成します。
 /// </summary>
 /// <param name="http">シングルトン <see cref="HttpClient"/>。</param>
 /// <param name="applicationState">シングルトン <see cref="ApplicationStateService"/>。</param>
 public JWTApiService(
     HttpClient http,
     IApplicationStateService applicationState
     ) : base(
         http: http,
         applicationState: applicationState
         )
 {
 }
Example #25
0
        protected override void RestoreState(IApplicationStateService applicationStateService)
        {
            base.RestoreState(applicationStateService);

            if (applicationStateService.HasValueFor(nameof(this.StartDate), ApplicationState.Temp))
                this.StartDate = applicationStateService.Get<DateTimeOffset>(nameof(this.StartDate), ApplicationState.Temp);

            if (applicationStateService.HasValueFor(nameof(this.EndDate), ApplicationState.Temp))
                this.EndDate = applicationStateService.Get<DateTimeOffset>(nameof(this.EndDate), ApplicationState.Temp);
        }
 public PlaylistsPageViewPresenter(
     IApplicationResources resources,
     IPlaylistsService playlistsService,
     INavigationService navigationService,
     IPlayQueueService playQueueService,
     ISongsCachingService cachingService,
     IApplicationStateService stateService)
     : base(resources, playlistsService, navigationService, playQueueService, cachingService, stateService)
 {
 }
Example #27
0
        public CTimeService(IEventAggregator eventAggregator, IApplicationStateService applicationStateService, IGeoLocationService geoLocationService)
        {
            Guard.NotNull(eventAggregator, nameof(eventAggregator));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(geoLocationService, nameof(geoLocationService));

            this._eventAggregator = eventAggregator;
            this._applicationStateService = applicationStateService;
            this._geoLocationService = geoLocationService;
        }
Example #28
0
        /// <summary>
        /// Invoked when application execution is being suspended.  Application state is saved
        /// without knowing whether the application will be terminated or resumed with the contents
        /// of memory still intact.
        /// </summary>
        /// <param name="sender">The source of the suspend request.</param>
        /// <param name="e">Details about the suspend request.</param>
        protected override async void OnSuspending(SuspendingEventArgs args)
        {
            // Obtains the registered application state service
            IApplicationStateService stateService = this.GetService <IApplicationStateService>();

            var deferral = args.SuspendingOperation.GetDeferral();
            await stateService.SaveAsync();

            deferral.Complete();
        }
Example #29
0
        public static void Initialize(
            IMainFrame applicationToolbar,
            IApplicationResources resources,
            IApplicationStateService stateService,
            IEventAggregator eventAggregator)
        {
            eventAggregator.GetEvent <ApplicationStateChangeEvent>().Subscribe(
                (e) => applicationToolbar.SetMenuItems(GetItems(resources, stateService)));

            applicationToolbar.SetMenuItems(GetItems(resources, stateService));
        }
 public CopyDataToClipboardCommandHandler(
     IColumnRepository columnRepository,
     IApplicationStateService stateService,
     ITabExporter exporter,
     IClipboard clipboard)
 {
     _columnRepository = columnRepository;
     _stateService     = stateService;
     _exporter         = exporter;
     _clipboard        = clipboard;
 }
Example #31
0
        public AttendanceListViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, INavigationService navigationService, IEmployeeGroupService employeeGroupService, IDialogService dialogService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(navigationService, nameof(navigationService));
            Guard.NotNull(employeeGroupService, nameof(employeeGroupService));
            Guard.NotNull(dialogService, nameof(dialogService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;
            this._navigationService = navigationService;
            this._employeeGroupService = employeeGroupService;
            this._dialogService = dialogService;

            this.DisplayName = CTime2Resources.Get("Navigation.AttendanceList");
            this.SelectedUsers = new ReactiveList<AttendingUser>();
            this.State = AttendanceListState.Loading;

            this.LoadUsers = UwCoreCommand.Create(this.LoadUsersImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.AttendanceList"))
                .HandleExceptions()
                .TrackEvent("LoadAttendanceList");
            this.LoadUsers.ToProperty(this, f => f.Users, out this._usersHelper);

            var canShowDetails = this.WhenAnyValue(f => f.SelectedUsers).Select(f => f.Any());
            this.ShowDetails = UwCoreCommand.Create(canShowDetails, this.ShowDetailsImpl)
                .HandleExceptions()
                .TrackEvent("ShowAttendingUserDetails");

            var canCreateGroup = this.WhenAnyValue(f => f.State, mode => mode == AttendanceListState.View);
            this.CreateGroup = UwCoreCommand.Create(canCreateGroup, this.CreateGroupImpl)
                .HandleExceptions()
                .TrackEvent("CreateNewEmployeeGroup");

            var canSaveGroup = this
                .WhenAnyValue(f => f.State, f => f.GroupName,  (mode, groupName) => mode == AttendanceListState.CreateGroup && string.IsNullOrWhiteSpace(groupName) == false)
                .CombineLatest(this.SelectedUsers.Changed, (stateAndName, selectedUsers) => stateAndName && this.SelectedUsers.Any());
            this.SaveGroup = UwCoreCommand.Create(canSaveGroup, this.SaveGroupImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.SaveEmployeeGroup"))
                .HandleExceptions()
                .TrackEvent("SaveNewEmployeeGroup");

            var canCancelCreateGroup = this.WhenAnyValue(f => f.State, mode => mode == AttendanceListState.CreateGroup);
            this.CancelCreateGroup = UwCoreCommand.Create(canCancelCreateGroup, this.CancelCreateGroupImpl)
                .HandleExceptions()
                .TrackEvent("CancelCreateNewEmployeeGroup");

            var canDeleteGroup = this.WhenAnyValue(f => f.State, mode => mode == AttendanceListState.ViewGroup);
            this.DeleteGroup = UwCoreCommand.Create(canDeleteGroup, this.DeleteGroupImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.DeleteEmployeeGroup"))
                .HandleExceptions()
                .TrackEvent("DeleteEmployeeGroup");
        }
Example #32
0
 public MainWindow(
     Func <string, Task <Timetable> > loadTimetableFunc,
     Func <TrainNumber> windowFactory,
     EntriesCollection entries,
     IApplicationStateService appStateService)
 {
     Entries = entries;
     InitializeComponent();
     _loadTimetable   = loadTimetableFunc;
     _windowFactory   = windowFactory;
     _appStateService = appStateService;
 }
        public LinksRegionViewPresenter(
            IApplicationStateService stateService,
            IApplicationResources resources,
            ISearchService searchService,
            IDispatcher dispatcher,
            IGoogleMusicSynchronizationService googleMusicSynchronizationService,
            IApplicationSettingViewsService applicationSettingViewsService,
            IGoogleMusicSessionService sessionService,
            INavigationService navigationService)
        {
            this.stateService = stateService;
            this.resources    = resources;
            this.dispatcher   = dispatcher;
            this.googleMusicSynchronizationService = googleMusicSynchronizationService;
            this.sessionService          = sessionService;
            this.navigationService       = navigationService;
            this.ShowSearchCommand       = new DelegateCommand(searchService.Activate);
            this.NavigateToDownloadQueue = new DelegateCommand(async() =>
            {
                if (!this.disableClickToCache)
                {
                    await this.dispatcher.RunAsync(() => applicationSettingViewsService.Show("offlinecache"));
                }
            });

            this.UpdateLibraryCommand = new DelegateCommand(
                async() =>
            {
                if (this.UpdateLibraryCommand.CanExecute())
                {
                    this.synchronizationTimer.Stop();
                    await this.Synchronize(forceToDownloadPlaylists: true);
                }
            },
                () => !this.BindingModel.ShowProgressRing);

            this.BindingModel = new LinksRegionBindingModel();

            this.synchronizationTimer = new DispatcherTimer {
                Interval = TimeSpan.FromMinutes(5)
            };
            this.synchronizationTimer.Stop();
            this.synchronizationTime = 0;

            this.synchronizationTimer.Tick += this.SynchronizationTimerOnTick;

            this.Logger.LogTask(this.Synchronize());

            this.SetOfflineMessageIfRequired();

            this.sessionService.SessionCleared += this.SessionServiceOnSessionCleared;
        }
 public GoogleMusicCurrentSongPublisher(
     ILogManager logManager,
     IApplicationStateService stateService,
     ISongsWebService songsWebService,
     ISongsRepository songsRepository,
     IEventAggregator eventAggregator)
 {
     this.logger          = logManager.CreateLogger("GoogleMusicCurrentSongPublisher");
     this.stateService    = stateService;
     this.songsWebService = songsWebService;
     this.songsRepository = songsRepository;
     this.eventAggregator = eventAggregator;
 }
Example #35
0
        public CheckedInViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService)
            : base(cTimeService, applicationStateService)
        {
            this.CheckOut = UwCoreCommand.Create(this.CheckOutImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.CheckedOut"))
                .HandleExceptions()
                .TrackEvent("CheckOut");

            this.Pause = UwCoreCommand.Create(this.PauseImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.Pause"))
                .HandleExceptions()
                .TrackEvent("Pause");
        }
Example #36
0
        public LoggedInApplicationMode(IApplicationStateService applicationStateService, ICentronService centronService, ILoadingService loadingService, IHelpdeskGroupsService helpdeskGroupsService, IEventAggregator eventAggregator)
        {
            this._applicationStateService = applicationStateService;
            this._centronService          = centronService;
            this._loadingService          = loadingService;
            this._helpdeskGroupsService   = helpdeskGroupsService;
            this._eventAggregator         = eventAggregator;

            this._dashboardItem        = new NavigatingHamburgerItem(SBoardResources.Get("Navigation.Dashboard"), Symbol.Home, typeof(DashboardViewModel));
            this._logoutItem           = new ClickableHamburgerItem(SBoardResources.Get("Navigation.Logout"), SymbolEx.Logout, this.Logout);
            this._newHelpdeskGroupItem = new NavigatingHamburgerItem(SBoardResources.Get("Navigation.NewHelpdeskGroup"), Symbol.Add, typeof(NewHelpdeskGroupViewModel));
            this._helpdeskGroupItems   = new List <NavigatingHamburgerItem>();
        }
Example #37
0
 public OpenProjectCommandHandler(
     IDialogService dialogService,
     IEventBus eventBus,
     IApplicationStateService stateService,
     IDataContext dataContext,
     IXmlFileService xmlFileService,
     IProjectSerializer projectSerializer)
 {
     _dialogService     = dialogService;
     _xmlFileService    = xmlFileService;
     _projectSerializer = projectSerializer;
     _dataContext       = dataContext;
     _eventBus          = eventBus;
     _stateService      = stateService;
 }
Example #38
0
        public static void Initialize(
            IMainFrame applicationToolbar,
            IApplicationResources resources,
            IApplicationStateService stateService,
            ISettingsService settingsService,
            IEventAggregator eventAggregator)
        {
            eventAggregator.GetEvent <ApplicationStateChangeEvent>().Subscribe(
                (e) => applicationToolbar.SetMenuItems(GetItems(resources, stateService, settingsService)));

            eventAggregator.GetEvent <SettingsChangeEvent>()
            .Where(x => string.Equals(x.Key, GoogleMusicCoreSettingsServiceExtensions.IsAllAccessAvailableKey, StringComparison.OrdinalIgnoreCase))
            .Subscribe(
                (e) => applicationToolbar.SetMenuItems(GetItems(resources, stateService, settingsService)));

            applicationToolbar.SetMenuItems(GetItems(resources, stateService, settingsService));
        }
        internal CurrentPlaylistPageViewPresenter(
            IApplicationResources resources,
            IPlayQueueService playQueueService,
            ISongsService metadataEditService,
            ISongsCachingService cachingService,
            IApplicationStateService stateService,
            INavigationService navigationService,
            IRadioStationsService radioStationsService,
            ISettingsService settingsService,
            SongsBindingModel songsBindingModel)
        {
            this.resources            = resources;
            this.playQueueService     = playQueueService;
            this.metadataEditService  = metadataEditService;
            this.cachingService       = cachingService;
            this.stateService         = stateService;
            this.navigationService    = navigationService;
            this.radioStationsService = radioStationsService;
            this.settingsService      = settingsService;
            this.BindingModel         = songsBindingModel;

            this.playQueueService.QueueChanged += async(sender, args) => await this.Dispatcher.RunAsync(this.UpdateSongs);

            //this.SaveAsPlaylistCommand = new DelegateCommand(this.SaveAsPlaylist, () => this.BindingModel.Songs.Count > 0);
            this.RemoveSelectedSongCommand = new DelegateCommand(this.RemoveSelectedSong, () => this.BindingModel.SelectedItems.Count > 0);
            this.AddToPlaylistCommand      = new DelegateCommand(this.AddToPlaylist, () => this.BindingModel.SelectedItems.Count > 0);
            this.RateSongCommand           = new DelegateCommand(this.RateSong);
            this.DownloadCommand           = new DelegateCommand(this.Download, () => this.BindingModel.SelectedItems.Count(x => !x.Metadata.UnknownSong) > 0);
            this.UnPinCommand      = new DelegateCommand(this.UnPin, () => this.BindingModel.SelectedItems.Count(x => !x.Metadata.UnknownSong) > 0);
            this.StartRadioCommand = new DelegateCommand(this.StartRadio, () => this.BindingModel != null && this.BindingModel.SelectedItems.Count == 1);

            this.playQueueService.StateChanged += async(sender, args) => await this.Dispatcher.RunAsync(async() =>
            {
                if (this.BindingModel.SelectedItems.Count == 0)
                {
                    if (this.BindingModel.Songs != null && args.CurrentSong != null)
                    {
                        var currentSong = this.BindingModel.Songs.FirstOrDefault(x => string.Equals(x.Metadata.SongId, args.CurrentSong.SongId, StringComparison.Ordinal));
                        if (currentSong != null)
                        {
                            await this.View.ScrollIntoCurrentSongAsync(currentSong);
                        }
                    }
                }
            });
        }
Example #40
0
 public RadioPageViewPresenter(
     IApplicationResources resources,
     IPlaylistsService playlistsService,
     INavigationService navigationService,
     IPlayQueueService playQueueService,
     ISongsCachingService cachingService,
     IApplicationStateService stateService,
     IRadioWebService radioWebService)
     : base(resources, playlistsService, navigationService, playQueueService, cachingService, stateService)
 {
     this.resources            = resources;
     this.navigationService    = navigationService;
     this.playQueueService     = playQueueService;
     this.radioWebService      = radioWebService;
     this.EditRadioNameCommand = new DelegateCommand(this.EditRadioName, () => this.BindingModel.SelectedItems.Count == 1);
     this.DeleteRadioCommand   = new DelegateCommand(this.DeleteRadio, () => this.BindingModel.SelectedItems.Count > 0);
 }
 public UserPlaylistsPageViewPresenter(
     IApplicationResources resources,
     INavigationService navigationService,
     IPlayQueueService playQueueService,
     IPlaylistsService playlistsService,
     IUserPlaylistsService userPlaylistsService,
     ISongsCachingService cachingService,
     IApplicationStateService stateService)
     : base(resources, playlistsService, navigationService, playQueueService, cachingService, stateService)
 {
     this.resources              = resources;
     this.userPlaylistsService   = userPlaylistsService;
     this.stateService           = stateService;
     this.AddPlaylistCommand     = new DelegateCommand(this.AddPlaylist);
     this.EditPlaylistCommand    = new DelegateCommand(this.EditPlaylist, () => this.BindingModel.SelectedItems.Count == 1);
     this.DeletePlaylistsCommand = new DelegateCommand(this.DeletePlaylists, () => this.BindingModel.SelectedItems.Count > 0);
 }
Example #42
0
        public CheckedOutViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService)
            : base(cTimeService, applicationStateService)
        {
            this.CheckIn = UwCoreCommand.Create(this.CheckInImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.CheckIn"))
                .HandleExceptions()
                .TrackEvent("CheckIn");

            this.CheckInHomeOffice = UwCoreCommand.Create(this.CheckInHomeOfficeImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.CheckIn"))
                .HandleExceptions()
                .TrackEvent("CheckInHomeOffice");

            this.CheckInTrip = UwCoreCommand.Create(this.CheckInTripImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.CheckIn"))
                .HandleExceptions()
                .TrackEvent("CheckInTrip");
        }
        public DetailedStatisticViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, INavigationService navigationService, ISharingService sharingService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(navigationService, nameof(navigationService));
            Guard.NotNull(sharingService, nameof(sharingService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;
            this._navigationService = navigationService;
            this._sharingService = sharingService;

            this.LoadChart = UwCoreCommand.Create(this.LoadChartImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.LoadCharts"))
                .HandleExceptions();
            this.LoadChart.ToProperty(this, f => f.ChartItems, out this._chartItemsHelper);

            this.GoToMyTimesCommand = UwCoreCommand.Create(this.GoToMyTimes)
                .HandleExceptions();

            this.Share = UwCoreCommand.Create(this.ShareImpl)
                .HandleExceptions()
                .TrackEvent("ShareDetailedStatistic");
        }
Example #44
0
        public BiometricsService(IApplicationStateService applicationStateService)
        {
            Guard.NotNull(applicationStateService, nameof(applicationStateService));

            this._applicationStateService = applicationStateService;
        }
Example #45
0
        protected override void RestoreState(IApplicationStateService applicationStateService)
        {
            base.RestoreState(applicationStateService);

            var startDate = applicationStateService.Get<DateTimeOffset?>(nameof(this.StartDate), ApplicationState.Temp);
            if (startDate != null)
                this.StartDate = startDate.Value;

            var endDate = applicationStateService.Get<DateTimeOffset?>(nameof(this.EndDate), ApplicationState.Temp);
            if (endDate != null)
            {
                this.EndDate = endDate.Value;
            }
        }
Example #46
0
        public SettingsViewModel(IBiometricsService biometricsService, IApplicationStateService applicationStateService, IBandService bandService, IShell shell)
        {
            Guard.NotNull(biometricsService, nameof(biometricsService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(bandService, nameof(bandService));

            this._biometricsService = biometricsService;
            this._applicationStateService = applicationStateService;
            this._bandService = bandService;
            this._shell = shell;

            var hasUser = new ReplaySubject<bool>(1);
            hasUser.OnNext(this._applicationStateService.GetCurrentUser() != null);
            var deviceAvailable = this._biometricsService.BiometricAuthDeviceIsAvailableAsync().ToObservable();
            var canRememberLogin = hasUser.CombineLatest(deviceAvailable, (hasUsr, deviceAvail) => hasUsr && deviceAvail);
            this.RememberLogin = UwCoreCommand.Create(canRememberLogin, this.RememberLoginImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.RememberedLogin"))
                .HandleExceptions()
                .TrackEvent("SetupRememberLogin");

            var canToggleTile = this.WhenAnyValue(f => f.State, state => state != BandState.NotConnected);
            this.ToggleBandTile = UwCoreCommand.Create(canToggleTile, this.ToggleTileImpl)
                .ShowLoadingOverlay(() => this.State == BandState.Installed
                    ? CTime2Resources.Get("Loading.RemoveTileFromBand")
                    : CTime2Resources.Get("Loading.AddTileToBand"))
                .HandleExceptions()
                .TrackEvent("ToggleBandTile");

            this.Reload = UwCoreCommand.Create(this.ReloadImpl)
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.Settings"))
                .HandleExceptions()
                .TrackEvent("ReloadSettings");

            this.Theme = this._applicationStateService.GetApplicationTheme();
            this.SelectedWorkTime = this._applicationStateService.GetWorkDayHours();
            this.SelectedBreakTime = this._applicationStateService.GetWorkDayBreak();
            this.CompanyId = this._applicationStateService.GetCompanyId();

            this.WhenAnyValue(f => f.Theme)
                .Subscribe(theme =>
                {
                    this._shell.Theme = theme;
                    this._applicationStateService.SetApplicationTheme(theme);
                });

            this.WhenAnyValue(f => f.SelectedWorkTime)
                .Subscribe(workTime =>
                {
                    this._applicationStateService.SetWorkDayHours(workTime);
                });

            this.WhenAnyValue(f => f.SelectedBreakTime)
                .Subscribe(breakTime =>
                {
                    this._applicationStateService.SetWorkDayBreak(breakTime);
                });

            this.WhenAnyValue(f => f.CompanyId)
                .Subscribe(companyId =>
                {
                    this._applicationStateService.SetCompanyId(companyId);
                });

            this.DisplayName = CTime2Resources.Get("Navigation.Settings");

            this.WorkTimes = new ReactiveList<TimeSpan>(Enumerable
                .Repeat((object)null, 4 * 24)
                .Select((_, i) => TimeSpan.FromHours(0.25 * i)));

            this.BreakTimes = new ReactiveList<TimeSpan>(Enumerable
                .Repeat((object)null, 4 * 24)
                .Select((_, i) => TimeSpan.FromHours(0.25 * i)));
        }
Example #47
0
 public CTimeStampHelper(IApplicationStateService applicationStateService, ICTimeService cTimeService)
 {
     this._applicationStateService = applicationStateService;
     this._cTimeService = cTimeService;
 }