//"intedef.sci","Integracja definicje - include","\Integracja z FK a\",0,1.0.19,SYSTEM
/////////////////////////////////////////
// "Integracja definicje - include"
// intedef.sci
/////////////////////////////////////////

#include "Const - include"

#define NAL       "0"
#define NALROZL   "1"
#define PLAT      "2"
#define PLATROZL  "3"

#define ROZ_STAN_ALL		0
#define ROZ_STAN_ROZ		1
#define ROZ_STAN_NROZ 		2

#define ROZ_NALEZ			0
#define ROZ_ZOBOW			1
#define ROZ_WSZYSTKO		3

#define SUB_NULL			-1
#define SUB_PRACOWNICY		1
#define SUB_KONTRAHENCI		2
#define SUB_URZEDY			4

#define NIEANULOWANY		1
#define ANULOWANY			2

#define WYSTAWIONY			1
#define BUFORZE				2

#define KHtypKH		1
#define KHtypPR		2
#define KHtypUR		3

#define khPRACOWNIK		0x001
#define khURZAD			0x010
#define khKONTRAHENT	0x100

#define TiKontrahent	0x2BC2	//kontrahent
#define TiPracownik		0x2BC7	//pracownik
#define TiUrzad			0x2BC8	//urząd
#define TiKh			0x2BA5
#define TiPr			0x2BA6
#define TiUr			0x2BA7

#define TRYB_WSP_SYN			2	//tryb synchronizacji
#define TRYB_WSP_REP			1	//tryb replikacji
#define TRYB_WSP_CDB			4   //tryb wspólnej bazy

///////////////////////////////////////////////////////////////////////////
// dokumenty sprzedaży

#define FVS      40     // faktura VAT
#define FKS      41     // faktura korygująca VAT
#define RUS      42     // rachunek uproszczony
#define RKS      43     // rachunek korygujący VAT
#define DXK      45     // dokument eksp. korygujący
#define DEX      46     // dokument eksportowy
#define FAS      79     // faktura
#define FAK      80     // faktura korygująca
#define PAR      50     // paragon
#define PRK      51     // paragon korekta
#define FVW		101		// f-ra VAT w walucie
#define FKW		102		// korekta VAT w walucie
#define FVM		106		//Faktura VAT MP
#define FKM		107		//Faktura korygujaca VAT MP
#define FZS		108		//Faktura zaliczkowa
#define KZS		109		//Kontrakt zaliczkowy
#define KZZ		111		//Kontrakt zaliczkowy zakupu
#define ZKS		112		//Faktura korygujaca zaliczkowa
#define ZKZ		113		//Faktura korygujaca zaliczkowa zakupu
#define WDT		114		//Wewnątrzwspólnotowa dostawa towaru
#define WNT		115		//Wewnątrzwspólnotowe nabycie towaru
#define FWS		116		//Faktura wewnętrzna (sprzedaży)
#define FWZ		117		//Faktura wewnętrzna (zakupu)
#define WKS		118		//Faktura korygująca wewnętrzna (sprzedaży)
#define WKZ		119		//Faktura korygująca wewnętrzna (zakupu)
#define WDK		120		//Wewnątrzwspólnotowa dostawa towaru korekta
#define WNK		121		//Wewnątrzwspólnotowe nabycie towaru korekta
#define ZSK		122		//Kontrakt zaliczkowy korekta
#define ZZK		123		//Kontrakt zaliczkowy zakupu korekta
#define FVT		124		//Faktura VAT marża	(inaczej: turystyczna)
#define FTK		125		//Faktura VAT marża (inaczej: turystyczna) korekta
#define REX		126		//Rachunek eksportowy
#define RXK		127		//Rachunek eksportowy korekta
#define FZZ		128		//Faktura zaliczkowa zakupu
#define SKO		134		//Kontrakt sprzedaży
#define SKK		135		//Kontrakt sprzedaży korekta
#define SZA		136		//Zaliczka sprzedaży
#define SZK		137		//Zaliczka sprzedaży korekta
#define	ZVW		138		//Faktura VAT zakupu w walucie
#define	ZWK		139		//Faktura VAT zakupu w walucie korekta
#define SKW		150		//Kontrakt sprzedazy w walucie
#define SKWK	151		//Kontrakt sprzedazy w walucie korekta
#define SZW		152		//Zaliczka sprzedazy w walucie
#define SZWK	153		//Zaliczka sprzedazy w walucie korekta
#define NZW		157		// Nowa faktura zaliczkowa walutowa 
#define NZWK	158		// Nowa faktura zaliczkowa walutowa korekta 
#define NZZ		159		// Nowa faktura zaliczkowa zlotowkowa 
#define NZZK	160		// Nowa faktura zaliczkowa zlotowkowa korekta 

//...

///////////////////////////////////////////////////////////////////////////
// dokumenty zakupu

#define FVZ      68      // faktura VAT zakupu
#define FKZ      69      // faktura korygujaca VAT zakupu
#define RUZ      70      // rachunek uproszczony zakupu
#define RKZ      71      // rachunek korygujacy VAT zakupu
#define DIM      72      // dokument importowy
#define DKM      73      // dokument importowy korekta
#define ZRZ      97      // rachunek zakupu
#define ZRK      98      // rachunek zakupu korekta
#define FVR      99      // fakura VAT RR
#define FKR      100     // faktura korygująca VAT RR
#define	ZVW		138		//Faktura VAT zakupu w walucie
#define	ZWK		139		//Faktura VAT zakupu w walucie korekta
//...



///////////////////////////////////////////////////////////////////////////
// dokumenty magazynowe

#define PW       74     // przychod wewnetrzny
#define PWK      75     // przychod wewnetrzny korekta
#define RW       76     // rozchod wewnetrzny
#define RWK      77     // rozchod wewnetrzny korekta
#define WZM      78     // wydanie z magazynu
#define WZK      88     // wydanie z magazynu korekta
#define PZM      89     // przyjęcie do magazynu
#define PZK      81     // przyjęcie do magazynu korekta
#define MMP      82     // przesunięcie magazynowe plus
#define MKP      83     // przesunięcie magazynowe plus korekta
#define MMM      84     // przesunięcie magazynowe minus
#define MKM      85     // przesunięcie magazynowe minus korekta
#define KWM      90     // korekta wartości magazynu
#define PWM      91     // przecena wartości magazynu
#define	WDP		129		// wydanie do produkcji
#define	WPK		130		// wydanie do produkcji korekta
#define	PZP		131		// przyjęcie z produkcji
#define	PPK		132		// przyjęcie z produkcji korekta
//...

