Beispiel #1
0
        /// <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);
        }
Beispiel #2
0
        /// <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);
        }
Beispiel #3
0
        /// <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);
        }
Beispiel #4
0
        /// <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);
        }
Beispiel #5
0
        /// <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);
            }
        }
Beispiel #6
0
        /// <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));
        }
Beispiel #7
0
        /// <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);
            }
        }
Beispiel #8
0
        /// <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);
            }
        }
Beispiel #9
0
        /// <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);
            }
        }
Beispiel #10
0
        /// <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);
            }
        }
Beispiel #11
0
        /// <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);
            }
        }