---

DECLARE
    rec_outgoing_order record;
    rec_payment record;
    v_id_operation INTEGER;
    v_successe_list text := '';

    v_error_list text := '';
    v_web_base text;
    v_row_succeses_count integer := 0;
    v_row_error_count integer := 0;
    v_group integer;
    v_agent_id integer;
-- v_total_value integer := 0;

-- v_operation_code text;


    v_debit_mnemonics text[];
    v_credit_mnemonics text[];

    v_array_length integer;

    v_transaction_ids integer[];
    v_current_debit text;
    v_current_credit text;

    v_mnemonics_pair record;



v_debit_balances numeric[];
v_available_balance numeric;


v_current_balance numeric;

v_accrual_operation_id integer := null;
v_is_post_payment boolean := false;

v_full_credit_ammount numeric;

v_messing_mnemonics text;
v_proportion numeric;

v_already_used numeric;
v_remaining_amount numeric;

v_is_successe boolean;
v_is_error boolean;


v_pension_calculation_id integer;
v_termination_contract_calculation_id integer;




    

BEGIN

/******************************************************************************
* Получаем v_agent_id если запущено из интерфейса, p_user_id не NULL
*/-------------------------

select
t.group_recipient_id,
s.web_base,
a.id
INTO v_group, v_web_base, v_agent_id
FROM back_office.history_params_payment_register t
left join tools.settings s on true
left join ourpension.agent a on a.user_id = p_user_id
where is_active = true;



/******************************************************************************
* Получаем v_agent_id если запущено из Crone - роботом
*/
-------------------------


if p_user_id is null then

select a.id INTO v_agent_id from robot.params p
join "security"."USER" u on u.username = p.value
join ourpension.agent a on a.user_id = u.id
where p.name='login';

end if;

     RAISE NOTICE 'Получаем платежки';
for rec_outgoing_order in

/******************************************************************************
* Получаем Загруженные и не обработанные или частично обработанные с типом НПО ПДС
*/-------------------------


select o.id as id,
    o.number as number,
    o.date as date,
    o.value as value,
    pr.type_register as type_register,
    pr.payment_type_id as payment_type_id,
    pr.id as payment_register_id,
    o.service_type as service_type,
    o.payment_register_id as payment_register_id
from back_office.outgoing_order o
    left join back_office.outgoing_order_operation oo on oo.outgoing_order_id = o.id
    left join back_office.payment_register pr on pr.id = o.payment_register_id
-- left join ourpension.fund_bank_payment_type pt on pt.id = pr.payment_type_id
    where o.payment_upload_date is not null and coalesce(oo.value, 0.0) < o.value and o.service_type in ('NPO', 'PDS')
    order by o.id
    for update of o SKIP LOCKED

loop
-- создать операцию

v_is_successe := false;
v_is_error := false;


for rec_payment in

select p.id as id,
     p.accrual_pension_id as accrual_pension_id,
     p.accrual_repurchase_id as accrual_repurchase_id,
     p.topay as topay,
     p.total_topay as total_topay,
/******************************************************************************
* Получаем Тип решения и Код операции - для этого решения
*/
-------------------------
     min(coalesce(dpt.group_code, dpt1.group_code)) as decision_group_code ,
     min(coalesce(dpt.operation_code, dpt1.operation_code)) as operation_code,

/******************************************************************************
* Получаем Тип счета СПС КИПС ИПС
*/-------------------------

        sp.sharer_type as sharer_type,
        s.id as sharer_id
from back_office.payment p
     left join back_office.accrual_detail ad on ad.id = p.accrual_pension_id
     left join back_office.accrual_repurchase_amount_payments_details pd on pd.id = p.accrual_repurchase_id


left join back_office.pension_calculation pc on pc.id = ad.pension_calculation_id
left join back_office.termination_contract_calculation tc on tc.id = pd.termination_contract_calculation_id