long DECLARE GETIDxVATNP ()
dispatch DECLARE GETxStawkaObjectByIdentifier (long identifier)

string sStndError
//////////////////////////////////////////////////////////////////////////////////////////
int iSingleOper = 0	//

//---------------------------------------------------------------------------
int sub XErr(int nErr)
//---------------------------------------------------------------------------
	int i
	if nErr==771 then
		for i=1 to i>xFactory.komunikaty.count
			if xFactory.komunikaty.item(i).status then
				sStndError+= "Błąd nr."+(using "%d",xFactory.komunikaty.item(i).id)+": '"+xFactory.komunikaty.item(i).tresc+"'\n"//Atrybut: "+xFactory.komunikaty.item(i).nazwapola+"\n"
			else
				sStndError+="OSTRZEŻENIE !! "+xFactory.komunikaty.item(i).tresc+"\n"
			endif
		next i
	else
		Select case nErr
			case -4101
				sStndError = "Nie odnaleziono rekordu w bazie XT"
			case -4010
				sStndError = "Nieunikalny kod towaru."
			case -4013
				sStndError = "Nie podano nazwy obiektu."
			case 4
				sStndError = "Nie odnaleziono obiektu."
			case -4201
				sStndError = "Nie można zapisac obiektu, w bazie danych istnieje już obiekt posiadający ten sam skrot i charakter."
			case else
				sStndError = "Nieznany błąd nr. "+(using "%d",nErr)
		endselect
	endif
endsub

//---------------------------------------------------------------------------
string Sub TypDOK(int ityp)
//---------------------------------------------------------------------------
	select case ityp
		case FVS
			TypDOK = "FVS"
		case FKS
			TypDOK = "FKS"
		case RUS
			TypDOK = "RUS"
		case RKS
			TypDOK = "RKS"
		case DXK
			TypDOK = "DXK"
		case DEX
			TypDOK = "DEX"
		case FAS
			TypDOK = "SRS"
		case FAK
			TypDOK = "SRK"
		case PAR
			TypDOK = "PAR"
		case PRK
			TypDOK = "PRK"
		case FVW
			TypDOK = "FVW"
		case FKW
			TypDOK = "FKW"
		case FVM
			TypDOK = "FVM"
		case FKM
			TypDOK = "FKM"
///////////////////////////////////////////////////////////////////////////
// dokumenty zakupu
		case FVZ
			TypDOK = "FVZ"
		case FKZ
			TypDOK = "FKZ"
		case RUZ
			TypDOK = "RUZ"
		case RKZ
			TypDOK = "RKZ"
		case DIM
			TypDOK = "DIM"
		case DKM
			TypDOK = "DKM"
		case ZRZ
			TypDOK = "ZRZ"
		case ZRK
			TypDOK = "ZRK"
		case FVR
			TypDOK = "FVR"
		case FKR
			TypDOK = "FKR"
		case FVT
			TypDOK = "FVT"
		case FTK
			TypDOK = "FTK"
///////////////////////////////////////////////////////////////////////////
// dokumenty magazynowe
		case PW
			TypDOK = "PW"
		case PWK
			TypDOK = "PWK"
		case RW
			TypDOK = "RW"
		case RWK
			TypDOK = "RWK"
		case WZM
			TypDOK = "WZ"
		case WZK
			TypDOK = "WZK"
		case PZM
			TypDOK = "PZ"
		case PZK
			TypDOK = "PZK"
		case MMP
			TypDOK = "MM+"
		case MKP
			TypDOK = "MK+"
		case MMM
			TypDOK = "MM-"
		case MKM
			TypDOK = "MK-"
		case KWM
			TypDOK = "KWM"
		case PWM
			TypDOK = "PWM"
		case WDP
			TypDOK = "WDP"
		case WPK
			TypDOK = "WPK"
		case PZP
			TypDOK = "PZP"
		case PPK
			TypDOK = "PPK"
		case else
			TypDOK = ""
	endselect
EndSub
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

#define FDK_IMPORT	0x20 //dokumenty zaimportowane z oddzialu
#define XTustaDOK   "32"  // typ dokumentu

#define DOV_OKRES	 0	// okres vat wybrany
#define DOV_OCZEK	 1	// okres vat oczekujący
#define DOV_ZAPLATA  2	// okres vat  ustalony  metodą kasową (rozliczenie zapłatą)
#define DOV_TERMIN	 3  // okres vat na podstawie terminu płatnośći (z transakcji)

#define	BFLAGdkVATKAS		0x0080		//vat naliczany metodą kasow


//****************************************
record InfoStVat
//****************************************
	long id
	int  typ
	float stawka
	string nazwa[10]
	int aktywna
	float netto
	float vat
	float wnetto
	float wbrutto

	//---------------------------------------------------------------------------
	int Sub ClearRec()
	//---------------------------------------------------------------------------
		id = -2000
		typ = 0
		stawka = 0
		nazwa = ""
		aktywna = 0
		netto = 0
		vat = 0
		wnetto = 0
		wbrutto = 0
	EndSub

	//---------------------------------------------------------------------------
	int Sub Init(dispatch dpStVat)
	//---------------------------------------------------------------------------
		id = dpStVat.id
		typ = dpStVat.typ
		select case typ
			case STVAT_ZWOLNIONE
				stawka = -1
			case STVAT_NIEPODLEGA
				stawka = -2
			case else
				stawka = dpStVat.wartosc * 100
		endselect
		nazwa = dpStVat.nazwa
		aktywna = dpStVat.aktywny
	EndSub
endrec

