Delimiter $$
/**
 * compute BUSINESS_FI_ANA_TMP_ACCOUNTS_AGING_BALANCE_BASE
 * optimisation pour le calcul fiana
 * création de la table temporaire tmp_v_acc_aging_bal_bas_det
 * contient des données de balance agés par compte en fonction du lettrage
 * appel la procédure BUSINESS_FI_ANA_TMP_ENTRIES_NB_RECLAIMS
 * BUSINESS_COMPUTE_ENTRIES_DATA_MATCHINGCODES_LAST doit avoir été appelé au préalables
 * #6850 prendres les status d'écriture "bloqué" (DF_ENTRIES_STATUT_INDICATOR = 8) dans le calcul des montant bloqué
 * #8167 prise en compte des date de promesse échue/ non échue dans le calcul de l'exigible
 * une écriture n'es plus exigible s'il elle à une promesse non échus
 * vu avec olivier
 * certaine écriture ont une date compte dans le futur  lors de leur création
 * pour contourner on utilisé la valeur minimal entre la date de l'écriture (date comptable)
 * et la date de creation C&C (date technique)
 */ 
Drop Procedure if Exists BUSINESS_FI_ANA_TMP_ACCOUNTS_AGING_BALANCE_BASE $$
Create Procedure BUSINESS_FI_ANA_TMP_ACCOUNTS_AGING_BALANCE_BASE(In refdate DateTime, In idaccounts Int unsigned, In identities Int unsigned)
Begin
    v_acc_aging_bal_base_det: begin
        --  set @bfataabb_refDate  = Cast(AMO_BAL_REFDATE() As Date); -- pour test/debug
		set @bfataabb_refDate = Cast(Coalesce(refdate, AMO_BAL_REFDATE()) as Date);
#         set @bfataabb_refDate =  Cast(curdate() as Date); -- debug
        --		date de filtrage des ecritures pour historisation fiana

		-- pour les écritures anti-daté (futur)
		set @bfataabb_today = Cast(curdate() as Date);


		-- le montant restant du évolue avec le temps (en fonction des lettrages)
		-- on ne peut pas se baser dessus pour FI_ANA_HISTO
		-- Vu avec Olivier, on applique la regle suivante
		-- si calcul quotidian (FI_ANA uniquement) on utilise le montant restant du (pas de changement)
		-- si calcule pour FI_ANA_HISTO on utilise ENT_DEBIT-ENT_CREDIT
		-- on fait fi volontairement des lettrages intermédiaires
		Set @bfataabb_useDebitAndCredit = (Case When @bfataabb_refDate < curdate() Then 1 Else 0 End);

        if idaccounts Is null Then
            Set @bfataabb_accMinVal = 0;
            Set @bfataabb_accMaxVal = 4e7;
        Else
            Set @bfataabb_accMinVal = idaccounts;
            Set @bfataabb_accMaxVal = idaccounts;
        End if;
-- 

        if identities Is null Then
            Set @bfataabb_enttMinVal = 0;
            Set @bfataabb_enttMaxVal = 1000;
        Else
            Set @bfataabb_enttMinVal = identities;
            Set @bfataabb_enttMaxVal = identities;
        End if;
-- Get matching codes state ids
        Set @bfataabb_OpenEntry = (Select ID_DF_MATCHINGCODE_STATE From DF_MATCHINGCODE_STATE Where DF_MATCHINGCODE_STATE_CODE = 'OPEN ENTRY');
        Set @bfataabb_Partial = (Select ID_DF_MATCHINGCODE_STATE From DF_MATCHINGCODE_STATE Where DF_MATCHINGCODE_STATE_CODE = 'PARTIAL MATCHING CODE');
        Set @bfataabb_ClosedEntry = (Select ID_DF_MATCHINGCODE_STATE From DF_MATCHINGCODE_STATE Where DF_MATCHINGCODE_STATE_CODE = 'CLOSED ENTRY');

        Set @bfataabb_minPromDate = Cast('1970-10-01' as Date);