left join ourpension.npo_decision_payment_type dpt on dpt.code = pc.npo_decision_payment_type_code
left join ourpension.npo_decision_payment_type dpt1 on dpt1.code = tc.decision_payment_type_code

left JOIN ourpension.sharer s ON s.id = p.sharer_id
left JOIN ourpension.sharer_params sp ON sp.sharer_id = s.id
    
    where p.outgoing_order_number = rec_outgoing_order.number
and p.payment_register_id = rec_outgoing_order.payment_register_id and p.completed is null and p.operation_id is null
group by p.id, p.accrual_pension_id, p.accrual_repurchase_id, p.topay, p.total_topay, sp.sharer_type, s.id
loop

BEGIN


    v_messing_mnemonics := '';
    v_available_balance := 0;
    v_debit_balances := ARRAY[]::numeric[];
    v_debit_mnemonics := ARRAY[]::text[];
    v_credit_mnemonics := ARRAY[]::text[];


/******************************************************************************
* Код операции для Удержаний - RETENTION
*/
-------------------------

IF rec_outgoing_order.type_register = 'RETENTION' THEN
rec_payment.operation_code := CASE rec_outgoing_order.service_type
WHEN 'NPO' THEN 'NPO_WITHHOLDING_UNDER_WRIT_EXECUTION'
WHEN 'PDS' THEN 'PDS_WITHHOLDING_UNDER_WRIT_EXECUTION'
ELSE NULL
END;
END IF;


/******************************************************************************
* Код операции для НДФЛ - NDFL
*/-------------------------------------------------------------------------------

IF rec_outgoing_order.type_register = 'NDFL' THEN
rec_payment.operation_code := CASE
WHEN rec_outgoing_order.service_type = 'PDS' AND rec_payment.decision_group_code = 'СПВ_ПДС' THEN 'PDS_NDFL_PERIODIC_PAYMENT'
WHEN rec_outgoing_order.service_type = 'PDS' AND rec_payment.decision_group_code = 'ЕВ' THEN 'PDS_NDFL_LUMP_SUM_PAYMENT'
WHEN rec_outgoing_order.service_type = 'PDS' AND rec_payment.decision_group_code = 'ПЖ_ПДС' THEN 'PDS_NDFL_PENSION_PAYMENT'
WHEN rec_outgoing_order.service_type = 'PDS' AND rec_payment.decision_group_code IN ('ВС_ВЗ', 'ВС_ПВ_ПДС', 'ДОП_ПП_ПДС', 'ВС_ПП_ПДС' ) THEN 'PDS_NDFL_REDEMPTION_PAYMENT'
WHEN rec_outgoing_order.service_type = 'PDS' AND rec_payment.decision_group_code IN ('ОЖС') THEN 'PDS_NDFL_REDEMPTION_REDEMPTION_LOSS'
WHEN rec_outgoing_order.service_type = 'NPO' AND rec_payment.decision_group_code IN ('ДОП_ПП_НПО', 'ВС_ПП_НПО', 'ВС_ПВ_НПО', 'ВС_РЖ' ) THEN 'NPO_NDFL_PAYMENT_TERMINATED'
WHEN rec_outgoing_order.service_type = 'NPO' AND rec_payment.decision_group_code IN ('ПЖ_НПО', 'СПВ_НПО', 'ДИ' ) THEN 'NPO_NDFL_NONSTATE_PENSION'
ELSE NULL
END;
END IF;



IF rec_payment.operation_code is NULL THEN
    RAISE EXCEPTION 'Не удалось определить тип операции';
END IF;    


--v_debit_mnemonics := ARRAY[]::text[];
--v_credit_mnemonics := ARRAY[]::text[];


