/// <summary>
/// Efface une sous categorie
/// </summary>
/// <param name="idSousCategorie">l'id de la sous categorie</param>
/// <returns></returns>
public async Task DeleteSousCategorie(int idSousCategorie)
{
var sousCateg = await Bdd.Connection.Table <SousCategorie>().Where(x => x.Id == idSousCategorie).FirstOrDefaultAsync();
await Bdd.DeleteDonnee(sousCateg);
await RoamingCategorieBusiness.SupprimerSousCategorie(sousCateg);
}
/// <summary>
/// Supprimer un échéancier de la base de donnée
/// </summary>
/// <param name="idEcheancier">l'id de l'échéancier à supprimer</param>
/// <returns>la task</returns>
public async Task SupprimerEcheancier(int idEcheancier)
{
var obj = await Bdd.Connection.Table <Echeancier>().Where(x => x.Id == idEcheancier).FirstOrDefaultAsync();
await Bdd.DeleteDonnee(obj);
await RoamingEcheancierBusiness.SupprimerEcheancier(obj);
}
/// <summary>
/// Supprime un film de la base de donnée
/// </summary>
/// <param name="film">le film à supprimer</param>
/// <returns></returns>
public async Task SupprimerFilm(Film film)
{
await RemoveGenreFilm(film);
await RemovePersonneFilm(film);
await SupprimerFilmCollection(film.Id);
await Bdd.DeleteDonnee(film);
}
/// <summary>
/// efface une categorie
/// </summary>
/// <param name="idCategorie">la catégorie à effacer</param>
/// <returns></returns>
public async Task DeleteCategorie(int idCategorie)
{
var categ = await Bdd.Connection.Table <Categorie>().Where(x => x.Id == idCategorie).FirstOrDefaultAsync();
var listeSousCateg = await Bdd.Connection.Table <SousCategorie>().Where(x => x.IdCategorie == idCategorie).ToListAsync();
await Bdd.DeleteDonnee(categ);
foreach (var sousCategory in listeSousCateg)
{
await DeleteSousCategorie(sousCategory.Id);
}
await RoamingCategorieBusiness.SupprimerCategorie(categ);
}
/// <summary>
/// Supprime une banque de la base de donnée et du roaming
/// </summary>
/// <param name="banque">la banque à supprimer</param>
/// <returns>la task</returns>
public async Task SupprimerBanque(Banque banque)
{
var comptes = await Bdd.Connection.Table <Compte>().Where(x => x.IdBanque == banque.Id).ToListAsync();
var compteBusiness = new CompteBusiness();
await compteBusiness.Initialization;
foreach (var compte in comptes)
{
await compteBusiness.SupprimerCompte(compte);
}
if (await Bdd.DeleteDonnee(banque) > 0)
{
await RoamingCompteBusiness.SupprimerBanque(banque);
}
}
/// <summary>
/// efface les scores puis l'utilisateur
/// </summary>
/// <param name="user">l'utilisateur a effacer</param>
/// <returns>le nombre de ligne affectés</returns>
public async Task <int> DeleteUser(User user)
{
var scoreToDel = await Bdd.Connection.Table <Score>().Where(x => x.IdUtilisateur == user.Id).ToListAsync();
if (scoreToDel != null && scoreToDel.Count > 0)
{
await Bdd.DeleteListeDonnee(scoreToDel);
}
var tutoPasseToDel = await Bdd.Connection.Table <TutorielPasse>().Where(x => x.IdUtilisateur == user.Id).ToListAsync();
if (tutoPasseToDel != null && tutoPasseToDel.Count > 0)
{
await Bdd.DeleteListeDonnee(tutoPasseToDel);
}
return(await Bdd.DeleteDonnee(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>
/// Supprimer un compte de la base puis du roaming
/// </summary>
/// <param name="compte">le compte à supprimer</param>
/// <returns>la task</returns>
public async Task SupprimerCompte(Compte compte)
{
if (await Bdd.DeleteDonnee(compte) > 0)
{
//supression du compte
await SupprimerMouvementsCompte(compte.Id);
//supression des échéanciers lié au compte
var echeancierBusiness = new EcheancierBusiness();
await echeancierBusiness.Initialization;
var listeEcheancier =
await
Bdd.Connection.Table <Echeancier>()
.Where(x => x.IdCompte == compte.Id || x.IdCompteVirement == compte.Id).ToListAsync();
await echeancierBusiness.SupprimerEcheancier(listeEcheancier);
//supression en roaming
await RoamingCompteBusiness.SupprimerCompte(compte);
}
}
/// <summary>
/// Supprime un mouvement du compte
/// </summary>
/// <param name="idMouvement">l'id du mouvement à supprimer</param>
/// <returns>la task</returns>
public async Task SupprimerMouvement(int idMouvement)
{
var mouvement =
await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == idMouvement).FirstOrDefaultAsync();
await Bdd.DeleteDonnee(mouvement);
await CalculerSolde(null, mouvement);
//supression en cas de virement
if (mouvement.IdMouvementVirement > 0)
{
var mouvementB =
await
Bdd.Connection.Table <Mouvement>()
.Where(x => x.Id == mouvement.IdMouvementVirement)
.FirstOrDefaultAsync();
await Bdd.DeleteDonnee(mouvementB);
await CalculerSolde(null, mouvementB);
}
}
/// <summary>
/// Supprime un film d'une collection et la collection avec si le film est le dernier y appartemant
/// </summary>
/// <param name="idFilm">l'id du film concerné</param>
/// <returns></returns>
private async Task SupprimerFilmCollection(int idFilm)
{
if (await Bdd.Connection.Table <Film>().Where(x => x.Id == idFilm).CountAsync() > 0)
{
var film = await Bdd.Connection.Table <Film>().Where(x => x.Id == idFilm).FirstAsync();
//si il n'y a plus qu'une seule occurence du film lié à la la collection, on supprime la collection avant de supprimer le film de la collection
if (await Bdd.Connection.Table <Film>().Where(x => x.IdCollection == film.IdCollection).CountAsync() == 1)
{
if (await Bdd.Connection.Table <Collection>().Where(x => x.Id == film.IdCollection).CountAsync() > 0)
{
var collec = await Bdd.Connection.Table <Collection>().Where(x => x.Id == film.IdCollection).FirstAsync();
await Bdd.DeleteDonnee(collec);
}
}
//supression du film de la liste des films de la collection
film.IdCollection = 0;
film.OrdreCollection = 0;
await Bdd.UpdateDonnee(film);
}
}
/// <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);
}
}
