 /*!40101 SET NAMES utf8 */;
DELIMITER $$

DROP PROCEDURE IF EXISTS `fr_pl_zest`$$

CREATE DEFINER=`root`@`localhost` PROCEDURE `fr_pl_zest`(
    IN _MODE VARCHAR(38),
    IN _GUID VARCHAR(38),
    IN _ROK VARCHAR(38),
    IN _MIESIAC VARCHAR(38),
    IN _WHERE_SQL TEXT,
    IN _Param_A VARCHAR(50),
    IN _Param_B VARCHAR(255))
SPROC: BEGIN
    DECLARE _S TEXT DEFAULT '';
    DECLARE _WHERE TEXT DEFAULT '';
    DECLARE _i TINYINT;
	DECLARE _stawka DOUBLE(16,4);
	DECLARE _ncp DOUBLE(16,4);

	DECLARE _od VARCHAR(10);
	DECLARE _do VARCHAR(10);
	DECLARE _dzien, _dzien1, _dzien2, _dzienA, _dzienB VARCHAR(10);
	DECLARE _LP INT;
	DECLARE _done BOOL;

    SET _WHERE_SQL = IFNULL(_WHERE_SQL, '');

    SET SESSION group_concat_max_len = 1024*1024*1024;

/*
 CALL fr_pl_zest('PLACE_ListaEkwiwalentow','','2012','12','','','');
*/

    IF (_MODE = 'PLACE_ListaEkwiwalentow') THEN
    DROP TABLE IF EXISTS t01;

      CREATE TEMPORARY TABLE t01
      SELECT
      CONCAT(o.nazwisko,' ',o.imiona) AS osoba,
      o.guid AS osobaGUID,
      pl.rok AS rok,
      pl.miesiac AS miesiac,
      #dsp.nazwa,
      SUM(IF(dsp.ZnaczenieSkladnika=121, pls.kwota,0)) AS a01,
      SUM(IF(dsp.ZnaczenieSkladnika=131, pls.kwota,0)) AS a02,
      SUM(IF(dsp.ZnaczenieSkladnika=161, pls.kwota,0)) AS a03,
      SUM(IF(dsp.ZnaczenieSkladnika=171, pls.kwota,0)) AS a04,
      SUM(IF(dsp.ZnaczenieSkladnika=111, pls.kwota,0)) AS a05,
      SUM(IF(dsp.ZnaczenieSkladnika=151, pls.kwota,0)) AS a06,
      SUM(IF(dsp.ZnaczenieSkladnika=122, pls.kwota,0)) AS a07,
      SUM(IF(dsp.ZnaczenieSkladnika=132, pls.kwota,0)) AS a08,
      SUM(IF(dsp.ZnaczenieSkladnika=162, pls.kwota,0)) AS a09,
      SUM(IF(dsp.ZnaczenieSkladnika=172, pls.kwota,0)) AS a10,
      SUM(IF(dsp.ZnaczenieSkladnika=112, pls.kwota,0)) AS a11,
      SUM(IF(dsp.ZnaczenieSkladnika=152, pls.kwota,0)) AS a12,
      SUM(IF(dsp.ZnaczenieSkladnika=123, pls.kwota,0)) AS a13,
      SUM(IF(dsp.ZnaczenieSkladnika=133, pls.kwota,0)) AS a14,
      SUM(IF(dsp.ZnaczenieSkladnika=163, pls.kwota,0)) AS a15,
      SUM(IF(dsp.ZnaczenieSkladnika=173, pls.kwota,0)) AS a16,
      SUM(IF(dsp.ZnaczenieSkladnika=113, pls.kwota,0)) AS a17,
      SUM(IF(dsp.ZnaczenieSkladnika=153, pls.kwota,0)) AS a18,
      SUM(IF(dsp.ZnaczenieSkladnika=124, pls.kwota,0)) AS a19,
      SUM(IF(dsp.ZnaczenieSkladnika=134, pls.kwota,0)) AS a20,
      SUM(IF(dsp.ZnaczenieSkladnika=164, pls.kwota,0)) AS a21,
      SUM(IF(dsp.ZnaczenieSkladnika=174, pls.kwota,0)) AS a22,
      SUM(IF(dsp.ZnaczenieSkladnika=114, pls.kwota,0)) AS a23,
      SUM(IF(dsp.ZnaczenieSkladnika=154, pls.kwota,0)) AS a24,
      SUM(IF(dsp.ZnaczenieSkladnika=125, pls.kwota,0)) AS a25,
      SUM(IF(dsp.ZnaczenieSkladnika=135, pls.kwota,0)) AS a26,
      SUM(IF(dsp.ZnaczenieSkladnika=165, pls.kwota,0)) AS a27,
      SUM(IF(dsp.ZnaczenieSkladnika=175, pls.kwota,0)) AS a28,
      SUM(IF(dsp.ZnaczenieSkladnika=115, pls.kwota,0)) AS a29,
      SUM(IF(dsp.ZnaczenieSkladnika=155, pls.kwota,0)) AS a30,

      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (121,122,123,124,125) AND pls2.guid_zapisu_placowego=pl.guid) AS b01,
      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (131,132,133,134,135) AND pls2.guid_zapisu_placowego=pl.guid) AS b02,
      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (161,162,163,164,165) AND pls2.guid_zapisu_placowego=pl.guid) AS b03,
      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (171,172,173,174,175) AND pls2.guid_zapisu_placowego=pl.guid) AS b04,
      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (111,112,113,114,115) AND pls2.guid_zapisu_placowego=pl.guid) AS b05,
      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (151,152,153,154,155) AND pls2.guid_zapisu_placowego=pl.guid) AS b06,
/*
      CASE WHEN dsp.nazwa LIKE '%szkĂłĹ‚ka%' THEN 'szkolka'
      WHEN dsp.nazwa LIKE '%poz. drewna%' THEN 'pozysk'
      WHEN dsp.nazwa LIKE '%hod. ciÄ™ĹĽka%' THEN 'h ciezka'
      WHEN dsp.nazwa LIKE '%hod. lekka%' THEN 'h lekka'
      WHEN dsp.nazwa LIKE '%kier.%zr-1%' THEN 'zr1'
      WHEN dsp.nazwa LIKE '%kier.%zr-2%' THEN 'zr2'
      END AS grupa,

      CASE WHEN dsp.nazwa LIKE '%za pilar%' THEN 'pilarka'
      WHEN dsp.nazwa LIKE '%za pranie%' THEN 'pranie'
      WHEN dsp.nazwa LIKE '%snej odz%' THEN 'odziez'
      WHEN dsp.nazwa LIKE '%snych narz%' THEN 'narzedzia'
      WHEN dsp.nazwa LIKE '%hig%' THEN 'higiena'
      END AS grupa2,
*/
      SUM(pls.kwota) AS kwota,

      (SELECT SUM(pls2.kwota) FROM place_skladniki pls2
      LEFT JOIN definicja_skladnika_placy dsp2 ON dsp2.guid=pls2.guid_definicja_skladnika_placy
      WHERE dsp2.ZnaczenieSkladnika IN (121,131,161,171,111,151,122,132,162,172,112,152,
      123,133,163,173,113,153,124,134,164,174,114,154,125,135,165,175,115,155)
      AND pls2.guid_zapisu_placowego=pl.guid) AS dowyplaty

      FROM place pl
      INNER JOIN osoby o ON o.guid=pl.GUID_pracownika
      LEFT JOIN place_skladniki pls ON pl.guid=pls.guid_zapisu_placowego
      LEFT JOIN definicja_skladnika_placy dsp ON dsp.guid=pls.guid_definicja_skladnika_placy
      WHERE pl.rok=_ROK AND pl.miesiac=_MIESIAC
      AND dsp.ZnaczenieSkladnika IN (121,131,161,171,111,151,122,132,162,172,112,152,
     123,133,163,173,113,153,124,134,164,174,114,154,125,135,165,175,115,155)
		AND pl.deleted=0
      GROUP BY o.guid
      ORDER BY osoba;

      SELECT
      t.*,
      ZUL_godz_hod_ciezka AS godz01,
      ZUL_godz_hod_lekka AS godz02,
      ZUL_operator_ciagnika_1 AS godz03,
      ZUL_operator_ciagnika_2 AS godz04,
      ZUL_godz_pozysk_drewna AS godz05,
      ZUL_godz_hod_szkolka AS godz06
      FROM t01 t
      LEFT JOIN frekw f ON t.osobaguid=f.pracGUID AND f.rok=t.rok AND f.miesiac=t.miesiac AND f.deleted=0;

      DROP TABLE IF EXISTS t01;

    END IF;    --    IF _MODE = 'PLACE_ListaEkwiwalentow'


	IF (_MODE = 'PLACE_OdprawyEmerytalne') THEN
	-- CALL fr_pl_zest('PLACE_OdprawyEmerytalne','','2018','','','2','3');

		SET @rok = _ROK;
		SET @wzrost = _Param_A;
		SET @dyskonto = _Param_B;

		SET @okresy = 1;

		SELECT o.nazwisko, o.imiona,
		kp.nazwa AS kategoria,
		IF(o.plec=0,'K','M') AS plec, o.dataurodzenia,
		YEAR(p.DataZatrudnieniaWzakl) AS rok_rozp_pracy,
		@lata := @rok-YEAR(p.DataZatrudnieniaWzakl) AS lata_przepracoane,
		@lata_do := IF(plec=0,60-@lata,65-@lata) AS lata_do_przepracowania,

		@podstawa := (SELECT _Rnd2(IFNULL(SUM(PodstFchorobowy)/3,0)) FROM place WHERE guid_pracownika=o.guid AND rok=@rok-1 AND miesiac IN (10,11,12))
		AS podstawa,
		@podstawa_sk := _Rnd2(@podstawa*POW(1+@wzrost/100,@lata_do)/POW(1+@dyskonto/100,@lata_do)) AS podstawa_skorygowana,

		_Rnd2(@podstawa_sk*1) AS kwota_odprawy,
		IF(@podstawa>0, @lata+@lata_do, 0) AS okres_pracy,

		@odpis1 := _Rnd2(@podstawa_sk/@lata_do) AS odpis1,
		IF(@lata>0,_Rnd2(@odpis1),0) AS odpis_br
		FROM osoby o
		INNER JOIN Pracownicy p ON p.guid=o.guid
		LEFT JOIN kategorie_pracownikow kp ON kp.idn = p.KategoriaPracownicza
		WHERE o.deleted = 0 AND p.czyobecniepracuje = 1;


	END IF;

/*
CALL fr_pl_zest('LICZBA_DNI_183','','','','','2020-10-29','AUTOID18621');
CALL fr_pl_zest('LICZBA_DNI_183_ZLEC','','','','','2019-09-25','aaa');
CREATE TEMPORARY TABLE t_prace_zlecone (guid VARCHAR(38));
INSERT INTO t_prace_zlecone VALUES ('{7C4206E7-D191-4FB3-80BB-B1DDB46564EE}'),('{12574416-BEDE-4565-85BB-68605E52E45D}');

Mode LICZBA_DNI_183_NALICZANIE sluzy do wywoloania procedury z naliczania umow-zlecen - i badania pracownikow podanych tam, bez ograniczen, za to bioraca pod uwage umowe tworzona (daty tej umowy, choc jeszcze jej nie ma)

*/
	IF (_MODE = 'LICZBA_DNI_183') THEN

		SET @NaDzien = _Param_A;
		SET @OdDnia = CONCAT(YEAR(_Param_A),'-01-01');

		DROP TABLE IF EXISTS tt_prac;
		CREATE TEMPORARY TABLE tt_prac (
			guid VARCHAR(38),
			DataOd VARCHAR(10),
			dni_absencji INT(11),
			dni_pobytu INT(10),
			KEY guid (guid)
		) DEFAULT CHARSET=utf8;

			INSERT INTO tt_prac
			SELECT o.guid, @OdDnia,
				0 AS dni_absencji,
				0
			FROM osoby o, Pracownicy p
				WHERE o.guid=p.guid
				-- AND p.rezydent=2 wylaczam warunek na podstawie ustalen w Criscie
				AND DATE_ADD(@NaDzien, INTERVAL -2 MONTH) <= p.ZlecenieDo
				AND @NaDzien >= p.ZlecenieOd
				AND p.ZlecenieDo IS NOT NULL
				AND  IF(_Param_B='',TRUE, o.guid = _Param_B)
				AND o.guid IN (SELECT DISTINCT guid_pracownika FROM prace_zlecone WHERE rodzajryczaltu=2 AND deleted=0)
			GROUP BY o.guid
			;

		UPDATE tt_prac t SET t.DataOd =
			(SELECT MIN(dataod) FROM prace_zlecone WHERE YEAR(datawyplaty)= YEAR(_Param_A) AND rodzajryczaltu=2 AND deleted=0
				AND guid_pracownika = t.guid);

		UPDATE tt_prac t SET t.DataOd = @OdDnia WHERE t.DataOd is null OR t.DataOd < @OdDnia;


		UPDATE tt_prac t SET t.dni_absencji =
		IFNULL((SELECT SUM(DATEDIFF(IF(absencjado > @NaDzien,@Nadzien,absencjado),IF(absencjaod < DataOd,DataOd,absencjaod))+1)
			FROM absencje_obco WHERE guidpr = t.guid AND absencjado > DataOd),0);

		UPDATE tt_prac t SET t.dni_absencji = 0 WHERE t.dni_absencji < 0;

-- SUM(DATEDIFF(IF(a.absencjado>@NaDzien,@Nadzien,a.absencjado),IF(absencjaod<@OdDnia,@OdDnia,a.absencjaod))) AS dni_absencji,


		UPDATE tt_prac t, Pracownicy p
			SET t.dni_pobytu = (DATEDIFF(@NaDzien, DataOd)+1) - (dni_absencji) + p.LiczbaDniWPolsce
			WHERE t.guid=p.guid;


		SELECT '-' AS guid_zlecenia, o.guid, o.nazwisko, o.imie1 as imie, o.imie2, o.NrPesel as `Nr pesel`, NrPaszportu as `Nr paszportu`,
			p.NrEmerytury as `Nr emerytury`,
			p.ZlecenieOd as `Zlecenie od`, p.ZlecenieDo as `Zlecenie do`,
			IF(IFNULL(dni_pobytu,0) < 0,0,IFNULL(dni_pobytu,0)) AS Dni
		FROM osoby o, Pracownicy p, tt_prac t
		WHERE o.guid = t.guid AND o.guid = p.guid
			ORDER BY o.nazwisko, o.imie1;
	END IF;

	-- CALL fr_pl_zest('LICZBA_DNI_183_NALICZANIE','','','','','','');
	IF (_MODE = 'LICZBA_DNI_183_NALICZANIE') THEN
		DROP TABLE IF EXISTS tt_prac;
		CREATE TEMPORARY TABLE tt_prac (
			guid VARCHAR(38),
			DataPocz VARCHAR(10), -- data naliczania dni, zazwyczaj 1 stycznia, ale niekoniecznie!
			DataBadania VARCHAR(10), -- dzien, na ktory badamy przekroczenie, zazwyczaj data konca umowy
			data_od VARCHAR(10), -- data poczatku badanej umowy
			data_do VARCHAR(10), -- data konca badanej umowy
			dni_absencji INT(11),
			dni_pobytu INT(10),
			KEY guid (guid)
		) DEFAULT CHARSET=utf8;

			INSERT INTO tt_prac
			SELECT o.guid,
				'',
				-- t.data_do, to jest niezodne z modem LICZBA_DNI_183_ZLEC, ktory opiera sie na dacie wyplaty
				t.data_wyplaty,
				t.data_od,
				t.data_do,
				0 AS dni_absencji,
				0
			FROM osoby o, Pracownicy p, tt_dane_zlecenia t
				WHERE o.guid = p.guid AND t.guid = o.guid
 				-- AND DATE_ADD(@NaDzien, INTERVAL -2 MONTH) <= _varStr(p.ZlecenieDo)
				AND t.data_do >= p.ZlecenieOd
				AND p.ZlecenieDo IS NOT NULL

			GROUP BY o.guid
			;

		UPDATE tt_prac t SET t.DataPocz =
			(SELECT MIN(dataod) FROM prace_zlecone WHERE YEAR(datawyplaty)= YEAR(data_do) AND rodzajryczaltu=2 AND deleted=0
				AND guid_pracownika = t.guid);

		UPDATE tt_prac t SET t.DataPocz = t.data_od WHERE t.DataPocz is null;
		UPDATE tt_prac t SET t.DataPocz = CONCAT(YEAR(DataBadania),'-01-01') WHERE t.DataPocz < CONCAT(YEAR(DataBadania),'-01-01');

		UPDATE tt_prac t SET t.dni_absencji =
		IFNULL((SELECT SUM(DATEDIFF(IF(absencjado > DataBadania,DataBadania,absencjado),IF(absencjaod < DataPocz,DataPocz,absencjaod))+1)
			FROM absencje_obco WHERE guidpr = t.guid AND absencjado > DataPocz),0);

		UPDATE tt_prac t SET t.dni_absencji = 0 WHERE t.dni_absencji < 0;