IF rec_outgoing_order.service_type = 'PDS' THEN
IF rec_outgoing_order.type_register = 'NDFL' THEN
    v_credit_mnemonics := ARRAY[NULL]::text[];
    v_debit_mnemonics := CASE
        WHEN rec_payment.decision_group_code = 'СПВ_ПДС' THEN ARRAY['В НДФЛ ПДС СВ']
        WHEN rec_payment.decision_group_code = 'ЕВ' THEN ARRAY['В НДФЛ ПДС ЕВ']
        WHEN rec_payment.decision_group_code = 'ПЖ_ПДС' THEN ARRAY['В НДФЛ ПДС ПВ']
        WHEN rec_payment.decision_group_code IN (
         'ВС_ВЗ' ,
         'ВС_ПВ_ПДС' ,
         'ВС_ПП_ПДС' ,
         'ДОП_ПП_ПДС'
        ) THEN ARRAY['В НДФЛ ПДС ВС СВ']
        WHEN rec_payment.decision_group_code = 'ОЖС' THEN ARRAY['В НДФЛ ПДС ВС ОЖС ПК']
        ELSE ARRAY[]::text[]
        END;
ELSIF rec_outgoing_order.type_register = 'RETENTION' THEN
     v_credit_mnemonics :=ARRAY[NULL]::text[];
     v_debit_mnemonics := ARRAY['В ИЛ ПДС'];