-- --         call BUSINESS_UPDATE_ENTRIES_NB_RECLAIMS(@bfataabb_refDate, idaccounts, null); -- ne met pas à jour la tables des entries
        call BUSINESS_UPDATE_ENTRIES_RECLAIMS(@bfataabb_refDate, null, idaccounts); -- met à jour la tables des entries, appel BUSINESS_UPDATE_ENTRIES_NB_RECLAIMS


        Drop Temporary Table If exists tmp_v_acc_aging_bal_bas_det;

        Create Temporary Table tmp_v_acc_aging_bal_bas_det  (
                ID_ACCOUNTS Int Unsigned not Null
--                 , ENT_IS_CLOSED SmallInt -- pour optimisation calcul, non utilisé dans les données
                , ENT_BAL Decimal(19, 4) -- pour optimisation calcul, non utilisé dans les données
                , NOT_OVERDUE Decimal(19, 4)
                , UNBOUND_NOT_OVERDUE Decimal(19, 4)
                , P1 Decimal(19, 4)
                , P2 Decimal(19, 4)
                , P3 Decimal(19, 4)
                , P4 Decimal(19, 4)
                , P5 Decimal(19, 4)
                , P6 Decimal(19, 4)
                , P7 Decimal(19, 4)
                , P8 Decimal(19, 4)
                , OUTSTANDING Decimal(19, 4)
                , UNBOUND_OUTSTANDING Decimal(19, 4)
                , OVERDUE Decimal(19, 4)
                , UNBOUND_OVERDUE Decimal(19, 4)
                , `BLOCKED` Decimal(19, 4)
                , `UNBOUND_BLOCKED` Decimal(19, 4)
                , BLOCKED_OVERDUE Decimal(19, 4)
                , UNBOUND_BLOCKED_OVERDUE Decimal(19, 4)

#                 , UNBLOCKED_OVERDUE_WTH_PRMESS Decimal(19, 4)
#                 , UNBOUND_UNBLOCKED_OVERDUE_WTH_PRMESS Decimal(19, 4)
                , `DUE` Decimal(19, 4)
                , UNBOUND_DUE Decimal(19, 4)
                , CONSO Int
                
                , Index (ID_ACCOUNTS)
            )
        ;
        Insert Into tmp_v_acc_aging_bal_bas_det  (
                ID_ACCOUNTS
/*
--                 , ENT_IS_CLOSED         -- pour optimisation calcul, non utilisé dans les données
#                 , ENT_BAL               -- pour optimisation calcul, non utilisé dans les données
*/
                , NOT_OVERDUE
                , UNBOUND_NOT_OVERDUE
                , P1
                , P2
                , P3
                , P4
                , P5
                , P6
                , P7
                , P8
                , OUTSTANDING
                , UNBOUND_OUTSTANDING
                , OVERDUE
                , UNBOUND_OVERDUE
                , `BLOCKED`
                , `UNBOUND_BLOCKED`
                , BLOCKED_OVERDUE
                , UNBOUND_BLOCKED_OVERDUE
                , `DUE`
                , UNBOUND_DUE
#                 , UNBLOCKED_OVERDUE_WTH_PRMESS
#                 , UNBOUND_UNBLOCKED_OVERDUE_WTH_PRMESS


                , CONSO
            )
/*
--         Create Temporary Table tmp_v_acc_aging_bal_bas_det As

        -- regle pour determiner si un ecriture est ouverte par rapport à la date
        -- (test avec une fonction sql, contre performant)
--         (
--                             Case
--                 When dms.DF_MATCHINGCODE_STATE_CLOSED  = 0 Then 1
--                 When MTC.ID_MATCHINGCODES is null Then
--                     -- ici on a un status de lettrage total 
--                     -- sans sans lettrage associé à l'ectiture
--                     -- cela implique un lettrage forcé
--                     -- on ignore le montant de l'ecriture
--                     0
--                 Else 
--                     -- on prend en compte si la date est posterieur
--                     MTC.MATCHINGCODES_DATE  > @bfataabb_refDate
--             End
--         )
*/
        -- explain
        Select
            ac.ID_ACCOUNTS
            , Sum(
                 -- non échu = écritures ouvertes date échéance > date ref
                 Case
                     When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                     When et.ENTRIES_DUE_DATE <= @bfataabb_refDate then 0 -- échus donc non pris en compte
                        -- implicite : ici non échue pour la période
                     When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement non échus)
                         If(@bfataabb_useDebitAndCredit=0
                             , et.ENTRIES_ENT_BALANCE
                             , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                             )

                     -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                     -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                     -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                     When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                     When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                     Else
                         -- implicite non lettrée à la date ref
                         If(@bfataabb_useDebitAndCredit=0
                             , et.ENTRIES_ENT_BALANCE
                             , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                         )
                 End
            ) As NOT_OVERDUE

           , Sum(
                 -- non échu = écritures ouvertes date échéance > date ref
                 Case
                     When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0

                     When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                     When et.ENTRIES_DUE_DATE <= @bfataabb_refDate then 0 -- échus donc non pris en compte
                 -- implicite : ici non échue pour la période
                     When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement non échus)
                         If(@bfataabb_useDebitAndCredit=0
                             , et.ENTRIES_ENT_BALANCE
                             , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                             )

                     -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                     -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                     -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                     When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                     When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                     Else
                         -- implicite non lettrée à la date ref
                         If(@bfataabb_useDebitAndCredit=0
                             , et.ENTRIES_ENT_BALANCE
                             , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                             )
                 End
            ) As UNBOUND_NOT_OVERDUE

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between 0 and ad.ADMIN_AGING_PORT_BAL_PERIOD1 then 0 -- age échéance hors période

                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus pour la période)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période

                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P1

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD1 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD2 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P2

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD2 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD3 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P3

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD3 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD4 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P4

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD4 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD5 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P5

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD5 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD6 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P6

         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) Not Between ad.ADMIN_AGING_PORT_BAL_PERIOD6 + 1 and ad.ADMIN_AGING_PORT_BAL_PERIOD7 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P7
         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
