Exemple #1
0
        public IEnumerable<AlerteEcartSoldeRaw> AlertesEcartSoldeRaw()
        {
            var groupeId = ProfileUser.GroupeId;

            // 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
            var comptes = uow.CompteBanque.GetAllByGroupeId(groupeId);
            service.EnrichirAvecSoldeCalculeAvecArchive(comptes);

            var s2 = new CompteBanqueRawSoldeCalculeServices(uow, groupeId);
            s2.EnrichirAvecSoldeCalcules(comptes);

            // Fabrique des alertes
            var fabrique = new AlerteEcartSoldeRawFabrique(uow, groupeId);
            var alertes = fabrique.GetAlertes(comptes.ToList());

            // Retour
            return alertes;
        }
 public override TraceLog Echec(DateTime dtCrea, int nbEntites, string rapport)
 {
     ServiceDate svc = new ServiceDate();
     string libelle = "Provision du mois "
         + svc.LibelleMoisInFrench(dtCrea.Month)
         + " "
         + dtCrea.Year;
     return new TraceLog(groupeId, dtCrea, "Provision", libelle, nbEntites, "#echec", rapport);
 }
        public IQueryable<Reajustement> GetReajustements()
        {
            // Calcul date archivage
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);

            // Calcul des réajustements
            ReajustementServices services = new ReajustementServices(uow, ProfileUser.GroupeId);
            return services.Produire(_limite);
        }
        // Produire le calendrier des dates de provisionnement
        // à partir de la date de la dernière exécution
        // et jusqu'à la date de la dernière exécution possible par rapport à date jour
        public List<DateTime> GetCalendrier(ServiceDate svcDate)
        {
            // Calcul du calendrier cible
            var cible = GetCalendrierCible(svcDate);

            // Calcul du calendrier réalisé
            var realise = GetCalendrierRealise();

            // Init du calendrier
            return svcDate.GetCalendrierDifference(cible, realise);
        }
Exemple #5
0
        public IQueryable<Imputation> GetImputations()
        {
            // Calcul date archivage
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);

            // Calcul des écarts
            var services = new ImputationService(uow, ProfileUser.GroupeId);
            return services.Produire(_limite);
        }
        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);
        }
Exemple #7
0
        public IQueryable<Caisse> CaissesCalcules()
        {
            // Caisses
            IEnumerable<Caisse> caisses = uow.CompteCaisse
                .GetAllByGroupeId(ProfileUser.GroupeId)
                .ToList()
                ;

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

            return caisses.AsQueryable<Caisse>();
        }
Exemple #8
0
        public Caisse CaissesCalcule(int id)
        {
            // Caisses
            List<Caisse> caisses = new List<Caisse>();
            Caisse caisse = uow.CompteCaisse
                .GetById(id)
                ;
            caisses.Add(caisse);

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

            return caisse;
        }
        // Exécution batch prolongation budgets
        public void Executer()
        {
            // Date exécution: égale à la fin du mois qui précède la date du jour
            var scvDate = new ServiceDate();
            var current = scvDate.GetDerniereDateMoisPrecedent();

            // Récupération des budgets A terme
            var service = new EcheanceService(uow, groupeId);
            var echeances = service.ImputationsEchues(current);

            // Pour chaque budget dans la liste, exécuter le processus
            // puis tracer
            foreach (var echeance in echeances)
            {
                // Exécuter process
                echeance.Annuler();
            }

            // Report des résidus sur imputations suivantes
            var nextImputations = service.NextActiveImputations(current);
            foreach (var ech in echeances) {
                foreach (var imp in nextImputations)
                {
                    if (ech.ContratId == imp.ContratId)
                    {
                        ech.Montant += imp.Montant;
                    };
                }
            }

            // Tracer le processus
            if (echeances.Count() > 0)
            {
                var traceur = new AnnulationImputationTraceur(groupeId);
                string rapport = traceur.SaveForRapportSuccess(current, echeances);
                int nb = echeances.Count();
                TraceLog trace = traceur.Success(current, nb, rapport);

                // Ajout repo
                uow.TraceLog.Add(trace);
            }
        }
Exemple #10
0
        public CompteBanque CompteBanquesCalcule(int id)
        {
            // Comptes banque
            List<CompteBanque> _comptes = new List<CompteBanque>();
            CompteBanque _compte = uow.CompteBanque
                .GetById(id)
                ;

            // Récupération des compte banque avec compteurs
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);
            var s1 = new CompteBanqueSoldeCalculeAvecArchiveServices(uow, ProfileUser.GroupeId, _dateArchivage, _limite);
            s1.EnrichirAvecSoldeCalculeAvecArchive(_comptes);

            // Récupération des compte banque avec compteurs
            var s2 = new CompteBanqueRawSoldeCalculeServices(uow, ProfileUser.GroupeId);
            var _compte2s = s2.EnrichirAvecSoldeCalcules(_comptes);

            return _compte;
        }
