Exemplo n.º 1
0
        /// <summary>
        /// Charge un fichier de mot de passe, ou le créer si aucun
        /// </summary>
        /// <returns>les erreurs à afficher</returns>
        public async Task <string> Valider()
        {
            var retour = Validate();

            if (string.IsNullOrWhiteSpace(retour))
            {
                //si le fichier est à créer
                if (ModeSelect.Equals(ModeOuvertureEnum.FichierACreer))
                {
                    PasswordBusiness.Password = MotDePasseA;
                    await PasswordBusiness.Save();
                }

                if (ModeSelect.Equals(ModeOuvertureEnum.FichierDejaExistant))
                {
                    if (!await PasswordBusiness.Load(MotDePasseA, true))
                    {
                        retour += ResourceLoader.GetForCurrentView("Errors").GetString("erreurOuvertureFichier");
                    }
                    else
                    {
                        if (ContexteAppli.IsCortanaActive)
                        {
                            await CortanaBusiness.CheckPassword();
                        }
                    }
                }
            }
            return(retour);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Sauvegarde dans le fichier les modifications apportés  un mot de passe, ou l'ajout de ce dernier
        /// </summary>
        /// <returns>les erreurs éventuellements générés</returns>
        public async Task <string> Save()
        {
            var retour = Validate();

            //si aucune erreur
            if (string.IsNullOrWhiteSpace(retour))
            {
                //en cas d'ajout du mot de passe
                if (Action.Equals(ActionMotDePasseEnum.Ajouter))
                {
                    var mdp = new MotDePasse
                    {
                        Titre             = Titre,
                        Login             = Login,
                        MotDePasseObjet   = Password,
                        SiteWeb           = Site,
                        Commentaire       = Commentaire,
                        DossierPossesseur = DossierPossesseur,
                        IdIcone           = SelectedIcone
                    };

                    var res = ContexteAppli.ListeIcone.Where(x => (int)x.Tag == SelectedIcone).ToList();
                    if (res.Count > 0)
                    {
                        mdp.Icone = (BitmapImage)res[0].Source;
                    }
                    else
                    {
                        mdp.Icone = null;
                    }
                    DossierPossesseur.ListeMotDePasse.Add(mdp);
                }
                //en cas de modification placement des nouvelles informations
                if (Action.Equals(ActionMotDePasseEnum.Modifier))
                {
                    PasswordOriginal.Titre           = Titre;
                    PasswordOriginal.Login           = Login;
                    PasswordOriginal.MotDePasseObjet = Password;
                    PasswordOriginal.IdIcone         = SelectedIcone;
                    PasswordOriginal.Commentaire     = Commentaire;
                    PasswordOriginal.SiteWeb         = Site;
                    var res = ContexteAppli.ListeIcone.Where(x => (int)x.Tag == PasswordOriginal.IdIcone).ToList();
                    if (res.Count > 0)
                    {
                        PasswordOriginal.Icone = (BitmapImage)res[0].Source;
                    }
                    else
                    {
                        PasswordOriginal.Icone = null;
                    }
                }
                //sauvegarde
                await PasswordBusiness.Save();


                //mise à jour de la liste de cortana
                await CortanaBusiness.UpdateCortana();
            }
            return(retour);
        }
Exemplo n.º 3
0
 public async void Current_DataChanged(ApplicationData sender, object args)
 {
     if (!string.IsNullOrWhiteSpace(PasswordBusiness.Password))
     {
         await PasswordBusiness.Load(PasswordBusiness.Password, true);
     }
 }
Exemplo n.º 4
0
        /// <summary>
        /// A lancer en premier dans le démarrage de l'application
        /// </summary>
        /// <param name="full">true si l'application est lancé en mode complet ou mode arrière plan</param>
        /// <param name="fichier">le fichier à ouvrir si différent de celui présent dans roaming</param>
        /// <returns></returns>
        public static async Task Initialize(bool full, StorageFile fichier)
        {
            if (full)
            {
                ChargerIcones();
                await IconeBusiness.Load();

                IconeBusiness.AddIconToIconAppli();
                DossierMere = new Dossier {
                    Titre = ResourceLoader.GetForCurrentView().GetString("phraseRacine")
                };
                ImageUnlockBusiness.Init();
            }
            else
            {
                DossierMere = new Dossier {
                    Titre = "Root"
                };
            }

            if (fichier != null)
            {
                if (StringUtils.GetExtension(fichier.Name) != ContexteStatic.Extension)
                {
                    fichier = null;
                }
            }
            IsFichierRoamingOuvert = fichier == null;
            PasswordBusiness.Init(fichier);
            ParamBusiness.Init();
            await ParamBusiness.Load(full);

            CortanaBusiness.Init();
        }
Exemplo n.º 5
0
        /// <summary>
        /// supprime un mot de passe des données de l'utilisateur et sauvegarde le fichier
        /// </summary>
        public async Task SupprimerMotDepasse()
        {
            Password.DossierPossesseur.ListeMotDePasse.Remove(Password);
            await PasswordBusiness.Save();

            //mise à jour de la liste de cortana
            await CortanaBusiness.UpdateCortana();
        }
Exemplo n.º 6
0
        /// <summary>
        /// Change l'emplacement du mot de passe avec le dossier en cours de navigation
        /// </summary>
        public async Task ChangerEmplacementMotDePasse()
        {
            Password.DossierPossesseur.ListeMotDePasse.Remove(Password);
            DossierEncours.ListeMotDePasse.Add(Password);
            Password.DossierPossesseur = DossierEncours;
            await PasswordBusiness.Save();

            SelectedDossierAbstract = DossierEncours;
        }
Exemplo n.º 7
0
        /// <summary>
        /// Ajoute le nouveau dossier au dossier en cours et sauvegarde le tout
        /// </summary>
        /// <returns>les erreurs à afficher</returns>
        public async Task <string> AjouterDossier()
        {
            var retour = ValidateDossier(DossierToEditName);

            if (string.IsNullOrWhiteSpace(retour))
            {
                var newDossier = new Dossier(DossierToEditName, DossierSelected);
                DossierSelected.SousDossier.Add(newDossier);
                await PasswordBusiness.Save();

                OuvrirDossier(DossierSelected);
            }
            return(retour);
        }
Exemplo n.º 8
0
        /// <summary>
        /// met à jour la date de dernière modification du fichier
        /// </summary>
        public async Task MajDerniereSynchro()
        {
            var date = await PasswordBusiness.GetDerniereModifFile();

            DerniereSynchro = ResourceLoader.GetForCurrentView().GetString("textDerniereSynchro") + date.Day + "/" +
                              date.Month + "/" +
                              date.Year + " " +
                              date.Hour + ":" +
                              date.Minute + ":" +
                              date.Second;

            EspaceOccupe = (ContexteAppli.IsFichierRoamingOuvert)?ResourceLoader.GetForCurrentView().GetString("textEspaceOccupe") +
                           await PasswordBusiness.GetEspaceFichierOccupePourcent() + " %" : await PasswordBusiness.GetNameFile();
        }
Exemplo n.º 9
0
        /// <summary>
        /// Efface le fichier de mot de passe
        /// </summary>
        /// <returns></returns>
        public static async Task <bool> ReinitAppli()
        {
            //efface le fichier des mots de passes
            if (await PasswordBusiness.Delete() && await ParamBusiness.Delete() && await CortanaBusiness.DeletePassword())
            {
                await IconeBusiness.DeletelAll();

                await ImageUnlockBusiness.DeleteFile();

                await CortanaBusiness.UpdateCortana();
                await Initialize(true, null);

                return(true);
            }
            return(false);
        }
Exemplo n.º 10
0
        public async Task <string> Valider()
        {
            var retour = Validate();

            if (string.IsNullOrWhiteSpace(retour))
            {
                if (!await PasswordBusiness.Load(MotDePasse, true))
                {
                    retour += ResourceLoader.GetForCurrentView("Errors").GetString("erreurOuvertureFichier");
                }
                else
                {
                    await LancerRecherche();
                }
            }
            return(retour);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Tente d'ouvrir le fichier de mot de passe retourne null si ok sinon le message d'erreur
        /// </summary>
        /// <returns>le message d'erreur sinon null</returns>
        public async Task <string> OuvrirFichierPassword()
        {
            if (string.IsNullOrWhiteSpace(Password))
            {
                Password = "";
                return(ResourceLoader.GetForCurrentView("Errors").GetString("erreurChampsNonRemplis") + "\r\n");
            }


            if (!await PasswordBusiness.Load(Password, true))
            {
                Password = "";
                return(ResourceLoader.GetForCurrentView("Errors").GetString("erreurOuvertureFichier"));
            }
            IsLog = true;
            return(null);
        }
Exemplo n.º 12
0
        /// <summary>
        /// Permet de vérifier si l'application peut s'autoLogger, s'autologue si possible, et lance la recherche
        /// </summary>
        /// <returns>true si à tout réussi à faire automatiquement</returns>
        public async Task <bool> LanceRechercheSansMotDePasse()
        {
            if (ContexteAppli.IsCortanaActive)
            {
                var mdp = await CortanaBusiness.GetPasswordUser();

                if (!string.IsNullOrWhiteSpace(mdp))
                {
                    if (await PasswordBusiness.Load(mdp, true))
                    {
                        await LancerRecherche();

                        return(true);
                    }
                }
            }
            return(false);
        }
Exemplo n.º 13
0
        /// <summary>
        /// change le mot de passe et sauvegarde le fichier
        /// </summary>
        /// <returns>les erreurs du validate sinon une ssting vide</returns>
        public async Task <string> ChangerMdp()
        {
            var retour = Validate();

            if (string.IsNullOrWhiteSpace(retour))
            {
                PasswordBusiness.Password = NewMdp;
                await PasswordBusiness.Save();

                //si cortana est activé, changer le fichier
                if (CortanaActive != null && CortanaActive.Value)
                {
                    await CortanaBusiness.SavePassword();
                }
            }

            return(retour);
        }
Exemplo n.º 14
0
 private async void OpenButton_Click(object sender, RoutedEventArgs e)
 {
     if (GridMdp.Visibility == Visibility.Visible)
     {
         if (await PasswordBusiness.DoesFileCypherExist())
         {
             ((Frame)Window.Current.Content).Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierDejaExistant);
         }
         else
         {
             ((Frame)Window.Current.Content).Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierACreer);
         }
     }
     else
     {
         ((Frame)Window.Current.Content).Navigate(typeof(MainPageView));
     }
 }
