コード例 #1
0
        public ReportScreenMasterViewModel(ITimeEntryService timeEntryService, IBusyService busyService, IConnectivityService connectivityService,
                                           ITimeEntryTypeRepository timeEntryTypeRepository, ITimeEntryRepository timeEntryRepository, IAppSettings appSettings)
        {
            _timeEntryService        = timeEntryService;
            _busyService             = busyService;
            _connectivityService     = connectivityService;
            _timeEntryTypeRepository = timeEntryTypeRepository;
            _timeEntryRepository     = timeEntryRepository;
            _appSettings             = appSettings;
            Search = new DelegateCommand <object>(ExecuteSearch);
            _busyService.ShowBusy(_reportscreenKey);
            LoadPredefinedSearchItems();
            SelectedPredefinedSearch = PredefinedSearchItems[1];
            EditTimeEntryCommand     = new DelegateCommand <object>(EditTimeEntry);
            SaveCommand = new DelegateCommand <object>(SaveCommandExecute);

            try
            {
                TimeEntryTypes = _timeEntryTypeRepository.GetGlobal();
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            TaskCommands.SaveTaskCompleted.RegisterCommand(new DelegateCommand(Reload));
            TaskCommands.SaveTaskCancelled.RegisterCommand(new DelegateCommand(Reload));

            ApplicationCommands.ConnectivityChanged.RegisterCommand(new DelegateCommand <object>(ConnectivityChangedExecute));
        }
コード例 #2
0
        private void SaveCommandExecute(object item)
        {
            _busyService.ShowBusy(_reportscreenKey);

            var list = new List <TimeEntry>();

            foreach (var gridRowItemViewModel in GridRows.Where(x => x.HasChanges))
            {
                var timeEntry = gridRowItemViewModel.TimeEntry;

                timeEntry.IsSynced = false;

                timeEntry.Billable      = gridRowItemViewModel.EditableBillable;
                timeEntry.TimeEntryType = gridRowItemViewModel.EditableType;

                list.Add(timeEntry);
                TaskCommands.SaveTaskCompleted.Execute(timeEntry);
            }

            _timeEntryRepository.AddOrUpdateRange(list);
            ApplicationCommands.StartSync.Execute(null);

            _busyService.HideBusy(_reportscreenKey);
        }
コード例 #3
0
        public DayOverviewViewModel(ITimeEntryService timeEntryService, IBusyService busyService)
        {
            _timeEntryService = timeEntryService;
            _busyService      = busyService;
            _busyService.ShowBusy(_dayoverviewKey);
            TimeEntries = new List <DataOverviewItemViewModel>();

            PreviousDateCommand          = new DelegateCommand <object>(a => StartDate = StartDate.AddDays(-1));
            NextDayCommand               = new DelegateCommand <object>(a => StartDate = StartDate.AddDays(1));
            TodayCommand                 = new DelegateCommand <object>(a => StartDate = GetNuetralKindDateTimeToday());
            EditTaskCommand              = new DelegateCommand <object>(EditTaskExecute);
            _saveCommandCompletedCommand = new DelegateCommand <object>(SaveTaskCompleted);
            TaskCommands.SaveTaskCompleted.RegisterCommand(_saveCommandCompletedCommand);
            OverviewCommands.GoToDaySubMenu.RegisterCommand(new DelegateCommand <object>(ChangeDate));

            VisiblePeriodStart = StartDate.AddHours(6);
            VisiblePeriodEnd   = EndDate.AddHours(-6);
            StartDate          = GetNuetralKindDateTimeToday();
        }
コード例 #4
0
        private async void LoadTimeEntries()
        {
            // Is being invoked twice when date is selected in bound datepicker
            if (IsBusy)
            {
                return;
            }

            IsBusy = true;
            _busyService.ShowBusy(_dayoverviewKey);

            IEnumerable <DataOverviewItemViewModel> timeEntries = new List <DataOverviewItemViewModel>();

            try
            {
                //enddate tasks are also included
                var timeEntriesDtos = await _timeEntryService.GetTimeEntriesByDateIgnoreEmptyTimeEntries(StartDate, StartDate);

                timeEntries = timeEntriesDtos.Select(timeEntry => new DataOverviewItemViewModel(timeEntry));
            }
            catch (Exception ex)
            {
                if (!_isShowingTextbox)
                {
                    _isShowingTextbox = true;
                    var result = MessageBox.Show("Error loading timeentries", "Error", MessageBoxButton.OK);
                    _isShowingTextbox = result == MessageBoxResult.None;
                }
                Logger.Error(ex);
            }
            TimeEntries = timeEntries.OrderBy(x => x.TimeEntry.Guid).ToList();
            await Task.Run(() => ThreadUtils.WaitForUIRendering());

            IsBusy = false;
            _busyService.HideBusy(_dayoverviewKey);
        }
コード例 #5
0
ファイル: SyncService.cs プロジェクト: StefanAniff/hb.trex
        private async void DoSync()
        {
            if (!_connectivityService.IsOnline)
            {
                ApplicationCommands.SyncCompleted.Execute(null);
                return;
            }

            if (SyncInProgress || !_connectivityService.IsOnline)
            {
                return;
            }

            SyncInProgress = true;

            ApplicationCommands.SyncStarted.Execute(ShouldDisplayProgress);

            try
            {
                if (ForceResync)
                {
                    _busyService.ShowBusy(_syncKey);

                    await Task.Run(() =>
                    {
                        SyncProgressChanged(20, "Synchronizing companies");
                        SynchronizeCompanies().Wait();
                        SyncProgressChanged(30, "Synchronizing projects");
                        SynchronizeProjects().Wait();
                        SyncProgressChanged(20, "Synchronizing tasks");
                        SynchronizeTasks().Wait();
                        SyncProgressChanged(5, "Synchronizing time entry types");
                        SynchronizeTimeEntryTypes().Wait();
                        SyncProgressChanged(10, "Synchronizing local time entries");
                        SynchronizeTimeEntries().Wait();
                        SyncProgressChanged(20, "Synchronizing user statistics");
                        UserSession.UserStatistics   = UserService.GetPerformanceInfo(UserSession);
                        AppSettings.MinTimeEntryDate = UserService.GetTimeEntryMinStartDate(UserSession);
                    });
                }
                else
                {
                    SyncProgressChanged(20, "Synchronizing companies");
                    await SynchronizeCompanies();

                    SyncProgressChanged(30, "Synchronizing projects");
                    await SynchronizeProjects();

                    SyncProgressChanged(20, "Synchronizing tasks");
                    await SynchronizeTasks();

                    SyncProgressChanged(5, "Synchronizing time entry types");
                    await SynchronizeTimeEntryTypes();

                    SyncProgressChanged(10, "Synchronizing local time entries");
                    await SynchronizeTimeEntries();

                    SyncProgressChanged(20, "Synchronizing user statistics");
                    UserSession.UserStatistics   = UserService.GetPerformanceInfo(UserSession);
                    AppSettings.MinTimeEntryDate = UserService.GetTimeEntryMinStartDate(UserSession);
                }


                SyncProgressChanged(10, "Synchronizing history list");
                var numOfDaysBack        = UserSession.UserPreferences.StatisticsNumOfDaysBack;
                var startTime            = DateTime.Now.Date.AddDays(-numOfDaysBack);
                var endTime              = DateTime.Now;
                var lastXDaysTimeEntries = await TimeEntryService.GetTimeEntriesByDate(startTime, endTime);

                var unsyncedTimeEntries = _timeEntryRepository.GetUnsyncedTimeEntries();
                lastXDaysTimeEntries.AddRange(unsyncedTimeEntries.Where(x => !x.HasSyncError));
                UserSession.UserStatistics.LastXDaysTimeEntries = lastXDaysTimeEntries;

                AppSettings.LastSyncDate = DateTime.Now;
                AppSettings.Save();
                SyncProgressChanged(0, "Synchronization complete");
                SyncInProgress = false;
                ForceResync    = false;
                ApplicationCommands.SyncCompleted.Execute(null);
            }
            catch (NotFoundByGuidException notFoundByGuidException)
            {
                Logger.Error(notFoundByGuidException);
                SyncInProgress = false;
                _resyncCommand.Execute(null);
            }
            catch (MissingHieracleDataException missingHieracleDataException)
            {
                Logger.Error(missingHieracleDataException);
                if (!ForceResync)
                {
                    SyncInProgress = false;
                    _resyncCommand.Execute(null);
                }
                else
                {
                    OnSyncFailed("Unknown Synchronization failure. Contact support");
                }
            }
            catch (Exception ex)
            {
                if (ex is AggregateException)
                {
                    var aggregateException = ex as AggregateException;
                    foreach (var e in aggregateException.Flatten().InnerExceptions)
                    {
                        HandleSyncError(e);
                    }
                }
                else
                {
                    HandleSyncError(ex);
                }
                OnSyncFailed("Synchronization failed due to a connectivity error. The application will retry in " +
                             AppSettings.SyncInterval.Minutes + " minutes.");
            }
            _busyService.HideBusy(_syncKey);
        }