Пример #1
0
        public MainModel(IGoogleAuthService googleAuthService, IStorageService storageService, ISystemTrayService systemTrayService)
        {
            _googleAuthService = googleAuthService;
            _storageService = storageService;
            _systemTrayService = systemTrayService;

            Load();
        }
Пример #2
0
        public NewFolderViewModel(IMainModel mainModel, INavigationService navigationService, IGoogleDriveService googleDriveService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService)
        {
            _mainModel = mainModel;
            _navigationService = navigationService;
            _googleDriveService = googleDriveService;
            _systemTrayService = systemTrayService;
            _messageBoxService = messageBoxService;

            CreateNewFolderCommand = new RelayCommand(CreateNewFolder, () => !IsBusy);
        }
Пример #3
0
        public MainViewModel(IMainModel mainModel, ISettingsModel settingsModel, IHereMapsService hereMapsService, IKnownCitiesService knownCitiesService, INavigationService navigationService, ILocationService locationService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService, ISmsComposeService smsComposeService, IShareLinkService shareLinkService, IEmailComposeService emailComposeService)
        {
            _mainModel           = mainModel;
            _settingsModel       = settingsModel;
            _hereMapsService     = hereMapsService;
            _knownCitiesService  = knownCitiesService;
            _navigationService   = navigationService;
            _locationService     = locationService;
            _messageBoxService   = messageBoxService;
            _systemTrayService   = systemTrayService;
            _smsComposeService   = smsComposeService;
            _shareLinkService    = shareLinkService;
            _emailComposeService = emailComposeService;

            UseCurrentLocationCommand = new RelayCommand(UseCurrentLocation);

            UseAntipodeLocationCommand = new RelayCommand(UseAntipodeLocation);

            ShareByEmailCommand = new RelayCommand(() =>
            {
                _emailComposeService.Show("The Other Side", CurrentPosition.ToString());
            });

            ShareBySmsCommand = new RelayCommand(() =>
            {
                _smsComposeService.Show(string.Empty, "The Other Side: " + CurrentPosition.ToString());
            });

            ShareOnSocialNetworkCommand = new RelayCommand(() =>
            {
                var coordinate  = CurrentPosition;
                var hereMapsUrl = "http://here.com/{0},14".FormatWithInvariantCulture(coordinate);

                _shareLinkService.Show("The Other Side", CurrentPosition.ToString(), hereMapsUrl);
            });

            PinToStartCommand = new RelayCommand(PinToStart);

            FindNearestLandMassCommand = new RelayCommand(FindNearestLandMass);

            FindNearestCityCommand = new RelayCommand(FindNearestCity);

            ShowLocationInfoCommand = new RelayCommand(ShowLocationInfo);

            ShowSettingsCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/SettingsPage.xaml");
            });

            ShowAboutCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/AboutPage.xaml");
            });
        }
Пример #4
0
        public NewObjectViewModel(ICttObjectTrackingService cttObjectTrackingService, INavigationService navigationService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService)
        {
            _cttObjectTrackingService = cttObjectTrackingService;
            _navigationService        = navigationService;
            _systemTrayService        = systemTrayService;
            _messageBoxService        = messageBoxService;

            AddObjectCommand = new RelayCommand(() =>
            {
                if (string.IsNullOrWhiteSpace(ObjectId))
                {
                    _messageBoxService.Show("Por favor indique o número do objecto", "Erro");

                    return;
                }

                _systemTrayService.SetProgressIndicator(string.Format("A adicionar: {0}...", ObjectId));

                _cttObjectTrackingService.GetCttObjectTrackingStatus(ObjectId, result =>
                {
                    _systemTrayService.HideProgressIndicator();

                    if (result.Error != null)
                    {
                        _messageBoxService.Show(string.Format("Não foi possível adicionar o objecto \"{0}\"", ObjectId), "Erro");

                        ScanBarcodeCommand.RaiseCanExecuteChanged();
                        AddObjectCommand.RaiseCanExecuteChanged();
                    }
                    else
                    {
                        MessengerInstance.Send <AddObjectMessage>(new AddObjectMessage(_description, result.ETag, result.Data));

                        _navigationService.GoBack();

                        ObjectId = null;
                    }
                }, null);

                ScanBarcodeCommand.RaiseCanExecuteChanged();
                AddObjectCommand.RaiseCanExecuteChanged();
            }, () => !IsBusy);

            ScanBarcodeCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo(new Uri("/View/ScanBarcodePage.xaml", UriKind.Relative));
            }, () => !IsBusy);

            MessengerInstance.Register <ScannedBarcodeMessage>(this, message =>
            {
                ObjectId = message.ObjectId;
            });
        }