Exemplo n.º 15
0
        /// <summary>
        /// supprime un dossier
        /// </summary>
        /// <param name="toDelete">le dossier à effacer</param>
        /// <returns>les erreurs à afficher</returns>
        public async Task <string> SuppprimerDossier(Dossier toDelete)
        {
            var resourceLoader = ResourceLoader.GetForCurrentView("Errors");

            if (toDelete != null)
            {
                if (toDelete.DossierParent != null)
                {
                    toDelete.DossierParent.SousDossier.Remove(toDelete);
                    await PasswordBusiness.Save();

                    OuvrirDossier(DossierSelected);
                }
            }
            else
            {
                return(resourceLoader.GetString("erreurAucunDossierToSup") + "\r\n");
            }
            return("");
        }
Exemplo n.º 16
0
        /// <summary>
        /// modifie le nom d'un dossier
        /// </summary>
        /// <returns>les erreurs</returns>
        public async Task <string> ModifierDossier()
        {
            var resourceLoader = ResourceLoader.GetForCurrentView("Errors");
            var retour         = ValidateDossier(DossierToEditName);

            if (string.IsNullOrWhiteSpace(retour))
            {
                if (DossierToEdit != null)
                {
                    DossierToEdit.Titre = DossierToEditName;
                    await PasswordBusiness.Save();

                    OuvrirDossier(DossierSelected);
                }
                else
                {
                    retour += resourceLoader.GetString("erreurAucunDossier") + "\r\n";
                }
            }
            return(retour);
        }
