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

DROP PROCEDURE IF EXISTS `pl_gratyfikacje_tools_arg7`$$
CREATE DEFINER=`root`@`localhost` PROCEDURE `pl_gratyfikacje_tools_arg7`(
	IN _MODE VARCHAR(150),
	IN _Param_A VARCHAR(50),  -- GUID zlecenia
	IN _Param_B VARCHAR(50),  -- rok
	IN _Param_C VARCHAR(50),  -- miesiac 	
	IN _Param_D VARCHAR(50),  -- GUID pracownika	  
	IN _Param_E VARCHAR(50),	  
	IN _Param_F VARCHAR(50)   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne)    Jest to naliczanie dla Konkola
)
SPROC: BEGIN
	/*
	_MODE

	*/
	
	DECLARE _RozliczajWg INTEGER;
	DECLARE _I, _MZ_idn, _suma_mies, _dniW, _period INTEGER;
	DECLARE _ZLEC_Potr INTEGER DEFAULT 4;   -- cInnePotracenia
	DECLARE cInneDodatki INTEGER DEFAULT 5;   -- cInneDodatki
	DECLARE _ZLEC_ZUS  INTEGER DEFAULT 6;	-- 3
	DECLARE _ZaZlecenie, _SklHestia, _GratyfPodst, _DodNocny, _MinWynagr, _NomCzasPracyREG  DOUBLE;
	DECLARE  _KwotaJarzExtra1,  _KwotaJarzExtra2 DOUBLE;
	DECLARE _SQLText TEXT;
	
	DECLARE _GrafikCzasPracy, _CzasZ, _ProcPremii, _SG, _SGdef, aSGNoc, _SGp, _SGz DOUBLE;
	DECLARE _MaxAreaGUID, _CurrAreaGUID, _CurrFrekwGUID, _CurrWorkerGUID, _OrderGUID, _RangeGUID VARCHAR(38);
	DECLARE _IsMaxArea BOOLEAN;
	
	DECLARE _godzSNS, _godzSNS_nast,  _NCP,  _GodzNocne, _godzW, _OCP, _OCP_3mc, _godz_3mc,
			_SUM_12m, _kwotaW, _kwota_def DOUBLE;
	
	DECLARE _godzP, _godz_niedorobka, _godz_total, _godz100prac,  _godziny150, _godz_plus100wolne, 
			_godziny_premia, _godz_noc, _godz_yy DOUBLE;  -- ,  _godzSNS
	
	DECLARE aPlaca, aNadGodz150, aNadGodz200,  aPremia, aPremiaMotyw, aPremiaUzn, 
	        _suma_place, _suma_zlec, aNoc, aNoc_yy DOUBLE;
	
	DECLARE _SymbZakr VARCHAR(200);
	DECLARE _Def_NCP_REG, _NCP_REG_mc VARCHAR(10);
	
	DECLARE _done BOOL DEFAULT FALSE;	
	
		
	-- DECLARE _DB_ZLEC VARCHAR(50);
	