ELSE
     v_credit_mnemonics := CASE rec_payment.decision_group_code
     WHEN 'ЕВ' THEN ARRAY[
                'В Р(Е) ПДС СВ',
                'В Р(Е) ПДС СВ ИД',
                'В Р(Е) ПДС ЕВ',
                'В Р(Е) ПДС ЕВ ИД',
                'В Р(Е) ПДС СОФ',
                'В Р(Е) ПДС СОФ ИД',
                'В Р(Е) ПДС СВ_Р',
                'В Р(Е) ПДС СВ_РИД'
                ]
     WHEN 'СПВ_ПДС' THEN ARRAY[
                'В Р(С) ПДС СВ',
                'В Р(С) ПДС СВ ИД',
                'В Р(С) ПДС ЕВ',
                'В Р(С) ПДС ЕВ ИД',
                'В Р(С) ПДС СОФ',
                'В Р(С) ПДС СОФ ИД',
                'В Р(С) ПДС СВ_Р',
                'В Р(С) ПДС СВ_РИД'
     ]
     WHEN 'ПЖ_ПДС' THEN ARRAY[
                'В Р(П) ПДС СВ',
                'В Р(П) ПДС СВ ИД',
                'В Р(П) ПДС ЕВ',
                'В Р(П) ПДС ЕВ ИД',
                'В Р(П) ПДС СОФ',
                'В Р(П) ПДС СОФ ИД',
                'В Р(П) ПДС СВ_Р',
                'В Р(П) ПДС СВ_РИД'
     ]
     WHEN 'ВС_ВЗ' THEN ARRAY[    
                'В Р(ВС) ПДС СВ ИД',    
                'В Р(ВС) ПДС СВ'

     ]    
     WHEN 'ВС_ПВ_ПДС' THEN ARRAY[
                'В Р(ВС_НПФ) ПДС СВ' ,
                'В Р(ВС_НПФ) ПДС СВ ИД',            
                'В Р(ВС_НПФ) ПДС СВ_Р',
                'В Р(ВС_НПФ) ПДС СВ_Р ИД',
                'В Р(ВС_НПФ) ПДС ЕВ',
                'В Р(ВС_НПФ) ПДС ЕВ ИД',
                'В Р(ВС_НПФ) ПДС СОФ',
                'В Р(ВС_НПФ) ПДС СОФ ИД'        
     ]

     WHEN 'ОЖС' THEN ARRAY[
                'В Р(ВС_НПФ) ПДС СВ' ,
                'В Р(ВС_НПФ) ПДС СВ ИД',            
                'В Р(ВС_НПФ) ПДС СВ_Р',
                'В Р(ВС_НПФ) ПДС СВ_Р ИД',
                'В Р(ВС_НПФ) ПДС ЕВ',
                'В Р(ВС_НПФ) ПДС ЕВ ИД',
                'В Р(ВС_НПФ) ПДС СОФ',
                'В Р(ВС_НПФ) ПДС СОФ ИД'
     ]
     WHEN 'ВС_ПП_ПДС' THEN ARRAY[
                'В Р(ПП) ПДС СВ',
                'В Р(ПП) ПДС СВ ИД',
                'В Р(ПП) ПДС СВ_Р',
                'В Р(ПП) ПДС СВ_Р ИД',
                'В Р(ПП) ПДС ЕВ',
                'В Р(ПП) ПДС ЕВ ИД',
                'В Р(ПП) ПДС СОФ',
                'В Р(ПП) ПДС СОФ ИД'

     ]
     WHEN 'ДОП_ПП_ПДС' THEN ARRAY[
                'В Р(ПП) ПДС СВ',
                'В Р(ПП) ПДС СВ ИД',
                'В Р(ПП) ПДС СВ_Р',
                'В Р(ПП) ПДС СВ_Р ИД',
                'В Р(ПП) ПДС ЕВ',
                'В Р(ПП) ПДС ЕВ ИД',
                'В Р(ПП) ПДС СОФ',
                'В Р(ПП) ПДС СОФ ИД'
     ]
     ELSE ARRAY[]::text[]
     END; -- CASE
         v_debit_mnemonics := CASE rec_payment.decision_group_code
     WHEN 'ЕВ' THEN ARRAY[
                'НВ Р(ЕВ) ПДС СВ',
                'НВ Р(ЕВ) ПДС СВ ИД',
                'НВ Р(ЕВ) ПДС ЕВ',
                'НВ Р(ЕВ) ПДС ЕВ ИД',
                'НВ Р(ЕВ) ПДС СОФ',
                'НВ Р(ЕВ) ПДС СОФ ИД',
                'НВ Р(ЕВ) ПДС СВ_Р',
                'НВ Р(ЕВ) ПДС СВ_РИД'
                ]
     WHEN 'СПВ_ПДС' THEN ARRAY[
                'НВ Р(С) ПДС СВ',
                'НВ Р(С) ПДС СВ ИД',
                'НВ Р(С) ПДС ЕВ',
                'НВ Р(С) ПДС ЕВ ИД',
                'НВ Р(С) ПДС СОФ',
                'НВ Р(С) ПДС СОФ ИД',
                'НВ Р(С) ПДС СВ_Р',
                'НВ Р(С) ПДС СВ_РИД'
     ]
     WHEN 'ПЖ_ПДС' THEN ARRAY[
                'НВ Р(П) ПДС СВ',
                'НВ Р(П) ПДС СВ ИД',
                'НВ Р(П) ПДС ЕВ',
                'НВ Р(П) ПДС ЕВ ИД',
                'НВ Р(П) ПДС СОФ',
                'НВ Р(П) ПДС СОФ ИД',
                'НВ Р(П) ПДС СВ_Р',
                'НВ Р(П) ПДС СВ_РИД'
     ]
     WHEN 'ВС_ВЗ' THEN ARRAY[    
                'НВ Р(ВС) ПДС СВ ИД',    
                'НВ Р(ВС) ПДС СВ'

     ]    
     WHEN 'ВС_ПВ_ПДС' THEN ARRAY[
                'НВ Р(ВС_НПФ) ПДС СВ' ,
                'НВ Р(ВС_НПФ) ПДС СВ ИД',            
                'НВ Р(ВС_НПФ) ПДС СВ_Р',
                'НВ Р(ВС_НПФ) ПДС СВ_Р ИД',
                'НВ Р(ВС_НПФ) ПДС ЕВ',
                'НВ Р(ВС_НПФ) ПДС ЕВ ИД',
                'НВ Р(ВС_НПФ) ПДС СОФ',
                'НВ Р(ВС_НПФ) ПДС СОФ ИД'
                
     ]
     WHEN 'ОЖС' THEN ARRAY[
                'НВ Р(ВС_ОЖС) ПДС СВ' ,
                'НВ Р(ВС_ОЖС) ПДС СВ ИД',            
                'НВ Р(ВС_ОЖС) ПДС СВ_Р',
                'НВ Р(ВС_ОЖС) ПДС СВ_Р ИД',
                'НВ Р(ВС_ОЖС) ПДС ЕВ',
                'НВ Р(ВС_ОЖС) ПДС ЕВ ИД',
                'НВ Р(ВС_ОЖС) ПДС СОФ',
                'НВ Р(ВВС_ОЖС) ПДС СОФ ИД'    
     ]
     WHEN 'ВС_ПП_ПДС' THEN ARRAY[
                'НВ Р(ПП) ПДС СВ',
                'НВ Р(ПП) ПДС СВ ИД',
                'НВ Р(ПП) ПДС СВ_Р',
                'НВ Р(ПП) ПДС СВ_Р ИД',
                'НВ Р(ПП) ПДС ЕВ',
                'НВ Р(ПП) ПДС ЕВ ИД',
                'НВ Р(ПП) ПДС СОФ',
                'НВ Р(ПП) ПДС СОФ ИД'
     ]
     WHEN 'ДОП_ПП_ПДС' THEN ARRAY[
                'НВ Р(ПП) ПДС СВ',
                'НВ Р(ПП) ПДС СВ ИД',
                'НВ Р(ПП) ПДС СВ_Р',
                'НВ Р(ПП) ПДС СВ_Р ИД',
                'НВ Р(ПП) ПДС ЕВ',
                'НВ Р(ПП) ПДС ЕВ ИД',
                'НВ Р(ПП) ПДС СОФ',
                'НВ Р(ПП) ПДС СОФ ИД'
     ]
     ELSE ARRAY[]::text[]
     END;


