/// <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);
}
/// <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);
}
public async void Current_DataChanged(ApplicationData sender, object args)
{
if (!string.IsNullOrWhiteSpace(PasswordBusiness.Password))
{
await PasswordBusiness.Load(PasswordBusiness.Password, true);
}
}
/// <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();
}
/// <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();
}
/// <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;
}
/// <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);
}
/// <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();
}
/// <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);
}
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);
}
/// <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);
}
/// <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);
}
/// <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);
}
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));
}
}
/// <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("");
}
/// <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);
}
/// <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"));
}
/// <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);
}
}
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;
}
/// <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();
}
}