/*	DECLARE _work_c CURSOR FOR	
	SELECT  
	  AreaGuid, WorkerGuid, orderGUID	
	FROM tt_area_order;  */
	
    /*  #43752 ZREMB */
	IF _MODE = 'create.from.existing' THEN
	  
	  SET @pl.newGUID = md5(concat(_Param_A, _Param_D));  -- GUID zapisu org. + idn wybranej listy plac
	  REPLACE INTO place 
		(GUID, rok, miesiac, nrlisty, datawyplaty, DataWyplDoDeklar, 
		 GUID_pracownika, nazwisko, Kategoria_Idn, wzordekr, 
		 KluczWzoruPK,  -- po przejsciu na {$DEFINE WZ_DEKR_SYMBOL} to pole nie bedzie potrzebne
		 katcol0, katcol1, katcol2, katcol3, katcol4, KodTytUbezp, KodTytUbzpMacWych, ProcentPodatku, 
		 ProcSkladkiKZP, ProcFemerytalnyPracow, ProcFrentowyPracow, ProcFchorobowyPracow, ProcFwypadkowyPracow, ProcKasaChorychPracowPobr, ProcKasaChorOdlicz,
		 ProcFemerytalnyPracod, ProcFrentowyPracod, ProcFchorobowyPracod, ProcFwypadkowyPracod, ProcKasaChorychPracod,
		 ProcFemerytalnyBudzet, ProcFrentowyBudzet, ProcFchorobowyBudzet, ProcFwypadkowyBudzet, ProcKasaChorychBudzet,
		 ProcFemerytalnyPFRON, ProcFrentowyPFRON, ProcFchorobowyPFRON, ProcFwypadkowyPFRON, ProcKasaChorychPFRON, ProcKasaChorychZUS
		)
	  SELECT 
		@pl.newGUID, _varINT(_Param_B), _varINT(_Param_C), _varINT(_Param_D), _Param_E, _Param_F AS DataWyplDoDeklar, 
		GUID_pracownika, nazwisko, Kategoria_Idn, wzordekr,
		-- po przejsciu na {$DEFINE WZ_DEKR_SYMBOL} ponizsza linia nie b�dzie juz potrzebna:
		(SELECT w.idn FROM wzordekr w WHERE w.rok = _varINT(_Param_B) AND w.symbol = (SELECT tmp.symbol FROM wzordekr tmp WHERE tmp.idn = p.kluczwzorupk) LIMIT 1) AS KluczWzoruPK,  
		katcol0, katcol1, katcol2, katcol3, katcol4, KodTytUbezp, KodTytUbzpMacWych, ProcentPodatku, 
		ProcSkladkiKZP, ProcFemerytalnyPracow, ProcFrentowyPracow, ProcFchorobowyPracow, ProcFwypadkowyPracow, ProcKasaChorychPracowPobr, ProcKasaChorOdlicz,
		ProcFemerytalnyPracod, ProcFrentowyPracod, ProcFchorobowyPracod, ProcFwypadkowyPracod, ProcKasaChorychPracod,
		ProcFemerytalnyBudzet, ProcFrentowyBudzet, ProcFchorobowyBudzet, ProcFwypadkowyBudzet, ProcKasaChorychBudzet,
		ProcFemerytalnyPFRON, ProcFrentowyPFRON, ProcFchorobowyPFRON, ProcFwypadkowyPFRON, ProcKasaChorychPFRON, ProcKasaChorychZUS
	  FROM 
		place p
	  WHERE  p.GUID = _Param_A AND deleted = 0;  -- _Param_A = GUID zapisu �r�d�owego 
	  	  	  
	  -- wstawiamy skladniki systemowe...
	  REPLACE INTO place_skladniki
		(GUID, GUID_zapisu_placowego, GUID_definicja_skladnika_placy, RodzajSkladnika)
	  SELECT 
		uuid(), @pl.newGUID, GUID_definicja_skladnika_placy, RodzajSkladnika
	  FROM 
		place_skladniki
	  WHERE  GUID_zapisu_placowego = _Param_A AND RodzajSkladnika = 0;
	  
	  -- ...oraz wskazany sk�adnik w got�wce  (@pl.SklGUID = GUID podczepianego skladnika, zmienna globalna ustawiona przed wywolaniem procedury)
	  DELETE FROM place_skladniki WHERE GUID_zapisu_placowego = @pl.newGUID;
	  
	  REPLACE INTO place_skladniki
		(GUID, GUID_zapisu_placowego, GUID_definicja_skladnika_placy, RodzajSkladnika, kwota, NomKwota, ZmniejszZwieksz)
	  SELECT 
		uuid(), @pl.newGUID, @pl.SklGUID, RodzajSkladnika, SUM(kwota), SUM(NomKwota), SUM(ZmniejszZwieksz)
	  FROM 	place_skladniki
	  WHERE  GUID_zapisu_placowego = _Param_A AND RodzajSkladnika IN (2,5) 
	  GROUP BY GUID_zapisu_placowego; -- zalozenie jest takie, �e do zapisu �r�d�owego jest podpi�ty tylko jeden sk�adnik w got�wce i jeden sk�adnik typu "inne dodatki"
	  -- LIMIT 1;	
	  
	END IF;

	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.one.order.mode.jarz.extra'
		Naliczenie  jednego zlecenia (reszta wynagrodzenia)  - Jarzembinscy
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	data wyp�aty   -- GUID karty frekwencji za dany miesiac
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" <- p�ki co zawsze "auto"
		
		CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.jarz.extra', 'ZlecGUID', '2012', '5', 'Prac1', '2012-12-01', 'manual');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.one.order.mode.jarz.extra' THEN
	
		SET _ZaZlecenie = 0; SET _DodNocny = 0;  SET _godz_total = 0; set _godzP =0; set _godz_niedorobka = 0;
		SET _ProcPremii = 0; SET _SG  = 0; SET _GratyfPodst = 0;	SET _SGdef = 0;	SET _godzW = 0;
		SET _RozliczajWg = 0;  SET _CzasZ = 0;   SET _godz100prac = 0; SET  _OCP = 0; SET _kwota_def = 0;
		SET _OCP_3mc = 0; SET _godz_3mc = 0;  SET _SGp = 0; SET _SGz = 0; SET _kwotaW = 0;
		
		-- "stawka godzinowa 2" z karty pracownika
		SELECT StawkaGodzinowa2, StawkaGodzinowa
		FROM Pracownicy
		WHERE GUID = _Param_D
		INTO _SG, _SGdef;
		
		-- nadgodziny do rozliczenia
		SELECT 
			GUID, (godz100prac + godz_plus50prac + godz_plus50wolne + 
			  godz_plus100prac + godz_plus100wolne)/60 AS godz_przeprac,
			  (W_godz + G_godz)/60 as urlop_wypocz
		FROM 
			frekw 
		WHERE rok = _Param_B AND miesiac = _Param_C AND PracGUID = _Param_D	AND deleted = 0 
		INTO _CurrFrekwGUID, _godz_total, _godzW;  
		
		SELECT 
	        -- ponizej: je�li ma literk� P (wolne za SN�), ale ma godz. wej. to znaczy, �e pracowal	
			-- OR (absencja = 'P' AND IFNULL(godz_wej, 0) > 0 )
			SUM(IF(absencja IN ('E', '', 'P') , kp_godziny, 0))/60  AS realCP,  -- rozmowa z p.Bozena: usuwamy st�d '-' tzn. liczymy godziny tylko za okres, w ktorym pracownik by� zatrudniony
			SUM(IF(absencja IN ('P'), kp_godziny, 0))/60 AS godzP,
			SUM(IF(absencja IN ('') AND kp_godziny > godziny, kp_godziny - godziny, 0))/60 AS godz_niedorobka
		FROM 
			frekw_po 
		WHERE FrekwGUID = _CurrFrekwGUID
		INTO _OCP, _godzP, _godz_niedorobka;	
		
		SET @jarz.extra._godz_total = _godz_total;
		SET @jarz.extra._OCP = _OCP;
		SET @jarz.extra._CurrFrekwGUID =  _CurrFrekwGUID;
				
		IF _godz_total > _OCP THEN  -- jesli mamy nadgodziny (w skali miesi�ca, a nie poszczeg�lnych dni), to naliczamy zlecenie
		  
		   -- kwota1 = (godzP + godz_niedorobka) * StawkaGodzinowa   		 
		   SET _KwotaJarzExtra1 = (_godzP + _godz_niedorobka) * _SGdef;
		   
		 /* 2) godz2: suma wszystkich przeprac. godz. - nomina� (OCP)    // -  (godzP + godz_niedorobka)
             kwota2 = godz2 * StawkaGodzinowa2 */
		   SET _KwotaJarzExtra2 = GREATEST(_godz_total - _OCP, 0) * _SG;   --   - (_godzP + _godz_niedorobka)
		   SET _ZaZlecenie = _KwotaJarzExtra1 + _KwotaJarzExtra2;
		ELSE
		  SET _ZaZlecenie = 0;  -- nie ma nadgodzin (w skali miesiaca), to nie naliczamy w og�le zlecenia
		END IF;
		
		SET @jarz.extra.ZaZlecenie  = _ZaZlecenie;
		
        /* stara wersja naliczania - sprzed zmian w dn.	29.05.2013
		-- jesli suma przepracowanych godzin 100 jest mniejsza od obliczonego CP (NCP - nieobecnosci), to nadgodziny
		-- bedace podstaw� do kwoty "za zlecenie" zmniejszamy o "brakuj�ce" godziny100
		IF((_CzasZ > 0) AND _OCP > _godz100prac)  THEN
			SET _CzasZ = GREATEST(0, (_CzasZ - (_OCP - _godz100prac)) );
			-- za "brakujace" (do zrealizowania pe�nego NCP) godziny kwota jest liczona po stawce standardowej:
			SET _kwota_def = (_OCP - _godz100prac) * _SGdef;
		END IF;		
		
		SET _ZaZlecenie = _CzasZ * _SG;
		IF _kwota_def > 0 THEN
			SET _ZaZlecenie = _ZaZlecenie +  _kwota_def;
		END IF;
		*/	
			
		IF _ZaZlecenie > 0 THEN
		    -- SET  _ZaZlecenie = _Rnd(_ZaZlecenie, 2);											  
			--	SET  _ZaZlecenie = ROUND(_ZaZlecenie, 0);											  
			SET  _ZaZlecenie = CEIL(_ZaZlecenie);

			update frekw set
			  StawkaDlaKolek = _SG,
			  WynagrNadGodz = _ZaZlecenie
			WHERE rok = _Param_B AND miesiac = _Param_C AND PracGUID = _Param_D	AND deleted = 0;   
			
				
					 SET @jarz.extra.DataOd = ifnull(concat(_Param_B,'-',_Param_C,'-01'), current_date);			
					 SET @jarz.extra.DataDo = ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
					 SET @jarz.extra.DataWypl = _Param_E; -- ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
										
					SET _MZ_idn = 0;
					
					-- jesli jest juz rekord o takim GUIDzie, to kopiujemy jego idn i wstawiamy do tab.tymcz. (ma to pozniej znaczenie przy replace)
					set _I = 0;
					select idn from prace_zlecone where guid = _Param_A into _I;
					
					if _I  = 0 then
						select max(idn)+1 from prace_zlecone into _I;
					end if;	
					
					-- #032872 ew. wynagrodzenie za czas urlopu wypocz.
					IF _godzW > 0 THEN
					    SET @jarz.extra.godzW = _godzW;
					    SET _period = 100* _VarINT(_Param_B) + _VarINT(_Param_C); 
						SET @jarz.extra.period = _period;
						
						-- SET _mc_od, SET _mc_do
					
						-- (1) suma skladnikow placowych z 3 miesiecy poprzedzajacych urlop
						SELECT SUM(ps.kwota + ps.ZmniejszZwieksz)  AS suma_place
						FROM place g, place_skladniki ps, definicja_skladnika_placy dsp
						WHERE ps.GUID_definicja_skladnika_placy = dsp.guid AND dsp.DoUrlopu = 1
							AND ps.GUID_zapisu_placowego = g.guid
							-- AND g.guid_pracownika = _Param_D AND g.rok = _Param_B AND (g.miesiac BETWEEN _VarINT(_Param_C) - 3-1 AND _VarINT(_Param_C) - 1-1) AND g.deleted = 0
							AND g.guid_pracownika = _Param_D AND g.deleted = 0 
							-- AND g.rok = 2013 AND (g.miesiac BETWEEN 9 AND 11)   -- rozwiazac na przelomie lat
							AND ( (100*g.rok + g.miesiac) BETWEEN PERIOD_ADD(_period, -3-1) AND PERIOD_ADD(_period, -1-1) )							
						INTO  _suma_place;
						set @_suma_place = _suma_place;

						-- (2) suma wynagr. z tytulu umowy-zlecenia z 3 m-cy poprz. urlop  (analogia do (1) )
						SELECT IFNULL(SUM(ZaZlecenie), 0) AS suma_zlec  
						FROM prace_zlecone  z
						WHERE 
						  z.guid_pracownika = _Param_D AND z.deleted=0 
						  -- AND z.rok = _Param_B AND (z.miesiac BETWEEN _VarINT(_Param_C) - 3-1 AND _VarINT(_Param_C) - 1-1) 
						  -- AND z.rok = 2013 AND (z.miesiac BETWEEN 9 AND 11)  -- rozwiazac na przelomie lat
						  AND ( (100*z.rok + z.miesiac) BETWEEN PERIOD_ADD(_period, -3-1) AND PERIOD_ADD(_period, -1-1) )						  
						INTO  _suma_zlec;  
						SET @_suma_zlec = _suma_zlec;
					
						-- (3) czasy pracy z 3 m-cy poprzedzajacych urlop
						SELECT 						
						_Rnd(SUM(IF(absencja IN ('E', '', 'P') , kp_godziny, 0))/60, 0)  AS realCP_3mc,  
						_Rnd(SUM(godziny)/60, 0) AS godz_3mc						
						FROM 
							frekw_po 
						WHERE 
							PracGUID = _Param_D 
							-- YEAR(rok_msc_dzien) = _Param_B AND (MONTH(rok_msc_dzien) BETWEEN _VarINT(_Param_C) - 3 -1 AND _VarINT(_Param_C) - 1 -1) 
							-- YEAR(rok_msc_dzien) = 2013 AND (MONTH(rok_msc_dzien) BETWEEN 9 AND 11) -- rozwiazac na przelomie lat
							AND ( (100*YEAR(rok_msc_dzien) + MONTH(rok_msc_dzien)) BETWEEN PERIOD_ADD(_period, -3-1) AND PERIOD_ADD(_period, -1-1) )						  
						INTO _OCP_3mc, _godz_3mc;	
						SET @_OCP_3mc = _OCP_3mc;
						SET @_godz_3mc = _godz_3mc;	
					
						-- (4) stawki godz. urlopu wypocz. w ramach umowy o prace i w ramach umowy-zlecenia
						SET _SGp = _Rnd(_suma_place / _OCP_3mc, 2);
						SET _SGz = _Rnd((_suma_place + _suma_zlec)/ _godz_3mc, 2);
						set @_SGp = _SGp;
						set @_SGz = _SGz;
						-- (5) wynagr. za urlop wypocz. z tytulu umowy o prace  (stawka * godz. urlopu)
						SET aPlaca =  _Rnd(_SGp * _godzW, 2);
						
						-- (6) wynagr. za urlop wypocz. z tytulu umowy-zlecenia  
						SET -- _kwotaW =  (_SGz * _godzW) -  aPlaca;
						   _kwotaW = _Rnd( (_SGz - _SGp) * _godzW ,0);
						set @_kwotaW = _kwotaW;
					END IF;  -- naliczenia wynagrodzenia za czas urlopu wypoczynkowego
										
																					
					-- wstawienie do place_zlec i do place_skladniki
					REPLACE INTO tt_prace_zlecone 
					(idn, GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, DataZawarcia, NrZlecenia, 
					  ZaZlecenie, kwota_za_UW, RodzajRyczaltu,  -- slon add DataOd
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, AreaGUID, DataWyplaty, MZ_Idn  -- , ZlecERP
					)   -- nazwisko,  @pl.gratyf.za_zlecenie
					VALUES(_I, _Param_A, _Param_D, _Param_C, _Param_B, @jarz.extra.DataOd, @jarz.extra.DataDo, @jarz.extra.DataOd, '', 
					  _ZaZlecenie, IFNULL(_kwotaW, 0), 7,   
					  (SELECT ValueN FROM IReg WHERE idkey = 'Procent_kosztow_um_zlec' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_odliczone_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecdawcy' AND rok = _Param_B),  -- , ProcFwypadkowyZleceniod = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FP_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FGSP_zlecdawcy' AND rok = _Param_B), _Param_E, @jarz.extra.DataWypl, _MZ_idn  -- , 1
					);  -- 20, (SELECT nazwisko from osoby WHERE GUID = _Param_C),
				
													
					-- Z_1-Z_5(rodz.skl = 0) 
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_1')), 'Z_1', _Param_A, _ZaZlecenie, _ZaZlecenie , 0);  -- @pl.gratyf.za_zlecenie, @pl.gratyf.za_zlecenie
					set @jmam='z1';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_2')), 'Z_2', _Param_A, 0, 0, 0);
					set @jmam='z2';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_3')), 'Z_3', _Param_A, 0, 0, 0);
					set @jmam='z3';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_4')), 'Z_4', _Param_A, 0, 0, 0);
					set @jmam='z4';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_5')), 'Z_5', _Param_A, 0, 0, 0);
					set @jmam='z5';
					-- Z_ZUS_1 - 9 (rodz.skl = 6)  _ZLEC_ZUS
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_1')), 'Z_ZUS_1', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_2')), 'Z_ZUS_2', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_3')), 'Z_ZUS_3', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_A, 'Z_ZUS_4')), 'Z_ZUS_4', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_5')), 'Z_ZUS_5', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_6')), 'Z_ZUS_6', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_7')), 'Z_ZUS_7', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_8')), 'Z_ZUS_8', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_9')), 'Z_ZUS_9', _Param_A, 0, 0, _ZLEC_ZUS);
					set @pl.gratyf.debug = 'zus9';
									
					CALL pl_gratyfikacje_tools_arg7('pl.przepisz.dane.pracownika.one.zlec', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);

					-- wszystkie sk�adki ZUS maj� by� naliczone:
					update tt_prace_zlecone z, Pracownicy k
					set 
						NaliczacZus = 1,PodlUbezpChorob = 1, PodlUbezpWypadk = 1, PodlUbezpZdrowot = 1, z.PracaStr = k.uwagi_dodatkowe
					where z.GUID = _Param_A and z.guid_pracownika = k.guid;
 					
					
					CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.skladki', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);
						
				-- dodac kwota_za_UW		
				SET _SQLText = 'SELECT
					(z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) AS KwotaBrutto,
					_Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2) AS KosztyUzyskania
					
					FROM tt_prace_zlecone z			
					WHERE	
						z.GUID = ''#_ZlecGUID#'' 
					INTO 
						@one.zlec.KwotaBrutto, @one.zlec.KosztyUzyskania ;
				';
				
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET @_SQLText_sel =  _SQLText;
				CALL _ExecuteCmd(_SQLText, @Error);	
				
				-- przeliczenie kwot innych potracen i innych dodatkow
				SET _SQLText = 'UPDATE tt_prace_zlecone z 
					SET
						z.InneDod = (select sum(kwota) from place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Dod#),	
						z.InnePotr = (select sum(kwota) from place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Potr#)	
					WHERE	
						z.GUID = ''#_ZlecGUID#'' ; 
				';
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Dod#', cInneDodatki);	
				SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Potr#', _ZLEC_Potr);	
				SET @_SQLText = _SQLText;		
				CALL _ExecuteCmd(_SQLText, @Error);	
				
				-- przeliczenie kwot na zleceniu
				SET _SQLText = 'UPDATE tt_prace_zlecone z
					SET
						z.KwotaBrutto     = (z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
						z.KosztyUzyskania = _Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
						z.Dochod          = _Rnd(
							(z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - 
							   _Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
										0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
						z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
						z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
						z.KwotaNetto = (z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
							_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
						z.DoWyplaty  = _Rnd((z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
							_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + kwota_za_UW + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie + kwota_za_UW - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
							- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2)						
					WHERE	
						z.GUID = ''#_ZlecGUID#'' ; ';
					-- przeniesione wyzej do oddzielnego zapytania: z.InnePotr = (select sum(kwota) from place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Potr#)		
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(TRUE, "zoo", "konkol_zoo"));	
				
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				-- SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Potr#', _ZLEC_Potr);			
				SET @_SQLText = _SQLText;		
				CALL _ExecuteCmd(_SQLText, @Error);	
				
				-- sposob wyplaty
				SET _SQLText = '
				update  tt_prace_zlecone z, Pracownicy k
				set
					z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
					z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
				where z.guid = ''#_ZlecGUID#'' and z.guid_pracownika = k.GUID;
				';
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET @_SQLText_wypl = _SQLText;		
				CALL _ExecuteCmd(_SQLText, @Error);	
				
			IF _Param_F = 'auto' THEN          -- naliczanie automatyczne, czyli z calla => wstawiamy wartosci do tabeli	
			  
			  -- sprawdzamy, czy jest juz zamkniete zlecenie o takim GUIDzie
			  SET _I = 0;
			  select COUNT(*) from prace_zlecone where guid = _Param_A and ZamknietyZapis = 1
			  into _I;
			  
			  IF (_I = 0) THEN  -- jesli nie ma zaknietego zlecenia, to wstawiamy/nadpisujemy
				
				REPLACE INTO 
					prace_zlecone 
				SELECT *				   
				FROM tt_prace_zlecone 
				WHERE  GUID = _Param_A;					
				
				REPLACE INTO 
					place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				SELECT 
					GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika
				FROM 
					tt_zlec_skladniki 
				WHERE  GUID_zapisu_placowego = _Param_A;					
				
			  END IF;	
					
			  
			-- koniec    naliczania automatycznego ( czyli z calla)
			ELSE  -- _Param_F = 'manual' tryb r�czny (wywolanie z aplikacji) - warto�ci trzeba przekaza� jako select
				-- select 	ZaZlecenie .....  <- w Delphi b�dzie aDS := ConnectSuport.GetNavQuery
				
				select 
					_SG AS StGodz, _GrafikCzasPracy AS PracaZ, _godzSNS AS godzSNS, _GodzNocne AS GodzNoc, _ProcPremii AS ProcPremii, _NCP AS NCP,
					ZaZlecenie, _DodNocny AS DodNocny, (ZaZlecenie - _DodNocny) AS Podst, DataWyplaty, DataOd, DataDo, _godzW, _kwotaW,
					aPlaca, aNadGodz150, aNadGodz200, aPremia, aPremiaMotyw, aPremiaUzn, aNoc, aNoc_yy					
					from tt_prace_zlecone where GUID_pracownika = _Param_D;
		
			END IF;	-- trybu r�cznego
		ELSE	 -- (gdy kwota ZaZlecenie = 0)  :
			select 
			  _SG AS StGodz, _GrafikCzasPracy AS PracaZ, _godzSNS AS godzSNS, _GodzNocne AS GodzNoc, _ProcPremii AS ProcPremii, _NCP AS NCP,
			  0 AS ZaZlecenie, _DodNocny AS DodNocny, 0 AS Podst, _varDateTime(@konkol_zoo.DataWypl) AS DataWyplaty, _godzW, _kwotaW,	
			  aPlaca, aNadGodz150, aNadGodz200, aPremia, aPremiaMotyw, aPremiaUzn, aNoc, aNoc_yy,					
			  _varDateTime(@konkol_zoo.DataOd) AS DataOd, _varDateTime(@konkol_zoo.Datado) AS DataDo;
		END IF;  -- IF @pl.gratyf.za_zlecenie > 0
	

	
	END IF;  -- IF _MODE = 'calc.one.order.mode.jarz.extra' THEN
	
	
	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.auto.multi.order.mode.konkol_ht'
		Zalozenie tabel tymczasowych, wlasciwe naliczenie zlecenia, zwrocenie warto�ci jako SELECT
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu (dla trybu "ht" nieu�ywane)
		_Param_F   -- tryb: zawsze "auto" (naliczanie automat.) (tryb "manual" wyst�puje dla "one.order.mode")
				
		CALL pl_gratyfikacje_tools_arg7('calc.auto.multi.order.mode.konkol_ht', '', '2012', '9', '', '', 'auto');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.auto.multi.order.mode.konkol_ht' THEN
	    set @co = 'start';
		-- 1) zakladamy tabele tymcz. (kopie tabel prace_zlecone i place_skladniki)
		CALL pl_gratyfikacje_tools_arg7('create.work.tables', '', '', '', '', '', '');
		
		DROP TEMPORARY TABLE IF EXISTS `tt_hr_frekw`;
		CREATE TEMPORARY TABLE  `tt_hr_frekw` AS
		SELECT  DISTINCT k.guid AS hrGUID, f.guid AS FrekwGUID   --    s.symbol, s.nazwa,
		FROM Pracownicy k 
		JOIN osoby o ON o.guid = k.guid
		JOIN frekw f ON f.pracguid = k.guid AND f.rok = _Param_B and f.miesiac = _Param_C and f.deleted = 0
				WHERE -- d.osobaguid = _GUID   
					-- g.DayWork BETWEEN '2012-05-01' AND '2012-05-31'
					-- year(g.DayWork) = _Param_B and month(g.DayWork) = _Param_C
					-- AND g.areaguid NOT IN (SELECT z.areaguid FROM prace_zlecone z WHERE z.GUID_pracownika = d.osobaguid  
				-- AND z.rok = _Param_B AND z.miesiac = _Param_C and z.deleted = 0)
				-- and exists (select guid from frekw f where  f.rok = _Param_B and f.miesiac = _Param_C and f.pracguid = d.osobaguid AND f.deleted=0)
				o.ToZleceniobiorca = 1 AND o.ToPracownik = 0;    
		
		
		BEGIN
			DECLARE _frekw_c CURSOR FOR	
			SELECT  
				hrGUID, FrekwGUID	
			FROM tt_hr_frekw;
			
			DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;		
			
			SET _CurrFrekwGUID = ''; SET _CurrWorkerGUID = '';  SET _OrderGUID = '';
			
			SET _done = FALSE;			
			SET @IleZlec = 0;
			
			OPEN _frekw_c;
			loopF: LOOP
				FETCH _frekw_c INTO 
					_CurrWorkerGUID, _CurrFrekwGUID;  -- Prac.guid, frekw.guid
				IF _done THEN
						-- set @co = 'spadamy';
						LEAVE loopF;
				ELSE
				    -- spr. czy dla tej osoby nie ma juz recznie wprowadzonego zlecenia - jesli tak, to pomijamy
					SET _I = 0;
				    select 
						count(*) as ile 
					from 
						prace_zlecone g
					where 
						g.rok = _Param_B and g.miesiac = _Param_C and g.deleted = 0 and g.GUID_pracownika = _CurrWorkerGUID
					into
						_I;					
					
					IF (_I = 0) THEN
						  SET @IleZlec = @IleZlec + 1;
						  SET _OrderGUID = md5(concat(_CurrFrekwGUID, _CurrWorkerGUID, _Param_B, _Param_C));	
						  -- set @_OrderGUID = concat(@_OrderGUID, ',', _OrderGUID);
						  -- 2) naliczamy
						  CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.konkol_ht', _OrderGUID, _Param_B, _Param_C, _CurrWorkerGUID, _CurrFrekwGUID, 'auto');				
					END IF;		
					
				END IF;	
			
			END LOOP;
			CLOSE _frekw_c;
			
			-- uzupelnienie tresci zlecenia we wszystkich wygenerowanych zleceniach
			SET _SymbZakr = ''; SET _RangeGUID = '';
			CALL _IReg_Get('Place2003\\Parametry_kartoteki_zlecen', 'Symbol_zakresu_prac_zlec', 0, 'STRING', _SymbZakr, '');
			-- (aRok, 'Proc_zdr_odliczone_zlecbiorcy', 0.00, 'Place2003\Parametry_kartoteki_zlecen', 1);
			
			select GUID from prace_zlec_opisy where symbol = trim(_SymbZakr)
			into _RangeGUID;
			
		/*	update prace_zlecone z, tt_area_order s, prace_zlec_opisy o
			set z.PracaStr = o.opis
			where z.guid = s.orderGUID and o.guid = _RangeGUID;  */
			
		END; 	
		
	END IF;	

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.auto.multi.order.mode.konkol_zoo'
		Zalozenie tabel tymczasowych, wlasciwe naliczenie zlecenia, zwrocenie warto�ci jako SELECT
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools_arg7('calc.auto.multi.order.mode.konkol_zoo', 'ZlecGUID', '2012', '5', 'Prac1', 'SklepGUID', 'manual');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.auto.multi.order.mode.konkol_zoo' THEN
	    set @co = 'start';
		-- 1) zakladamy tabele tymcz. (kopie tabel prace_zlecone i place_skladniki)
		CALL pl_gratyfikacje_tools_arg7('create.work.tables', '', '', '', '', '', '');
		
		DROP TEMPORARY TABLE IF EXISTS `tt_area_order`;
		CREATE TEMPORARY TABLE  `tt_area_order` AS
		SELECT  DISTINCT g.areaguid, k.guid AS WorkerGuid, md5(concat(g.areaguid, k.guid, _Param_B, _Param_C)) AS orderGUID   --    s.symbol, s.nazwa,
		FROM hr_team_ng g
		JOIN erp_area_nodes s ON g.areaGUID = s.guid AND s.deleted = 0
		JOIN hr_team_po d ON d.GUIDNg = g.guid
		JOIN Pracownicy k ON k.guid = d.osobaguid
		JOIN osoby o ON o.guid = d.osobaguid
				WHERE -- d.osobaguid = _GUID   
					-- g.DayWork BETWEEN '2012-05-01' AND '2012-05-31'
					year(g.DayWork) = _Param_B and month(g.DayWork) = _Param_C
					AND g.areaguid NOT IN (SELECT z.areaguid FROM prace_zlecone z WHERE z.GUID_pracownika = d.osobaguid  
				AND z.rok = _Param_B AND z.miesiac = _Param_C and z.deleted = 0)
				and exists (select guid from frekw f where  f.rok = _Param_B and f.miesiac = _Param_C and f.pracguid = d.osobaguid AND f.deleted=0)
				AND o.ToZleceniobiorca = 1 AND o.ToPracownik = 0;    
		
		BEGIN
			DECLARE _work_c CURSOR FOR	
			SELECT  
				AreaGuid, WorkerGuid, orderGUID	
			FROM tt_area_order;
			
			DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;					
			
			-- pobieramy dane (zestaw zleceniobiorca-sklep)
			SET _CurrAreaGUID = ''; SET _CurrWorkerGUID = ''; SET _OrderGUID = '';
			
			SET _done = FALSE;			
			SET @IleZlec = 0;
			set @_OrderGUID = '';
			
			OPEN _work_c;
			loopW: LOOP
				FETCH _work_c INTO 
						_CurrAreaGUID, _CurrWorkerGUID, _OrderGUID;
				IF _done THEN
						-- set @co = 'spadamy';
						LEAVE loopW;
				ELSE
				  SET @IleZlec = @IleZlec + 1;
				  -- SET _OrderGUID = md5(concat(_CurrAreaGUID, _CurrWorkerGUID, _Param_B, _Param_C));	
				  set @_OrderGUID = concat(@_OrderGUID, ',', _OrderGUID);
				  -- 2) naliczamy
				  CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.konkol_zoo', _OrderGUID, _Param_B, _Param_C, _CurrWorkerGUID, _CurrAreaGUID, 'auto');				
					
				END IF;	
			
			END LOOP;
			CLOSE _work_c;
			
			
			-- uzupelnienie tresci zlecenia we wszystkich wygenerowanych zleceniach
			SET _SymbZakr = ''; SET _RangeGUID = '';
			CALL _IReg_Get('Place2003\\Parametry_kartoteki_zlecen', 'Symbol_zakresu_prac_zlec', 0, 'STRING', _SymbZakr, '');
			-- (aRok, 'Proc_zdr_odliczone_zlecbiorcy', 0.00, 'Place2003\Parametry_kartoteki_zlecen', 1);
			
			select GUID from prace_zlec_opisy where symbol = trim(_SymbZakr)
			into _RangeGUID;
			
			update prace_zlecone z, tt_area_order s, prace_zlec_opisy o
			set z.PracaStr = o.opis
			where z.guid = s.orderGUID and o.guid = _RangeGUID;
			
		END;
		
    	-- tymczasowo CALL pl_gratyfikacje_tools_arg7('drop.work.tables', '', '', '', '', '', ''); 
		
	END IF;	
	
	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.manual.one.order.mode.konkol_zoo'
		Zalozenie tabel tymczasowych, wlasciwe naliczenie zlecenia, zwrocenie warto�ci jako SELECT
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools_arg7('calc.manual.one.order.mode.konkol_zoo', 'ZlecGUID', '2012', '5', 'Prac1', 'SklepGUID', 'manual');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.manual.one.order.mode.konkol_zoo' THEN
	
		-- 1) zakladamy tabele tymcz.
		CALL pl_gratyfikacje_tools_arg7('create.work.tables', '', '', '', '', '', '');
		
		-- 2) naliczamy
		CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.konkol_zoo', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, 'manual');
		
 	    -- 3) zwracamy wyliczone warto�ci
	    -- select ZaZlecenie from tt_prace_zlecone;
		
    	-- CALL pl_gratyfikacje_tools('drop.work.tables', '', '', '', '', '', ''); <- to wywola� z Delphi po naliczeniu
		
	END IF;	
	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'create.work.tables'
		Za�o�enie tabel tymczasowych 
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools('create.work.tables', '', '', '', '', '', '');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'create.work.tables' THEN
	
		DROP TEMPORARY TABLE IF EXISTS `tt_prace_zlecone`;
		CREATE TEMPORARY TABLE  `tt_prace_zlecone` LIKE `prace_zlecone`;

		DROP TEMPORARY TABLE IF EXISTS `tt_zlec_skladniki`;
		CREATE TEMPORARY TABLE  `tt_zlec_skladniki` LIKE `place_skladniki`;
		
	END IF;

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'drop.work.tables'
		Za�o�enie tabel tymczasowych 
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools('drop.work.tables', '', '', '', '', '', '');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'drop.work.tables' THEN
	
		DROP TEMPORARY TABLE IF EXISTS `tt_prace_zlecone`;
		-- CREATE TEMPORARY TABLE  `tt_prace_zlecone` LIKE `prace_zlecone`;

		DROP TEMPORARY TABLE IF EXISTS `tt_zlec_skladniki`;
		-- CREATE TEMPORARY TABLE  `tt_zlec_skladniki` LIKE `place_skladniki`;
		
		DROP TEMPORARY TABLE IF EXISTS `tt_area_order`;
		
	END IF;

	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.one.order.mode.konkol_ht'
		Naliczenie  jednego zlecenia (metoda standardowa czyli "wg ht")
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	GUID karty frekwencji za dany miesiac
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.konkol_ht', 'ZlecGUID', '2012', '5', 'Prac1', 'FrekwGUID', 'manual');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.one.order.mode.konkol_ht' THEN
		SET _ZaZlecenie = 0; SET _DodNocny = 0;  
		SET _ProcPremii = 0; SET _SG  = 0; SET _GratyfPodst = 0;		
		SET _RozliczajWg = 0;  SET _CzasZ = 0;
		-- zmienne skopiowane z Delphi (tryb "ht")
		SET aPlaca = 0; SET aNadGodz150 = 0; SET aNadGodz200 = 0;  SET aPremia = 0; SET aPremiaMotyw = 0; SET aPremiaUzn = 0;
		SET _godz_noc = 0; SET _godz_yy  = 0;
		
		SELECT 	k.stawkaGodzinowa, k.ZeSG
		FROM  Pracownicy k 
		WHERE k.guid = _Param_D			
		INTO _SG, _RozliczajWg; 
		
		SET @Zlecb = _Param_D;
		
		IF _RozliczajWg = 0 THEN  -- wer. rozszerz.
		    SET _CzasZ = 0;  SET _godzSNS_nast = 0; SET _godzSNS = 0;
			
			SELECT n.godz100prac/60,  SUM(d.godziny150)/60, n.godz_plus100wolne/60, GREATEST(SUM(d.godziny_zz - d.godziny)/60, 0),  n.godzSNS/60,
				 _RndTIME('MIN', 60*SUM(d.noc), 30, '', ''), _RndTIME('MIN', 60*SUM(d.godziny_yy), 30, '', '') 
			FROM frekw n, frekw_po d 
			WHERE d.FrekwGUID  = n.GUID AND	n.GUID  = _Param_E and n.deleted = 0
			INTO _godz100prac,  _godziny150, _godz_plus100wolne, _godziny_premia, _godzSNS, _godz_noc, _godz_yy ;
			
			SELECT godzSNS_nast/60
			FROM frekw 
			WHERE (PracGUID  = _Param_D) AND ((12 * rok + miesiac) = (12 * _Param_B + _Param_C - 1))  and deleted = 0
			INTO _godzSNS_nast;
			
			SET aPlaca = _Rnd2(_godz100prac * _SG * 1.0); 
			
			SET aNadGodz150 = _Rnd2(_godziny150 * _SG * 1.5); 
			SET aNadGodz200 = _Rnd2(_godz_plus100wolne * _SG * 2.0);   
			SET aPremia = _Rnd2(_godziny_premia * _SG * 1.0); 
			SET aPremiaMotyw = _Rnd2( (_godzSNS + _godzSNS_nast)  * _SG * 0.5); 
			SET aPremiaUzn = _Rnd2((aPlaca + aPremia + aPremiaMotyw) * 0.3);  -- (0.3 = aProcUzn/100)
			
			
			-- shlEPlace.PobranieZDBPlacyZGodzinINadGodzinKonkol
	
			-- aNoc := shlEPlace.NaliczDodatekZaNocKonkol('noc')   dodatek za prac� w nocy
	
			-- aNoc_yy := shlEPlace.NaliczDodatekZaNocKonkol('godziny_yy')	   dodatek za prac� w nocy (YY).   
			-- SELECT _RndTIME('MIN', 60*46, 30, '', '');
			
			SET _NomCzasPracyREG = 0;
			/*
			IF _Param_C = 2 THEN
				SET _Def_NCP_REG = '160';
			ELSE
				SET _Def_NCP_REG = '168';
			END	IF; */
			SET _Def_NCP_REG = IF(_Param_C = 2, '160', '168');
			
			-- SET _NCP_REG_mc = REPLACE('NCP#mc#', '#mc#', _Param_C); -- REPLACE(_SQLText, '#PracGUID#', _PracGUID);
			
			
			CALL _IReg_Get('Place2003\\Parametry_ogolne', _NCP_REG_mc, _Param_B, 'FLOAT', _NomCzasPracyREG, _Def_NCP_REG);
			
			SET _MinWynagr = 0;
			CALL _IReg_Get('Place2003\\Progi_podatkowe_stawki_ZUS', 'Minimalne_wynagrodzenie', _Param_B, 'FLOAT', _MinWynagr, 0);
			SET aSGNoc = IF(_MinWynagr = 0.0, 0.0, _Rnd2((_MinWynagr/_NomCzasPracyREG)*0.2)   );
			
			-- _Rnd2(2*aSGNoc*aLGtmp); -- 20% za to ze siedzi po nocach
			
			SET aNoc = _Rnd2(2 * aSGNoc * _Rnd2(_godz_noc/60));
			SET aNoc_yy = _Rnd2(2 * aSGNoc * _Rnd2(_godz_yy/60));
			
			SET _ZaZlecenie = aPlaca + aNadGodz150 + aNadGodz200 + aPremia + aPremiaMotyw + aPremiaUzn + aNoc + aNoc_yy;
			
			-- F.w_godz/60 AS godzW  -- , SUM(D.godziny)/60 AS OCP 
			SET _dniW = 0; SET _godzW = 0;
			SELECT SUM(IF(D.absencja= 'W', 1, 0))  AS dniW, F.w_godz/60 AS godzW      
			FROM frekw F, frekw_po D        
				   WHERE D.FrekwGUID = F.GUID AND F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
			INTO
				_dniW, _godzW;		 -- , _OCP
				
			-- naliczenie urlopu wych.	
			SET _suma_mies = 0;
			SELECT IFNULL(SUM(ZaZlecenie), 0), COUNT(DISTINCT z.miesiac) AS suma_mies  
			FROM prace_zlecone z
			WHERE GUID <> _Param_A	-- Ten warunek w sumie niepotrzebny bo siegamy do poprzednich m-cy
			AND GUID_pracownika = _Param_D AND z.deleted = 0 AND  
				(12 * z.rok + z.miesiac) BETWEEN (12 * _Param_B + _Param_C - 13) AND (12 * _Param_B + _Param_C - 1)
			INTO _SUM_12m, _suma_mies;
			
			-- wynagr = (sum_12m/ocp)  * _godzW
			SET  _OCP = _suma_mies * 25.5;
			SET _kwotaW = (_SUM_12m / _OCP) * _dniW;
			
			IF _kwotaW > 0 THEN
				SET _ZaZlecenie = _ZaZlecenie + _kwotaW; -- _GratyfPodst = _GratyfPodst + _kwotaW;    -- _GratyfPodst ....
			END IF;
			-- koniec naliczenia urlopu
			
			
		ELSE  -- wer podst. (_RozliczajWg = 1)	
				    
			SELECT SUM(godziny_zz)/60
			FROM frekw_po WHERE FrekwGUID  = _Param_E
			INTO _CzasZ;
		
			SET _ZaZlecenie = _CzasZ * _SG;
		END IF;
	
		IF _ZaZlecenie > 0 THEN
		    SET  _ZaZlecenie = _Rnd(_ZaZlecenie, 2);
				
			
				   -- set @szambo = 'zazlecenie';
					-- SET @_ZlecGUID =  md5(concat(_Param_C, _Param_B, _Param_A));
				
					 SET @konkol_ht.DataOd = ifnull(concat(_Param_B,'-',_Param_C,'-01'), current_date);			
					 SET @konkol_ht.DataDo = ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
					 SET @konkol_ht.DataWypl = ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
					
					-- miejsce wykonywania pracy (za�o�enie o 3znakowej zgodno�ci symbolu)
					SET _MZ_idn = 0;
				--	SELECT m.idn FROM prace_zlec_miejsca m, erp_area_nodes e
				--	WHERE LOCATE(TRIM(e.symbol), m.symbol) > 0  AND m.uzywany = 1
				--	AND e.guid = _Param_E  AND e.symbol <> 'D' LIMIT 1
				--	INTO _MZ_idn;
					
					SET @_MZ_idn = _MZ_idn;

												
					-- wstawienie do place_zlec i do place_skladniki
					REPLACE INTO tt_prace_zlecone 
					(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, AreaGUID, DataWyplaty, MZ_Idn  -- , ZlecERP
					)   -- nazwisko,  @pl.gratyf.za_zlecenie
					VALUES(_Param_A, _Param_D, _Param_C, _Param_B, @konkol_ht.DataOd, @konkol_ht.DataDo, '', _ZaZlecenie, 7,   
					  (SELECT ValueN FROM IReg WHERE idkey = 'Procent_kosztow_um_zlec' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_odliczone_zlecbiorcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecdawcy' AND rok = _Param_B),  -- , ProcFwypadkowyZleceniod = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_pracod' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FP_zlecdawcy' AND rok = _Param_B),
					  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FGSP_zlecdawcy' AND rok = _Param_B), _Param_E, @konkol_ht.DataWypl, _MZ_idn  -- , 1
					);  -- 20, (SELECT nazwisko from osoby WHERE GUID = _Param_C),
				
													
					-- Z_1-Z_5(rodz.skl = 0) 
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_1')), 'Z_1', _Param_A, _ZaZlecenie, _ZaZlecenie , 0);  -- @pl.gratyf.za_zlecenie, @pl.gratyf.za_zlecenie
					set @jmam='z1';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_2')), 'Z_2', _Param_A, 0, 0, 0);
					set @jmam='z2';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_3')), 'Z_3', _Param_A, 0, 0, 0);
					set @jmam='z3';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_4')), 'Z_4', _Param_A, 0, 0, 0);
					set @jmam='z4';
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_5')), 'Z_5', _Param_A, 0, 0, 0);
					set @jmam='z5';
					-- Z_ZUS_1 - 9 (rodz.skl = 6)  _ZLEC_ZUS
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_1')), 'Z_ZUS_1', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_2')), 'Z_ZUS_2', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_3')), 'Z_ZUS_3', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_A, 'Z_ZUS_4')), 'Z_ZUS_4', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_5')), 'Z_ZUS_5', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_6')), 'Z_ZUS_6', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_7')), 'Z_ZUS_7', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_8')), 'Z_ZUS_8', _Param_A, 0, 0, _ZLEC_ZUS);
				
					REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
						VALUES(md5(concat(_Param_A, 'Z_ZUS_9')), 'Z_ZUS_9', _Param_A, 0, 0, _ZLEC_ZUS);
					set @pl.gratyf.debug = 'zus9';
									
					CALL pl_gratyfikacje_tools_arg7('pl.przepisz.dane.pracownika.one.zlec', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);					
					
					CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.skladki', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);
																					
				SET _SQLText = 'SELECT
					(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) AS KwotaBrutto,
					_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2) AS KosztyUzyskania
					
					FROM prace_zlecone z			
					WHERE	
						z.GUID = ''#_ZlecGUID#'' 
					INTO 
						@one.zlec.KwotaBrutto, @one.zlec.KosztyUzyskania ;
				';
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET @_SQLText_sel =  _SQLText;
				CALL _ExecuteCmd(_SQLText, @Error);	
				
				-- przeliczenie kwot
				SET _SQLText = 'UPDATE tt_prace_zlecone z
					SET
						z.KwotaBrutto     = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
						z.KosztyUzyskania = _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
						z.Dochod          = _Rnd(
							(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
										0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
						z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
						z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
						z.KwotaNetto = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
							_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
						z.DoWyplaty  = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
							_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
							_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
							- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2),
						z.InnePotr = (select sum(kwota) from place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Potr#)	
					WHERE	
						z.GUID = ''#_ZlecGUID#'' ; ';
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(TRUE, "zoo", "konkol_zoo"));	
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Potr#', _ZLEC_Potr);			
				SET @_SQLText = _SQLText;		
				CALL _ExecuteCmd(_SQLText, @Error);	
				
				-- sposob wyplaty
				SET _SQLText = '
				update  tt_prace_zlecone z, Pracownicy k
				set
					z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
					z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
				where z.guid = ''#_ZlecGUID#'' and z.guid_pracownika = k.GUID;
				';
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
				SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
				SET @_SQLText_wypl = _SQLText;		
				CALL _ExecuteCmd(_SQLText, @Error);	
			IF _Param_F = 'auto' THEN          -- naliczanie automatyczne, czyli z calla => wstawiamy wartosci do tabeli	
				
				REPLACE INTO prace_zlecone 
				/*	(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, 
					  KwotaBrutto, KosztyUzyskania, Dochod, ZaliczkaPrzedSklUbezp, Zaliczka, KwotaNetto, DoWyplaty, InnePotr,
					  WyplataPrzelewem, WyplataGotowka, AreaGUID, nazwisko, DataWyplaty, MZ_Idn,  -- , ZlecERP
					  NaliczacZus, PodlUbezpChorob, PodlUbezpWypadk, PodlUbezpZdrowot, naliczFGSP, naliczFP
					)   -- nazwisko,  @pl.gratyf.za_zlecenie  */
				SELECT * 
				    /*  GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, 
					  KwotaBrutto, KosztyUzyskania, Dochod, ZaliczkaPrzedSklUbezp, Zaliczka, KwotaNetto, DoWyplaty, InnePotr,
					  WyplataPrzelewem, WyplataGotowka, AreaGUID, nazwisko, DataWyplaty, MZ_Idn,
					  NaliczacZus, PodlUbezpChorob, PodlUbezpWypadk, PodlUbezpZdrowot, naliczFGSP, naliczFP					  */
				FROM tt_prace_zlecone 
				WHERE  GUID = _Param_A;					
				
				REPLACE INTO place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				SELECT GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika
				FROM tt_zlec_skladniki 
				WHERE  GUID_zapisu_placowego = _Param_A;					
					
			  
			  
			ELSE  -- _Param_F = 'manual' tryb r�czny (wywolanie z aplikacji) - warto�ci trzeba przekaza� jako select
				-- select 	ZaZlecenie .....  <- w Delphi b�dzie aDS := ConnectSuport.GetNavQuery
				
				select 
					_SG AS StGodz, _GrafikCzasPracy AS PracaZ, _godzSNS AS godzSNS, _GodzNocne AS GodzNoc, _ProcPremii AS ProcPremii, _NCP AS NCP,
					ZaZlecenie, _DodNocny AS DodNocny, (ZaZlecenie - _DodNocny) AS Podst, DataWyplaty, DataOd, DataDo, _godzW, _kwotaW,
					aPlaca, aNadGodz150, aNadGodz200, aPremia, aPremiaMotyw, aPremiaUzn, aNoc, aNoc_yy					
					from tt_prace_zlecone where GUID_pracownika = _Param_D;
		
			END IF;	-- trybu r�cznego
		ELSE	 -- (gdy kwota ZaZlecenie = 0)  :
			select 
			  _SG AS StGodz, _GrafikCzasPracy AS PracaZ, _godzSNS AS godzSNS, _GodzNocne AS GodzNoc, _ProcPremii AS ProcPremii, _NCP AS NCP,
			  0 AS ZaZlecenie, _DodNocny AS DodNocny, 0 AS Podst, _varDateTime(@konkol_zoo.DataWypl) AS DataWyplaty, _godzW, _kwotaW,	
			  aPlaca, aNadGodz150, aNadGodz200, aPremia, aPremiaMotyw, aPremiaUzn, aNoc, aNoc_yy,					
			  _varDateTime(@konkol_zoo.DataOd) AS DataOd, _varDateTime(@konkol_zoo.Datado) AS DataDo;
		END IF;  -- IF @pl.gratyf.za_zlecenie > 0
	

	
	END IF;  -- IF _MODE = 'calc.one.order.mode.konkol_ht' THEN
	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.one.order.mode.konkol_zoo'
		Naliczenie  jednego zlecenia (Nalicz_place_typu_konkol_zoo)
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	AreaGUID  = GUID sklepu;  gdy sklep = 'szkolenia' to niestandardowy algorytm naliczania (zadanie #43564)
		_Param_F   -- tryb: "auto" (naliczanie automat.) lub "manual" (r�czne - wolane z Delphi)
		
		CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.konkol_zoo', 'ZlecGUID', '2012', '5', 'Prac1', 'SklepGUID', 'manual');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	
	IF _MODE = 'calc.one.order.mode.konkol_zoo' THEN  
		SET _GrafikCzasPracy = 0;  SET _godzW = 0;
		SET _ZaZlecenie = 0; SET _DodNocny = 0;  
		SET _ProcPremii = 0; SET _SG  = 0; SET _GratyfPodst = 0;	
		
		SELECT  SUM(d.duration_min)/60 AS czas_pracy, MIN(g.DayWork), MAX(g.DayWork)    -- g.areaguid, g.daywork, s.symbol, s.nazwa, 
		FROM hr_team_ng g
		JOIN erp_area_nodes s ON g.areaGUID = s.guid
		JOIN hr_team_po d ON d.GUIDNg = g.guid
		WHERE d.osobaguid = _Param_D   
			AND g.areaguid = _Param_E
			AND YEAR(g.DayWork) = _Param_B  AND MONTH(g.DayWork) = _Param_C
		GROUP BY g.areaguid	
		INTO _GrafikCzasPracy, @konkol_zoo.DataOd, @konkol_zoo.Datado  ;  -- PracaZ - czas do przepracowania na danym sklepie, okre�lony w grafiku
				
		--  spr. czy _Param_E = db_globals.pl.AreaGUID.szkolenie, jesli tak, to oddzielne naliczenie kwoty 
		SELECT `value` AS szkolGUID FROM _db_globals WHERE `key` = 'pl.AreaGUID.szkolenie' INTO @szkolGUID;
		IF _Param_E = @szkolGUID THEN
		  /* 
		    naliczenie wynagrodzenia dla sklepu 'szkolenia': 
		     wynagrodzenie_za_prace_na_sklepie_SZKOLENIE = liczba_godzin_pracy_w_tym_sklepie x stawka_godzinowa_szkolenia_z_konfiguracji
		  */
		  SET @pl.debug = 'szkolenie';   -- ponizej: _Param_B = rok; ostatni arg. = default val.		  		   
		  CALL _IReg_Get('Place2003\\Parametry_kartoteki_plac', 'szkolenia_stawka_godz', 0, 'FLOAT', _SG, 0);    -- Parametry_kartoteki_zlecen
		  
		  SET _ZaZlecenie  =  _Rnd(_GrafikCzasPracy * _SG, 2);
		  
		ELSE  -- obsluga standardowa (dotychczasowa)
				
			SELECT h.premia/100  
			FROM erp_area_nodes h
			WHERE h.guid = _Param_E
			INTO _ProcPremii;	
			
			SET _RozliczajWg = 0;
			SELECT 	k.stawkaGodzinowa, k.ZeSG  -- "Naliczanie wynagrodzenia za umow� - zlecenie" : 0 = Metoda rozszerzona, 1 = Metoda prosta
			FROM  Pracownicy k 
			WHERE k.guid = _Param_D			
			INTO _SG, _RozliczajWg; 
			
			SET _OCP = 0;  SET _kwotaW = 0; SET _godzW = 0;
		
			SELECT 				
				SUM(IF(D.absencja= 'C', 1, 0)) AS dniC, SUM(IF(D.absencja= 'L', 1, 0)) AS dniL,
				SUM(D.kp_godziny)/60 AS NCPkal, SUM(IF(D.absencja IN (''), kp_godziny, 0))/60 AS NCPobl   --  NOT IN ('F', 'W')
			FROM 
				frekw F, frekw_po D 
			JOIN hr_team_ng g
			JOIN hr_team_po p ON p.GUIDNg = g.guid			
			WHERE D.FrekwGUID = F.GUID AND F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
					  AND p.osobaguid = F.PracGUID and g.areaguid = _Param_E
					  AND YEAR(g.DayWork) = F.rok  AND MONTH(g.DayWork) = F.miesiac AND D.rok_msc_dzien = g.DayWork
			INTO
				@zlec.dniC,  @zlec.dniL, @zlec.kalNCP,  @zlec.oblNCP;
			SET	_NCP = @zlec.kalNCP;
		
							
			-- SET _GratyfPodst = _Rnd((_GrafikCzasPracy + _godzW) * _SG, 2);	   -- skladnik_A
			SET _GratyfPodst = _Rnd(_GrafikCzasPracy * _SG, 2);
		
			IF _RozliczajWg = 0 THEN  -- Metoda rozszerzona:
									
				SELECT SUM(IF(D.absencja= 'W', kp_godziny, 0))/60 AS godzW, SUM(IF(D.absencja= 'W', 1, 0)) AS dniW		-- jeszcze okoliczn. (9 O) i op.zdr. dziecko (14 D)						 
				FROM frekw F, frekw_po D 
				JOIN hr_team_ng g
				JOIN hr_team_po p ON p.GUIDNg = g.guid			
				WHERE D.FrekwGUID = F.GUID AND F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
					  and p.osobaguid = F.PracGUID and g.areaguid = _Param_E
					  AND YEAR(g.DayWork) = F.rok  AND MONTH(g.DayWork) = F.miesiac AND D.rok_msc_dzien = g.DayWork
				INTO
					_godzW, _dniW;			 --  <- to zawiera urlop w dniach.  , _OCP
											
				IF _dniW > 0 THEN	
					SET _suma_mies = 0;
					SELECT IFNULL(SUM(ZaZlecenie), 0), COUNT(DISTINCT z.miesiac) AS suma_mies  
					FROM prace_zlecone z
					WHERE GUID <> _Param_A	-- Ten warunek w sumie niepotrzebny bo siegamy do poprzednich m-cy
					AND GUID_pracownika = _Param_D AND z.deleted = 0 AND  
						(12 * z.rok + z.miesiac) BETWEEN (12 * _Param_B + _Param_C - 13) AND (12 * _Param_B + _Param_C - 1)
					INTO _SUM_12m, _suma_mies;
														
					SET _OCP = _suma_mies * 25.5;
					
					-- wynagr = (sum_12m/ocp)  * _godzW
					-- Rnd2((aSUM12 / aOCP) * aDniW);
					-- SET _kwotaW = (_SUM_12m / _OCP) * _godzW;
					SET _kwotaW = (_SUM_12m / _OCP) * _dniW;
					
					SET @_kwotaW = _kwotaW; 
					SET @_dniW =  _dniW;
					
				END IF;  -- IF _dniW > 0 THEN	
			
				IF _kwotaW > 0 THEN
					SET _GratyfPodst = _GratyfPodst + _kwotaW;
				END IF;
				
				/* #43835 naliczenie wynagrodzenia za godziny SNS i godziny nocne przepracowane na danym sklepie (dane sa w `frekw_po_area`), 
					zamiast dotychczasowego ich rozliczenia doliczanego do najbardziej "zapracowanego" sklepu
				   				
				stare zapytanie: 
				SELECT 
					F.godzSNS/60 AS godzSNS, SUM(PO.kp_godziny)/60 as NCP, SUM(PO.noc + PO.godziny_yy)/60 as GodzNocne   -- yy - proteza dla AS
				 FROM frekw F
				   LEFT JOIN frekw_po PO ON PO.FrekwGUID = F.GUID 
				   WHERE F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
				INTO
					_godzSNS,  _NCP,  _GodzNocne;  _NCP mamy juz w @zlec.kalNCP */
				SELECT 
					-- F.godzSNS/60 AS godzSNS, SUM(PO.kp_godziny)/60 as NCP, SUM(PO.noc + PO.godziny_yy)/60 as GodzNocne   
					SUM(a.godzSNS)/60 AS godzSNS, SUM(a.GodzNocne)/60 AS GodzNocne
				 FROM frekw F 
				 LEFT JOIN frekw_po_area a ON a.FrekwGUID = F.GUID AND a.AreaGUID = _Param_E
				   WHERE F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
				INTO
					_godzSNS,  _GodzNocne;	
				
				SET _GratyfPodst = 	_GratyfPodst + _Rnd(0.5 * _SG * _godzSNS, 2);  -- skladnik_A
				SET @ZaSNS = _Rnd(0.5 * _SG * _godzSNS, 2);
				
				SET _MinWynagr = 0;
				CALL _IReg_Get('Place2003\\Progi_podatkowe_stawki_ZUS', 'Minimalne_wynagrodzenie', _Param_B, 'FLOAT', _MinWynagr, 0);  -- _Param_B = rok
				SET _DodNocny = _GodzNocne * _Rnd(0.2 * ( _MinWynagr / _NCP) , 2);
				SET _ZaZlecenie  =  _ZaZlecenie + _DodNocny;
				
			END IF;	-- IF _RozliczajWg = 0 THEN  -- (tj. metoda rozszerzona)
		
			SET @_GratyfPodst = _GratyfPodst;
			SET @_GrafikCzasPracy = _GrafikCzasPracy;
			SET @_SG = _SG;
			
			SET @_ZlecbGUID = _Param_D;
				
			-- czy to jest zlecenie dla sklepu, gdzie zlecb. pracowal najwieksza liczbe godzin?  <-- #43835 jest to juz nieaktualne, godz. SNS i nocne sa rejestrowane na poszczegolnych sklepach
		/*	SET _MaxAreaGUID = '';
		
			SELECT g.areaguid -- , sum(d.duration_min)
			FROM hr_team_ng g,  hr_team_po d
			WHERE d.osobaguid = _Param_D  
				AND g.guid = d.guidng 
				AND YEAR(g.DayWork) = _Param_B  AND MONTH(g.DayWork) = _Param_C
				AND  g.areaguid <> ''
			GROUP BY (g.areaguid)
			ORDER BY SUM(d.duration_min) DESC LIMIT 1
			INTO _MaxAreaGUID;
			
			SET _IsMaxArea = (_MaxAreaGUID = _Param_E);
			SET  @_MaxArea =  _IsMaxArea;
			SET  @_MaxAreaGUID =  _MaxAreaGUID;
		
			
			IF _IsMaxArea  AND (_RozliczajWg = 0) THEN
				-- jest to zlecenie dla najbardziej "zapracowanego" sklepu - pobieramy   godziny SNS i godziny nocne
				--  i doliczamy do wynagr.  <-- 43835 zostalo to przeniesione wczesniej (naliczanie w oparciu o tabele `frekw_po_area`)
			
				SELECT 
					F.godzSNS/60 AS godzSNS, SUM(PO.kp_godziny)/60 as NCP, SUM(PO.noc + PO.godziny_yy)/60 as GodzNocne   -- yy - proteza dla AS
				 FROM frekw F
				   LEFT JOIN frekw_po PO ON PO.FrekwGUID = F.GUID 
				   WHERE F.PracGUID = _Param_D and F.rok = _Param_B and F.miesiac = _Param_C  and F.deleted = 0
				INTO
					_godzSNS,  _NCP,  _GodzNocne;
				

				SET _GratyfPodst = 	_GratyfPodst + _Rnd(0.5 * _SG * _godzSNS, 2);  -- skladnik_A
				SET @ZaSNS = _Rnd(0.5 * _SG * _godzSNS, 2);
				
				SET _MinWynagr = 0;
				CALL _IReg_Get('Place2003\\Progi_podatkowe_stawki_ZUS', 'Minimalne_wynagrodzenie', _Param_B, 'FLOAT', _MinWynagr, 0);  -- _Param_B = rok
				SET _DodNocny = _GodzNocne * _Rnd(0.2 * ( _MinWynagr / _NCP) , 2);
				SET _ZaZlecenie  =  _ZaZlecenie + _DodNocny;
			
			END IF;  -- IF _IsMaxArea  AND (_RozliczajWg = 0) THEN    */	
		
			SET _ZaZlecenie  =  _ZaZlecenie + _GratyfPodst;
			SET @_ZaZlecenie_pre = _ZaZlecenie;
			IF (_RozliczajWg = 0) THEN
				CASE 
				  WHEN  (@zlec.dniC +  @zlec.dniL) > 5 THEN SET @zlec.premia = 0;
				  WHEN  (@zlec.dniC +  @zlec.dniL) BETWEEN 1 AND 5 THEN 
				  BEGIN
					 SET @zlec.premia = 
					  _Rnd2(@zlec.oblNCP * _SG * 0.5 * _ProcPremii) + 
					  _Rnd2(_godzSNS * _SG * 0.5 * _ProcPremii) +
					  _Rnd2((_GrafikCzasPracy - @zlec.oblNCP) * _SG * _ProcPremii);
					
				  END;
				  ELSE	SET @zlec.premia = _Rnd((_GratyfPodst - _kwotaW) * _ProcPremii, 2);			  
				END CASE;
						
				SET _ZaZlecenie  = _ZaZlecenie + @zlec.premia;    -- premia
			END IF;  -- IF (_RozliczajWg = 0) THEN
		
		END IF;  -- koniec IFa zamykajacego standardowe naliczanie (inne niz sklep `szkolenie`)
		
				
		SET @_ZaZlecenie = _ZaZlecenie;
		
		SET @konkol_zoo.DataWypl = ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
		
		SET @_DodNocny = _DodNocny;
		IF _ZaZlecenie > 0 THEN
		    SET  _ZaZlecenie = _Rnd(_ZaZlecenie, 2);
											   
					-- SET @_ZlecGUID =  md5(concat(_Param_C, _Param_B, _Param_A));
				
					-- SET @konkol_zoo.DataOd = ifnull(concat(_Param_B,'-',_Param_C,'-01'), current_date);			
					-- SET @konkol_zoo.DataDo = ifnull(last_day(concat(_Param_B,'-',_Param_C,'-01')), current_date);
					
			-- miejsce wykonywania pracy (za�o�enie o 3znakowej zgodno�ci symbolu)
			SET _MZ_idn = 0;
			SELECT m.idn FROM prace_zlec_miejsca m, erp_area_nodes e
			WHERE LOCATE(TRIM(e.symbol), m.symbol) > 0  AND m.uzywany = 1
			AND e.guid = _Param_E  AND e.symbol <> 'D' LIMIT 1
			INTO _MZ_idn;
			
			SET @_MZ_idn = _MZ_idn;

												
			-- wstawienie do place_zlec i do place_skladniki
			REPLACE INTO tt_prace_zlecone 
			(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
			  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
			  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
			  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
			  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, AreaGUID, DataWyplaty, MZ_Idn  -- , ZlecERP
			)   -- nazwisko,  @pl.gratyf.za_zlecenie
			VALUES(_Param_A, _Param_D, _Param_C, _Param_B, @konkol_zoo.DataOd, @konkol_zoo.DataDo, '', _ZaZlecenie, 7,   
			  (SELECT ValueN FROM IReg WHERE idkey = 'Procent_kosztow_um_zlec' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_odliczone_zlecbiorcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecdawcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecdawcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecdawcy' AND rok = _Param_B),  -- , ProcFwypadkowyZleceniod = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_pracod' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecdawcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FP_zlecdawcy' AND rok = _Param_B),
			  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FGSP_zlecdawcy' AND rok = _Param_B), _Param_E, @konkol_zoo.DataWypl, _MZ_idn  -- , 1
			);  -- 20, (SELECT nazwisko from osoby WHERE GUID = _Param_C),
				
													
			-- Z_1-Z_5(rodz.skl = 0) 
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_1')), 'Z_1', _Param_A, _ZaZlecenie, _ZaZlecenie , 0);  -- @pl.gratyf.za_zlecenie, @pl.gratyf.za_zlecenie
			set @jmam='z1';
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_2')), 'Z_2', _Param_A, 0, 0, 0);
			set @jmam='z2';
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_3')), 'Z_3', _Param_A, 0, 0, 0);
			set @jmam='z3';
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_4')), 'Z_4', _Param_A, 0, 0, 0);
			set @jmam='z4';
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_5')), 'Z_5', _Param_A, 0, 0, 0);
			set @jmam='z5';
			-- Z_ZUS_1 - 9 (rodz.skl = 6)  _ZLEC_ZUS
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_1')), 'Z_ZUS_1', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_2')), 'Z_ZUS_2', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_3')), 'Z_ZUS_3', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
			VALUES(md5(concat(_Param_A, 'Z_ZUS_4')), 'Z_ZUS_4', _Param_A, 0, 0, _ZLEC_ZUS);
				
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_5')), 'Z_ZUS_5', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_6')), 'Z_ZUS_6', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_7')), 'Z_ZUS_7', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_8')), 'Z_ZUS_8', _Param_A, 0, 0, _ZLEC_ZUS);
		
			REPLACE INTO tt_zlec_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_A, 'Z_ZUS_9')), 'Z_ZUS_9', _Param_A, 0, 0, _ZLEC_ZUS);
			set @pl.gratyf.debug = 'zus9';
							
			CALL pl_gratyfikacje_tools_arg7('pl.przepisz.dane.pracownika.one.zlec', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);					
			
			CALL pl_gratyfikacje_tools_arg7('calc.one.order.mode.skladki', _Param_A, _Param_B, _Param_C, _Param_D, _Param_E, _Param_F);
																					
			SET _SQLText = 'SELECT
				(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) AS KwotaBrutto,
				_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2) AS KosztyUzyskania
				
				FROM prace_zlecone z			
				WHERE	
					z.GUID = ''#_ZlecGUID#'' 
				INTO 
					@one.zlec.KwotaBrutto, @one.zlec.KosztyUzyskania ;
			';
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
			SET @_SQLText_sel =  _SQLText;
			CALL _ExecuteCmd(_SQLText, @Error);	
				
			-- przeliczenie kwot
			SET _SQLText = 'UPDATE tt_prace_zlecone z
				SET
					z.KwotaBrutto     = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
					z.KosztyUzyskania = _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
					z.Dochod          = _Rnd(
						(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
									0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
					z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
					z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.KwotaNetto = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.DoWyplaty  = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
						- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2),
					z.InnePotr = (select sum(kwota) from place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Potr#)	
				WHERE	
					z.GUID = ''#_ZlecGUID#'' ; ';
			
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(TRUE, "zoo", "konkol_zoo"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
			SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Potr#', _ZLEC_Potr);			
			SET @_SQLText = _SQLText;		
			CALL _ExecuteCmd(_SQLText, @Error);	
				
			-- sposob wyplaty
			SET _SQLText = '
			update  tt_prace_zlecone z, Pracownicy k
			set
				z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
				z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
			where z.guid = ''#_ZlecGUID#'' and z.guid_pracownika = k.GUID;
			';
			
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', _Param_A);			
			SET @_SQLText_wypl = _SQLText;		
			CALL _ExecuteCmd(_SQLText, @Error);	
				
			IF _Param_F = 'auto' THEN          -- naliczanie automatyczne, czyli z calla => wstawiamy wartosci do tabeli	
				
				REPLACE INTO prace_zlecone 
				/*	(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, 
					  KwotaBrutto, KosztyUzyskania, Dochod, ZaliczkaPrzedSklUbezp, Zaliczka, KwotaNetto, DoWyplaty, InnePotr,
					  WyplataPrzelewem, WyplataGotowka, AreaGUID, nazwisko, DataWyplaty, MZ_Idn,  -- , ZlecERP
					  NaliczacZus, PodlUbezpChorob, PodlUbezpWypadk, PodlUbezpZdrowot, naliczFGSP, naliczFP
					)   -- nazwisko,  @pl.gratyf.za_zlecenie  */
				SELECT *
					/*  GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  
					  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
					  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
					  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
					  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, 
					  KwotaBrutto, KosztyUzyskania, Dochod, ZaliczkaPrzedSklUbezp, Zaliczka, KwotaNetto, DoWyplaty, InnePotr,
					  WyplataPrzelewem, WyplataGotowka, AreaGUID, nazwisko, DataWyplaty, MZ_Idn,
					  NaliczacZus, PodlUbezpChorob, PodlUbezpWypadk, PodlUbezpZdrowot, naliczFGSP, naliczFP					  */
				FROM tt_prace_zlecone 
				WHERE  GUID = _Param_A;					
				
				REPLACE INTO place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				SELECT GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika
				FROM tt_zlec_skladniki 
				WHERE  GUID_zapisu_placowego = _Param_A;					
					
			  
			  -- przepisac do prace_zlec
			ELSE  -- _Param_F = 'manual' tryb r�czny (wywolanie z aplikacji) - warto�ci  przekazujemy jako select
				-- select 	ZaZlecenie .....  <- w Delphi: aDS := ConnectSuport.GetNavQuery
				
				SET @StGodzSNS = (0.5 * _SG);
				
				REPLACE INTO prace_zlecone_detal 
				  (zlecGUID, StGodz, CzasPracy, 
				   GodzSNS, StGodzSNS, GodzNoc, StGodzNoc, 
				   ProcPremii, NCP, 
				   ZaZlecenie, DodNocny, Podst, DataWyplaty, DataOd, DataDo, GodzW, KwotaW,
				   ObliczNCP,  DniC, DniL,  Premia)
				SELECT 
					GUID, _SG AS StGodz, _GrafikCzasPracy AS PracaZ, 
					_godzSNS AS godzSNS, (0.5 * _SG) AS StGodzSNS, _GodzNocne AS GodzNoc, _Rnd(0.2 * ( _MinWynagr / _NCP) , 2) AS StGodzNoc,
					_ProcPremii AS ProcPremii, _NCP AS NCP,  --  AS kalNCP
					ZaZlecenie, _DodNocny AS DodNocny, (ZaZlecenie - _DodNocny) AS Podst, DataWyplaty, DataOd, DataDo, _godzW, /* _dniW,*/ _kwotaW, 	
					@zlec.oblNCP AS oblNCP, @zlec.dniC AS dniC, @zlec.dniL AS dniL, _Rnd2(@zlec.premia) AS premia		
				FROM tt_prace_zlecone;
				
				SELECT 
					StGodz, CzasPracy AS PracaZ, GodzSNS, GodzNoc, ProcPremii, NCP, 
					ZaZlecenie, DodNocny, Podst, DataWyplaty, DataOd, DataDo, GodzW AS _godzW, KwotaW AS _kwotaW,
				    ObliczNCP AS oblNCP,  DniC, DniL,  Premia
				FROM	
					prace_zlecone_detal
				WHERE 
				    zlecGUID = _Param_A;		
		
			END IF;	-- trybu r�cznego
		ELSE	 -- gdy kwota ZaZlecenie = 0
			REPLACE INTO prace_zlecone_detal 
				  (zlecGUID, StGodz, CzasPracy, GodzSNS, StGodzSNS, GodzNoc, StGodzNoc, 
				   ProcPremii, NCP, 
				   ZaZlecenie, DodNocny, Podst, DataWyplaty, DataOd, DataDo, GodzW, KwotaW,
				   ObliczNCP,  DniC, DniL,  Premia)
			SELECT 
			  _Param_A, _SG AS StGodz, _GrafikCzasPracy AS PracaZ, _godzSNS AS godzSNS, (0.5 * _SG) AS StGodzSNS, _GodzNocne AS GodzNoc, _Rnd(0.2 * ( _MinWynagr / _NCP) , 2) AS StGodzNoc,
			  _ProcPremii AS ProcPremii, _NCP AS NCP,
			  0 AS ZaZlecenie, _DodNocny AS DodNocny, 0 AS Podst, _varDateTime(@konkol_zoo.DataWypl) AS DataWyplaty, 
			  _varDateTime(@konkol_zoo.DataOd) AS DataOd, _varDateTime(@konkol_zoo.Datado) AS DataDo, 
			  _godzW, /*_dniW,*/ _kwotaW,	
			  @zlec.oblNCP AS oblNCP, @zlec.dniC AS dniC, @zlec.dniL AS dniL,  0 AS premia
			;
			
			SELECT 
				StGodz, CzasPracy AS PracaZ, GodzSNS, GodzNoc, ProcPremii, NCP, 
				ZaZlecenie, DodNocny, Podst, DataWyplaty, DataOd, DataDo, GodzW AS _godzW, KwotaW AS _kwotaW,
				ObliczNCP AS oblNCP,  DniC, DniL,  Premia
			FROM	
				prace_zlecone_detal  -- #43565  tabelka z danymi do wydruku
			WHERE 
				zlecGUID = _Param_A
			;		
		END IF;  -- IF @pl.gratyf.za_zlecenie > 0
	END IF;	--	IF _MODE = 'calc.one.order.mode.konkol_zoo'


/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'calc.one.order.mode.skladki'
		Naliczenie skladek dla jednego zlecenia
		Parametry
		_Param_A	GUID zlecenia
		_Param_B	rok
		_Param_C	miesiac		
		_Param_D	GUID pracownika		
		_Param_E	nieuzywany
		_Param_F    nieuzywany
		
		CALL pl_gratyfikacje_tools('calc.one.order.mode.skladki', '2011', '', '', 'GUID_Zlec', '1');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	IF _MODE = 'calc.one.order.mode.skladki' THEN    
      -- @pl.gratyf.za_zlecenie	
	BEGIN
		-- DECLARE _Podstawa  DOUBLE;
		-- DECLARE _Dekl  	   DOUBLE;
		DECLARE _PodstE DOUBLE;
		DECLARE _PodstR DOUBLE;
		DECLARE _PodstW DOUBLE;
		DECLARE _PodstC DOUBLE;
		DECLARE _PodstF DOUBLE;
		
		-- DECLARE _SumaZ DOUBLE;
		-- DECLARE _SumaP DOUBLE;
		-- DECLARE _KwotaPoprz DOUBLE;
		-- DECLARE _SumaPodstCW DOUBLE;
		-- DECLARE _NaliczacZUS INTEGER;
		DECLARE _PodlUbezpZdrowot INTEGER; -- to jest niezalezne od "NaliczacZUS"
		
		CALL _IReg_Get('Place2003\\Progi_podatkowe_stawki_ZUS', 'Max_podstawa_ubezp_emeryt', _Param_B, 'FLOAT', @MaxPodstUbezpEm, 0);   -- Max_podstawa_ubezp_emeryt 0
							
		SET @pl.zlec.skladki_Podstawa = 0.0;
		SET @pl.zlec.skladki_PodstC = 0.0;
		SET @pl.zlec.skladki_PodstW = 0.0;
		SET @pl.zlec.skladki_PodstE = 0.0;
		SET @pl.zlec.skladki_PodstR = 0.0;
		
		SET @pl.zlec.skladki_NaliczacZUS = 0;
		SET @pl.zlec.skladki_PodlUbezpZdrowot = 0;
		SET @pl.zlec.skladki_Dekl = 0.0;
		
		
		
		-- dodanie + kwota_za_UW
		SET _SQLText = 
		'SELECT 
			IF(DeklarowanaPodstUbezpiecz>0, DeklarowanaPodstUbezpiecz, ZaZlecenie + kwota_za_UW) AS podst, 
			NaliczacZus, PodlUbezpZdrowot, DeklarowanaPodstUbezpiecz  
		FROM tt_prace_zlecone 
		WHERE 
			GUID = ''#_Param_A#''
		INTO @pl.zlec.skladki_Podstawa, @pl.zlec.skladki_NaliczacZUS, @pl.zlec.skladki_PodlUbezpZdrowot, @pl.zlec.skladki_Dekl
		;				'		;
		
		-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
		SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);			
		SET @_SQLText = _SQLText;		
		CALL _ExecuteCmd(_SQLText, @Error);
		
		
		
		IF (@pl.zlec.skladki_NaliczacZUS OR @pl.zlec.skladki_PodlUbezpZdrowot) THEN
		
			--	set @szambo = 'naliczamy ZUS';
			DROP TEMPORARY TABLE IF EXISTS `tt_skladki_place_do_zlec`;
			
			SET _SQLText =  
			'CREATE TEMPORARY TABLE `tt_skladki_place_do_zlec`
				SELECT ''#_Param_A#'' AS GUID,	
			  IFNULL(SUM(ZusFPprc), 0) as SUMZusFPprc, IFNULL(SUM(ZUSFEPPrc), 0) as ZUSFEPPrc, 
			  IFNULL(SUM(ZusFGprc), 0) as SUMZusFGprc, IFNULL(SUM(PodstFemerytalny), 0) as SUMPodstFemerytalny, 
			  IFNULL(SUM(PodstFrentowy), 0) as SUMPodstFrentowy,  
			  IFNULL(SUM(PodstFchorobowy), 0) as SUMPodstFchorobowy, 
			  IFNULL(SUM(PodstFwypadkowy), 0) as SUMPodstFwypadkowy, 
			  IFNULL(SUM(PodstKasaChorych), 0) as SUMPodstKasaChorych, 
			  IFNULL(SUM(SklFemerytalnyPracow), 0) as SUMSklFemerytalnyPracow, 
			  IFNULL(SUM(SklFrentowyPracow), 0) as SUMSklFrentowyPracow, 
			  IFNULL(SUM(SklFchorobowyPracow), 0) as SUMSklFchorobowyPracow, 
			  IFNULL(SUM(SklFwypadkowyPracow), 0) as SUMSklFwypadkowyPracow, 
			  IFNULL(SUM(SklKasaChorychPracowPobr), 0) as SUMSklKasaChorychPracowPobr, 
			  IFNULL(SUM(SklKasaChorOdlicz), 0) as SUMSklKasaChorOdlicz, 
			  IFNULL(SUM(SklFemerytalnyPracod), 0) as SUMSklFemerytalnyPracod, 
			  IFNULL(SUM(SklFrentowyPracod), 0) as SUMSklFrentowyPracod, 
			  IFNULL(SUM(SklFchorobowyPracod), 0) as SUMSklFchorobowyPracod, 
			  IFNULL(SUM(SklFwypadkowyPracod), 0) as SUMSklFwypadkowyPracod, 
			  IFNULL(SUM(SklKasaChorychPracod), 0) as SUMSklKasaChorychPracod, 
			  IFNULL(SUM(PodstDlaZUSFundPracy), 0) as SUMPodstDlaZUSFundPracy, 
			  IFNULL(SUM(PodstDlaZusFGSP), 0) as SUMPodstDlaZusFGSP, 
			  IFNULL(SUM(ZusFunduszPracy), 0) as SUMZusFunduszPracy, 
			  IFNULL(SUM(ZusFunduszGwarancyjny), 0) as SUMZusFunduszGwarancyjny, 
			  IFNULL(SUM(SkladkaFEP), 0) as SUMSkladkaFEP  
			  FROM place 
		
			  WHERE GUID_pracownika = ''#_Param_D#'' and Month(ifnull(DataWyplDoDeklar, datawyplaty)) = #_Param_C# 
			  AND deleted = 0 AND Year(ifnull(DataWyplDoDeklar, datawyplaty)) = #_Param_B#
			  AND KodTytUbezp = (SELECT KodTytUbezp FROM prace_zlecone WHERE GUID = ''#_Param_A#'') AND zapis_koryg_skl = 0
			;
			'
			;  -- qrPlaceSkladkiZaMiesiacDoZlecen
			
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
			SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
			SET _SQLText = REPLACE(_SQLText, '#_Param_B#', _Param_B);
			SET _SQLText = REPLACE(_SQLText, '#_Param_C#', _Param_C);
			SET _SQLText = REPLACE(_SQLText, '#_Param_D#', _Param_D);			
			SET @_SQLText = _SQLText;
			CALL _ExecuteCmd(_SQLText, @Error);
			
			-- set @szambo_place = _SQLText;
			-- set @szambo_place_error = @Error;
			set @db.pdz_sql = @_SQLText;
			set @db.pdz_err = @Error;
			
			DROP TEMPORARY TABLE IF EXISTS `tt_skladki_zlec_do_zlec`;
			
			SET _SQLText =  
			'CREATE TEMPORARY TABLE `tt_skladki_zlec_do_zlec`
				SELECT ''#_Param_A#'' AS GUID,	
			  IFNULL(SUM(PodstFemerytalny), 0) AS SumaPodstEmeryt, 
			  IFNULL(SUM(PodstFrentowy), 0) AS SumaPodstRent, IFNULL(SUM(PodstFchorobowy), 0) AS SumaPodstChorob, 
			  IFNULL(SUM(PodstFwypadkowy), 0) AS SumaPodstWypadk, IFNULL(SUM(PodstKasaChorych), 0) AS SumaPodstKCh, 
			  
			  IFNULL(SUM(SklFemerytalnyZleceniob), 0) AS SumaSklEmerytZB, IFNULL(SUM(SklFrentowyZleceniob), 0) AS SumaSklRentZB, 
			  IFNULL(SUM(SklFchorobowyZleceniob), 0) AS SumaSklChorobZB, IFNULL(SUM(SklFwypadkowyZleceniob), 0) AS SumaSklWypadkZB, 
			  IFNULL(SUM(SklKasaChorychZleceniobPobr), 0) AS SumaSklKChPobrZB, IFNULL(SUM(SklKasaChorychZleceniobOdlicz), 0) AS SumaSklKChOdlZB, 
			  IFNULL(SUM(RazemSkladkiZleceniobiorcy), 0) AS SumaSklRazemZB, 
			  
			  IFNULL(SUM(SklFemerytalnyZleceniod), 0) AS SumaSklEmerytZD, IFNULL(SUM(SklFrentowyZleceniod), 0) AS SumaSklRentZD, 
			  IFNULL(SUM(SklFchorobowyZleceniod), 0) AS SumaSklChorobZD, IFNULL(SUM(SklFwypadkowyZleceniod), 0) AS SumaSklWypadkZD, 
			  IFNULL(SUM(SklKasaChorychZleceniod), 0) AS SumaSklKChZD, IFNULL(SUM(RazemSkladkiZleceniodawcy), 0) AS SumaSklRazemZD, 
			
			  IFNULL(SUM(SklFundPracy), 0) AS SumaSklFundPracy, IFNULL(SUM(SklFGSP), 0) AS SumaSklFGSP, 
			  IFNULL(SUM(PodstFpFGSP), 0) AS SumaPodstFpFGSP 
			FROM prace_zlecone WHERE GUID_Pracownika = ''#_Param_D#'' AND datawyplaty >= @konkol_zoo.DataOd AND datawyplaty <= @konkol_zoo.DataDo 
			AND GUID <> ''#_Param_A#'' and KodTytUbezp =(SELECT KodTytUbezp FROM prace_zlecone WHERE GUID = ''#_Param_A#'') and deleted = 0  
			;
			'
			;
			
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
			SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
			SET _SQLText = REPLACE(_SQLText, '#_Param_B#', _Param_B);
			SET _SQLText = REPLACE(_SQLText, '#_Param_C#', _Param_C);
			SET _SQLText = REPLACE(_SQLText, '#_Param_D#', _Param_D);		
			SET @_SQLText = _SQLText;
			CALL _ExecuteCmd(_SQLText, @Error);
			
			-- set @szambo_zlec = _SQLText;
			-- set @szambo_zlec_error = @Error;
			
			set @db.zdz_sql = @_SQLText;
			set @db.zdz_err = @Error;
		
		
			IF @pl.zlec.skladki_NaliczacZUS THEN
				
				SET @pl.zlec.skladki_SumaZ = 0.0;
				
				SET _SQLText = 
				'SELECT 
					IFNULL(SUM(PodstFemerytalny), 0) AS suma 				
				FROM tt_prace_zlecone 
				WHERE GUID_Pracownika = ''#_Param_D#'' AND GUID <> ''#_Param_A#'' and deleted = 0 
					AND datawyplaty >= ''#_Param_B#-01-01'' AND datawyplaty <= LAST_DAY(''#_Param_B#-#_Param_C#-01'')
				INTO @pl.zlec.skladki_SumaZ;
				;		
				'
				;			
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
				SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
				SET _SQLText = REPLACE(_SQLText, '#_Param_B#', _Param_B);	
				SET _SQLText = REPLACE(_SQLText, '#_Param_C#', _Param_C);
				SET _SQLText = REPLACE(_SQLText, '#_Param_D#', _Param_D);	
				SET @_SQLText = _SQLText;
				CALL _ExecuteCmd(_SQLText, @Error);
				
				SET @pl.zlec.skladki_SumaP = 0.0;
				
				SET _SQLText = 
				'SELECT 
					IFNULL(SUM(PodstFemerytalny), 0) AS suma 				
				FROM place
				WHERE GUID_Pracownika = ''#_Param_D#'' AND GUID <> ''#_Param_A#'' and deleted = 0 
					AND datawyplaty >= ''#_Param_B#-01-01'' AND datawyplaty <= LAST_DAY(''#_Param_B#-#_Param_C#-01'')
				INTO @pl.zlec.skladki_SumaP
				;		
				'
				;			
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
				SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
				SET _SQLText = REPLACE(_SQLText, '#_Param_B#', _Param_B);	
				SET _SQLText = REPLACE(_SQLText, '#_Param_C#', _Param_C);
				SET _SQLText = REPLACE(_SQLText, '#_Param_D#', _Param_D);	
				SET @_SQLText = _SQLText;
				CALL _ExecuteCmd(_SQLText, @Error);
							
				IF @pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ + @pl.zlec.skladki_Podstawa > @MaxPodstUbezpEm  THEN
					SET @pl.zlec.skladki_PodstE = @MaxPodstUbezpEm - (@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ);
				ELSE
					SET @pl.zlec.skladki_PodstE = @pl.zlec.skladki_Podstawa;
				END IF; 
				
				SET @pl.zlec.skladki_PodstR = IF(@pl.zlec.skladki_Dekl > 0, @pl.zlec.skladki_Podstawa, @pl.zlec.skladki_PodstE);
				
				SET @pl.zlec.skladki_PodstW = _Rnd(@pl.zlec.skladki_Podstawa, 2);
				SET @pl.zlec.skladki_PodstC = _Rnd(@pl.zlec.skladki_Podstawa, 2);
				SET @pl.zlec.skladki_PodstF = _Rnd(@pl.zlec.skladki_Podstawa, 2);
			
				SET @pl.zlec.skladki_SumaPodstCW = 0;
				SELECT 
					(select ifnull(sum(z.podstfchorobowy), 0) from prace_zlecone z 
					where z.guid <> _Param_A and month(z.datawyplaty) = _Param_C and z.rok = _Param_B and z.deleted = 0 and z.guid_pracownika = _Param_D 
					) + 
					(select ifnull(sum(p.podstfchorobowy), 0) from place p 
					where p.rok = _Param_B and month(p.datawyplaty) = _Param_C and p.deleted = 0 and p.guid_pracownika = _Param_D
					) INTO @pl.zlec.skladki_SumaPodstCW; 
				
				SET @pl.zlec.skladki_KwotaPoprz = 0;
				select ifnull(KwotaDo3procZaktualnegoMsca, 0) from Pracownicy where GUID = _Param_D INTO @pl.zlec.skladki_KwotaPoprz;  -- bylo: KwotaZpoprzZaklDoSkl3proc
			
				CALL _IReg_Get('Place2003\\Progi_podatkowe_stawki_ZUS', 'Skladka_na_FP', _Param_B, 'FLOAT', @Zlec_Skladka_na_FP, 0);   -- Max_podstawa_ubezp_emeryt 0
			
				-- glowny update  (emeryt i rentowe naliczamy tylko gdy nie przekroczono max. podstawy ubezpieczenia)   SumaSklEmerytZB
				SET _SQLText =  
				'UPDATE tt_prace_zlecone Z
					SET
				
				Z.PodstUbSpolNarastAktualna = IF(NaliczacZus, @pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ, 0),
				Z.PodstFemerytalny 			= IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, @pl.zlec.skladki_PodstE, 0),
				Z.PodstFrentowy    			= IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, @pl.zlec.skladki_PodstR, 0)
				
				WHERE Z.GUID = 				''#_Param_A#''
				;'	;
											
				-- Z.PodstE_R					= IF(NaliczacZus, ZaZlecenie, 0),
				-- Z.PodstC_W					= IF(NaliczacZus, ZaZlecenie, 0),
				
				-- FieldByName('PodstUbSpolNarastAktualna').AsCurrency := aC; =>  PodstUbSpolNarastAktualna = _SumaP + _SumaZ
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
				SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
				SET @_SQLText = _SQLText;
				
				-- set @szambo = @_SQLText;
				
				CALL _ExecuteCmd(_SQLText, @Error);
				
				SET _SQLText =  				
				
				'UPDATE tt_prace_zlecone Z, tt_skladki_place_do_zlec tp, tt_skladki_zlec_do_zlec tz
					SET						
				Z.SklFemerytalnyZleceniob   = _Rnd(IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, 
				  (tp.SUMPodstFemerytalny  + tz.SumaPodstEmeryt + @pl.zlec.skladki_PodstE) *
				  Z.ProcFemerytalnyZleceniob/100 - (select tp.SUMSklFemerytalnyPracow  + tz.SumaSklEmerytZB), 	  0), 2),
				Z.SklFemerytalnyZleceniod	= _Rnd(IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, 
				 (tp.SUMPodstFemerytalny + tz.SumaPodstEmeryt + @pl.zlec.skladki_PodstE) *
				  Z.ProcFemerytalnyZleceniod/100 - (tp.SUMSklFemerytalnyPracod +  tz.SumaSklEmerytZD), 0), 2),
				Z.SklFrentowyZleceniob   	= _Rnd(IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, 
				  (tp.SUMPodstFrentowy + tz.SumaPodstRent + @pl.zlec.skladki_PodstR) *
				  Z.ProcFrentowyZleceniob/100 - (tp.SUMSklFrentowyPracow + tz.SumaSklRentZB),	  0), 2),
				Z.SklFrentowyZleceniod   	= _Rnd(IF(@pl.zlec.skladki_SumaP + @pl.zlec.skladki_SumaZ < @MaxPodstUbezpEm, 
				  (tp.SUMPodstFrentowy + tz.SumaPodstRent + @pl.zlec.skladki_PodstR) *
				  Z.ProcFrentowyZleceniod/100 - (tp.SUMSklFrentowyPracod +  tz.SumaSklRentZD), 	  0), 2),
				Z.PodstFwypadkowy           = _Rnd(IF(Z.PodlUbezpWypadk, @pl.zlec.skladki_PodstW, 0), 2),   
				Z.SklFwypadkowyZleceniod	= _Rnd(IF(Z.PodlUbezpWypadk, (tp.SUMPodstFwypadkowy + tz.SumaPodstWypadk + @pl.zlec.skladki_PodstW) *
				  Z.ProcFwypadkowyZleceniod/100 - (tp.SUMSklFwypadkowyPracod + tz.SumaSklWypadkZD), 0), 2), 
				Z.PodstFchorobowy           = _Rnd(IF(Z.PodlUbezpChorob, @pl.zlec.skladki_PodstC, 0), 2),   
				Z.SklFchorobowyZleceniob	= _Rnd(IF(Z.PodlUbezpChorob, (tp.SUMPodstFchorobowy + tz.SumaPodstChorob + @pl.zlec.skladki_PodstC) *
				  Z.ProcFchorobowyZleceniob/100 - (tp.SUMSklFchorobowyPracow + tz.SumaSklChorobZB), 0), 2), 
				Z.PodstFpFGSP				= _Rnd(IF(Z.NaliczFGSP OR Z.NaliczFP, @pl.zlec.skladki_PodstF, 0), 2),
				Z.SklFundPracy		        = _Rnd(IF(Z.NaliczFP AND (Z.ZaZlecenie + @pl.zlec.skladki_SumaPodstCW + @pl.zlec.skladki_KwotaPoprz > @Zlec_Skladka_na_FP), 
				  _Rnd(@pl.zlec.skladki_PodstF * ProcFPracy/100, 2), 0), 2),
				Z.SklFGSP				    = _Rnd(IF(Z.NaliczFGSP, _Rnd(@pl.zlec.skladki_PodstF * ProcFGSP/100, 2), 0), 2)
				WHERE Z.GUID = 				''#_Param_A#''
				;';
				
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
				SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
				SET @_SQLText = _SQLText;
				
				 -- set @szambo2 = @_SQLText;
				
				CALL _ExecuteCmd(_SQLText, @Error);
				
				-- set @szambo2error = @Error;
				
			END IF;		-- IF _NaliczacZUS THEN
			
			IF @pl.zlec.skladki_PodlUbezpZdrowot THEN   -- robimy jako oddzielne zapytanie, bo korzystamy tu z wyliczonych skladek na zapisie
			
				-- SELECT Z.ZaZlecenie - (Z.SklFemerytalnyZleceniob + Z.SklFrentowyZleceniob + Z.SklFchorobowyZleceniob) FROM 	
				-- PodstKasaChorych ( = aPodstZdrowot) := ZaZlecenie - (SklFemerytalnyZleceniob + SklFrentowyZleceniob + SklFchorobowyZleceniob)
				-- oddzielnie skladka pobrana, odzielnie skladka odliczona - ta sama podstawa, inny procent
				SET _SQLText =  
				'UPDATE tt_prace_zlecone Z, tt_skladki_place_do_zlec tp, tt_skladki_zlec_do_zlec tz
					SET
				Z.PodstKasaChorych 				= Z.ZaZlecenie + Z.kwota_za_UW  - (Z.SklFemerytalnyZleceniob + Z.SklFrentowyZleceniob + Z.SklFchorobowyZleceniob),
				Z.SklKasaChorychZleceniobPobr   = _Rnd( ((Z.ZaZlecenie + Z.kwota_za_UW  - (Z.SklFemerytalnyZleceniob + Z.SklFrentowyZleceniob + Z.SklFchorobowyZleceniob))+ 
				  (tz.SumaPodstKCh + tp.SUMPodstKasaChorych)) * ProcKasaChorychZleceniobPobr/100 -
				  ( tp.SUMSklKasaChorychPracowPobr + tz.SumaSklKChPobrZB ), 2), 
				Z.SklKasaChorychZleceniobOdlicz = _Rnd( ((Z.ZaZlecenie + Z.kwota_za_UW  - (Z.SklFemerytalnyZleceniob + Z.SklFrentowyZleceniob + Z.SklFchorobowyZleceniob))+ 
				  (tz.SumaPodstKCh + tp.SUMPodstKasaChorych)) * ProcKasaChorychZleceniobOdlicz/100 -
				  ( tp.SUMSklKasaChorOdlicz + tz.SumaSklKChOdlZB), 2) 			  
				WHERE Z.GUID = 				''#_Param_A#''  
				;
				'
				;
							
				-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
				SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
				SET @_SQLText = _SQLText;
				
				CALL _ExecuteCmd(_SQLText, @Error);
				
				set @db.zdr_sql = @_SQLText;
				set @db.zdr_err = @Error;
									
			END IF;		-- IF @pl.zlec.skladki_PodlUbezpZdrowot THEN
			
			--  zapamietujemy oryg.(nominalna) wartosc skladki oraz wyliczamy skladki lacznie (bez zdrowotnego)
			SET _SQLText =  
				'UPDATE tt_prace_zlecone Z
				 SET
					Z.SklKChZleceniobOdliczNomin = Z.SklKasaChorychZleceniobOdlicz,
					Z.SklKChZleceniobPobrNomin   = Z.SklKasaChorychZleceniobPobr,
					Z.RazemSkladkiZleceniobiorcy = Z.SklFemerytalnyZleceniob + Z.SklFrentowyZleceniob + Z.SklFchorobowyZleceniob,
					Z.RazemSkladkiZleceniodawcy  = Z.SklFemerytalnyZleceniod + Z.SklFrentowyZleceniod + Z.SklFwypadkowyZleceniod
				 WHERE Z.GUID = 	''#_Param_A#''  
				;
				'
				;		
			
			-- SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));
			SET _SQLText = REPLACE(_SQLText, '#_Param_A#', _Param_A);
			SET @_SQLText = _SQLText;
			CALL _ExecuteCmd(_SQLText, @Error);
			
			DROP TEMPORARY TABLE IF EXISTS `tt_skladki_place_do_zlec`;
			DROP TEMPORARY TABLE IF EXISTS `tt_skladki_zlec_do_zlec`;
		END IF; -- IF (@pl.zlec.skladki_NaliczacZUS OR @pl.zlec.skladki_PodlUbezpZdrowot) THEN
    END;	
	
	END IF;  --	IF _MODE = 'calc.one.order.mode.skladki'
	