//****************************************
record InfoRejVat
//****************************************
	InfoStVat StVat(1)
	long id
	string JPK_V7[10]
	int rodzajDostawy_OSS
	long ABCD
	string nazwaFK[50]
	float sumNetto
	float sumVat
	int Naliczony

	//---------------------------------------------------------------------------
	int Sub ClearRec()
	//---------------------------------------------------------------------------
		int iPom
		id = -2000
		JPK_V7 = ""
		rodzajDostawy_OSS = 0
		ABCD=1
		nazwaFK = ""
		sumNetto = 0
		sumVat = 0
		Naliczony = 0
		for iPom = 1 to iPom > size(StVat)
			StVat(iPom).ClearRec()
		next iPom
	EndSub

	//---------------------------------------------------------------------------
	int Sub Znajdz(dispatch dpStVat)
	//---------------------------------------------------------------------------
		int iPom

		Znajdz=-2000
		for iPom=1 to iPom > size(StVat)
			if StVat(iPom).id == dpStVat.id then exit
		next iPom
		if iPom > size(StVat) then
			if size(StVat) == 1 && StVat(1).id == -2000 then
				StVat(1).Init(dpStVat)
				Znajdz = 1
			else
				grow StVat,1
				StVat(size(StVat)).ClearRec()
				StVat(size(StVat)).Init(dpStVat)
				Znajdz = size(StVat)
			endif
		else
			Znajdz = iPom
		endif
	endsub

	//---------------------------------------------------------------------------
	int Sub Wstaw(dispatch dpStVat, dispatch dpPozycja, int p_Naliczony, int nMinus)
	//---------------------------------------------------------------------------
		int iPom = Znajdz(dpStVat)
		float f = 1.0
		if nMinus then f = -1.0
		
		if !dpPozycja.czyVat50 then
			StVat(iPom).netto   += (f * dpPozycja.netto)
			StVat(iPom).netto   += (f * dpPozycja.niePodlega)
			StVat(iPom).netto   -= dpPozycja.rozlZalNettoPLN

			StVat(iPom).vat     += (f * dpPozycja.VAT)
			StVat(iPom).vat     -= dpPozycja.rozlZalVATPLN

			StVat(iPom).wnetto  += (f * dpPozycja.nettoWal)
			StVat(iPom).wnetto  += (f * dpPozycja.niePodlegaWal)
			StVat(iPom).wnetto  -= dpPozycja.rozlZalNetto

			StVat(iPom).wbrutto += (f * dpPozycja.bruttoWal)
			StVat(iPom).wbrutto += (f * dpPozycja.niePodlegaWal)
			StVat(iPom).wbrutto -= dpPozycja.rozlZalBrutto

			Naliczony = p_Naliczony

			sumNetto += (f * (dpPozycja.netto - dpPozycja.rozlZalNettoPLN))
			// sumNetto += (f *dpPozycja.niePodlega)
			sumVat += (f * (dpPozycja.VAT - dpPozycja.rozlZalVATPLN))
		else 
			if dpStVat.czyNpNew || dpStVat.czyNpOld then	//ta czesc co nie podlega
				StVat(iPom).netto+=(f * Round(dpPozycja.netto/2))
				StVat(iPom).netto+=(f * dpPozycja.Vat50)
				StVat(iPom).wnetto+=(f * Round(dpPozycja.bruttoWal/2))
				StVat(iPom).wnetto+=(f * Round(dpPozycja.niePodlegaWal/2))
				StVat(iPom).wbrutto+=(f * Round(dpPozycja.bruttoWal/2))
				StVat(iPom).wbrutto+= (f * Round(dpPozycja.niePodlegaWal/2))
				Naliczony=p_Naliczony
			else
				StVat(iPom).netto+=(f * (dpPozycja.netto - Round(dpPozycja.netto/2)))
				//StVat(iPom).netto+=(f * (dpPozycja.niePodlega - Round(dpPozycja.niePodlega/2)))
				StVat(iPom).vat+=(f * (dpPozycja.VAT - dpPozycja.Vat50))
				StVat(iPom).wnetto+=(f * (dpPozycja.nettoWal - Round(dpPozycja.nettoWal/2)))
				//StVat(iPom).wnetto+= (f * (dpPozycja.niePodlegaWal - Round(dpPozycja.niePodlegaWal/2)))
				StVat(iPom).wbrutto+=(f * (dpPozycja.bruttoWal - Round(dpPozycja.bruttoWal/2)))
				//StVat(iPom).wbrutto+= (f * (dpPozycja.niePodlegaWal - Round(dpPozycja.niePodlegaWal/2)))
				Naliczony=p_Naliczony
				sumNetto+=(f * (dpPozycja.netto - Round(dpPozycja.netto/2)))
				//sumNetto+=(f *dpPozycja.niePodlega)
				sumVat+=(f * (dpPozycja.VAT - dpPozycja.Vat50))
			endif
		endif
	endsub

	//---------------------------------------------------------------------------
	Int Sub WstawRV( Dispatch dpStVat, Float netto, Float vat )
	//---------------------------------------------------------------------------

		Int		iPom = Znajdz( dpStVat )

		StVat( iPom ).netto += netto
		StVat( iPom ).vat += vat
		StVat( iPom ).wnetto += netto
		StVat( iPom ).wbrutto += ( netto + vat )
		Naliczony = 0
		sumNetto += netto
		sumVat += vat

	EndSub

	//---------------------------------------------------------------------------
	int Sub IloscStawek(int ile)
	//---------------------------------------------------------------------------
		if !ile then
			IloscStawek=size(StVat)
		else
			shrink StVat,ile
		endif
	endsub
endrec