Пример #5
0
        public RenameFileViewModel(IMainModel mainModel, INavigationService navigationService, IGoogleDriveService googleDriveService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService)
        {
            _mainModel = mainModel;
            _navigationService = navigationService;
            _googleDriveService = googleDriveService;
            _systemTrayService = systemTrayService;
            _messageBoxService = messageBoxService;

            RenameFileCommand = new RelayCommand(RenameFile, () => !IsBusy);

            PageLoadedCommand = new RelayCommand(() =>
            {
                FileName = _mainModel.SelectedFile.Title;
            });
        }
Пример #6
0
        public AuthorizationViewModel(IMainModel mainModel, IGoogleAuthService googleAuthService, IGoogleOAuth2Service googleOAuth2Service, INavigationService navigationService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService)
        {
            _mainModel = mainModel;
            _googleAuthService = googleAuthService;
            _googleOAuth2Service = googleOAuth2Service;
            _navigationService = navigationService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;

            PageLoadedCommand = new RelayCommand(() =>
            {
                ShowBrowser = true;

                WebBrowserSourceUri = _googleAuthService.GetAuthUri();
            });

            WebBrowserNavigatingCommand = new RelayCommand<NavigatingEventArgs>(e =>
            {
                if (_showBrowser)
                {
                    _systemTrayService.SetProgressIndicator("");
                }

                if (e.Uri == null || e.Uri.Host != "localhost")
                    return;

                ShowBrowser = false;

                WebBrowserSourceUri = new Uri("https://accounts.google.com/Logout");

                var queryString = e.Uri.QueryString();

                ExchangeAuthorizationCode(queryString.GetValue("code"));
            });

            WebBrowserNavigatedCommand = new RelayCommand<NavigationEventArgs>(e =>
            {
                if (_showBrowser)
                {
                    _systemTrayService.HideProgressIndicator();
                }
            });

            WebBrowserNavigationFailedCommand = new RelayCommand<NavigationFailedEventArgs>(e =>
            {
                _systemTrayService.HideProgressIndicator();
            });
        }
        public RefreshViewModel(IMainModel mainModel, IJogosSantaCasaService jogosSantaCasaService, INavigationService navigationService, ISystemTrayService systemTrayService, IShellTileService shellTileService)
        {
            _mainModel             = mainModel;
            _jogosSantaCasaService = jogosSantaCasaService;
            _navigationService     = navigationService;
            _systemTrayService     = systemTrayService;
            _shellTileService      = shellTileService;

            RefreshCommand = new RelayCommand(() =>
            {
                IsBusy = true;

                StatusText = "A actualizar os resultados...";

                _jogosSantaCasaService.GetResults(result =>
                {
                    if (result.Error != null)
                    {
                        StatusText = "Ocorreu um erro ao actualizar os resultados!";

                        IsBusy = false;

                        return;
                    }
                    else if (result.StatusCode != System.Net.HttpStatusCode.NotModified)
                    {
                        _mainModel.Results = result.Data;
                        _mainModel.ETag    = result.ETag;
                    }

                    _systemTrayService.HideProgressIndicator();

                    if (_navigationService.CanGoBack)
                    {
                        _navigationService.RemoveBackEntry();
                    }
                    _navigationService.NavigateTo(new Uri("/View/ResultsPage.xaml", UriKind.Relative));
                }, _mainModel.ETag, null);
            }, () => !IsBusy);

#if !WP8
            DispatcherHelper.RunAsync(UpdateTiles);
#endif
        }
        public MainViewModel(IMainModel model, ICttObjectTrackingService cttObjectTrackingService, INavigationService navigationService, ISystemTrayService systemTrayService, IMessageBoxService messageBoxService, IClipboardService clipboardService, IEmailComposeService emailComposeService, ISmsComposeService smsComposeService)
        {
            _model = model;
            _cttObjectTrackingService = cttObjectTrackingService;
            _navigationService        = navigationService;
            _systemTrayService        = systemTrayService;
            _messageBoxService        = messageBoxService;
            _clipboardService         = clipboardService;
            _emailComposeService      = emailComposeService;
            _smsComposeService        = smsComposeService;

            TrackedObjects = _model.TrackedObjects
                             .Select(x => new ObjectDetailsViewModel(x))
                             .ToObservableCollection();

            ShowObjectDetailsCommand = new RelayCommand <ObjectDetailsViewModel>(item =>
            {
                var objectId = item.Model.ObjectId;

                _navigationService.NavigateTo(new Uri("/View/ObjectDetailsPage.xaml?" + objectId, UriKind.Relative));
            });

            NewObjectCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo(new Uri("/View/NewObjectPage.xaml", UriKind.Relative));
            }, () => !IsBusy);

            EnableSelectionCommand = new RelayCommand(() =>
            {
                IsSelectionEnabled = true;
            }, () => !IsTrackedObjectsEmpty && !IsBusy);

            RefreshCommand = new RelayCommand(() =>
            {
                var enumerator = TrackedObjects.GetEnumerator();

                RefreshNext(enumerator);
            }, () => !IsTrackedObjectsEmpty && !IsBusy);

            DeleteObjectsCommand = new RelayCommand <IList>(items =>
            {
                if (items == null || items.Count == 0)
                {
                    return;
                }

                _messageBoxService.Show("Está prestes a apagar os objectos seleccionados", "Tem a certeza?", new string[] { "eliminar", "cancelar" }, button =>
                {
                    if (button != 0)
                    {
                        return;
                    }

                    var itemsToRemove = items
                                        .Cast <ObjectDetailsViewModel>()
                                        .ToArray();

                    foreach (var item in itemsToRemove)
                    {
                        _model.TrackedObjects.Remove(item.Model);

                        TrackedObjects.Remove(item);
                    }

                    IsTrackedObjectsEmpty = (TrackedObjects.Count == 0);

                    _model.Save();
                });
            }, items => !IsBusy);

            ShowAboutCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo(new Uri("/View/AboutPage.xaml", UriKind.Relative));
            });

            BackKeyPressCommand = new RelayCommand <CancelEventArgs>(e =>
            {
                if (IsSelectionEnabled)
                {
                    IsSelectionEnabled = false;

                    e.Cancel = true;
                }
            });

            CopyCodeCommand = new RelayCommand <ObjectDetailsViewModel>(item =>
            {
                _clipboardService.SetText(item.Model.ObjectId);
            });

            MailCodeCommand = new RelayCommand <ObjectDetailsViewModel>(item =>
            {
                _emailComposeService.Show("CTT Objectos", string.Format("\nO seu código de tracking: {0}\n\nPode consultar o estado entrando em http://www.ctt.pt e utilizando a opção \"Pesquisa de Objectos\".\n\nEnviado por CTT Objectos (http://bit.ly/cttobjectos)", item.Model.ObjectId));
            });

            TextCodeCommand = new RelayCommand <ObjectDetailsViewModel>(item =>
            {
                _smsComposeService.Show(string.Empty, item.Model.ObjectId);
            });

            MessengerInstance.Register <AddObjectMessage>(this, message =>
            {
                var objectViewModel = TrackedObjects.FirstOrDefault(x => x.Model.ObjectId == message.Model.ObjectId);

                if (objectViewModel == null)
                {
                    var objectModel = new ObjectModel(message.Description, message.ETag, message.Model);

                    _model.TrackedObjects.Add(objectModel);

                    TrackedObjects.Add(new ObjectDetailsViewModel(objectModel));

                    IsTrackedObjectsEmpty = false;
                }
                else
                {
                    objectViewModel.Model.Description = message.Description;
                    objectViewModel.Model.State       = message.Model;
                }

                _model.Save();
            });

            IsTrackedObjectsEmpty = (TrackedObjects.Count == 0);
        }
 public static void Show(this ISystemTrayService systemTrayService, string text)
 {
     systemTrayService.Text            = text;
     systemTrayService.IsIndeterminate = true;
     systemTrayService.IsVisible       = true;
 }
 public static void Hide(this ISystemTrayService systemTrayService)
 {
     systemTrayService.IsVisible       = false;
     systemTrayService.IsIndeterminate = false;
     systemTrayService.Text            = null;
 }