-- SUM(DATEDIFF(IF(a.absencjado>@NaDzien,@Nadzien,a.absencjado),IF(absencjaod<@OdDnia,@OdDnia,a.absencjaod))) AS dni_absencji,


		UPDATE tt_prac t, Pracownicy p
			SET t.dni_pobytu = (DATEDIFF(t.DataBadania, DataPocz)+1) - (dni_absencji) + p.LiczbaDniWPolsce
			WHERE t.guid=p.guid;

	END IF; -- 'LICZBA_DNI_183_NALICZANIE'

	-- CALL fr_pl_zest('LICZBA_DNI_183_NALICZANIE_WER2','GUID_pracownika','rok','','','','');
	IF (_MODE = 'LICZBA_DNI_183_NALICZANIE_WER2') THEN
		DROP TABLE IF EXISTS tt_dni;
		CREATE TEMPORARY TABLE tt_dni (
			guid VARCHAR(38),
			dzien VARCHAR(10), -- data roku w ciagu roku
			umowa INT, -- znacznik, czy jest umowa/aneks na dany dzien
			KEY guid (guid)
		) DEFAULT CHARSET=utf8;

		set _dzien1 = concat(_rok, '-01-01');
		set _dzien2 = concat(_rok, '-12-31');

		set _dzien = _dzien1;
		SET _LP = 1;

		REPEAT
			INSERT INTO tt_dni
			VALUES(_GUID, _dzien, 0);

			SET _dzien = DATE_ADD(_dzien, interval 1 day);
			SET _LP = _LP + 1;
		UNTIL _LP > 366
		END REPEAT;

		DELETE FROM tt_dni WHERE YEAR(dzien) <> _rok;

		SET @test1 = CONCAT(_GUID, '-',_dzien1, _dzien2);

		BEGIN
			DECLARE _zlec_c CURSOR FOR
			SELECT
				GUID, datazawarcia, DataDo
			FROM umowa_zlecenie
			WHERE GUID_pracownika = _GUID
			AND ((_dzien1 BETWEEN datazawarcia AND DataDo) OR (_dzien2 BETWEEN datazawarcia AND DataDo));

			DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;

			SET _GUID = '';

			SET _done = FALSE;

			OPEN _zlec_c;
			loopF: LOOP
				FETCH _zlec_c INTO
					_GUID, _dzienA, _dzienB;

					SET @test2 = CONCAT(_GUID, '-',_dzienA, _dzienB);

				IF _done THEN
						set @co = 'spadamy';
						LEAVE loopF;
				ELSE
					SET @test3 = CONCAT(_GUID, '-',_dzienA, _dzienB);
					update tt_dni SET umowa = 1;
					-- WHERE dzien BETWEEN _dzienA AND _dzienB;

				END IF;

			END LOOP;
			CLOSE _zlec_c;

		END;











/*
			INSERT INTO tt_prac
			SELECT o.guid,
				'',
				-- t.data_do, to jest niezodne z modem LICZBA_DNI_183_ZLEC, ktory opiera sie na dacie wyplaty
				t.data_wyplaty,
				t.data_od,
				t.data_do,
				0 AS dni_absencji,
				0
			FROM osoby o, Pracownicy p, tt_dane_zlecenia t
				WHERE o.guid = p.guid AND t.guid = o.guid
 				-- AND DATE_ADD(@NaDzien, INTERVAL -2 MONTH) <= _varStr(p.ZlecenieDo)
				AND t.data_do >= p.ZlecenieOd
				AND p.ZlecenieDo IS NOT NULL

			GROUP BY o.guid
			;

		UPDATE tt_prac t SET t.DataPocz =
			(SELECT MIN(dataod) FROM prace_zlecone WHERE YEAR(datawyplaty)= YEAR(data_do) AND rodzajryczaltu=2 AND deleted=0
				AND guid_pracownika = t.guid);

		UPDATE tt_prac t SET t.DataPocz = t.data_od WHERE t.DataPocz is null;
		UPDATE tt_prac t SET t.DataPocz = CONCAT(YEAR(DataBadania),'-01-01') WHERE t.DataPocz < CONCAT(YEAR(DataBadania),'-01-01');

		UPDATE tt_prac t SET t.dni_absencji =
		IFNULL((SELECT SUM(DATEDIFF(IF(absencjado > DataBadania,DataBadania,absencjado),IF(absencjaod < DataPocz,DataPocz,absencjaod))+1)
			FROM absencje_obco WHERE guidpr = t.guid AND absencjado > DataPocz),0);

		UPDATE tt_prac t SET t.dni_absencji = 0 WHERE t.dni_absencji < 0;

-- SUM(DATEDIFF(IF(a.absencjado>@NaDzien,@Nadzien,a.absencjado),IF(absencjaod<@OdDnia,@OdDnia,a.absencjaod))) AS dni_absencji,


		UPDATE tt_prac t, Pracownicy p
			SET t.dni_pobytu = (DATEDIFF(t.DataBadania, DataPocz)+1) - (dni_absencji) + p.LiczbaDniWPolsce
			WHERE t.guid=p.guid;

	*/


	END IF; -- 'LICZBA_DNI_183_NALICZANIE_WER2'


	IF (_MODE = 'LICZBA_DNI_183_ZLEC') THEN

		-- SET @NaDzien = _Param_A;
		SET @OdDnia = CONCAT((SELECT YEAR(datawyplaty) FROM prace_zlecone z, t_prace_zlecone t WHERE z.guid=t.guid LIMIT 1),'-01-01');

		DROP TABLE IF EXISTS tt_zlec;
		CREATE TEMPORARY TABLE tt_zlec (
		guid VARCHAR(38),
		guid_zlecenia VARCHAR(38),
		DataOd VARCHAR(10),
		DataWyplaty VARCHAR(10),
		dni_absencji INT(11),
		dni_pobytu INT(10),
		KEY guid (guid)
		) DEFAULT CHARSET=utf8;

		INSERT INTO tt_zlec
		SELECT z.guid_pracownika, z.guid AS guid_zlecenia, @OdDnia AS DataOd, z.datawyplaty,
				0 AS dni_absencji,
				0 AS dni_pobytu
		FROM t_prace_zlecone t
		INNER JOIN prace_zlecone z ON t.guid = z.guid
		INNER JOIN Pracownicy p ON z.guid_pracownika = p.guid
			WHERE -- p.rezydent=2 AND
				z.rodzajryczaltu=2
		;

		UPDATE tt_zlec t SET t.DataOd =
			(SELECT MIN(dataod) FROM prace_zlecone WHERE YEAR(datawyplaty)= YEAR(t.datawyplaty) AND rodzajryczaltu=2 AND deleted=0
				AND guid_pracownika = t.guid);

		UPDATE tt_zlec t SET t.DataOd = @OdDnia WHERE t.DataOd is null OR t.DataOd < @OdDnia;

		UPDATE tt_zlec t SET t.dni_absencji =
		IFNULL((SELECT SUM(DATEDIFF(IF(absencjado > datawyplaty,datawyplaty,absencjado),IF(absencjaod < DataOd,DataOd,absencjaod))+1)
			FROM absencje_obco WHERE guidpr = t.guid AND absencjado > DataOd),0);

		UPDATE tt_zlec t SET t.dni_absencji = 0 WHERE t.dni_absencji < 0;

		UPDATE tt_zlec t, Pracownicy p
			SET t.dni_pobytu = (DATEDIFF(datawyplaty, DataOd)+1) - (dni_absencji) + p.LiczbaDniWPolsce
			WHERE t.guid=p.guid;


		SELECT t.guid_zlecenia, o.guid, o.nazwisko, o.imie1 as imie, o.imie2, o.NrPesel as `Nr pesel`, NrPaszportu as `Nr paszportu`,
			p.NrEmerytury as `Nr emerytury`,
			p.ZlecenieOd as `Zlecenie od`, p.ZlecenieDo as `Zlecenie do`,
			IF(IFNULL(dni_pobytu,0) < 0,0,IFNULL(dni_pobytu,0)) AS Dni
		FROM osoby o, Pracownicy p, tt_zlec t
		WHERE o.guid = t.guid AND o.guid = p.guid
		HAVING IF(_Param_B = '', TRUE, dni > 183)
			ORDER BY o.nazwisko, o.imie1;


	END IF;

	IF (_MODE = 'CZAS_PRACY_RCP') THEN

	SET @fk.okrOd  = _varINT(_ROK) * 100 + _varINT(_MIESIAC);
	SET @fk.okrDo  =  @fk.okrOd;


	IF(_PARAM_A ='PRACOWNIK_DATA') THEN

		SELECT
			"RCP" AS Pochodzenie,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,DATE(StartTime_work) AS data_startu_pracy,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			h.StartTime_work AS czas_startu,h.EndTime_work AS czas_konca, ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy

		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND
		           s.param5=1
		GROUP BY o.guid, h.areaguid,data_startu_pracy


		UNION

		SELECT
			"GRF" AS Pochodzenie,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,g.DayWork ,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			d.StartTime AS czas_startu,'' AS czas_konca, ROUND(SUM(d.duration_min)/60,2) AS czas_pracy

		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY o.guid, g.areaguid,g.DayWork
		ORDER BY pracownik;




        END IF;
	IF(_PARAM_A ='PRACOWNIK_SKLEP') THEN
		SELECT
		"RCP" AS Pochodzenie,@fk.okrOd 	AS rok_miesiac,	s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			 ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy

		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND s.param5=1
		GROUP BY o.guid, h.areaguid

		UNION

		SELECT
			"GRF" AS Pochodzenie,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu ,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			 ROUND(SUM(d.duration_min)/60,2) AS czas_pracy

		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY o.guid, g.areaguid
		ORDER BY pracownik;
	END IF;
	IF(_PARAM_A ='SKLEP') THEN

		SELECT
		"RCP" AS Pochodzenie,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu, ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy

		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND s.param5=1
		GROUP BY  h.areaguid


		UNION


		SELECT
			"GRF" AS Pochodzenie,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,
			 ROUND(SUM(d.duration_min)/60,2) AS czas_pracy

		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY  g.areaguid
		ORDER BY nazwa_sklepu;



	END IF;
	END IF;

/*
zestawienie pokazujace pracownikow w okolicy 55 roku zycia, potrzebne do sprawdzenia deklaracji do PPK
p.NaliczajPPKpo55roku
CALL fr_pl_zest('PRACOWNICY_55','','','','','2019-11-28','');
*/
	IF (_MODE = 'PRACOWNICY_55') THEN

		SET @NaDzien = IF(_Param_A <> '', _Param_A, current_date());

		DROP TABLE IF EXISTS t1_prac;
		CREATE TEMPORARY TABLE t1_prac
		SELECT guid_pracownika AS guid, MAX(oddnia) AS oddnia
		FROM pracownicy_ppk
		WHERE deleted=0 AND oddnia <= @NaDzien
		GROUP BY guid_pracownika;

		DROP TABLE IF EXISTS tt_prac;
		CREATE TEMPORARY TABLE tt_prac (
		guid VARCHAR(38),
		oddnia DATE,
		aktywny INT(11),
		KEY guid (guid)
		);

		INSERT INTO tt_prac
		SELECT guid_pracownika AS guid,  p.oddnia, p.aktywnyppk
		FROM pracownicy_ppk p, t1_prac t WHERE p.deleted=0
			AND p.guid_pracownika = t.guid AND p.oddnia = t.oddnia;


		SELECT o.guid, o.nazwisko, o.imie1 AS imie, o.imie2, DataUrodzenia,
		DATE_ADD(dataurodzenia, INTERVAL 55 YEAR) AS data_graniczna,
		o.NrPesel, NrSeriaDowoduOsobistego AS NrDowodu
		FROM osoby o, Pracownicy p, tt_prac t
		WHERE o.guid = t.guid AND o.guid = p.guid
			AND p.NaliczajPPKpo55roku = 0 AND p.rezygnacja_z_PPK = 0
		HAVING data_graniczna <= DATE_ADD(@NaDzien, INTERVAL 2 MONTH)
			ORDER BY o.nazwisko, o.imie1;

	END IF;


/*
zestawienie dla Crist, pokazujace pracownikow i zleceniobiorcow w okolicy 55 roku zycia, ktorzy NIE sa w ppk
p.NaliczajPPKpo55roku
CALL fr_pl_zest('PRACOWNICY_55_V2','','','','','2021-06-17','');
*/
	IF (_MODE = 'PRACOWNICY_55_V2') THEN

		SET @NaDzien = IF(_Param_A <> '', _Param_A, current_date());

		DROP TABLE IF EXISTS t1_prac;
		CREATE TEMPORARY TABLE t1_prac
		SELECT guid_pracownika AS guid, MAX(oddnia) AS oddnia
		FROM pracownicy_ppk
		WHERE deleted=0 AND oddnia <= @NaDzien
		GROUP BY guid_pracownika;

		-- tabela potrzebna do wylapania planowanych/wpisanych, ale jeszcze nie obowiazujacych zgloszen do ppk - te maja byc w zestawieniu
		DROP TABLE IF EXISTS t3_prac;
		CREATE TEMPORARY TABLE t3_prac
		SELECT guid_pracownika AS guid, MAX(oddnia) AS oddnia
		FROM pracownicy_ppk
		WHERE deleted=0 AND oddnia > @NaDzien
		GROUP BY guid_pracownika;

		-- tabela z osobami zgloszonymi/aktywnymi w ppk - te wykluczamy z koncowego zestawienia
		DROP TABLE IF EXISTS t2_prac;
		CREATE TEMPORARY TABLE t2_prac (
		guid VARCHAR(38),
		oddnia DATE,
		aktywny INT(11),
		KEY guid (guid)
		);

		INSERT INTO t2_prac
		SELECT guid_pracownika AS guid,  p.oddnia, p.aktywnyppk
		FROM pracownicy_ppk p, t1_prac t
		WHERE p.deleted=0 AND p.guid_pracownika = t.guid AND p.oddnia = t.oddnia
		AND p.aktywnyppk=1;


		DROP TABLE IF EXISTS tt_prac;
		CREATE TEMPORARY TABLE tt_prac (
		guid VARCHAR(38),
		data_graniczna VARCHAR(10),
		data_zatrudnienia VARCHAR(10),
		rezygnacja_z_PPK INT(11),
		NaliczajPPKpo55roku INT(11),
		KEY guid (guid)
		);

		INSERT INTO tt_prac
		SELECT p.guid, DATE_ADD(dataurodzenia, INTERVAL 55 YEAR), DataZatrudnieniaWzakl, rezygnacja_z_PPK, p.NaliczajPPKpo55roku
		FROM Pracownicy p, osoby o
			WHERE o.guid=p.guid AND o.deleted=0 AND p.ToPracownik=1 AND p.czyobecniepracuje=1
			-- AND (DATE_ADD(dataurodzenia, INTERVAL 55 YEAR) > DataZatrudnieniaWzakl)
			-- AND DATE_ADD(DataZatrudnieniaWzakl, INTERVAL 3 MONTH) < @NaDzien
		;

		INSERT IGNORE INTO tt_prac
		SELECT p.guid, DATE_ADD(dataurodzenia, INTERVAL 55 YEAR), DataZatrudnieniaWzakl, rezygnacja_z_PPK, p.NaliczajPPKpo55roku
		FROM Pracownicy p, osoby o
		WHERE o.guid=p.guid AND o.deleted=0 AND p.ToZleceniobiorca=1 AND p.ZlecenieOkresowe=1
			AND ZlecenieDo >= @NaDzien
			-- AND DATE_ADD(dataurodzenia, INTERVAL 55 YEAR) > ZlecenieOd
			-- AND DATE_ADD(ZlecenieOd, INTERVAL 3 MONTH) < @NaDzien
		;


		SELECT o.guid, o.nazwisko, o.imie1 AS imie, o.imie2, DataUrodzenia,
		t.data_graniczna,
		o.NrPesel, NrSeriaDowoduOsobistego AS NrDowodu,
		p.ToPracownik, p.DataZatrudnieniaWzakl, p.ToZleceniobiorca, p.ZlecenieOd, p.ZlecenieDo,
		t3.oddnia AS oddnia,
		t.rezygnacja_z_PPK, t.NaliczajPPKpo55roku
		FROM osoby o
		inner JOIN Pracownicy p ON o.guid = p.guid
		inner join tt_prac t ON o.guid = t.guid
		left join t3_prac t3 on t.guid = t3.guid
		WHERE t.guid NOT IN (SELECT guid FROM t2_prac) AND o.obywatelstwo = 'polskie'
		AND ((IFNULL(t3.oddnia,'1900-01-01') >= @NaDzien AND DATE_ADD(data_zatrudnienia, INTERVAL 3 MONTH) < _varSTR(@NaDzien)) OR
				(t.rezygnacja_z_PPK = 0 AND t.data_graniczna > _varSTR(@NaDzien)) OR
				(data_graniczna <= @NaDzien AND t.NaliczajPPKpo55roku = 1)
				)
		-- AND p.NaliczajPPKpo55roku = 1

		-- HAVING NOT (data_graniczna < @NaDzien AND p.NaliczajPPKpo55roku = 1)
			ORDER BY o.nazwisko, o.imie1;

	END IF;


/*
zestawienie dla SPOA, pokazujace pracownikow i zleceniobiorcow którzy skonczyli 26 rok zycia
CALL fr_pl_zest('PRACOWNICY_26','','','','','2020-09-01','');
*/
	IF (_MODE = 'PRACOWNICY_26') THEN

		SET @NaDzien = IF(_Param_A <> '', _Param_A, current_date());

		DROP TABLE IF EXISTS tt_prac;
		CREATE TEMPORARY TABLE tt_prac (
		guid VARCHAR(38),
		KEY guid (guid)
		);

		INSERT INTO tt_prac
		SELECT p.guid
		FROM Pracownicy p, osoby o
			WHERE o.guid=p.guid AND o.deleted=0 AND p.ToPracownik=1 AND p.czyobecniepracuje=1
			AND p.ZwolnOdPodatku26LatPo2019 = 1
			AND DATE_ADD(dataurodzenia, INTERVAL 26 YEAR) < @NaDzien
		;

		INSERT IGNORE INTO tt_prac
		SELECT p.guid
		FROM Pracownicy p, osoby o
		WHERE o.guid=p.guid AND o.deleted=0 AND p.ToZleceniobiorca=1
			AND p.ZwolnOdPodatku26LatPo2019 = 1
			AND DATE_ADD(dataurodzenia, INTERVAL 26 YEAR) < @NaDzien
		;

		SELECT DISTINCT o.guid, o.nazwisko, o.imie1 AS imie, o.imie2, DataUrodzenia,
		DATE_ADD(dataurodzenia, INTERVAL 26 YEAR) AS data_graniczna,
		o.NrPesel, NrSeriaDowoduOsobistego AS NrDowodu,
		p.ToPracownik, p.DataZatrudnieniaWzakl, p.ToZleceniobiorca, p.ZlecenieOd, p.ZlecenieDo
		FROM osoby o, Pracownicy p, tt_prac t
		WHERE o.guid = t.guid AND o.guid = p.guid
			ORDER BY o.nazwisko, o.imie1;

	END IF;

