コード例 #1
0
        // Production des refinancements
        public IList<SoldeBudget> Make(IQueryable<Budget> _budgets, DateTime dateArchivage)
        {
            // EnrichirAvecNbreContratsEtPeriodeFinancementRestantes
            var e1 = new BudgetContratEnrichisseur(uow, groupeId);
            var _budgetAvecContrats = e1.EnrichirAvecNbreContratsEtPeriodeFinancementRestantes(_budgets);

            // Constitution des feeds à partir des budgets
            IList<SoldeBudget> _soldeBudgets = InitSoldeBudgets(_budgetAvecContrats);

            // Inputs: opérations - mouvements - financements - échéances à venir
            FacadeRepo facade = new FacadeRepo(uow, groupeId);
            InputSoldeBudgets _inputs = facade.InputSoldeBudgetsForRefi(dateArchivage);

            // Mouvements à venir
            var f1 = new ProvisionFabrique(uow, groupeId);
            _inputs.mouvementAVenirs = f1.CalculerMouvementsAVenir(_budgetAvecContrats);

            // Enrichissement des soldes budgets avec les montants
            var s1 = new SoldeBudgetMontantsEnrichisseur();
            s1.EnrichirMontants(_soldeBudgets, _inputs);

            // Calcul des soldes courant & écart financement
            foreach (var _solde in _soldeBudgets)
            {
                _solde.Calculer();
            }

            // Retour
            return _soldeBudgets;
        }
コード例 #2
0
        // Calcul des soldes opérations pour une série d'opérations et une série de comte banque
        public void EnrichirAvecSoldeArchivable(IEnumerable<Budget> budgets)
        {
            // Reset solde opérations
            budgets.ToList().ForEach(c => c.SoldeOperationArchivables = 0.0M);
            budgets.ToList().ForEach(c => c.SoldeFinancementArchivables = 0.0M);
            budgets.ToList().ForEach(c => c.SoldeProvisionArchivables = 0.0M);
            budgets.ToList().ForEach(c => c.SoldeArchivable = 0.0M);

            // Contrats
            var s1 = new BudgetContratEnrichisseur(uow, groupeId);
            s1.EnrichirAvecNbContrats(budgets);

            // Inputs: opérations
            FacadeRepo facade = new FacadeRepo(uow, groupeId);
            InputSoldeBudgets inputs = facade.InputSoldeArchivableBudgets(dateLimiteArchivage);

            // Enrichissement solde des opérations
            var enrichisseur = new BudgetSoldeOperationArchivableEnrichisseur();
            enrichisseur.Executer(inputs, budgets);

            // Enrichissement solde archive
            foreach (var budget in budgets)
            {
                budget.EnrichirAvecSoldeArchivable();
            }
        }
コード例 #3
0
ファイル: Budget.cs プロジェクト: paulkornikov/Pragonas
        public IQueryable<Budget> BudgetsActifEtInactifsAvecContrats()
        {
            IEnumerable<Budget> budgets = uow.Budget
                .GetAllByGroupeId(ProfileUser.GroupeId)
                .ToList()
                ;

            // Création du service
            BudgetContratEnrichisseur service = new BudgetContratEnrichisseur(uow, ProfileUser.GroupeId);

            // Récupération des budgets avec compteurs
            IQueryable<Budget> budgetAvecContrats = service
                .EnrichirAvecContratsActifs(budgets)
                .AsQueryable<Budget>();

            return budgetAvecContrats;
        }
コード例 #4
0
ファイル: Budget.cs プロジェクト: paulkornikov/Pragonas
        public IQueryable<Budget> BudgetReservesAvecSoldesCalcules()
        {
            // Budgets réserve
            IEnumerable<Budget> _budgets = uow.Budget
                .GetAllByGroupeId(ProfileUser.GroupeId)
                .Where(b => b.IsActive == true)
                .Where(b => b.IsBudgetEquilibre == true || b.TypeNonAlloue == true)
                .ToList()
                ;

            // Récupération des budgets avec compteurs
            var s0 = new BudgetContratEnrichisseur(uow, ProfileUser.GroupeId);
            s0.EnrichirAvecNbContrats(_budgets);

            // Récupération des budgets avec compteurs
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);
            var service = new BudgetSoldeCalculeAvecArchiveServices(uow, ProfileUser.GroupeId, _dateArchivage, _limite);
            service.EnrichirAvecSoldeCalculeAvecArchive(_budgets);

            return _budgets.AsQueryable<Budget>();
        }
