Esempio n. 1
0
        /// <summary>
        /// Recalcul la solde d'un compte après l'ajout ou la modification d'un mouvement
        /// </summary>
        /// <param name="mouvement">le mouvement (null pour une suppresion de mouvement)</param>
        /// <param name="oldMouvement">l'ancien mouvement (null si ajout)</param>
        /// <returns>la task</returns>
        private static async Task CalculerSolde(Mouvement mouvement, Mouvement oldMouvement)
        {
            var idCompte = mouvement?.IdCompte ?? oldMouvement.IdCompte;
            var compte   = await RoamingCompteBusiness.GetCompte(idCompte);

            //si c'est une modification, on efface la prise en compte de l'ancienne valeur
            if (oldMouvement != null)
            {
                if (oldMouvement.Credit > 0)
                {
                    compte.Solde -= oldMouvement.Credit;
                }
                else
                {
                    compte.Solde += oldMouvement.Debit;
                }
            }

            if (mouvement != null)
            {
                //ajout de la nouvelle valeur
                if (mouvement.Credit > 0)
                {
                    compte.Solde += mouvement.Credit;
                }
                else
                {
                    compte.Solde -= mouvement.Debit;
                }
            }

            await RoamingCompteBusiness.ModifierCompte(compte);
        }
Esempio n. 2
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 static async Task SaveVirement(Mouvement mouvement, int idCompte)
        {
            await DemarrageRoaming();

            var       create = mouvement.Id == 0;
            Mouvement mouvementA;
            Mouvement mouvementB;

            //mise à jour
            if (!create)
            {
                await SupprimerMouvementRoaming(mouvement.Id);

                mouvement.Id = 0;
            }
            mouvementA = mouvement;

            var idA = await AjouterMouvementRoaming(mouvementA);

            var idDeviseA = (await RoamingCompteBusiness.GetCompte(mouvementA.IdCompte)).IdDevise;
            var idDeviseB = (await RoamingCompteBusiness.GetCompte(idCompte)).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,
                IdMouvementVirement = idA
            };

            var idB = await AjouterMouvementRoaming(mouvementB);

            mouvementA.Id = idA;
            mouvementA.IdMouvementVirement = idB;
            await ModifierMouvementRoaming(mouvementA);
        }
Esempio n. 3
0
        /// <summary>
        /// Retourne la liste des mouvements en roaming
        /// </summary>
        /// <param name="idCompte">l'id du compte dont on cherche les mouvements</param>
        /// <returns>la liste des mouvements associés au compte</returns>
        public static async Task <List <Mouvement> > GetMouvementsRoaming(int idCompte)
        {
            await DemarrageRoaming();

            var devise = await RoamingCompteBusiness.GetDevise(idCompte);

            var retour = _roamingMouvement.ListeMouvement.Where(x => x.IdCompte == idCompte).ToList();

            foreach (var mouv in retour)
            {
                mouv.MouvementChiffre = ((mouv.Credit > 0) ? "+" + mouv.Credit : "-" + mouv.Debit) + " " + devise;
                mouv.Type             =
                    ContexteAppli.ListeCategoriesMouvement.SelectMany(
                        varA =>
                        varA.SousCategorieList.Where(
                            varB => varB.Id == mouv.IdType && varB.IsSousCategPerso == mouv.IsTypePerso))
                    .FirstOrDefault();
            }

            return(retour);
        }