//****************************************
record InfoTabRejVat
//****************************************
	InfoRejVat RejVat(1)

	//---------------------------------------------------------------------------
	int Sub ClearRec()
	//---------------------------------------------------------------------------
		int iPom

		for iPom = 1 to iPom > size(RejVat)
			RejVat(iPom).ClearRec()
		next iPom
	endsub

	//---------------------------------------------------------------------------
	int Sub Znajdz(long lRejId, string JPK_V7, long ABCD, int rodzajDostawy_OSS)
	//---------------------------------------------------------------------------
		int iPom

		Znajdz=-2000
		for iPom=1 to iPom > size(RejVat)
			if RejVat(iPom).id == lRejId  && RejVat(iPom).ABCD==ABCD && RejVat(iPom).JPK_V7 == JPK_V7 && RejVat(iPom).rodzajDostawy_OSS == rodzajDostawy_OSS then exit
		next iPom
		if iPom > size(RejVat) then
			if size(RejVat) == 1 && RejVat(1).id == -2000 then
				RejVat(1).id = lRejId
				RejVat(1).ABCD = ABCD
				RejVat(1).JPK_V7 = JPK_V7
				RejVat(1).rodzajDostawy_OSS = rodzajDostawy_OSS
				Znajdz = 1
			else
				grow RejVat,1
				RejVat(size(RejVat)).ClearRec()
				RejVat(size(RejVat)).id = lRejId
				RejVat(size(RejVat)).ABCD = ABCD
				RejVat(size(RejVat)).JPK_V7 = JPK_V7
				RejVat(size(RejVat)).rodzajDostawy_OSS = rodzajDostawy_OSS
				Znajdz = size(RejVat)
			endif
		else
			Znajdz = iPom
		endif
	endsub

	//---------------------------------------------------------------------------
	int Sub Wstaw(long lRejId, dispatch dpStVat, dispatch dpPozycja , long ABCD, int p_Naliczony, int nMinus, Int SendAggregated, int czyOSS)
	//---------------------------------------------------------------------------
		int iPom

		if ABCD&2 then
			ABCD=2
		else
			if ABCD&4 then
				ABCD=4
			else
				if ABCD&8 then
					ABCD=8
				else
					ABCD=1
				endif
			endif
		endif

		int rodzajDostawy = 0
		if czyOSS  then
			rodzajDostawy = IIF(dpPozycja.usluga_OSS, 2, 1)
		endif

		iPom = Znajdz(lRejId, IIF(SendAggregated, AggregatedGTU(), dpPozycja.JPK_V7), ABCD, rodzajDostawy)
		RejVat(iPom).Wstaw(dpStVat, dpPozycja, p_Naliczony, nMinus)
	endsub

	//---------------------------------------------------------------------------
	Int Sub WstawRV( Long dpRejID, string JPK_V7, Dispatch dpStVat, Float netto, Float vat )
	//---------------------------------------------------------------------------

		Int iPom = Znajdz( dpRejID, JPK_V7, 1, 0 )

		RejVat( iPom ).WstawRV( dpStVat, netto, vat )
		
	EndSub
	
	//---------------------------------------------------------------------------
	float Sub Wartosc(int iRej, int iStVat, string pole)
	//---------------------------------------------------------------------------
		select case pole
			case "netto"
				Wartosc=RejVat(iRej).StVat(iStVat).netto
			case "vat"
				Wartosc=RejVat(iRej).StVat(iStVat).vat
			case "wnetto"
				Wartosc=RejVat(iRej).StVat(iStVat).wnetto
			case "wbrutto"
				Wartosc=RejVat(iRej).StVat(iStVat).wbrutto
			case "stawka"
				Wartosc=RejVat(iRej).StVat(iStVat).stawka
		endselect
	endsub

	//---------------------------------------------------------------------------
	int Sub IloscRejestrow(int ile)
	//---------------------------------------------------------------------------
		int iPom

		if !ile then
			IloscRejestrow=size(RejVat)
		else
			shrink RejVat,ile
			for iPom = 1 to iPom > size(RejVat)
				RejVat(iPom).IloscStawek(ile)
			next iPom
		endif
	endsub

	//---------------------------------------------------------------------------
	int Sub IloscStawek(int iRej)
	//---------------------------------------------------------------------------
		IloscStawek=RejVat(iRej).IloscStawek(0)
	endsub
endrec

InfoTabRejVat TabRejVat

Dispatch xAdoConnection = GetAdoConnection()
Dispatch xAdoRecordset = "ADODB.Recordset"
dispatch cmdAdoCommand = "ADODB.Command"
xAdoRecordset.CursorType = 1
xAdoRecordset.LockType = 3

String		sSqlRequest
Dispatch	StVatRV

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//****************************************
record InfoPozycjaVat
//****************************************
	long id
	long stawka
	string towar[50]
	string opis[250]
	float wartosc
	long rejestrVat
	int usluga
	int UE
	string JPK_V7[10]
	int rodzajDostawy_OSS

	//---------------------------------------------------------------------------
	int Sub ClearRec()
	//---------------------------------------------------------------------------
		id = -2000
		stawka = 0
		towar = ""
		wartosc = 0
		rejestrVat = 0
		opis = ""
		usluga = 0
		UE = 0
		JPK_V7 = ""
		rodzajDostawy_OSS = 0
	EndSub
endrec

//****************************************
record InfoTabPozycjaVat
//****************************************
	InfoPozycjaVat PozVat(1)
	InfoStVat	   StVat(1)

	//---------------------------------------------------------------------------
	int Sub ClearRec()
	//---------------------------------------------------------------------------
		int iPom

		for iPom = 1 to iPom > size(StVat)
			StVat(iPom).ClearRec()
		next iPom

		for iPom = 1 to iPom > size(PozVat)
			PozVat(iPom).ClearRec()
		next iPom
	endsub

	//---------------------------------------------------------------------------
	int Sub ZnajdzStawke(long lStVat)
	//---------------------------------------------------------------------------
		int iPom
		ZnajdzStawke = -1
		for iPom=1 to iPom > size(StVat)
			if StVat(iPom).id == lStVat then
				ZnajdzStawke = iPom
				exit
			endif
		next iPom
	endsub

	//---------------------------------------------------------------------------
	int Sub InitStawke(dispatch dpStVat)
	//---------------------------------------------------------------------------
		int iPom

		InitStawke=-2000
		for iPom=1 to iPom > size(StVat)
			if StVat(iPom).id == dpStVat.id then exit
		next iPom
		if iPom > size(StVat) then
			if size(StVat) == 1 && StVat(1).id == -2000 then
				StVat(1).Init(dpStVat)
				InitStawke = 1
			else
				grow StVat,1
				StVat(size(StVat)).ClearRec()
				StVat(size(StVat)).Init(dpStVat)
				InitStawke = size(StVat)
			endif
		else
			InitStawke = iPom
		endif
	endsub

	//---------------------------------------------------------------------------
	int Sub Wstaw(dispatch pozycja, float wartosc, int czyDEX, int czyOSS)
	//---------------------------------------------------------------------------
		int iPom
		dispatch stawka
		
    	//dla DEX i DXK poza pozycjami NP,wszystkie wysylamy ze stawka 0%
		if czyDEX && pozycja.stVAT.typ != STVAT_NIEPODLEGA && pozycja.stVAT.typ != STVAT_ZEROWA then
			stawka = xFactory.GetObject("BStawkaVAT")
			stawka.Load("id=1004")
		else
			stawka = pozycja.stVAT
		endif
		if size(PozVat) > 1 || (PozVat(1).id != -2000) then grow PozVat,1
		iPom = size(PozVat)
		PozVat(iPom).ClearRec()
		PozVat(iPom).id = pozycja.id
		PozVat(iPom).stawka = StVat(InitStawke(stawka)).id
		PozVat(iPom).towar = pozycja.kod
		PozVat(iPom).opis = pozycja.opis
		PozVat(iPom).wartosc = wartosc
		PozVat(iPom).rejestrVat = pozycja.rejestrVAT.rejestrFKid
		PozVat(iPom).usluga = pozycja.eksportUslug
		PozVat(iPom).UE = pozycja.vatue
		PozVat(iPom).JPK_V7 = pozycja.JPK_V7
		if czyOSS then
			PozVat(iPom).rodzajDostawy_OSS = IIF(pozycja.usluga_OSS, 2, 1)
		endif
		Wstaw = iPom
	endsub

	//---------------------------------------------------------------------------
	int Sub Rozmiar()
	//---------------------------------------------------------------------------
		Rozmiar = size(PozVat)
	endsub