Пример #11
0
        public ExplorerViewModel(IMainModel mainModel, IGoogleDriveService googleDriveService, INavigationService navigationService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService, IPhotoChooserService photoChooserService)
        {
            _mainModel = mainModel;
            _googleDriveService = googleDriveService;
            _navigationService = navigationService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;
            _photoChooserService = photoChooserService;

            Files = new ObservableCollection<GoogleFileViewModel>();
            PictureFiles = new ObservableCollection<GoogleFileViewModel>();

            OpenFileCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                if (IsSelectionEnabled)
                {
                    return;
                }

                OpenFile(file);
            });

            ChangeStaredStatusCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                if (IsSelectionEnabled)
                {
                    return;
                }

                ChangeStaredStatus(file);
            });

            AddFileCommand = new RelayCommand(UploadFile);

            EnableSelectionCommand = new RelayCommand(() =>
            {
                if (IsBusy)
                {
                    return;
                }

                IsSelectionEnabled = true;
            });

            RefreshFilesCommand = new RelayCommand(RefreshFiles);

            DeleteFilesCommand = new RelayCommand<IList>(files =>
            {
                _messageBoxService.Show("You are about to delete the selected files. Do you wish to proceed?", "Delete files?", new[] { "delete", "cancel" }, button =>
                {
                    if (button != 0)
                        return;

                    var filesArray = files
                        .Cast<GoogleFileViewModel>()
                        .ToArray();

                    IsSelectionEnabled = false;

                    DeleteFiles(filesArray);
                });
            });

            CreateNewFolderCommand = new RelayCommand(CreateNewFolder);

            RenameFileCommand = new RelayCommand<GoogleFileViewModel>(RenameFile);

            DeleteFileCommand = new RelayCommand<GoogleFileViewModel>(file =>
            {
                _messageBoxService.Show(string.Format("You are about to delete '{0}'. Do you wish to proceed?", file.Title), "Delete file?", new[] { "delete", "cancel" }, button =>
                {
                    if (button != 0)
                        return;

                    DeleteFile(file);
                });
            });

            ShowAboutCommand = new RelayCommand(() =>
            {
                _navigationService.NavigateTo("/View/AboutPage.xaml");
            });

            PageLoadedCommand = new RelayCommand(ExecuteInitialLoad);

            BackKeyPressCommand = new RelayCommand<CancelEventArgs>(e =>
            {
                GoogleDriveFile item;

                if (PivotSelectedIndex == 1)
                {
                    PivotSelectedIndex = 0;

                    e.Cancel = true;
                }
                else if (IsSelectionEnabled)
                {
                    IsSelectionEnabled = false;

                    e.Cancel = true;
                }
                else if (_mainModel.TryPop(out item))
                {
                    AbortCurrentCall();

                    RaisePropertyChanged(() => CurrentPath);

                    RefreshFiles();

                    e.Cancel = true;
                }
                else
                {
                    AbortCurrentCall(true);

                    Files.Clear();
                    PictureFiles.Clear();
                }
            });

            MessengerInstance.Register<RefreshFilesMessage>(this, message =>
            {
                DispatcherHelper.RunAsync(RefreshFiles);
            });
        }
Пример #12
0
        public ViewFileViewModel(IMainModel mainModel, IGoogleDriveService googleDriveService, IMessageBoxService messageBoxService, ISystemTrayService systemTrayService, IMediaLibraryService mediaLibraryService)
        {
            _mainModel = mainModel;
            _googleDriveService = googleDriveService;
            _messageBoxService = messageBoxService;
            _systemTrayService = systemTrayService;
            _mediaLibraryService = mediaLibraryService;

            DownloadFileCommand = new RelayCommand(DownloadFile, () => !IsBusy && CanDownload);

            BackKeyPressCommand = new RelayCommand<CancelEventArgs>(e =>
            {
                AbortCurrentCall(false);
            });
        }