#                     When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) < ad.ADMIN_AGING_PORT_BAL_PERIOD7 +1 then 0 -- age échéance hors période
                    When DATEDIFF(@bfataabb_refDate, et.ENTRIES_DUE_DATE) <= ad.ADMIN_AGING_PORT_BAL_PERIOD7 then 0 -- age échéance hors période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As P8
         , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As OUTSTANDING

         , Sum(
                Case
                    When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus periode)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As UNBOUND_OUTSTANDING
            , Sum(

                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus donc non pris en compte
                -- implicite : ici échue pour la période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As OVERDUE
            , Sum(
                Case
                    When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus donc non pris en compte
                -- implicite : ici échue pour la période
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite lettrée non échu  à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As UNBOUND_OVERDUE
            , Sum(

                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) = 0 And Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) <> 8 Then 0 -- pas de reclamtion ou status bloquant  on exclu


                    -- implicite : bloqué
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As `BLOCKED`

            , Sum(

                Case
                    When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0

                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) = 0 And Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) <> 8 Then 0 -- pas de reclamation ou status bloquant  on exclu


                    -- implicite : bloqué
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement bloqué)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As UNBOUND_BLOCKED
            , Sum(
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) = 0 And Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) <> 8 Then 0 -- pas de reclamtion ou status bloquant  on exclu
                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus donc non pris en compte

                -- implicite : bloqué échus
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As `BLOCKED_OVERDUE`

            , Sum(
                Case
                    When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0

                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) = 0 And Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) <> 8 Then 0 -- pas de reclamtion ou status bloquant  on exclu
                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus donc non pris en compte

                -- implicite : bloqué échus
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As `UNBOUND_BLOCKED_OVERDUE`
            , Sum(
                -- exigible = encoure echus - bloquées - promesses non échues
                -- = somme des écritures ouvertes échues - bloquées - promesses non échues
                Case
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) > 0 Then 0 -- reclamation bloquante ouverte, on exclu
                    When Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) = 8 Then 0 -- statue bloquante, on exclu
                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus, on exclu
                    When Coalesce(et.ENTRIES_PROMISE_DATE, @bfataabb_minPromDate) > @bfataabb_refDate Then 0 -- promesse non échu, on exclu

                -- implicite : non bloqué échus, sans promesse ou promesse échus
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As  `DUE`
             -- `UNBLOCKED_OVERDUE_WTH_PRMESS` -- due

             , Sum(
                Case
                    When eha.ENTRIES_PERMANENT_ATTACHEMENT = 0 Then 0
                    When Least(et.ENTRIES_DATE, et.ENTRIES_CREATION_DATE) > @bfataabb_refDate then 0 -- retro-calcul, écriture non créé à la date de ref

                    When Coalesce(r.RECLAIMS_NB_BLOCKED, 0) > 0 Then 0 -- reclamation bloquante ouverte, on exclu
                    When Coalesce(DF_ENTRIES_STATUT_INDICATOR,0) = 8 Then 0 -- statue bloquante, on exclu
                    When et.ENTRIES_DUE_DATE > @bfataabb_refDate then 0 -- non échus, on exclu
                    When Coalesce(et.ENTRIES_PROMISE_DATE, @bfataabb_minPromDate) > @bfataabb_refDate Then 0 -- promesse non échu, on exclu

                -- implicite : non bloqué échus, sans promesse ou promesse échus
                    When et.DF_MATCH_STAT_ID_DF_MATCH_STAT In (@bfataabb_OpenEntry, @bfataabb_Partial) Then -- ouvert (& implicitement échus)
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )

                    -- écritures lettrées : on doit tenir compte de la date de lettrage pour le retro calcul
                    -- condition implicte : et.ENTRIES_DUE_DATE > @bfataabb_refDate
                    -- si le lettrage est antérieur à la date de ref cela implique que l'écriture était déjà close la période
                    When MTC.ID_MATCHINGCODES is Not null And MTC.MATCHINGCODES_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    When EFMTCST.ENTRIES_COMPUTED_DATA_DATE is Not null And EFMTCST.ENTRIES_COMPUTED_DATA_DATE < @bfataabb_refDate Then 0 -- lettré pour la période
                    Else
                        -- implicite non lettrée à la date ref
                        If(@bfataabb_useDebitAndCredit=0
                            , et.ENTRIES_ENT_BALANCE
                            , et.ENTRIES_ENT_DEBIT - et.ENTRIES_ENT_CREDIT
                            )
                    End
            ) As `UNBOUND_DUE`
            -- `UNBOUND_UNBLOCKED_OVERDUE_WTH_PRMESS` -- unbound due


            , 0 As CONSO
        From ACCOUNTS ac
			Inner Join ENTITIES e
				On ac.ENTITIES_ID_ENTITIES = e.ID_ENTITIES
			Inner Join ADMIN_PARAMS ad
				On e.ADMIN_ID_ADMIN = ad.ID_ADMIN_PARAMS
            Left Join (
				ENTRIES_has_ACCOUNTS eha

				Inner Join ENTRIES et
					On eha.ENTRIES_ID_ENTRIES = et.ID_ENTRIES
                     And et.DF_ENTR_TYPE_ID_DF_ENTR_TYPE In (1, 2, 3, 4, 5 , 6, 7)
-- 				Inner Join DF_ENTRIES_TYPE det
-- 					On et.DF_ENTR_TYPE_ID_DF_ENTR_TYPE = det.ID_DF_ENTRIES_TYPE
-- 					And det.DF_ENTRIES_TYPE_ACCOUNTANT = 1
				Left Join DF_ENTRIES_STATUT dfes
					On et.DF_ENTR_STT_ID_DF_ENTR_STT = dfes.ID_DF_ENTRIES_STATUT

				Left Join ENTRIES_NB_RECLAIMS_VIEW_FOR_VIEW r
					ON et.ID_ENTRIES = r.ENTRIES_ID_ENTRIES
-- 				Left Join DF_MATCHINGCODE_STATE dms
-- 					ON et.DF_MATCH_STAT_ID_DF_MATCH_STAT = dms.ID_DF_MATCHINGCODE_STATE
                Left Join (
                    MATCHINGCODES MTC
                    Inner Join ENTRIES_MATCHCOD EMC
                        On MTC.ID_MATCHINGCODES = EMC.MATCHCOD_ID_MATCHCOD
-- 						And MTC.MATCHINGCODES_DATE <= @bfataabb_refDate
                )
                    On et.ID_ENTRIES = EMC.ENTRIES_ID_ENTRIES
                    And EMC.ENTRIES_MATCHCOD_CURRENT = 1
                Left Join ENTRIES_COMPUTED_DATA EFMTCST
                    On et.ID_ENTRIES = EFMTCST.ENTRIES_ID_ENTRIES
                    And EFMTCST.ENTRIES_COMPUTED_DATA_KEY = 'FORCEDMATCHSTS'
-- 				Left Join (
-- 					ENTRIES_COMPUTED_DATA ENMTC
-- 					Inner Join MATCHINGCODES MTC
-- 						On MTC.ID_MATCHINGCODES = ENMTC.ENTRIES_COMPUTED_DATA_EXTID
-- 						And ENMTC.ENTRIES_COMPUTED_DATA_KEY = 'LASTMATCH'
-- 						And MTC.MATCHINGCODES_DATE <= @bfataabb_refDate
-- 
-- 				) On et.ID_ENTRIES = ENMTC.ENTRIES_ID_ENTRIES
			) On ac.ID_ACCOUNTS = eha.ACCOUNTS_ID_ACCOUNTS
-- 				And et.DF_SAND_STATE_ID_DF_SAND_STATE <> 3
				And et.DF_SAND_STATE_ID_DF_SAND_STATE In (1,2,4,5)
                And Least(et.ENTRIES_DATE, @bfataabb_today) <= @bfataabb_refDate
        Where
			 ac.ID_ACCOUNTS between @bfataabb_accMinVal And @bfataabb_accMaxVal
			 And ac.ENTITIES_ID_ENTITIES between @bfataabb_enttMinVal And @bfataabb_enttMaxVal
        Group By
                ac.ID_ACCOUNTS
        ;


    end ;
end $$
Delimiter ;