END IF; -- В ПДС - NDFL , Удержание, Обычные выплаты


ELSIF rec_outgoing_order.service_type = 'NPO' THEN
     IF rec_outgoing_order.type_register = 'NDFL' THEN
         v_debit_mnemonics := ARRAY[NULL]::text[];
         v_credit_mnemonics := CASE
        WHEN rec_payment.decision_group_code IN ('ПЖ_НПО', 'СПВ_НПО', 'ДИ') THEN ARRAY['В НДФЛ']
        WHEN rec_payment.decision_group_code IN ('ВС_ПВ_НПО', 'ВС_РЖ', 'ДИ') THEN ARRAY['В НДФЛ ВС']
        ELSE ARRAY[]::text[]
        END;
    ELSIF rec_outgoing_order.type_register = 'RETENTION' THEN
        v_debit_mnemonics :=ARRAY[NULL]::text[];
        v_credit_mnemonics :=
         CASE
             WHEN rec_payment.sharer_type is not null and rec_payment.sharer_type = 'IPS' THEN ARRAY['В ИЛ ИПС']
             WHEN rec_payment.sharer_type is not null and rec_payment.sharer_type = 'SPS_U' THEN ARRAY['В ИЛ СПС']
             WHEN rec_payment.sharer_type is not null and rec_payment.sharer_type = 'KIPS' THEN ARRAY['В ИЛ ИПС ЮЛ']
         END;
    ELSE -- обычные выплаты
     IF rec_payment.decision_group_code IN ('СПВ_НПО', 'ДИ') THEN
        v_credit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['В Р(С) СПС', 'В Р(С) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['В Р(С) ИПС ЮЛ', 'В Р(С) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['В Р(С) ИПС ФЛ', 'В Р(С) ИПС ФЛ ИД']
         END;
         v_debit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['НВ Р(С) СПС', 'НВ Р(С) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['НВ Р(С) ИПС ЮЛ', 'НВ Р(С) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['НВ Р(С) ИПС ФЛ', 'НВ Р(С) ИПС ФЛ ИД']
         END;
     ELSIF rec_payment.decision_group_code = 'ПЖ_НПО' THEN -- Пожизненная
         v_credit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['В Р(П) СПС', 'В Р(П) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['В Р(П) ИПС ЮЛ', 'В Р(П) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['В Р(П) ИПС ФЛ', 'В Р(П) ИПС ФЛ ИД']
         END;
         v_debit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['НВ Р(П) СПС', 'НВ Р(П) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['НВ Р(П) ИПС ЮЛ', 'НВ Р(П) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['НВ Р(П) ИПС ФЛ', 'НВ Р(П) ИПС ФЛ ИД']
         END;


     ELSIF rec_payment.decision_group_code IN ('ВС_РЖ', 'ВС_ПВ_НПО') THEN -- Полное расторжение и перевод в другой фонд
         v_credit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['В Р(ВС) СПС', 'В Р(ВС) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['В Р(ВС) ИПС ЮЛ', 'В Р(ВС) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['В Р(ВС) ИПС ФЛ', 'В Р(ВС) ИПС ФЛ ИД']
         END;
         v_debit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['НВ Р(ВС) СПС', 'НВ Р(ВС) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['НВ Р(ВС) ИПС ЮЛ', 'НВ Р(ВС) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['НВ Р(ВС) ИПС ФЛ', 'НВ Р(ВС) ИПС ФЛ ИД']
         END;


        ELSIF rec_payment.decision_group_code IN ('ВС_ПП_НПО', 'ДОП_ПП_НПО') THEN -- Выплата ПП наследнику
         v_credit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['В Р(ПП) СПС', 'В Р(ПП) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['В Р(ПП) ИПС ЮЛ', 'В Р(ПП) ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['В Р(ПП) ИПС ФЛ', 'В Р(ПП) ИПС ФЛ ИД']
         END;
         v_debit_mnemonics := CASE
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'SPS_U' THEN ARRAY['НВ Р(ПП) СПС', 'НВ Р(ПП) СПС ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'KIPS' THEN ARRAY['НВ Р(ПП) НПО ИПС ЮЛ', 'НВ Р(ПП) НПО ИПС ЮЛ ИД']
         WHEN rec_payment.sharer_type IS NOT NULL AND rec_payment.sharer_type = 'IPS' THEN ARRAY['НВ Р(ПП) НПО ИПС ФЛ', 'НВ Р(ПП) НПО ИПС ФЛ ИД']
         END;
        ELSE
         v_credit_mnemonics := ARRAY[]::text[];
         v_debit_mnemonics := ARRAY[]::text[];
        END IF;
END IF; -- В NPO - NDFL , Удержание, Обычные выплаты

END IF; -- PDS или NPO


-- Проверяем что массивы не пустые и одинаковой длины
v_array_length := array_length(v_debit_mnemonics, 1);


-- RAISE NOTICE 'decision_group_code: %', rec_payment.decision_group_code;
-- RAISE NOTICE 'operation_code: %', rec_payment.operation_code;
-- RAISE NOTICE 'rec_outgoing_order.type_register: %', rec_outgoing_order.type_register;
-- RAISE NOTICE 'rec_payment.id: %', rec_payment.id;
-- RAISE NOTICE 'rec_payment.sharer_type: %', rec_payment.sharer_type;
-- RAISE NOTICE 'rec_outgoing_order.service_type: %', rec_outgoing_order.service_type;



-- RAISE NOTICE 'v_debit_mnemonics: %', v_debit_mnemonics;
-- RAISE NOTICE 'v_credit_mnemonics: %', v_credit_mnemonics;

IF v_debit_mnemonics IS NULL OR v_credit_mnemonics IS NULL THEN
    RAISE EXCEPTION 'Один из массивов дебита/кредита не определён';
END IF;

IF v_array_length IS NULL OR v_array_length = 0 OR v_array_length <> array_length(v_credit_mnemonics, 1) THEN
    RAISE EXCEPTION 'Не верно определены массивы дебита и кредита';
END IF;


--================== ПОЛУЧАЕМ БАЛАНСЫ и ПРОВЕРЯЕМ================


RAISE NOTICE 'Показы