 SET NAMES UTF8;
DELIMITER $$

DROP PROCEDURE IF EXISTS fk_konta_tools$$
CREATE DEFINER=root@localhost PROCEDURE fk_konta_tools(
    IN _MODE VARCHAR(150),
    IN _Konto VARCHAR(255),
    IN _Okres VARCHAR(50),    
    IN _Param_A VARCHAR(255),    
    IN _Param_B VARCHAR(255),    
    IN _Param_C VARCHAR(255),    
    IN _Param_D VARCHAR(255)    
)
SPROC: BEGIN 
/*
_MODE

------------------------------------------------------------------------------------------------------------------------------------------------------------
'SYNCH'
    Okreslenie różnic w planie kont dla dwóch okresów obrach. i uzupelnienie docelowego o konta, które istnieją tylko w źródłowym
    Parametry
        
        _Okres        okres obrachunkowy    źródłowy
        _Param_A    okres obrachunkowy    docelowy
    CALL fk_konta_tools('SYNCH', '', '2018', '2019', '', '', '');        
        
------------------------------------------------------------------------------------------------------------------------------------------------------------
'EXIST'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('EXIST', '*|234|297|1|235', '2019', '', '');        
    
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CREATE_IF_NOT_EXIST'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('CREATE_IF_NOT_EXIST', '*|234|297|1|235', '2019', 'obcy', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CREATE'
    Zakłada konta w planie kont (wola CREATE_ONE) i zwraca rezultat 
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
        _Param_A     ObcyGUID
        _Param_B     Separator
    CALL fk_konta_tools('CREATE', '*|234|297|1|235', '2019', 'obcy', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CREATE_ONE'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
        _Param_A     ObcyGUID
        _Param_B     Separator
        _Param_C     Opis
        _Param_D     ???
    CALL fk_konta_tools('CREATE_ONE', '*|234|297|1|235', '2019', 'obcy', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CREATE_ALL_FROM_ZAPISY'
    Zakłada konta brakujące konta w planie kont - wszystkie konta z zapisów w danym okresie nie istniejące w planie kont
    Parametry
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('CREATE_ALL_FROM_ZAPISY', '', '2019', '', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'BUILD_ALL_NOT_EXISTS_FROM_ZAPISY'
    Zakłada temp table z kontami brakującymi - wszystkie konta z zapisów w danym okresie nie istniejące w planie kont 
    Parametry
        _Okres        okres obrachunkowy    
        _Param_A     1 - zwroc select
    CALL fk_konta_tools('BUILD_ALL_NOT_EXISTS_FROM_ZAPISY', '', '2019', '', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CREATE_NEW_FOR_OBCY_GUID'
    Zakłada temtablea z kontami brakującymi - wszystkie konta z zapisów w danym okresie nie istniejące w planie kont
    Parametry
        _Okres        okres obrachunkowy    
        _Param_A     1 - zwroc select
    CALL fk_konta_tools('CREATE_NEW_FOR_OBCY_GUID', '', '2019', '', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------
'CHECK_AND_CREATE_FOR_IDNOPER'
    Zakłada konta brakujące konta w planie kont - wszystkie konta z zapisów danej operacji
    Parametry
        _Param_A     idnoper zapisu 
    CALL fk_konta_tools('CHECK_AND_CREATE_FOR_IDNOPER', '', '', 'idnoper zapisu', '');        
    

*/

DECLARE _DEBUG INTEGER DEFAULT 0;
DECLARE _KontoSave VARCHAR(250);
DECLARE _ParentKonto VARCHAR(250);
DECLARE _NextPart VARCHAR(250);
DECLARE _NextPos INTEGER;
DECLARE _Poziom INTEGER;
DECLARE _KontoSymbol VARCHAR(250);
DECLARE _KontoSymbolFmt VARCHAR(250);
DECLARE _ObcyGUID VARCHAR(38);
DECLARE _Separator VARCHAR(5);

DECLARE _ROK INTEGER;
DECLARE _ROK2 INTEGER;

DECLARE _CS_UNKNOWN INTEGER DEFAULT -1;
DECLARE _CS_EXIST INTEGER DEFAULT 0;
DECLARE _CS_CREATE INTEGER DEFAULT 1;
DECLARE _CS_INVALID INTEGER DEFAULT 2;