コード例 #5
0
        // EnrichirRawsAvecSpecCandidates
        private IEnumerable<OperationRawSG> EnrichirRawsAvecSpecCandidates(Chargement chargement)
        {
            //// Récupération des raws du référentiel des rappros pour le compte associé au chargement
            IQueryable<RapproRaw> referentielRappros = uow.RapproRaw.GetAll()
                    .Include(r => r.RawSG)
                    .Include(r => r.Operation.CompteB)
                    .Include(r => r.Operation.MoyenPaiementCompteA)
                    .Include(r => r.Operation.MoyenPaiementCompteB)
                    .Where(r => r.RawSG.CompteId == chargement.CompteId)
                    .Where(r => r.Operation.CompteB.IsActive == true)
                    ;

            // Raws non rapprochées - Pas seulement celles du dernier chargement
            IList<OperationRawSG> rawsNonRapprochees = uow.OperationRawSG
                .GetAllRapprochablesByGroupeId(groupeId)
                .OrderBy(r => r.Valorisee)
                .ToList()
                ;

            // Il faut ramener les contrats des budgets avant de travailler sur les raws
            IEnumerable<Budget> budgets = uow.Budget
                .GetAllByGroupeId(groupeId)
                .ToList()
                ;

            BudgetContratEnrichisseur budgetContratService = new BudgetContratEnrichisseur(uow, groupeId);
            IEnumerable<Budget> _budgetAvecContrats = budgetContratService
                .EnrichirAvecContratsActifs(budgets);

            // Enrichissement avec budgets ou caisses pour toutes les raws du groupe non rapprochées
            return rawEnrichisseur.EnrichirAvecSpecCandidates(rawsNonRapprochees, referentielRappros);
        }
コード例 #6
0
        public RapportAuditSoldeDtoJSon GetRapportAuditSolde(int _GroupeId)
        {
            // Comptes caisses et budegts
            // Comptes banque
            IEnumerable<CompteBanque> _comptes = uow.CompteBanque
                .GetAllByGroupeId(_GroupeId)
                .Include(x => x.Banque)
                .ToList()
                ;

            // Calcul date archivage
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);

            // Création du service
            var service = new CompteBanqueSoldeCalculeAvecArchiveServices(uow, _GroupeId
                , _dateArchivage, _limite);

            // Récupération des budgets avec compteurs
            service.EnrichirAvecSoldeCalculeAvecArchive(_comptes);
            var s20 = new CompteBanqueRawSoldeCalculeServices(uow, _GroupeId);
            s20.EnrichirAvecSoldeCalcules(_comptes);

            // Caisses
            IEnumerable<Caisse> _caisses = uow.CompteCaisse
                .GetAllByGroupeId(_GroupeId)
                .ToList()
                ;
            var s2 = new CaisseSoldeCalculeAvecArchiveServices(uow, _GroupeId, _dateArchivage, _limite);
            s2.EnrichirAvecSoldeCalculeAvecArchive(_caisses);

            // Budgets
            IEnumerable<Budget> _budgets = uow.Budget
                .GetAllByGroupeId(_GroupeId)
                .ToList()
                ;
            // Enrichissement budgets avec solde Contrat calculés
            var s0 = new BudgetContratEnrichisseur(uow, _GroupeId);
            s0.EnrichirAvecNbContrats(_budgets);
            var s1 = new BudgetSoldeCalculeAvecArchiveServices(uow, _GroupeId, _dateArchivage, _limite);
            s1.EnrichirAvecSoldeCalculeAvecArchive(_budgets);

            // Retour
            return new RapportAuditSoldeDtoJSon(_comptes, _caisses, _budgets);
        }
コード例 #7
0
        // EnrichirRawsAvecSpecCandidates
        private void EnrichirReferentielRapproRaws(int compteId)
        {
            //// Récupération des raws du référentiel des rappros pour le compte associé au chargement
            IQueryable<RapproRaw> referentiel = uow.RapproRaw.GetAll()
                    .Include(r => r.RawSG)
                    .Include(r => r.Operation.CompteB)
                    .Include(r => r.Operation.MoyenPaiementCompteA)
                    .Include(r => r.Operation.MoyenPaiementCompteB)
                    .Where(r => r.RawSG.CompteId == compteId)
                    .Where(r => r.Operation.CompteB.IsActive == true)
                    ;

            // Raws non rapprochées - Pas seulement celles du dernier chargement
            IList<OperationRawSG> raws = uow.OperationRawSG
                .GetAllRapprochablesByGroupeId(groupeId)
                .OrderBy(r => r.Valorisee)
                .ToList()
                ;

            // Enrichir budgets
            var enr = new BudgetContratEnrichisseur(uow, groupeId);
            var budgets = uow.Budget.GetAllByGroupeId(groupeId).ToList();
            var _budgetAvecContrats = enr.EnrichirAvecContratsActifs(budgets);

            // Enrichissement avec budgets ou caisses pour toutes les raws du groupe non rapprochées
            var enrRaw = new RawEnrichisseur(uow, fabriqueSpec);
            var _raws = enrRaw.EnrichirAvecSpecCandidates(raws, referentiel);
        }