Exemplo n.º 17
0
        /// <summary>
        /// Lance l'opération de récupération des mots de passe
        /// </summary>
        /// <returns>les erreurs à afficher.</returns>
        public async Task <string> Recuperer()
        {
            ValidSave = false;
            if (IsLog)
            {
                var erreur = Validate();
                if (string.IsNullOrWhiteSpace(erreur))
                {
                    foreach (var mdp in ListeMotDePasses.Where(mdp => mdp.Selected))
                    {
                        if (mdp.IdIcone != 0 && mdp.IdIcone < ContexteAppli.ListeIcone.Count)
                        {
                            mdp.Icone = (BitmapImage)ContexteAppli.ListeIcone[mdp.IdIcone].Source;
                        }
                        else
                        {
                            mdp.Icone = null;
                        }

                        if (mdp.DossierPossesseur == null)
                        {
                            mdp.DossierPossesseur = ContexteAppli.DossierMere;
                        }
                        mdp.DossierPossesseur.ListeMotDePasse.Add(mdp);
                    }

                    await PasswordBusiness.Save();

                    ValidSave = true;
                    return(ResourceLoader.GetForCurrentView("Errors").GetString("infoMdpAjoute"));
                }

                return(erreur);
            }
            return(ResourceLoader.GetForCurrentView("Errors").GetString("erreurFichierPasOuvert"));
        }