/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'pl.przepisz.dane.pracownika.one.zlec'
		Przepisanie danych z karty pracownika do zlecenia  (dawne DBPlacesPlaceZlec.PrzepiszDanePrac)  <- wersja dla Security (obsluga 2 baz)
		Parametry
		_Param_A    GUID zlecenia
		_Param_B	Rok
		_Param_C	Miesiac
		_Param_D	GUID pracownika
		
		
		CALL pl_gratyfikacje_tools('pl.przepisz.dane.pracownika.one.zlec', 'Prac1');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	IF _MODE = 'pl.przepisz.dane.pracownika.one.zlec' THEN
		
		SET @sel_zakres_DataOd = ifnull(concat(_Param_B, '-', _Param_C, '-01'), current_date);		
		SET @sel_zakres_DataDo = ifnull(last_day(concat(_Param_B, '-', _Param_C, '-01')), current_date);
		
		
			UPDATE tt_prace_zlecone g, Pracownicy p, pracownicy_ZUS z, osoby o
			SET 
				g.nazwisko         = o.nazwisko,
				g.KodTytUbezp      = p.KodUbezpUmZlecenie,
				g.ProcentPodatku   = p.ProcPodOdZlecen,
				g.AnalitykaFK      = ifnull(p.AnalitykaFK, ''),
				g.Kategoria_Idn    = p.KategoriaPracownicza,
				g.naliczFGSP	   = p.naliczFGSP_zlec,
				g.naliczFP		   = p.naliczFP_zlec,	
				g.US_GUID		   = p.KluczUrzeduSkarbowego,
				g.calosc_przelewem = p.CzyCosPrzelewem,
				g.katcol0 		   = p.katcol0,
				g.katcol1 		   = p.katcol1,
				g.katcol2          = p.katcol2,
				g.NaliczacZus	   = IF(z.PodlEmerytalneUbzp OR z.Dobr_UbzpEmeryt OR z.PodlRentoweUbzp OR z.Dobr_UbzpRentowe, 1, 0) ,
				g.PodlUbezpChorob  = IF((z.PodlEmerytalneUbzp OR z.Dobr_UbzpEmeryt OR z.PodlRentoweUbzp OR z.Dobr_UbzpRentowe) AND z.PodlChorobUbzp, 1, 0),
				g.PodlUbezpWypadk  = IF((z.PodlEmerytalneUbzp OR z.Dobr_UbzpEmeryt OR z.PodlRentoweUbzp OR z.Dobr_UbzpRentowe) AND z.PodlWypadkUbzp, 1, 0),
				g.PodlUbezpZdrowot = IF((!ISNULL(z.DataPowstObowUbezpZdrow) OR z.Dobr_UbzpZdrowotne=1) AND z.ZgloszZUA_ZZA=1 AND ((z.KodKasyChorych <> '''') AND !ISNULL(z.KodKasyChorych)), 1, 0),				
				g.KluczWzoruPK     = ifnull(if((SELECT ValueB FROM IReg WHERE idkey = 'Inicjacja_wzoru_PK_zlecenia')=1, p.KluczWzoruPK_zlec, 0), 0) 			
				-- {$IFDEF KADRY_LISTA_UMOW_ZLECEN}  wl. dla Security - przepisz z akt. um.zlec
			WHERE g.GUID = _Param_A AND p.GUID = g.GUID_pracownika AND p.GUID = z.GUID_Pracownika AND o.GUID = p.GUID;
			
			
		
			
			-- to dopisa� do powy�szego update
		/*		UPDATE sec.prace_zlecone g, sel_umowa_zlecenie t
				SET 
				g.MZ_Idn = t.MZ_Idn,
				g.RodzajRyczaltu = t.RodzajRyczaltu,
				g.NrZlecenia = t.NrZlecenia,
				g.PracaStr = t.PracaStr,
				g.DataZawarcia = t.DataZawarcia,
				g.NaliczacZus = t.NaliczacZus,
				g.PodlUbezpChorob = t.PodlUbezpChorob,
				g.PodlUbezpWypadk = t.PodlUbezpWypadk,
				g.PodlUbezpZdrowot = t.PodlUbezpZdrowot		
				WHERE  g.GUID_pracownika = _Param_C and t.GUID_pracownika = g.GUID_pracownika;				
			*/
		
		
		-- else
		/* 'IF(Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe, 1, 0) AS ZlecNaliczacZus, '+
			'IF((Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe) AND Z.PodlChorobUbzp, 1, 0) AS PodlChorobUbzp,  '+
		 'IF((Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe) AND Z.PodlWypadkUbzp, 1, 0) AS PodlWypadkUbzp, '+
		 'IF((!ISNULL(Z.DataPowstObowUbezpZdrow) OR Z.Dobr_UbzpZdrowotne=1) AND Z.ZgloszZUA_ZZA=1 AND ((Z.KodKasyChorych <> '''') AND !ISNULL(Z.KodKasyChorych)), 1, 0) AS PodlUbezpZdrowot '+
		
		FieldByName('NaliczacZus').AsInteger :=
          aDS.FieldByName('ZlecNaliczacZus').AsInteger;
        FieldByName('PodlUbezpChorob').AsInteger := aDS.FieldByName('PodlChorobUbzp').AsInteger;
        FieldByName('PodlUbezpWypadk').AsInteger :=  aDS.FieldByName('PodlWypadkUbzp').AsInteger;
        FieldByName('PodlUbezpZdrowot').AsInteger :=  aDS.FieldByName('PodlUbezpZdrowot').AsInteger;
		*/
		
		
		
	END IF;	--	IF _MODE = 'pl.przepisz.dane.pracownika.one.zlec' 

/*--------------------------------- sekcja nalicze� dla Security --------------------------------------------------------------------------------*/		
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'pl.nalicz.z.kart.obiektow.one.zlec'
		Naliczanie z kart obiekt�w (Security) jednego zlecenia
		Parametry
		_Param_A	Rok
		_Param_B	Miesiac
		_Param_C	GUID pracownika
		_Param_D	tryb naliczania: 0 - wg kwoty z umowy o prac�, 1 - wg stawki godzinowej
		_Param_E	rozliczenie wg: 0)Sec�etat+MS�zlec; 1) Sec�zlec�201�+MS�zlec 2)MS�zlec�201�+Sec�zlec
		
		CALL pl_gratyfikacje_tools('pl.nalicz.z.kart.obiektow.one.zlec', '2011', '10', 'Prac1', '0', '0');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
	-- 0 P�aca zasadnicza
    -- 1 Stawka godz.
	IF _MODE = 'pl.nalicz.z.kart.obiektow.one.zlec' THEN
		    SET _ZaZlecenie = 0;
			IF  _Param_E in ('0', '3')   THEN  -- bylo: _Param_E = '0'   // , '4', '5'
				IF _Param_D = '1' THEN   --  Security: Zlecenie - nadwy�ka p�acy zas.      //       Wg stawki godz.
				-- OPEN _c_zlec_kp;
				-- FETCH _c_zlec_kp INTO _Za_zlecenie;
				SELECT 
						SUM(
						(godziny_etat * stawka_etat) + (godziny_zlec * stawka_zlec) + 
						(godziny_chorob * if(stawka_zlec > 0.0000, stawka_zlec, stawka_etat) * 0.8) + 
						(godziny_wypocz * if(stawka_zlec > 0.0000, stawka_zlec, stawka_etat)) + 
						-- (godziny_chorob * stawka_Z * 0.8) + (godziny_wypocz * stawka_Z) + 
						extra_wynagr
						-- (godziny_etat * stawka_etat) + 
						-- (godziny_zlec * stawka_zlec) + 
						-- (godziny_chorob * stawka_etat * 0.8) + 
						-- (godziny_wypocz * stawka_etat) + 
						-- extra_wynagr
						) - MAX(PlacaZasadnicza)                          -- 0 - sec.etat, 3 - ms.etat -> i z takiej bazy bra� pracownik.PlacaZasadnicza
					FROM `te_pl_wynagr_z_obiektow`
					WHERE GUID = _Param_C
					INTO _ZaZlecenie; -- @pl.gratyf.za_zlecenie;
				-- set @szambo = concat('zazlecenie =1 e=0: ', _ZaZlecenie);	
				END IF; -- _Param_D = '1'
			
				IF _Param_D = '0' THEN   -- Security:  Zlecenie - ca�o�� wynagrodz.      // Wg umowy o prace
					-- OPEN _c_zlec_sg;
					-- FETCH _c_zlec_sg INTO _Za_zlecenie;			  
					SELECT 
						SUM((godziny_zlec * stawka_zlec) + extra_wynagr)
					FROM `te_pl_wynagr_z_obiektow`
					WHERE GUID = _Param_C
					INTO _ZaZlecenie; -- @pl.gratyf.za_zlecenie;  -- @;
				END IF; -- _Param_D = '0'				
			ELSE 
				IF _Param_E in ('1', '2', '4', '5') THEN -- _Param_E = '1,2' (odejmujemy @Kwota_201); 4,5 - cale rozliczenie w jednej bazie
					SELECT 
						SUM(godziny_zlec * stawka_zlec) + SUM(godziny_etat * stawka_etat) + 
						SUM(extra_wynagr) - IF(_Param_E in ('1', '2'), @Kwota_201, 0)
					FROM `te_pl_wynagr_z_obiektow`
					WHERE GUID = _Param_C
					INTO _ZaZlecenie; -- @pl.gratyf.za_zlecenie;  -- @;
				-- ELSE
				  -- IF _Param_E in ('4', '5') THEN
				
				END IF;
			
			END IF; -- _Param_E = '0' 
			-- set @szambo = concat('zazlecenie: ', _ZaZlecenie);
			-- IF @pl.gratyf.za_zlecenie > 0 THEN
			IF _ZaZlecenie > 0 THEN
			    SET  _ZaZlecenie = _Rnd(_ZaZlecenie, 2);
				
			   -- set @szambo = 'zazlecenie';
				SET @_ZlecGUID =  md5(concat(_Param_C, _Param_B, _Param_A));
			
				SET @DataOd = ifnull(concat(_Param_A,'-',_Param_B,'-01'), current_date);			
				SET @DataDo = ifnull(last_day(concat(_Param_A,'-',_Param_B,'-01')), current_date);
			
			IF _Param_E in ('0', '1', '5') THEN -- UWAGA WSZYSTKIE ZMIANY WPROWADZAC SYMETRYCZNIE DLA OBU IFOW 
				-- wstawienie do place_zlec i do place_skladniki
				REPLACE INTO ms.prace_zlecone 
				(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
				  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
				  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
				  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod, ProcFwypadkowyZleceniod, -- ProcFwypadkowyZleceniod
				  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, ZlecERP
				)   -- nazwisko,  @pl.gratyf.za_zlecenie
				VALUES(@_ZlecGUID, _Param_C, _Param_B, _Param_A, @DataOd, @DataDo, '', _ZaZlecenie, 7,   
				  (SELECT ValueN FROM IReg WHERE idkey = 'Procent_kosztow_um_zlec' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_odliczone_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecdawcy' AND rok = _Param_A),  -- , ProcFwypadkowyZleceniod = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_pracod' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FP_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FGSP_zlecdawcy' AND rok = _Param_A), 1
				);  -- 20, (SELECT nazwisko from osoby WHERE GUID = _Param_C),
				/* 
					KosztyUzyskaniaWproc           = Procent_kosztow_um_zlec  Place2003\Progi_podatkowe_stawki_ZUS
					Place2003\Parametry_kartoteki_zlecen:
					ProcFemerytalnyZleceniob       = Proc_emeryt_zlecbiorcy
					ProcFrentowyZleceniob          = Proc_rent_zlecbiorcy
					ProcFchorobowyZleceniob        = Proc_chorob_zlecbiorcy
					ProcFwypadkowyZleceniob        = Proc_wypadk_zlecbiorcy
					ProcKasaChorychZleceniobPobr   = Proc_zdr_pobrane_zlecbiorcy
					ProcKasaChorychZleceniobOdlicz = Proc_zdr_odliczone_zlecbiorcy
					ProcFemerytalnyZleceniod       = Proc_emeryt_zlecdawcy
					ProcFrentowyZleceniod          = Proc_rent_zlecdawcy
					ProcFchorobowyZleceniod        = Proc_chorob_zlecdawcy
					ProcFwypadkowyZleceniod        = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
					ProcKasaChorychZleceniod       = Proc_zdr_pobrane_zlecdawcy
					ProcFPracy					   = ZUS_FP_zlecdawcy
					ProcFGSP					   = ZUS_FGSP_zlecdawcy
			    */
				
				
				
				-- Z_1-Z_5(rodz.skl = 0) 
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_1')), 'Z_1', @_ZlecGUID, _ZaZlecenie, _ZaZlecenie , 0);  -- @pl.gratyf.za_zlecenie, @pl.gratyf.za_zlecenie
				set @jmam='z1';
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_2')), 'Z_2', @_ZlecGUID, 0, 0, 0);
				set @jmam='z2';
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_3')), 'Z_3', @_ZlecGUID, 0, 0, 0);
				set @jmam='z3';
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_4')), 'Z_4', @_ZlecGUID, 0, 0, 0);
				set @jmam='z4';
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_5')), 'Z_5', @_ZlecGUID, 0, 0, 0);
				set @jmam='z5';
				-- Z_ZUS_1 - 9 (rodz.skl = 6)  _ZLEC_ZUS
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_1')), 'Z_ZUS_1', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_2')), 'Z_ZUS_2', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_3')), 'Z_ZUS_3', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_4')), 'Z_ZUS_4', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_5')), 'Z_ZUS_5', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_6')), 'Z_ZUS_6', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_7')), 'Z_ZUS_7', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_8')), 'Z_ZUS_8', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO ms.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_9')), 'Z_ZUS_9', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
				set @pl.gratyf.debug = 'zus9';
				
				/*
				-- skladka Hestia (potracenia)
				set _SklHestia = 0;
				select ifnull(SkladkaUbezp2, 0) as hestia from sec.Pracownicy where guid = _Param_C
				into _SklHestia;
				if _SklHestia > 0 then
				  REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					  VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Hestia')), 
					  (SELECT guid FROM sec.definicja_skladnika_placy WHERE nazwa='hestia' AND typ_gratyfikacji=1 AND deleted = 0 LIMIT 1), @_ZlecGUID, 
					  _SklHestia, _SklHestia, _ZLEC_Potr);
				end if;	 */
				
				-- stale potracenia	z karty pracownika							
				REPLACE INTO ms.place_skladniki
					(RodzajSkladnika, GUID_definicja_skladnika_placy, guid_zapisu_placowego, kwota, nomkwota, ZmniejszZwieksz)
				SELECT  
					_ZLEC_Potr, GUID_def_skl_placy, @_ZlecGUID, kwota, kwota, 0 
				FROM ms.prac_stale_skladniki p 
				JOIN ms.definicja_skladnika_placy d ON p.GUID_def_skl_placy = d.GUID AND d.typ_gratyfikacji = 1 AND d.deleted = 0 
				WHERE p.GUID_pracownika = _Param_C AND p.typ_skladnika = 0 
					AND ((p.rok_do > _Param_A) OR (p.rok_do = _Param_A AND p.msc_do > _Param_B)) ;
				
				
				CALL pl_gratyfikacje_tools('pl.przepisz.dane.pracownika.one.zlec', _Param_A, _Param_B, _Param_C, @_ZlecGUID, _Param_E);
				set @pl.gratyf.debug = 'po przepis.';				
			
				-- SET @_ZlecGUID =
				
				-- if naliczac zus  = 1 to update ms.prace_zlecone z WHERE	z.GUID = @_ZlecGUID;
				-- if PodlUbezpZdrowot (jest to niezalezne od NaliczacZus)  // pola PodlUbezpZdrowot i NaliczacZus wyznaczone przez pl.przepisz.dane.pracownika.one.zlec
				-- set @pl.gratyf.za_zlecenie = _ZaZlecenie
				-- call 
				-- set
				
				-- SKLADKI ZUS
				/*set @szambo = 'CALL pl_gratyfikacje_tools(''pl.nalicz.z.kart.obiektow.one.zlec.skladki'', #_Param_A#, #_Param_B#, #_Param_C#, #@_ZlecGUID#, #_Param_E#);';
				SET @szambo = REPLACE(@szambo, '#_Param_A#', _Param_A);
				SET @szambo = REPLACE(@szambo, '#_Param_B#', _Param_B);	
				SET @szambo = REPLACE(@szambo, '#_Param_C#', _Param_C);
				SET @szambo = REPLACE(@szambo, '#@_ZlecGUID#', @_ZlecGUID);
				SET @szambo = REPLACE(@szambo, '#_Param_E#', _Param_E);	*/
				CALL pl_gratyfikacje_tools('pl.nalicz.z.kart.obiektow.one.zlec.skladki', _Param_A, _Param_B, _Param_C, @_ZlecGUID, _Param_E);
				
			
				-- przeliczenie kwot
			/*	UPDATE  ms.prace_zlecone z
				SET
					z.KwotaBrutto     = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
					z.KosztyUzyskania = _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
					z.Dochod          = _Rnd(
						(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
								    0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
					z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
					z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.KwotaNetto = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.DoWyplaty  = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
						- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2),
					z.InnePotr = (select sum(kwota) from ms.place_skladniki s where s.guid_zapisu_placowego = @_ZlecGUID and s.RodzajSkladnika = _ZLEC_Potr)	
				WHERE	
					z.GUID = @_ZlecGUID;
													
				-- sposob wyplaty
				update  ms.prace_zlecone z, ms.Pracownicy k
				set
					z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
					z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
				where z.guid = @_zlecguid;
			*/	
			-- END;	
			ELSE  -- _Param_E in '2', '3', '4' 
			
				-- wstawienie do place_zlec i do place_skladniki
				REPLACE INTO sec.prace_zlecone 
				(GUID, GUID_pracownika,  miesiac, rok, DataOd, DataDo, NrZlecenia, ZaZlecenie, RodzajRyczaltu,  -- slon add DataOd
				  KosztyUzyskaniaWproc, ProcFemerytalnyZleceniob, ProcFrentowyZleceniob, ProcFchorobowyZleceniob,
				  ProcFwypadkowyZleceniob, ProcKasaChorychZleceniobPobr, ProcKasaChorychZleceniobOdlicz,
				  ProcFemerytalnyZleceniod, ProcFrentowyZleceniod, ProcFchorobowyZleceniod,  ProcFwypadkowyZleceniod,
				  ProcKasaChorychZleceniod, ProcFPracy, ProcFGSP, ZlecERP
				)   -- nazwisko,  @pl.gratyf.za_zlecenie
				VALUES(@_ZlecGUID, _Param_C, _Param_B, _Param_A, @DataOd, @DataDo, '', _ZaZlecenie, 7,   
				  (SELECT ValueN FROM IReg WHERE idkey = 'Procent_kosztow_um_zlec' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_odliczone_zlecbiorcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_emeryt_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_rent_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_chorob_zlecdawcy' AND rok = _Param_A),  
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_wypadk_pracod' AND rok = _Param_A),  -- , ProcFwypadkowyZleceniod = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
				  (SELECT ValueN FROM IReg WHERE idkey = 'Proc_zdr_pobrane_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FP_zlecdawcy' AND rok = _Param_A),
				  (SELECT ValueN FROM IReg WHERE idkey = 'ZUS_FGSP_zlecdawcy' AND rok = _Param_A), 1
				);  -- 20, (SELECT nazwisko from osoby WHERE GUID = _Param_C),
				/* 
					KosztyUzyskaniaWproc           = Procent_kosztow_um_zlec  Place2003\Progi_podatkowe_stawki_ZUS
					Place2003\Parametry_kartoteki_zlecen:
					ProcFemerytalnyZleceniob       = Proc_emeryt_zlecbiorcy
					ProcFrentowyZleceniob          = Proc_rent_zlecbiorcy
					ProcFchorobowyZleceniob        = Proc_chorob_zlecbiorcy
					ProcFwypadkowyZleceniob        = Proc_wypadk_zlecbiorcy
					ProcKasaChorychZleceniobPobr   = Proc_zdr_pobrane_zlecbiorcy
					ProcKasaChorychZleceniobOdlicz = Proc_zdr_odliczone_zlecbiorcy
					ProcFemerytalnyZleceniod       = Proc_emeryt_zlecdawcy
					ProcFrentowyZleceniod          = Proc_rent_zlecdawcy
					ProcFchorobowyZleceniod        = Proc_chorob_zlecdawcy
					ProcFwypadkowyZleceniod        = DBPlacesProc_wypadkowe.GetProcentWypadkowego(aDataWyplaty);
					ProcKasaChorychZleceniod       = Proc_zdr_pobrane_zlecdawcy
					ProcFPracy					   = ZUS_FP_zlecdawcy
					ProcFGSP					   = ZUS_FGSP_zlecdawcy
			    */
				
				
				
				-- Z_1-Z_5(rodz.skl = 0) 
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_1')), 'Z_1', @_ZlecGUID, _ZaZlecenie, _ZaZlecenie , 0);  -- @pl.gratyf.za_zlecenie, @pl.gratyf.za_zlecenie
				set @jmam='z1';
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_2')), 'Z_2', @_ZlecGUID, 0, 0, 0);
				set @jmam='z2';
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_3')), 'Z_3', @_ZlecGUID, 0, 0, 0);
				set @jmam='z3';
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_4')), 'Z_4', @_ZlecGUID, 0, 0, 0);
				set @jmam='z4';
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_5')), 'Z_5', @_ZlecGUID, 0, 0, 0);
				set @jmam='z5';
				-- Z_ZUS_1 - 9 (rodz.skl = 6)  _ZLEC_ZUS
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_1')), 'Z_ZUS_1', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_2')), 'Z_ZUS_2', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_3')), 'Z_ZUS_3', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
				VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_4')), 'Z_ZUS_4', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_5')), 'Z_ZUS_5', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_6')), 'Z_ZUS_6', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_7')), 'Z_ZUS_7', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_8')), 'Z_ZUS_8', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
			
				REPLACE INTO sec.place_skladniki (GUID, GUID_definicja_skladnika_placy, GUID_zapisu_placowego, kwota, nomkwota, RodzajSkladnika)
					VALUES(md5(concat(_Param_C, _Param_B, _Param_A, 'Z_ZUS_9')), 'Z_ZUS_9', @_ZlecGUID, 0, 0, _ZLEC_ZUS);
				set @pl.gratyf.debug = 'zus9';
				
								
				-- stale potracenia		z karty pracownika						
				REPLACE INTO sec.place_skladniki
					(RodzajSkladnika, GUID_definicja_skladnika_placy, guid_zapisu_placowego, kwota, nomkwota, ZmniejszZwieksz)
				SELECT  
					_ZLEC_Potr, GUID_def_skl_placy, @_ZlecGUID, kwota, kwota, 0 
				FROM sec.prac_stale_skladniki p 
				JOIN sec.definicja_skladnika_placy d ON p.GUID_def_skl_placy = d.GUID AND d.typ_gratyfikacji = 1 AND d.deleted = 0 
				WHERE p.GUID_pracownika = _Param_C AND p.typ_skladnika = 0 
					AND ((p.rok_do > _Param_A) OR (p.rok_do = _Param_A AND p.msc_do > _Param_B)) ;
				
				CALL pl_gratyfikacje_tools('pl.przepisz.dane.pracownika.one.zlec', _Param_A, _Param_B, _Param_C, @_ZlecGUID, _Param_E);
				set @pl.gratyf.debug = 'po przepis.';
				
				
				-- SKLADKI ZUS
				-- set @szambo = 'wywolanie wewn. 2 skladki';
				CALL pl_gratyfikacje_tools('pl.nalicz.z.kart.obiektow.one.zlec.skladki', _Param_A, _Param_B, _Param_C, @_ZlecGUID, _Param_E);
				
				
			
				-- SET @_ZlecGUID =
			
				-- if naliczac zus  = 1 to update ms.prace_zlecone z WHERE	z.GUID = @_ZlecGUID;
				-- if PodlUbezpZdrowot (jest to niezalezne od NaliczacZus)  // pola PodlUbezpZdrowot i NaliczacZus wyznaczone przez pl.przepisz.dane.pracownika.one.zlec
				
			
			/*
				-- przeliczenie kwot
				UPDATE  sec.prace_zlecone z
				SET
					z.KwotaBrutto     = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
					z.KosztyUzyskania = _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
					z.Dochod          = _Rnd(
						(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
								    0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
					z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
					z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.KwotaNetto = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.DoWyplaty  = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
						- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2),
					z.InnePotr = (select sum(kwota) from sec.place_skladniki s where s.guid_zapisu_placowego = @_ZlecGUID and s.RodzajSkladnika = _ZLEC_Potr)	
				WHERE	
				z.GUID = @_ZlecGUID;
								
			-- END;	
				
				-- sposob wyplaty
				update  sec.prace_zlecone z, sec.Pracownicy k
				set
					z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
					z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
				where z.guid = @_zlecguid;
			*/
			END IF; -- _Param_E in '2', '3', '4' (czyli baza = sec)
			
			SET _SQLText = 'SELECT
				(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) AS KwotaBrutto,
				_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2) AS KosztyUzyskania
				
				FROM #DB_ZLEC#.prace_zlecone z			
				WHERE	
					z.GUID = ''#_ZlecGUID#'' 
				INTO 
					@one.zlec.KwotaBrutto, @one.zlec.KosztyUzyskania ;
			';
			SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', @_ZlecGUID);			
			SET @_SQLText_sel =  _SQLText;
			CALL _ExecuteCmd(_SQLText, @Error);	
			
			-- przeliczenie kwot
			SET _SQLText = 'UPDATE 	#DB_ZLEC#.prace_zlecone z
				SET
					z.KwotaBrutto     = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy),
					z.KosztyUzyskania = _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2), 
					z.Dochod          = _Rnd(
						(z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab - z.RazemSkladkiZleceniobiorcy) - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2),
								    0),  -- regint.Zaokr_podstawy_zaliczki   dochod = KwotaBrutto - KosztyUzyskania
					z.ZaliczkaPrzedSklUbezp = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - _Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100),
					z.Zaliczka  = _Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.KwotaNetto = (z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0),
					z.DoWyplaty  = _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - (z.RazemSkladkiZleceniobiorcy + z.SklKasaChorychZleceniobPobr)  -
						_Rnd(GREATEST(0, _Rnd((z.ZaZlecenie + z.ZasChorRazem + z.ZasMacierz + z.ZasRehab) - z.RazemSkladkiZleceniobiorcy - 
						_Rnd((z.ZaZlecenie - z.RazemSkladkiZleceniobiorcy) * (KosztyUzyskaniaWproc / 100), 2)  , 0) * (z.ProcentPodatku/100) - z.SklKasaChorychZleceniobOdlicz), 0) 
						- z.InnePotr + z.InneDod +z.InneZasilkZUS, 2),
					z.InnePotr = (select sum(kwota) from #DB_ZLEC#.place_skladniki s where s.guid_zapisu_placowego = ''#_ZlecGUID#'' and s.RodzajSkladnika = #_ZLEC_Potr#)	
				WHERE	
					z.GUID = ''#_ZlecGUID#'' ; ';
			
			SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', @_ZlecGUID);			
			SET _SQLText = REPLACE(_SQLText, '#_ZLEC_Potr#', _ZLEC_Potr);			
			SET @_SQLText = _SQLText;		
			CALL _ExecuteCmd(_SQLText, @Error);	
			
			-- sposob wyplaty
			SET _SQLText = '
			update  #DB_ZLEC#.prace_zlecone z, #DB_ZLEC#.Pracownicy k
			set
				z.wyplataprzelewem = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), z.dowyplaty, 0),
				z.wyplatagotowka   = if ((k.czycosprzelewem=1 and length(k.nrrachunku) > 0), 0, z.dowyplaty)					
			where z.guid = ''#_ZlecGUID#'' and z.guid_pracownika = k.GUID;
			';
			
			SET _SQLText = REPLACE(_SQLText, '#DB_ZLEC#', IF(_Param_E in ('0','1','5'), "ms", "sec"));	
			SET _SQLText = REPLACE(_SQLText, '#_ZlecGUID#', @_ZlecGUID);			
			SET @_SQLText_wypl = _SQLText;		
			CALL _ExecuteCmd(_SQLText, @Error);	
				
		END IF;  -- IF @pl.gratyf.za_zlecenie > 0
	END IF;	--	IF _MODE = 'pl.nalicz.z.kart.obiektow.one.zlec'
	
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------	
	'pl.nalicz.z.kart.obiektow'
		Naliczanie z kart obiekt�w (Security)
		Parametry
		_Param_A	Rok
		_Param_B	Miesiac
		CALL pl_gratyfikacje_tools('pl.nalicz.z.kart.obiektow', '2011', '10, '', '', '');
------------------------------------------------------------------------------------------------------------------------------------------------------------------*/	
		
	IF _MODE = 'pl.nalicz.z.kart.obiektow' THEN
	
	    CALL _IReg_Get('Place2003', 'Gratyfikacje_AvgMscNCP', _Param_A, 'INTEGER', @AvgMscNCP, 168);
	    CALL _IReg_Get('Place2003', 'Zlecenie_Podstawowe_Kwota', _Param_A, 'INTEGER', @Kwota_201, 1850);  -- -- "W zwi�zku ze zmian� przepis�w ZUS od 01.01.2016": 201 -> 1850
			    
		DROP  TABLE IF EXISTS `te_pl_wynagr_z_obiektow`;  -- TEMPORARY
		CREATE  TABLE `te_pl_wynagr_z_obiektow`     -- TEMPORARY
			SELECT
				o.GUID, k.ZeSG, k.PlacaZasadnicza, k.RozliczajWg, 
			--	(SELECT IFNULL(SUM(z.ZaZlecenie), 0) FROM prace_zlecone z WHERE z.miesiac = _Param_B AND z.rok = _Param_A AND z.GUID_pracownika = o.GUID) as zeZlecen,
				_rnd2(k.PlacaZasadnicza/@AvgMscNCP) as stawka_Z,
				SUM(p.czas_P) AS godziny_etat, -- A
				SUM(p.czas_Z) AS godziny_zlec, -- B
				MAX(p.stawka_P) AS stawka_etat, -- C
				MAX(p.stawka_Z) AS stawka_zlec, -- D
				SUM(p.Absencja_CLZ) AS godziny_chorob, -- E
				SUM(p.Absencja_WOD) * 8 AS godziny_wypocz, -- F
				SUM(p.Extra_Wynagr) AS extra_wynagr,  -- G
				p.guid AS guidKop
			FROM `pl_karty_obiektu_ng` c
			JOIN  `pl_karty_obiektu_po` p ON c.guid = p.guidng
			JOIN osoby o ON o.GUID = p.PracGUID
			JOIN Pracownicy k ON k.GUID = p.PracGUID
			WHERE c.rok = _Param_A
			AND c.miesiac = _Param_B
			GROUP BY p.PracGUID, guidKop
			ORDER BY o.nazwisko, o.imiona
			;
		ALTER TABLE `te_pl_wynagr_z_obiektow` ADD PRIMARY KEY GUID (GUID, guidKop);
		
		-- dla RozliczajWg = 0 lub 3 w naliczeniach wykorzystywana jest PlacaZasadnicza - trzeba j� pobra� z frekwencji z odp. bazy
		
		-- dla RozliczajWg = 0 (sec=etat, ms=zlec) trzeba pobra� z bazy sec
		update 
			sec.te_pl_wynagr_z_obiektow s, sec.frekw m, sec.Pracownicy k
		set
			s.PlacaZasadnicza = m.PlacaZasad,
			s.stawka_Z	      = _rnd2(m.PlacaZasad/@AvgMscNCP)
		where
			k.RozliczajWg = 0 and k.guid = s.guid  and s.guid = m.Pracguid and m.rok = _Param_A and m.miesiac = _Param_B;
		
		-- dla RozliczajWg = 3 (sec=zlec, ms=etat) trzeba pobra� z bazy ms
		update 
			sec.te_pl_wynagr_z_obiektow s, ms.frekw m, ms.Pracownicy k
		set
			s.PlacaZasadnicza = m.PlacaZasad,
			s.stawka_Z	      = _rnd2(m.PlacaZasad/@AvgMscNCP)
		where
			k.RozliczajWg = 3 and k.guid = s.guid  and s.guid = m.Pracguid and m.rok = _Param_A and m.miesiac = _Param_B;
		
		BEGIN
			DECLARE _OsobaGUID VARCHAR(38);
			DECLARE _Tryb INTEGER;
			DECLARE _done BOOL DEFAULT FALSE;
			DECLARE _c_proc CURSOR FOR
				SELECT 
					GUID, ZeSG, RozliczajWg
				FROM `te_pl_wynagr_z_obiektow`
				;
		    DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;
			OPEN _c_proc;
				loop1: LOOP
					FETCH _c_proc INTO
						_OsobaGUID, _Tryb, _RozliczajWg;
					IF _done THEN
						LEAVE loop1;
					ELSE
					   -- set @szambo = 'wolam pl.nalicz.z.kart.obiektow.one.zlec';
						CALL pl_gratyfikacje_tools('pl.nalicz.z.kart.obiektow.one.zlec', _Param_A, _Param_B, _OsobaGUID, _Tryb, _RozliczajWg);						  	
					END IF;
				END LOOP;
			CLOSE _c_proc;		
		END;
		
	END IF;	 --   IF _MODE = 'pl.nalicz.z.kart.obiektow'
	
	
	IF (_MODE = 'pl.SprawdzRozniceNaRozliczeniaZasilkuIKwotaZasilku') THEN
	/*
	DROP TEMPORARY TABLE tmp_zestzbior;
	CREATE TEMPORARY TABLE tmp_zestzbior
	SELECT idn, guid FROM place WHERE miesiac=9 AND guid IN ('{BEBF482E-343F-4D7B-887D-7C4E610ADCCA}','{F0303508-ECD8-4D39-90DC-034975AF680C}') ;
	
	CALL pl_tools('pl.SprawdzRozniceNaRozliczeniaZasilkuIKwotaZasilku','','','','','','','','');
	
	*/	
		
		DROP TEMPORARY TABLE IF EXISTS t_pr_rozlicz_zas;
		
		CREATE TEMPORARY TABLE t_pr_rozlicz_zas 
			SELECT 
				GUID_Place, 
				SUM(IFNULL(rz.KwotaZUS+rz.kwotafirma+rz.ZasMacierz+rz.ZasOpiekun+rz.ZasRehab,0)) AS kwota
			FROM rozliczenie_zasilku rz 
			WHERE 
				rz.GUID_Place IN (SELECT DISTINCT guid FROM tmp_zestzbior)
			GROUP BY
				GUID_Place
		;
		
		

		DROP TEMPORARY TABLE IF EXISTS t_pr_rozlicz_zas_sklad;
		
		CREATE TEMPORARY TABLE t_pr_rozlicz_zas_sklad  
		SELECT 
			PS.GUID_zapisu_placowego, DSP.GUID, SUM(PS.kwota + PS.ZmniejszZwieksz) AS suma	
		FROM
			place_skladniki PS 
		LEFT JOIN definicja_skladnika_placy DSP ON PS.GUID_definicja_skladnika_placy = DSP.GUID AND DSP.deleted = 0 
		WHERE 
			PS.GUID_zapisu_placowego IN (SELECT DISTINCT guid FROM tmp_zestzbior) 
			AND DSP.GUID IN('C_9','C_10','C_11') 
		GROUP BY 
			PS.GUID_zapisu_placowego, DSP.GUID
		;
		
		
		SELECT 
			p.GUID,
			p.rok, 
			p.miesiac, 
			CONCAT(o.Nazwisko," ",o.Imiona) AS pracownik, 
			
			 IFNULL(SUM((SELECT SUM(kwota) FROM t_pr_rozlicz_zas WHERE GUID_Place=p.GUID)),0)
			 - (SUM(p.ChoroboweZUS + p.ChoroboweFirma) +
			 IFNULL(SUM((SELECT SUM(suma) FROM t_pr_rozlicz_zas_sklad WHERE GUID_zapisu_placowego=p.GUID)),0)
			 ) AS roznica 
   
   
		FROM place p  
		LEFT JOIN osoby o ON o.GUID= p.GUID_Pracownika
		WHERE 
			p.GUID IN (SELECT DISTINCT guid FROM tmp_zestzbior) 
		GROUP BY 
			p.GUID_Pracownika, -- pracownik
			p.miesiac 
		HAVING 
			ABS(roznica)>=0.01 
		ORDER BY 
			pracownik  
		;
	END IF;	--	IF _MODE = 'pl.SprawdzRozniceNaRozliczeniaZasilkuIKwotaZasilku'
	

END$$

DELIMITER ;

/*
====================================================================================================================================================================================
	NOTATNIK
====================================================================================================================================================================================
procedure TDBPlacesPlaceZlec.PrzepiszDanePrac(aPracGUID: String; var aZaZlecenie: Currency);
const
  cSQL = 'SELECT O.Nazwisko, CONCAT(O.Imie1,'' '',O.Imie2) AS Imie, '+
    'O.DataUrodzenia, O.NrPesel, Z.ZgloszZUA_ZZA, P.CzyCosPrzelewem, '+
    'P.ProcPodOdZlecen, P.GUID, P.KodUbezpUmZlecenie, P.KluczWzoruPK, P.AnalitykaFK, '+
    'P.KategoriaPracownicza, P.KluczUrzeduSkarbowego, P.KluczWzoruPK_zlec, '+
    'P.naliczFGSP, P.naliczFP, P.NrZlecenia, '+  //IF((P.TypNaliczaniaSkladek = 0) AND (P.KodUbezpUmZlecenie <> ''''), 1, 0) AS ZlecNaliczacZus ' +
    'IF(Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe, 1, 0) AS ZlecNaliczacZus, '+
    'IF((Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe) AND Z.PodlChorobUbzp, 1, 0) AS PodlChorobUbzp,  '+
    'IF((Z.PodlEmerytalneUbzp OR Z.Dobr_UbzpEmeryt OR Z.PodlRentoweUbzp OR Z.Dobr_UbzpRentowe) AND Z.PodlWypadkUbzp, 1, 0) AS PodlWypadkUbzp, '+
    'IF((!ISNULL(Z.DataPowstObowUbezpZdrow) OR Z.Dobr_UbzpZdrowotne=1) AND Z.ZgloszZUA_ZZA=1 AND ((Z.KodKasyChorych <> '''') AND !ISNULL(Z.KodKasyChorych)), 1, 0) AS PodlUbezpZdrowot '+
    'FROM Pracownicy P '+
    'LEFT JOIN osoby O ON P.GUID = O.GUID '+
    'LEFT JOIN pracownicy_ZUS Z ON P.GUID = Z.GUID_Pracownika '+
    'WHERE P.GUID = ''%s'' ';
	
	stale potracenia z karty pracownika:
	
	cStalePotrSQL = 'SELECT p.* FROM prac_stale_skladniki p '+
    'JOIN definicja_skladnika_placy d '+
    'ON p.GUID_def_skl_placy = d.GUID AND d.typ_gratyfikacji = %d and d.deleted = 0 '+
    'WHERE p.GUID_pracownika = ''%s'' AND p.typ_skladnika = %d AND '+
    '((p.rok_do > %d) OR (p.rok_do = %d AND p.msc_do > %d)) ';
	
RozliczajWg 		Sec		   MS
   0			    Etat      Zlec
   1			   Zlec201    Zlec 
   2                Zlec     Zlec201
   3				Zlec	  Etat
   4				Zlec       X
   5				 X        Zlec
	
	
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
*/

			
			