/// <summary>
/// Ajoute un film à une collection, et créer la collection si elle n'existe pas
/// </summary>
/// <param name="film">le film contenant es informations pour la collection (le titre de la collection et l'id internet de la collection si elle n'existe pas encore)</param>
/// <returns></returns>
public async Task AjouterFilmCollection(Film film)
{
//on ajoute le film à la collection où on la crée si elle n'existe pas
var collection = await GetCollectionByTitre(film.NomCollection);
if (collection != null)
{
//mise à jour du film
var f = await Bdd.Connection.Table <Film>().Where(x => x.Id == film.Id).FirstAsync();
f.IdCollection = collection.Id;
await Bdd.UpdateDonnee(f);
//mise à jour de l'ordre des films
await ReorganizeOrdreCollection(collection.Id);
}
else
{
//Création de la collection
var newCollec = new Collection
{
Id = await GetNewIdCollection(),
NomCollection = film.NomCollection,
IdCollectionInternet = film.IdCollectionInternet
};
await Bdd.AjouterDonnee(newCollec);
var f = await Bdd.Connection.Table <Film>().Where(x => x.Id == film.Id).FirstAsync();
f.IdCollection = newCollec.Id;
await Bdd.UpdateDonnee(f);
}
}
/// <summary>
/// Ajoute une sous catégorie provenant de l'outil s de restauration
/// </summary>
/// <param name="sousCategorie">la sous catégorie à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterSousCategorieFmRestauration(SousCategorie sousCategorie)
{
sousCategorie.IsSousCategPerso = true;
await Bdd.AjouterDonnee(sousCategorie);
await RoamingCategorieBusiness.AjouterSousCategorie(sousCategorie);
}
/// <summary>
/// Vérifie la dernière version installée, et sinon met à jour
/// </summary>
/// <returns></returns>
public async Task CheckVersion()
{
//on vérifie l'existence de la ligne appli
var nbLigne = await Bdd.Connection.Table <Application>().Where(x => x.Id >= 1).CountAsync();
if (nbLigne < 1)
{
var app = new Application {
Id = 1, Version = "1.0.0"
};
await Bdd.AjouterDonnee(app);
}
var res = await Bdd.Connection.Table <Application>().Where(x => x.Id == 1).FirstOrDefaultAsync();
if (res.Version != ContexteStatic.Version)
{
//si c'est une maj vers la version 1.2.0 recherche des collections, et maj des types
if (StringUtils.CheckVersion(res.Version, "1.2.0"))
{
try
{
await UpdateFilmForCollection();
await UpdateTypeFilm();
}
catch (Exception)
{
// ignored
}
}
res.Version = ContexteStatic.Version;
await Bdd.UpdateDonnee(res);
}
}
/// <summary>
/// Ajoute ou modifie en base un échéancier en base
/// </summary>
/// <param name="echeancier">l'échéancier à sauvegardé (Id à zéro pour un ajout)</param>
/// <returns>l'id de l'échéancier</returns>
public async Task <int> SaveEcheancier(Echeancier echeancier)
{
if (echeancier.Id == 0)
{
var echeancierId = await Bdd.Connection.Table <Echeancier>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (echeancierId != null)
{
id = echeancierId.Id + 1;
}
echeancier.Id = id;
echeancier.Date = new DateTime(echeancier.Date.Year, echeancier.Date.Month, echeancier.Date.Day);
if (echeancier.IsDateLimite)
{
echeancier.DateLimite = new DateTime(echeancier.DateLimite.Year, echeancier.DateLimite.Month, echeancier.DateLimite.Day);
}
await Bdd.AjouterDonnee(echeancier);
await RoamingEcheancierBusiness.AjouterEcheancierRoaming(echeancier);
}
else
{
await Bdd.UpdateDonnee(echeancier);
await RoamingEcheancierBusiness.ModifierEcheancierRoaming(echeancier);
}
return(echeancier.Id);
}
/// <summary>
/// Sauvegarde en base un mouvement provenant du roaming
/// </summary>
/// <param name="mouvement">le mouvement à sauvegarder</param>
/// <returns>l'id du nouveau mouvement sinon 0</returns>
public async Task <int> SaveMouvementFmRoaming(Mouvement mouvement)
{
//verifie si l'id comtpe et l'id du virement existe
if (await Bdd.Connection.Table <Compte>().Where(x => x.Id == mouvement.IdCompte).CountAsync() > 0)
{
var compteVirement = (await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.IdMouvementVirement).FirstOrDefaultAsync());
if ((mouvement.IdMouvementVirement != 0 && compteVirement != null && (await Bdd.Connection.Table <Compte>().Where(x => x.Id == compteVirement.IdCompte).CountAsync() > 0)) ||
mouvement.IdMouvementVirement == 0)
{
//ajout du mouvement
var mouvementId = await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (mouvementId != null)
{
id = mouvementId.Id + 1;
}
mouvement.Id = id;
await Bdd.AjouterDonnee(mouvement);
return(id);
}
}
return(0);
}
/// <summary>
/// Créer une personne en base de donnée
/// </summary>
/// <param name="personne">la personne à créer</param>
/// <returns>la personne ajouté en base avec l'id</returns>
private async Task <Personne> AddPersonne(Personne personne)
{
personne.Id = await GetNewIdPersonne();
await Bdd.AjouterDonnee(personne);
return(personne);
}
/// <summary>
/// Créer un genre de film en base de donnée
/// </summary>
/// <param name="genre">le genre à créer</param>
/// <returns>le genre ajouté en base avec l'id</returns>
private async Task <Genre> AddGenre(Genre genre)
{
genre.Id = await GetNewIdGenre();
await Bdd.AjouterDonnee(genre);
return(genre);
}
/// <summary>
/// Ajoute une catégorie provenant de l'outil s de restauration
/// </summary>
/// <param name="categorie">la catégorie à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterCategorieFmRestauration(Categorie categorie)
{
categorie.SousCategorieList = new List <SousCategorie>();
categorie.IsCategPerso = true;
await Bdd.AjouterDonnee(categorie);
await RoamingCategorieBusiness.AjouterCategorie(categorie);
}
/// <summary>
/// Inscrit en base qu'un utilisateur a passé un tuto
/// </summary>
/// <param name="idExercice">l'id de l'exercice</param>
/// <param name="idUtilisateur">l'id de l'utilisateur</param>
/// <returns></returns>
public async Task SaveTutoPasse(int idExercice, int idUtilisateur)
{
var tuto = new TutorielPasse
{
isPasse = true,
IdExercice = idExercice,
IdUtilisateur = idUtilisateur
};
tuto.GenerateId();
await Bdd.AjouterDonnee(tuto);
}
/// <summary>
/// Ajoute à la table des soldes initials un nouveau solde avec un id du compte
/// </summary>
/// <param name="solde">le solde</param>
/// <param name="idCompte">l'id du compte</param>
/// <returns>la task</returns>
public async Task AjouterSoldeInitial(double solde, int idCompte)
{
var obj = new SoldeInitial(idCompte, solde);
var soldeInitId = await Bdd.Connection.Table <SoldeInitial>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (soldeInitId != null)
{
id = soldeInitId.Id + 1;
}
obj.Id = id;
await Bdd.AjouterDonnee(obj);
}
/// <summary>
/// Sauvegarde un score à la fin d'un jeu
/// </summary>
/// <param name="idExercice">l'id de l'exercice ayant fait le score</param>
/// <param name="score">le score à sauvegardé</param>
/// <param name="nbSecondes">temps de résolution de l'exerice</param>
public async Task <Score> SaveScore(int idExercice, int score, int nbSecondes)
{
var scoreToSave = new Score
{
Date = DateUtils.GetMaintenant(),
IdExercice = idExercice,
Resultat = score,
IdUtilisateur = ContextAppli.ContextUtilisateur.EnCoursUser.Id,
NbSecondes = nbSecondes
};
scoreToSave.GenerateId();
await Bdd.AjouterDonnee(scoreToSave);
return(scoreToSave);
}
/// <summary>
/// Ajoute un compte en base
/// </summary>
/// <param name="compte">le compte à ajouter</param>
/// <returns>la task</returns>
public async Task <int> AjouterCompte(Compte compte)
{
var compteId = await Bdd.Connection.Table <Compte>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (compteId != null)
{
id = compteId.Id + 1;
}
compte.Id = id;
await Bdd.AjouterDonnee(compte);
await RoamingCompteBusiness.AjouterCompte(compte);
return(compte.Id);
}
/// <summary>
/// Ajoute une banque en base
/// </summary>
/// <param name="banque">la banque à ajouter</param>
/// <returns>la task</returns>
public async Task <Banque> AjouterBanque(Banque banque)
{
var banqueId = await Bdd.Connection.Table <Banque>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (banqueId != null)
{
id = banqueId.Id + 1;
}
banque.Id = id;
await Bdd.AjouterDonnee(banque);
await RoamingCompteBusiness.AjouterBanque(banque);
return(banque);
}
/// <summary>
/// Ajoute un utilisateur
/// </summary>
/// <param name="nom">le nom du nouvel utilisateur</param>
/// <param name="dateNaissance">la date de naissance du nouvel utilisateur</param>
/// <returns>l'utilisateur crée</returns>
public async Task <User> InsertUser(string nom, DateTime dateNaissance)
{
var userId = await Bdd.Connection.Table <User>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (userId != null)
{
id = userId.Id + 1;
}
var user = new User {
Id = id, Nom = nom, DateNaissance = dateNaissance
};
await Bdd.AjouterDonnee(user);
return(user);
}
/// <summary>
/// Ajoute un mouvement en base, ou le met à jour si déjà existant
/// </summary>
/// <param name="mouvement">le mouvement à ajouter avec l'id à 0 pour ajout, sinon l'id véritable</param>
/// <returns>l'id du mouvement ajouter/updater</returns>
public async Task <int> SaveMouvement(Mouvement mouvement)
{
//si c'est un nouveau mouvement creation
if (mouvement.Id == 0)
{
var mouvementId =
await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (mouvementId != null)
{
id = mouvementId.Id + 1;
}
mouvement.Id = id;
mouvement.IsPasse = false;
await Bdd.AjouterDonnee(mouvement);
await CalculerSolde(mouvement, null);
return(id);
}
else
{
var oldMouvement = await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.Id).FirstOrDefaultAsync();
//si le mouvement à metre à jour est un ancien virement
if (mouvement.IdMouvementVirement > 0)
{
var mouvementToDelete = await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.IdMouvementVirement).FirstOrDefaultAsync();
await Bdd.DeleteDonnee(mouvementToDelete);
mouvement.IdMouvementVirement = 0;
await CalculerSolde(null, mouvementToDelete);
}
await Bdd.UpdateDonnee(mouvement);
await CalculerSolde(mouvement, oldMouvement);
return(mouvement.Id);
}
}
/// <summary>
/// Ajoute une catégorie en base
/// </summary>
/// <param name="libelle">le libelle de la catégorie à ajouter</param>
/// <returns>la catégorie créer</returns>
public async Task <Categorie> AddCategorie(string libelle)
{
var categorie = new Categorie();
var categId = await Bdd.Connection.Table <Categorie>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (categId != null)
{
id = categId.Id + 1;
}
categorie.Id = id;
categorie.IsCategPerso = true;
categorie.Libelle = libelle;
categorie.SousCategorieList = new List <SousCategorie>();
await Bdd.AjouterDonnee(categorie);
await RoamingCategorieBusiness.AjouterCategorie(categorie);
return(categorie);
}
/// <summary>
/// Créer une sous catégorie perso
/// </summary>
/// <param name="libelle">le libelle de la sous catégorie</param>
/// <param name="idCategorie">l'id de la catégorie mère</param>
/// <param name="isCategoriePerso">si la catégorie mère est perso ou non</param>
/// <returns>la sous catégorie de créer</returns>
public async Task <SousCategorie> AddSousCategorie(string libelle, int idCategorie, bool isCategoriePerso)
{
var sousCategorie = new SousCategorie();
var sousCategId = await Bdd.Connection.Table <SousCategorie>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (sousCategId != null)
{
id = sousCategId.Id + 1;
}
sousCategorie.Id = id;
sousCategorie.Libelle = libelle;
sousCategorie.IdCategorie = idCategorie;
sousCategorie.IsCategPerso = isCategoriePerso;
sousCategorie.IsSousCategPerso = true;
await Bdd.AjouterDonnee(sousCategorie);
await RoamingCategorieBusiness.AjouterSousCategorie(sousCategorie);
return(sousCategorie);
}
/// <summary>
/// Ajoute un mouvement provenant de l'outil de restauration
/// </summary>
/// <param name="mouvement">le mouvement à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterMouvementFmRestauration(Mouvement mouvement)
{
await Bdd.AjouterDonnee(mouvement);
}
/// <summary>
/// Sauvegarde un virement
/// </summary>
/// <param name="mouvement">le mouvement d'origine du virement</param>
/// <param name="idCompte">l'id du compte sur lequel s'effectue sur le virement</param>
/// <returns>la task</returns>
public async Task SaveVirement(Mouvement mouvement, int idCompte)
{
var create = mouvement.Id == 0;
Mouvement mouvementA;
Mouvement mouvementB;
//mise à jour
if (!create)
{
var mouvementAOld =
await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.Id).FirstOrDefaultAsync();
var mouvementBOld =
await
Bdd.Connection.Table <Mouvement>()
.Where(x => x.Id == mouvementAOld.IdMouvementVirement)
.FirstOrDefaultAsync();
var idDeviseA =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == mouvementAOld.IdCompte).FirstOrDefaultAsync())
.IdDevise;
var idDeviseB =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == idCompte).FirstOrDefaultAsync())
.IdDevise;
await Bdd.DeleteDonnee(mouvementBOld);
await CalculerSolde(null, mouvementBOld);
mouvementA = mouvement;
mouvementB = new Mouvement
{
Id = 0,
Commentaire = mouvementA.Commentaire,
Credit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Debit),
Debit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Credit),
Date = mouvementA.Date,
IdCompte = idCompte,
ModeMouvement = mouvementA.ModeMouvement,
Numero = mouvementA.Numero,
IdType = mouvementA.IdType,
IsTypePerso = mouvementA.IsTypePerso
};
var idMax = 0;
var residR = (await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync());
if (residR != null)
{
idMax = residR.Id;
}
var mouvementBId = idMax + 1;
mouvementA.IdMouvementVirement = mouvementBId;
mouvementB.Id = mouvementBId;
mouvementB.IdMouvementVirement = mouvementA.Id;
await Bdd.UpdateDonnee(mouvementA);
await CalculerSolde(mouvementA, mouvementAOld);
await Bdd.AjouterDonnee(mouvementB);
await CalculerSolde(mouvementB, null);
}
else //création
{
mouvementA = mouvement;
var idDeviseA =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == mouvementA.IdCompte).FirstOrDefaultAsync())
.IdDevise;
var idDeviseB =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == idCompte).FirstOrDefaultAsync())
.IdDevise;
mouvementB = new Mouvement
{
Id = 0,
Commentaire = mouvementA.Commentaire,
Credit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Debit),
Debit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Credit),
Date = mouvementA.Date,
IdCompte = idCompte,
ModeMouvement = mouvementA.ModeMouvement,
Numero = mouvementA.Numero,
IdType = mouvementA.IdType,
IsTypePerso = mouvementA.IsTypePerso
};
var idMax = 0;
var residR = (await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync());
if (residR != null)
{
idMax = residR.Id;
}
var mouvementAId = idMax + 1;
var mouvementBId = idMax + 2;
mouvementA.Id = mouvementAId;
mouvementA.IdMouvementVirement = mouvementBId;
mouvementB.Id = mouvementBId;
mouvementB.IdMouvementVirement = mouvementAId;
await Bdd.AjouterDonnee(mouvementA);
await CalculerSolde(mouvementA, null);
await Bdd.AjouterDonnee(mouvementB);
await CalculerSolde(mouvementB, null);
}
}
/// <summary>
/// Ajoute une banque en base
/// </summary>
/// <param name="banque">la banque à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterBanqueFmRestauration(Banque banque)
{
await Bdd.AjouterDonnee(banque);
await RoamingCompteBusiness.AjouterBanque(banque);
}
/// <summary>
/// Créer la base de donnée à partir des données présentes dans le fihier Roaming
/// </summary>
/// <returns>las task</returns>
public async Task CreerBaseDeDonneeFromRoaming(AppareilEnum appareil)
{
//creer la base
await CreerBase(appareil);
if (appareil == AppareilEnum.ModeAppareilPrincipal)
{
//ajout des banques et des comptes
var listeBanques = await RoamingCompteBusiness.GetListeBanques();
foreach (var banque in listeBanques)
{
// ajout de la banque
var banqueId = await Bdd.Connection.Table <Banque>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var idbanque = 1;
if (banqueId != null)
{
idbanque = banqueId.Id + 1;
}
banque.Id = idbanque;
await Bdd.AjouterDonnee(banque);
//ajout des comtpes
foreach (var compte in banque.ListeCompte)
{
var compteId = await Bdd.Connection.Table <Compte>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (compteId != null)
{
id = compteId.Id + 1;
}
compte.Id = id;
compte.IdBanque = banque.Id;
await Bdd.AjouterDonnee(compte);
}
}
//Ajout des échéanciers
var listeEcheancier = await RoamingEcheancierBusiness.GetAllEcheancier();
foreach (var echeancier in listeEcheancier)
{
await Bdd.AjouterDonnee(echeancier);
}
//ajout des catégories perso
var listeCategorie = await RoamingCategorieBusiness.GetCategorieRoaming();
foreach (var category in listeCategorie)
{
await Bdd.AjouterDonnee(category);
}
var listeSousCategorie = await RoamingCategorieBusiness.GetSousCategorieRoaming();
foreach (var sousCategory in listeSousCategorie)
{
await Bdd.AjouterDonnee(sousCategory);
}
}
}
/// <summary>
/// Ajoute une échéancier provenant de l'outil de restauration
/// </summary>
/// <param name="echeancier"> l'échéancier à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterEcheancierFmRestauration(Echeancier echeancier)
{
await Bdd.AjouterDonnee(echeancier);
await RoamingEcheancierBusiness.AjouterEcheancierRoaming(echeancier);
}
/// <summary>
/// Ajoute une solde initial provenant de la restauration
/// </summary>
/// <param name="soldeinitial">la solde initial</param>
/// <returns>la task</returns>
public async Task AjouterSoldeInitialFmRestauration(SoldeInitial soldeinitial)
{
await Bdd.AjouterDonnee(soldeinitial);
}
/// <summary>
/// Ajoute un compte provenant des données de restauration
/// </summary>
/// <param name="compte">le compte à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterCompteFmRestauration(Compte compte)
{
await Bdd.AjouterDonnee(compte);
await RoamingCompteBusiness.AjouterCompte(compte);
}
/// <summary>
/// Sauvegarde un film en base
/// </summary>
/// <param name="film">le film à sauvegarder</param>
/// <returns></returns>
public async Task SaveFilm(Film film)
{
var isCreate = film.Id == 0;
//si création, récup d'un nouvel ID
if (isCreate)
{
film.Id = await GetNewIdFilm();
}
else
{
//si modif, on efface les tables de jointures genre/ personne du film
await RemoveGenreFilm(film);
await RemovePersonneFilm(film);
//et on efface l'id de la collection éventuelle à laquelle il peut appartenir
if (film.IdCollection > 0)
{
await SupprimerFilmCollection(film.Id);
}
}
//Création des genres s'ils n'existent pas, puis jointure avec le film
foreach (var genre in film.Genres)
{
if (genre.Id == 0)
{
var newGenre = await AddGenre(genre);
genre.Id = newGenre.Id;
}
var joinFilmGenre = new GenreFilm
{
Id = await GetNewIdGenreFilm(),
IdFilm = film.Id,
IdGenre = genre.Id
};
await Bdd.AjouterDonnee(joinFilmGenre);
}
//Création de la liste des acteurs
if (film.Acteurs != null && film.Acteurs.Count > 0)
{
foreach (var personne in film.Acteurs)
{
var res = await SearchPersonne(personne.Nom);
if (res == null)
{
var newPersonne = await AddPersonne(personne);
personne.Id = newPersonne.Id;
}
else
{
personne.Id = res.Id;
}
var personneFilm = new PersonneFilm
{
Id = await GetNewIdPersonneFilm(),
IdFilm = film.Id,
IdPersonne = personne.Id,
Role = (int)TypePersonneEnum.ACTEUR
};
await Bdd.AjouterDonnee(personneFilm);
}
}
//Création de la liste des producteurs
if (film.Producteurs != null && film.Producteurs.Count > 0)
{
foreach (var personne in film.Producteurs)
{
var res = await SearchPersonne(personne.Nom);
if (res == null)
{
var newPersonne = await AddPersonne(personne);
personne.Id = newPersonne.Id;
}
else
{
personne.Id = res.Id;
}
var personneFilm = new PersonneFilm
{
Id = await GetNewIdPersonneFilm(),
IdFilm = film.Id,
IdPersonne = personne.Id,
Role = (int)TypePersonneEnum.PRODUCTEUR
};
await Bdd.AjouterDonnee(personneFilm);
}
}
//Création de la liste des réalisateurs
if (film.Realisateurs != null && film.Realisateurs.Count > 0)
{
foreach (var personne in film.Realisateurs)
{
var res = await SearchPersonne(personne.Nom);
if (res == null)
{
var newPersonne = await AddPersonne(personne);
personne.Id = newPersonne.Id;
}
else
{
personne.Id = res.Id;
}
var personneFilm = new PersonneFilm
{
Id = await GetNewIdPersonneFilm(),
IdFilm = film.Id,
IdPersonne = personne.Id,
Role = (int)TypePersonneEnum.REALISATEUR
};
await Bdd.AjouterDonnee(personneFilm);
}
}
//Création du film en base
if (isCreate)
{
await Bdd.AjouterDonnee(film);
}
else
{
await Bdd.UpdateDonnee(film);
}
//si le film doit appartenir à une collection, lien avec cette dernière
if (!string.IsNullOrEmpty(film.NomCollection))
{
await AjouterFilmCollection(film);
}
}