DECLARE _ErrNo INTEGER DEFAULT 0;
DECLARE _MyErrNo INTEGER DEFAULT 0;
DECLARE _Metoda INTEGER DEFAULT 0;
DECLARE _Obcy_ID VARCHAR(255) DEFAULT '';
DECLARE _Konto_opis    VARCHAR(255) DEFAULT '';

-- zastapione funkcja    DECLARE _aI INTEGER DEFAULT 0;
-- zastapione funkcja    DECLARE _CharCount INTEGER DEFAULT 0;

-- SET _ErrNo = 0;
SET _ROK=_VarINT(_Okres);
SET _DEBUG=_Param_D LIKE '%DEBUG%';
IF @session.FK.IR.EraseSeparatorFromFirstAccountChars IS NULL THEN 
        CALL _IReg_Get('FK', 'Konta_pierwsze_znaki_bez_separatora', 0, 'INT', @session.FK.IR.EraseSeparatorFromFirstAccountChars, 0);
END IF;

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'SYNCH'
    Okreslenie różnic w planie kont dla dwóch okresów obrach. i uzupelnienie docelowego o konta, które istnieją tylko w źródłowym
    Parametry            
        _Konto        konto - do like
        _Okres        okres obrachunkowy    źródłowy
        _Param_A    okres obrachunkowy    docelowy
    CALL fk_konta_tools('SYNCH', '', '2025', '2026', '', '', '');        
    CALL fk_konta_tools('SYNCH', '*|2|47|%', '2025', '2026', '', '', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/        
IF _MODE = 'SYNCH' THEN
    SET _ROK2=IF(_Param_A='',NULL,_VarINT(_Param_A)),_Konto = IF(_Konto='','%',_Konto);

    -- 2. tworzymy tabele tymczasowa z roznica (konta ktore były w roku źródłowym, a nie ma ich w docelowym)
    DROP TEMPORARY TABLE IF EXISTS t_konta_diff;
    CREATE TEMPORARY TABLE t_konta_diff AS 
    SELECT * FROM plankont 
    WHERE rok = _ROK AND symbol LIKE _Konto AND 
        symbol NOT IN (SELECT symbol FROM plankont WHERE rok = _ROK2)
    ;

    -- 3. aktualizujemy odp. wartosci
    UPDATE t_konta_diff SET idn = 0,   guid_poprzedni_rok  = guid, guid = UUID(), rok = _ROK2;

    -- 4. wstawiamy przygotowane konta do planu kont
    INSERT IGNORE INTO plankont SELECT * FROM t_konta_diff;
    
END IF;

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'EXIST'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('EXIST', '*|234|297|1|235', '2019', '', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'EXIST' THEN
    SET @_ErrNo = 0;
    SET @SymbolKonta = '';
    SELECT
        Symbol, GUID INTO @SymbolKonta, @LastKontoGUID
    FROM plankont    
    WHERE
        Symbol = _Konto
        AND Rok = _ROK
    ;
    SET @SymbolKonta = IFNULL(@SymbolKonta, '');
    SET @LastKontoGUID = IFNULL(@LastKontoGUID, '');
    SET _ErrNo = IF(@SymbolKonta = '', 1, 0);
    SET @_ErrNo = _ErrNo;
    SET @_Msg = IF(@_ErrNo, 'Not Exist', 'Exist');
    IF _Param_B = '' THEN
        SELECT @_ErrNo AS ErrNo, _VarStr(@_Msg) AS Msg, _VarStr(@LastKontoGUID) as LastKontoGUID, _VarStr(@SymbolKonta) as SymbolKonta;
    END IF;
END IF;    --    IF _MODE = 'EXIST'

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'EXIST_ANAL'
    Sprawdza czy konto istnieje i jest analityczne
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('EXIST', '*|234|297|1|235', '2019', '', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/

IF _MODE = 'EXIST_ANAL' THEN
    SET @_ErrNo = 0;
    SET @SymbolKonta = '';
    SELECT
        Symbol, GUID INTO @SymbolKonta, @LastKontoGUID
    FROM plankont    
    WHERE
        Symbol = _Konto
        AND Rok = _ROK
        AND dl_potomka=0
    ;
    SET @SymbolKonta = IFNULL(@SymbolKonta, '');
    SET @LastKontoGUID = IFNULL(@LastKontoGUID, '');
    SET _ErrNo = IF(@SymbolKonta = '', 1, 0);
    SET @_ErrNo = _ErrNo;
    SET @_Msg = IF(@_ErrNo, 'Not Exist', 'Exist');
    IF _Param_B = '' THEN
        SELECT @_ErrNo AS ErrNo, _VarStr(@_Msg) AS Msg, _VarStr(@LastKontoGUID) AS LastKontoGUID, _VarStr(@SymbolKonta) AS SymbolKonta;
    END IF;
END IF;    

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'CREATE_IF_NOT_EXIST'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _ErrNo        ZWRACA    0 - istnieje    1 - NIE istnieje
        _Okres        okres obrachunkowy    
    CALL fk_konta_tools('CREATE_IF_NOT_EXIST', '*|234|297|1|235', '2019', 'obcy', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'CREATE_IF_NOT_EXIST' THEN
    SET @_ErrNo = 0;
    CALL fk_konta_tools('EXIST', _Konto, _Okres, '', '1', '', '');        
    IF @_ErrNo != 0 THEN
        CALL fk_konta_tools('CREATE', _Konto, _Okres, _Param_A, _Param_B, _Param_C, _Param_D);        
    ELSE    
        SELECT @_ErrNo AS ErrNo, _VarStr(@_Msg) AS Msg, _VarStr(@LastKontoGUID) as LastKontoGUID, _VarStr(@SymbolKonta) as SymbolKonta;
    END IF;
    SET _ErrNo = _MyErrNo;
    -- SELECT _ErrNo AS ErrNo;
END IF;    --    IF _MODE = 'CREATE_IF_NOT_EXIST'

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'CREATE'
    Zakłada konta w planie kont (wola CREATE_ONE) i zwraca rezultat 
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
        _Param_A     ObcyGUID
        _Param_B     Separator
    CALL fk_konta_tools('CREATE', '*|234|297|1|235', '2019', 'obcy', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'CREATE' THEN
    SET @LastKontoGUID = '';
    CALL fk_konta_tools('CREATE_ONE', _Konto, _Okres, _Param_A, _Param_B, _Param_C, _Param_D);        
    SET _ErrNo = @_ErrNo;
    SET @_Msg = IF(_ErrNo, 'Błąd w strukturze', 'Zakończono pomyślnie');
    SELECT @_ErrNo AS ErrNo, @_Ile_Zakladam_Kont AS Ile_Stworzono_Kont, _VarStr(@_Msg) AS Msg, _VarStr(@LastKontoGUID) AS LastKontoGUID, _VarStr(@SymbolKonta) as SymbolKonta;
END IF;    --    IF _MODE = 'CREATE'

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'CREATE_ONE'
    Zakłada konta w planie kont
    Parametry
        _Konto        konto zakładane
        _Okres        okres obrachunkowy    
        _Param_A     ObcyGUID
        _Param_B     Separator
        _Param_C     Opis
        _Param_D     ???
    CALL fk_konta_tools('CREATE_ONE', '*|234|297|1|235', '2019', 'obcy', '', '', '');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'CREATE_ONE' THEN
    /*    
    Wyszukuje kontrahentow
    */    
    SET @_Ile_Zakladam_Kont = 0;
-- zastapione funkcja        CALL _IReg_Get('FK', 'Konta_pierwsze_znaki_bez_separatora', 0, 'INT', @KontoFirstCharsWithoutSeparator, 1);

    DROP TEMPORARY TABLE IF EXISTS t_konto_tree;
    CREATE TEMPORARY TABLE t_konto_tree (
        Poziom INT(11),
        Part VARCHAR(250),
        Symbol VARCHAR(250),
        ParentSymbol VARCHAR(250),
        dl_potomka INT(11),
        guid VARCHAR(38),
        rok INT(11),
        analityka VARCHAR(50),
        My_Len INT(11),
        Valid_Len INT(11),
        Status INT(11),
        symbol_fmt VARCHAR(250),
        Dzieci INT(11),
        Nazwa VARCHAR(250),
        ObcyGuid VARCHAR(38),
        pozabilans INT(11),
        KEY Symbol(Symbol)
    )
    ;
    SET _KontoSave = _Konto;
    SET _NextPart = '';
    SET _ObcyGUID = IFNULL(_Param_A, '');
    SET @_ObcyGUID = _ObcyGUID;
    SET _Separator = IF(IFNULL(_Param_B, ''), '-', _Param_B);
    SET _Konto_opis = IFNULL(_Param_C, '');
    -- SET _Konto = REPLACE(_Konto, ' ' , '|');
    SET _Konto = CONCAT(_Konto, '|');
    SET _NextPos = LOCATE('|', _Konto);
    SET _ParentKonto = '';
    SET @_Konto = _Konto;
    SET _Poziom = 0;
    
    WHILE _NextPos > 0 DO
        IF _NextPos > 1 THEN 
            SET _NextPart = SUBStr(_Konto, 1, _NextPos - 1);
            SET _KontoSymbol = _ConcatStr(_ParentKonto, _NextPart, '|');
            SET _KontoSymbolFmt = _varSTR_FK_Format_Konto(_KontoSymbol);
            INSERT INTO t_konto_tree
            SELECT _Poziom, _NextPart, _KontoSymbol, _ParentKonto, -1, '', _Okres, '', LENGTH(_NextPart), -1, _CS_UNKNOWN, _KontoSymbolFmt, 0, '', '', 0;    
            SET _ParentKonto = _ConcatStr(_ParentKonto, _NextPart, '|');
            SET @_NextPart = _NextPart;
        END IF;
        SET _Konto = SUBStr(_Konto, _NextPos + 1, 255);
        SET _NextPos = LOCATE('|', _Konto);
        -- SET @_WHERE = _WHERE;
        SET @_NextPos = _NextPos;
        SET _Poziom = _Poziom + 1;
        
    END WHILE;
    
    UPDATE t_konto_tree tk, plankont p
    SET
        tk.GUID = p.GUID,
        tk.dl_potomka = p.dl_potomka,
        tk.Nazwa = p.Nazwa,
        tk.Status = _CS_EXIST,
        tk.ObcyGUID = p.ObcyGUID,
        tk.pozabilans = p.pozabilans
    WHERE
        p.Symbol = tk.Symbol
        AND p.Rok = tk.Rok
    ;
--    Zapamiętaj poziom w którym pojawia sie pozabilans <> 0. Każdy następny poziom musi mieć pozabilans również ustawiony na 1
    SET @Poziom_pozabilans = 999999;
    SELECT 
        MIN(tk.Poziom) INTO @Poziom_pozabilans
    FROM t_konto_tree tk
    WHERE
        tk.pozabilans != 0
    ;
    SET @Poziom_pozabilans = IFNULL(@Poziom_pozabilans, 999999);
    UPDATE t_konto_tree tk
    SET
        tk.pozabilans = 1
    WHERE
        tk.Poziom > @Poziom_pozabilans
    
    ;
    UPDATE t_konto_tree tk, plankont p
    SET
        tk.Valid_Len = p.dl_potomka
    WHERE
        p.Symbol = tk.ParentSymbol
        AND p.Rok = tk.Rok
        -- AND tk.Status <> _CS_EXIST
    ;
    
    UPDATE t_konto_tree tk
    SET
        -- tk.Status = IF(tk.Valid_Len = LENGTH(tk.Part), _CS_CREATE, 2)
        tk.Status = IF(tk.Valid_Len = My_Len, _CS_CREATE, _CS_INVALID)
    WHERE
        tk.Status <> _CS_EXIST
    ;

        SELECT
            Status INTO @FinalStatus
        FROM t_konto_tree
        WHERE
            Symbol = _KontoSave
        ;
        
        SET _ErrNo = IF(@FinalStatus != _CS_INVALID, 0, 2);
    
--    Ile jest rekordow do stworzenia _CS_CREATE ALE NIE     _CS_INVALID !!!!!!!
    SELECT
        COUNT(*) AS ILE INTO @Ile
    FROM t_konto_tree
    WHERE
        Status = _CS_CREATE
    ;
    SET @_Ile_Zakladam_Kont = @Ile;
    IF @Ile > 0 THEN
    
    
        SELECT
            COUNT(*) AS ILE INTO @Ile
        FROM t_konto_tree
        WHERE
            Status <> _CS_EXIST
        ;
        
        SET @Ile = IFNULL(@ILe, 0);
        
        WHILE @Ile > 0 DO
        
            DROP TEMPORARY TABLE IF EXISTS t_konto_tree_2;
            CREATE TEMPORARY TABLE t_konto_tree_2 
                SELECT * FROM t_konto_tree
            ;
        --    Ustal pole dl_potomka na podstawie dlugosci analityki dziecka
            UPDATE t_konto_tree tk, t_konto_tree_2 tk2
            SET
                tk.dl_potomka = tk2.My_Len
            WHERE
                tk.Symbol = tk2.ParentSymbol
                AND tk.Status <> _CS_EXIST
            ;
        --    Ustal nazwy    
            UPDATE t_konto_tree tk, t_konto_tree_2 tk2
            SET
                tk.Nazwa = IF(tk2.Nazwa != '', CONCAT(tk2.Nazwa, ' - ', tk.Part), '')
            WHERE
                tk2.Symbol = tk.ParentSymbol
                AND tk.Status <> _CS_EXIST
            ;
        
        
            SET @Ile = @Ile - 1;
            
        END WHILE;
            
        DROP TEMPORARY TABLE IF EXISTS t_konto_tree_2;
        CREATE TEMPORARY TABLE t_konto_tree_2 
            SELECT * FROM t_konto_tree
        ;

        UPDATE t_konto_tree tk, t_konto_tree_2 tk2
        SET
            tk.Valid_Len = tk2.dl_potomka
        WHERE
            tk2.Symbol = tk.ParentSymbol
            AND tk.Status <> _CS_EXIST
        ;
        
        
        UPDATE t_konto_tree tk
        SET
            tk.Status = IF(tk.Valid_Len = My_Len, _CS_CREATE, _CS_INVALID)
        WHERE
            tk.Status = _CS_INVALID
        ;
        
        UPDATE t_konto_tree tk
        SET
            tk.GUID = NewGUID(),
            tk.dl_potomka = IF(dl_potomka = -1, 0, dl_potomka),
            tk.Dzieci = (
                SELECT _VarINT(Count(*)) FROM t_konto_tree_2 tk2
                WHERE
                    tk.Symbol = tk2.ParentSymbol
            )        
            
        WHERE
            tk.Status = _CS_CREATE
        ;
        SELECT 
            GUID 
        INTO
            @LastKontoGUID
        FROM t_konto_tree tk 
        WHERE 
            symbol = _KontoSave
        ;
        
        SELECT 
            symbol 
        INTO
            @SymbolKonta
        FROM t_konto_tree tk 
        WHERE 
            symbol = _KontoSave
        ;
        
        
        UPDATE t_konto_tree tk
        SET
            tk.ObcyGUID = _ObcyGUID,
            tk.nazwa = IF(_Konto_opis != '', _Konto_opis, nazwa)
        WHERE
            tk.Symbol = _KontoSave
        ;
        
        SELECT
            Status INTO @FinalStatus
        FROM t_konto_tree
        WHERE
            Symbol = _KontoSave
        ;
        
        SET _ErrNo = IF(@FinalStatus != _CS_INVALID, 0, 2);
        

        IF _ErrNo = 0 THEN
            INSERT INTO plankont
                (guid, symbol, nazwa, analityka, dl_potomka, poziom, dzieci, symbol_fmt, rok, ObcyGUID, pozabilans)
                SELECT    
                    tk.guid, tk.symbol, tk.nazwa, tk.Part, tk.dl_potomka, tk.poziom, tk.dzieci, tk.symbol_fmt, _Okres, tk.ObcyGUID, tk.pozabilans
                FROM t_konto_tree tk
                WHERE
                    tk.Status = _CS_CREATE
            ;
        END IF;
    
        IF FALSE THEN
        SELECT * FROM t_konto_tree;
        
        END IF;
        
        
    END IF;
    SET @_ErrNo = _ErrNo;
    
END IF;    --    IF _MODE = 'CREATE_ONE'


/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'BUILD_ALL_NOT_EXISTS_FROM_ZAPISY'
    Zakłada temtablea z kontami brakującymi - wszystkie konta z zapisów w danym okresie (_Okres) lub danej operacji (_ParamA) nie istniejące w planie kont
    Parametry
        _Okres        okres obrachunkowy    
        _Param_A        idnoper
        _Param_B        cokolowiek dla select
    CALL fk_konta_tools('BUILD_ALL_NOT_EXISTS_FROM_ZAPISY', '', '2019', '', '', '', '');
    CALL fk_konta_tools('BUILD_ALL_NOT_EXISTS_FROM_ZAPISY', '', '', 'idnoper', '', '', '');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'BUILD_ALL_NOT_EXISTS_FROM_ZAPISY' THEN
    SET @jest_idnoper=0,@rok_idnoper=_ROK;
    IF _Param_A != '' THEN -- kompatybilnosc wsteczna
        SELECT count(*),max(rok)  FROM zapisy WHERE idnoper=_Param_A INTO @jest_idnoper,@rok_idnoper;
        IF @jest_idnoper=0 THEN 
            SET _Param_B=_Param_A,_Param_A='';
        ELSE
            SET _ROK = @rok_idnoper;
        END IF;
    END IF;
    SET _ROK = IFNULL(_ROK,YEAR(CURRENT_DATE));
    DROP TEMPORARY TABLE IF EXISTS t_konta_not_exists;
    CREATE TEMPORARY TABLE t_konta_not_exists
        SELECT 
            distinct z.konto,z.rok,
            _VarInt(0) AS Exist
        FROM zapisy z
        LEFT JOIN plankont p on p.symbol=z.konto and p.rok=z.rok
        WHERE
            isnull(p.symbol) and z.konto<>'' and 
            z.Rok=_ROK and
            (z.idnoper=_Param_A OR @jest_idnoper=0)
            
    ;
    IF _Param_B != '' THEN
        SELECT 
            konto
        FROM t_konta_not_exists
    ;
    END IF;
    
END IF;


/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'CREATE_ALL_FROM_ZAPISY'
    Zakłada konta brakujące konta w planie kont - wszystkie konta z zapisów w danym okresie nie istniejące w planie kont
    Parametry
        _Okres        okres obrachunkowy    
        _Param_A    Tylko gdy <> '' to nie buduje zestawu CALL fk_konta_tools('BUILD_ALL_NOT_EXISTS_FROM_ZAPISY'... zostawia bo zestaw jest dany "z zewnątrz"
    CALL fk_konta_tools('CREATE_ALL_FROM_ZAPISY', '', '2019', '', '', '', '');        
    CALL fk_konta_tools('CREATE_ALL_FROM_ZAPISY', '', '2019', '', '1', '', '');    kreuj ale nie twporz tempa t_konta_not_exists bo juz istnieje    
    CALL fk_konta_tools('CREATE_ALL_FROM_ZAPISY', '', '', 'idnoper', '', '', '');        
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'CREATE_ALL_FROM_ZAPISY' THEN
    SET @jest_idnoper=0;
    IF _Param_A != '' THEN -- kompatybilnosc wsteczna
        SELECT count(*) FROM zapisy WHERE idnoper=_Param_A INTO @jest_idnoper;
        IF @jest_idnoper=0 THEN 
            SET _Param_B=_Param_A,_Param_A='';
        END IF;
    END IF;
    IF (IFNULL(_Param_B, '') = '') THEN
        CALL fk_konta_tools('BUILD_ALL_NOT_EXISTS_FROM_ZAPISY', '', _Okres, _Param_A, _Param_B, _Param_C, _Param_D);        
    END IF;
    BEGIN
        DECLARE _CurrSymbolKonta VARCHAR(250);    -- kolejne zakladane konto (w petli)
        DECLARE done BOOL DEFAULT FALSE;
        DECLARE c_proc CURSOR FOR
            SELECT 
                konto,rok
            FROM t_konta_not_exists
        ;

        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
        OPEN c_proc;
        loop1: LOOP
            FETCH c_proc INTO
                _CurrSymbolKonta,_Rok    -- kolejne zakladane konto (w petli)
            ;
            IF done THEN
                LEAVE loop1;
            ELSE
                -- kolejny rekord -> wołaj zakładanie konta dla _CurrSymbolKonta
                CALL fk_konta_tools('CREATE_ONE', _CurrSymbolKonta, _Rok, '', '', '', '');        
                -- ustaw pole exist jesli pole zostalo zalozone
                UPDATE t_konta_not_exists    k, t_konto_tree t
                SET
                    k.Exist = 1
                WHERE
                    t.Symbol = k.konto
                    AND t.Status IN (0, 1)
                ;
            END IF;
        END LOOP;
        CLOSE c_proc;
    END;
    IF @jest_idnoper>0 THEN
        UPDATE zapisy z, plankont p SET z.pozabilans=p.pozabilans 
        WHERE z.konto=p.symbol AND z.rok=p.rok and z.idnoper=_Param_A AND z.pozabilans!=p.pozabilans;
    END IF;

-- zwracaj niezalozone !!!!!!!!!!    
    SELECT 
        * 
    FROM t_konta_not_exists 
    WHERE 
        Exist = 0
    ;
END IF;    --    IF _MODE = 'CREATE_ALL_FROM_ZAPISY'




/*------------------------------------------------------------------------------------------------------------------------------------------------------------------    
'CREATE_NEW_FOR_OBCY_GUID'
    Zakłada konta brakujące konta w planie kont - wszystkie konta z zapisów w danym okresie nie istniejące w planie kont
    Parametry
        _Okres        okres obrachunkowy    
        _Param_A    Tylko gdy <> '' ?!
        _Param_B    Separator
        _Param_C    Opis
        _Param_D    Idn kontrahenta        
    CALL fk_konta_tools('CREATE_NEW_FOR_OBCY_GUID', '', '2019', '', '', '', '');        
    
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/    
IF _MODE = 'CREATE_NEW_FOR_OBCY_GUID' THEN
    SET _Param_A = IFNULL(_Param_A, '');
    SET _Param_B = IFNULL(_Param_B, '');
    SET _Param_C = IFNULL(_Param_C, '');
    SET _Param_D = IFNULL(_Param_D, '');
    
    SET @_tmp_dl_potomka = 0;
    
    -- IF (IFNULL(_Param_A, '') = '') THEN
    -- END IF;
    IF (@session.FK.IR.Tworzenie_kont_z_Analityki_kontrah IS NULL) OR (@session.FK.IR.Tworzenie_kont_z_IDN_kontrah IS NULL) THEN
        CALL _Session_Refresh_Variables('FK', 'konta', '');
    END IF;
    -- CALL _IReg_Get('FK', 'Tworzenie_kont_z_Analityki_kontrah', 0, 'BOOLEAN', @session.FK.IR.Tworzenie_kont_z_Analityki_kontrah, FALSE); 
    -- CALL _IReg_Get('FK', 'Tworzenie_kont_z_IDN_kontrah', 0, 'BOOLEAN', @session.FK.IR.Tworzenie_kont_z_IDN_kontrah, FALSE); 
    IF @session.FK.IR.Tworzenie_kont_z_Analityki_kontrah then 
        SET _Metoda = 0; -- CCreateKontoForAnalityka
    ELSE 
        IF @session.FK.IR.Tworzenie_kont_z_IDN_kontrah then 
            SET _Metoda = 1; -- CCreateKontoForIdn
        ELSE 
            SET _Metoda = 2; -- CCreateKontoMax
        END IF;
    END IF;
    
    IF _Metoda = 0 THEN -- CCreateKontoForAnalityka
    -- PRZYKŁAD
        SELECT 
            analityka 
        INTO 
            @_Analityka
        FROM kontrah
        WHERE
            idn = _Param_D
        ;    
    END IF;
    IF _Metoda = 1 THEN -- CCreateKontoForIdn
        SELECT 
            idn 
        INTO 
            @_Analityka
        FROM kontrah
        WHERE
            idn = _Param_D
        ;    
    END IF;
    IF _Metoda = 2 THEN -- CCreateKontoMax
        SELECT 
            MAX(Analityka)
        INTO 
            @_Analityka
        FROM plankont
        WHERE
            symbol LIKE CONCAT(_Konto,'|%') AND Rok = _ROK 
        LIMIT 1
        ;
        IF _varIs_Number(IFNULL(@_Analityka, '')) THEN            
            SET @_Analityka = @_Analityka + 1; 
        ELSE
            SELECT 1 AS ErrNo, _VarStr(Concat('Błędna analityka:\n ', @_Analityka, '\n w planie kont')) AS Msg, _VarStr('') as LastKontoGUID, _VarStr(@SymbolKonta) as SymbolKonta;
            LEAVE SPROC;  
        END IF;
    END IF;
    
    SELECT 
        dl_potomka 
    INTO 
        @_tmp_dl_potomka 
    FROM 
        plankont 
    WHERE 
        rok = _ROK AND symbol = _Konto;

    select 
        LPAD(@_Analityka, @_tmp_dl_potomka, '0') INTO @_Analityka ; 
    
    set _Konto = concat(_Konto,'|',@_Analityka);
    CALL fk_konta_tools('CREATE_IF_NOT_EXIST', _Konto, _Okres, _Param_A, _Param_B, _Param_C, '');        

END IF;    --    IF _MODE = 'CREATE_NEW_FOR_OBCY_GUID'

/*
CALL fk_konta_tools('JPKCITbyPARENT', '', '2025', '', '', '', '');
CALL fk_konta_tools('JPKCITbyPARENT', '*|201', '2025', '', '', '', 'DEBUG');
*/


IF _MODE = "JPKCITbyPARENT" THEN
    SET @fk_konta_tools.mode=_MODE;
    SET _KONTO=IF(_KONTO='', '', CONCAT(_KONTO,'|%'));
    SELECT MAX(poziom) INTO _Poziom FROM plankont WHERE rok=_ROK AND (_KONTO='' OR symbol LIKE _KONTO);
    SELECT _Poziom,_ROK,_KONTO,_DEBUG;

    IF _Poziom<2 THEN
        LEAVE sproc;
    END IF;

    SET @poziom=1,@ile=0;
    
    WHILE @poziom<_Poziom DO
        DROP TABLE IF EXISTS tmp_jpkcit;
        CREATE TABLE tmp_jpkcit AS
        SELECT CONCAT(symbol,'|%') AS symbol, jpkcit, jpkcit2, jpkcit3, typ_konta
        FROM plankont
        WHERE rok = _ROK AND poziom = @poziom AND 
            dl_potomka>0 AND
            IFNULL(jpkcit, '') != '' AND
            (_KONTO='' OR symbol LIKE _KONTO);
        ALTER TABLE tmp_jpkcit ADD INDEX idx_symbol (symbol);
        IF _DEBUG THEN
            SELECT * FROM tmp_jpkcit;
        END IF;
        SELECT COUNT(*) INTO @ile FROM tmp_jpkcit;
        SELECT @poziom,@ile;
        IF @ile>0 THEN

            UPDATE plankont p , tmp_jpkcit t
            SET p.jpkcit=t.jpkcit, p.jpkcit2=t.jpkcit2, p.jpkcit3=t.jpkcit3, p.typ_konta=t.typ_konta, p.kategoria='AUTOJPKCIT'
            WHERE p.rok = _ROK AND p.poziom = @poziom +1 AND p.symbol LIKE t.symbol AND 
                (IFNULL(p.jpkcit, '') = '' OR p.kategoria='AUTOJPKCIT');
            
            DROP TABLE tmp_jpkcit;
        END IF;
        SET @poziom = @poziom + 1;
    END WHILE;
END IF;
    
END$$

DELIMITER ;

/* REWIZJE
$Log: fk_konta_tools.sql,v $
Revision 1.16  2025/12/30 09:48:52  apro
reformat2

Revision 1.15  2025/12/30 09:47:54  apro
reformat

Revision 1.14  2022/07/11 05:58:31  apro
zabezpieczenie przed brakiem roku
$SEND$

Revision 1.13  2020/03/12 13:45:08  rafalg
dodanie EXIST_ANAL
$SEND$

Revision 1.12  2019/02/05 09:47:50  apro
kosmetyka - 2019

Revision 1.11  2018/10/23 08:24:17  apro
$SEND$
kosmetyka

Revision 1.10  2018/09/19 10:23:25  apro
dodanie modu zakładania kont dla wskazanej operacji
$SEND$

Revision 1.9  2017/03/21 12:42:56  apro
poprawka _ROK2 -
$SEND$

Revision 1.8  2017/03/02 08:39:11  apro
kosmetyka

*/