endrec

InfoTabPozycjaVat	TabPozVat

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

//---------------------------------------------------------------------------
dispatch sub GetObjById(string sObiekt, long id)
//---------------------------------------------------------------------------
	dispatch xParams = xFactory.NewObject("XParams")

	xParams.id = id
	GetObjById = xFactory.GetObject(sObiekt, xParams)
endsub

//---------------------------------------------------------------------------
Dispatch Sub GetNewObjById(string sObiekt, long id)
//---------------------------------------------------------------------------

	GetNewObjById = xFactory.NewObject(sObiekt)
	If GetNewObjById.Load(Using "id=%l", id) Then Error "Błąd podczas odczytywania dokumentu"

EndSub

//---------------------------------------------------------------------------
dispatch sub GetObjByKod(string sObiekt, string str)
//---------------------------------------------------------------------------
	dispatch xParams = xFactory.NewObject("XParams")

	xParams.kod = str
	GetObjByKod = xFactory.GetObject(sObiekt, xParams)
endsub

String strOpis

//---------------------------------------------------------------------------
int Sub DodajDoOpisu(String strCzescOpisu, String strSeparator)
//---------------------------------------------------------------------------
// zmienne globalne: String strOpis

	if ( 59 == len(strOpis) ) then Exit

	String Tablica_kod(2) = "\"","\'"
	String strTmp = Translate(strCzescOpisu, Tablica_kod)

	if ( strOpis == "" ) then
		strOpis = strTmp
	else
		if ( len(strOpis) < 55 ) then
			strOpis += strSeparator
			strOpis += strTmp
		endif
	endif

	if ( len(strOpis) > 59 ) then
		strOpis = mid(strOpis, 0, 56)
		strOpis += "..."
	endif
EndSub

#define		Integr_WSZYSTKIE	0	// Wysyłaj wszystkie
#define		PYTAJ_UZYTK			1	// pytaj użytkownika
#define		POMIN_WSZYSTKIE		2	// pomiń wszystkie
#define		PRZYCHOD			0x0100
#define		PWflagZATWWART		0x04

////////////////////////////////////////////////////////////////////////////////////
// sprawdzanie czy wysyłać niezatwierdzone wartościowo

int nEZatwWart = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub IntegrZatwWart(dispatch dpDokMg, string strKodHandl, Int pytaj)
//---------------------------------------------------------------------------
	IntegrZatwWart = 0

	If !pytaj Then Exit

	int err, bZatw = 1
	string sMessTekst
	Dispatch xDokMg = xFactory.NewObject("BDokMg")
	Dispatch xKartParamsDokMg = xFactory.NewObject("BKartParamsDokMg")

	// 0- niezatwierdzony wartosciowo

	xKartParamsDokMg.numer = dpDokMg.numer
	xKartParamsDokMg.id = dpDokMg.id
	xKartParamsDokMg.wystawioneIBufor = iif(dpDokMg.czyWystawiony,1,2)

	nRes = xDokMg.Load(xKartParamsDokMg)
	if nRes then  error "Dokument magazynowy nie załadowany"

	long idMG = dpDokMg.id
	bZatw = dpDokMg.czyZatwWart
	//bZatw = xDokMg.item(1).czyZatwWart

	if strKodHandl == "" then
		if iSingleOper then
			sMessTekst = "Dokument '%s' nie został zatwierdzony wartościowo.{{icon=? buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
		else
			sMessTekst = "Dokument '%s' nie został zatwierdzony wartościowo.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
		endif
		sMessTekst = using sMessTekst, dpDokMg.numer
	else
		if iSingleOper then
			sMessTekst = "Dokument magazynowy '%s' skojarzony z dokumentem handlowym '%s' nie został zatwierdzony wartościowo.{{icon=? buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
		else
			sMessTekst = "Dokument magazynowy '%s' skojarzony z dokumentem handlowym '%s' nie został zatwierdzony wartościowo.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
		endif
		sMessTekst = using sMessTekst, dpDokMg.numer, strKodHandl
	endif

	if nEZatwWart == Integr_WSZYSTKIE then // nie sprawdzamy czy zatwierdzone wartościowo
		if !bZatw then
			AddInfo(sMessTekst,idMG)
		endif
		IntegrZatwWart = 0
		Exit
	endif

	if !bZatw then // nie jest zatwierdzony wartościowo
		if nEZatwWart == POMIN_WSZYSTKIE then // nie wysyłamy nie zatwierdzonych
			AddError(sMessTekst,idMG)
			IntegrZatwWart = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddAsk(sMessTekst,err,idMG)


		if err == 1 || err == (1+16) then // wysyłaj
			IntegrZatwWart = 0
			if err == (1+16) then // dla wszystkich
				nEZatwWart = Integr_WSZYSTKIE
			endif
			Exit
		endif

		// pozostałe pomiń...
		IntegrZatwWart = 1
		if err == (5+16) then // pomiń dla wszystkich
			nEZatwWart = POMIN_WSZYSTKIE
		endif
	endif
EndSub