IF (_MODE = 'CZAS_PRACY_RCP') THEN
	DROP TEMPORARY TABLE IF EXISTS czas_pracy_konkol;
	CREATE TEMPORARY TABLE czas_pracy_konkol
	(
	  pochodzenie  VARCHAR(10) ,
	  czas_prac DOUBLE(16,4),
	    rok_miesiac  VARCHAR(6) ,
	  symbol_sklepu    VARCHAR(15),
	  nazwa_sklepu   VARCHAR(50),
	  data_startu_pracy VARCHAR(15),
	  pracownik VARCHAR(30),
	  czas_startu VARCHAR(50),
	  czas_konca VARCHAR(50));

	SET @fk.okrOd  = _varINT(_ROK) * 100 + _varINT(_MIESIAC);
	SET @fk.okrDo  =  @fk.okrOd;
	IF(_PARAM_A ='PRACOWNIK_DATA') THEN

		INSERT INTO czas_pracy_konkol
		SELECT
			"RCP" AS Pochodzenie, ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy,@fk.okrOd AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,DATE(StartTime_work) AS data_startu_pracy,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			h.StartTime_work AS czas_startu,h.EndTime_work AS czas_konca

		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND
		           s.param5=1
		GROUP BY o.guid, h.areaguid,data_startu_pracy


		UNION

		SELECT
			"     GRF" AS Pochodzenie,ROUND(SUM(d.duration_min)/60,2) AS czas_pracy, @fk.okrOd AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,g.DayWork ,CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,
			d.StartTime AS czas_startu,'' AS czas_konca

		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
			   d.duration_min > 0 AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo
			  AND g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY o.guid, g.areaguid,g.DayWork
		ORDER BY pracownik;


        END IF;
	IF(_PARAM_A ='PRACOWNIK_SKLEP') THEN
	INSERT INTO czas_pracy_konkol
		SELECT
		"RCP" AS Pochodzenie,ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy,@fk.okrOd 	AS rok_miesiac,	s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,'',CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,'',''


		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND s.param5=1
		GROUP BY o.guid, h.areaguid

		UNION

		SELECT
			"      GRF" AS Pochodzenie,ROUND(SUM(d.duration_min)/60,2) AS czas_pracy,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu ,'',CONCAT(o.nazwisko,' ',o.imiona) AS pracownik,'',''


		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
		          d.duration_min > 0 AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY o.guid, g.areaguid
		ORDER BY pracownik;
	END IF;
	IF(_PARAM_A ='SKLEP') THEN
	INSERT INTO czas_pracy_konkol
		SELECT
		"RCP" AS Pochodzenie, ROUND(SUM(h.duration_min_work)/60,2) AS czas_pracy,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,'','','',''

		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			  YEAR(h.StartTime_work)*100 + MONTH(h.StartTime_work) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           event_source LIKE "RCP" AND event_type="WORK" AND s.param5=1
		GROUP BY  h.areaguid


		UNION


		SELECT
			"      GRF" AS Pochodzenie, ROUND(SUM(d.duration_min)/60,2) AS czas_pracy,@fk.okrOd 	AS rok_miesiac,s.symbol AS symbol_sklepu,s.nazwa AS nazwa_sklepu,'','','',''

		    FROM
			osoby o, Pracownicy k, hr_team_ng g, erp_area_nodes s, hr_team_po d
		    WHERE   d.osobaguid = k.guid AND k.guid = o.guid AND g.guid = d.guidng AND
	                   d.duration_min > 0 AND
			  YEAR(g.DayWork)*100 + MONTH(g.DayWork) BETWEEN @fk.okrOd AND @fk.okrDo AND
		           g.areaguid <> '''' AND g.areaGUID = s.guid AND s.deleted = 0 AND s.param5<>1
		GROUP BY  g.areaguid
		ORDER BY nazwa_sklepu;



	END IF;
	END IF;

IF (_MODE = 'OKRES_CZAS_PRACY_RCP') THEN


	SELECT
			IF(s.param5=1,'RCP','GRF') AS SOURCE,s.nazwa AS Nazwa_sklepu,CONCAT(o.nazwisko,' ',o.imiona) AS osoba ,
			CONCAT('wej: ',TIME(h.StartTime_Work),' wyj: ',  TIME(h.EndTime_work),' (',TIMEDIFF(h.EndTime_work,h.StartTime_Work),')') AS opis,
			TIMEDIFF(h.EndTime_work,h.StartTime_Work) AS czas_pracy,
			h.StartTime_Work, h.EndTime_work,o.guid
		    FROM
			osoby o, hr_events h,Pracownicy p,erp_area_nodes s
		    WHERE  h.osobaguid = p.guid AND p.guid = o.guid AND  h.areaGUID = s.guid AND
			 DATE(h.StartTime_work)=_Param_A AND
		           event_source LIKE "RCP" AND event_type="WORK"
		GROUP BY o.guid
		ORDER BY s.nazwa,o.nazwisko;

	END IF;

/*
W planach:
Mode sumujacy okresy, w których dla danego pracownika byla naliczana skladka FEP
Do wydruku zaswiadczenia o naliczaniu lub nie FEP (z kartoteki pracownikow)
okres ciągły (kolejne miesiące) podać jako od msc/rok do msc/rok; drugą sekcją w tej informacji ma być zestawienie okresów bezskładkowych (zasiłki, bezpłatny itd - uzupełnię to), które przypadały w okresie naliczania FEP

zerkac w ht_mhdroid_setcontext i fr_ht_zest_droid


konsultacje z AS
ZSWA to zestawienie robione ba razie jedną metodą, ale mają być dwie ścieżki naliczania/tworzenia XML-a
FEP to załącznik do świadectwa pracy, wydruk, który zbiera okres opłat i przerw w opłatach za dany okres (rocznie łatwiej, dla świadectwa pracy, za czas zatrudnienia, trochę trudniej)

CALL fr_pl_zest('OKRESY_FEP','{29BAE3B3-3952-4882-B6CF-F4DE6E0E7B28}','','','','','');
CALL fr_pl_zest('OKRESY_FEP','AUTOID17639','','','','','');
CALL fr_pl_zest('OKRESY_FEP','','','','','','');
*/
IF (_MODE = 'OKRESY_FEP') THEN

	-- tabela wstepa, ktora wybiera okresy z fep z plac i zapisuje takze kodu (ubezpieczenia zus z plac)
	DROP TABLE IF EXISTS tt_01;
	CREATE TEMPORARY TABLE `tt_01` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`rok` int NOT NULL DEFAULT '0',
	`miesiac` int NOT NULL DEFAULT '0',
	`okres` int NOT NULL NULL DEFAULT '0',
	`okresod` int NOT NULL NULL DEFAULT '0',
	`okresdo` int NOT NULL NULL DEFAULT '0',
	`dzienod` date,
	`dziendo` date,
	kodu varchar(8),
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;


	DROP TABLE IF EXISTS tt_01gr;
	CREATE TEMPORARY TABLE `tt_01gr` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`dzienod` date,
	`dziendo` date,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;



	DROP TABLE IF EXISTS tt_02;
	CREATE TEMPORARY TABLE `tt_02` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`okresod` int NOT NULL NULL DEFAULT '0',
	`okresdo` int NOT NULL NULL DEFAULT '0',
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;


	-- okresy bezskladkowe, ktore potem trzeba bedzie odjac od okresow fep
	DROP TABLE IF EXISTS tt_03;
	CREATE TEMPORARY TABLE `tt_03` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`rok` int NOT NULL DEFAULT '0',
	`miesiac` int NOT NULL DEFAULT '0',
	`okres` date DEFAULT NULL,
	`okresod` date DEFAULT NULL,
	`okresdo` date DEFAULT NULL,
	rodzaj int default NULL,
	`okresod2` date DEFAULT NULL,
	`okresdo2` date DEFAULT NULL,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;

	DROP TABLE IF EXISTS tt_03a;
	CREATE TEMPORARY TABLE `tt_03a` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	-- `okresod` int NOT NULL NULL DEFAULT '0', -- co to, wamac, bylo????
	-- `okresdo` int NOT NULL NULL DEFAULT '0',
	`okresod` date DEFAULT NULL,
	`okresdo` date DEFAULT NULL,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;

	-- tabela pomocniza do sumowania liczby dni zwolnien w okresie, potrzebne do przrzucenia do tt_05
	DROP TABLE IF EXISTS tt_03b;
	CREATE TEMPORARY TABLE `tt_03b` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`okresod2` date DEFAULT NULL,
	`okresdo2` date DEFAULT NULL,
	dni_zwolnien INT,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;



	DROP TABLE IF EXISTS tt_04;
	CREATE TEMPORARY TABLE `tt_04` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`dzien` date,
	`typ` varchar(10),
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;


	--  tabela z danymi z historii pracy
	DROP TABLE IF EXISTS tt_10;
	CREATE TEMPORARY TABLE `tt_10` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`rok` int NOT NULL DEFAULT '0',
	`miesiac` int NOT NULL DEFAULT '0',
	`okres` date DEFAULT NULL,
	`okresod` date DEFAULT NULL,
	`okresdo` date DEFAULT NULL,
	rodzaj int default NULL,
	`okresod2` date DEFAULT NULL,
	`okresdo2` date DEFAULT NULL,

	`kodww` varchar(20),
	`etat_l` INT,
	`etat_m` INT,
	stanowisko varchar(80),
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;



	-- tabela z danymi już pogrupowanymi, z datami zatrudnienia
	DROP TABLE IF EXISTS tt_05;
	CREATE TEMPORARY TABLE `tt_05` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`dzienod` date,
	`dziendo` date,
	`dzienza` date,
	`dzienzw` date,
	kodu VARCHAR(8),
-- 	`etat_l` INT,
-- 	`etat_m` INT,
 dni_okresu INT,
 dni_zwolnien INT,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;



	INSERT INTO tt_01 (guid_pracownika,rok,miesiac,okres,kodu)
	select distinct guid_pracownika, rok, miesiac,
	rok*100 + miesiac as okres,
	KodTytUbezp
	from place pl
	where IF(_GUID<>'', guid_pracownika = _GUID, TRUE)
	and pl.skladkaFEP > 0
	AND IF(_ROK <> '', pl.rok = _ROK, TRUE)
	AND pl.deleted = 0
	order by guid_pracownika, okres;


	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _pop_GUID VARCHAR(38);
	DECLARE _okres INT;
	DECLARE _pop_okres INT;
	DECLARE _okresod INT;
	DECLARE _okresdo INT;
	DECLARE done BOOL;
	DECLARE c_okresy CURSOR FOR
    SELECT guid_pracownika, okres FROM tt_01 ORDER BY guid_pracownika, okres;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	SET done = FALSE;
	SET _pop_okres = 0;
	SET _pop_GUID = '';

	OPEN c_okresy;
        loop1: LOOP
            FETCH c_okresy INTO _LGUID, _okres;
            IF done THEN
                LEAVE loop1;
            END IF;

			IF (_okres - _pop_okres = 1 OR _okres - _pop_okres = 89) THEN
				SET _okresod = _okresod;
			ELSE
				SET _okresod = _okres;
            END IF;

            UPDATE tt_01 SET okresod = _okresod WHERE guid_pracownika = _LGUID AND okres = _okres;

			SET _pop_okres = _okres;
			SET _pop_GUID = _LGUID;

        END LOOP;
    CLOSE c_okresy;
	END;

	INSERT INTO tt_02
	SELECT guid_pracownika, okresod, max(okres)
	FROM tt_01
	GROUP BY guid_pracownika, okresod;

	UPDATE tt_01 t1, tt_02 t2 SET t1.okresdo = t2.okresdo WHERE t1.guid_pracownika = t2.guid_pracownika AND t1.okresod=t2.okresod;

	UPDATE tt_01 SET dzienod = concat(left(okresod,4),'-',right(okresod,2),'-01');
	UPDATE tt_01 SET dziendo = LAST_DAY(concat(left(okresdo,4),'-',right(okresdo,2),'-01'));

	-- SELECT * FROM tt_01;

	INSERT INTO tt_01gr
	SELECT guid_pracownika, min(dzienod), max(dziendo)
	FROM tt_01
	GROUP BY guid_pracownika;


	INSERT INTO tt_05 (guid_pracownika, dzienod, dziendo, kodu)
	SELECT guid_pracownika, dzienod, dziendo, kodu
	FROM tt_01
	GROUP BY guid_pracownika, dzienod, dziendo
	order by guid_pracownika, dzienod;

	-- dodatkowa tabela, zeby nie było poroblemu podwojnego odwolania do tabeli tymczasowej, wczesniej miala w nazwie test - a to zlo!!!
	drop table if exists tt_05_2;
	create temporary table tt_05_2 like tt_05;
	insert into tt_05_2 select * from tt_05;

	-- korekta okresow zatrudnienia
	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj)
	SELECT guidpr, oddnia, 10
	FROM historia_pracy h
	INNER JOIN tt_01gr t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%zatrudnienie%'
	AND oddnia > t.dzienod AND oddnia < t.dziendo;

	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj)
	SELECT guidpr, oddnia, 11
	FROM historia_pracy h
	INNER JOIN tt_01gr t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%zwolnienie%'
	AND oddnia > t.dzienod AND oddnia < t.dziendo;

	-- korekta okresow zatrudnienia
	set @log = '';
	set @alog11 = 0;
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _dzienod date;
	DECLARE _dziendo date;
	DECLARE _dzienza date;
	DECLARE _dzienzw date;
	DECLARE done BOOL;
	DECLARE c_okresy11 CURSOR FOR
		SELECT guid_pracownika, dzienod, dziendo FROM tt_05_2
		-- where guid_pracownika='ID101951da-d41f-11e2-9597-1cc1de282c0e'
		ORDER BY guid_pracownika, dzienod;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	SET done = FALSE;

	OPEN c_okresy11;
        loop1: LOOP
            FETCH c_okresy11 INTO _LGUID, _dzienod, _dziendo;
            IF done THEN
                LEAVE loop1;
            END IF;

            SET _dzienza =
            (SELECT okresod FROM tt_10
            WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=10 LIMIT 1);

			SET _dzienzw =
			(SELECT okresod FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=11 LIMIT 1);
/*
			SELECT okresod INTO _dzienza FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=10
			LIMIT 1;

			SELECT okresod INTO _dzienzw FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=11;

*/
			IF _dzienza IS NOT NULL  THEN
				UPDATE tt_05 SET dzienza = _dzienza WHERE guid_pracownika = _LGUID AND dzienod = _dzienod;
            END IF;

            IF _dzienzw IS NOT NULL  THEN
				UPDATE tt_05 SET dzienzw = _dzienzw WHERE guid_pracownika = _LGUID AND dzienod = _dzienod;
            END IF;


            set @log = concat(ifnull(@log,''),'\n', _LGUID, '|', _dzienod, '|',_dziendo, '', '|', ifnull(_dzienza,''), '|', done);

            set @alog11 = @alog11 + 1;
/*

	insert into tt_log (guid_pracownika, dzienod, dziendo, okresod, dzienza)
	select _LGUID, _dzienod, _dziendo, '', _dzienza;

	create temporary table tt_log (
	idn int auto_increment,
	guid_pracownika varchar(38),
	dzienod varchar(10),
	dziendo varchar(10),
	okresod varchar(10),
	dzienza varchar(10),
	key idn (idn)
	);

	truncate table tt_log;
*/

        END LOOP;
    CLOSE c_okresy11;
	END;

	-- select * from tt_05;

	-- LEAVE SPROC;

	-- jezeli nie bylo korekty dni zatrudnienia, to przepisujemy
	UPDATE tt_05 SET dzienza = dzienod WHERE dzienza is null;
	UPDATE tt_05 SET dzienzw = dziendo WHERE dzienzw is null;

	-- tutaj wyliczam liczbe dni w okresie
	UPDATE tt_05 SET dni_okresu = datediff(dzienzw, dzienza) + 1;

	-- stanowiska i etaty, zbieranie danych, zakladam, ze zmiana jest zgodna z opisem, nie badam juz zmian pomiędzy wpisami
	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, etat_l, etat_m)
	SELECT guidpr, oddnia, 12, etat_l, etat_m
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%etat%'
	AND h.oddnia between t.dzienza AND t.dzienzw;

	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, kodww, stanowisko)
	SELECT guidpr, oddnia, 13, s.KodZUS, s.stanowisko
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	LEFT JOIN stanowiska s ON s.guid = h.stanowisko
	WHERE zmiany LIKE '%stanowisko%'
	-- AND h.zmiany not like '%zwolnienie%' -- jest potrzebne, zeby nie bral wpisow z dnia zwolnienia do zmian etatu
	-- AND h.zmiany not like 'PlacaZasadnicza' -- wycina tylko zmiany placy, ale to ogolnie lipa
	AND h.oddnia between t.dzienza AND t.dzienzw;


	-- przypadek, gdy pracownik nie miał zmian etatu/stanowiska w okresach fep/zatrudnienia w ogole
	-- albo nie mial zmiany/wpisu wczesniej niz badany okres
	-- trzeba przeleciec indywidualnie przez pracownika, bo limit i order by musi byc dla danych indywid.
	-- etat
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _dzienod VARCHAR(10);
	DECLARE done BOOL;
	DECLARE c_historia CURSOR FOR
    select guid_pracownika, dzienod from tt_05
    where guid_pracownika not in
    (select guid_pracownika from tt_10 where rodzaj in (12) and okresod <= dzienod);
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
	SET done = FALSE;
	OPEN c_historia;
        loop1: LOOP
            FETCH c_historia INTO _LGUID, _dzienod;
            IF done THEN
                LEAVE loop1;
            END IF;

			INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, etat_l, etat_m)
			SELECT guidpr, oddnia, 12, etat_l, etat_m
			FROM historia_pracy h
			INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
			WHERE h.oddnia <= _dzienod -- zmiany LIKE '%etat%'
			and t.guid_pracownika = _LGUID
			ORDER BY h.oddnia DESC LIMIT 1;

        END LOOP;
    CLOSE c_historia;
	END;

	-- stanowisko, to jest waniejsze, bo sa braki we wpisach i tutaj wszystko sie rozlatywalo
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _dzienod VARCHAR(10);
	DECLARE done BOOL;
	DECLARE c_historia CURSOR FOR
    select guid_pracownika, dzienod from tt_05
    where guid_pracownika not in
    (select guid_pracownika from tt_10 where rodzaj in (13) and okresod <= dzienod);
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
	SET done = FALSE;
	OPEN c_historia;
        loop1: LOOP
            FETCH c_historia INTO _LGUID, _dzienod;
            IF done THEN
                LEAVE loop1;
            END IF;

			INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, kodww, stanowisko)
			SELECT guidpr, oddnia, 13, s.KodZUS, s.stanowisko
			FROM historia_pracy h
			INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
			LEFT JOIN stanowiska s ON s.guid = h.stanowisko
			WHERE h.oddnia <= _dzienod    -- zmiany LIKE '%stanowisko%'
			and t.guid_pracownika = _LGUID
			ORDER BY h.oddnia DESC LIMIT 1;

        END LOOP;
    CLOSE c_historia;
	END;


	/*
	drop table if exists tt_pgr;
	create temporary table tt_pgr like tb_zus;
	insert into tt_pgr
	select guid_pracownika from tt_05 where guid_pracownika not in (select guid_pracownika from tt_10 where rodzaj in (12));

	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, etat_l, etat_m)
	SELECT guidpr, oddnia, 12, etat_l, etat_m
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	inner join tt_pgr g ON t.guid_pracownika = t.guid_pracownika
	WHERE zmiany LIKE '%etat%'
	ORDER BY h.oddnia DESC LIMIT 1;

	-- stanowisko
	truncate table tt_pgr;
	insert into tt_pgr
	select guid_pracownika from tt_05 where guid_pracownika not in (select guid_pracownika from tt_10 where rodzaj in (13) and okresod <= dzienod);

	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, kodww, stanowisko)
	SELECT guidpr, oddnia, 13, s.KodZUS, s.stanowisko
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	inner join tt_pgr g ON t.guid_pracownika = t.guid_pracownika
	LEFT JOIN stanowiska s ON s.guid = h.stanowisko
	WHERE h.oddnia <= t.dzienod    -- zmiany LIKE '%stanowisko%'
	ORDER BY h.oddnia DESC LIMIT 1;
*/
	-- i tak zabraknie wpisow dla stanowisk, co trzeba powtorzyc juz z danych pracownika, ale to na koncu


	-- todo tutaj mozna kiedys dorobic scalenie zmian dla stanowisk, jezeli zmiana stanowiska nie zmienia kodww (warunkow szkodliwych)



	-- sekcja dodawania zwolnien, niezaleznie od rodzaju
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _okresod, _okresdo, _dzienod, _dziendo VARCHAR(10);
	DECLARE done BOOL;
	DECLARE c_historia CURSOR FOR
    select guid_pracownika, okresod, okresdo from tt_02; -- bierzemy po kolei wszystkie okresy i dodajemy absencje, ktore wpadaja w dany okres
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
	SET done = FALSE;
	OPEN c_historia;
        loop1: LOOP
            FETCH c_historia INTO _LGUID, _okresod, _okresdo;
            IF done THEN
                LEAVE loop1;
            END IF;

					SET _dzienod = CONCAT(left(_okresod,4),'-',right(_okresod,2),'-01');
					SET _dziendo = LAST_DAY(CONCAT(left(_okresdo,4),'-',right(_okresdo,2),'-01'));

					-- okresy ze zwolnien, rodzaj 1
					INSERT INTO tt_03 (guid_pracownika,rok,miesiac,okresod,okresdo, rodzaj)
					SELECT a.guidpr, year(a.AbsencjaOd),month(a.AbsencjaOd), a.AbsencjaOd, a.AbsencjaDo,
					1 as rodzaj
					FROM absencje a
					-- INNER JOIN tt_01gr t ON t.guid_pracownika = a.guidpr
					WHERE a.rodzaj IN (11, 12, 17, 21) -- 21 to sluzba wojskowa J
					AND (a.absencjaod between _dzienod and _dziendo OR a.absencjado between _dzienod and _dziendo)
					AND a.guidpr = _LGUID
					-- AND year(a.AbsencjaOd) <= _ROK
					order by guidpr, absencjaod;


					-- okresy z rozliczen zus, rodzaj 2
					INSERT INTO tt_03 (guid_pracownika,rok,miesiac,okresod,okresdo, rodzaj)
					SELECT p.GUID_pracownika, p.rok, p.miesiac, rz.DataOd AS okresod, rz.DataDo,
					2 AS rodzaj
					FROM rozliczenie_zasilku rz
					LEFT JOIN place p ON p.guid=rz.GUID_Place
					-- INNER JOIN tt_01gr t ON t.guid_pracownika = p.guid_pracownika
					WHERE ((rz.DataOd between _dzienod and _dziendo) OR (rz.DataOd between _dzienod and _dziendo))
					and IF(_ROK <> '', p.rok = _ROK, TRUE)
					AND p.guid_pracownika = _LGUID
					ORDER BY p.GUID_pracownika, okresod
					;

        END LOOP;
    CLOSE c_historia;
	END;


	-- scalenie okresow zwolnienin, jezeli nie ma przerw miedzy nimi
	SET @test = '';
	set @alog22 = 0;
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _pop_GUID VARCHAR(38);
	DECLARE _pop_okresod date;
	DECLARE _pop_okresdo date;
	DECLARE _okresod date;
	DECLARE _okresdo date;
	DECLARE _okresod2 date;
	-- DECLARE _okresdo2 date;
	DECLARE done BOOL;
	DECLARE c_okresy2 CURSOR FOR
    SELECT guid_pracownika, okresod, okresdo FROM tt_03 ORDER BY guid_pracownika, okresod;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	SET done = FALSE;
	-- SET _pop_okresod = '0000-00-00';
	-- SET _pop_okresdo = '0000-00-00';
	SET _pop_GUID = '';

	OPEN c_okresy2;
        loop1: LOOP
            FETCH c_okresy2 INTO _LGUID, _okresod, _okresdo;
            IF done THEN
                LEAVE loop1;
            END IF;

			-- resetujemy okresy startowe dla nowego pracownika
			IF _pop_GUID <> _LGUID THEN
				SET _pop_okresod = '0000-00-00';
				SET _pop_okresdo = '0000-00-00';
			END IF;

			-- jest to typowo licznik remisow, ehhhh
			IF date_add(_pop_okresdo, interval 1 day) = _okresod  THEN
				SET _okresod2 = _pop_okresod;
			ELSE
				SET _okresod2 = _okresod;
				SET _pop_okresod = _okresod;
			END IF;

      UPDATE tt_03 SET okresod2 = _okresod2 WHERE guid_pracownika = _LGUID AND okresod = _okresod;

			SET _pop_okresdo = _okresdo;
			SET _pop_GUID = _LGUID;

			SET @test = concat(ifnull(@test,''),'\n',ifnull(_pop_okresod,'n'), ifnull(_okresod,'m'), ifnull(_pop_okresdo,'o'), ifnull(_okresdo,'p'), ' done: ', done);

			set @alog22 = @alog22 + 1;

        END LOOP;
    CLOSE c_okresy2;
	END;


	INSERT INTO tt_03a
	SELECT guid_pracownika, okresod, max(okresdo)
	FROM tt_03
	GROUP BY guid_pracownika, okresod2;

	UPDATE tt_03 t3, tt_03a t3a SET t3.okresdo2 = t3a.okresdo WHERE t3.guid_pracownika = t3a.guid_pracownika AND t3.okresod2=t3a.okresod;


	-- teraz trzeba podsumowac dni zwolnien w ogole w danym okresie i przerzucic sumy do tabeli tt_05
	-- to po to, zeby wywalic okresy, ktorych nie powinno byc bo sa cale ze zwolnieniami
 INSERT INTO tt_03b
	SELECT guid_pracownika, okresod2, okresdo2, sum(datediff(okresdo,okresod)+1)
 FROM tt_03
 GROUP BY guid_pracownika, concat(okresod2, okresdo2);

 UPDATE tt_05 t5, tt_03b t3b
 SET t5.dni_zwolnien = t3b.dni_zwolnien
 WHERE t5.guid_pracownika = t3b.guid_pracownika AND t5.dzienza=t3b.okresod2 and t5.dzienzw = t3b.okresdo2;

 -- pracownik moze nie miec w ogole zwolnien
 UPDATE tt_05 SET dni_zwolnien = 0 WHERE dni_zwolnien IS NULL;

 -- wywalam takie okresy - jednak nie wywalam
 -- DELETE FROM tt_05 WHERE dni_okresu <= dni_zwolnien;


	-- SELECT * FROM tt_03;

	INSERT INTO tt_04
	SELECT distinct guid_pracownika, IF(dzienza IS NOT NULL, dzienza, dzienod), 'start' FROM tt_05 where dni_okresu > dni_zwolnien;

	INSERT INTO tt_04
	SELECT distinct guid_pracownika, IF(dzienzw IS NOT NULL, dzienzw, dziendo), 'stop' FROM tt_05 where dni_okresu > dni_zwolnien;


	INSERT INTO tt_04
	SELECT distinct guid_pracownika, date_add(okresod2, interval -1 day), 'stop' FROM tt_03
	WHERE IF(_ROK <> '', YEAR(date_add(okresod2, interval -1 day)) = _ROK, TRUE);


	INSERT INTO tt_04
	SELECT distinct t3.guid_pracownika, date_add(t3.okresdo2, interval +1 day), 'start'
	-- SELECT t3.guid_pracownika, t3.okresdo, 'start'
	FROM tt_03 t3
	INNER JOIN tt_01gr tgr ON t3.guid_pracownika = tgr.guid_pracownika
	WHERE IF(_ROK <> '', YEAR(date_add(t3.okresdo2, interval +1 day)) = _ROK, TRUE)
	AND date_add(t3.okresdo2, interval +1 day) <= tgr.dziendo;




	-- SELECT * FROM tt_04 order by guid_pracownika, dzien;

	-- tutaj trzeba dodac wpisy z tabeli tt_10, zwiazane z rozmnazaniem okresow z powodu zmiany etatu lub stanowiska
	INSERT INTO tt_04
	SELECT distinct t10.guid_pracownika, okresod, 'start'
	FROM tt_10 t10
	INNER JOIN tt_05 t05 ON t10.guid_pracownika = t05.guid_pracownika
	WHERE IF(_ROK <> '', YEAR(okresod) = _ROK, TRUE)
	AND t10.okresod > t05.dzienza
	AND rodzaj in (12,13);

	INSERT INTO tt_04
	SELECT distinct t10.guid_pracownika, date_add(okresod, interval -1 day), 'stop'
	FROM tt_10 t10
	INNER JOIN tt_05 t05 ON t10.guid_pracownika = t05.guid_pracownika
	WHERE IF(_ROK <> '', YEAR(okresod) = _ROK, TRUE)
	AND date_add(okresod, interval -1 day) > t05.dzienza
	AND rodzaj in (12,13);

/*
	dodatkowa blokada zrobiona dla cdg, ktora kasuje blednie dodane wpisy start/stop, ktore nie sa w okresach fep w ogole

	to wszystko ogolnie jest do dupy i cala procedura powinna zostac zmieniona - zamiast sekwencji start-stop nalezy zrobic porzadne badanie wg okresow, ale to jest od cholery roboty
*/
 DELETE t4 FROM tt_04 t4
 WHERE NOT EXISTS (SELECT * FROM tt_01 WHERE t4.guid_pracownika = guid_pracownika AND t4.dzien BETWEEN dzienod AND dziendo)
 ;


	DROP TABLE IF EXISTS tt_grupy;
	CREATE TEMPORARY TABLE tt_grupy (
		guid VARCHAR(38),
		zakresy TEXT,
		KEY guid (guid)
		) DEFAULT CHARSET=utf8;

	insert into tt_grupy (guid, zakresy)
	select guid_pracownika,
	group_concat(concat(dzien,IF(typ='start','-','\n')) order by dzien separator '') as okresy_fep
	from tt_04 group by guid_pracownika;






	drop table if exists tt_wiersze;
	create temporary table tt_wiersze (
	guid VARCHAR(38),
	wiersz varchar(255) NOT NULL DEFAULT '')
	;


	SET _i = 0;
	WHILE _i < 21 DO
		-- @pos =  LOCATE(substr,str,pos)
		SET _i = _i + 1;
		insert into tt_wiersze
		-- select replace(substring_index(substring_index(zakresy,char(13),@Iter),char(13),-1),char(10),'') as linia
		select guid, substring_index(substring_index(zakresy,'\n',_i),'\n',-1) as linia
		from tt_grupy
		where (substring_index(substring_index(zakresy,'\n',_i),'\n',-1)) <> ''
		having length(linia) > 11 -- wycina pojedyncze daty od, czyli w sumie zbedny
		;
	END WHILE;

	-- chamskie rozwiazanie problemu dwoch startow po kolei (przypadek, gdy okres zaczyna sie od zwolnienia)
	-- ale ile to ma skutkow ubocznych to cholera wie
	-- generalnie idea start-stop sie nie sprawdzila i chyba lepiej przejsc na iteracyjne badanie okresow, ehhhhh
	update tt_wiersze set wiersz = right(wiersz, 21) where length(wiersz) > 21;


	DROP TABLE IF EXISTS t_okresy;
	CREATE TEMPORARY TABLE t_okresy (
		guid VARCHAR(38),
		LP INT,
		kodu VARCHAR(10), -- KodTytuluUbezpieczenia
		kodww VARCHAR(15), -- KodPracyWszczegWarunkach
		oddnia date,
		dodnia date,
		etat_l VARCHAR(3),
		etat_m VARCHAR(3),
		stanowisko VARCHAR(80),
		xml1 TEXT,
		KEY guid (guid)
		) DEFAULT CHARSET=utf8;

	SET @a = 0;
	SET @guid = '';
	insert into t_okresy (lp, oddnia, dodnia, guid)
	SELECT
		CASE WHEN @guid <> guid THEN @a := 1
		ELSE @a := @a +1 END as lp,
	left(wiersz,10), right(wiersz,10),
	@guid := guid AS guid
	FROM tt_wiersze
	-- WHERE guid IN (SELECT guid FROM tb_zus)
	order by guid, left(wiersz,10);



	-- do okresow, juz ostatecznych, przypisanie kodu uzbezp, kodow ww i etatow
	SET @log2 = '';
	SET @alog2 = 0;
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _oddnia date;
	DECLARE _dodnia date;
	DECLARE _kodu varchar(8);
	DECLARE _kodww varchar(15);
	DECLARE _etat_l int;
	DECLARE _etat_m int;
	DECLARE _stanowisko varchar(80);

	DECLARE done BOOL;
	DECLARE c_okresy3 CURSOR FOR
    SELECT guid, oddnia, dodnia FROM t_okresy ORDER BY guid, oddnia;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	SET done = FALSE;

	OPEN c_okresy3;
        loop1: LOOP
            FETCH c_okresy3 INTO _LGUID, _oddnia, _dodnia;
            IF done THEN
                LEAVE loop1;
            END IF;

			SET _etat_l = (SELECT etat_l FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=12
			AND etat_l IS NOT NULL
			ORDER by okresod desc LIMIT 1);

            SET _etat_m = (SELECT etat_m FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=12
			AND etat_l IS NOT NULL
			ORDER by okresod desc LIMIT 1);

			SET _kodww = (SELECT kodww FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=13
			AND kodww IS NOT NULL
			ORDER by okresod desc LIMIT 1);

			SET _stanowisko = (SELECT stanowisko FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=13
			AND kodww IS NOT NULL
			ORDER by okresod desc LIMIT 1);

/*
			SELECT etat_l, etat_m INTO _etat_l, _etat_m FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=12
			AND etat_l IS NOT NULL
			ORDER by okresod desc LIMIT 1;

			SELECT kodww, stanowisko INTO _kodww, _stanowisko FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=13
			AND kodww IS NOT NULL
			ORDER by okresod desc LIMIT 1;
*/

			SET _kodu =
			(SELECT kodu FROM tt_01
			WHERE guid_pracownika = _LGUID AND kodu is not null and dzienod <= _oddnia
			ORDER BY dzienod DESC LIMIT 1);

			UPDATE t_okresy SET etat_l = _etat_l, etat_m = _etat_m WHERE guid = _LGUID AND oddnia = _oddnia;
			UPDATE t_okresy SET kodww = _kodww, stanowisko = _stanowisko WHERE guid = _LGUID AND oddnia = _oddnia;
			UPDATE t_okresy SET kodu = _kodu WHERE guid = _LGUID AND oddnia = _oddnia;

			 set @log2 = concat(@log2,'\n', _LGUID, '|', done);
			 set @alog2 = @alog2 +1;

        END LOOP;
    CLOSE c_okresy3;
	END;

END IF;

/*
zalozenie, ze jezeli dostaje guid, to sam tworze tabele tb_zus (albo mam inne zlaczenie)
jezeli jest bez guid, to korzystam z tabeli tb_zus i robie dla wszystkich pracownikow
zmienne sa mizedzy znakami &, nazwa do znaku =, wartosc po znaku= do &

CALL fr_pl_zest('ZSWA','','','','','','&DataWyp=2024-02-16&nr=1&&rok=2024&');
CALL fr_pl_zest('OKRESY_FEP','',2024,'','','','');

call pl_zus_xml('create.ZSWA','','','','','','','','');

drop table tb_zus;
CREATE TEMPORARY TABLE tb_zus (
guid VARCHAR(38),
KEY guid (guid));
insert into tb_zus values ('{9C5D3483-C235-4DB1-863E-6FBAD584511A}'),('{769A835B-B647-40B4-A5BC-B293B3C1859B}');
select * from tb_zus;
select * from t_pracownicy;
select * from t_okresy;

select * from tt_10; where guid_pracownika='AUTOID23676';
select * from tt_05 where guid_pracownika='AUTOID23735';
select * from t_okresy where xml1 is null; guid='AUTOID23735'; select distinct guid from t_okresy;
select * from tt_03 where guid_pracownika='AUTOID23735';
select * from tt_grupy;
select * from tt_wiersze;
select * from tt_log;
select @log2, @alog2, @test, @alog11, @alog22;
set @alog = null;


select * from t_pracownicy;
select * from t_bloki where guid = 'AUTOID23676';
select * from t_zswa;
select * from tb_zus;
select * from historia_pracy where guidpr='{87F6670F-4343-4C89-8D91-4DF646E90F11}';

drop table tb_zus;
CREATE TEMPORARY TABLE tb_zus (
guid VARCHAR(38),
KEY guid (guid));

truncate tb_zus;
insert into tb_zus
select distinct guid_pracownika
	from place pl
	-- where IF(_GUID<>'', guid_pracownika = _GUID, TRUE)
	where pl.skladkaFEP > 0
	AND pl.rok = 2022
	order by guid_pracownika; limit 10;
;

select * from tt_05 where guid_pracownika not in (select guid_pracownika from tt_10 where rodzaj in (12,13));

*/
IF (_MODE = 'ZSWA') THEN

	-- SELECT YEAR(SUBSTRING_INDEX(SUBSTRING_INDEX(_Param_B, 'DataWyp=', -1), '&', 1)) INTO _ROK;
	-- SET _ROK = '2022'; -- do zmiany z gory gdy w programie bedzie wlasciwe pytanie
	SELECT SUBSTRING_INDEX(SUBSTRING_INDEX(_Param_B, 'rok=', -1), '&', 1) INTO _ROK;
	SET @ROK = _ROK;

	CALL fr_pl_zest('OKRESY_FEP',_GUID,_ROK,'','','','');

	call pl_zus_xml('create.ZSWA',_GUID,'','','','','','',_Param_B);

	-- SELECT 1;

END IF;



/*
CALL fr_pl_zest('OKRESY_FEP','{1FA0696C-3D44-46E4-80A5-3E969C596A5A}','','','','','');
CALL fr_pl_zest('OKRESY_FEP','','2022','','','','');

select t4.guid_pracownika,
group_concat(concat(t4.dzien,IF(t4.typ='start','-','\n')) order by t4.dzien separator "")
from tt_04 t4
group by guid_pracownika;

SET @g = 'DZ-4bc000b0ae19898d51aac7ae1bbd6146'; -- baca
SET @g = 'ID101951da-d41f-11e2-9597-1cc1de282c0e'; -- arciszewski sebastian
SET @g = '{2E659964-6A7D-40DF-8A64-143D2DA46721}'; -- sumionka
CALL fr_pl_zest('OKRESY_FEP',@g,'','','','','');

select * from tt_01 where guid_pracownika = @g;
select * from tt_01gr where guid_pracownika = @g;
select * from tt_02 where guid_pracownika = @g;
select * from tt_03a where guid_pracownika = @g;
select * from tt_03 where guid_pracownika = @g;
select * from tt_04 where guid_pracownika = @g;
select * from tt_05 where guid_pracownika = @g;
select * from tt_10;
select * from t_okresy;
select * from historia_pracy where guidpr = @g; and zmiany like '%zwol%';


CALL fr_pl_zest('ZSWA','','','','','','&DataWyp2023-03-22&nr=8&');


select * from osoby where nazwisko='sumionka' and deleted=0;


select
(select kodu from tt_01 where t.guid = guid_pracownika and kodu is not null and dzienod <= t.oddnia order by dzienod desc limit 1) as kodu,

-- (select etat_l from tt_10 where t.guid = guid_pracownika and etat_l is not null and okresod <= t.oddnia and rodzaj=12 order by okresod desc limit 1) as etat,
(select etat_m from tt_10 where t.guid = guid_pracownika and etat_l is not null and okresod <= t.oddnia and rodzaj=12 order by okresod desc limit 1) as etat,

t.*
-- t.oddnia, t.dodnia,
-- kodww,
-- (select kodww from tt_10 where t.guid = guid_pracownika and kodww is not null and okresod <= t.oddnia and rodzaj=13 order by okresod desc limit 1) as kodww,

from t_okresy t;


SELECT guid, oddnia, dodnia FROM t_okresy ORDER BY guid, oddnia;
*/

/*
zalozenie, ze jezeli dostaje guid, to sam tworze tabele tb_zus (albo mam inne zlaczenie)
jezeli jest bez guid, to korzystam z tabeli tb-zus i robie dla wszystkich pracownikow
zmienne sa mizedzy znakami &, nazwa do znaku =, wartosc po znaku= do &
CALL fr_pl_zest('DANE_PRAC','{1FA0696C-3D44-46E4-80A5-3E969C596A5A}','2022','','','','');
*/
IF (_MODE = 'DANE_PRAC') THEN

	IF _GUID <> '' THEN
		DROP TABLE IF EXISTS tb_zus;
		CREATE TEMPORARY TABLE tb_zus (
		guid VARCHAR(38),
		KEY guid (guid));

		insert into tb_zus values (_GUID);
	END IF;

	-- SELECT YEAR(SUBSTRING_INDEX(SUBSTRING_INDEX(_Param_B, 'DataWyp=', -1), '&', 1)) INTO _ROK;

	-- tabela z danymi już pogrupowanymi, z datami zatrudnienia
	DROP TABLE IF EXISTS tt_05;
	CREATE TEMPORARY TABLE `tt_05` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`dzienod` date,
	`dziendo` date,
	`dzienza` date,
	`dzienzw` date,
	zatr INT,

	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;

	--  tabela z danymi z historii pracy
	DROP TABLE IF EXISTS tt_10;
	CREATE TEMPORARY TABLE `tt_10` (
	`guid_pracownika` varchar(38) NOT NULL DEFAULT '',
	`rok` int NOT NULL DEFAULT '0',
	`miesiac` int NOT NULL DEFAULT '0',
	`okres` date DEFAULT NULL,
	`okresod` date DEFAULT NULL,
	`okresdo` date DEFAULT NULL,
	rodzaj int default NULL,
	`okresod2` date DEFAULT NULL,
	`okresdo2` date DEFAULT NULL,
	`kodww` varchar(20),
	`etat_l` INT,
	`etat_m` INT,
	stanowisko varchar(80),
	hp_WymiarUrlopuDni double(12,6) DEFAULT 0,
	KEY guid_pracownika (guid_pracownika)
	) DEFAULT CHARSET=cp1250;

	INSERT INTO tt_05 (guid_pracownika)
	SELECT _GUID;


	-- sprawdzenie zatrudnienia w okresie
	SELECT oddnia INTO @dataza
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%zatrudnienie%'
	AND oddnia <= CONCAT(_ROK,'-12-31')
	ORDER BY oddnia DESC LIMIT 1;

	IF @dataza IS NULL THEN

		UPDATE tt_05 SET zatr = 0;

	END IF;


	IF @dataza IS NOT NULL THEN

		SELECT oddnia INTO @datazw
		FROM historia_pracy h
		INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
		WHERE zmiany LIKE '%zwolnienie%'
		AND oddnia <= CONCAT(_ROK,'-12-31')
		AND oddnia > @dataza
		ORDER BY oddnia DESC LIMIT 1;

	END IF;




	-- CONCAT(_ROK,'-01-01'), CONCAT(_ROK,'-12-31');


	-- korekta okresow zatrudnienia
	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj)
	SELECT guidpr, oddnia, 10
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%zatrudnienie%'
	AND oddnia > t.dzienod AND oddnia < t.dziendo;

	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj)
	SELECT guidpr, oddnia, 11
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%zwolnienie%'
	AND oddnia > t.dzienod AND oddnia < t.dziendo;

-- korekta okresow zatrudnienia
	BEGIN
	DECLARE done BOOL DEFAULT FALSE;
	DECLARE _LGUID VARCHAR(38);
	DECLARE _dzienod date;
	DECLARE _dziendo date;
	DECLARE _dzienza date;
	DECLARE _dzienzw date;
	DECLARE c_okresy2 CURSOR FOR
		SELECT guid_pracownika, dzienod, dziendo FROM tt_05 ORDER BY guid_pracownika, dzienod;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	-- SET done = FALSE;

	OPEN c_okresy2;
        loop1: LOOP
            FETCH c_okresy2 INTO _LGUID, _dzienod, _dziendo;
            IF done THEN
                LEAVE loop1;
            END IF;

			SELECT okresod INTO _dzienza FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=10;

			SELECT okresod INTO _dzienzw FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod > _dzienod AND okresod < _dziendo AND rodzaj=11;


			IF _dzienza IS NOT NULL  THEN
				UPDATE tt_05 SET dzienza = _dzienza WHERE guid_pracownika = _LGUID AND dzienod = _dzienod;
            END IF;

            IF _dzienzw IS NOT NULL  THEN
				UPDATE tt_05 SET dzienzw = _dzienzw WHERE guid_pracownika = _LGUID AND dzienod = _dzienod;
            END IF;

        END LOOP;
    CLOSE c_okresy2;
	END;


	-- jezeli nie bylo korekty dni zatrudnienia, to przepisujemy
	UPDATE tt_05 SET dzienza = dzienod WHERE dzienza is null;
	UPDATE tt_05 SET dzienzw = dziendo WHERE dzienzw is null;

	-- stanowiska i etaty, zbieranie danych, zakladam, ze zmiana jest zgodna z opisem, nie badam juz zmian pomiędzy wpisami
	INSERT INTO tt_10 (guid_pracownika, okresod, rodzaj, etat_l, etat_m)
	SELECT guidpr, h.oddnia, 12, h.etat_l, h.etat_m
	FROM historia_pracy h
	INNER JOIN tt_05 t ON t.guid_pracownika = h.guidpr
	WHERE zmiany LIKE '%etat%'
	AND h.oddnia between t.dzienza AND t.dzienzw;




	DROP TABLE IF EXISTS t_okresy;
	CREATE TEMPORARY TABLE t_okresy (
		guid VARCHAR(38),
		LP INT,
		kodu VARCHAR(10), -- KodTytuluUbezpieczenia
		kodww VARCHAR(15), -- KodPracyWszczegWarunkach
		oddnia VARCHAR(10),
		dodnia VARCHAR(10),
		etat_l VARCHAR(3),
		etat_m VARCHAR(3),
		stanowisko VARCHAR(80),
		zatr INT,
		KEY guid (guid)
		) DEFAULT CHARSET=utf8;

	SET @a = 0;
	SET @guid_pracownika = '';
	insert into t_okresy (lp, oddnia, dodnia, zatr, guid)
	SELECT
		CASE WHEN @guid_pracownika <> guid_pracownika THEN @a := 1
		ELSE @a := @a +1 END as lp,
	dzienza, dzienzw, zatr,
	@guid_pracownika := guid_pracownika AS guid_pracownika
	FROM tt_05
	order by guid_pracownika, dzienza;









	-- do okresow, przypisanie kodu uzbezp, kodow ww i etatow
	BEGIN
	DECLARE _LGUID VARCHAR(38);
	DECLARE _oddnia date;
	DECLARE _dodnia date;
	DECLARE _kodu varchar(8);
	DECLARE _kodww varchar(15);
	DECLARE _etat_l int;
	DECLARE _etat_m int;
	DECLARE _stanowisko varchar(80);

	DECLARE done BOOL;
	DECLARE c_okresy3 CURSOR FOR
    SELECT guid, oddnia, dodnia FROM t_okresy ORDER BY guid, oddnia;
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;

	SET done = FALSE;

	OPEN c_okresy3;
        loop1: LOOP
            FETCH c_okresy3 INTO _LGUID, _oddnia, _dodnia;
            IF done THEN
                LEAVE loop1;
            END IF;

			SELECT etat_l, etat_m INTO _etat_l, _etat_m FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=12
			AND etat_l IS NOT NULL
			ORDER by okresod desc LIMIT 1;

			SELECT kodww, stanowisko INTO _kodww, _stanowisko FROM tt_10
			WHERE guid_pracownika = _LGUID AND okresod <= _oddnia AND rodzaj=13
			AND kodww IS NOT NULL
			ORDER by okresod desc LIMIT 1;

/*
			SELECT kodu INTO _kodu FROM tt_01
			WHERE guid_pracownika = _LGUID AND kodu is not null and dzienod <= _oddnia
			ORDER BY dzienod DESC LIMIT 1;
*/
			UPDATE t_okresy SET etat_l = _etat_l, etat_m = _etat_m WHERE guid = _LGUID AND oddnia = _oddnia;
			UPDATE t_okresy SET kodww = _kodww, stanowisko = _stanowisko WHERE guid = _LGUID AND oddnia = _oddnia;
			-- UPDATE t_okresy SET kodu = _kodu WHERE guid = _LGUID AND oddnia = _oddnia;


        END LOOP;
    CLOSE c_okresy3;
	END;


	SELECT * FROM t_okresy;



END IF;


/*
zestawienie dla Konkola, rentownosc sklepow
CALL fr_pl_zest('RENTOWNOSC_SKLEPOW','','2024','10','','','');
select * from tt_z01

trzeba rozbic sciezke napiczania rentownosci tak, zeby od listopada 2024 opierala sie na nowych godzinach (zgodnych z zrcp), a wcześniej, żeby było po staremu - linia 2082 (godziny nocne), co do innych godzin to zobaczymy
*/
IF (_MODE = 'RENTOWNOSC_SKLEPOW') THEN
	-- SET _MIESIAC = 7; -- do wyrzucenia, gdy miesiac ma byc obslugiwany

	DROP TABLE IF EXISTS tt_z01;
	CREATE TEMPORARY TABLE `tt_z01` (
	sklep varchar(10),
	`sklep_nazwa` varchar(100),
	`StartTime` datetime ,
	`EndTime` datetime ,
	`nazwisko` varchar(40) ,
	`imiona` varchar(50) ,
	`GodzNaSklepie` double(16,2), -- kol 1
	`GodzSN` double(16,2), -- kol 8 (liczba godzin na sklepie w soboty, niedz, swieta)
	`SumaGodz` double(16,2) ,
	`stawka_brutto` double(16,2), -- kol. 2
	`kwota_netto` double(16,2), -- wstep do kol. 4 - suma wyplat pracownika
	`do_wyplaty_sklep` double(16,2), -- kol. 4
	`netto_zpremia` double(16,2), -- kol. 3
	placa_brutto double(16,2), -- kol. 5
	GodzNoc double(16,2), -- potrzebne do kol 6
	KwotaNoc double(16,2), -- kol. 6 (kwota za noc)
	KwotaSN double(16,2), -- kol. 7 (kwota za swieta, niedziele)

	GodzNPlatne double(16,2), -- nieobecnosci platne
	SumaGodzNPlatne double(16,2), -- nieobecnosci platne pracownika w calym miesiacu
	urlop_wopok double(16,2), -- kol nowa, suma wynagrodzeń za urlop wyp, opieka, okolicznosciowy
	zwolnienia double(16,2), -- kol nowa, suma wynagrodzeń za zwolnienia rozne

	placa_brutto_razem double(16,2), -- kol. 11
	proc_premia double(16,2), -- kol. 9
	premia double(16,2), -- kol. 10
	spoleczne double(16,2), -- kol. 12 (skladki spol. pracodawcy ze zlecen)
	brutto_zus double(16,2), -- kol. 13 (skladki spol. pracodawcy ze zlecen + 11)
	koszty_sklepu_s double(16,2), -- kol 14 (suma kol. 13 dla sklepu)
	GodzNaSklepie_s double(16,2), -- kol 17 (suma kol. 1 dla sklepu)
	utarg_s double(16,2), -- kol 15, suma ze sprzedazy
	utarg_na_godz double(16,2), -- kol 18
	liczba_sprzed double(16,2), -- kol 19 (liczba sprzedawczyn indywidualnie)
	liczba_sprzed_s double(16,2), -- kol 19 (liczba sprzedawczyn w sklepie zsumowana)
	utarg_na_sprzed_s double(16,2), -- kol 20
	placa_do_przych_s double(16,2), -- kol 21
	wzrost_rtr varchar(10) DEFAULT '', -- kol 16, nie liczymy
	dochod_strata varchar(10) DEFAULT '', -- kol 22, nie liczymy
	rok int,
	miesiac int,
	KEY sklep(sklep)
	) DEFAULT CHARSET=cp1250 -- COLLATE=cp1250_general_ci
	;

	drop table if exists tt_z02;
	create temporary table tt_z02 (
	sklep varchar(10),
	kontrGUID varchar(38),
	GodzNaSklepie_s double(16,2),
	koszty_sklepu_s double(16,2),
	utarg_s double(16,2),
	utarg_na_sprzed_s double(16,2),
	liczba_sprzed_s double(16,2),
	KEY kontrGUID(kontrGUID)
	) DEFAULT CHARSET=cp1250
 ;
 -- uproszczona wersja tabeli tt_z02 dla nowej wersji naliczania
 drop table if exists tt_zr03;
	create temporary table tt_zr03 (
	areaGUID varchar(38),
	koszty_sklepu_s double(16,2),
	KEY areaGUID(areaGUID)
	) DEFAULT CHARSET=cp1250
 ;



	select valuen into _stawka from IReg where idkey like '%Stawka_godz_dodatek_nocny%' and rok= _ROK limit 1;
	select valuen into _ncp from IReg where idkey like '%NCP7%' and rok= _ROK limit 1;

	SET _od = CONCAT(_ROK,'-',LPAD(_MIESIAC,2,'0'),'-01');
	SET _do = LAST_DAY(_od);

 IF _od < '2024-12-01' THEN -- stara wersja naliczania zestawienia
  insert into tt_z01 (sklep ,sklep_nazwa ,StartTime ,EndTime, nazwisko, imiona, GodzNaSklepie, SumaGodz, stawka_brutto, kwota_netto, GodzNoc, GodzSN, GodzNPlatne, SumaGodzNPlatne, proc_premia, spoleczne,
  urlop_wopok, zwolnienia)

  SELECT n.symbol AS sklep, n.nazwa AS sklep_nazwa,
         _VarDateTime(he.StartTime) AS StartTime, _VarDateTime(he.EndTime) AS EndTime,
         -- g.DayWork,
         o.nazwisko, o.imiona,
         SUM(he.duration_min/60) AS GodzNaSklepie,
         (SELECT SUM(heS.Duration_min / 60)
          FROM `hr_team_ng` nS
   INNER JOIN `hr_team_po` pS ON pS.GUIDNg = nS.GUID
   LEFT JOIN `hr_events` heS ON heS.GUID = pS.GUID AND heS.Deleted = 0
   JOIN osoby oS ON oS.guid = pS.osobaguid
   WHERE nS.Template = 0 AND pS.osobaguid=p.osobaguid
            -- and pS.osobaguid='{623A2125-7E63-4755-9A0C-F859AFCE2225}'
            -- AND nS.symbol='006'
   AND nS.DayWork BETWEEN _od AND _do) AS SumaGodz,

  -- pr.StawkaGodzinowa AS stawka_brutto,
  (select StawkaGodzinowa from historia_pracy where GUIDpr = pr.GUID and OdDnia <= _do order by OdDnia desc limit 1) AS stawka_brutto,

  ifnull((select sum(KwotaNetto) from place
  join listy_plac l1 on l1.idn=nrlisty
  where place.rok= _ROK and place.miesiac= _MIESIAC and guid_pracownika=o.guid and l1.lista_glowna=1 AND deleted=0),0) +

  ifnull((select sum(KwotaNetto) from prace_zlecone where year(DataOd) = _ROK and Month(DataOd)= _MIESIAC and guid_pracownika=o.guid and deleted=0),0) +

  ifnull((select sum(ps.kwota) from place_skladniki ps inner join place pl on ps.guid_zapisu_placowego = pl.guid
  inner join listy_plac l2 on l2.idn=pl.nrlisty
  where pl.rok= _ROK and pl.miesiac= _MIESIAC and ps.RodzajSkladnika = 5 and guid_pracownika=o.guid and l2.lista_glowna=1 AND pl.deleted=0),0) +
  ifnull((select sum(ps.kwota) from place_skladniki ps inner join prace_zlecone pl on ps.guid_zapisu_placowego = pl.guid where year(pl.DataOd) = _ROK and Month(pl.DataOd)= _MIESIAC and ps.RodzajSkladnika = 5 and guid_pracownika=o.guid and deleted=0),0)
  as kwota_netto,

  sum((fp.godziny_yy + fp.noc)/60) AS GodzNoc, -- wracamy do starej wersji wybierania zestawienia
  -- sum(if(he.duration_min_night>0,(fp.godziny_yy + fp.noc)/60,0)) AS GodzNoc,

  ifnull(sum(fp2.godziny_zz/60 * fp2.dzien_wolny_F),0) AS GodzSN,

  ifnull(sum(fp3.godz_absencji/60),0) AS GodzNPlatne, -- nieobecnosci platne

  ifnull((select sum(pp.godz_absencji/60) from frekw_po pp, frekw ff where ff.GUID = pp.frekwGUID AND ff.rok = _ROK and ff.miesiac = _miesiac AND ff.pracGUID = o.guid and pp.absencja IN ('C','W','G','L','K','M','O','R','D','Z','T','E','Q','WD','EO','EZ','MO','MR','MT') and ff.deleted=0), 0)
  AS SumaGodzNPlatne,

  -- (select premia/100 from erp_area_nodes where `type`='LOC' and right(symbol,2) = right(n.symbol,2) limit 1) as proc_premia,
  0 as proc_premia,

  ifnull((select sum(SklFemerytalnyZleceniod+SklFrentowyZleceniod+SklFchorobowyZleceniod+SklFwypadkowyZleceniod) from prace_zlecone where year(DataOd) = _ROK and Month(DataOd) = _MIESIAC and guid_pracownika=o.guid and deleted=0),0)

  + ifnull((select sum(SklFemerytalnyPracod+SklFrentowyPracod+SklFchorobowyPracod+SklFwypadkowyPracod) from place where rok= _ROK and miesiac= _MIESIAC and guid_pracownika=o.guid and deleted=0),0)
  as spoleczne,

  ifnull((select sum(ps.kwota) from place_skladniki ps inner join place pl on ps.guid_zapisu_placowego = pl.guid where pl.rok= _ROK and pl.miesiac= _MIESIAC and ps.GUID_definicja_skladnika_placy IN ('C_6','C_7','C_8') and guid_pracownika=o.guid and pl.deleted=0),0)
  as urlop_wopok,

  ifnull((select sum(ps.kwota) from place_skladniki ps inner join prace_zlecone pl on ps.guid_zapisu_placowego = pl.guid where year(pl.DataOd) = _ROK and Month(pl.DataOd) = _MIESIAC and ps.GUID_definicja_skladnika_placy IN ('C_9','C_10','C_11') and guid_pracownika=o.guid and pl.deleted=0),0)
  +
  ifnull((select sum(ChoroboweFirma + ChoroboweZUS) from place where rok= _ROK and miesiac= _MIESIAC and guid_pracownika=o.guid and deleted=0),0)
  as zwolnienia

  FROM hr_team_po p
  INNER JOIN hr_team_ng n ON n.guid=p.guidng
  INNER JOIN osoby o ON o.guid=p.osobaguid
  INNER JOIN Pracownicy pr ON pr.guid=o.guid
     LEFT JOIN hr_events he ON he.GUID = p.GUID AND he.Deleted = 0
     left join frekw_po fp on fp.rok_msc_dzien = n.daywork and fp.pracGUID = o.guid
     left join frekw f on f.GUID = fp.frekwGUID and f.deleted=0
     left join frekw_po fp2 on fp2.rok_msc_dzien = n.daywork and fp2.pracGUID = o.guid and fp2.kp_info IN ('D','N','X')
     left join frekw f2 on f2.GUID = fp2.frekwGUID and f2.deleted=0
     left join frekw_po fp3 on fp3.rok_msc_dzien = n.daywork and fp3.pracGUID = o.guid and fp3.absencja IN ('C','W','G','L','K','M','O','R','D','Z','T','E','Q','WD','EO','EZ','MO','MR','MT')
  left join frekw f3 on f3.GUID = fp3.frekwGUID and f3.deleted=0

  WHERE n.Template = 0
     and n.DayWork BETWEEN _od AND _do
        -- and d.osobaguid= '{E290EF89-B4C0-4554-B81D-2E155196CE9C}'
  GROUP BY n.symbol, o.guid
     HAVING GodzNaSklepie > 0
  ORDER BY n.symbol, o.nazwisko,o.imiona
  ;

  update tt_z01 t set
  t.proc_premia =
  (select ext.proc_premii/100 from erp_area_nodes ean, erp_area_nodes_ext ext
  where ext.areaGUID = ean.GUID AND `type`='LOC' and right(ean.symbol,2) = right(t.sklep,2)
  and ext.rok = _ROK AND ext.miesiac = _MIESIAC limit 1);

  /*
  update tt_z01 t set
  t.proc_premia =
  (select premia/100 from erp_area_nodes where `type`='LOC' and right(symbol,2) = right(t.sklep,2) limit 1)
  where t.proc_premia = 0;
  */

  update tt_z01 set
  do_wyplaty_sklep = kwota_netto * (GodzNaSklepie + GodzNPlatne)/(SumaGodz+SumaGodzNPlatne)
  ;

  update tt_z01 set
  netto_zpremia = do_wyplaty_sklep/ifnull(GodzNaSklepie + GodzNPlatne,1), -- 3=4/1
  placa_brutto = ifnull(GodzNaSklepie,1) * stawka_brutto, -- 5=1*2
  KwotaNoc = GodzNoc * _stawka, -- 6= 8 * stawka nocna z IReg
  KwotaSN = GodzSN * stawka_brutto * 0.5 -- 7=8*2* 0.5
  ;

  update tt_z01 set
  premia = (placa_brutto + KwotaSN) * proc_premia -- kol. 10 = 9*11
  ;

  update tt_z01 set
  placa_brutto_razem = placa_brutto + KwotaNoc + KwotaSN +
  ((urlop_wopok + zwolnienia) * GodzNaSklepie/SumaGodz) + premia
  -- kol. 11 = 5 + 6 + 7 + nowe kolumny podzielone proporcjonalnie
  ;

  update tt_z01 set
  brutto_zus = placa_brutto_razem + spoleczne -- kol. 13 = 11+12
  ;


  -- dane grupowane wg sklepu, potrzebne potem roznie
  insert into tt_z02 (sklep, GodzNaSklepie_s, koszty_sklepu_s)
  select sklep, sum(GodzNaSklepie), sum(brutto_zus) from tt_z01 group by sklep;

  -- w sprzedazy sklep jest kontrahentem, ale oczywiscie symbol kontrahenta do symbolu sklepu pasuje srednio...
  -- dlatego najpierw guid (indeks na guid w tabeli jest)
  update tt_z02 t, kontrah k
  set t.kontrGUID = k.guid
  where concat('02',right(t.sklep,2)) = k.symbol;

  update tt_z02 t
  set utarg_s = (select sum(brutto) from opng where kontrGUID = t.kontrGUID
  and datawystaw >= _od and datawystaw <= _do
  and rodzaj in (4, 0, 30, 32, 3, 29)
  );

  -- przenosimy dane do tabeli tt_z01, zeby wszystko bylo razem, a i tak jest potrzebne
  update tt_z01 t1, tt_z02 t2
  set t1.koszty_sklepu_s = t2.koszty_sklepu_s,
  t1.GodzNaSklepie_s = t2.GodzNaSklepie_s,
  t1.utarg_s = t2.utarg_s
  where t2.sklep=t1.sklep;

  update tt_z01 set
  utarg_na_godz = utarg_s / GodzNaSklepie_s -- kol. 18 = 15/17
  ;

  update tt_z01 set
  liczba_sprzed = IF(GodzNaSklepie >= _ncp, _ncp, GodzNaSklepie) / _ncp -- kol. 19 (liczba sprzed na osobe)
  ;

  update tt_z02 t set
  liczba_sprzed_s = (select sum(liczba_sprzed) from tt_z01 where sklep = t.sklep group by sklep);

  update tt_z01 t1, tt_z02 t2
  set t1.liczba_sprzed_s = t2.liczba_sprzed_s
  where t2.sklep=t1.sklep;

  update tt_z01 set
  utarg_na_sprzed_s = utarg_s / liczba_sprzed_s -- kol. 20
  ;

  update tt_z01 set
  placa_do_przych_s = koszty_sklepu_s / utarg_s -- kol. 21
  ;

  update tt_z01 set
  rok = _ROK, miesiac = _MIESIAC;

 END IF; -- koniec _od < '2024-11-01'


 IF _od >= '2024-12-01' THEN -- nowa wersja zestawienia, zgodna z nowymi zasadami naliczania płac
 	DROP TABLE IF EXISTS tt_z00;
  CREATE TEMPORARY TABLE `tt_z00` (
   areaGUID varchar(40) ,
   pracGUID varchar(40) ,
  `GodzNaSklepie` double(16,2), -- kol 1
  `GodzSN` double(16,2), -- kol 8 (liczba godzin na sklepie w soboty, niedz, swieta)
  `SumaGodz` double(16,2) ,
  `stawka_brutto` double(16,2), -- kol. 2
  `kwota_netto` double(16,2), -- wstep do kol. 4 - suma wyplat pracownika
  `do_wyplaty_sklep` double(16,2), -- kol. 4
  `netto_zpremia` double(16,2), -- kol. 3
  placa_brutto double(16,2), -- kol. 5
  GodzNoc double(16,2), -- potrzebne do kol 6
  KwotaNoc double(16,2), -- kol. 6 (kwota za noc)
  KwotaSN double(16,2), -- kol. 7 (kwota za swieta, niedziele)

  GodzNPlatne double(16,2), -- nieobecnosci platne
  SumaGodzNPlatne double(16,2), -- nieobecnosci platne pracownika w calym miesiacu
  urlop_wopok double(16,2), -- kol nowa, suma wynagrodzeń za urlop wyp, opieka, okolicznosciowy
  zwolnienia double(16,2), -- kol nowa, suma wynagrodzeń za zwolnienia rozne

  placa_brutto_razem double(16,2), -- kol. 11
  proc_premia double(16,2), -- kol. 9
  premia double(16,2), -- kol. 10
  spoleczne double(16,2), -- kol. 12 (skladki spol. pracodawcy ze zlecen)
  brutto_zus double(16,2), -- kol. 13 (skladki spol. pracodawcy ze zlecen + 11)
  koszty_sklepu_s double(16,2), -- kol 14 (suma kol. 13 dla sklepu)
  GodzNaSklepie_s double(16,2), -- kol 17 (suma kol. 1 dla sklepu)
  utarg_s double(16,2), -- kol 15, suma ze sprzedazy
  utarg_na_godz double(16,2), -- kol 18
  liczba_sprzed double(16,2), -- kol 19 (liczba sprzedawczyn indywidualnie)
  liczba_sprzed_s double(16,2), -- kol 19 (liczba sprzedawczyn w sklepie zsumowana)
  utarg_na_sprzed_s double(16,2), -- kol 20
  placa_do_przych_s double(16,2), -- kol 21
  wzrost_rtr varchar(10) DEFAULT '', -- kol 16, nie liczymy
  dochod_strata varchar(10) DEFAULT '', -- kol 22, nie liczymy
  rok int,
  miesiac int,
  KEY areaGUID(areaGUID),
  KEY pracGUID(pracGUID)
  ) DEFAULT CHARSET=cp1250 -- COLLATE=cp1250_general_ci
  ;

  insert into tt_z00 (areaGUID, pracGUID, GodzNaSklepie, GodzNoc, GodzSN, liczba_sprzed, rok, miesiac)
  select p.areaGUID, p.pracGUID,
  p.godz, p.godz_noc, p.godz_sns,
  p.etat_przel as liczba_sprzed,
  p.Y, p.M
  from pl_zrcp_gr p
  where p.Y = 2024 and p.M = 7
  order by p.areaGUID, p.pracGUID
  ;
 -- to są łaczny czas pracy danego pracownika w tym miesiącu
  update tt_z00 t
  set t.SumaGodz =
  (select sum(godz) from pl_zrcp_gr where Y = _ROK and M = _MIESIAC and pracGUID = t.pracGUID)
  ;

  update tt_z00 t
  SET t.stawka_brutto =
  (select StawkaGodzinowa from historia_pracy where GUIDpr = t.pracGUID and OdDnia <= _do order by OdDnia desc limit 1)
  ;

  update tt_z00 t
  SET t.kwota_netto =
  ifnull((select sum(KwotaNetto) from place
  join listy_plac l1 on l1.idn=nrlisty
  where place.rok= _ROK and place.miesiac= _MIESIAC and guid_pracownika=t.pracGUID and l1.lista_glowna=1 AND deleted=0),0) +

  ifnull((select sum(KwotaNetto) from prace_zlecone where year(DataOd) = _ROK and Month(DataOd)= _MIESIAC and guid_pracownika=t.pracGUID and deleted=0),0) +

  ifnull((select sum(ps.kwota) from place_skladniki ps inner join place pl on ps.guid_zapisu_placowego = pl.guid
  inner join listy_plac l2 on l2.idn=pl.nrlisty
  where pl.rok= _ROK and pl.miesiac= _MIESIAC and ps.RodzajSkladnika = 5 and guid_pracownika=t.pracGUID and l2.lista_glowna=1 AND pl.deleted=0),0) +
  ifnull((select sum(ps.kwota) from place_skladniki ps inner join prace_zlecone pl on ps.guid_zapisu_placowego = pl.guid where year(pl.DataOd) = _ROK and Month(pl.DataOd)= _MIESIAC and ps.RodzajSkladnika = 5 and guid_pracownika=t.pracGUID and deleted=0),0)
  ;

  -- godziny nieplatne na danym sklepie
  DROP TABLE IF EXISTS tt_z05;
  CREATE TEMPORARY TABLE `tt_z05` (
  areaGUID varchar(40),
  pracGUID varchar(40),
  GodzNPlatne double(16,2), -- nieobecnosci platne
  KEY areaGUID(areaGUID),
  KEY pracGUID(pracGUID)
  ) DEFAULT CHARSET=cp1250;

  insert into tt_z05
  select
  p.areaGUID, p.pracGUID,
  ifnull(sum(fp3.godz_absencji/60),0) AS GodzNPlatne
  from pl_zrcp p
  left join frekw_po fp3 on fp3.rok_msc_dzien = p.D and fp3.pracGUID = p.pracGUID
  left join frekw f3 on f3.GUID = fp3.frekwGUID and f3.deleted=0
  where p.Y = _ROK and p.M = _MIESIAC
  and fp3.absencja IN ('C','W','G','L','K','M','O','R','D','Z','T','E','Q','WD','EO','EZ','MO','MR','MT')
  group by p.areaGUID, p.pracGUID
  having GodzNPlatne > 0
  ;

  update tt_z00 t, tt_z05 t5
  SET t.GodzNPlatne = t5.GodzNPlatne
  where t.pracGUID = t5.pracGUID and t.areaGUID = t5.areaGUID
  ;

  -- godziny nieplatne w miesiacu dla pracownika w ogole w miesiacu
  update tt_z00 t
  SET t.SumaGodzNPlatne =
  (select
  ifnull(sum(fp.godz_absencji/60),0)
  from frekw_po fp
  inner join frekw f on f.GUID = fp.frekwGUID
  where f.rok = _ROK and f.miesiac = _MIESIAC
  and fp.pracGUID = t.pracGUID
  and f.deleted=0
  and fp.absencja IN ('C','W','G','L','K','M','O','R','D','Z','T','E','Q','WD','EO','EZ','MO','MR','MT')
  group by t.pracGUID)
  ;

  update tt_z00 t
  SET t.spoleczne =
  ifnull((select sum(SklFemerytalnyZleceniod+SklFrentowyZleceniod+SklFchorobowyZleceniod+SklFwypadkowyZleceniod) from prace_zlecone where year(DataOd) = _ROK and Month(DataOd) = _MIESIAC and guid_pracownika=t.pracGUID and deleted=0),0)
  +
  ifnull((select sum(SklFemerytalnyPracod+SklFrentowyPracod+SklFchorobowyPracod+SklFwypadkowyPracod) from place where rok= _ROK and miesiac= _MIESIAC and guid_pracownika=t.pracGUID and deleted=0),0)
  ;

  update tt_z00 t
  SET t.urlop_wopok =
  ifnull((select sum(ps.kwota) from place_skladniki ps inner join place pl on ps.guid_zapisu_placowego = pl.guid where pl.rok= _ROK and pl.miesiac= _MIESIAC and ps.GUID_definicja_skladnika_placy IN ('C_6','C_7','C_8') and guid_pracownika=t.pracGUID and pl.deleted=0),0)
  ;

  update tt_z00 t
  SET t.zwolnienia =
  ifnull((select sum(ps.kwota) from place_skladniki ps inner join prace_zlecone pl on ps.guid_zapisu_placowego = pl.guid where year(pl.DataOd) = _ROK and Month(pl.DataOd) = _MIESIAC and ps.GUID_definicja_skladnika_placy IN ('C_9','C_10','C_11') and guid_pracownika=t.pracGUID and pl.deleted=0),0)
  +
  ifnull((select sum(ChoroboweFirma + ChoroboweZUS) from place where rok= _ROK and miesiac= _MIESIAC and guid_pracownika=t.pracGUID and deleted=0),0)
  ;

  -- tutaj porzadki z nullami
  update tt_z00 set
  GodzNPlatne = ifnull(GodzNPlatne,0),
  SumaGodzNPlatne = ifnull(SumaGodzNPlatne, 0)
  ;

  -- ten kawałek powinien brać dane z nowych kluczy, ale na razie tak zostaje, co czasów ustalen z konkolem
  update tt_z00 t set
  t.proc_premia =
  (select ext.proc_premii/100 from erp_area_nodes ean, erp_area_nodes_ext ext
  where ext.areaGUID = ean.GUID AND `type`='LOC' and ean.guid = t.areaGUID
  and ext.rok = _ROK AND ext.miesiac = _MIESIAC limit 1);


  update tt_z00 set
  do_wyplaty_sklep = kwota_netto * (GodzNaSklepie + GodzNPlatne)/(SumaGodz+SumaGodzNPlatne)
  ;

  update tt_z00 set
  netto_zpremia = do_wyplaty_sklep/ifnull(GodzNaSklepie + GodzNPlatne,1), -- 3=4/1
  placa_brutto = ifnull(GodzNaSklepie,1) * stawka_brutto, -- 5=1*2
  KwotaNoc = GodzNoc * _stawka, -- 6= 8 * stawka nocna z IReg
  KwotaSN = GodzSN * stawka_brutto * 0.5 -- 7=8*2* 0.5
  ;

  update tt_z00 set
  premia = (placa_brutto + KwotaSN) * proc_premia -- kol. 10 = 9*11
  ;

  update tt_z00 set
  placa_brutto_razem = placa_brutto + KwotaNoc + KwotaSN +
  ((urlop_wopok + zwolnienia) * GodzNaSklepie/SumaGodz) + premia
  -- kol. 11 = 5 + 6 + 7 + nowe kolumny podzielone proporcjonalnie
  ;

  update tt_z00 set
  brutto_zus = placa_brutto_razem + spoleczne -- kol. 13 = 11+12
  ;

  -- dane grupowane wg sklepu, w sumie to tylko koszty, bo reszta danych jest w tabeli pl_zrcp_pr
  insert into tt_zr03 (areaGUID, koszty_sklepu_s)
  select areaGUID, sum(brutto_zus) from tt_z00 group by areaGUID;

  update tt_z00 t, tt_zr03 t3
  set t.koszty_sklepu_s = t3.koszty_sklepu_s
  where t.areaGUID = t3.areaGUID;

  update tt_z00 t, pl_zrcp_pr pl set
  t.GodzNaSklepie_s = pl.godz,
  t.utarg_s = pl.przychod_razem,
  t.utarg_na_godz = _Rnd2(pl.przychod_razem/pl.godz),
  t.liczba_sprzed_s = pl.etat_przel,
  t.utarg_na_sprzed_s = pl.przychod_na_etat
  where t.areaGUID = pl.areaGUID
  and pl.Y = _ROK and pl.M = _MIESIAC;

  update tt_z00 set
  placa_do_przych_s = koszty_sklepu_s / utarg_s -- kol. 21
  ;

  insert into tt_z01
  select a.symbol, a.nazwa, _do, _do,
  o.nazwisko, o.imiona,
  GodzNaSklepie,
  GodzSN,
  SumaGodz,
  stawka_brutto,
  kwota_netto,
  do_wyplaty_sklep,
  netto_zpremia,
  placa_brutto,
  GodzNoc,
  KwotaNoc,
  KwotaSN,
  GodzNPlatne,
  SumaGodzNPlatne,
  urlop_wopok,
  zwolnienia,
  placa_brutto_razem,
  proc_premia,
  t.premia,
  spoleczne,
  brutto_zus,
  koszty_sklepu_s,
  GodzNaSklepie_s,
  utarg_s,
  utarg_na_godz,
  liczba_sprzed,
  liczba_sprzed_s,
  utarg_na_sprzed_s,
  placa_do_przych_s,
  wzrost_rtr,
  dochod_strata,
  rok,
  miesiac
  from tt_z00 t
  inner join erp_area_nodes a on a.GUID = t.areaGUID
  inner join osoby o on o.guid = t.pracGUID
  order by a.symbol, o.nazwisko, o.imiona;

 END IF; -- koniec _od >= '2024-11-01'

END IF; -- RENTOWNOSC_SKLEPOW

/*
zestawienie dla Jarz, rezerwa urlopowa
CALL fr_pl_zest('REZERWA_URLOPOWA','','2023','','','','');
select * from tt_z022 order by nazwisko, imiona;
*/
IF (_MODE = 'REZERWA_URLOPOWA') THEN

	SET @data1 = CONCAT(_ROK-1,'-12-01');
	SET @data2 = CONCAT(_ROK,'-11-30');

	SET @data3 = CONCAT(_ROK+1,'-12-31');

	SET @data4 = CONCAT(_ROK,'-12-01');
	SET @data5 = CONCAT(_ROK,'-12-31');

	drop table if exists tt_z01;
	create temporary table tt_z01 (
	nazwisko varchar(50),
	imiona varchar(50),
	NrPesel varchar(15),
	identyfikator varchar(38),
	plec varchar(1),
	rok_mc_urodzenia varchar(7),
	l_lat varchar(1),
	l_miesiecy varchar(1),
	data_zatrudnienia varchar(10),
	czy_przysluguje_odprawa varchar(3),
	czy_planowana_odprawa varchar(3),
	inny_wiek_emerytalny varchar(3),
	kwota double(16,2),
	godziny double(16,2),
	kp_godziny double(16,2),
	kp_godziny_12 double(16,2),
	placazasadnicza double(16,2),
	StawkaGodzinowa double(16,2),
	stawka double(16,2),
	srednia double(16,2),
	data_umowy1 varchar(10),
	data_umowy2 varchar(10),
	uwagi varchar(1),
	KEY identyfikator(identyfikator)
	) DEFAULT CHARSET=cp1250;

	drop table if exists tt_z022;
	create table tt_z022 (
	nazwisko varchar(50),
	imiona varchar(50),
	NrPesel varchar(15),
	identyfikator varchar(38),
	plec varchar(1),
	rok_mc_urodzenia varchar(7),
	l_lat varchar(1),
	l_miesiecy varchar(1),
	data_zatrudnienia varchar(10),
	srednia double(16,2),
	czy_przysluguje_odprawa varchar(3),
	czy_planowana_odprawa varchar(3),
	inny_wiek_emerytalny varchar(3),
	data_umowy1 varchar(10),
	data_umowy2 varchar(10),
	uwagi varchar(1),
	KEY identyfikator(identyfikator)
	) DEFAULT CHARSET=cp1250;


	insert into tt_z01 (nazwisko, imiona, NrPesel, identyfikator, plec, rok_mc_urodzenia, l_lat, l_miesiecy, data_zatrudnienia, czy_przysluguje_odprawa, czy_planowana_odprawa, inny_wiek_emerytalny, kwota, godziny, kp_godziny, kp_godziny_12, placazasadnicza, StawkaGodzinowa, data_umowy1, data_umowy2, uwagi)

	select
	o.nazwisko, o.imiona, o.NrPesel,
	p.guid as identyfikator, IF(o.plec = 0,'K','M') AS plec,
	LEFT(o.DataUrodzenia, 7) as rok_mc_urodzenia,
	'' as l_lat, '' as l_miesiecy,
	p.DataZatrudnieniaWzakl as data_zatrudnienia,

	IF(@data5 >= DATE_ADD(o.DataUrodzenia,INTERVAL if(o.plec=0,60,65) YEAR) and
	(select count(*) from place_skladniki ps
	inner join definicja_skladnika_placy dsp on dsp.guid = ps.GUID_definicja_skladnika_placy
	inner join place pl on pl.guid = ps.GUID_zapisu_placowego
	where dsp.typ_gratyfikacji=0 and dsp.rodzajskladnika=2 and dsp.nazwa = 'odprawa emerytalno rentowa'
	and pl.deleted=0
	and pl.guid_pracownika = p.guid) > 0,
	'NIE', '') as czy_przysluguje_odprawa,

	IF(@data3 >= DATE_ADD(o.DataUrodzenia,INTERVAL if(o.plec=0,60,65) YEAR)
	and @data5 < DATE_ADD(o.DataUrodzenia,INTERVAL if(o.plec=0,60,65) YEAR),
	'TAK', '') as czy_planowana_odprawa,
	'' as inny_wiek_emerytalny,

	ifnull((select sum(ps.kwota)
	from place_skladniki ps
	inner join definicja_skladnika_placy dsp on dsp.guid = ps.GUID_definicja_skladnika_placy
	inner join place pl on pl.guid = ps.GUID_zapisu_placowego
	where dsp.dourlopu=1
	and pl.deleted=0
	and pl.datawyplaty between @data1 and @data2
	and pl.guid_pracownika = p.guid),0) as kwota,

	ifnull((select sum(fp.godziny/60)
	from frekw_po fp
	inner join frekw f on f.guid = fp.frekwGUID
	where f.deleted=0 and fp.rok_msc_dzien between @data1 and @data2
	and fp.pracguid = p.guid),0) as godziny,

	ifnull((select sum(fp.kp_godziny/60)
	from frekw_po fp
	inner join frekw f on f.guid = fp.frekwGUID
	where f.deleted=0 and fp.rok_msc_dzien between @data1 and @data2
	and fp.pracguid = p.guid),0) as kp_godziny,

	ifnull((select sum(fp.kp_godziny/60)
	from frekw_po fp
	inner join frekw f on f.guid = fp.frekwGUID
	where f.deleted=0 and fp.rok_msc_dzien between @data4 and @data5
	and fp.pracguid = p.guid),0) as kp_godziny_12,
	p.placazasadnicza, p.StawkaGodzinowa,

	if(TypOkresuUmowy<2,p.UmowaDo,'') as data_umowy1,
	if(TypOkresuUmowy<2,p.UmowaDo,'') as data_umowy2,

	'' as uwagi

	from Pracownicy p
	inner join osoby o on o.guid=p.guid
	where p.topracownik=1 and (p.CzyObecniePracuje=1)
	;

	update tt_z01 set
	stawka = _Rnd2(kwota/(if(godziny<kp_godziny, godziny, kp_godziny))),
	srednia = _Rnd(_Rnd2(kwota/(if(godziny<kp_godziny, godziny, kp_godziny))) * kp_godziny_12 ,0)
	where godziny <> 0
	;

	update tt_z01 set
	srednia = if(placazasadnicza > 0, placazasadnicza, _Rnd(StawkaGodzinowa * kp_godziny_12, 0))
	where godziny = 0
	;

	insert into tt_z022
	select nazwisko, imiona, NrPesel,
	identyfikator,
	plec, rok_mc_urodzenia,
	l_lat,l_miesiecy,
	data_zatrudnienia,
	ifnull(srednia,0),
	czy_przysluguje_odprawa ,
	czy_planowana_odprawa ,
	inny_wiek_emerytalny ,
	data_umowy1,
	data_umowy2,
	uwagi
	from tt_z01;


-- select t.* from tt_poz t;


/*
desc Pracownicy '%umow%';

wyngrodzenie za 12 miesiecy od listopada!!!, skladniki, systemowe
zasadnicza (placa nominalna, i ta druga),
premia, skladniki w gotowce i w naturze,

w definicji byla informacja - wchodzi do sredniej urlopowej
dzielimy przez liczba godzin w miesiacu (dni pracy, ale nie więcej niż nominał z kalendarza!)
kp godziny, frekw po

to daje stawkę godzinową (zaokr. do grosza) i razy czas pracy nominalny w grudniu (zaokrąglaby do złotówki)
*/





END IF;

-- CALL fr_pl_zest('WNIOSKI_URLOPOWE','','','','','','');
-- dla skoku zestaw wnioskow zlozonych przez portal i ręcznie w programie
IF (_MODE = 'WNIOSKI_URLOPOWE') THEN

	/*
	drop table if exists tt_z01;
	create temporary table tt_z01 (
	GUID varchar(38),
	KEY GUID(GUID)
	) DEFAULT CHARSET=cp1250;

	insert into tt_z01 select GUIDWniosku from absencje where frekwGUID = _GUID and rodzaj = 2;
	*/

	select
	'fr_pl_zest_WR' as fr_pl_zest_WR,
	(SELECT valuea FROM IReg WHERE idkey = 'Pelna_nazwa' LIMIT 1) AS FirmaNazwa,
	(SELECT valuea FROM IReg WHERE idkey = 'Address Info' LIMIT 1) AS FirmaAdres,
	(SELECT valuea FROM IReg WHERE idkey = 'Miasto' AND IdPath= 'INT\\SYSTEM\\MOTLAWA\\DaneFirmy' LIMIT 1) AS FirmaMiasto,
	(SELECT valuex FROM IReg WHERE idkey = 'Contact' LIMIT 1) AS FirmaKontakt,
	(SELECT valuea FROM IReg WHERE idkey = 'Reprezentant_firmy_sprawy_kadrowe' LIMIT 1) AS FirmaReprezentant,
	current_date() as data_wydruku,

	(select date(decisionAt) from v_crm_workflow where commisionGUID = a.GUIDWniosku and curr_status = 'accepted' order by idn desc limit 1) as data_zatwierdzenia,

	IF(o.plec = 0,'Pani','Pan') AS plecStr,
	concat(o.imie1,' ',o.nazwisko) as osoba,
	(select date(decisionAt) from v_crm_workflow where commisionGUID = a.GUIDWniosku and curr_status = 'sent' order by idn desc limit 1) as data_zlozenia,
	if(ifnull((select decision_user_nazwiska from v_crm_workflow where commisionGUID = a.GUIDWniosku and curr_status = 'approved_1' order by idn desc limit 1),'')= '',
       (SELECT CONCAT_WS(' ', o.Nazwisko, o.Imie1) AS Zast FROM `crm_workflow_n` cwn LEFT JOIN `crm_workflow_confirm`  cwcZast ON cwcZast.wGUID = cwn.GUID AND cwcZast.IDN_workflow = 0 AND cwcZast.UserGUID = 'uAbsZast' LEFT JOIN `osoby` o ON o.GUID = cwcZast.uGUID WHERE cwn.GUID = a.GUIDWniosku),
       (select decision_user_nazwiska from v_crm_workflow where commisionGUID = a.GUIDWniosku and curr_status = 'approved_1' order by idn desc limit 1)
	  ) as osoba_zastepujaca,
	(select decision_user_nazwiska from v_crm_workflow where commisionGUID = a.GUIDWniosku and curr_status = 'accepted' order by idn desc limit 1) as osoba_zatwierdzajaca,
	a.tAbs/60 as godzin,
	case when a.rodzaj=2 then 'Wniosek o urlop wypoczynkowy'
	when a.rodzaj=3 then 'Wniosek o urlop na żądanie pracownika'
	when a.rodzaj=9 then 'Wniosek o urlop okolicznościowy'
	when a.rodzaj=14 then 'Wniosek o opiekę nad zdrowym dzieckiem'
	end AS wniosek_rodzaj,
	_Rnd2(a.dAbs) AS dni,
	a.*
	from absencje a
	inner join osoby o on o.guid = a.guidpr
	where a.frekwGUID = _GUID and a.rodzaj IN (2,3,9,14);

/*

	-- CALL crm_porta_fide_tools('select.hist', 'WNIOS.PF:100631154528354312', '', '', '', '', '', '', '');
	CALL crm_workflow_TOOLS('Select.workflow.history', _crmGUID, '', '', '', '', '');


	Select.2022.workflow.history
*/

END IF;

-- zestawienie pakietów/dodaktów medycznych dla Cris
-- CALL fr_pl_zest('DODATKI_MED','','2024','4','','','');
IF (_MODE = 'DODATKI_MED') THEN

	drop table if exists tt_med;
	create temporary table tt_med (
	nazwisko varchar(50),
	imie1 varchar(50),
	NrPesel varchar(15),
	identyfikator varchar(38),
	kwota1 double(16,2),
	kwota2 double(16,2),
	kwota3 double(16,2),
	kwota4 double(16,2),
	kwota5 double(16,2),
	rodzaj varchar(20),
	KEY klucz (NrPesel, rodzaj)
	) DEFAULT CHARSET=cp1250;

	insert into tt_med
	SELECT o.nazwisko, o.imie1, o.nrpesel,
	o.info2 AS autoid,
	sum(z.DodUbezpMedyczneZlec) as kwota1,
	-- 0 as kwota2,
	-- sum(if(dsp.znaczenieskladnika=70,ps.kwota,0)) as kwota2,

	ifnull((select sum(ps.kwota) from place_skladniki ps, definicja_skladnika_placy dsp, prace_zlecone z2 where ps.GUID_zapisu_placowego = z2.GUID and dsp.GUID = ps.GUID_definicja_skladnika_placy and dsp.ZnaczenieSkladnika=70 and z2.GUID_pracownika = o.GUID and z2.rok = _ROK and z2.miesiac = _MIESIAC),0) as kwota2,

	sum(z.PotrDodUbezpMedyczneZlec) as kwota3,

	ifnull((select sum(ps.kwota) from place_skladniki ps, definicja_skladnika_placy dsp, prace_zlecone z2 where ps.GUID_zapisu_placowego = z2.GUID and dsp.GUID = ps.GUID_definicja_skladnika_placy and dsp.ZnaczenieSkladnika=72 and z2.GUID_pracownika = o.GUID and z2.rok = _ROK and z2.miesiac = _MIESIAC),0) as kwota4,

	ifnull((select sum(ps.kwota) from place_skladniki ps, definicja_skladnika_placy dsp, prace_zlecone z2 where ps.GUID_zapisu_placowego = z2.GUID and dsp.GUID = ps.GUID_definicja_skladnika_placy and dsp.ZnaczenieSkladnika=73 and z2.GUID_pracownika = o.GUID and z2.rok = _ROK and z2.miesiac = _MIESIAC),0) as kwota5,

	-- sum(if(dsp.znaczenieskladnika=72,ps.kwota,0)) as kwota4,
  -- sum(if(dsp.znaczenieskladnika=73,ps.kwota,0)) as kwota5,
	-- 0 as kwota4, 0 as kwota5,
	'umowa-zlecenie' as rodzaj
	FROM prace_zlecone z
	inner join osoby o on o.guid = z.GUID_pracownika

	-- left join place_skladniki ps on ps.GUID_zapisu_placowego = z.GUID
  -- left join definicja_skladnika_placy dsp on dsp.GUID = ps.GUID_definicja_skladnika_placy and dsp.ZnaczenieSkladnika IN (69,70,71,72,73)

	WHERE z.deleted=0
	-- and z.datawyplaty >= '2024-04-01' and z.datawyplaty >= '2024-04-31'
	and z.rok = _ROK AND z.miesiac = _MIESIAC
	-- and (z.DodUbezpMedyczneZlec <> 0 OR z.PotrDodUbezpMedyczneZlec <> 0)

	group by o.guid

	having kwota1<>0 or kwota2<>0 or kwota3<>0 or kwota4<>0 or kwota5<>0
	order by o.nazwisko, o.imie1
	;


	insert into tt_med
	SELECT o.nazwisko, o.imie1, o.nrpesel,
	o.info2 AS autoid,
	sum(if(dsp.znaczenieskladnika=69,ps.kwota,0)),
  sum(if(dsp.znaczenieskladnika=70,ps.kwota,0)),
	sum(if(dsp.znaczenieskladnika=71,ps.kwota,0)),
  sum(if(dsp.znaczenieskladnika=72,ps.kwota,0)),
  sum(if(dsp.znaczenieskladnika=73,ps.kwota,0)),
	'płace' as rodzaj
	FROM place pl
  inner join place_skladniki ps on ps.GUID_zapisu_placowego = pl.GUID
  inner join definicja_skladnika_placy dsp on dsp.GUID = ps.GUID_definicja_skladnika_placy
	inner join osoby o on o.guid = pl.GUID_pracownika
	WHERE pl.deleted=0
	and pl.rok = _ROK AND pl.miesiac = _MIESIAC
  and dsp.ZnaczenieSkladnika IN (69,70,71,72,73)
	and ps.kwota <> 0
	group by o.guid
	order by o.nazwisko, o.imie1;

	/*
	select
	'fr_pl_zest_WR' as fr_pl_zest_WR,
	t.*
	FROM tt_med t
	order by t.nazwisko, t.imie1
	;
*/

END IF;

-- zestawienie liczby przepracowanych godzin dla Hydromegi
-- CALL fr_pl_zest('GODZINY_PRAC','','2024','6','','','');
-- CALL fr_pl_zest('GODZINY_PRAC','','','','','2024-01-01','2024-07-30');
IF (_MODE = 'GODZINY_PRAC') THEN
-- porzadki w danych
-- update katcols set guidlink = replace(guidlink,'\r','') where guidlink like '%\r%' limit 5;
/*
update katcols set guidlink = replace(guidlink,'
','') where guidlink like '%
%';
*/

		IF _ROK <> '' AND _MIESIAC <> '' THEN
				SET _dzienA = CONCAT(_ROK,'-',LPAD(_MIESIAC,2,'0'),'-01');
				SET _dzienB = LAST_DAY(_dzienA);
		ELSE
				SET _dzienA = _Param_A;
				SET _dzienB = _Param_B;
		END IF;

		drop table if exists tt_godz;
		create temporary table tt_godz (
		guid_pracownika varchar(38),
		nazwisko varchar(50),
		imiona varchar(50),
		NrPesel varchar(15),
		rok int,
		mc int,
		data_wykonania date,
		guid_oppo varchar(255), -- guidy pozycji z rw
		guid_zlecenia varchar(38),
		nr_zlecenia varchar(50),
		godz double(16,2),
		nadgodz double(16,2),
		godz150 double(16,2),
		godz200 double(16,2),
		kwota_zlec double(16,2),
		znacznik varchar(2),
		stawkagodzinowa double(16,2),
		placazasadnicza double(16,2),
		SymbolKalendarza varchar(12),
		info varchar(1), -- to info z pozycji kalendarza pracy
		ncp double(16,2), -- nominalny czas pracy

		ProcFemerytalnyPracod double(16,2),
		ProcFrentowyPracod double(16,2),
		ProcFwypadkowyPracod double(16,2),

		ZusFPprc double(16,2),
		ZusFGprc double(16,2),
		kwota_pracod double(16,2),

		SklFEPracod double(16,2),
		SklFRPracod double(16,2),
		SklFWPracod double(16,2),
		SklZusFP double(16,2),
		SklZusFG double(16,2),

		miejsce varchar(12),
		KEY guid_pracownika (guid_pracownika)
		) DEFAULT CHARSET=cp1250;

		insert into tt_godz (guid_pracownika, guid_zlecenia, nr_zlecenia, data_wykonania,
		godz, nadgodz, znacznik)

		select
		kp.GUID_pracownika, p.GUID_zlecenia, k2.valuex, data_wykonania,
		sum(p.godz100), sum(p.godz150+p.godz200),
		-- sum(p.godz150), sum(p.godz200),
		-- sum(p.godz100*p.stawka_godz + p.godz150*p.stawka_godz*1.5 + p.godz200*p.stawka_godz*2),
		'kp' as znacznik
		from zlec_prac p
		left join karty_pracy kp on p.GUID_karty_pracy = kp.guid and kp.deleted=0
		left join zmng z on z.guid = p.GUID_zlecenia
		left join v_kkn2 k2 on z.katcol2 = k2.klucz
		-- where year(p.data_wykonania) = _ROK AND month(p.data_wykonania) = _MIESIAC
		where p.data_wykonania between _dzienA and _dzienB
		group by kp.GUID_pracownika, p.data_wykonania, p.GUID_zlecenia
		;

		-- RW - rodzaj 11
		insert into tt_godz (guid_pracownika, nr_zlecenia, data_wykonania, guid_oppo,
		godz, nadgodz, znacznik)

		select
		kt2.guidlink, k2.valuex, p.datawystaw, group_concat(p.guid),
		sum(if(p.jednostka=8,p.ilosc, 0)) as godz,
		sum(if(p.jednostka <> 8, p.ilosc, 0)) as nadgodz,
		'rw' as znacznik
		from oppo p
		inner join TowrNg t on t.GUID = p.idntowr
		left join v_kkn2 k2 on p.kat2 = k2.klucz -- zlecenia, nr zlecenia
		left join v_ktw2 kt2 on p.kat7 = kt2.klucz -- pracownik
		where p.rodzaj=11 -- and p.datawystaw >= '2024-06-01'
		-- and year(p.datawystaw) = _ROK AND month(p.datawystaw) = _MIESIAC
		and p.datawystaw between _dzienA and _dzienB
		and t.wyroznik = 'RBH'
		and p.tymczasowa = 0
		group by kt2.GUIDlink, p.datawystaw, k2.valuex
		-- having guidlink <> ''
		;

		update tt_godz t
		SET stawkagodzinowa = (select stawkagodzinowa from historia_pracy where guidpr = t.GUID_pracownika and oddnia<= t.data_wykonania order by oddnia desc limit 1)
		;

		update tt_godz t
		SET placazasadnicza = (select placazasadnicza from historia_pracy where guidpr = t.GUID_pracownika and oddnia<= t.data_wykonania order by oddnia desc limit 1)
		;

		update tt_godz t
		SET SymbolKalendarza = (select SymbolKalendarza from historia_pracy where guidpr = t.GUID_pracownika and oddnia<= t.data_wykonania order by oddnia desc limit 1)
		;
		-- ustawienie dnia tygodnia, potrzebne potem do okreslenia rodzaju nadgodzin
		update tt_godz t, kalendpracy k, kalendpracy_po kp
		SET t.info = kp.info
		where t.SymbolKalendarza = k.symbol and k.rok = year(t.data_wykonania) and k.GUID = kp.GUIDNg and t.data_wykonania = kp.data
		;

		-- rodzaje nadgodzin
		update tt_godz t
		SET t.godz150 = t.nadgodz
		-- where info IN ('D') and znacznik = 'rw'
		where info NOT IN ('N') and znacznik = 'rw'
		;

		update tt_godz t
		SET t.godz200 = t.nadgodz
		where info = 'N' and znacznik = 'rw'
		;

		-- dla prabut (kp) nie ma nadgodzin w tygodniu, to sa etatowe godziny i tak
		update tt_godz t
		SET t.godz150 = t.nadgodz
		where info IN ('D') and znacznik = 'kp'
		;

		update tt_godz t
		SET t.godz200 = t.nadgodz
		where info = 'N' and znacznik = 'kp'
		;

		/*
		-- dopiero teraz mozna naliczyc kwoty za zlecenie, gdy wiemy, jaki jest rodzaj nadgodzin
		update tt_godz t
		SET t.kwota_zlec =
		t.godz*t.stawkagodzinowa + t.godz150*t.stawkagodzinowa*1.5 + t.godz200*t.stawkagodzinowa*2
		-- where znacznik = 'kp' -- and stawkagodzinowa <> 0
		;
*/

		update tt_godz t
		SET t.godz150 = 0
		where t.godz150 is null
		;

		update tt_godz t
		SET t.godz200 = 0
		where t.godz200 is null
		;

		update tt_godz t set t.ncp =
		(select
		case
		when month(t.data_wykonania) = 1 then NCP_1/60
		when month(t.data_wykonania) = 2 then NCP_2/60
		when month(t.data_wykonania) = 3 then NCP_3/60
		when month(t.data_wykonania) = 4 then NCP_4/60
		when month(t.data_wykonania) = 5 then NCP_5/60
		when month(t.data_wykonania) = 6 then NCP_6/60
		when month(t.data_wykonania) = 7 then NCP_7/60
		when month(t.data_wykonania) = 8 then NCP_8/60
		when month(t.data_wykonania) = 9 then NCP_9/60
		when month(t.data_wykonania) = 10 then NCP_10/60
		when month(t.data_wykonania) = 11 then NCP_11/60
		when month(t.data_wykonania) = 12 then NCP_12/60
		end
		FROM kalendpracy where rok = year(t.data_wykonania) and symbol = t.SymbolKalendarza and deleted = 0 limit 1)
		;

		update tt_godz t
		SET t.kwota_zlec =
		t.godz*t.stawkagodzinowa + t.godz150*t.stawkagodzinowa*1.5 + t.godz200*t.stawkagodzinowa*2
		where stawkagodzinowa <> 0
		;

		-- tutaj l iczymy kwoty dla placy zasadniczej, uwzgledniajac ncp
		update tt_godz t
		SET t.kwota_zlec =
		_Rnd2(t.godz*placazasadnicza/ncp + t.godz150*placazasadnicza/ncp*1.5 + t.godz200*placazasadnicza/ncp*2)
		where placazasadnicza <> 0
		;

		update tt_godz t, place pl SET
		t.ProcFemerytalnyPracod = pl.ProcFemerytalnyPracod,
		t.ProcFrentowyPracod = pl.ProcFrentowyPracod,
		t.ProcFwypadkowyPracod = pl.ProcFwypadkowyPracod,
		t.ZusFPprc = if(pl.naliczFP=1, pl.ZusFPprc, 0),
		t.ZusFGprc = if(pl.naliczFGSP=1, pl.ZusFGprc, 0)
		where t.guid_pracownika = pl.guid_pracownika and pl.rok = year(t.data_wykonania) and pl.miesiac = month(t.data_wykonania) and pl.deleted=0
		;

		-- kwota_zlec to kwotabrutto w ich rozumieniu w zestawieniu
		update tt_godz t SET
		SklFEPracod = _Rnd2(t.ProcFemerytalnyPracod * t.kwota_zlec/100),
		SklFRPracod = _Rnd2(t.ProcFrentowyPracod * t.kwota_zlec/100),
		SklFWPracod = _Rnd2(t.ProcFwypadkowyPracod * t.kwota_zlec/100),
		SklZusFP = _Rnd2(t.ZusFPprc * t.kwota_zlec/100),
		SklZusFG = _Rnd2(t.ZusFGprc * t.kwota_zlec/100)
		;

		update tt_godz t SET
		t.kwota_pracod =
		_Rnd2(t.kwota_zlec * (t.ProcFemerytalnyPracod + t.ProcFrentowyPracod + t.ProcFwypadkowyPracod + t.ZusFPprc + t.ZusFGprc)/100)
		;

		update tt_godz t SET
		t.kwota_pracod = 0
		where t.kwota_pracod is null
		;

		update tt_godz t SET
		t.miejsce = if(znacznik = 'kp','Prabuty','Gdynia')
		;

		update tt_godz t, osoby o SET
		t.nazwisko = o.nazwisko,
		t.imiona = o.imiona
		where o.GUID = t.GUID_pracownika
		;

/*
		select t.nazwisko, t.imiona,
		t.miejsce,
		t.data_wykonania,
		t.nr_zlecenia,
		t.godz,
		(t.godz150+t.godz200) as nadgodz,
		t.kwota_zlec + t.kwota_pracod as kwota_zlecenia
		from tt_godz t
		order by t.nazwisko, t.imiona, t.data_wykonania, t.nr_zlecenia;
*/
/*
select *
from karty_pracy where rok=2024;

select * from zlec_prac where year(data_wykonania)=2024;
*/


END IF;

-- dla skoku jest juz zestawienie podobniej nazwy, ale chyba do wydruku wniosku urlopowego
-- CALL fr_pl_zest('WNIOSKI_URLOPOWE_SQD','','','','','ALL','');
-- _PARAM_A mowi, czy mają być tylk wnioski urlopowe czy wszystkie
IF (_MODE = 'WNIOSKI_URLOPOWE_SQD') THEN

	drop table if exists tt_wnioski;
	CREATE TEMPORARY TABLE `tt_wnioski` (
  `GUID` varchar(38) NOT NULL COMMENT 'GUID zdarzenia',
  `osobaGUID` varchar(38) NOT NULL,
  `nCreator` varchar(61) DEFAULT NULL,
  `uCreator` varchar(38) DEFAULT NULL,
  pracownik varchar(61) DEFAULT NULL,
  `CreateAt` date DEFAULT NULL,
  `AbsencjaOd` date DEFAULT NULL,
  `AbsencjaDo` date DEFAULT NULL,
  `Zastepca` varchar(61) DEFAULT NULL,
  `KierownikDomys` varchar(61) DEFAULT NULL,
  `Kierownik` varchar(61) DEFAULT NULL,
  `Descr_status` varchar(250) DEFAULT NULL COMMENT 'Opis samego statusu',
  `GUID_Zast` varchar(38) DEFAULT '',
  `GUID_Kier_Domys` varchar(38) DEFAULT '',
  `GUID_Kier` varchar(38) DEFAULT '',
  PozostUrlopWypoczDni INT DEFAULT NULL,
  dzial varchar(100) DEFAULT NULL,
  kategoria varchar(100) DEFAULT NULL,
  podrodzaj INT,
  podrodzaj_str varchar(100) DEFAULT NULL
	) DEFAULT CHARSET=cp1250
	;

	-- uCreatro to guid prawnika, jest potrzebny do filtrowania w zestawieniu, gdy sa podwojne osoby, dla kierownika i zastepcy filtr jest wg nazwisk, do ewentualnej zmiany
	insert into tt_wnioski
	SELECT
	cwn.GUID,
	o_prac.GUID as osobaGUID,
	cwn.nCreator,
	cwn.uCreator,
	CONCAT_WS(' ', o_prac.Nazwisko, o_prac.Imie1) AS pracownik,
	date(cwn.CreateAt) as CreateAt,
	a.AbsencjaOd, a.AbsencjaDo,
	CONCAT_WS(' ', o_zast.Nazwisko, o_zast.Imie1) AS nZastepca,
	CONCAT_WS(' ', o_kierD.Nazwisko, o_kierD.Imie1) AS nKierownikDomys,
	CONCAT_WS(' ', o_kier.Nazwisko, o_kier.Imie1) AS nKierownik,
	cwn.Descr_status,
	o_zast.GUID AS GUID_Zast,
	o_kierD.GUID  AS GUID_Kier_Domys,
	o_kier.GUID AS GUID_Kier,
	0 as PozostUrlopWypoczDni,
	'' as dzial, '' as kategoria,
	cwn.Podrodzaj,
	'' as podrodzaj_str
	FROM `v_crm_workflow_n` cwn
	INNER JOIN `absencje` a ON a.GuidWniosku = cwn.GUID
	INNER JOIN osoby o_prac ON o_prac.GUID = cwn.uCreator
	LEFT JOIN `crm_workflow_confirm` cwc_zast ON cwc_zast.wGUID = cwn.GUID AND cwc_zast.IDN_workflow = 0 AND cwc_zast.UserGUID = 'uAbsZast'
	LEFT JOIN `osoby` o_zast ON o_zast.GUID = cwc_zast.uGUID
	LEFT JOIN `crm_workflow_confirm` cwc_kier ON cwc_kier.wGUID = cwn.GUID AND cwc_kier.IDN_workflow = 0 AND cwc_kier.UserGUID = 'uOdp'
	LEFT JOIN `osoby` o_kier ON o_kier.GUID = cwc_kier.uGUID
	LEFT JOIN `hr_self_links` h_kier ON h_kier.OsobaGUID_A = cwn.uOwner AND h_kier.Rel = 'szef'
	LEFT JOIN `osoby` o_kierD ON o_kierD.GUID = h_kier.OsobaGUID_B
	LEFT JOIN `hr_self_links` h_zast ON h_zast.OsobaGUID_A = cwn.uOwner AND h_zast.Rel = '<-zastepca'
	LEFT JOIN `osoby` o_zastD ON o_zastD.GUID = h_zast.OsobaGUID_B
	WHERE
		cwn.Rodzaj = 16 AND
		IF(_Param_A = 'ALL', cwn.Podrodzaj in (SELECT wniosek_podrodzaj FROM absencje_dict WHERE settingflags LIKE '%[VIEW.PF]%'), cwn.Podrodzaj = 0)

	-- (SELECT wniosek_podrodzaj FROM absencje_dict WHERE settingflags LIKE '%[VIEW.PF]%');
	-- AND cwn.CreateAt > '2024-01-01'
	;

 drop table if exists tt_wf;
	CREATE TEMPORARY TABLE `tt_wf` (
  osobaGUID varchar(38),
  YYYY_MM INT,
  key osobaGUID(osobaGUID),
  key YYYY_MM(YYYY_MM)
	) DEFAULT CHARSET=cp1250
	;

	insert into tt_wf
	SELECT t.osobaGUID, MAX(f.YYYY_MM)
 FROM tt_wnioski t, frekw f
 WHERE t.osobaGUID = f.PracGUID AND f.deleted=0
 GROUP BY t.GUID;

 UPDATE tt_wnioski t, tt_wf tt, frekw f
 SET t.PozostUrlopWypoczDni=f.PozostUrlopWypoczDni
 WHERE t.osobaGUID = tt.osobaGUID AND f.PracGUID = tt.osobaGUID AND tt.YYYY_MM = f.YYYY_MM AND f.deleted=0;

 UPDATE tt_wnioski t, Pracownicy p, dzialy d SET t.dzial = d.opis
 WHERE t.osobaGUID = p.GUID AND p.dzial = d.idn;

 UPDATE tt_wnioski t, Pracownicy p, kategorie_pracownikow kp SET t.kategoria = kp.nazwa
 WHERE t.osobaGUID = p.GUID AND p.KategoriaPracownicza = kp.idn;

 UPDATE tt_wnioski t, absencje_dict d SET t.podrodzaj_str = d.definicja
 WHERE t.podrodzaj = d.wniosek_podrodzaj AND d.wniosek_rodzaj=16;


END IF;


END$$

DELIMITER ;

