/// <summary>
/// Récupère les mots de passe d'un fichier
/// </summary>
/// <returns>les erreurs si il y en a</returns>
public async Task <string> RecupFichier()
{
var erreur = Validate();
if (string.IsNullOrWhiteSpace(erreur))
{
try
{
//lecture
var buffer = (await FileIO.ReadBufferAsync(Fichier)).ToArray();
//déchiffrement
var data = CryptUtils.AesDecryptByteArrayToString(buffer, CryptKey, CryptSalt);
//deserialization
var xsb = new XmlSerializer(typeof(ObservableCollection <MotDePasse>));
var rd = new StringReader(data);
ListeMdpRecup = xsb.Deserialize(rd) as ObservableCollection <MotDePasse>;
}
catch
{
erreur += ResourceLoader.GetForCurrentView("Errors").GetString("erreurDechiffrementb");
}
}
return(erreur);
}
/// <summary>
/// lit le fichier , le déchiffre à partir du mot de passe fournit et le désérialize
/// </summary>
/// <param name="passwordTmp">le mot de passe pour tenter le déchiffrement</param>
/// <param name="fullLoad">Indique si c'est un chargement complet ou légé</param>
/// <returns>true si ok</returns>
public static async Task <bool> Load(string passwordTmp, bool fullLoad)
{
try
{
//lecture
var inFile = await Fichier.LireByteArray();
//dechiffrement
var xmlIn = CryptUtils.AesDecryptByteArrayToString(inFile, passwordTmp, passwordTmp);
//deserialize
var xsb = new XmlSerializer(typeof(Dossier));
var rd = new StringReader(xmlIn);
ContexteAppli.DossierMere = xsb.Deserialize(rd) as Dossier;
if (fullLoad)
{
RemiseEnPlaceParent(ContexteAppli.DossierMere);
RemiseEnPlaceIcone(ContexteAppli.DossierMere);
}
Password = passwordTmp;
return(true);
}
catch (Exception)
{
return(false);
}
}
/// <summary>
/// Importe le fichier chiffré dans le fichier de travail et le recharge
/// </summary>
/// <returns>la liste des erreurs</returns>
public async Task <string> ImporterKwi()
{
var retour = Validate();
if (string.IsNullOrWhiteSpace(retour))
{
var buffer = await FileIO.ReadBufferAsync(Fichier);
byte[] inFile = buffer.ToArray();
var xml = CryptUtils.AesDecryptByteArrayToString(inFile, MdpCypher, MdpCypher);
var xsb = new XmlSerializer(typeof(Dossier));
Dossier resultImport;
using (var rd = new StringReader(xml))
{
resultImport = xsb.Deserialize(rd) as Dossier;
if (!EcraserDossier)
{
RemiseEnPlaceParent(resultImport);
if (resultImport != null)
{
resultImport.DossierParent = SelectedDossier;
}
RemiseEnPlaceIcone(resultImport);
SelectedDossier.SousDossier.Add(resultImport);
}
else
{
RemiseEnPlaceParent(resultImport);
RemiseEnPlaceIcone(resultImport);
if (resultImport?.Titre != null)
{
SelectedDossier.Titre = resultImport.Titre;
}
if (resultImport.SousDossier.Count > 0)
{
SelectedDossier.SousDossier.Clear();
foreach (var dossier in resultImport.SousDossier)
{
SelectedDossier.SousDossier.Add(dossier);
}
}
if (resultImport.ListeMotDePasse.Count > 0)
{
SelectedDossier.ListeMotDePasse.Clear();
foreach (var mdp in resultImport.ListeMotDePasse)
{
SelectedDossier.ListeMotDePasse.Add(mdp);
}
}
}
}
}
return(retour);
}
/// <summary>
/// Charge les données du fichier de compte en roaming s'il existe
/// </summary>
private static async Task LoadFileCompte()
{
if (await _roamingCompteFile.FileExist() && await _roamingCompteFile.GetSizeFile() > 0)
{
var inFile = await _roamingCompteFile.LireByteArray();
var xmlIn = CryptUtils.AesDecryptByteArrayToString(inFile, ContexteStatic.CleChiffrement,
ContexteStatic.CleChiffrement);
var xsb = new XmlSerializer(typeof(RoamingCompteModel));
var rd = new StringReader(xmlIn);
_roamingCompte = xsb.Deserialize(rd) as RoamingCompteModel;
}
}
/// <summary>
/// Recharge les éléments pour la récupération de mot de passe
/// </summary>
/// <returns>les éléments</returns>
public static async Task <ImageUnlock> Load()
{
try
{
var inFile = await Fichier.LireByteArray();
var xmlIn = CryptUtils.AesDecryptByteArrayToString(inFile, password, salt);
var xsb = new XmlSerializer(typeof(ImageUnlock));
var rd = new StringReader(xmlIn);
return(xsb.Deserialize(rd) as ImageUnlock);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// Initialise le controleur
/// </summary>
/// <param name="fichier">le fichier à ouvrir contenant la liste des mots de passe</param>
/// <returns>la liste des mots de passes sinon null</returns>
public async Task Init(StorageFile fichier)
{
try
{
//lecture
var buffer = (await FileIO.ReadBufferAsync(fichier)).ToArray();
//déchiffrement
var data = CryptUtils.AesDecryptByteArrayToString(buffer, PartageViewModel.CryptKey, PartageViewModel.CryptSalt);
//deserialization
var xsb = new XmlSerializer(typeof(ObservableCollection <MotDePasse>));
var rd = new StringReader(data);
ListeMotDePasses = xsb.Deserialize(rd) as ObservableCollection <MotDePasse>;
IsLog = !string.IsNullOrEmpty(PasswordBusiness.Password);
}
catch
{
//Ignored
}
}
/// <summary>
/// importe les données
/// </summary>
/// <returns>true si ok</returns>
public async Task <bool> Restauration()
{
try
{
//deserialization
string xml;
if (IsMdp)
{
var buffer = await FileIO.ReadBufferAsync(Fichier);
byte[] inFile = buffer.ToArray();
xml = CryptUtils.AesDecryptByteArrayToString(inFile, MotDePasse, MotDePasse);
}
else
{
xml = await FileIO.ReadTextAsync(Fichier, Windows.Storage.Streams.UnicodeEncoding.Utf8);
}
var xsb = new XmlSerializer(typeof(SauvegardeModel));
var rd = new StringReader(xml);
var resultImport = xsb.Deserialize(rd) as SauvegardeModel;
//effacement des données
await _applicationBusiness.DeleteForRestauration();
//restauration
//appli
await _applicationBusiness.ChangeIdCouleurBackground(resultImport.Application.IdBackGround);
await _applicationBusiness.ChangeIdLangue(ListeLangues.GetLangueById(resultImport.Application.IdLangue));
ListeLangues.ChangeLangueAppli(resultImport.Application.IdLangue);
//banque et compte
foreach (var banque in resultImport.ListeBanque)
{
await _banqueBusiness.AjouterBanqueFmRestauration(banque);
foreach (var compte in banque.ListeCompte)
{
await _compteBusiness.AjouterCompteFmRestauration(compte);
}
}
//solde init
foreach (var soldeInitial in resultImport.ListeSoldeInit)
{
await _compteBusiness.AjouterSoldeInitialFmRestauration(soldeInitial);
}
//categorie
foreach (var category in resultImport.ListeCategorie)
{
await _categorieBusiness.AjouterCategorieFmRestauration(category);
}
//sous categorie
foreach (var sousCategory in resultImport.ListeSousCategorie)
{
await _categorieBusiness.AjouterSousCategorieFmRestauration(sousCategory);
}
//échéancier
foreach (var echeancier in resultImport.ListeEcheancier)
{
await _echeancierBusiness.AjouterEcheancierFmRestauration(echeancier);
}
//mouvement
foreach (var mouvement in resultImport.ListeMouvement)
{
await _mouvementBusiness.AjouterMouvementFmRestauration(mouvement);
}
//regénère les catégories
await ContexteAppli.GenerateCategorieMouvement();
}
catch (Exception)
{
return(false);
}
return(true);
}