//////////////////////////////////////////////////////////////////////////////////////////
// Czy wysyłać dokumenty dla których nie jest określony schemat księgowa

int nBrakSchematu = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrBrakSchematu(string strSchemat, string strKodDok, long idDK)
//---------------------------------------------------------------------------
	CzyIntegrBrakSchematu = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Dokument '%s' ma nieokreślony schemat księgowań.{{icon=? buttons=[&Wysyłaj ze wzorcem:o](&Pomiń:i)  title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' ma nieokreślony schemat księgowań.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wysyłaj ze wzorcem:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok
	sMessTekst2 = strKodDok+" Nieokreślony schemat księgowań."

	if nBrakSchematu == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		if strSchemat == "" then // brak schematu
			AddWarning(sMessTekst2, idDK)
		endif
		CzyIntegrBrakSchematu = 0
		Exit
	endif

	if strSchemat == "" then // brak schematu
		if nBrakSchematu == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
			AddWarning(sMessTekst2, idDK)
			CzyIntegrBrakSchematu = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddWarning(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // wysyłaj
			CzyIntegrBrakSchematu = 0
			if err == (1+16) then // dla wszystkich
				nBrakSchematu = Integr_WSZYSTKIE
			endif
			Exit
		endif

		// pozostałe pomiń...
		CzyIntegrBrakSchematu = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBrakSchematu = POMIN_WSZYSTKIE
		endif
	endif

	if CzyIntegrBrakSchematu then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub


//////////////////////////////////////////////////////////////////////////////////////////
// Czy wysyłać dokumenty dla których określony schemat księgowań nie istnieje

int nBlednySchemat = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrBlednySchemat(int iSchemat, string strKodDok, long idDK)
//---------------------------------------------------------------------------
	CzyIntegrBlednySchemat = 0

	int err
	string sMessTekst
	string sMessTekst2


	if iSingleOper then
		sMessTekst = "Określony dla dokumentu '%s' schemat księgowań nie istnieje.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Określony dla dokumentu '%s' schemat księgowań nie istnieje.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wysyłaj ze wzorcem:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok
	sMessTekst2 = strKodDok+" Nie istnieje schemat księgowań."

	if nBlednySchemat == Integr_WSZYSTKIE then
		if iSchemat then
			AddWarning(sMessTekst2, idDK)
		endif
		CzyIntegrBlednySchemat = 0
		Exit
	endif

	if iSchemat then
		if nBlednySchemat == POMIN_WSZYSTKIE then
			AddWarning(sMessTekst2, idDK)
			CzyIntegrBlednySchemat = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
			AddWarning(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // Wysyłaj
			CzyIntegrBlednySchemat = 0
			if err == (1+16) then // dla wszystkich
				nBlednySchemat = Integr_WSZYSTKIE
			endif
			Exit
		endif

		// pozostałe pomiń...
		CzyIntegrBlednySchemat = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBlednySchemat = POMIN_WSZYSTKIE
		endif
	endif

	if CzyIntegrBlednySchemat then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

///////////////////////////////////////////////////////////////////////
int nBrakIDFK = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrBrakIDFK(long idFK, string strKodDok, long idDK, int iTypKh)
//---------------------------------------------------------------------------
	CzyIntegrBrakIDFK = 0

	int err
	string sMessTekst
	string sMessTekst2

    string stypKh, stypKh2

    select case iTypKh
		case KHtypKH
            stypKh = "kontrahenta"
            stypKh2 = "kontrahent"
		case KHtypPR
            stypKh = "pracownika"
            stypKh2 = "pracownik"
	    case KHtypUR
            stypKh = "urzędu"
            stypKh2 = "urząd"
	endselect

	if iSingleOper then
		sMessTekst = "Dokument '%s' ma nieuzgodnione dane %s z danymi FK-a.\nW celu uzgodnienia danych %s należy przeprowadzić synchronizację danych z kartotekami FK-a dostępną w ustawieniach programu.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' ma nieuzgodnione dane %s z danymi FK-a.\nW celu uzgodnienia danych %s należy przeprowadzić synchronizację danych z kartotekami FK-a dostępną w ustawieniach programu.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok, stypKh, stypKh
	sMessTekst2 = using "Nieuzgodniony %s.", stypKh2

	if nBrakIDFK == Integr_WSZYSTKIE then // nie sprawdzamy
		if !idFK then // brak
			AddError(sMessTekst2, idDK)
		endif
		CzyIntegrBrakIDFK = 0
		Exit
	endif

	if !idFK then // brak
		if nBrakIDFK == POMIN_WSZYSTKIE then // nie wysyłamy
			AddError(sMessTekst2, idDK)
			CzyIntegrBrakIDFK = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddError(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // przerwij
			CzyIntegrBrakIDFK = -6000
			Exit
		endif

		// pozostałe pomiń...
		CzyIntegrBrakIDFK = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBrakIDFK = POMIN_WSZYSTKIE
		endif
	endif

	if CzyIntegrBrakIDFK then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

///////////////////////////////////////////////////////////////////////
int nBrakTypDK = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrBrakTypDK(string strTypDK, string strKodDok, long idDK, string strTypUZG)
//---------------------------------------------------------------------------
	CzyIntegrBrakTypDK = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Dokument '%s' ma nieuzgodniony typ dokumentu '%s'.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' ma nieuzgodniony typ dokumentu '%s'.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok, strTypUZG
	sMessTekst2 = strKodDok
	sMessTekst2 = sMessTekst2 + using " Nieuzgodniony typ dokumentu '%s'.", strTypUZG

	if nBrakTypDK == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		if !defdok.MoveTo(strTypDK) then // brak schematu
			AddError(sMessTekst2, idDK)
		endif
		CzyIntegrBrakTypDK = 0
		Exit
	endif

	if !defdok.MoveTo(strTypDK) then // brak schematu
		if nBrakTypDK == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
			AddError(sMessTekst2, idDK)
			CzyIntegrBrakTypDK = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddError(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // przerwij
			CzyIntegrBrakTypDK = -6000
			Exit
		endif

		// pozostałe pomiń...
		CzyIntegrBrakTypDK = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBrakTypDK = POMIN_WSZYSTKIE
		endif
	endif
	if CzyIntegrBrakTypDK then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

///////////////////////////////////////////////////////////////////////
//Zablokowanie wysylania dokumentu zlotowkowego jako faktura walutowa
int nBlednyTypFK2 = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrBlednyTypFK2(string strTypDK, string strKodDok, long idDK, string strTypUZG)
//---------------------------------------------------------------------------
	CzyIntegrBlednyTypFK2 = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Dokument '%s' ma błędnie uzgodniony typ dokumentu '%s'.\nDokument złotówkowy nie może być wysłany do FK jako faktura walutowa.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' ma błędnie uzgodniony typ dokumentu '%s'.\nDokument złotówkowy nie może być wysłany do FK jako faktura walutowa.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok, strTypUZG
	sMessTekst2 = strKodDok
	sMessTekst2 = sMessTekst2 + using " Błędnie uzgodniony typ dokumentu '%s'.", strTypUZG

	if nBlednyTypFK2 == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		AddError(sMessTekst2, idDK)
		CzyIntegrBlednyTypFK2 = 0
		Exit
	endif

	if nBlednyTypFK2 == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
		AddError(sMessTekst2, idDK)
		CzyIntegrBlednyTypFK2 = 1
		Exit
	endif

	/////////////////////////////////////////////////////////////////////////
	// Pytamy się użytkownika
	err = Message(sMessTekst)
	AddError(sMessTekst2, idDK)

	if err == 1 || err == (1+16) then // przerwij
		CzyIntegrBlednyTypFK2 = -6000
		Exit
	endif

	// pozostałe pomiń...
	CzyIntegrBlednyTypFK2 = 1
	if err == (5+16) then // pomiń dla wszystkich
		nBlednyTypFK2 = POMIN_WSZYSTKIE
	endif

	if CzyIntegrBlednyTypFK2 then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub


//////////////////////////////////////////////////////////////////////////////////////////
// Czy wysyłać faktury walutowe z roznym kursem VAT i CIT/PIT jako stare (nie walutowe) dokumenty FK
int nBlednyTypFK = PYTAJ_UZYTK

//-----------------------------------------------------------------------------------------------------
int Sub CzyIntegrBlednyTypFK(int iTypFK,string strTypDK, string strKodDok, long idDK, string strTypUZG)
//-----------------------------------------------------------------------------------------------------
	CzyIntegrBlednyTypFK = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Ze względu na różnice kursowe, dokument '%s' ma błędnie uzgodniony typ dokumentu '%s'.{{icon=? buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
	else
		sMessTekst = "Ze względu na różnice kursowe, dokument '%s' ma błędnie uzgodniony typ dokumentu '%s'.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok, strTypUZG
	sMessTekst2 = strKodDok
	sMessTekst2 = sMessTekst2 + using " Błędnie uzgodniony typ dokumentu '%s'.", strTypUZG

	if nBlednyTypFK == Integr_WSZYSTKIE then // nie sprawdzamy
		if iTypFK then // nieprawidlowy typFK
			AddInfo(sMessTekst2, idDK)
		endif
		CzyIntegrBlednyTypFK = 0
		Exit
	endif
	
	if iTypFK then // nieprawidlowy typFKu
		if nBlednyTypFK == POMIN_WSZYSTKIE then // nie wysyłamy
			AddInfo(sMessTekst2, idDK)
			AddError(strKodDok + " Nie został wysłany",idDK)
			CzyIntegrBlednyTypFK = 1
			Exit
		endif
		
		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddAsk(sMessTekst, err, idDK)

		if err == 1 || err == (1+16) then // wysyłaj
			CzyIntegrBlednyTypFK = 0
			if err == (1+16) then // dla wszystkich
				nBlednyTypFK = Integr_WSZYSTKIE
			endif
			Exit
		endif

		// pozostałe pomiń...
		CzyIntegrBlednyTypFK = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBlednyTypFK = POMIN_WSZYSTKIE
		endif
	endif
	if CzyIntegrBlednyTypFK then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

/////////////////////////////////////////////////////////
int nBlednyRej = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyintegrBlednyRej(long idRej, string strKodDok, long idDK, Int zbiorczy)
//---------------------------------------------------------------------------
	CzyintegrBlednyRej = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Dokument '%s' nie ma uzgodnionego rejestru bądź ma błędnie uzgodniony.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' nie ma uzgodnionego rejestru bądź ma błędnie uzgodniony.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok
	sMessTekst2 = strKodDok+" Błędnie bądź w ogóle nieuzgodniony rejestr."

	if nBlednyRej == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		if idRej == 0 then // brak schematu
			AddError(sMessTekst2, idDK)
		endif
		CzyintegrBlednyRej = 0
		Exit
	endif

	if idRej == 0 then // brak schematu
		if nBlednyRej == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
			AddError(sMessTekst2, idDK)
			CzyintegrBlednyRej = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddError(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // przerwij
			CzyintegrBlednyRej = -6000
			Exit
		endif

		// pozostałe pomiń...
		CzyintegrBlednyRej = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBlednyRej = POMIN_WSZYSTKIE
		endif
	endif

	if CzyintegrBlednyRej then AddError(IIF(zbiorczy, "Dokument zbiorczy", strKodDok) + " nie został wysłany",idDK)
EndSub

/////////////////////////////////////////////////////////
int nBrakRej = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyintegrBrakRej(int intRej, string strKodDok, long idDK)
//---------------------------------------------------------------------------
	CzyintegrBrakRej = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Dokument '%s' ma nieokreślony rejestr.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument '%s' ma nieokreślony rejestr.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strKodDok
	sMessTekst2 = strKodDok+" Nieokreślony rejestr."

	if nBrakRej == Integr_WSZYSTKIE then // nie sprawdzamy
		if intRej then // brak
			AddError(sMessTekst2, idDK)
		endif
		CzyintegrBrakRej = 0
		Exit
	endif

	if intRej then // brak schematu
		if nBrakRej == POMIN_WSZYSTKIE then // nie wysyłamy
			AddError(sMessTekst2, idDK)
			CzyintegrBrakRej = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddError(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // przerwij
			CzyintegrBrakRej = -6000
			Exit
		endif

		// pozostałe pomiń...
		CzyintegrBrakRej = 1
		if err == (5+16) then // pomiń dla wszystkich
			nBrakRej = POMIN_WSZYSTKIE
		endif
	endif

	if CzyintegrBrakRej then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

//////////////////////////////////////////////////////////////////////////////////////////
// Czy wysyłać stare dokumenty do bufora FKF, bo fo RDF sie nie da

int nSenttoFK = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub CzyIntegrSentToFK(string strKodDok, long idDK)
//---------------------------------------------------------------------------
	CzyIntegrSentToFK = 0

	int err
	string sMessTekst
	string sMessTekst2
	
	if iSingleOper then
		sMessTekst = "Dokument nie został zapisany w Repozytorium Dokumentów.\nDekretacja zostanie zapisana bezpośrednio w buforze programu Finanse i Księgowość.{{icon=? buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
	else
		sMessTekst = "Dokument nie został zapisany w Repozytorium Dokumentów.\nDekretacja zostanie zapisana bezpośrednio w buforze programu Finanse i Księgowość.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
		
	sMessTekst = using sMessTekst, strKodDok
	sMessTekst2 = strKodDok+" nie został zapisany w Repozytorium Dokumentów."

	if nSenttoFK == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		AddWarning(sMessTekst2, idDK)
		CzyIntegrSentToFK = 0
		Exit
	endif

	if nSenttoFK == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
		AddWarning(sMessTekst2, idDK)
		CzyIntegrSentToFK = 1
		Exit
	endif

	/////////////////////////////////////////////////////////////////////////
	// Pytamy się użytkownika
	err = Message(sMessTekst)
	AddWarning(sMessTekst2, idDK)

	if err == 1 || err == (1+16) then // wysyłaj
		CzyIntegrSentToFK = 0
		if err == (1+16) then // dla wszystkich
			nSenttoFK = Integr_WSZYSTKIE
		endif
		Exit
	endif

	// pozostałe pomiń...
	CzyIntegrSentToFK = 1
	if err == (5+16) then // pomiń dla wszystkich
		nSenttoFK = POMIN_WSZYSTKIE
	endif


	if CzyIntegrSentToFK then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

/////////////////////////////////////////////////////////
int nYearClosed = PYTAJ_UZYTK

//---------------------------------------------------------------------------
int Sub ZamknietyRok(int intRok, string strKodDok, string strData, long idDK)
//---------------------------------------------------------------------------
	ZamknietyRok = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Rok obrachunkowy w programie FK z datą '%s'jest niedostępny.\nDokument '%s' nie zostanie wysłany.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Rok obrachunkowy w programie FK z datą '%s'jest niedostępny.\nDokument '%s' nie zostanie wysłany.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[P&rzerwij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strData, strKodDok
	sMessTekst2 = strKodDok+" Niedostępny rok obrachunkowy."

	if nYearClosed == Integr_WSZYSTKIE then // nie sprawdzamy
		if intRok then // brak
			AddError(sMessTekst2, idDK)
		endif
		ZamknietyRok = 0
		Exit
	endif

	if intRok then // zamkniety rok
		if nYearClosed == POMIN_WSZYSTKIE then // nie wysyłamy
			AddError(sMessTekst2, idDK)
			ZamknietyRok = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddError(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // przerwij
			ZamknietyRok = -6000
			Exit
		endif

		// pozostałe pomiń...
		ZamknietyRok = 1
		if err == (5+16) then // pomiń dla wszystkich
			nYearClosed = POMIN_WSZYSTKIE
		endif
	endif

	if ZamknietyRok then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub

int nYearClosed2 = PYTAJ_UZYTK
//---------------------------------------------------------------------------
int Sub ZamknietyRok2(int intRok, string strKodDok, string strData, long idDK, int bSP)
//---------------------------------------------------------------------------
	ZamknietyRok2 = 0

	int err
	string sMessTekst
	string sMessTekst2

	if iSingleOper then
		sMessTekst = "Rok obrachunkowy z datą '%s'jest niedostępny w programie FK.{{title=(Integracja danych)}}"
	else
		sMessTekst = "Rok obrachunkowy z datą '%s'jest niedostępny w programie FK.\nDokument '%s' zostanie umieszczony w roku wynikającym z daty %s dokumentu.{{icon=? check=(&Zastosuj dla wszystkich) buttons=[&Wyślij:o](&Pomiń:i)  title=(Integracja danych)}}"
	endif
	
	sMessTekst = using sMessTekst, strData, strKodDok, IIF(bSP, "wystawienia", "wpływu")
	sMessTekst2 = strKodDok+" Niedostępny rok obrachunkowy."

	if 	nYearClosed2 == Integr_WSZYSTKIE then // nie sprawdzamy czy brak schematu
		if intRok then // brak schematu
			AddWarning(sMessTekst2, idDK)
		endif
		ZamknietyRok2 = 0
		Exit
	endif

	if intRok then // brak schematu
		if nYearClosed2 == POMIN_WSZYSTKIE then // nie wysyłamy z brakującym schematem
			AddWarning(sMessTekst2, idDK)
			ZamknietyRok2 = 1
			Exit
		endif

		/////////////////////////////////////////////////////////////////////////
		// Pytamy się użytkownika
		err = Message(sMessTekst)
		AddWarning(sMessTekst2, idDK)

		if err == 1 || err == (1+16) then // wysyłaj
			ZamknietyRok2 = 0
			if err == (1+16) then // dla wszystkich
				nYearClosed2 = Integr_WSZYSTKIE
			endif
			Exit
		endif

		// pozostałe pomiń...
		ZamknietyRok2 = 1
		if err == (5+16) then // pomiń dla wszystkich
			nYearClosed2 = POMIN_WSZYSTKIE
		endif
	endif

	if ZamknietyRok2 then AddError(strKodDok + " Nie został wysłany",idDK)
EndSub
#include "Integracja definicje 2 - include"

// ==============================          ZBIORCZE          ==============================
// Integracja z FK
// Zbiorcze dokumenty i zbiorcza dekretacji
// Definicje i struktury danych wspolne dla MG, SP, ZK

#define DEKRETY_ZBIORCZE		0x1
#define ROWNOLEGLE_KSIEG_MAG	0x8

Record DokId
	Long lDokId
EndRec

DokId listaDokId(1)

Float  dWartoscDok
Int    nCount = 1
String terminplat
String zbiorczyTermin
String zbiorczaTresc