Exemple #11
0
        public IQueryable<CompteBanque> CompteBanquesCalcules()
        {
            // Comptes banque
            IEnumerable<CompteBanque> _comptes = uow.CompteBanque
                .GetAllByGroupeId(ProfileUser.GroupeId)
                .Include(x => x.Banque)
                .ToList()
                ;

            // Récupération des compte banque avec compteurs
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);
            var s1 = new CompteBanqueSoldeCalculeAvecArchiveServices(uow, ProfileUser.GroupeId, _dateArchivage, _limite);
            s1.EnrichirAvecSoldeCalculeAvecArchive(_comptes);

            // Récupération des compte banque avec compteurs
            var s2 = new CompteBanqueRawSoldeCalculeServices(uow, ProfileUser.GroupeId);
            _comptes = s2.EnrichirAvecSoldeCalcules(_comptes);

            return _comptes.AsQueryable<CompteBanque>();
        }
Exemple #12
0
        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>();
        }
Exemple #13
0
        public AlerteAtelier AlertesAtelier()
        {
            var groupeId = ProfileUser.GroupeId;

            // Init
            var alerte = new AlerteAtelier();

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

            // Récupération des budgets avec compteurs
            EcartFinancementBudgetServices serviceB = new EcartFinancementBudgetServices(uow);
            IQueryable<Budget> budgets = serviceB
                .GetBudgetsAvecEcartFinancement(groupeId, _limite)
                .AsQueryable<Budget>();
            var fabrique = new AlerteEcartFinancementFabrique(uow, groupeId);
            alerte.AlertesEcartFinancement = fabrique.GetAlertes(budgets.ToList());

            // Retour
            return alerte;
        }
Exemple #14
0
        public IEnumerable<EcheanceContrat> NextActiveImputations()
        {
            ServiceDate scvDate = new ServiceDate();
            DateTime date = scvDate.GetDerniereDateMoisPrecedent();

            var service = new EcheanceService(uow, ProfileUser.GroupeId);
            return service.NextActiveImputations(date);
        }
Exemple #15
0
        public IQueryable<EcheanceContrat> ImputationsEchues()
        {
            // Date exécution: égale à la fin du mois qui précède la date du jour
            var scvDate = new ServiceDate();
            var current = scvDate.GetDerniereDateMoisPrecedent();

            var service = new EcheanceService(uow, ProfileUser.GroupeId);
            return service.ImputationsEchues(current);
        }
Exemple #16
0
        public IQueryable<Budget> BudgetsWithEcartFinancement()
        {
            // Création du service
            EcartFinancementBudgetServices service = new EcartFinancementBudgetServices(uow);

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

            // Récupération des budgets avec compteurs
            IQueryable<Budget> budgets = service
                .GetBudgetsAvecEcartFinancement(ProfileUser.GroupeId, _limite)
                .AsQueryable<Budget>();

            return budgets;
        }
Exemple #17
0
        public IQueryable<Budget> BudgetsAvecSoldesCalculesEtContratActifs()
        {
            // Budgets
            IEnumerable<Budget> _budgets = uow.Budget
                .GetAllByGroupeId(ProfileUser.GroupeId)
                .Include(x => x.Contrats)
                .ToList()
                ;

            // Récupération des budgets avec compteurs
            DateTime _dateArchivage = DateTime.Now;
            var svcDate = new ServiceDate();
            DateTime _limite = svcDate.DateLimite(_dateArchivage);

            // Création du service
            var service = new BudgetSoldeCalculeAvecArchiveServices(uow, ProfileUser.GroupeId, _dateArchivage, _limite);

            // Récupération des budgets avec compteurs
            service.EnrichirAvecSoldeCalculeAvecArchive(_budgets)
                ;

            return _budgets.AsQueryable<Budget>();
        }
 // Prochaine date provisions
 public DateTime ProchaineDateProvision(ServiceDate svcDate)
 {
     int jourProvisionDuMois = 02;
     var calendrier = this.GetCalendrier(svcDate);
     return svcDate.ProchaineDateInCalendrierDanslemois(calendrier, jourProvisionDuMois);
 }
Exemple #19
0
 // Test archiver
 private void TestArchiver()
 {
     // Archivage
     DateTime _dateArchivage = DateTime.Now;
     var svcDate = new ServiceDate();
     DateTime _limite = svcDate.DateLimite(_dateArchivage);
     TestArchivageServices test = new TestArchivageServices(uow);
     test.TesterCalculsSoldes(groupeId, _dateArchivage, _limite);
 }
Exemple #20
0
 // Archiver
 private void Archiver()
 {
     // Archivage
     DateTime _dateArchivage = DateTime.Now;
     var svcDate = new ServiceDate();
     DateTime _limite = svcDate.DateLimite(_dateArchivage);
     var process = new ArchivageProcessus(uow, groupeId, _dateArchivage, _limite);
     process.Executer();
 }
        private List<DateTime> GetCalendrierCible(ServiceDate svcDate)
        {
            // Calcul de dernière date d'exécution de provision possible pour ce groupe
            DateTime end = svcDate.GetDerniereDatePossibleDanslemois(02);

            // Récupération de la première date du calendrier pour cette famille
            DateTime creation = uow.Groupe
                .GetAll()
                .Where(g => g.Id == groupeId)
                .FirstOrDefault()
                .DateCreation
                ;
            DateTime start = new DateTime(creation.Year, creation.Month, 02);

            // Init calendrier
            var calendrier = new List<DateTime>();
            DateTime current = start;
            while (current <= end)
            {
                calendrier.Add(current);
                current = current.AddMonths(1);
            }

            // Retour
            return calendrier;
        }