Exemplo n.º 18
0
        /// <summary>
        /// Méthode se lancant lors de l'appel de cortana pour l'appli
        /// </summary>
        /// <param name="taskInstance"></param>
        public async void Run(IBackgroundTaskInstance taskInstance)
        {
            //lancement de cortana, récupération des objets nécéssaires
            _serviceDeferral       = taskInstance.GetDeferral();
            taskInstance.Canceled += (sender, reason) => _serviceDeferral?.Complete();
            var triggerDetails = taskInstance.TriggerDetails as AppServiceTriggerDetails;

            _voiceCommandServiceConnection = VoiceCommandServiceConnection.FromAppServiceTriggerDetails(triggerDetails);
            _voiceCommandServiceConnection.VoiceCommandCompleted += (sender, args) => _serviceDeferral?.Complete();
            var    identifiant = (await _voiceCommandServiceConnection.GetVoiceCommandAsync()).Properties["site"][0].ToLower();
            string message;
            var    openApp   = false;
            var    openTiles = false;
            var    tiles     = new List <VoiceCommandContentTile>();

            //Initialisation de l'appli
            await ContexteAppli.Initialize(false, null);

            //si le fichier existe
            if (await PasswordBusiness.DoesFileCypherExist())
            {
                //si cortana est autorisé
                if (ContexteAppli.IsCortanaActive)
                {
                    //récupération du mot de passe
                    var mdp = await CortanaBusiness.GetPasswordUser();

                    if (!string.IsNullOrWhiteSpace(mdp))
                    {
                        //chargement du fichier
                        if (await PasswordBusiness.Load(mdp, false))
                        {
                            tiles = CortanaBusiness.GetMotDePasseTile(identifiant, ContexteAppli.DossierMere);

                            if (tiles.Count == 0)
                            {
                                message = GetString("cortanaAucunIdentifiant");
                            }
                            else if (tiles.Count > 10)
                            {
                                message = GetString("cortanaPlusieursResultats");
                                openApp = true;
                            }
                            else
                            {
                                message   = GetString("cortanaIdentifiantsTrouves");
                                openTiles = true;
                            }
                        }
                        else
                        {
                            message = GetString("cortanaEchecFichier");
                            openApp = true;
                        }
                    }
                    else
                    {
                        message = GetString("cortanaEchecFichier");
                        openApp = true;
                    }
                }
                else
                {
                    message = GetString("cortanaLanceApp");
                    openApp = true;
                }
            }
            else
            {
                message = GetString("cortanaAucunIdentifiant");
            }

            var userPrompt = new VoiceCommandUserMessage
            {
                DisplayMessage = message,
                SpokenMessage  = message
            };

            if (openApp)
            {
                var response = VoiceCommandResponse.CreateResponse(userPrompt);
                response.AppLaunchArgument = identifiant;
                await _voiceCommandServiceConnection.RequestAppLaunchAsync(response);
            }
            else if (openTiles)
            {
                var response = VoiceCommandResponse.CreateResponse(userPrompt, tiles);
                await _voiceCommandServiceConnection.ReportSuccessAsync(response);
            }
            else
            {
                var response = VoiceCommandResponse.CreateResponse(userPrompt);
                await _voiceCommandServiceConnection.ReportSuccessAsync(response);
            }
        }
Exemplo n.º 19
0
        private async void validerButton_Click(object sender, RoutedEventArgs e)
        {
            WaitRing.IsActive              = true;
            ValiderButton.IsEnabled        = false;
            ParcourirButton.IsEnabled      = false;
            ChangerDossierButton.IsEnabled = false;
            EraseCheckBox.IsEnabled        = false;
            MdpTextbox.IsEnabled           = false;
            var erreur = "";

            try
            {
                //vérification du format
                if (FormatComboBox.SelectedItem != null)
                {
                    ViewModel.FormatChoisi = ((ImportExportViewModel.ExportFormat)FormatComboBox.SelectedItem);
                }
                else
                {
                    erreur = ResourceLoader.GetForCurrentView("Errors").GetString("erreurAucunFormat");
                }

                ViewModel.MdpCypher = MdpTextbox.Password;
                //ViewModel.SelectedDossier = ContexteAppli.PageViewMere.GetDossierSelected();

                switch (ViewModel.Mode)
                {
                case ImportExportEnum.Import:
                    switch (ViewModel.FormatChoisi.Id)
                    {
                    case 1:
                        erreur = await ViewModel.ImporterCsv();

                        break;

                    case 2:
                        erreur = await ViewModel.ImporterXml();

                        break;

                    case 3:
                        erreur = await ViewModel.ImporterKwi();

                        break;
                    }
                    break;

                case ImportExportEnum.Export:
                    switch (ViewModel.FormatChoisi.Id)
                    {
                    case 1:
                        erreur = await ViewModel.ExporterCsv();

                        break;

                    case 2:
                        erreur = await ViewModel.ExporterXml();

                        break;

                    case 3:
                        erreur = await ViewModel.ExporterKwi();

                        break;
                    }
                    break;
                }

                if (!string.IsNullOrWhiteSpace(erreur))
                {
                    TextBlockErreur.Text = erreur;
                }
                else
                {
                    await PasswordBusiness.Save();

                    //mise à jour de la liste de cortana
                    await CortanaBusiness.UpdateCortana();

                    switch (ViewModel.Mode)
                    {
                    case ImportExportEnum.Import:
                        await MessageBox.ShowAsync(ResourceLoader.GetForCurrentView().GetString("textImportOK"), "", MessageBoxButton.Ok);

                        break;

                    case ImportExportEnum.Export:
                        await MessageBox.ShowAsync(ResourceLoader.GetForCurrentView().GetString("textExportOK"), "", MessageBoxButton.Ok);

                        break;
                    }
                    ((Frame)Window.Current.Content).Navigate(typeof(MainPageView));
                }
            }
            catch
            {
                TextBlockErreur.Text = ResourceLoader.GetForCurrentView("Errors").GetString("erreurInconnu");
            }
            WaitRing.IsActive              = false;
            ValiderButton.IsEnabled        = true;
            ParcourirButton.IsEnabled      = true;
            ChangerDossierButton.IsEnabled = true;
            EraseCheckBox.IsEnabled        = true;
            MdpTextbox.IsEnabled           = true;
        }
Exemplo n.º 20
0
        /// <summary>
        /// Lance l'application
        /// </summary>
        /// <param name="recherche">la recherche commandé par cortana sinon null</param>
        /// <param name="fichier">le fichier à ouvrir dans la page de partage</param>
        /// <returns></returns>
        private async Task LaunchApp(string recherche, StorageFile fichier)
        {
            var rootFrame = Window.Current.Content as Frame;

            // Do not repeat app initialization when the Window already has content,
            // just ensure that the window is active
            if (rootFrame == null)
            {
                // Create a Frame to act as the navigation context and navigate to the first page
                rootFrame = new Frame();

                rootFrame.NavigationFailed += OnNavigationFailed;
                rootFrame.Navigated        += OnNavigated;

                // Place the frame in the current Window
                Window.Current.Content = rootFrame;

                // Register a handler for BackRequested events and set the
                // visibility of the Back button
                SystemNavigationManager.GetForCurrentView().BackRequested += OnBackRequested;

                SystemNavigationManager.GetForCurrentView().AppViewBackButtonVisibility =
                    rootFrame.CanGoBack ?
                    AppViewBackButtonVisibility.Visible :
                    AppViewBackButtonVisibility.Collapsed;
            }

            if (rootFrame.Content == null)
            {
                await ContexteAppli.Initialize(true, fichier);

                bool ouvertureReussi;

                if (fichier != null)
                {
                    if (StringUtils.GetExtension(fichier.Name) == ContexteStatic.Extension)
                    {
                        ouvertureReussi = rootFrame.Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierDejaExistant);
                    }
                    else if (StringUtils.GetExtension(fichier.Name) == ContexteStatic.ExtensionPartage)
                    {
                        if (await PasswordBusiness.DoesFileCypherExist())
                        {
                            ouvertureReussi = rootFrame.Navigate(typeof(RecupPasswordView), fichier);
                        }
                        else
                        {
                            ouvertureReussi = rootFrame.Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierACreer);
                        }
                    }
                    else
                    {
                        ouvertureReussi = false;
                    }
                }
                else
                {
                    if (await PasswordBusiness.DoesFileCypherExist())
                    {
                        if (!string.IsNullOrWhiteSpace(recherche))
                        {
                            ouvertureReussi = rootFrame.Navigate(typeof(ResultCortanaView), recherche);
                        }
                        else
                        {
                            ouvertureReussi = rootFrame.Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierDejaExistant);
                        }
                    }
                    else
                    {
                        ouvertureReussi = rootFrame.Navigate(typeof(StartPageView), ModeOuvertureEnum.FichierACreer);
                    }
                }

                if (!ouvertureReussi)
                {
                    throw new Exception(ResourceLoader.GetForCurrentView("Errors").GetString("erreurDemarrage"));
                }
                Window.Current.Activate();
            }
        }