<?xml version="1.0" encoding="UTF-8"?>
<Export generator="Cache" version="25" zv="Cache for Windows (x86-64) 2011.1.2 (Build 701U)" ts="2011-12-06 08:27:25">
<Class name="DBDebiKredi.AF.DebitorAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61437,49014.356727</TimeCreated>

<Query name="ListeRootZahlenAUTO6">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT {fn CONVERT(d.Adresse->Adressnummer / 100000, SQL_INTEGER)} As Ziffer 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	ORDER BY Ziffer]]></SqlQuery>
</Query>

<Query name="ListeRootZahlenAUTO8">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT {fn CONVERT(d.Adresse->Adressnummer / 10000000, SQL_INTEGER)} As Ziffer 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	ORDER BY Ziffer]]></SqlQuery>
</Query>

<Query name="ListeVonRootZahlAUTO6">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Ziffer:%Integer,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adressnummer, d.Adresse->Adresscode, 
	   	   d.Adresse->Name, d.Adresse->VornameZusatz1, d.Adresse->Plz, 
	   	   d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND {fn CONVERT(d.Adresse->Adressnummer / 100000, SQL_INTEGER)} = :Ziffer 
	ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeVonRootZahlAUTO8">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Ziffer:%Integer,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adressnummer, d.Adresse->Adresscode, 
	       d.Adresse->Name, d.Adresse->VornameZusatz1, 
		   d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND {fn CONVERT(d.Adresse->Adressnummer / 10000000, SQL_INTEGER)} = :Ziffer 
	ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeFortlaufendeManuelleAdrnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adressnummer, d.Adresse->Adresscode, 
		   d.Adresse->Name, d.Adresse->VornameZusatz1, d.Adresse->Plz, 
		   d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeRootEintraegeStandard">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT {fn LEFT({fn UCASE(d.Adresse->Name)},1)} As Ziffer 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND (({fn ASCII({fn UCASE(d.Adresse->Name)})} > 47 AND {fn ASCII({fn UCASE(d.Adresse->Name)})} < 58) 
	OR ({fn ASCII({fn UCASE(d.Adresse->Name)})} >= 65 AND {fn ASCII({fn UCASE(d.Adresse->Name)})} <= 90)) 
	ORDER BY Ziffer]]></SqlQuery>
</Query>

<Query name="GetFirstAdressId">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT TOP 1 d.Adresse->ID 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis 
	ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeNachNormalBuchstaben">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Letter:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid 
    AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis 
    AND {fn LEFT({fn UCASE(d.Adresse->Name)},1)} = :Letter 
    ORDER By d.Adresse->Name]]></SqlQuery>
</Query>

<Query name="ListeNachLetterA">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND (ASCII({fn UCASE(d.Adresse->Name)}) = 65 
	OR (ASCII({fn UCASE(d.Adresse->Name)}) >=192 
	AND ASCII({fn UCASE(d.Adresse->Name)}) <=198)) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterE">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(d.Adresse->Name)})} = 69 
	OR (ASCII({fn UCASE(d.Adresse->Name)}) >=200 
	AND ASCII({fn UCASE(d.Adresse->Name)}) <=203)) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterI">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(d.Adresse->Name)})} = 73 
	OR (ASCII({fn UCASE(d.Adresse->Name)}) >=204 
	AND ASCII({fn UCASE(d.Adresse->Name)}) <=207)) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterO">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(d.Adresse->Name)})} = 79 
	OR (ASCII({fn UCASE(d.Adresse->Name)}) >=210
	AND ASCII({fn UCASE(d.Adresse->Name)}) <=214)) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterU">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(d.Adresse->Name)})} = 85 
	OR (ASCII({fn UCASE(d.Adresse->Name)}) >=217 
	AND ASCII({fn UCASE(d.Adresse->Name)}) <=220)) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeNachNummern">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.Adresse->ID, d.Adresse->Adresscode, d.Adresse->Name, 
		   d.Adresse->VornameZusatz1, d.Adresse->Plz, d.Adresse->Ort 
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(d.Adresse->Name)})} > 47 
	AND {fn ASCII({fn UCASE(d.Adresse->Name)})} < 58) 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeKunden">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Adressnummer, 
		   d.Adresse->Adresscode, d.Adresse->Name, d.Adresse->VornameZusatz1, 
		   d.Adresse->Plz, d.Adresse->Ort, 
		   trim((str(d.Adresse->Adressnummer) || ' - ' || d.Adresse->Name || ', ' || d.Adresse->Plz || ' ' || d.Adresse->Ort)) As DisplayText
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid 
	AND d.Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Adressnummer, 
		   d.Adresse->Adresscode, d.Adresse->Name, d.Adresse->VornameZusatz1, 
		   d.Adresse->Plz, d.Adresse->Ort, 
		   trim((str(d.Adresse->Adressnummer) || ' - ' || d.Adresse->Name || ', ' || d.Adresse->Plz || ' ' || d.Adresse->Ort)) As DisplayText
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid
	ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeVZ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT d.ID As DebiId, d.Adresse->ID As AdrId,
		   trim(str(d.Adresse->Adressnummer)) As Adressnummer, trim(d.Adresse->Name || ', ' || d.Adresse->Plz || ' ' || d.Adresse->Ort) As DisplayText
	FROM DBDebiKredi.Debitor d 
	WHERE d.Mandant = :MandantOid
	AND LENGTH(d.WebEdiId) > 0
	ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeVZVonBis">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonAdrNr:%Integer,BisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT d.ID As DebiId, d.Adresse->ID As AdrId,
    		trim(str(d.Adresse->Adressnummer)) As Adressnummer, 
    		trim(d.Adresse->Name || ', ' || d.Adresse->Plz || ' ' || d.Adresse->Ort) As DisplayText
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid
    		AND LENGTH(d.WebEdiId) > 0
    		AND d.Adresse->Adressnummer BETWEEN :VonAdrNr AND :BisAdrNr
    ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeHogaShopExport">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,nurAktivierte:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Adressnummer, 
        d.Adresse->Adresscode, d.Adresse->Name, d.Adresse->VornameZusatz1, 
        d.Adresse->Strasse || ' ' || NVL(d.Adresse->Hausnummer,'') AS Strasse, d.Adresse->Plz, d.Adresse->Ort,
        d.Adresse->Kundengruppe->Code As Kundengruppe,
        KundenNrHogaShop,
		d.Adresse->EMail AS EMail, 
		d.Adresse->Fax AS Fax, 
		d.Adresse->Telefon1 AS Telefon1
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid AND (NVL(HogaShopAktiv,0) = 1 OR :nurAktivierte = 0)
    ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeHogaShopCustomersByKG">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,kgOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Adressnummer, 
          KundenNrHogaShop 
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid AND d.Adresse->Kundengruppe = :kgOid AND NVL(HogaShopAktiv,0) = 1
    ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeHogaShopCustomersByPK">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PkOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Adressnummer, 
          KundenNrHogaShop 
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid AND d.Adresse->Preiskategorie = :PkOid AND NVL(HogaShopAktiv,0) = 1
    ORDER BY d.Adresse->NAME]]></SqlQuery>
</Query>

<Query name="ListeHogaShopAddresses">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonAdrNr:%Integer,BisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT d.ID As DebiId, d.Adresse->ID As AdressId, d.Adresse->Kundengruppe As KundenGrOid
    FROM DBDebiKredi.Debitor d 
    WHERE d.Mandant = :MandantOid AND 
    d.Adresse->Adressnummer Between :VonAdrNr AND :BisAdrNr AND 
    NVL(HogaShopAktiv,0) = 1
    ORDER BY d.Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeKundenumsatz">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,mandjahrOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Adresse As "Adresse.ID",
		Adresse->Adressnummer As "Adresse.Adressnummer",
		Adresse->Kurzname As "Adresse.Kurzname",
		DBAdressen.Adresse_GetName(Adresse->Adresscode, Adresse->Name, Adresse->VornameZusatz1, 0) As "Adresse.Name",
		Adresse->Plz As "Adresse.Plz",
		Adresse->Ort As "Adresse.Ort",
		{fn CONVERT(NVL(DBDebiKredi.Debitor_GetUmsatzSollPeriodeVjEwClass(ID,:mandjahrOid,:vonPeriode,:bisPeriode),0), SQL_DOUBLE)} As UmsatzVorjahr, 
		{fn CONVERT(NVL(DBDebiKredi.Debitor_GetUmsatzSollPeriodeEwClass(ID,:mandjahrOid,:vonPeriode,:bisPeriode),0), SQL_DOUBLE)} As UmsatzLaufJahr, 
		{fn CONVERT(NVL(DBDebiKredi.Debitor_GetSaldoEwClass(ID,:mandjahrOid,NULL),0), SQL_DOUBLE)} As Saldo 
	FROM DBDebiKredi.Debitor 
	WHERE Mandant=:MandantOid AND Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis
	ORDER BY Adresse->Adressnummer]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.DebitorUmsatzAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61492,42860.305518</TimeCreated>

<Query name="ListeWaehrungen">
<Type>%SQLQuery</Type>
<FormalSpec>DebitorOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Waehrung->ID,
			Waehrung->FWCode,
			Waehrung->Faktor,
			Waehrung->KursAnkauf,
			Waehrung->KursVK,
			Waehrung->Waehrung,
			DBFibu_SD.Fremdwaehrung_GetBezeichnungClass(Waehrung->ID, :MandantOid, :Lang) As Bezeichnung,
		   	Waehrung->ISOSWIFTCode
 	FROM DBDebiKredi.DebitorUmsatz
 	WHERE Debitor=:DebitorOid
 	GROUP BY Waehrung
 	ORDER BY FWCode]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.KreditorAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61437,33472.668704</TimeCreated>

<Query name="ListeProduzenten">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery> 
     SELECT k.ID As KrediId, a.ID As AdressId, NVL(a.Adressnummer,0) As Adressnummer, NVL(a.Adresscode,0) As Adresscode, NVL(a.Name,'') As Name, NVL(a.VornameZusatz1,'') As VornameZusatz1, NVL(a.Plz,'') As Plz, NVL(a.Ort,'') As Ort, 
     trim((str(NVL(a.Adressnummer,0)) || ' - ' || NVL(a.Name,'') || ', ' || NVL(a.Plz,'') || ' ' || NVL(a.Ort,''))) As DisplayText, 
     trim(NVL(a.Name,'') || ', ' || NVL(a.Plz,'') || ' ' || NVL(a.Ort,'')) As DisplayText2 
     FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis  AND NVL(AuftragErfassungInaktiv, 0) = 0
     ORDER BY a.NAME</SqlQuery>
</Query>

<Query name="ListeRootZahlenAUTO6">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT DISTINCT {fn CONVERT(a.Adressnummer / 100000, SQL_INTEGER)} As Ziffer FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 ORDER BY Ziffer</SqlQuery>
</Query>

<Query name="ListeRootZahlenAUTO8">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT DISTINCT {fn CONVERT(a.Adressnummer / 10000000, SQL_INTEGER)} As Ziffer FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 ORDER BY Ziffer</SqlQuery>
</Query>

<Query name="ListeVonRootZahlAUTO6">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Ziffer:%Integer,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>SELECT a.ID, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 AND {fn CONVERT(a.Adressnummer / 100000, SQL_INTEGER)} = :Ziffer ORDER BY a.Adressnummer</SqlQuery>
</Query>

<Query name="ListeVonRootZahlAUTO8">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Ziffer:%Integer,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>SELECT a.ID, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 AND {fn CONVERT(a.Adressnummer / 10000000, SQL_INTEGER)} = :Ziffer ORDER BY a.Adressnummer</SqlQuery>
</Query>

<Query name="ListeFortlaufendeManuelleAdrnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>SELECT a.ID, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 ORDER BY a.Adressnummer</SqlQuery>
</Query>

<Query name="ListeRootEintraegeStandard">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[SELECT DISTINCT {fn LEFT({fn UCASE(a.Name)},1)} As Ziffer FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
AND (({fn ASCII({fn UCASE(a.Name)})} > 47 AND {fn ASCII({fn UCASE(a.Name)})} < 58) 
OR ({fn ASCII({fn UCASE(a.Name)})} >= 65 AND {fn ASCII({fn UCASE(a.Name)})} <= 90)) ORDER BY Ziffer]]></SqlQuery>
</Query>

<Query name="GetFirstAdressId">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT TOP 1 a.ID FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis ORDER BY Adressnummer</SqlQuery>
</Query>

<Query name="ListeNachNormalBuchstaben">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Letter:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse  AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND {fn LEFT({fn UCASE(a.Name)},1)} = :Letter ORDER By a.Name</SqlQuery>
</Query>

<Query name="ListeNachLetterA">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND (ASCII({fn UCASE(a.Name)}) = 65 OR (ASCII({fn UCASE(a.Name)}) >=192 AND ASCII({fn UCASE(a.Name)}) <=198)) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterE">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(a.Name)})} = 69 OR (ASCII({fn UCASE(a.Name)}) >=200 AND ASCII({fn UCASE(a.Name)}) <=203)) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterI">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(a.Name)})} = 73 OR (ASCII({fn UCASE(a.Name)}) >=204 AND ASCII({fn UCASE(a.Name)}) <=207)) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterO">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(a.Name)})} = 79 OR (ASCII({fn UCASE(a.Name)}) >=210 AND ASCII({fn UCASE(a.Name)}) <=214)) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeNachLetterU">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(a.Name)})} = 85 OR (ASCII({fn UCASE(a.Name)}) >=217 AND ASCII({fn UCASE(a.Name)}) <=220)) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeNachNummern">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT a.ID, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
	AND ({fn ASCII({fn UCASE(a.Name)})} > 47 AND {fn ASCII({fn UCASE(a.Name)})} < 58) ORDER BY a.NAME]]></SqlQuery>
</Query>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT k.ID As KrediId, a.ID As AdressId, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort, trim((str(a.Adressnummer) || ' - ' || a.Name || ', ' || a.Plz || a.Ort)) As DisplayText
	FROM DBAdressen.Adresse a,  DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse
	ORDER BY a.NAME</SqlQuery>
</Query>

<Query name="ListeProduzentenNr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>     SELECT k.ID As KrediId, a.ID As AdressId, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort, trim((str(a.Adressnummer) || ' - ' || a.Name || ', ' || a.Plz || ' ' || a.Ort)) As DisplayText, 
     trim(a.Name || ', ' || a.Plz || ' ' || a.Ort) As DisplayText2 
     FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse AND a.Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis AND NVL(AuftragErfassungInaktiv, 0) = 0 
     ORDER BY a.Adressnummer</SqlQuery>
</Query>

<Query name="ListeProduzentenNrByGruppe">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,LieferGrp:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>     SELECT k.ID As KrediId, a.ID As AdressId, a.Adressnummer, a.Adresscode, a.Name, a.VornameZusatz1, a.Plz, a.Ort, trim((str(a.Adressnummer) || ' - ' || a.Name || ', ' || a.Plz || ' ' || a.Ort)) As DisplayText, 
     trim(a.Name || ', ' || a.Plz || ' ' || a.Ort) As DisplayText2 
     FROM DBAdressen.Adresse a, DBDebiKredi.Kreditor k 
     WHERE k.Mandant = :MandantOid AND a.ID = k.Adresse 
     AND a.Lieferantengruppe = :LieferGrp
     AND NVL(AuftragErfassungInaktiv, 0) = 0 
     ORDER BY a.Adressnummer</SqlQuery>
</Query>

<Query name="ListeLieferantenumsatz">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,mandjahrOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Adresse As "Adresse.ID",
		Adresse->Adressnummer As "Adresse.Adressnummer",
		Adresse->Kurzname As "Adresse.Kurzname",
		DBAdressen.Adresse_GetName(Adresse->Adresscode, Adresse->Name, Adresse->VornameZusatz1, 0) As "Adresse.Name",
		Adresse->Plz As "Adresse.Plz",
		Adresse->Ort As "Adresse.Ort",
		{fn CONVERT(NVL(DBDebiKredi.Kreditor_GetUmsatzSollPeriodeVjEwClass(ID,:mandjahrOid,:vonPeriode,:bisPeriode),0), SQL_DOUBLE)} As UmsatzVorjahr, 
		{fn CONVERT(NVL(DBDebiKredi.Kreditor_GetUmsatzSollPeriodeEwClass(ID,:mandjahrOid,:vonPeriode,:bisPeriode),0), SQL_DOUBLE)} As UmsatzLaufJahr, 
		{fn CONVERT(NVL(DBDebiKredi.Kreditor_GetSaldoEwClass(ID,:mandjahrOid,NULL),0), SQL_DOUBLE)} As Saldo 
	FROM DBDebiKredi.Kreditor 
	WHERE Mandant=:MandantOid AND Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis
	ORDER BY Adresse->Adressnummer]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.KreditorUmsatzAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61494,50684.96687</TimeCreated>

<Query name="ListeWaehrungen">
<Type>%SQLQuery</Type>
<FormalSpec>KreditorOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Waehrung->ID,
			Waehrung->FWCode,
			Waehrung->Faktor,
			Waehrung->KursAnkauf,
			Waehrung->KursVK,
			Waehrung->Waehrung,
			DBFibu_SD.Fremdwaehrung_GetBezeichnungClass(Waehrung->ID, :MandantOid, :Lang) As Bezeichnung,
		   	Waehrung->ISOSWIFTCode
 	FROM DBDebiKredi.KreditorUmsatz
 	WHERE Kreditor=:KreditorOid
 	GROUP BY Waehrung
 	ORDER BY FWCode]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.OPAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>62143,50098.343578</TimeCreated>

<Query name="ListeOpByVerrechnungsnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VerrechnungsNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			FibuBuchung AS FibuBuchung
		FROM DBDebiKredi.OP 
		WHERE VerrechnungsNr=:VerrechnungsNr AND
			(ID IN (SELECT ID 
				FROM DBDebiKredi.OPKredi 
				WHERE Kreditor->Mandant=:MandantOid)
			OR ID IN (SELECT ID 
				FROM DBDebiKredi.OPDebi 
				WHERE Debitor->Mandant=:MandantOid))]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.OPDebiAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61390,42852.803783</TimeCreated>

<Query name="ListeOffene">
<Type>%SQLQuery</Type>
<FormalSpec>DebiOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			Saldo,
			FWSaldo,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			Debitor->Adresse As "Adresse",
			Debitor->Adresse->Adressnummer As "Adressnummer",
			Debitor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Name",
			Debitor->Adresse->Plz As "Plz",
			Debitor->Adresse->Ort As "Ort",
			Zahlungskondition,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			FibuBuchungsart
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor=:DebiOid AND IsOPgeschlossen<>1 	
 	ORDER BY Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlle">
<Type>%SQLQuery</Type>
<FormalSpec>DebiOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			BetragExklMwst,
			BetragInklMwst,
			BetragMwst,
			FWBetrag,
			0 As Skontoabzug,
			0 As FWSkontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			0 As "IsZahlung",
			0 As "Verbuchungsjnr",
			0 As "VerbuchungsjnrManuell",
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			FibuBuchungsart
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor=:DebiOid
 	
 	UNION ALL 
 	SELECT  ID,
			BelegNr,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragExklMwst,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			0 As BetragMwst,
			FWZahlbetrag As FWBetrag,
			Skontoabzug,
			FWSkontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			0 As "Mahnstufe",
			FibuKonto->KontoNr As "KontoNr",
			1 As "IsZahlung",
			Verbuchungsjnr,
			VerbuchungsjnrManuell,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			0 As FibuBuchungsart
 	FROM DBDebiKredi.Zahlung
 	WHERE ID IN (SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID FROM DBDebiKredi.OPDebi WHERE Debitor=:DebiOid))
 	
 	ORDER BY Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeSuche">
<Type>%SQLQuery</Type>
<FormalSpec>Buchungstext:%String,BelegNr:%String,BetragExakt:%Decimal(SCALE=5),BetragVon:%Decimal(SCALE=5),BetragBis:%Decimal(SCALE=5),ValutadatumVon:%Date,ValutadatumBis:%Date,BelegdatumVon:%Date,BelegdatumBis:%Date,MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			DBDebiKredi.OP_BetragExklMwstClass(ID) AS BetragExklMwst,
			DBDebiKredi.OP_BetragInklMwstClass(ID) AS BetragInklMwst,
			DBDebiKredi.OP_BetragMwstClass(ID) AS BetragMwst,
			DBDebiKredi.OP_CalcSaldoClass(ID) AS Saldo,
			0 As Skontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			0 As "IsZahlung",
			0 As "Verbuchungsjnr",
			FibuBuchungsart
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			(Buchungstext1 LIKE :Buchungstext OR :Buchungstext = '') AND
			(BelegNr LIKE :BelegNr OR :BelegNr = '') AND
			(DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragInklMwstClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragExklMwstClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragMwstClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(DBDebiKredi.OP_CalcSaldoClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR DBUtils.NumberUtils_Round(:BetragExakt,2) = 0) AND
			((DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragInklMwstClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragInklMwstClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragExklMwstClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragExklMwstClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragMwstClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.OP_BetragMwstClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(DBDebiKredi.OP_CalcSaldoClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.OP_CalcSaldoClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(:BetragVon,2) = 0 AND DBUtils.NumberUtils_Round(:BetragBis,2) = 0)) AND
			(Valutadatum BETWEEN {d :ValutadatumVon} AND {d :ValutadatumBis}) AND
			(Belegdatum BETWEEN {d :BelegdatumVon} AND {d :BelegdatumBis})
 	
 	UNION ALL 
 	SELECT  ID,
			BelegNr,
			(NVL(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),0)+NVL(DBDebiKredi.Zahlung_GetKursdifferenzClass(ID),0)) As BetragExklMwst,
			(NVL(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),0)+NVL(DBDebiKredi.Zahlung_GetKursdifferenzClass(ID),0)) As BetragInklMwst,
			0 As BetragMwst,
			0 As Saldo,
			DBDebiKredi.Zahlung_GetSkontoabzugClass(ID) AS Skontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			0 As "Mahnstufe",
			FibuKonto->KontoNr As "KontoNr",
			1 As "IsZahlung",
			Verbuchungsjnr,
			0 As FibuBuchungsart
 	FROM DBDebiKredi.Zahlung
 	WHERE ID IN (SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID FROM DBDebiKredi.OPDebi WHERE Debitor->Mandant=:MandantOid)) AND
 			(Buchungstext1 LIKE :Buchungstext OR :Buchungstext = '') AND
			(BelegNr LIKE :BelegNr OR :BelegNr = '') AND
			(DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetSkontoabzugClass(ID),2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR DBUtils.NumberUtils_Round(:BetragExakt,2) = 0) AND
			((DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetSkontoabzugClass(ID),2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(DBDebiKredi.Zahlung_GetSkontoabzugClass(ID),2) <> 0) OR 
					(DBUtils.NumberUtils_Round(:BetragVon,2) = 0 AND DBUtils.NumberUtils_Round(:BetragBis,2) = 0)) AND
			(Valutadatum BETWEEN {d :ValutadatumVon} AND {d :ValutadatumBis}) AND
			(Belegdatum BETWEEN {d :BelegdatumVon} AND {d :BelegdatumBis})

 	ORDER BY Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="OPbyFibuBuchung">
<Type>%SQLQuery</Type>
<FormalSpec>buchungOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
			Debitor->Adresse->ID AS "AdressOid",
			Debitor->Adresse->Adressnummer AS "Adressnummer",
			Debitor->Adresse->Kurzname AS "Kurzname",
			Debitor->Adresse->Name AS "Name",
			Debitor->Adresse->Ort AS "Ort",
			Valutadatum,
			Belegdatum,
			Belegnr,
			BetragInklMwst,
			FWBetrag,
			Typ,
			FibuKonto,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Waehrung->FWCode As FWCode,
			Fibukonto->KontoNr As KontoNr
	FROM DBDebiKredi.OPDebi
	WHERE FibuBuchung=:buchungOid
	ORDER BY Fibukonto->KontoNr, Debitor->Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeMwstByCodes">
<Type>%SQLQuery</Type>
<FormalSpec>OpOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Mwst, 
			Mwst->MwstCode, 
			MwstSatz, 
			SUM(MwstBetrag) AS MwstBetrag, 
			SUM(BetragExklMwst) AS MwstBetragExkl,
			SUM(BetragInklMwst) AS MwstBetragInkl
	FROM DBDebiKredi.OPMwst
	WHERE OP=:OpOid
	GROUP BY Mwst ORDER BY MwstCode]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			ZKTage3 As "Zahlungskondition.TageNetto",
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr", 
			Saldo,
			FWSaldo,
			FWKurs,
			FWFaktor,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 	ORDER BY Debitor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleAdrPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.BelegNr,
			o.Buchungstext1,
			o.Buchungstext2,
			o.Valutadatum,
			o.Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(o.Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			o.ZKTage3 As "Zahlungskondition.TageNetto",
			o.Typ,
			o.Mahnstufe,
			o.FibuKonto->KontoNr As "KontoNr", 
			(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As Saldo,
			(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As FWSaldo,
			o.FWKurs,
			o.FWFaktor,
			o.Debitor->Adresse As "Adresse.ID",
			o.Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			o.Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(o.Debitor->Adresse->Adresscode, o.Debitor->Adresse->Name, o.Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			o.Debitor->Adresse->Strasse As "Adresse.Strasse",
			o.Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			o.Debitor->Adresse->Plz As "Adresse.Plz",
			o.Debitor->Adresse->Ort As "Adresse.Ort",
			o.Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			o.Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			o.Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			o.Vertreter->Code As "Vertreter.Code"
 	FROM DBDebiKredi.OPDebi o
 	WHERE o.Debitor->Mandant=:MandantOid AND 
 			o.Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	ORDER BY o.Debitor->Adresse->Adressnummer, o.Valutadatum, o.BelegNr]]></SqlQuery>
</Query>

<Query name="ListeVerfallAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,perDatum:%Date,abRgDatum:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Zahlungskondition->Code As "Zahlungskondition.Code",
			CASE WHEN :abRgDatum = 1 THEN DBDebiKredi.OPDebi_GetAlter(%ID, {d :perDatum}) ELSE DBDebiKredi.OPDebi_GetVerzugstage(%ID, {d :perDatum}) END AS Verzugstage,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			ZKTage3 As "Zahlungskondition.TageNetto",
			Typ,
			Mahnstufe,
			Saldo,
			FWSaldo,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			DBAdressen_SD.Vertreter_GetNameClass(Vertreter, :MandantOid, :Lang) As "Vertreter.Name",
			Vertreter->Code As "Vertreter.Code"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr
 	ORDER BY Debitor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,vonDatum:%Date,bisDatum:%Date,ohneVerrechnungen:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			0 As Skontoabzug,
			FWBetrag,
			0 As FWSkontoabzug,
			FWKurs,
			FWFaktor,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsZahlung",
			(SELECT ProjektIntern->Hauptnummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID) As "Projekt.Hauptnummer",
			(SELECT ProjektIntern->Teilnummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID) As "Projekt.Teilnummer"
 	FROM DBDebiKredi.OPDebi opd
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 			
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			Skontoabzug,
			FWZahlbetrag As FWBetrag,
			FWSkontoabzug,
			FWKurs,
			FWFaktor,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID",
			(SELECT Debitor->Adresse->Adressnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Adressnummer",
			(SELECT Debitor->Adresse->Kurzname FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Kurzname",
			(SELECT DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Name",
			(SELECT Debitor->Adresse->Strasse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Strasse",
			(SELECT Debitor->Adresse->Hausnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Hausnummer",
			(SELECT Debitor->Adresse->Plz FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Plz",
			(SELECT Debitor->Adresse->Ort FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Ort",
			(SELECT Debitor->Adresse->Telefon1 FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Telefon1",
			(SELECT Debitor->Fremdwaehrung->FWCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.FWCode",
			(SELECT Debitor->Fremdwaehrung->ISOSWIFTCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.ISOSWIFTCode",
			(SELECT Vertreter->Code FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Vertreter.Code",
			1 As "IsZahlung",
			'' As "Projekt.Hauptnummer",
			'' As "Projekt.Teilnummer"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi 
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0 OR 
 		VerrechnungsNr IN (SELECT NVL(Zahlung->VerrechnungsNr,0) 
 								FROM DBDebiKredi.OPZahlung
 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi)) OR
 		VerrechnungsNr IN (SELECT NVL(OP->VerrechnungsNr,0) 
 								FROM DBDebiKredi.OPZahlung
 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi))
 	)
 	
 	ORDER BY "Adresse.Adressnummer", Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAdrVortrag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,bisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(BetragInklMwst) AS Betrag, SUM(FWBetrag) AS FWBetrag, "Adresse.ID" FROM (
	SELECT 	
			CASE WHEN Typ = 0 THEN BetragInklMwst ELSE (-1)*BetragInklMwst END AS BetragInklMwst,
			CASE WHEN Typ = 0 THEN FWBetrag ELSE (-1)*FWBetrag END AS FWBetrag,
			Debitor->Adresse As "Adresse.ID"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum < {d :bisDatum}
 			
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)+NVL(Skontoabzug,0)) ELSE (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)+NVL(Skontoabzug,0)) END As BetragInklMwst,
			CASE WHEN Typ = 0 THEN (-1)*(NVL(FWZahlbetrag,0)+NVL(FWSkontoabzug,0)) ELSE (NVL(FWZahlbetrag,0)+NVL(FWSkontoabzug,0)) END As FWBetrag,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi 
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum < {d :bisDatum}
 	) GROUP BY "Adresse.ID"]]></SqlQuery>
</Query>

<Query name="ListeOffeneFibuKontoPerDatumJ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,o.FibuKonto) As "Konto.Bezeichnung", 
			SUM(CASE o.Typ
					WHEN 0 THEN	
						(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
					ELSE 
						(-1)*(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
				END) AS "Saldo",
			SUM(CASE o.Typ
					WHEN 0 THEN	
						(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0))
					ELSE 
						(-1)*(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0))
				END) AS "SaldoFW"

 	FROM DBDebiKredi.OPDebi o
 	WHERE o.Debitor->Mandant=:MandantOid AND 
 			o.Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	GROUP BY o.FibuKonto->KontoNr
 	ORDER BY o.FibuKonto->KontoNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneFibuKontoJahr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,FibuKonto) As "Konto.Bezeichnung", 
			SUM(CASE Typ
					WHEN 0 THEN	Saldo
					ELSE (-1)*Saldo 
				END) AS "Saldo",
			SUM(CASE Typ
					WHEN 0 THEN	FWSaldo
					ELSE (-1)*FWSaldo 
				END) AS "SaldoFW"

 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 	GROUP BY FibuKonto->KontoNr
 	ORDER BY FibuKonto->KontoNr]]></SqlQuery>
</Query>

<Query name="ListeMahnungenAdressen">
<Type>%SQLQuery</Type>
<FormalSpec>stichtag:%Date,karrenztage:%Integer,mandOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Debitor, 
			Debitor->Adresse->Adressnummer As "Adressnummer",
			Debitor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Name",
			DBAdressen.Adresse_GetZusatz1(Debitor->Adresse->Adresscode, Debitor->Adresse->VornameZusatz1) As "Adresszeile1", 
			Debitor->Adresse->Zusatz2 As "Zusatz2",
			Debitor->Adresse->Strasse As "Strasse",
			Debitor->Adresse->Hausnummer AS "Hausnummer",
			Debitor->Adresse->Plz As "Plz",
			Debitor->Adresse->Ort As "Ort", 
			DBDebiKredi_SD.Mahneinst_GetBelegNrByDebi(Debitor) As "Tabelle.BelegNr",
			DBDebiKredi_SD.Mahneinst_GetBelegArtByDebi(Debitor) As "Tabelle.BelegArt",
			DBDebiKredi_SD.Mahneinst_GetBelegdatumByDebi(Debitor) As "Tabelle.Belegdatum",
			DBDebiKredi_SD.Mahneinst_GetVerfalleneOPByDebi(Debitor) As "Tabelle.VerfalleneOP",
			DBDebiKredi_SD.Mahneinst_GetZahlungenBisByDebi(Debitor) As "Tabelle.ZahlungenBis",
			DBDebiKredi_SD.Mahneinst_GetFaelligByDebi(Debitor) As "Tabelle.Faellig",
			DBDebiKredi_SD.Mahneinst_GetVerzugByDebi(Debitor) As "Tabelle.Verzug",
			DBDebiKredi_SD.Mahneinst_GetBetragByDebi(Debitor) As "Tabelle.Betrag",
			DBDebiKredi_SD.Mahneinst_GetTotalOPByDebi(Debitor) As "Tabelle.TotalOP",
			DBDebiKredi_SD.Mahneinst_GetMahnArtByDebi(Debitor) As "Tabelle.MahnArt",
			DBDebiKredi_SD.Mahneinst_GetUebertragByDebi(Debitor) As "Tabelle.Uebertrag",
			DBDebiKredi_SD.Mahneinst_GetKundenNrByDebi(Debitor) As "Tabelle.KundenNr",
			DBDebiKredi_SD.Mahneinst_GetSeiteByDebi(Debitor) As "Tabelle.Seite",
			DBDebiKredi_SD.Mahneinst_GetTageByDebi(Debitor) As "Tabelle.Tage",
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByDebi(Debitor) As MahnArt, 
			DBDebiKredi_SD.Mahntyp_GetMahntextByDebi(Debitor) As Mahntext, 
			DBDebiKredi_SD.Mahneinst_GetEinschreibenByDebi(Debitor) As "Text.Einschreiben",
			DBDebiKredi_SD.Mahntyp_GetEinschreibenByDebi(Debitor) AS Einschreiben,
			Debitor->Fremdwaehrung->FWCode AS "Debitor.Fremdwaehrung.Code",
			Debitor->Fremdwaehrung->ISOSWIFTCode AS "Debitor.Fremdwaehrung.ISOSWIFT"
	FROM DBDebiKredi.OPDebi 
	WHERE DBDebiKredi.OPDebi_GetVerzugstage(ID,{d :stichtag}) > :karrenztage AND
			 Debitor->Mandant=:mandOid AND
			 Debitor->Adresse->Adressnummer >= :vonAdrNr AND Debitor->Adresse->Adressnummer <= :bisAdrNr
	GROUP BY Debitor
	ORDER BY Debitor->Adresse->Adressnummer, Belegdatum]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlle">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Debitor->Adresse As "Adresse",
			Debitor->Adresse->Adressnummer As "Adressnummer",
			Debitor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Name",
			Debitor->Adresse->Plz As "Plz",
			Debitor->Adresse->Ort As "Ort",
			Zahlungskondition,
			Typ
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1
 	ORDER BY Debitor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOPMwst">
<Type>%SQLQuery</Type>
<FormalSpec>OpOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID			
 	FROM DBDebiKredi.OPMwst
 	WHERE OP=:OpOid</SqlQuery>
</Query>

<Query name="ListeDiffSuche">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID			
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid
 	ORDER BY Debitor->Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeFaelligeOPsByAdresse">
<Type>%SQLQuery</Type>
<FormalSpec>stichtag:%Date,adrOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			BelegNr, 
			Belegdatum, 
			Buchungstext1
	FROM DBDebiKredi.OPDebi 
	WHERE IsOpGeschlossen=0 AND
			 Debitor->Adresse= :adrOid AND
			 DBDebiKredi.OPDebi_GetFaellig(ID) <= {d :stichtag}
	ORDER BY Belegdatum]]></SqlQuery>
</Query>

<Query name="ListeMahnungEinzelOPBau">
<Type>%SQLQuery</Type>
<FormalSpec>OpOid:%String,PerDatum:%Date,IndMahnText:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			Projektleitung, 
			Projektleitung->Adressnummer As "Projektleiter.Adressnummer",
			Projektleitung->Kurzname As "Projektleiter.Kurzname",
			DBAdressen.Adresse_GetName(Projektleitung->Adresscode, Projektleitung->Name, Projektleitung->VornameZusatz1, 0) As "Projektleiter.Name",
			DBAdressen.Adresse_GetZusatz1(Projektleitung->Adresscode, Projektleitung->VornameZusatz1) As "Projektleiter.Adresszeile1", 
			Offenposten->Debitor->Adresse->Zusatz2 As "Adresse.Zusatz2",
			Projektleitung->Strasse As "Projektleiter.Strasse",
			Projektleitung->Hausnummer AS "Projektleiter.Hausnummer",
			Projektleitung->Plz As "Projektleiter.Plz",
			Projektleitung->Ort As "Projektleiter.Ort", 
			
			Offenposten->Debitor, 
			Offenposten->Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Offenposten->Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Offenposten->Debitor->Adresse->Adresscode, Offenposten->Debitor->Adresse->Name, Offenposten->Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			DBAdressen.Adresse_GetZusatz1(Offenposten->Debitor->Adresse->Adresscode, Offenposten->Debitor->Adresse->VornameZusatz1) As "Adresse.Adresszeile1", 
			Offenposten->Debitor->Adresse->Strasse As "Adresse.Strasse",
			Offenposten->Debitor->Adresse->Hausnummer AS "Adresse.Hausnummer",
			Offenposten->Debitor->Adresse->Plz As "Adresse.Plz",
			Offenposten->Debitor->Adresse->Ort As "Adresse.Ort", 
			
			DBDebiKredi_SD.Mahneinst_GetBelegNrByDebi(Offenposten->Debitor) As "Tabelle.BelegNr",
			DBDebiKredi_SD.Mahneinst_GetBelegArtByDebi(Offenposten->Debitor) As "Tabelle.BelegArt",
			DBDebiKredi_SD.Mahneinst_GetBelegdatumByDebi(Offenposten->Debitor) As "Tabelle.Belegdatum",
			DBDebiKredi_SD.Mahneinst_GetVerfalleneOPByDebi(Offenposten->Debitor) As "Tabelle.VerfalleneOP",
			DBDebiKredi_SD.Mahneinst_GetZahlungenBisByDebi(Offenposten->Debitor) As "Tabelle.ZahlungenBis",
			DBDebiKredi_SD.Mahneinst_GetFaelligByDebi(Offenposten->Debitor) As "Tabelle.Faellig",
			DBDebiKredi_SD.Mahneinst_GetVerzugByDebi(Offenposten->Debitor) As "Tabelle.Verzug",
			DBDebiKredi_SD.Mahneinst_GetBetragByDebi(Offenposten->Debitor) As "Tabelle.Betrag",
			DBDebiKredi_SD.Mahneinst_GetTotalOPByDebi(Offenposten->Debitor) As "Tabelle.TotalOP",
			DBDebiKredi_SD.Mahneinst_GetMahnArtByDebi(Offenposten->Debitor) As "Tabelle.MahnArt",
			DBDebiKredi_SD.Mahneinst_GetUebertragByDebi(Offenposten->Debitor) As "Tabelle.Uebertrag",
			DBDebiKredi_SD.Mahneinst_GetKundenNrByDebi(Offenposten->Debitor) As "Tabelle.KundenNr",
			DBDebiKredi_SD.Mahneinst_GetSeiteByDebi(Offenposten->Debitor) As "Tabelle.Seite",
			DBDebiKredi_SD.Mahneinst_GetTageByDebi(Offenposten->Debitor) As "Tabelle.Tage",
			DBDebiKredi_SD.Mahneinst_GetMahngebuehrByDebi(Offenposten->Debitor) As "Tabelle.Mahngebuehr",
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByCode(Offenposten->Mahnstufe, Offenposten->Debitor->Mandant, Offenposten->Debitor->Adresse->Sprachcode) As MahnArt, 
			DBDebiKredi_SD.Mahntyp_GetMahngebuehrByCode(Offenposten->Mahnstufe, Offenposten->Debitor->Mandant, Offenposten->Saldo) As Mahngebuehr, 
			
			CASE  NVL(Offenposten->FibuBuchungsart,0)
				WHEN DBFibu.Konst_CodeBaDebitorRechnung() THEN
					CASE Offenposten->Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Offenposten->Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Offenposten->Debitor)
						END
				WHEN DBFibu.Konst_CodeBaDebitorAkontoRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontorechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeilRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeilrechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSchlussRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSchlussrechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorRegierechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetRegierechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSituationsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSituationsrechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeuerungsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeuerungsrechnungByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorAkontozahlungsges() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontozahlungsgesuchByDebi(Offenposten->Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorVorauszahlung() THEN
						DBDebiKredi_SD.Mahneinst_GetVorauszahlungByDebi(Offenposten->Debitor)
				WHEN 0 THEN
					CASE Offenposten->Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Offenposten->Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Offenposten->Debitor)
						END
			END AS "BelegArt",
			
			CASE :IndMahnText
			WHEN  1  THEN
				MahntextIndivid
			ELSE 
				DBDebiKredi_SD.Mahntyp_GetMahntextByCode(Offenposten->Mahnstufe, Offenposten->Debitor->Mandant, Offenposten->Debitor->Adresse->Sprachcode)
			END AS "Mahntext",
			DBDebiKredi.OPDebi_GetVerzugstage(Offenposten,{d :PerDatum}) As Verzug, 
			Offenposten->BelegNr, 
			Offenposten->Typ,
			Offenposten->Belegdatum, 
			Offenposten->Zahlungskondition->TageNetto As TageNetto,
			DBDebiKredi.OPDebi_GetFaellig(Offenposten) As Faellig,
			CASE Offenposten->Typ
				WHEN 0 THEN	Offenposten->Saldo
				ELSE (-1)*Offenposten->Saldo 
			END AS "Saldo",
			Offenposten->Mahnstufe,
			ProjektbezeichnungExtern,
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByCode(Offenposten->Mahnstufe,Offenposten->Debitor->Mandant, Offenposten->Debitor->Adresse->Sprachcode) As MahnArt,
			DBIntrap_SD.Projekt_GetBezeichnungClass(ProjektIntern, Offenposten->Debitor->Mandant, Offenposten->Debitor->Adresse->Sprachcode) AS ProjektBez,
			DBAdressen.Adresse_GetName(Offenposten->Debitor->Adresse->Adresscode, SachbearbeiterIntern->Name, SachbearbeiterIntern->Vorname, 0) As "Sachbearbeiter",
			ProjektleiterKunde,
			ProjektIntern->Hauptnummer Projektnummer,
			Prueffrist,
			DBDebiKredi_SD.Mahneinst_GetEinschreibenByDebi(Offenposten->Debitor) As "Text.Einschreiben",
			DBDebiKredi_SD.Mahntyp_GetEinschreibenByCode(Offenposten->Mahnstufe,Offenposten->Debitor->Mandant) AS Einschreiben
			FROM DBDebiKredi.OPDebiZusatz 
	WHERE Offenposten=:OpOid]]></SqlQuery>
</Query>

<Query name="ListeMahnungenOP">
<Type>%SQLQuery</Type>
<FormalSpec>stichtag:%Date,karrenztage:%Integer,mandOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			Debitor, 
			BelegNr, 
			Typ, 
			
			CASE NVL(FibuBuchungsart,0)
				WHEN DBFibu.Konst_CodeBaDebitorRechnung() THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
				WHEN DBFibu.Konst_CodeBaDebitorAkontoRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontorechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeilRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeilrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSchlussRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSchlussrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorRegierechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetRegierechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSituationsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSituationsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeuerungsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeuerungsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorAkontozahlungsges() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontozahlungsgesuchByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorVorauszahlung() THEN
						DBDebiKredi_SD.Mahneinst_GetVorauszahlungByDebi(Debitor)
				WHEN 0 THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
			END AS "BelegArt",
			
			Belegdatum, 
			Zahlungskondition->TageNetto As TageNetto, 
			DBDebiKredi.OPDebi_GetFaellig(ID) As Faellig, 
			DBDebiKredi.OPDebi_GetVerzugstage(ID,{d :stichtag}) As Verzug, 
			CASE Typ
				WHEN 0 THEN	Saldo
				ELSE (-1)*Saldo 
			END AS "Saldo",
			CASE Typ
				WHEN 0 THEN	FWSaldo
				ELSE (-1)*FWSaldo 
			END AS "FWSaldo",
			Mahnstufe,
			DBDebiKredi.OPDebiZusatz_GetProjektNrBezByOp(%ID) As ProjektBezeichnung,
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByCode(Mahnstufe,Debitor->Mandant, Debitor->Adresse->Sprachcode) As MahnArt
	FROM DBDebiKredi.OPDebi 
	WHERE IsOpGeschlossen=0 AND
			 Debitor->Mandant=:mandOid AND 
			 Debitor->Adresse->Adressnummer >= :vonAdrNr AND Debitor->Adresse->Adressnummer <= :bisAdrNr
	ORDER BY Debitor->Adresse->Adressnummer, Belegdatum]]></SqlQuery>
</Query>

<Query name="ListeOffeneDebiKredi">
<Type>%SQLQuery</Type>
<FormalSpec>DebiOid:%String,KrediOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			Saldo,
			FWSaldo,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			Debitor->Adresse As "Adresse",
			Debitor->Adresse->Adressnummer As "Adressnummer",
			Debitor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Name",
			Debitor->Adresse->Plz As "Plz",
			Debitor->Adresse->Ort As "Ort",
			Zahlungskondition,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			FibuBuchungsart,
			1 As IsDebitor
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor=:DebiOid AND IsOPgeschlossen<>1 	
 	
 	UNION ALL SELECT  ID,
			BelegNr,
			Saldo,
			FWSaldo,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Zahlungskondition,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			FibuBuchungsart,
			0 As IsDebitor
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor=:KrediOid AND IsOPgeschlossen<>1 	
 	
 	ORDER BY Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeVonBisAdrMitMahnstufe">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrNrVon:%Integer,AdrNrBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
	ID, Mahnstufe 
	FROM DBDebiKredi.OPDebi 
	WHERE Debitor->Mandant=:MandantOid
	AND	Debitor->Adresse->Adressnummer BETWEEN :AdrNrVon AND :AdrNrBis 
	AND IsOPgeschlossen=0 AND Mahnstufe > 0]]></SqlQuery>
</Query>

<Query name="ListeMahnungEinzelOP">
<Type>%SQLQuery</Type>
<FormalSpec>OpOid:%String,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			"" AS Projektleitung, 
			0 As "Projektleiter.Adressnummer",
			"" As "Projektleiter.Kurzname",
			"" As "Projektleiter.Name",
			"" As "Projektleiter.Adresszeile1", 
			"" As "Projektleiter.Strasse",
			"" AS "Projektleiter.Hausnummer",
			"" As "Projektleiter.Plz",
			"" As "Projektleiter.Ort", 
			
			Debitor, 
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			DBAdressen.Adresse_GetZusatz1(Debitor->Adresse->Adresscode, Debitor->Adresse->VornameZusatz1) As "Adresse.Adresszeile1", 
			Debitor->Adresse->Zusatz2 As "Adresse.Zusatz2",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer AS "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort", 
			
			DBDebiKredi_SD.Mahneinst_GetBelegNrByDebi(Debitor) As "Tabelle.BelegNr",
			DBDebiKredi_SD.Mahneinst_GetBelegArtByDebi(Debitor) As "Tabelle.BelegArt",
			DBDebiKredi_SD.Mahneinst_GetBelegdatumByDebi(Debitor) As "Tabelle.Belegdatum",
			DBDebiKredi_SD.Mahneinst_GetVerfalleneOPByDebi(Debitor) As "Tabelle.VerfalleneOP",
			DBDebiKredi_SD.Mahneinst_GetZahlungenBisByDebi(Debitor) As "Tabelle.ZahlungenBis",
			DBDebiKredi_SD.Mahneinst_GetFaelligByDebi(Debitor) As "Tabelle.Faellig",
			DBDebiKredi_SD.Mahneinst_GetVerzugByDebi(Debitor) As "Tabelle.Verzug",
			DBDebiKredi_SD.Mahneinst_GetBetragByDebi(Debitor) As "Tabelle.Betrag",
			DBDebiKredi_SD.Mahneinst_GetTotalOPByDebi(Debitor) As "Tabelle.TotalOP",
			DBDebiKredi_SD.Mahneinst_GetMahnArtByDebi(Debitor) As "Tabelle.MahnArt",
			DBDebiKredi_SD.Mahneinst_GetUebertragByDebi(Debitor) As "Tabelle.Uebertrag",
			DBDebiKredi_SD.Mahneinst_GetKundenNrByDebi(Debitor) As "Tabelle.KundenNr",
			DBDebiKredi_SD.Mahneinst_GetSeiteByDebi(Debitor) As "Tabelle.Seite",
			DBDebiKredi_SD.Mahneinst_GetTageByDebi(Debitor) As "Tabelle.Tage",
			DBDebiKredi_SD.Mahneinst_GetMahngebuehrByDebi(Debitor) As "Tabelle.Mahngebuehr",
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByCode(Mahnstufe, Debitor->Mandant, Debitor->Adresse->Sprachcode) As MahnArt, 
			DBDebiKredi_SD.Mahntyp_GetMahngebuehrByCode(Mahnstufe, Debitor->Mandant, Saldo) As Mahngebuehr, 
			
			CASE  NVL(FibuBuchungsart,0)
				WHEN DBFibu.Konst_CodeBaDebitorRechnung() THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
				WHEN DBFibu.Konst_CodeBaDebitorAkontoRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontorechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeilRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeilrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSchlussRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSchlussrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorRegierechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetRegierechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSituationsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSituationsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeuerungsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeuerungsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorAkontozahlungsges() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontozahlungsgesuchByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorVorauszahlung() THEN
						DBDebiKredi_SD.Mahneinst_GetVorauszahlungByDebi(Debitor)
				WHEN 0 THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
			END AS "BelegArt",
			
			DBDebiKredi_SD.Mahntyp_GetMahntextByCode(Mahnstufe, Debitor->Mandant, Debitor->Adresse->Sprachcode) AS "Mahntext",
			DBDebiKredi.OPDebi_GetVerzugstage(ID,{d :PerDatum}) As Verzug, 
			BelegNr, 
			Typ,
			Belegdatum, 
			Zahlungskondition->TageNetto As TageNetto,
			DBDebiKredi.OPDebi_GetFaellig(ID) As Faellig,
			CASE Typ
				WHEN 0 THEN	Saldo
				ELSE (-1)*Saldo 
			END AS "Saldo",
			Mahnstufe,
			"" AS ProjektbezeichnungExtern,
			"" As MahnArt,
			"" AS ProjektBez,
			"" As "Sachbearbeiter",
			"" AS ProjektleiterKunde,
			"" AS Projektnummer,
			0 AS Prueffrist,
			DBDebiKredi_SD.Mahneinst_GetEinschreibenByDebi(Debitor) As "Text.Einschreiben",
			DBDebiKredi_SD.Mahntyp_GetEinschreibenByCode(Mahnstufe, Debitor->Mandant) AS Einschreiben
			FROM DBDebiKredi.OPDebi 
	WHERE ID=:OpOid]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediAlleAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,vonDatum:%Date,bisDatum:%Date,ohneVerrechnungen:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			FWBetrag,
			FWKurs,
			FWFaktor,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsZahlung",
			1 As "IsDebitor"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 	
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			FWBetrag,
			FWKurs,
			FWFaktor,
			Kreditor->Adresse As "Adresse.ID",
			Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Kreditor->Adresse->Strasse As "Adresse.Strasse",
			Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Kreditor->Adresse->Plz As "Adresse.Plz",
			Kreditor->Adresse->Ort As "Adresse.Ort",
			Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsZahlung",
			0 As "IsDebitor"
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Adresse->Mandant=:MandantOid AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 				
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			FWZahlbetrag As FWBetrag,
			FWKurs,
			FWFaktor,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID",
			(SELECT Debitor->Adresse->Adressnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Adressnummer",
			(SELECT Debitor->Adresse->Kurzname FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Kurzname",
			(SELECT DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Name",
			(SELECT Debitor->Adresse->Strasse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Strasse",
			(SELECT Debitor->Adresse->Hausnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Hausnummer",
			(SELECT Debitor->Adresse->Plz FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Plz",
			(SELECT Debitor->Adresse->Ort FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Ort",
			(SELECT Debitor->Adresse->Telefon1 FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Telefon1",
			(SELECT Debitor->Fremdwaehrung->FWCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.FWCode",
			(SELECT Debitor->Fremdwaehrung->ISOSWIFTCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.ISOSWIFTCode",
			(SELECT Vertreter->Code FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Vertreter.Code",
			1 As "IsZahlung",
			1 As "IsDebitor"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi 
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0)
 	
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			FWZahlbetrag As FWBetrag,
			FWKurs,
			FWFaktor,
			(SELECT Kreditor->Adresse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID",
			(SELECT Kreditor->Adresse->Adressnummer FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Adressnummer",
			(SELECT Kreditor->Adresse->Kurzname FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Kurzname",
			(SELECT DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Name",
			(SELECT Kreditor->Adresse->Strasse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Strasse",
			(SELECT Kreditor->Adresse->Hausnummer FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Hausnummer",
			(SELECT Kreditor->Adresse->Plz FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Plz",
			(SELECT Kreditor->Adresse->Ort FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Ort",
			(SELECT Kreditor->Adresse->Telefon1 FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Telefon1",
			(SELECT Kreditor->Fremdwaehrung->FWCode FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.FWCode",
			(SELECT Kreditor->Fremdwaehrung->ISOSWIFTCode FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.ISOSWIFTCode",
			(SELECT Vertreter->Code FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Vertreter.Code",
			1 As "IsZahlung",
			0 As "IsDebitor"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPKredi 
 			WHERE Kreditor->Adresse->Mandant=:MandantOid AND
 				Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 				Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0)
 	
 	ORDER BY "Adresse.Adressnummer", Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediAlleAdrVortrag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,bisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(BetragInklMwst) AS Betrag, SUM(FWBetrag) AS FWBetrag, "Adresse.ID" FROM (
	SELECT 	
			CASE WHEN Typ = 0 THEN BetragInklMwst ELSE (-1)*BetragInklMwst END AS BetragInklMwst,
			CASE WHEN Typ = 0 THEN FWBetrag ELSE (-1)*FWBetrag END AS FWBetrag,
			Debitor->Adresse As "Adresse.ID"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum < {d :bisDatum}
 			
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) ELSE (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) END As BetragInklMwst,
			CASE WHEN Typ = 0 THEN (-1)*FWZahlbetrag ELSE FWZahlbetrag END As FWBetrag,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi 
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum < {d :bisDatum}
 	
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (-1)*BetragInklMwst ELSE BetragInklMwst END AS BetragInklMwst,
			CASE WHEN Typ = 0 THEN (-1)*FWBetrag ELSE FWBetrag END AS FWBetrag,
			Kreditor->Adresse As "Adresse.ID"
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Adresse->Mandant=:MandantOid AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum < {d :bisDatum}
 			
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) ELSE (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) END As BetragInklMwst,
			CASE WHEN Typ = 0 THEN FWZahlbetrag ELSE (-1)*FWZahlbetrag END As FWBetrag,
			(SELECT Kreditor->Adresse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPKredi 
 			WHERE Kreditor->Adresse->Mandant=:MandantOid AND
 				Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 				Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum < {d :bisDatum}
 	
 	) GROUP BY "Adresse.ID"]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediOffeneAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			ZKTage3 As "Zahlungskondition.TageNetto",
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr", 
			Saldo,
			FWSaldo,
			FWKurs,
			FWFaktor,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			1 As "IsDebitor"
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 			
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			ZKTage3 As "Zahlungskondition.TageNetto",
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr", 
			Saldo,
			FWSaldo,
			FWKurs,
			FWFaktor,
			Kreditor->Adresse As "Adresse.ID",
			Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Kreditor->Adresse->Strasse As "Adresse.Strasse",
			Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Kreditor->Adresse->Plz As "Adresse.Plz",
			Kreditor->Adresse->Ort As "Adresse.Ort",
			Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsDebitor"
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Adresse->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 			
 	ORDER BY "Adresse.Adressnummer", Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediOffenePerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.BelegNr,
			o.Buchungstext1,
			o.Buchungstext2,
			o.Valutadatum,
			o.Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(o.Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			o.ZKTage3 As "Zahlungskondition.TageNetto",
			o.Typ,
			o.Mahnstufe,
			o.FibuKonto->KontoNr As "KontoNr", 
			(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As Saldo,
			(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As FWSaldo,
			o.FWKurs,
			o.FWFaktor,
			o.Debitor->Adresse As "Adresse.ID",
			o.Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			o.Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(o.Debitor->Adresse->Adresscode, o.Debitor->Adresse->Name, o.Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			o.Debitor->Adresse->Strasse As "Adresse.Strasse",
			o.Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			o.Debitor->Adresse->Plz As "Adresse.Plz",
			o.Debitor->Adresse->Ort As "Adresse.Ort",
			o.Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			o.Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			o.Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			o.Vertreter->Code As "Vertreter.Code",
			1 As "IsDebitor"
 	FROM DBDebiKredi.OPDebi o
 	WHERE o.Debitor->Mandant=:MandantOid AND 
 			o.Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
                                  
    UNION ALL SELECT
    	 	o.BelegNr,
			o.Buchungstext1,
			o.Buchungstext2,
			o.Valutadatum,
			o.Belegdatum,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(o.Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			o.ZKTage3 As "Zahlungskondition.TageNetto",
			o.Typ,
			o.Mahnstufe,
			o.FibuKonto->KontoNr As "KontoNr", 
			(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As Saldo,
			(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As FWSaldo,
			o.FWKurs,
			o.FWFaktor,
			o.Kreditor->Adresse As "Adresse.ID",
			o.Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			o.Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(o.Kreditor->Adresse->Adresscode, o.Kreditor->Adresse->Name, o.Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			o.Kreditor->Adresse->Strasse As "Adresse.Strasse",
			o.Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			o.Kreditor->Adresse->Plz As "Adresse.Plz",
			o.Kreditor->Adresse->Ort As "Adresse.Ort",
			o.Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			o.Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			o.Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			o.Vertreter->Code As "Vertreter.Code",
			0 As "IsDebitor"
 	FROM DBDebiKredi.OPKredi o
 	WHERE o.Kreditor->Adresse->Mandant=:MandantOid AND 
 			o.Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)

 	ORDER BY "Adresse.Adressnummer", Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediOffeneFibuKontoJ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT "Konto.Nummer",
			"Konto.Bezeichnung",
			SUM(Saldo) As Saldo,
			SUM(SaldoFW) As SaldoFW
	FROM (
	SELECT 	FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,FibuKonto) As "Konto.Bezeichnung", 
			CASE Typ
				WHEN 0 THEN	Saldo
				ELSE (-1)*Saldo 
			END AS "Saldo",
			CASE Typ
				WHEN 0 THEN	FWSaldo
				ELSE (-1)*FWSaldo 
			END AS "SaldoFW"

 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 	
 	UNION ALL SELECT 	
 			FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,FibuKonto) As "Konto.Bezeichnung", 
			CASE Typ
				WHEN 0 THEN	(-1)*Saldo
				ELSE Saldo 
			END AS "Saldo",
			CASE Typ
				WHEN 0 THEN	(-1)*FWSaldo
				ELSE FWSaldo 
			END AS "SaldoFW"

 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Adresse->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr
 	)
 	GROUP BY "Konto.Nummer"
 	ORDER BY "Konto.Nummer"]]></SqlQuery>
</Query>

<Query name="ListeDebiKrediOffeneKtoPerDatJ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT "Konto.Nummer",
			"Konto.Bezeichnung",
			SUM(Saldo) As Saldo,
			SUM(SaldoFW) As SaldoFW
	FROM (
	SELECT 	o.FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,o.FibuKonto) As "Konto.Bezeichnung", 
			CASE o.Typ
				WHEN 0 THEN	
					(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            	                FROM DBDebiKredi.OPZahlung oz 
                   		        WHERE oz.OP=o.ID AND 
                           		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
				ELSE 
					(-1)*(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            	                FROM DBDebiKredi.OPZahlung oz 
                   		        WHERE oz.OP=o.ID AND 
                           		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
			END AS "Saldo",
			CASE o.Typ
				WHEN 0 THEN	
					(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                           FROM DBDebiKredi.OPZahlung oz 
                           WHERE oz.OP=o.ID AND 
                                 oz.Zahlung->Valutadatum<={d :perDatum}),0))
				ELSE 
					(-1)*(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                           FROM DBDebiKredi.OPZahlung oz 
                           WHERE oz.OP=o.ID AND 
                                 oz.Zahlung->Valutadatum<={d :perDatum}),0))
			END AS "SaldoFW"

 	FROM DBDebiKredi.OPDebi o
 	WHERE o.Debitor->Mandant=:MandantOid AND 
 			o.Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
                                  
    UNION ALL SELECT 	
    		o.FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,o.FibuKonto) As "Konto.Bezeichnung", 
			CASE o.Typ
				WHEN 0 THEN	
					(-1)*(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            	                FROM DBDebiKredi.OPZahlung oz 
                   		        WHERE oz.OP=o.ID AND 
                           		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
				ELSE 
					(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            	                FROM DBDebiKredi.OPZahlung oz 
                   		        WHERE oz.OP=o.ID AND 
                           		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
			END AS "Saldo",
			CASE o.Typ
				WHEN 0 THEN	
					(-1)*(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                           FROM DBDebiKredi.OPZahlung oz 
                           WHERE oz.OP=o.ID AND 
                                 oz.Zahlung->Valutadatum<={d :perDatum}),0))
				ELSE 
					(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                           FROM DBDebiKredi.OPZahlung oz 
                           WHERE oz.OP=o.ID AND 
                                 oz.Zahlung->Valutadatum<={d :perDatum}),0))
			END AS "SaldoFW"

 	FROM DBDebiKredi.OPKredi o
 	WHERE o.Kreditor->Adresse->Mandant=:MandantOid AND 
 			o.Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	)
 	GROUP BY "Konto.Nummer"
 	ORDER BY "Konto.Nummer"]]></SqlQuery>
</Query>

<Query name="ListeSucheBelegNr">
<Type>%SQLQuery</Type>
<FormalSpec>BelegNr:%String,MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			DBDebiKredi.OP_BetragExklMwstClass(ID) AS BetragExklMwst,
			DBDebiKredi.OP_BetragInklMwstClass(ID) AS BetragInklMwst,
			DBDebiKredi.OP_BetragMwstClass(ID) AS BetragMwst,
			DBDebiKredi.OP_CalcSaldoClass(ID) AS Saldo,
			0 As Skontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			0 As "IsZahlung",
			0 As "Verbuchungsjnr",
			FibuBuchungsart
 	FROM DBDebiKredi.OPDebi
 	WHERE Debitor->Mandant=:MandantOid AND 
 			BelegNr LIKE :BelegNr
			 	
 	UNION ALL 
 	SELECT  ID,
			BelegNr,
			(NVL(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),0)+NVL(DBDebiKredi.Zahlung_GetKursdifferenzClass(ID),0)) As BetragExklMwst,
			(NVL(DBDebiKredi.Zahlung_GetZahlbetragClass(ID),0)+NVL(DBDebiKredi.Zahlung_GetKursdifferenzClass(ID),0)) As BetragInklMwst,
			0 As BetragMwst,
			0 As Saldo,
			DBDebiKredi.Zahlung_GetSkontoabzugClass(ID) AS Skontoabzug,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			0 As "Mahnstufe",
			FibuKonto->KontoNr As "KontoNr",
			1 As "IsZahlung",
			Verbuchungsjnr,
			0 As FibuBuchungsart
 	FROM DBDebiKredi.Zahlung
 	WHERE ID IN (SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID FROM DBDebiKredi.OPDebi WHERE Debitor->Mandant=:MandantOid)) AND
 			BelegNr LIKE :BelegNr
			
 	ORDER BY Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAlleAdrProjekt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonProjektNr:%String,bisProjektNr:%String,vonDatum:%Date,bisDatum:%Date,ohneVerrechnungen:%Boolean,projektSelektion:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			0 As Skontoabzug,
			FWBetrag,
			0 As FWSkontoabzug,
			FWKurs,
			FWFaktor,
			Debitor->Adresse As "Adresse.ID",
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort",
			Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsZahlung",
			(SELECT ProjektIntern->Hauptnummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID) As "Projekt.Hauptnummer",
			(SELECT ProjektIntern->Teilnummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID) As "Projekt.Teilnummer"
 	FROM DBDebiKredi.OPDebi opd
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			(:projektSelektion=0 OR NVL((SELECT ProjektIntern->Nummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID),'') BETWEEN :vonProjektNr AND :bisProjektNr) AND 
 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 			
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			Skontoabzug,
			FWZahlbetrag As FWBetrag,
			FWSkontoabzug,
			FWKurs,
			FWFaktor,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID",
			(SELECT Debitor->Adresse->Adressnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Adressnummer",
			(SELECT Debitor->Adresse->Kurzname FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Kurzname",
			(SELECT DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Name",
			(SELECT Debitor->Adresse->Strasse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Strasse",
			(SELECT Debitor->Adresse->Hausnummer FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Hausnummer",
			(SELECT Debitor->Adresse->Plz FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Plz",
			(SELECT Debitor->Adresse->Ort FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Ort",
			(SELECT Debitor->Adresse->Telefon1 FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Telefon1",
			(SELECT Debitor->Fremdwaehrung->FWCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.FWCode",
			(SELECT Debitor->Fremdwaehrung->ISOSWIFTCode FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.ISOSWIFTCode",
			(SELECT Vertreter->Code FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Vertreter.Code",
			1 As "IsZahlung",
			'' As "Projekt.Hauptnummer",
			'' As "Projekt.Teilnummer"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi opd
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				(:projektSelektion=0 OR NVL((SELECT ProjektIntern->Nummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID),'') BETWEEN :vonProjektNr AND :bisProjektNr) AND
 				Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 		)
 	) AND
 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0 OR 
 		VerrechnungsNr IN (SELECT NVL(Zahlung->VerrechnungsNr,0) 
 								FROM DBDebiKredi.OPZahlung
 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi))
 	)
 	
 	ORDER BY "Adresse.Adressnummer", Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAdrProjektVortrag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonProjektNr:%String,bisProjektNr:%String,bisDatum:%Date,projektSelektion:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(BetragInklMwst) AS Betrag, SUM(FWBetrag) AS FWBetrag, "Adresse.ID" FROM (
	SELECT 	
			CASE WHEN Typ = 0 THEN BetragInklMwst ELSE (-1)*BetragInklMwst END AS BetragInklMwst,
			CASE WHEN Typ = 0 THEN FWBetrag ELSE (-1)*FWBetrag END AS FWBetrag,
			Debitor->Adresse As "Adresse.ID"
 	FROM DBDebiKredi.OPDebi opd
 	WHERE Debitor->Mandant=:MandantOid AND
 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			(:projektSelektion=0 OR NVL((SELECT ProjektIntern->Nummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID),'') BETWEEN :vonProjektNr AND :bisProjektNr) AND 
 			Valutadatum < {d :bisDatum}
 			
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) ELSE (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) END As BetragInklMwst,
			CASE WHEN Typ = 0 THEN (-1)*FWZahlbetrag ELSE FWZahlbetrag END As FWBetrag,
			(SELECT Debitor->Adresse FROM DBDebiKredi.OPDebi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPDebi opd
 			WHERE Debitor->Mandant=:MandantOid AND
 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 				(:projektSelektion=0 OR NVL((SELECT ProjektIntern->Nummer FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=opd.ID),'') BETWEEN :vonProjektNr AND :bisProjektNr) AND
 				Valutadatum < {d :bisDatum}
 		)
 	) AND
 	Valutadatum < {d :bisDatum}
 	) GROUP BY "Adresse.ID"]]></SqlQuery>
</Query>

<Query name="ListeMahnungEinzelOPSerie">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonAdrNr:%Integer,BisAdrNr:%Integer,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 	
			Debitor, 
			Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Debitor->Adresse->Adresscode, Debitor->Adresse->Name, Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			DBAdressen.Adresse_GetZusatz1(Debitor->Adresse->Adresscode, Debitor->Adresse->VornameZusatz1) As "Adresse.Adresszeile1", 
			Debitor->Adresse->Zusatz2 As "Adresse.Zusatz2",
			Debitor->Adresse->Strasse As "Adresse.Strasse",
			Debitor->Adresse->Hausnummer AS "Adresse.Hausnummer",
			Debitor->Adresse->Plz As "Adresse.Plz",
			Debitor->Adresse->Ort As "Adresse.Ort", 
			
			DBDebiKredi_SD.Mahneinst_GetBelegNrByDebi(Debitor) As "Tabelle.BelegNr",
			DBDebiKredi_SD.Mahneinst_GetBelegArtByDebi(Debitor) As "Tabelle.BelegArt",
			DBDebiKredi_SD.Mahneinst_GetBelegdatumByDebi(Debitor) As "Tabelle.Belegdatum",
			DBDebiKredi_SD.Mahneinst_GetVerfalleneOPByDebi(Debitor) As "Tabelle.VerfalleneOP",
			DBDebiKredi_SD.Mahneinst_GetZahlungenBisByDebi(Debitor) As "Tabelle.ZahlungenBis",
			DBDebiKredi_SD.Mahneinst_GetFaelligByDebi(Debitor) As "Tabelle.Faellig",
			DBDebiKredi_SD.Mahneinst_GetVerzugByDebi(Debitor) As "Tabelle.Verzug",
			DBDebiKredi_SD.Mahneinst_GetBetragByDebi(Debitor) As "Tabelle.Betrag",
			DBDebiKredi_SD.Mahneinst_GetTotalOPByDebi(Debitor) As "Tabelle.TotalOP",
			DBDebiKredi_SD.Mahneinst_GetMahnArtByDebi(Debitor) As "Tabelle.MahnArt",
			DBDebiKredi_SD.Mahneinst_GetUebertragByDebi(Debitor) As "Tabelle.Uebertrag",
			DBDebiKredi_SD.Mahneinst_GetKundenNrByDebi(Debitor) As "Tabelle.KundenNr",
			DBDebiKredi_SD.Mahneinst_GetSeiteByDebi(Debitor) As "Tabelle.Seite",
			DBDebiKredi_SD.Mahneinst_GetTageByDebi(Debitor) As "Tabelle.Tage",
			DBDebiKredi_SD.Mahneinst_GetMahngebuehrByDebi(Debitor) As "Tabelle.Mahngebuehr",
			DBDebiKredi_SD.Mahntyp_GetBezeichnungByCode(Mahnstufe, Debitor->Mandant, Debitor->Adresse->Sprachcode) As MahnArt, 
			NVL(DBDebiKredi_SD.Mahntyp_GetMahngebuehrByCode(Mahnstufe, Debitor->Mandant, Saldo),0) As Mahngebuehr, 
			
			CASE  NVL(FibuBuchungsart,0)
				WHEN DBFibu.Konst_CodeBaDebitorRechnung() THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
				WHEN DBFibu.Konst_CodeBaDebitorAkontoRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontorechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeilRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeilrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSchlussRechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSchlussrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorRegierechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetRegierechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorSituationsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetSituationsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorTeuerungsrechnung() THEN
						DBDebiKredi_SD.Mahneinst_GetTeuerungsrechnungByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorAkontozahlungsges() THEN
						DBDebiKredi_SD.Mahneinst_GetAkontozahlungsgesuchByDebi(Debitor)
				WHEN DBFibu.Konst_CodeBaDebitorVorauszahlung() THEN
						DBDebiKredi_SD.Mahneinst_GetVorauszahlungByDebi(Debitor)
				WHEN 0 THEN
					CASE Typ
						WHEN 0 THEN	
							DBDebiKredi_SD.Mahneinst_GetRechnungByDebi(Debitor)
						ELSE 
							DBDebiKredi_SD.Mahneinst_GetGutschriftByDebi(Debitor)
						END
			END AS "BelegArt",
			
			DBDebiKredi_SD.Mahntyp_GetMahntextByCode(Mahnstufe, Debitor->Mandant, Debitor->Adresse->Sprachcode) AS "Mahntext",
			DBDebiKredi.OPDebi_GetVerzugstage(ID,{d :PerDatum}) As Verzug, 
			BelegNr, 
			Typ,
			Belegdatum, 
			Zahlungskondition->TageNetto As TageNetto,
			DBDebiKredi.OPDebi_GetFaellig(ID) As Faellig,
			Saldo,
			Mahnstufe,
			DBDebiKredi_SD.Mahneinst_GetEinschreibenByDebi(Debitor) As "Text.Einschreiben",
			DBDebiKredi_SD.Mahntyp_GetEinschreibenByCode(Mahnstufe, Debitor->Mandant) AS Einschreiben
			FROM DBDebiKredi.OPDebi 
	WHERE IsOpGeschlossen = 0 AND
		  Typ = DBDebiKredi.Konst_OPTypRechnung() AND
		  Debitor->Mandant=:MandantOid AND 
		  Debitor->Adresse->Adressnummer >= :VonAdrNr AND Debitor->Adresse->Adressnummer <= :BisAdrNr AND
		  DBDebiKredi.OPDebi_GetVerzugstage(ID,{d :PerDatum}) > 0
	ORDER BY Debitor->Adresse->Adressnummer, Belegdatum]]></SqlQuery>
</Query>

<UDLText name="T">
<Content><![CDATA[
/*
Query ListeAlleAlleAdrFibuKonto(MandantOid As %String, MandantJahrOid As %String, Lang As %String, vonAdrNr As %Integer, bisAdrNr As %Integer, vonKtoNr As %String, bisKtoNr As %String, vonDatum As %Date, bisDatum As %Date, ohneVerrechnungen As %Boolean, skontoAbzugFibukontoOid As %String) As %SQLQuery
{
	SELECT KontoNr,
			DBFibu.Konto_GetKontoBezeichnungClass(:MandantJahrOid,KontoOid) As Kontobezeichnung,
			SUM(NVL(BetragInklMwst,0)) As BetragInklMwst,
			SUM(NVL(FWBetrag,0)) As FWBetrag, 
			"Fremdwaehrung.FWCode",
			"Fremdwaehrung.ISOSWIFTCode"
	FROM (
		SELECT 	FibuKonto->KontoNr As "KontoNr", 
				FibuKonto As "KontoOid", 
				CASE WHEN Typ = 0 THEN BetragInklMwst ELSE (-1)*BetragInklMwst END AS BetragInklMwst,
				CASE WHEN Typ = 0 THEN FWBetrag ELSE (-1)*FWBetrag END AS FWBetrag,
				Waehrung->FWCode As "Fremdwaehrung.FWCode",
				Waehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode"
	 	FROM DBDebiKredi.OPDebi opd
	 	WHERE Debitor->Mandant=:MandantOid AND
	 			Debitor->Adresse->Adressnummer>=:vonAdrNr AND
	 			Debitor->Adresse->Adressnummer<=:bisAdrNr AND
	 			FibuKonto->KontoNr>=:vonKtoNr AND
	 			FibuKonto->KontoNr<=:bisKtoNr AND
	 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 			
	 	UNION ALL SELECT 	
	 			FibuKonto->KontoNr As "KontoNr", 
				FibuKonto As "KontoOid", 
				CASE WHEN Typ = 0 THEN (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) ELSE (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) END As BetragInklMwst,
				CASE WHEN Typ = 0 THEN (-1)*(NVL(FWZahlbetrag,0)) ELSE NVL(FWZahlbetrag,0) END As FWBetrag,
				Waehrung->FWCode As "Fremdwaehrung.FWCode",
				Waehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode"
	 	FROM DBDebiKredi.Zahlung z
	 	WHERE ID IN (
		 		SELECT Zahlung 
		 		FROM DBDebiKredi.OPZahlung 
		 		WHERE OP IN (
		 			SELECT ID 
		 			FROM DBDebiKredi.OPDebi 
		 			WHERE Debitor->Mandant=:MandantOid AND
		 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
		 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
		 				FibuKonto->KontoNr>=:vonKtoNr AND
		 				FibuKonto->KontoNr<=:bisKtoNr
		 		)
		 	) AND
		 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
		 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0 OR 
		 		VerrechnungsNr IN (SELECT NVL(Zahlung->VerrechnungsNr,0) 
		 								FROM DBDebiKredi.OPZahlung
		 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi))
		 	)
		 	
		 UNION ALL SELECT 	
	 			(SELECT KontoNr FROM DBFibu.Konto WHERE ID=:skontoAbzugFibukontoOid) As "KontoNr", 
				:skontoAbzugFibukontoOid As "KontoOid", 
				CASE WHEN Typ = 0 THEN (-1)*(NVL(Skontoabzug,0)) ELSE (NVL(Skontoabzug,0)) END As BetragInklMwst,
				CASE WHEN Typ = 0 THEN (-1)*(NVL(FWSkontoabzug,0)) ELSE (NVL(FWSkontoabzug,0)) END As FWBetrag,
				Waehrung->FWCode As "Fremdwaehrung.FWCode",
				Waehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode"
	 	FROM DBDebiKredi.Zahlung z
	 	WHERE ID IN (
		 		SELECT Zahlung 
		 		FROM DBDebiKredi.OPZahlung 
		 		WHERE OP IN (
		 			SELECT ID 
		 			FROM DBDebiKredi.OPDebi 
		 			WHERE Debitor->Mandant=:MandantOid AND
		 				Debitor->Adresse->Adressnummer>=:vonAdrNr AND
		 				Debitor->Adresse->Adressnummer<=:bisAdrNr AND
		 				FibuKonto->KontoNr>=:vonKtoNr AND
		 				FibuKonto->KontoNr<=:bisKtoNr
		 		)
		 	) AND
		 	(NVL(Skontoabzug,0)<>0 OR NVL(FWSkontoabzug,0)<>0) AND
		 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
		 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0 OR 
		 		VerrechnungsNr IN (SELECT NVL(Zahlung->VerrechnungsNr,0) 
		 								FROM DBDebiKredi.OPZahlung
		 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi))
		 	)
		 
 	)
 	GROUP BY KontoNr, "Fremdwaehrung.FWCode"
 	ORDER BY "KontoNr", "Fremdwaehrung.FWCode"
}
*/
]]></Content>
</UDLText>

<Query name="ListeVorzeitigeZahlungen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
		OP->Valutadatum As OpValuta, 
		Zahlung->Valutadatum As ZahlungValuta, 
		(SELECT Debitor->Adresse->Adressnummer 
				FROM DBDebiKredi.OPDebi 
				WHERE ID=OP) As Adressnummer, 
		OP->BelegNr As OpBelegNr, 
		Zahlung->BelegNr As ZahlungBelegNr 
	FROM DBDebiKredi.OPZahlung 
	WHERE OP In (SELECT ID FROM DBDebiKredi.OPDebi WHERE Debitor->Mandant=:MandantOid) AND 
		OP->Valutadatum>Zahlung->Valutadatum]]></SqlQuery>
</Query>

<Query name="ListeVerfallAlleAdrPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,perDatum:%Date,abRgDatum:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.BelegNr,
			o.Buchungstext1,
			o.Buchungstext2,
			o.Valutadatum,
			o.Belegdatum,
			CASE WHEN :abRgDatum = 1 THEN DBDebiKredi.OPDebi_GetAlter(o.ID, {d :perDatum}) ELSE DBDebiKredi.OPDebi_GetVerzugstage(o.ID, {d :perDatum}) END AS Verzugstage,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(o.Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			o.ZKTage3 As "Zahlungskondition.TageNetto",
			o.Typ,
			o.Mahnstufe,
			o.FibuKonto->KontoNr As "KontoNr", 
			(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As Saldo,
			(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As FWSaldo,
			o.FWKurs,
			o.FWFaktor,
			o.Debitor->Adresse As "Adresse.ID",
			o.Debitor->Adresse->Adressnummer As "Adresse.Adressnummer",
			o.Debitor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(o.Debitor->Adresse->Adresscode, o.Debitor->Adresse->Name, o.Debitor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			o.Debitor->Adresse->Strasse As "Adresse.Strasse",
			o.Debitor->Adresse->Hausnummer As "Adresse.Hausnummer",
			o.Debitor->Adresse->Plz As "Adresse.Plz",
			o.Debitor->Adresse->Ort As "Adresse.Ort",
			o.Debitor->Adresse->Telefon1 As "Adresse.Telefon1",
			o.Debitor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			o.Debitor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			o.Vertreter->Code As "Vertreter.Code"
 	FROM DBDebiKredi.OPDebi o
 	WHERE o.Debitor->Mandant=:MandantOid AND 
 			o.Debitor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Debitor->Adresse->Adressnummer<=:bisAdrNr AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	ORDER BY o.Debitor->Adresse->Adressnummer, o.Valutadatum, o.BelegNr]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.OPKrediAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61494,56407.321432</TimeCreated>

<Query name="ListeOffene">
<Type>%SQLQuery</Type>
<FormalSpec>KrediOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			Saldo,
			FWSaldo,
			FWKurs,
			FWFaktor,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Zahlungskondition,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor=:KrediOid AND IsOPgeschlossen<>1
 	ORDER BY Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlle">
<Type>%SQLQuery</Type>
<FormalSpec>KrediOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			BetragExklMwst,
			BetragInklMwst,
			BetragMwst,
			0 As Skontoabzug,
			0 As FWSkontoabzug,
			FWBetrag,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			0 As "IsZahlung",
			0 As "Verbuchungsjnr",
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor=:KrediOid
 	
 	UNION ALL 
 	SELECT  ID,
			BelegNr,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragExklMwst,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			0 As BetragMwst,
			Skontoabzug,
			FWSkontoabzug,
			FWZahlbetrag As FWBetrag,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			0 As "Mahnstufe",
			FibuKonto->KontoNr As "KontoNr",
			1 As "IsZahlung",
			Verbuchungsjnr,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			0 As "BankVerguetungscode",
			"" As RefNrGrund			
 	FROM DBDebiKredi.Zahlung
 	WHERE ID IN (SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi WHERE Kreditor=:KrediOid))
 	
 	ORDER BY Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeSuche">
<Type>%SQLQuery</Type>
<FormalSpec>Buchungstext:%String,BelegNr:%String,BetragExakt:%Decimal(SCALE=5),BetragVon:%Decimal(SCALE=5),BetragBis:%Decimal(SCALE=5),ValutadatumVon:%Date,ValutadatumBis:%Date,BelegdatumVon:%Date,BelegdatumBis:%Date,MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT  ID,
			BelegNr,
			BetragExklMwst,
			BetragInklMwst,
			BetragMwst,
			Saldo,
			0 As Skontoabzug,
			FWBetrag,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr",
			0 As "IsZahlung",
			0 As "Verbuchungsjnr",
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			(Buchungstext1 LIKE :Buchungstext OR :Buchungstext = '') AND
			(BelegNr LIKE :BelegNr OR :BelegNr = '') AND
			(DBUtils.NumberUtils_Round(BetragInklMwst,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(BetragExklMwst,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(BetragMwst,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(Saldo,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR DBUtils.NumberUtils_Round(:BetragExakt,2) = 0) AND
			((DBUtils.NumberUtils_Round(BetragInklMwst,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(BetragInklMwst,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(BetragExklMwst,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(BetragExklMwst,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(BetragMwst,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(BetragMwst,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(Saldo,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(Saldo,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(:BetragVon,2) = 0 AND DBUtils.NumberUtils_Round(:BetragBis,2) = 0)) AND
			(Valutadatum BETWEEN {d :ValutadatumVon} AND {d :ValutadatumBis}) AND
			(Belegdatum BETWEEN {d :BelegdatumVon} AND {d :BelegdatumBis})
 	
 	UNION ALL 
 	SELECT  ID,
			BelegNr,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragExklMwst,
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			0 As BetragMwst,
			0 As Saldo,
			Skontoabzug,
			FWZahlbetrag As FWBetrag,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			0 As "Mahnstufe",
			FibuKonto->KontoNr As "KontoNr",
			1 As "IsZahlung",
			Verbuchungsjnr,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			0 As "BankVerguetungscode",
			"" As RefNrGrund			
 	FROM DBDebiKredi.Zahlung
 	WHERE ID IN (SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID FROM DBDebiKredi.OPKredi WHERE Kreditor->Mandant=:MandantOid)) AND
 			(Buchungstext1 LIKE :Buchungstext OR :Buchungstext = '') AND
			(BelegNr LIKE :BelegNr OR :BelegNr = '') AND
			(DBUtils.NumberUtils_Round(Zahlbetrag,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR 
					DBUtils.NumberUtils_Round(Skontoabzug,2) = DBUtils.NumberUtils_Round(:BetragExakt,2) OR DBUtils.NumberUtils_Round(:BetragExakt,2) = 0) AND
			((DBUtils.NumberUtils_Round(Zahlbetrag,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(Zahlbetrag,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(Skontoabzug,2) BETWEEN DBUtils.NumberUtils_Round(:BetragVon,2) AND DBUtils.NumberUtils_Round(:BetragBis,2) AND DBUtils.NumberUtils_Round(Skontoabzug,2) <> 0) OR 
					(DBUtils.NumberUtils_Round(:BetragVon,2) = 0 AND DBUtils.NumberUtils_Round(:BetragBis,2) = 0)) AND
			(Valutadatum BETWEEN {d :ValutadatumVon} AND {d :ValutadatumBis}) AND
			(Belegdatum BETWEEN {d :BelegdatumVon} AND {d :BelegdatumBis})

 	ORDER BY Valutadatum, IsZahlung, BelegNr]]></SqlQuery>
</Query>

<Query name="OPbyFibuBuchung">
<Type>%SQLQuery</Type>
<FormalSpec>buchungOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
			Kreditor->Adresse->ID AS "AdressOid",
			Kreditor->Adresse->Adressnummer AS "Adressnummer",
			Kreditor->Adresse->Kurzname AS "Kurzname",
			Kreditor->Adresse->Name AS "Name",
			Kreditor->Adresse->Ort AS "Ort",
			Valutadatum,
			Belegdatum,
			Belegnr,
			BetragInklMwst,
			FWBetrag,
			Typ,
			FibuKonto,
			Waehrung,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Waehrung->FWCode As FWCode,
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund,
			Fibukonto->KontoNr As KontoNr			
	FROM DBDebiKredi.OPKredi
	WHERE FibuBuchung=:buchungOid
	ORDER BY Fibukonto->KontoNr, Kreditor->Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,alle:%Boolean,manuelle:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			DBDebiKredi_SD.KZahlungskond_GetBezeichnungClass(Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			Zahlungskondition->TageNetto As "Zahlungskondition.TageNetto",
			Typ,
			Mahnstufe,
			FibuKonto->KontoNr As "KontoNr", 
			Saldo,
			FWSaldo,
			FWKurs,
			FWFaktor,
			Kreditor->Adresse As "Adresse.ID",
			Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Kreditor->Adresse->Strasse As "Adresse.Strasse",
			Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Kreditor->Adresse->Plz As "Adresse.Plz",
			Kreditor->Adresse->Ort As "Adresse.Ort",
			Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND 
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			(:alle=1 OR NVL(ManuelleErfassung,0)=:manuelle)
 	ORDER BY Kreditor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleAdrPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,alle:%Boolean,manuelle:%Boolean,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.BelegNr,
			o.Buchungstext1,
			o.Buchungstext2,
			o.Valutadatum,
			o.Belegdatum,
			DBDebiKredi_SD.KZahlungskond_GetBezeichnungClass(o.Zahlungskondition, :MandantOid, :Lang) As "Zahlungskondition.Text",
			o.Zahlungskondition->TageNetto As "Zahlungskondition.TageNetto",
			o.Typ,
			o.Mahnstufe,
			o.FibuKonto->KontoNr As "KontoNr", 
			(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As Saldo,
			(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) As FWSaldo,
			o.FWKurs,
			o.FWFaktor,
			o.Kreditor->Adresse As "Adresse.ID",
			o.Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			o.Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(o.Kreditor->Adresse->Adresscode, o.Kreditor->Adresse->Name, o.Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			o.Kreditor->Adresse->Strasse As "Adresse.Strasse",
			o.Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			o.Kreditor->Adresse->Plz As "Adresse.Plz",
			o.Kreditor->Adresse->Ort As "Adresse.Ort",
			o.Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			o.Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			o.Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			o.Vertreter->Code As "Vertreter.Code"
 	FROM DBDebiKredi.OPKredi o
 	WHERE o.Kreditor->Mandant=:MandantOid AND 
 			o.Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Kreditor->Adresse->Adressnummer<=:bisAdrNr AND 
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			(:alle=1 OR NVL(o.ManuelleErfassung,0)=:manuelle) AND
 			o.Valutadatum<={d :perDatum} AND (
     		(o.BetragInklMwst-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(o.FWBetrag-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	ORDER BY o.Kreditor->Adresse->Adressnummer, o.Valutadatum, o.BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneFibuKontoJahr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,alle:%Boolean,manuelle:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,FibuKonto) As "Konto.Bezeichnung", 
			
			SUM(CASE Typ
					WHEN 0 THEN	Saldo
					ELSE (-1)*Saldo 
				END) AS "Saldo",
			SUM(CASE Typ
					WHEN 0 THEN	FWSaldo
					ELSE (-1)*FWSaldo 
				END) AS "SaldoFW"

 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND 
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			(:alle=1 OR NVL(ManuelleErfassung,0)=:manuelle)
 	GROUP BY FibuKonto->KontoNr
 	ORDER BY FibuKonto->KontoNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneFibuKontoPerDatumJ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,MandJahrOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,alle:%Boolean,manuelle:%Boolean,perDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	o.FibuKonto->KontoNr As "Konto.Nummer", 
			DBFibu.Konto_GetKontoBezeichnungClass(:MandJahrOid,o.FibuKonto) As "Konto.Bezeichnung", 
			SUM(CASE o.Typ
					WHEN 0 THEN	
						(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
					ELSE 
						(-1)*(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0))
				END) AS "Saldo",
			SUM(CASE o.Typ
					WHEN 0 THEN	
						(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0))
					ELSE 
						(-1)*(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0))
				END) AS "SaldoFW"

 	FROM DBDebiKredi.OPKredi o
 	WHERE o.Kreditor->Mandant=:MandantOid AND 
 			o.Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			o.Kreditor->Adresse->Adressnummer<=:bisAdrNr AND 
 			o.FibuKonto->KontoNr>=:vonKtoNr AND
 			o.FibuKonto->KontoNr<=:bisKtoNr AND
 			(:alle=1 OR NVL(ManuelleErfassung,0)=:manuelle) AND
 			o.Valutadatum<={d :perDatum} AND (
     		(NVL(o.BetragInklMwst,0)-NVL((SELECT SUM(NVL(oz.Zahlbetrag,0)+NVL(oz.SkontoAbzug,0)+NVL(oz.Kursdifferenz,0)) 
            		                FROM DBDebiKredi.OPZahlung oz 
                    		        WHERE oz.OP=o.ID AND 
                            		      oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0 OR 
      		(NVL(o.FWBetrag,0)-NVL((SELECT SUM(NVL(oz.FWZahlbetrag,0)+NVL(oz.FWSkontoAbzug,0)) 
                            FROM DBDebiKredi.OPZahlung oz 
                            WHERE oz.OP=o.ID AND 
                                  oz.Zahlung->Valutadatum<={d :perDatum}),0)) <> 0)
 	GROUP BY o.FibuKonto->KontoNr
 	ORDER BY o.FibuKonto->KontoNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlle">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,nurAdresse:%Boolean,AdressOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Buchungstext1,
			Zahlungskondition,
			Typ,
			FWBetrag,
			FWKurs,
			FWFaktor,
			ZKTage1,
			ZKTage2,
			ZKTage3,
			ZKProzentsatz1,
			ZKProzentsatz2,
			Waehrung->FWCode AS FWCode,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND
 			(:nurAdresse=0 OR Kreditor->Adresse=:AdressOid)
 	ORDER BY Kreditor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleManuelle">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,nurAdresse:%Boolean,AdressOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Buchungstext1,
			Zahlungskondition,
			Typ,
			FWBetrag,
			FWKurs,
			FWFaktor,
			ZKTage1,
			ZKTage2,
			ZKTage3,
			ZKProzentsatz1,
			ZKProzentsatz2,
			Waehrung->FWCode AS FWCode,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND 
 			NVL(ManuelleErfassung,0)=1 AND
 			(:nurAdresse=0 OR Kreditor->Adresse=:AdressOid)
 	ORDER BY Kreditor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeOffeneAlleAutomatische">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,nurAdresse:%Boolean,AdressOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Buchungstext1,
			Zahlungskondition,
			Typ,
			FWBetrag,
			FWKurs,
			FWFaktor,
			ZKTage1,
			ZKTage2,
			ZKTage3,
			ZKProzentsatz1,
			ZKProzentsatz2,
			Waehrung->FWCode AS FWCode,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			IsOPgeschlossen<>1 AND 
 			NVL(ManuelleErfassung,0)=0 AND
 			(:nurAdresse=0 OR Kreditor->Adresse=:AdressOid)
 	ORDER BY Kreditor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAlleAdr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,vonDatum:%Date,bisDatum:%Date,ohneVerrechnungen:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			0 As Skontoabzug,
			FWBetrag,
			0 As FWSkontoabzug,
			FWKurs,
			FWFaktor,
			Kreditor->Adresse As "Adresse.ID",
			Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Kreditor->Adresse->Strasse As "Adresse.Strasse",
			Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Kreditor->Adresse->Plz As "Adresse.Plz",
			Kreditor->Adresse->Ort As "Adresse.Ort",
			Kreditor->Adresse->Telefon1 As "Adresse.Telefon1",
			Kreditor->Fremdwaehrung->FWCode As "Fremdwaehrung.FWCode",
			Kreditor->Fremdwaehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Vertreter->Code As "Vertreter.Code",
			0 As "IsZahlung",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum}
 			
 	UNION ALL SELECT 	
 			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)) As BetragInklMwst,
			Skontoabzug,
			FWZahlbetrag As FWBetrag,
			FWSkontoabzug,
			FWKurs,
			FWFaktor,
			(SELECT Kreditor->Adresse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID",
			(SELECT Kreditor->Adresse->Adressnummer FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Adressnummer",
			(SELECT Kreditor->Adresse->Kurzname FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Kurzname",
			(SELECT DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Name",
			(SELECT Kreditor->Adresse->Strasse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Strasse",
			(SELECT Kreditor->Adresse->Hausnummer FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Hausnummer",
			(SELECT Kreditor->Adresse->Plz FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Plz",
			(SELECT Kreditor->Adresse->Ort FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Ort",
			(SELECT Kreditor->Adresse->Telefon1 FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.Telefon1",
			(SELECT Kreditor->Fremdwaehrung->FWCode FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.FWCode",
			(SELECT Kreditor->Fremdwaehrung->ISOSWIFTCode FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Fremdwaehrung.ISOSWIFTCode",
			(SELECT Vertreter->Code FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Vertreter.Code",
			1 As "IsZahlung",
			0 As "BankVerguetungscode",
			"" As RefNrGrund			
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPKredi 
 			WHERE Kreditor->Mandant=:MandantOid AND
 				Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 				Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum BETWEEN {d :vonDatum} AND {d :bisDatum} AND
 	(:ohneVerrechnungen=0 OR NVL(VerrechnungsNr,0)=0 OR 
 		VerrechnungsNr IN (SELECT NVL(Zahlung->VerrechnungsNr,0) 
 								FROM DBDebiKredi.OPZahlung
 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPDebi)) OR
 		VerrechnungsNr IN (SELECT NVL(OP->VerrechnungsNr,0) 
 								FROM DBDebiKredi.OPZahlung
 								WHERE OP IN (SELECT ID FROM DBDebiKredi.OPDebi))
 	)
 	ORDER BY "Adresse.Adressnummer", Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeAlleAdrVortrag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,vonAdrNr:%Integer,bisAdrNr:%Integer,vonKtoNr:%String,bisKtoNr:%String,bisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(BetragInklMwst) AS Betrag, SUM(FWBetrag) AS FWBetrag, "Adresse.ID" FROM (
	SELECT 	
			CASE WHEN Typ = 0 THEN BetragInklMwst ELSE (-1)*BetragInklMwst END AS BetragInklMwst,
			CASE WHEN Typ = 0 THEN FWBetrag ELSE (-1)*FWBetrag END AS FWBetrag,
			Kreditor->Adresse As "Adresse.ID"
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND
 			Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 			Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 			FibuKonto->KontoNr>=:vonKtoNr AND
 			FibuKonto->KontoNr<=:bisKtoNr AND
 			Valutadatum < {d :bisDatum}
 			
 	UNION ALL SELECT 	
			CASE WHEN Typ = 0 THEN (-1)*(NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)+NVL(Skontoabzug,0)) ELSE (NVL(Zahlbetrag,0)+NVL(Kursdifferenz,0)+NVL(Skontoabzug,0)) END As BetragInklMwst,
			CASE WHEN Typ = 0 THEN (-1)*(NVL(FWZahlbetrag,0)+NVL(FWSkontoabzug,0)) ELSE (NVL(FWZahlbetrag,0)+NVL(FWSkontoabzug,0)) END As FWBetrag,
			(SELECT Kreditor->Adresse FROM DBDebiKredi.OPKredi opd WHERE opd.ID=DBDebiKredi.Zahlung_GetFirstOP(z.ID)) As "Adresse.ID"
 	FROM DBDebiKredi.Zahlung z
 	WHERE ID IN (
 		SELECT Zahlung 
 		FROM DBDebiKredi.OPZahlung 
 		WHERE OP IN (
 			SELECT ID 
 			FROM DBDebiKredi.OPKredi 
 			WHERE Kreditor->Mandant=:MandantOid AND
 				Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 				Kreditor->Adresse->Adressnummer<=:bisAdrNr AND
 				FibuKonto->KontoNr>=:vonKtoNr AND
 				FibuKonto->KontoNr<=:bisKtoNr
 		)
 	) AND
 	Valutadatum < {d :bisDatum}
 	) GROUP BY "Adresse.ID"]]></SqlQuery>
</Query>

<Query name="ListeAlleAutomatische">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Buchungstext1,
			Zahlungskondition,
			Typ,
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid AND 
 			NVL(ManuelleErfassung,0)=0
 	ORDER BY Kreditor->Adresse->Adressnummer, Valutadatum, BelegNr]]></SqlQuery>
</Query>

<Query name="ListeMwstByCodes">
<Type>%SQLQuery</Type>
<FormalSpec>OpOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Mwst, 
           Mwst->MwstCode, 
           MwstSatz, 
           SUM(MwstBetrag) AS MwstBetrag, 
           SUM(BetragExklMwst) AS MwstBetragExkl,
           SUM(BetragInklMwst) AS MwstBetragInkl
    FROM DBDebiKredi.OPMwst
    WHERE OP=:OpOid
    GROUP BY Mwst ORDER BY MwstCode]]></SqlQuery>
</Query>

<Query name="ListeZahlungsvorschlag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,datumOhneInterval:%Date,datumMitInterval:%Date,vonAdrNr:%Integer,bisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			BelegNr,
			Buchungstext1,
			Buchungstext2,
			Valutadatum,
			Belegdatum,
			Typ,
			FibuKonto->KontoNr As "KontoNr", 
			BetragInklMwst,
			FWBetrag,
			ZKTage1,
			ZKTage2,
			ZKTage3,
			ZKProzentsatz1,
			ZKProzentsatz2,
			FibuBuchungsart,
			FibuBuchung->Journalnr As FibuJournalnr,
			Kreditor->Adresse As "Adresse.ID",
			Kreditor->Adresse->Adressnummer As "Adresse.Adressnummer",
			Kreditor->Adresse->Kurzname As "Adresse.Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Adresse.Name",
			Kreditor->Adresse->Strasse As "Adresse.Strasse",
			Kreditor->Adresse->Hausnummer As "Adresse.Hausnummer",
			Kreditor->Adresse->Plz As "Adresse.Plz",
			Kreditor->Adresse->Ort As "Adresse.Ort",
			Waehrung->FWCode As "Fremdwaehrung.FWCode",
			Waehrung->ISOSWIFTCode As "Fremdwaehrung.ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
	FROM DBDebiKredi.OPKredi 
	WHERE IsOPgeschlossen = 0 AND 
		Typ = 0 AND
		Kreditor->Mandant=:MandantOid AND 
		Kreditor->Adresse->Adressnummer>=:vonAdrNr AND
 		Kreditor->Adresse->Adressnummer<=:bisAdrNr AND (
		(DATEADD('dd',ZKTage1,Valutadatum) >= {d :datumOhneInterval} AND DATEADD('dd',ZKTage1,Valutadatum) <= {d :datumMitInterval} AND ZKTage1>0) OR 
		(DATEADD('dd',ZKTage2,Valutadatum) >= {d :datumOhneInterval} AND DATEADD('dd',ZKTage2,Valutadatum) <= {d :datumMitInterval} AND ZKTage2>0) OR 
		DATEADD('dd',ZKTage3,Valutadatum) <= {d :datumMitInterval}
		)
	ORDER BY Waehrung->FWCode, Kreditor->Adresse->Adressnummer, Valutadatum]]></SqlQuery>
</Query>

<Query name="ListeMarkiertAlsZahlvorschlag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,nurAdresse:%Boolean,AdressOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
			BelegNr,
			Saldo,
			Valutadatum,
			Belegdatum,
			Kreditor->Adresse As "Adresse",
			Kreditor->Adresse->Adressnummer As "Adressnummer",
			Kreditor->Adresse->Kurzname As "Kurzname",
			DBAdressen.Adresse_GetName(Kreditor->Adresse->Adresscode, Kreditor->Adresse->Name, Kreditor->Adresse->VornameZusatz1, 0) As "Name",
			Kreditor->Adresse->Plz As "Plz",
			Kreditor->Adresse->Ort As "Ort",
			Buchungstext1,
			Zahlungskondition,
			Typ,
			FWBetrag,
			ZKTage1,
			ZKTage2,
			ZKTage3,
			ZKProzentsatz1,
			ZKProzentsatz2,
			Waehrung->FWCode AS FWCode,
			Waehrung->ISOSWIFTCode As "ISOSWIFTCode",
			Bank->Verguetungscode As "BankVerguetungscode",
			RefNrGrund			
	FROM DBDebiKredi.OPKredi 
	WHERE IsOPgeschlossen = 0 AND 
		Kreditor->Mandant=:MandantOid AND 
		NVL(Zahlungsvorschlag,0) = 1 AND
 		(:nurAdresse=0 OR Kreditor->Adresse=:AdressOid)
	ORDER BY Waehrung->FWCode, Kreditor->Adresse->Adressnummer, Valutadatum]]></SqlQuery>
</Query>

<Query name="ListeDiffSuche">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID			
 	FROM DBDebiKredi.OPKredi
 	WHERE Kreditor->Mandant=:MandantOid
 	ORDER BY Kreditor->Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeVorzeitigeZahlungen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
		OP->Valutadatum As OpValuta, 
		Zahlung->Valutadatum As ZahlungValuta, 
		(SELECT Kreditor->Adresse->Adressnummer 
				FROM DBDebiKredi.OPKredi 
				WHERE ID=OP) As Adressnummer, 
		OP->BelegNr As OpBelegNr, 
		Zahlung->BelegNr As ZahlungBelegNr 
	FROM DBDebiKredi.OPZahlung 
	WHERE OP In (SELECT ID FROM DBDebiKredi.OPKredi WHERE Kreditor->Mandant=:MandantOid) AND 
		OP->Valutadatum>Zahlung->Valutadatum]]></SqlQuery>
</Query>
</Class>




<Class name="DBDebiKredi.AF.SD.DZahlungskondAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61319,42205.962347</TimeCreated>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID,Code, TageSatz1, ProzentSatz1, TageSatz2, ProzentSatz2,TageNetto,
			DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(ID, :MandantOid, :Lang) As Bezeichnung,
	   		FibuKonto, Mandant
 	FROM DBDebiKredi_SD.DZahlungskond
 	WHERE Mandant= :MandantOid
 	ORDER BY Code</SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.SD.KBankAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61319,42235.961788</TimeCreated>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
		Adresse,
		BankNr,
		Bankclearing,
		Bankname,
		Bezeichnung,
		IBANTyp,
		KontennrBank,
		Kostenschluessel,
		KtoBankIBAN,
		KtoBankPost,
		KtoBankPostClear,
		KtoBesrBic,
		LaengeBelegNr,
		Ort,
		SaveKonto,
		SaveText,
		StartBelegNr,
		Verguetungscode
	FROM DBDebiKredi_SD.KBank
 	WHERE Adresse->Adresse->Mandant= :MandantOid
 	ORDER BY BankNr]]></SqlQuery>
</Query>

<Query name="ListeByKreditor">
<Type>%SQLQuery</Type>
<FormalSpec>KrediOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID,
		Adresse,
		BankNr,
		Bankclearing,
		KtoBankPost,
		KtoBankPostClear,
		KtoBankIBAN,
		KtoBesrBic,
		Verguetungscode,
		Bezeichnung,
		Kostenschluessel,
		IBANTyp,
		Bankname,
		Ort,
		KontennrBank,
		SaveKonto,
		SaveText,
		LaengeBelegNr,
		StartBelegNr
	FROM DBDebiKredi_SD.KBank
 	WHERE Adresse = :KrediOid
 	ORDER BY BankNr</SqlQuery>
</Query>

<Query name="ListeByKontoESR">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Konto:%String,ESR:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT ID, 
           Adresse->Adresse->Adressnummer AS Adressnummer, 
           Adresse->Adresse->Name AS Name, 
           Adresse->Adresse->VornameZusatz1 AS VornameZusatz1, 
           Adresse->Adresse->Strasse AS Strasse, 
           Adresse->Adresse->Plz AS Plz, 
           Adresse->Adresse->Ort AS Ort, 
           Adresse->Adresse->Telefon1 AS Telefon1,
           Bankname,
           KtoBankPost,
           Verguetungscode
    FROM DBDebiKredi_SD.KBank
    WHERE Adresse->Adresse->Mandant=:MandantOid 
                   AND KtoBankPostClear=:Konto 
                   AND KtoBesrBic %STARTSWITH :ESR
                   AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3)]]></SqlQuery>
</Query>

<Query name="ListeByKonto">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Konto:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT ID, 
           Adresse->Adresse->Adressnummer AS Adressnummer, 
           Adresse->Adresse->Name AS Name, 
           Adresse->Adresse->VornameZusatz1 AS VornameZusatz1, 
           Adresse->Adresse->Strasse AS Strasse, 
           Adresse->Adresse->Plz AS Plz, 
           Adresse->Adresse->Ort AS Ort, 
           Adresse->Adresse->Telefon1 AS Telefon1,
           Bezeichnung AS Bankname,
           KtoBankPost,
           Verguetungscode
    FROM DBDebiKredi_SD.KBank
    WHERE Adresse->Adresse->Mandant=:MandantOid 
    		AND KtoBankPostClear=:Konto
    		AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3)]]></SqlQuery>
</Query>

<Query name="ListeDruck">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonAdresse:%String,BisAdresse:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
	       Adresse->Adresse->Adressnummer AS Adressnummer, 
           Adresse->Adresse->Name AS Name, 
           Adresse->Adresse->VornameZusatz1 AS VornameZusatz1, 
           Adresse->Adresse->Strasse AS Strasse, 
           Adresse->Adresse->Plz AS Plz, 
           Adresse->Adresse->Ort AS Ort, 
           Adresse->Adresse->Telefon1 AS Telefon1,
           Bezeichnung,
           BankNr,
           KtoBankPost,
           Verguetungscode,
           KtoBankIBAN
    FROM DBDebiKredi_SD.KBank
    WHERE (Adresse->Adresse->Adressnummer BETWEEN :VonAdresse and :BisAdresse) AND
    Adresse->Adresse->Mandant= :MandantOid
    ORDER BY Adresse->Adresse->Adressnummer]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.SD.KBankBuchAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61836,30592.41597</TimeCreated>

<Query name="ListeByBank">
<Type>%SQLQuery</Type>
<FormalSpec>bankOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, Nummer, Buchungstext1, Buchungstext2, FibuKonto->KontoNr As KontoNr 
	FROM DBDebiKredi_SD.KBankBuch
 	WHERE Bank=:bankOid
 	ORDER BY Nummer]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.SD.KZahlungskondAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61319,42266.35134</TimeCreated>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID,Code, TageSatz1, ProzentSatz1, TageSatz2, ProzentSatz2,TageNetto,
			DBDebiKredi_SD.KZahlungskond_GetBezeichnungClass(ID, :MandantOid, :Lang) As Bezeichnung,
	   		FibuKonto, Mandant
 	FROM DBDebiKredi_SD.KZahlungskond
 	WHERE Mandant= :MandantOid
 	ORDER BY Code</SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.SD.MahntypAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61767,53649.592375</TimeCreated>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID, Code, KeineMahnungBisBetrag, Mahngebuehr, MahngebuehrNachAnzTagen, VerzugszinsProzent,
			DBDebiKredi_SD.Mahntyp_GetBezeichnungClass(ID, :MandantOid, :Lang) As Bezeichnung,
	   		Funktion, Mandant
 	FROM DBDebiKredi_SD.Mahntyp
 	WHERE Mandant= :MandantOid
 	ORDER BY Code</SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.AF.ZahlungAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,32665</TimeChanged>
<TimeCreated>61717,33192.38661</TimeCreated>

<Query name="ListeUnverbuchteKrediZahlungen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,WaehrungOid:%String,VonAdrNr:%Integer,BisAdrNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Zahlung As ZahlungID, OP->Fibukonto As OpFibuKonto, OP
	FROM DBDebiKredi.OPZahlung
	WHERE NVL(Zahlung->Verbuchungsjnr, 0) <= 0
		AND Zahlung->Waehrung=:WaehrungOid
		AND (Zahlbetrag > 0 OR Skontoabzug > 0)
		AND OP IN (SELECT ID
			FROM DBDebiKredi.OPKredi
			WHERE Kreditor->Mandant=:MandantOid
			AND Kreditor->Adresse->Adressnummer>=:VonAdrNr
			AND Kreditor->Adresse->Adressnummer<=:BisAdrNr)]]></SqlQuery>
</Query>

<UDLText name="T">
<Content><![CDATA[
// AND NVL(Zahlung->VerrechnungsNr, 0) = 0 AND Zahlung->Typ = 0

]]></Content>
</UDLText>

<Query name="ListeDtaDruck">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Verbuchungsjnr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
		o.ID As OpID,
		o.Kreditor->Adresse->Adressnummer As "op.Kreditor.Adressnummer",
		o.Kreditor->Adresse->Name As "op.Kreditor.Name",
		o.Kreditor->Adresse->VornameZusatz1 As "op.Kreditor.VornameZusatz1",
		o.Kreditor->Adresse->Strasse As "op.Kreditor.Strasse",
		o.Kreditor->Adresse->Plz As "op.Kreditor.Plz",
		o.Kreditor->Adresse->Ort As "op.Kreditor.Ort",
		
		o.Bank->Bankclearing As "op.Bank.ClearingNr",
		o.Bank->KtoBankPost As "op.Bank.KtoBankPost",
		o.Bank->KtoBankIBAN As "op.Bank.KtoBankIBAN",
		o.Bank->Bankname As "op.Bank.Bankname",
		o.Bank->Ort As "op.Bank.Ort",
		o.Bank->KtoBesrBic As "op.Bank.KtoBesrBic",
		o.Bank->Verguetungscode As "op.Bank.Verguetungscode",
		
		o.RefNrGrund As "op.RefNrGrund",
		o.Belegnr As "op.Belegnr",
		
		z.ID As ZahlungID,
		z.Valutadatum As "zahlung.Valutadatum", 
		z.Zahlbetrag As "zahlung.Zahlbetrag", 
		z.FWZahlbetrag As "zahlung.FWZahlbetrag", 
		z.Waehrung->ISOSwiftCode As "zahlung.WaehrungISO",
		z.Waehrung->FWCode As "zahlung.WaehrungCode"

	FROM (DBDebiKredi.Zahlung As z JOIN DBDebiKredi.OPZahlung As oz ON z.ID=oz.Zahlung) JOIN DBDebiKredi.OPKredi As o ON o.ID=oz.OP

	WHERE z.Verbuchungsjnr=:Verbuchungsjnr AND
		o.Kreditor->Mandant=:MandantOid AND
		NVL(z.VerrechnungsNr, 0) = 0 AND 
		z.Typ = 0 AND
		z.Zahlbetrag > 0
		
	ORDER BY z.Valutadatum, o.Kreditor->Adresse->Adressnummer, o.Belegnr]]></SqlQuery>
</Query>

<Query name="ListeZahlungsjournalDruck">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Verbuchungsjnr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
		o.ID As OpID,
		o.Kreditor->Adresse->Adressnummer As "op.Kreditor.Adressnummer",
		o.Kreditor->Adresse->Name As "op.Kreditor.Name",
		o.Kreditor->Adresse->VornameZusatz1 As "op.Kreditor.VornameZusatz1",
		o.Kreditor->Adresse->Strasse As "op.Kreditor.Strasse",
		o.Kreditor->Adresse->Plz As "op.Kreditor.Plz",
		o.Kreditor->Adresse->Ort As "op.Kreditor.Ort",
		o.Belegnr As "op.Belegnr",
		o.Valutadatum As "op.Valutadatum", 
		
		z.ID As ZahlungID,
		z.Belegnr As "zahlung.Belegnr",
		z.Buchungstext1 As "zahlung.Buchungstext1",
		z.Valutadatum As "zahlung.Valutadatum", 
		z.Zahlbetrag As "zahlung.Zahlbetrag", 
		z.FWZahlbetrag As "zahlung.FWZahlbetrag", 
		z.Skontoabzug As "zahlung.Skontoabzug", 
		z.FWSkontoabzug As "zahlung.FWSkontoabzug", 
		z.Typ As "zahlung.Typ", 
		z.FibuBuchung->Journalnr As "zahlung.Fibubuchung.Journalnr",
		z.Waehrung->ISOSwiftCode As "zahlung.Waehrung.ISO",
		z.Waehrung->FWCode As "zahlung.Waehrung.Code"

	FROM (DBDebiKredi.Zahlung As z JOIN DBDebiKredi.OPZahlung As oz ON z.ID=oz.Zahlung) JOIN DBDebiKredi.OPKredi As o ON o.ID=oz.OP

	WHERE z.Verbuchungsjnr=:Verbuchungsjnr AND
		o.Kreditor->Mandant=:MandantOid
		
	ORDER BY z.Valutadatum, o.Kreditor->Adresse->Adressnummer, o.Belegnr]]></SqlQuery>
</Query>

<Query name="ZahlungKredibyFibuBuch">
<Type>%SQLQuery</Type>
<FormalSpec>buchungOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT oz.ID,
			o.Kreditor->Adresse->ID AS "AdressOid",
			o.Kreditor->Adresse->Adressnummer AS "Adressnummer",
			o.Kreditor->Adresse->Kurzname AS "Kurzname",
			o.Kreditor->Adresse->Name AS "Name",
			o.Kreditor->Adresse->Ort AS "Ort",
			oz.Zahlung->Valutadatum,
			oz.Zahlung->Belegnr,
			oz.Zahlung->Zahlbetrag,
			oz.Zahlung->Skontoabzug,
			oz.Zahlung->FWZahlbetrag,
			oz.Zahlung->FWSkontoabzug,
			oz.Zahlung->Typ,
			oz.Zahlung->Waehrung->FWCode,
			oz.Zahlung->FibuKonto,
			oz.Zahlung->VerrechnungsNr
	FROM DBDebiKredi.OPZahlung As oz JOIN DBDebiKredi.OPKredi As o ON o.ID=oz.OP
	WHERE oz.Zahlung->FibuBuchung=:buchungOid]]></SqlQuery>
</Query>

<Query name="ZahlungDebibyFibuBuch">
<Type>%SQLQuery</Type>
<FormalSpec>buchungOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT oz.ID,
			o.Debitor->Adresse->ID AS "AdressOid",
			o.Debitor->Adresse->Adressnummer AS "Adressnummer",
			o.Debitor->Adresse->Kurzname AS "Kurzname",
			o.Debitor->Adresse->Name AS "Name",
			o.Debitor->Adresse->Ort AS "Ort",
			oz.Zahlung->Valutadatum,
			oz.Zahlung->Belegnr,
			oz.Zahlung->Zahlbetrag,
			oz.Zahlung->Skontoabzug,
			oz.Zahlung->FWZahlbetrag,
			oz.Zahlung->FWSkontoabzug,
			oz.Zahlung->Typ,
			oz.Zahlung->Waehrung->FWCode,
			oz.Zahlung->FibuKonto,
			oz.Zahlung->VerrechnungsNr
	FROM DBDebiKredi.OPZahlung As oz JOIN DBDebiKredi.OPDebi As o ON o.ID=oz.OP
	WHERE oz.Zahlung->FibuBuchung=:buchungOid]]></SqlQuery>
</Query>

<Query name="ListeVerbuchungsjnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Zahlung->Verbuchungsjnr AS Verbuchungsjnr,
			MAX(Zahlung->Valutadatum) As Datum 
		FROM DBDebiKredi.OPZahlung 
		WHERE OP IN (SELECT ID 
				FROM DBDebiKredi.OPKredi 
				WHERE Kreditor->Mandant=:MandantOid)
		GROUP BY Zahlung->Verbuchungsjnr
		ORDER BY Zahlung->Verbuchungsjnr]]></SqlQuery>
</Query>

<Query name="ZahlungByBetrag">
<Type>%SQLQuery</Type>
<FormalSpec>opOid:%String,valutadatum:%Date,betrag:%Decimal</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT TOP 1 Zahlung 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP=:opOid AND
					Zahlung->Zahlbetrag=:betrag AND
					Zahlung->Valutadatum=TO_DATE(:valutadatum)]]></SqlQuery>
</Query>

<Query name="ListeZahlungenByVerrechnungsnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VerrechnungsNr:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Zahlung, 
			Zahlung->FibuBuchung AS FibuBuchung,
			Zahlung->Zahlbetrag AS Zahlbetrag,
			Zahlung->Skontoabzug AS Skontoabzug,
			Zahlung->FWZahlbetrag AS FWZahlbetrag,
			Zahlung->FWSkontoabzug AS FWSkontoabzug,
			Zahlung->Typ AS Typ
		FROM DBDebiKredi.OPZahlung 
		WHERE Zahlung->VerrechnungsNr=:VerrechnungsNr AND
			(OP IN (SELECT ID 
				FROM DBDebiKredi.OPKredi 
				WHERE Kreditor->Mandant=:MandantOid)
			OR OP IN (SELECT ID 
				FROM DBDebiKredi.OPDebi 
				WHERE Debitor->Mandant=:MandantOid))]]></SqlQuery>
</Query>

<Query name="ListeDiffSuche">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Zahlung
		FROM DBDebiKredi.OPZahlung 
		WHERE OP IN (SELECT ID 
				FROM DBDebiKredi.OPDebi 
				WHERE Debitor->Mandant=:MandantOid)]]></SqlQuery>
</Query>

<Query name="ListeDebiZahlungsjournal">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VerbuchungsjnrManuell:%Integer,bisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
		o.Debitor->Adresse->Adressnummer As "op.Debitor.Adressnummer",
		o.Debitor->Adresse->Name As "op.Debitor.Name",
		o.Debitor->Adresse->VornameZusatz1 As "op.Debitor.VornameZusatz1",
		o.Debitor->Adresse->Plz As "op.Debitor.Plz",
		o.Debitor->Adresse->Ort As "op.Debitor.Ort",
		o.BelegNr As "op.BelegNr",
		o.Valutadatum As "op.Valutadatum", 
		CASE 
			WHEN o.Typ=5 THEN
				(-1)*o.BetragInklMwst
			ELSE
				o.BetragInklMwst
		END As "op.BetragInklMwst",
		
		o.FibuKonto->KontoNr As "op.KontoNr",
			
		z.ID as "zahlung.ID",	
		z.Valutadatum As "zahlung.Valutadatum", 
		CASE 
			WHEN o.Typ=5 THEN
				(-1)*z.Zahlbetrag 
			ELSE
				z.Zahlbetrag
		END As "zahlung.Zahlbetrag", 
		z.Buchungstext1 As "zahlung.Buchungstext1", 
		z.Skontoabzug As "zahlung.Skontoabzug",
		z.FibuKonto->KontoNr As "zahlung.KontoNr"
		
	FROM (DBDebiKredi.Zahlung As z JOIN DBDebiKredi.OPZahlung As oz ON z.ID=oz.Zahlung) JOIN DBDebiKredi.OPDebi As o ON o.ID=oz.OP
	
	WHERE (NVL(z.ManuelleErfassung,0) = 1 OR NVL(z.VerrechnungsNr,0) <> 0) AND 
		NVL(z.VerbuchungsjnrManuell,0) = :VerbuchungsjnrManuell AND 
		o.Debitor->Mandant=:MandantOid AND
		z.Valutadatum <= {d :bisDatum}]]></SqlQuery>
</Query>

<Query name="ListeManuelleVerbuchungsjnr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Zahlung->VerbuchungsjnrManuell As VerbuchungsjnrManuell,
			MAX(Zahlung->Valutadatum) As Datum 
	FROM DBDebiKredi.OPZahlung 
	WHERE OP IN (SELECT ID 
				FROM DBDebiKredi.OPDebi 
				WHERE Debitor->Mandant=:MandantOid) AND 
			Zahlung->VerbuchungsjnrManuell IS NOT NULL
	GROUP BY Zahlung->VerbuchungsjnrManuell
	ORDER BY Zahlung->VerbuchungsjnrManuell]]></SqlQuery>
</Query>
</Class>


<Class name="DBDebiKredi.Debitor">
<Description>
</Description>
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61100,61878.174169</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
</Index>

<Property name="MwstSteuerungInklExkl">
<Description>
MWST Code</Description>
<Type>%Integer</Type>
</Property>

<Property name="Rabatt">
<Description>
Rabatt</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="LSVBankleitzahl">
<Description>
LSV Bankleitzahl</Description>
<Type>%Integer</Type>
</Property>

<Property name="LSVBankKontoNr">
<Description>
LSV Bank-Kontonummer</Description>
<Type>%String</Type>
</Property>

<Property name="SteuerNr">
<Description>
MWSTNummer</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="50"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Mahnung">
<Description>
Mahnung</Description>
<Type>%Integer</Type>
</Property>

<Property name="Kreditlimit">
<Description>
Kreditlimit</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="DatumLetzteBewegung">
<Description>
Letzte Bewegung</Description>
<Type>%Date</Type>
</Property>

<Property name="EUUstNr">
<Type>%String</Type>
<Parameter name="MAXLEN" value="50"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="UstIdNr">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Kundenidentifikation">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="SkontoBarzahlung">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="SpezArtikelAnsicht">
<Type>%Boolean</Type>
<InitialExpression>"0"</InitialExpression>
</Property>

<Property name="BestNrAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="RabattAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BestMengeAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="VorschlagBesteller">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="VorschlagReferenz">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="WebEdiId">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="WebEdiId2">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="HerkunftAktiv">
<Description>
HerkunftAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="Zahladresse">
<Description>
Zahladresse</Description>
<Type>DBDebiKredi.Debitor</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorZahladresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahladresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="DebitorZahladresse">
<Type>DBDebiKredi.Debitor</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahladresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FibuKonto">
<Description>
Sammelkonto Fibu</Description>
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Property name="Fremdwaehrung">
<Description>
Fremdwährung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorFremdwaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Fremdwaehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FremdwaehrungIndex">
<Properties>Fremdwaehrung</Properties>
</Index>

<Property name="Bank">
<Description>
Bank</Description>
<Type>DBFibu.SD.Bank</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorBank</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Bank"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="BankIndex">
<Properties>Bank</Properties>
</Index>

<Property name="Zahlungskondition">
<Description>
Zahlungs Konditionen</Description>
<Type>DBDebiKredi.SD.DZahlungskond</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorZahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahlungskondition"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ZahlungskonditionIndex">
<Properties>Zahlungskondition</Properties>
</Index>

<Property name="Adresse">
<Type>DBAdressen.Adresse</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Adresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="AdresseIndex">
<Properties>Mandant,Adresse</Properties>
<Unique>1</Unique>
</Index>

<Property name="AKAdresse">
<Type>DBAgrofresh.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Adresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="AKZahlAdresse">
<Type>DBAgrofresh.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ZahlAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="KundenPreis">
<Type>DBAgrofresh.KundenPreis</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="OPDebiDebitor">
<Type>DBDebiKredi.OPDebi</Type>
<Cardinality>many</Cardinality>
<Inverse>Debitor</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ChargenAusgangKunde">
<Type>DBAgrofreshEK.ChargenAusgang</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Umsatz">
<Type>DBDebiKredi.DebitorUmsatz</Type>
<Cardinality>children</Cardinality>
<Inverse>Debitor</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="Lieferart">
<Type>DBAgrofresh.SD.Lieferart</Type>
<Cardinality>one</Cardinality>
<Inverse>AdressVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Lieferart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="LieferartIndex">
<Properties>Lieferart</Properties>
</Index>

<Property name="Bestellart">
<Type>DBAgrofresh.SD.Bestellart</Type>
<Cardinality>one</Cardinality>
<Inverse>AdressVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Bestellart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="BestellartIndex">
<Properties>Bestellart</Properties>
</Index>

<Property name="KundenGebPreis">
<Type>DBAgrofresh.KundenGebPreis</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktLieferart">
<Type>DBFakturierung.SD.Lieferart</Type>
<Cardinality>one</Cardinality>
<Inverse>AdressVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FaktLieferart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FaktLieferartIndex">
<Properties>FaktLieferart</Properties>
</Index>

<Property name="FaktBestellart">
<Type>DBFakturierung.SD.Bestellart</Type>
<Cardinality>one</Cardinality>
<Inverse>FaktAdrVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FaktBestellart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FaktBestellartIndex">
<Properties>FaktBestellart</Properties>
</Index>

<Property name="VerarbAuftrag">
<Type>DBAgrofreshEK.VerarbAuftrag</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ChargeAktiv">
<Description>
ChargeAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="GebindeAktiv">
<Description>
GebindeAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="AnzJeGebindeAktiv">
<Description>
AnzJeGebindeAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="AnzahlAktiv">
<Description>
AnzahlAktiv</Description>
<Type>%Boolean</Type>
<InitialExpression>"1"</InitialExpression>
</Property>

<Property name="DetPreisAktiv">
<Description>
Detail Preis Aktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintMailAdr">
<Description>
E-mail adresse für beim Formulardruck</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PrintMailSubject">
<Description>
E-mail Betreff für beim Formulardruck</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PrintMailText">
<Type>DBCore.ReportMailText</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorPrintText</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="PrintMailText"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="PrintMailTextIndex">
<Properties>PrintMailText</Properties>
</Index>

<Property name="FaktAKAdresse">
<Type>DBFakturierung.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Adresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktAKZahlAdresse">
<Type>DBFakturierung.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ZahlAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktKundenPreis">
<Type>DBFakturierung.KundenPreis</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Fax">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Mobil">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PlattformBestKopf">
<Type>DBPlattform.BestKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Abnehmer</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Angebot">
<Type>DBPlattform.AngebotsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Abnehmer</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="PlattformAuftragsKopf">
<Type>DBPlattform.AuftragsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Abnehmer</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ArtikelCodeAktiv">
<Description>
Artikelcode Aktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BestellungAbnehmer">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Abnehmner</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="PrintMailAdrCC">
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="GlobalCompanyPrefix">
<Type>%String</Type>
<Parameter name="MAXLEN" value="11"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="AuftragErfassungInaktiv">
<Description>
Kunde für Auftragserfassung gesperrt.</Description>
<Type>%Boolean</Type>
</Property>

<Property name="VorschlagMitarbeiter">
<Type>DBAdressen.Mitarbeiter</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="VorschlagMitarbeiter"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="PrintDefEtiAktivState">
<Description>
Vorschlag ob Etikettendruck aktiv ist (0-wenn modul Print aktiv, 1-Ja, 2-Nein)</Description>
<Type>%Integer</Type>
</Property>

<Property name="PrintDefFaxAktiv">
<Description>
Vorschlag ob Formular als Fax versenden</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintDefMailAktiv">
<Description>
Vorschlag ob Formular als Mail versenden</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintDefEtiketten">
<Description>
Vorschlag ob Etikettendruck aktiv ist (0-wenn modul Print aktiv, 1-Ja, 2-Nein)</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintDefFax">
<Description>
Vorschlag ob Formular als Fax versenden</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintDefMail">
<Description>
Vorschlag ob Formular als Mail versenden</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="AktionspreisKopf">
<Type>DBAgrofresh.AktionspreisKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="LieferartWriteBack">
<Description>
Einsellung ob Lieferart zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BestellartWriteBack">
<Description>
Einsellung ob Bestellart zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BestellerWriteBack">
<Description>
Einsellung ob Besteller zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="ReferenzWriteBack">
<Description>
Einsellung ob Referenz zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="Zeitraster">
<Type>DBPlattform.SD.Zeitraster</Type>
<Cardinality>many</Cardinality>
<Inverse>Debitor</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="GebietWriteBack">
<Description>
Einsellung ob Gebiet zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="VorschlagGebiet">
<Type>DBAdressen.SD.Gebiet</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="VorschlagGebiet"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="KundenNrHogaShop">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="FaktAKZusatzAdresse">
<Type>DBFakturierung.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ZusatzAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="MecanoArtikel">
<Type>DBSpezial.Mecano.Artikel</Type>
<Cardinality>many</Cardinality>
<Inverse>Kunde</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="HogaShopAktiv">
<Description>
Einsellung ob Kunde für Hogashop aktiv ist</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintDefOutlook">
<Description>
Vorschlag ob Formular als Mail versenden</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="VorschlagLieferzeit">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="LieferzeitWriteBack">
<Description>
Einsellung ob Lieferzeit zurückschreiben</Description>
<Type>%Boolean</Type>
</Property>

<Property name="LieferdatumAktiv">
<Description>
LieferdatumAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="SSCCGenerierung">
<Description>
SSCCGenerierung</Description>
<Type>%Integer</Type>
<InitialExpression>1</InitialExpression>
</Property>

<Property name="RuestdatumArt">
<Type>%Integer</Type>
</Property>

<Property name="RuestdatumArtNB">
<Type>%Integer</Type>
</Property>

<Method name="GetPrintDefFax">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefFax.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefFax">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefFax.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefMail">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefMail.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefMail">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefMail.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefOutlook">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefOutlook.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefOutlook">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefOutlook.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefEtiketten">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefEtiketten.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefEtiketten">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefEtiketten.SetAt(value, typ)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzHabenEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzHabenEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzHabenTotalEwClass(ID)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzHabenTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenEw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenTotalEw(mandJahr, waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzHabenEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzSollEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollTotalEwClass(ID)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzSollTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollEw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollTotalEw(mandJahr, waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzSollEw(mandJahr, KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Vorjahr Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzHabenVjEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzHabenVjEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzHabenVjTotalEwClass(ID)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzHabenVjTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenVjEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenVjEw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenVjTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzHabenVjEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Vorjahr Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollVjEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzSollVjEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollVjTotalEwClass(ID)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetUmsatzSollVjTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollVjEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollVjEw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollVjTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzSollVjEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldovortrag Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldovortragEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(SaldovortragEw) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.SaldovortragEw
		}
	}
]]></Implementation>
</Method>

<Method name="SetSaldovortragEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set debiUmsatz = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1)
	Set debiUmsatz.SaldovortragEw = betrag
	Set status = debiUmsatz.%Save()
	Quit status
]]></Implementation>
</Method>

<Method name="GetSaldovortragEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetSaldovortragEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetSaldovortragEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetSaldovortragEw(mandJahr, waehrungOid, betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldo Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldoEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetSaldoEwClass(ID)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.GetSaldoEw()
		}
	}
]]></Implementation>
</Method>

<Method name="GetSaldoEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetSaldoEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzHabenFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzHabenTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenFw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzHabenFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzSollFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzSollTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollFw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzSollFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Vorjahr Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzHabenVjFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzHabenVjTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenVjFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenVjFw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzHabenVjTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzHabenVjFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Vorjahr Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzSollVjFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzSollVjTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollVjFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollVjFw(mandJahr, KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetUmsatzSollVjTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetUmsatzSollVjFw(mandJahr, KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldovortrag Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldovortragFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(SaldovortragFw) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (du = "") {
			Quit 0
		} else {
			Quit du.SaldovortragFw
		}
	}
]]></Implementation>
</Method>

<Method name="SetSaldovortragFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set debiUmsatz = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,1)
	Set debiUmsatz.SaldovortragFw = betrag
	Set status = debiUmsatz.%Save()
	Quit status
]]></Implementation>
</Method>

<Method name="GetSaldovortragFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetSaldovortragFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetSaldovortragFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).SetSaldovortragFw(mandJahr,waehrungOid, betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldo Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldoFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetSaldoFw()
	}
]]></Implementation>
</Method>

<Method name="GetSaldoFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Debitor).%OpenId(debiOid).GetSaldoFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben über alle Währungen

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenAlleWaehrungen">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set du = ##class(DBDebiKredi.DebitorUmsatz).GetDebitorUmsatz(..%Id(),mandJahr,"",0)
	if (du = "") {
		Quit 0
	} else {
		Quit du.GetUmsatzHabenEw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetIdByWebEdiId">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandOid:%String,webEdiId:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Debitor WHERE WebEdiId = :webEdiId AND Mandant = :MandOid)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetIdByUstId">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandOid:%String,UstId:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Debitor WHERE UstIdNr = :UstId AND Mandant = :MandOid)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetIdByAdrNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Debitor WHERE Mandant = :MandantOid
		 AND Adresse->Adressnummer = :AdrNr)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetIdByAdrOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Debitor WHERE Mandant = :MandantOid
			AND Adresse = :AdrOid)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetAdrNrById">
<ClassMethod>1</ClassMethod>
<FormalSpec>id:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set adrNr = ""
	&sql(SELECT Adresse->Adressnummer INTO :adrNr FROM DBDebiKredi.Debitor WHERE ID = :id)
	Quit:(SQLCODE'=0) 0
	Quit adrNr
]]></Implementation>
</Method>

<Method name="GetAdrOidById">
<ClassMethod>1</ClassMethod>
<FormalSpec>id:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set adrId = ""
	&sql(SELECT Adresse->ID INTO :adrId FROM DBDebiKredi.Debitor WHERE ID = :id)
	Quit:(SQLCODE'=0) ""
	Quit adrId
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%Delete</METHOD> method to 
provide notification that the object specified by <VAR>oid</VAR> is being deleted.

<P>If this method returns an error then the object will not be deleted.
[Previously private]]]></Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	set debOid = $lg(oid,1)
    
    do ..DeleteRelations(debOid)	
	
	Quit $$$OK
]]></Implementation>
</Method>

<Trigger name="trgBeforeDelete">
<Code>	new myId
	
	Set myId = {ID}
    
	do ..DeleteRelations(myId)</Code>
<Event>DELETE</Event>
</Trigger>

<Method name="DeleteRelations">
<ClassMethod>1</ClassMethod>
<FormalSpec>debOid:%String</FormalSpec>
<Implementation><![CDATA[
	//wenn Zahladresse auf den selben Debitor verweist -> nullen
	//damit der Debitor gelöscht werden kann
	set deb = ##class(DBDebiKredi.Debitor).%OpenId(debOid)
	if (deb '= "") {
		if (deb.Zahladresse '= "") {
			set zahladrId = deb.Zahladresse.%Id()
			if (zahladrId = debOid) {
				set deb.Zahladresse = ""
				do deb.%Save()
			}
		}
	}
	set deb = ""
]]></Implementation>
</Method>

<Method name="RecalcUmsatz">
<ClassMethod>1</ClassMethod>
<FormalSpec>mandantOid:%String</FormalSpec>
<Implementation><![CDATA[
	set myId = ""
	&sql(DECLARE C1 CURSOR FOR
    		SELECT ID InTo :myId
    		FROM DBDebiKredi.DebitorUmsatz 
    		WHERE Debitor->Mandant=:mandantOid)
    		
 	&sql(OPEN C1)
 	&sql(FETCH C1)
 	
 	While (SQLCODE = 0) {
	 	
	 	Set res = ##class(DBDebiKredi.DebitorUmsatz).%DeleteId(myId)
		if ($$$ISERR(res)) {
			w "DBDebiKredi.Debitor.RecalcUmsatz - Fehler beim Loeschen! "_res,!
		}
		
    	&sql(FETCH C1)
 	}
 	
    &sql(CLOSE C1)
    
	
    set debitor = ""
    set betragInklMwst = 0
    set fwBetrag = 0
    set valutadatum = 0
    set waehrung = ""
    set typ = 0
	&sql(DECLARE C2 CURSOR FOR
    		SELECT Debitor, BetragInklMwst, FWBetrag, Valutadatum, Waehrung, Typ 
    			InTo :debitor, :betragInklMwst, :fwBetrag, :valutadatum, :waehrung, :typ 
    		FROM DBDebiKredi.OPDebi 
    		WHERE Debitor->Mandant=:mandantOid)
    		
 	&sql(OPEN C2)
 	&sql(FETCH C2)
 	
 	While (SQLCODE = 0) {
	 	
 		Set faktor = 1
		if (typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()) {
			Set faktor = -1
		}
		Set betragEw = (faktor * betragInklMwst)
		Set betragFw = (faktor * fwBetrag)
		//Set datum = $ZDATEH(valutadatum,5)
		Set datum = valutadatum
		if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(betragEw, betragFw, datum, debitor, waehrung, 0)
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(betragEw, betragFw, datum, debitor, waehrung, 0)
		}
		
    	&sql(FETCH C2)
 	}
 	
    &sql(CLOSE C2)
    
    
    set debitor = ""
    set zahlbetrag = 0
    set skontoAbzug = 0
    set fwZahlbetrag = 0
    set fwSkontoAbzug = 0
    set valutadatum = 0
    set waehrung = ""
    set typ = 0
    &sql(DECLARE C3 CURSOR FOR
    		SELECT (SELECT Debitor 
    				FROM DBDebiKredi.OPDebi 
    				WHERE ID=OP) As Debitor, 
    				Zahlbetrag, SkontoAbzug, FWZahlbetrag, FWSkontoAbzug, Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ 
    			InTo :debitor, :zahlbetrag, :skontoAbzug, :fwZahlbetrag, :fwSkontoAbzug, :valutadatum, :waehrung, :typ
    		FROM DBDebiKredi.OPZahlung 
    		WHERE OP IN (SELECT ID 
    					 FROM DBDebiKredi.OPDebi 
    					 WHERE Debitor->Mandant=:mandantOid))
    						
    		
 	&sql(OPEN C3)
 	&sql(FETCH C3)
 	
 	While (SQLCODE = 0) {
	 	
		Set faktor = 1
		if ((typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
			Set faktor = -1
		}
		Set betragEw = (faktor * (zahlbetrag+skontoAbzug))
		Set betragFw = (faktor * (fwZahlbetrag+fwSkontoAbzug))
		//Set datum = $ZDATEH(valutadatum, 5)
		Set datum = valutadatum
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(betragEw, betragFw, datum, debitor, waehrung, 0)
				
    	&sql(FETCH C3)
 	}
 	
    &sql(CLOSE C3)
]]></Implementation>
</Method>

<Method name="GetDebiIdByHogaShopNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>KundenNrHoga:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Debitor WHERE KundenNrHogaShop = :KundenNrHoga)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetFirmaTextByAdrOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>AdrOid:%String,DebiMandant:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	&sql(SELECT Kundenidentifikation INTO :text FROM DBDebiKredi.Debitor WHERE Adresse = :AdrOid AND Mandant = :DebiMandant)
	Quit:(SQLCODE'=0) ""
	Quit text
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myOid:%String,mandJahr:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set total = 0
	&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollPeriodeEwClass(ID,:vonPeriode,:bisPeriode)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
	Quit total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myOid:%String,mandJahr:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set total = 0
	&sql(SELECT SUM(DBDebiKredi.DebitorUmsatz_GetUmsatzSollPeriodeVjEwClass(ID,:vonPeriode,:bisPeriode)) INTO :total FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:myOid AND MandantJahr=:mandJahr)
	Quit total
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.DebitorD</DataLocation>
<DefaultData>DebitorDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.DebitorD</IdLocation>
<IndexLocation>^DBDebiKredi.DebitorI</IndexLocation>
<StreamLocation>^DBDebiKredi.DebitorS</StreamLocation>
<Data name="DebitorDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>MwstSteuerungInklExkl</Value>
</Value>
<Value name="3">
<Value>Rabatt</Value>
</Value>
<Value name="4">
<Value>LSVBankleitzahl</Value>
</Value>
<Value name="5">
<Value>LSVBankKontoNr</Value>
</Value>
<Value name="6">
<Value>SteuerNr</Value>
</Value>
<Value name="7">
<Value>Mahnung</Value>
</Value>
<Value name="8">
<Value>Kreditlimit</Value>
</Value>
<Value name="9">
<Value>DatumLetzteBewegung</Value>
</Value>
<Value name="10">
<Value>Saldovortrag</Value>
</Value>
<Value name="11">
<Value>EUUstNr</Value>
</Value>
<Value name="12">
<Value>Zahladresse</Value>
</Value>
<Value name="13">
<Value>FibuKonto</Value>
</Value>
<Value name="14">
<Value>Fremdwaehrung</Value>
</Value>
<Value name="15">
<Value>Bank</Value>
</Value>
<Value name="16">
<Value>Zahlungskondition</Value>
</Value>
<Value name="17">
<Value>Adresse</Value>
</Value>
<Value name="18">
<Value>UstIdNr</Value>
</Value>
<Value name="19">
<Value>Kundenidentifikation</Value>
</Value>
<Value name="20">
<Value>SkontoBarzahlung</Value>
</Value>
<Value name="21">
<Value>SpezArtikelAnsicht</Value>
</Value>
<Value name="22">
<Value>Lieferart</Value>
</Value>
<Value name="23">
<Value>BestNrFokusieren</Value>
</Value>
<Value name="24">
<Value>VorschlagBesteller</Value>
</Value>
<Value name="25">
<Value>VorschlagReferenz</Value>
</Value>
<Value name="26">
<Value>Bestellart</Value>
</Value>
<Value name="27">
<Value>WebEdiId</Value>
</Value>
<Value name="28">
<Value>BestNrAktiv</Value>
</Value>
<Value name="29">
<Value>RabattAktiv</Value>
</Value>
<Value name="30">
<Value>BestMengeAktiv</Value>
</Value>
<Value name="31">
<Value>FaktLieferart</Value>
</Value>
<Value name="32">
<Value>FaktBestellart</Value>
</Value>
<Value name="33">
<Value>WebEdiId2</Value>
</Value>
<Value name="34">
<Value>HerkunftAktiv</Value>
</Value>
<Value name="35">
<Value>ChargeAktiv</Value>
</Value>
<Value name="36">
<Value>GebindeAktiv</Value>
</Value>
<Value name="37">
<Value>AnzJeGebindeAktiv</Value>
</Value>
<Value name="38">
<Value>PrintDefFaxAktiv</Value>
</Value>
<Value name="39">
<Value>PrintDefMailAktiv</Value>
</Value>
<Value name="40">
<Value>PrintMailAdr</Value>
</Value>
<Value name="41">
<Value>MailSubject</Value>
</Value>
<Value name="42">
<Value>PrintMailSubject</Value>
</Value>
<Value name="43">
<Value>PrintMailText</Value>
</Value>
<Value name="44">
<Value>Fax</Value>
</Value>
<Value name="45">
<Value>Mobil</Value>
</Value>
<Value name="46">
<Value>PrintDefEtiAktivState</Value>
</Value>
<Value name="47">
<Value>AnzahlAktiv</Value>
</Value>
<Value name="48">
<Value>DetPreisAktiv</Value>
</Value>
<Value name="49">
<Value>ArtikelCodeAktiv</Value>
</Value>
<Value name="50">
<Value>Zeitraster</Value>
</Value>
<Value name="51">
<Value>PrintMailAdrCC</Value>
</Value>
<Value name="52">
<Value>ZeitrasterNB</Value>
</Value>
<Value name="53">
<Value>GlobalCompanyPrefix</Value>
</Value>
<Value name="54">
<Value>AuftragErfassungInaktiv</Value>
</Value>
<Value name="55">
<Value>VorschlagMitarbeiter</Value>
</Value>
<Value name="56">
<Value>LieferartWriteBack</Value>
</Value>
<Value name="57">
<Value>BestellartWriteBack</Value>
</Value>
<Value name="58">
<Value>BestellerWriteBack</Value>
</Value>
<Value name="59">
<Value>ReferenzWriteBack</Value>
</Value>
<Value name="60">
<Value>GebietWriteBack</Value>
</Value>
<Value name="61">
<Value>VorschlagGebiet</Value>
</Value>
<Value name="62">
<Value>KundenNrHogaShop</Value>
</Value>
<Value name="63">
<Value>HogaShopAktiv</Value>
</Value>
<Value name="64">
<Value>Mandant</Value>
</Value>
<Value name="65">
<Value>VorschlagLieferzeit</Value>
</Value>
<Value name="66">
<Value>LieferzeitWriteBack</Value>
</Value>
<Value name="67">
<Value>LieferdatumAktiv</Value>
</Value>
<Value name="68">
<Value>SSCCGenerierung</Value>
</Value>
<Value name="69">
<Value>RuestdatumAktiv</Value>
</Value>
<Value name="70">
<Value>RuestdatumArt</Value>
</Value>
<Value name="71">
<Value>RuestdatumArtNB</Value>
</Value>
</Data>
<Data name="PrintDefEtiketten">
<Attribute>PrintDefEtiketten</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefEtiketten"</Subscript>
</Data>
<Data name="PrintDefFax">
<Attribute>PrintDefFax</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefFax"</Subscript>
</Data>
<Data name="PrintDefMail">
<Attribute>PrintDefMail</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefMail"</Subscript>
</Data>
<Data name="PrintDefOutlook">
<Attribute>PrintDefOutlook</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefOutlook"</Subscript>
</Data>
<Data name="UmsatzHaben">
<Attribute>UmsatzHaben</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHaben"</Subscript>
</Data>
<Data name="UmsatzHabenVorjahr">
<Attribute>UmsatzHabenVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVorjahr"</Subscript>
</Data>
<Data name="UmsatzSoll">
<Attribute>UmsatzSoll</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSoll"</Subscript>
</Data>
<Data name="UmsatzSollVorjahr">
<Attribute>UmsatzSollVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVorjahr"</Subscript>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Adresse">
</Property>
<Property name="AnzJeGebindeAktiv">
</Property>
<Property name="AnzahlAktiv">
</Property>
<Property name="ArtikelCodeAktiv">
</Property>
<Property name="AuftragErfassungInaktiv">
</Property>
<Property name="Bank">
</Property>
<Property name="BestMengeAktiv">
</Property>
<Property name="BestNrAktiv">
</Property>
<Property name="BestNrFokusieren"/>
<Property name="Bestellart">
</Property>
<Property name="BestellartWriteBack">
</Property>
<Property name="BestellerWriteBack">
</Property>
<Property name="ChargeAktiv">
</Property>
<Property name="DatumLetzteBewegung">
</Property>
<Property name="DetPreisAktiv">
</Property>
<Property name="EUUstNr">
</Property>
<Property name="FaktBestellart">
</Property>
<Property name="FaktLieferart">
</Property>
<Property name="Fax">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="Fremdwaehrung">
</Property>
<Property name="GebietWriteBack">
</Property>
<Property name="GebindeAktiv">
</Property>
<Property name="GlobalCompanyPrefix">
</Property>
<Property name="HerkunftAktiv">
</Property>
<Property name="HogaShopAktiv">
</Property>
<Property name="Kreditlimit">
</Property>
<Property name="KundenNrHogaShop">
</Property>
<Property name="Kundenidentifikation">
</Property>
<Property name="LSVBankKontoNr">
</Property>
<Property name="LSVBankleitzahl">
</Property>
<Property name="Lieferart">
</Property>
<Property name="LieferartWriteBack">
</Property>
<Property name="LieferdatumAktiv">
</Property>
<Property name="LieferzeitWriteBack">
</Property>
<Property name="Mahnung">
</Property>
<Property name="Mandant">
</Property>
<Property name="Mobil">
</Property>
<Property name="MwstSteuerungInklExkl">
</Property>
<Property name="PrintDefEtiAktivState">
</Property>
<Property name="PrintDefFaxAktiv">
</Property>
<Property name="PrintDefMailAktiv">
</Property>
<Property name="PrintMailAdr">
</Property>
<Property name="PrintMailAdrCC">
</Property>
<Property name="PrintMailSubject">
</Property>
<Property name="PrintMailText">
</Property>
<Property name="Rabatt">
</Property>
<Property name="RabattAktiv">
</Property>
<Property name="ReferenzWriteBack">
</Property>
<Property name="RuestdatumArt">
</Property>
<Property name="RuestdatumArtNB">
</Property>
<Property name="SSCCGenerierung">
</Property>
<Property name="Saldo"/>
<Property name="SaldoFW"/>
<Property name="Saldovortrag"/>
<Property name="SkontoBarzahlung">
</Property>
<Property name="SpezArtikelAnsicht">
</Property>
<Property name="SteuerNr">
</Property>
<Property name="TotalUmsatzHaben"/>
<Property name="TotalUmsatzHabenVorjahr"/>
<Property name="TotalUmsatzSoll"/>
<Property name="TotalUmsatzSollVorjahr"/>
<Property name="UstIdNr">
</Property>
<Property name="VorschlagBesteller">
</Property>
<Property name="VorschlagGebiet">
</Property>
<Property name="VorschlagLieferzeit">
</Property>
<Property name="VorschlagMitarbeiter">
</Property>
<Property name="VorschlagReferenz">
</Property>
<Property name="WebEdiId">
</Property>
<Property name="WebEdiId2">
</Property>
<Property name="Zahladresse">
</Property>
<Property name="Zahlungskondition">
</Property>
<Property name="Zeitraster"/>
<Property name="ZeitrasterNB"/>
</Storage>
</Class>


<Class name="DBDebiKredi.DebitorUmsatz">
<Description>
</Description>
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61488,40413.787939</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="SaldovortragEw">
<Description>
Saldovortrag Ew</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollEw">
<Description>
Umsatz Soll Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenEw">
<Description>
Umsatz Haben Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollVjEw">
<Description>
Umsatz Soll Vorjahr Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenVjEw">
<Description>
Umsatz Haben Vorjahr Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="SaldovortragFw">
<Description>
Saldovortrag Fw</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollFw">
<Description>
Umsatz Soll Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenFw">
<Description>
Umsatz Haben Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollVjFw">
<Description>
Umsatz Soll Vorjahr Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenVjFw">
<Description>
Umsatz Haben Vorjahr Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Debitor">
<Description>
Debitor</Description>
<Type>DBDebiKredi.Debitor</Type>
<Cardinality>parent</Cardinality>
<Inverse>Umsatz</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Debitor"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="Waehrung">
<Description>
Waehrung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorUmsatzWaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Waehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="WaehrungIndex">
<Properties>Waehrung</Properties>
</Index>

<Property name="MandantJahr">
<Description>
MandantJahr</Description>
<Type>DBCore.MandantJahr</Type>
<Cardinality>one</Cardinality>
<Inverse>DebitorUmsatzMandantJahr</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="MandantJahr"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="MandantJahrIndex">
<Properties>MandantJahr</Properties>
</Index>

<Index name="UniqueIndex">
<Properties>Debitor,Waehrung,MandantJahr</Properties>
<Unique>1</Unique>
</Index>

<Method name="GetUmsatzHabenEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzHabenEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzHabenTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzHabenEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzSollEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenVjEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzHabenVjEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzHabenVjTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenVjEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzHabenVjEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollVjEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollVjEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollVjTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollVjEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzSollVjEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetSaldoEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set saldo = 0
	set saldo = ..SaldovortragEw +..GetUmsatzSollTotalEw() -..GetUmsatzHabenTotalEw()
	Quit +saldo
]]></Implementation>
</Method>

<Method name="GetSaldoEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetSaldoEw()
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//--------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Fremdwaehrung

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//--------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzHabenFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzSollFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenVjFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenVjFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenVjFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzHabenVjFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollVjFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollVjFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollVjFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.DebitorUmsatz.SetUmsatzSollVjFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetSaldoFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set saldo = 0
	set saldo = ..SaldovortragFw +..GetUmsatzSollTotalFw() -..GetUmsatzHabenTotalFw()
	Quit +saldo
]]></Implementation>
</Method>

<Method name="GetDebitorUmsatz">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,mandJahr:%String,waehrungOid:%String,erfassen:%Boolean</FormalSpec>
<ReturnType>DBDebiKredi.DebitorUmsatz</ReturnType>
<Implementation><![CDATA[
	Set myId = ""
	
	&sql(SELECT ID INTO :myId FROM DBDebiKredi.DebitorUmsatz WHERE Debitor=:debiOid AND Waehrung=:waehrungOid AND MandantJahr=:mandJahr)
	
	if ((SQLCODE '= 0) || (myId = "")) {
		if (erfassen) {
			Set debiUmsatz = ##class(DBDebiKredi.DebitorUmsatz).%New()
			Set debiUmsatz.Debitor = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
			Set debiUmsatz.Waehrung = ##class(DBFibu.SD.Fremdwaehrung).%OpenId(waehrungOid)
			Set debiUmsatz.MandantJahr = ##class(DBCore.MandantJahr).%OpenId(mandJahr)
			Set status = debiUmsatz.%Save()
			if ($$$ISERR(status)) {
				w "DBDebiKredi.DebitorUmsatz.GetDebitorUmsatz - Fehler beim Speichern:"_status,!
			}
			Quit debiUmsatz
		} else {
			Quit ""
		}
	} else {
		Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(myId)
	}
]]></Implementation>
</Method>

<Method name="%OnAfterSave">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%Save</METHOD> method to 
provide notification that the object is being saved. It is called after 
the object's data has been successfully written to disk.

<P><VAR>insert</VAR> will be set to 1 if this object is being saved for the first time.

<P>If this method returns an error then the call to <METHOD>%Save</METHOD> will fail.]]></Description>
<FormalSpec>insert:%Boolean</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	Set ..Debitor.DatumLetzteBewegung = +$H
	Set sc = ..Debitor.%Save()
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEw">
<FormalSpec>vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if ((vonPeriode < 1) || (vonPeriode > 12)) {
		set vonPeriode = 1
	}
	if ((bisPeriode < 1) || (bisPeriode > 12)) {
		set bisPeriode = 12
	}	
	
	set total = 0
	FOR index=vonPeriode:1:bisPeriode {
		set total = +total +..UmsatzSollEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEw">
<FormalSpec>vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if ((vonPeriode < 1) || (vonPeriode > 12)) {
		set vonPeriode = 1
	}
	if ((bisPeriode < 1) || (bisPeriode > 12)) {
		set bisPeriode = 12
	}	
	
	set total = 0
	FOR index=vonPeriode:1:bisPeriode {
		set total = +total +..UmsatzSollVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollPeriodeEw(vonPeriode, bisPeriode)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.DebitorUmsatz).%OpenId(oid).GetUmsatzSollPeriodeVjEw(vonPeriode, bisPeriode)
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>{%%PARENT}("Umsatz")</DataLocation>
<DefaultData>DebitorUmsatzDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.DebitorC("Umsatz")</IdLocation>
<IndexLocation>^DBDebiKredi.DebitorUmsatzI</IndexLocation>
<StreamLocation>^DBDebiKredi.DebitorUmsatzS</StreamLocation>
<Data name="DebitorUmsatzDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Saldovortrag</Value>
</Value>
<Value name="3">
<Value>Waehrung</Value>
</Value>
<Value name="4">
<Value>SaldovortragEw</Value>
</Value>
<Value name="5">
<Value>SaldovortragFw</Value>
</Value>
<Value name="6">
<Value>MandantJahr</Value>
</Value>
</Data>
<Data name="UmsatzHaben">
<Attribute>UmsatzHaben</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHaben"</Subscript>
</Data>
<Data name="UmsatzHabenEw">
<Attribute>UmsatzHabenEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenEw"</Subscript>
</Data>
<Data name="UmsatzHabenFw">
<Attribute>UmsatzHabenFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenFw"</Subscript>
</Data>
<Data name="UmsatzHabenVjEw">
<Attribute>UmsatzHabenVjEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVjEw"</Subscript>
</Data>
<Data name="UmsatzHabenVjFw">
<Attribute>UmsatzHabenVjFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVjFw"</Subscript>
</Data>
<Data name="UmsatzHabenVorjahr">
<Attribute>UmsatzHabenVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVorjahr"</Subscript>
</Data>
<Data name="UmsatzHabenVorjahrEw">
<Attribute>UmsatzHabenVorjahrEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVorjahrEw"</Subscript>
</Data>
<Data name="UmsatzSoll">
<Attribute>UmsatzSoll</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSoll"</Subscript>
</Data>
<Data name="UmsatzSollEw">
<Attribute>UmsatzSollEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollEw"</Subscript>
</Data>
<Data name="UmsatzSollFw">
<Attribute>UmsatzSollFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollFw"</Subscript>
</Data>
<Data name="UmsatzSollVjEw">
<Attribute>UmsatzSollVjEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVjEw"</Subscript>
</Data>
<Data name="UmsatzSollVjFw">
<Attribute>UmsatzSollVjFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVjFw"</Subscript>
</Data>
<Data name="UmsatzSollVorjahr">
<Attribute>UmsatzSollVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVorjahr"</Subscript>
</Data>
<Data name="UmsatzSollVorjahrEw">
<Attribute>UmsatzSollVorjahrEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVorjahrEw"</Subscript>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Debitor">
</Property>
<Property name="MandantJahr">
</Property>
<Property name="SaldovortragEw">
</Property>
<Property name="SaldovortragFw">
</Property>
<Property name="Waehrung">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.Konst">
<Super>%RegisteredObject</Super>
<TimeChanged>62350,59949.304493</TimeChanged>
<TimeCreated>61486,31970.997581</TimeCreated>

<Method name="OPTypRechnung">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit 0
]]></Implementation>
</Method>

<Method name="OPTypGutschrift">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit 5
]]></Implementation>
</Method>

<Method name="OPTypVorauszahlung">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit 6
]]></Implementation>
</Method>

<Method name="ZahlungTypZahlung">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 0
]]></Implementation>
</Method>

<Method name="ZahlungTypVerrechnungGU">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 5
]]></Implementation>
</Method>

<Method name="ZahlungTypVerrechnungVZ">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 6
]]></Implementation>
</Method>

<Method name="BankzuweisungErsteIBAN">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 0
]]></Implementation>
</Method>

<Method name="BankzuweisungErsteBank">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 1
]]></Implementation>
</Method>

<Method name="BankzuweisungKeinDTA">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 9
]]></Implementation>
</Method>

<Method name="SSCCGenJePalette">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 1
]]></Implementation>
</Method>

<Method name="SSCCGenJePosition">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit 2
]]></Implementation>
</Method>
</Class>


<Class name="DBDebiKredi.Kreditor">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61278,32693.923095</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
</Index>

<Property name="MwstSteuerungInklExkl">
<Description>
MWST Code</Description>
<Type>%Integer</Type>
</Property>

<Property name="Rabatt">
<Description>
Rabatt</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Kundennummer">
<Description>
Kundennummer</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="50"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="MWSTNr">
<Description>
MWSTNummer</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="50"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Kreditlimit">
<Description>
Kreditlimit</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="DatumLetzteBewegung">
<Description>
Letzte Bewegung</Description>
<Type>%Date</Type>
</Property>

<Property name="Kundenidentifikation">
<Description>
Kundenidentifikation für Etiketten</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="SpezArtikelAnsicht">
<Description>
Nur Kreditoren spezifische Artikel in Baum anzeigen</Description>
<Type>%Boolean</Type>
<InitialExpression>"0"</InitialExpression>
</Property>

<Property name="VorschlagBesteller">
<Description>
Vorschlag Besteller</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="VorschlagReferenz">
<Description>
Vorschlag Referenz</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="BestNrAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="RabattAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BestMengeAktiv">
<Description>
BestNrAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="HerkunftAktiv">
<Description>
HerkunftAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="Zahladresse">
<Description>
Zahladresse</Description>
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorZahladresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahladresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="KreditorZahladresse">
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahladresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FibuKonto">
<Description>
Sammelkonto Fibu</Description>
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Property name="Fremdwaehrung">
<Description>
Fremdwährung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorFremdwaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Fremdwaehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FremdwaehrungIndex">
<Properties>Fremdwaehrung</Properties>
</Index>

<Property name="StammBanken">
<Description>
Bank beziehung für Stammbanken</Description>
<Type>DBDebiKredi.SD.KBank</Type>
<Cardinality>many</Cardinality>
<Inverse>Adresse</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="Zahlungskondition">
<Description>
Zahlungs Konditionen</Description>
<Type>DBDebiKredi.SD.KZahlungskond</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorZahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahlungskondition"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ZahlungskonditionIndex">
<Properties>Zahlungskondition</Properties>
</Index>

<Property name="Adresse">
<Type>DBAdressen.Adresse</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Adresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="AdresseIndex">
<Properties>Mandant,Adresse</Properties>
<Unique>1</Unique>
</Index>

<Property name="AktBank">
<Type>%Integer</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {AktBank}=##class(DBDebiKredi.Kreditor).GetAktiveBankIdClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
</Property>

<Property name="BkAdresse">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Adresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="BKZahlAdresse">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ZahlAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="LieferantenPreisLieferant">
<Type>DBAgrofreshEK.LieferantenPreis</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ChargenEingangLieferant">
<Type>DBAgrofreshEK.ChargenEingang</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Umsatz">
<Type>DBDebiKredi.KreditorUmsatz</Type>
<Cardinality>children</Cardinality>
<Inverse>Kreditor</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="OPKrediKreditor">
<Type>DBDebiKredi.OPKredi</Type>
<Cardinality>many</Cardinality>
<Inverse>Kreditor</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Lieferart">
<Type>DBAgrofreshEK.SD.Lieferart</Type>
<Cardinality>one</Cardinality>
<Inverse>BestellungsVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Lieferart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="LieferartIndex">
<Properties>Lieferart</Properties>
</Index>

<Property name="Bestellart">
<Type>DBAgrofreshEK.SD.Bestellart</Type>
<Cardinality>one</Cardinality>
<Inverse>BestellungsVorschlag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Bestellart"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="BestellartIndex">
<Properties>Bestellart</Properties>
</Index>

<Property name="LieferantGebPreis">
<Type>DBAgrofreshEK.LieferantenGebPreis</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="GebindeAktiv">
<Description>
GebindeAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="AnzJeGebindeAktiv">
<Description>
AnzJeGebindeAktiv</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintMailAdr">
<Description>
E-mail adresse für beim Formulardruck</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PrintMailSubject">
<Description>
E-mail Betreff für beim Formulardruck</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PrintMailText">
<Type>DBCore.ReportMailText</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorPrintText</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="PrintMailText"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="PrintMailTextIndex">
<Properties>PrintMailText</Properties>
</Index>

<Property name="ExtraNetPwd">
<Description>
ExtraNetPwd</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="128"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PlattformBestKopf">
<Type>DBPlattform.BestKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Angebot">
<Type>DBPlattform.AngebotsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="SSCCEinstellung">
<Description>
SSCC Einstellungen</Description>
<Type>%Integer</Type>
</Property>

<Property name="AbrechnungPDFSpeichern">
<Description>
AbrechungPDF speichern</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintDefEtiketten">
<Description>
Vorschlag ob Etikettendruck aktiv ist (0-wenn modul Print aktiv, 1-Ja, 2-Nein)</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintDefFax">
<Description>
Vorschlag ob Formular als Fax versenden</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintDefMail">
<Description>
Vorschlag ob Formular als Mail versenden</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintDefPDF">
<Description>
Vorschlag ob parallel PDF speichern</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="PrintMailAdrCC">
<Description>
E-mail adresse CC für beim Formulardruck</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="1024"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="NpNummer">
<Description>
NP - Nummer (für Etikettendruck)</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="25"/>
</Property>

<Property name="AuftragErfassungInaktiv">
<Description>
Lieferant für Auftragserfassung gesperrt.</Description>
<Type>%Boolean</Type>
</Property>

<Property name="PrintDefEinzelSelSAR">
<Description>
Vorschlag ob Formular als Mail versenden</Description>
<Type>%Boolean</Type>
</Property>

<Property name="WarenEingangFieldsInaktiv">
<Description>
Einstellung für die Einzelnen Felder ob sie Inaktiv sind</Description>
<Type>%Boolean</Type>
<Collection>array</Collection>
</Property>

<Property name="FaktEKAdresse">
<Type>DBFaktEK.Bestellungskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Adresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktEKZahlAdresse">
<Type>DBFaktEK.Bestellungskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ZahlAdresse</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="AngebotWochenerfassung">
<Description>
Angeboterfassung</Description>
<Type>%Boolean</Type>
</Property>

<Property name="AngebotPreiserfassung">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenMo">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenDi">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenMi">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenDo">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenFr">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassenSa">
<Type>%Boolean</Type>
</Property>

<Property name="AngebotErfassungArt">
<Type>%Integer</Type>
</Property>

<Property name="BestellungErfassungArt">
<Type>%Integer</Type>
</Property>

<Property name="Herkunftstyp">
<Description>
Wie bei diesem Kunden die Herkunft erfasst werden soll.</Description>
<Type>%Integer</Type>
</Property>

<Method name="GetWarenEingangInaktiv">
<FormalSpec>feld:%Integer</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (+feld = 0) {
		Quit 0
	} 
	quit ..WarenEingangFieldsInaktiv.GetAt(feld)
]]></Implementation>
</Method>

<Method name="SetWarenEingangInaktiv">
<FormalSpec>feld:%Integer,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..WarenEingangFieldsInaktiv.SetAt(value, feld)
]]></Implementation>
</Method>

<Method name="GetPrintDefFax">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefFax.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefFax">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefFax.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefMail">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefMail.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefMail">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefMail.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefEtiketten">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefEtiketten.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefEtiketten">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefEtiketten.SetAt(value, typ)
]]></Implementation>
</Method>

<Method name="GetPrintDefPDF">
<FormalSpec>typ:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	if (typ = "") {
		Quit 0
	} 
	quit ..PrintDefPDF.GetAt(typ)
]]></Implementation>
</Method>

<Method name="SetPrintDefPDF">
<FormalSpec>typ:%String,value:%Boolean</FormalSpec>
<Implementation><![CDATA[	d ..PrintDefPDF.SetAt(value, typ)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzHabenEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzHabenEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzHabenTotalEwClass(ID)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzHabenTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenEw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzHabenEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzSollEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollTotalEwClass(ID)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzSollTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollEw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzSollEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Vorjahr Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzHabenVjEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzHabenVjEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzHabenVjTotalEwClass(ID)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzHabenVjTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenVjEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenVjEw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenVjTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzHabenVjEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Vorjahr Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollVjEwClass(ID, :KeyMonat)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzSollVjEw(KeyMonat)
		}
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollVjTotalEwClass(ID)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetUmsatzSollVjTotalEw()
		}
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollVjEw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollVjEw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollVjTotalEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzSollVjEw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldovortrag Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldovortragEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(SaldovortragEw) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.SaldovortragEw
		}
	}
]]></Implementation>
</Method>

<Method name="SetSaldovortragEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set krediUmsatz = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1)
	Set krediUmsatz.SaldovortragEw = betrag
	Set status = krediUmsatz.%Save()
	Quit status
]]></Implementation>
</Method>

<Method name="GetSaldovortragEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetSaldovortragEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetSaldovortragEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetSaldovortragEw(mandJahr,waehrungOid, betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldo Ew

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldoEw">
<FormalSpec>mandJahr:%String,waehrungOid:%String=""</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if (waehrungOid = "") {
		Set myOid = ..%Id()
		Set total = 0
		&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetSaldoEwClass(ID)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
		Quit total
	} else {
		Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
		if (ku = "") {
			Quit 0
		} else {
			Quit ku.GetSaldoEw()
		}
	}
]]></Implementation>
</Method>

<Method name="GetSaldoEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetSaldoEw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzHabenFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzHabenTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenFw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzHabenFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzSollFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzSollTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollFw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzSollFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Haben Vorjahr Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzHabenVjFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzHabenVjTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzHabenVjFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenVjFw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzHabenVjTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzHabenVjFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Umsatz Soll Vorjahr Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzSollVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzSollVjFw(KeyMonat)
	}
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetUmsatzSollVjTotalFw()
	}
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFw">
<FormalSpec>mandJahr:%String,KeyMonat:%Integer,waehrungOid:%String,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1).SetUmsatzSollVjFw(KeyMonat,Value)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollVjFw(mandJahr,KeyMonat, waehrungOid)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetUmsatzSollVjTotalFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,KeyMonat:%Integer,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetUmsatzSollVjFw(mandJahr,KeyMonat,waehrungOid,betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldovortrag Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldovortragFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0).SaldovortragFw
]]></Implementation>
</Method>

<Method name="SetSaldovortragFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set krediUmsatz = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,1)
	Set krediUmsatz.SaldovortragFw = betrag
	Set status = krediUmsatz.%Save()
	Quit status
]]></Implementation>
</Method>

<Method name="GetSaldovortragFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetSaldovortragFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="SetSaldovortragFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,betrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).SetSaldovortragFw(mandJahr,waehrungOid, betrag)
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Saldo Fw

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//----------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetSaldoFw">
<FormalSpec>mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set ku = ##class(DBDebiKredi.KreditorUmsatz).GetKreditorUmsatz(..%Id(),mandJahr,waehrungOid,0)
	if (ku = "") {
		Quit 0
	} else {
		Quit ku.GetSaldoFw()
	}
]]></Implementation>
</Method>

<Method name="GetSaldoFwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##Class(DBDebiKredi.Kreditor).%OpenId(krediOid).GetSaldoFw(mandJahr,waehrungOid)
]]></Implementation>
</Method>

<Method name="GetIdByAdrNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Kreditor WHERE Mandant = :MandantOid
		 AND Adresse->Adressnummer = :AdrNr)
	Quit id
]]></Implementation>
</Method>

<Method name="GetIdByAdrOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi.Kreditor WHERE Mandant = :MandantOid
	     AND Adresse = :AdrOid)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetAdrNrById">
<ClassMethod>1</ClassMethod>
<FormalSpec>id:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set adrNr = ""
	&sql(SELECT Adresse->Adressnummer INTO :adrNr FROM DBDebiKredi.Kreditor WHERE ID = :id)
	Quit:(SQLCODE'=0) 0
	Quit adrNr
]]></Implementation>
</Method>

<Method name="SetActiveBankIdClass">
<Description>
Weist dem Benutzer den aktiven Mandant zu.
Falls kein Benutzer übergeben wird, wird der Standard-Mandant gesetzt</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>KredOid:%String,BankId:%String=""</FormalSpec>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	if (KredOid '= "") {
		Set ^KrediAktBank(KredOid) = BankId
	}
]]></Implementation>
</Method>

<Method name="SetActiveBankId">
<FormalSpec>BankId:%String=""</FormalSpec>
<Implementation><![CDATA[	do ..SetActiveBankIdClass(..%Id(), BankId)
]]></Implementation>
</Method>

<Method name="GetAktiveBankIdClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>KredOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set bankId = ""
	if KredOid'="" {
		if ($Data(^KrediAktBank(KredOid)) = 1) || ($Data(^KrediAktBank(KredOid)) = 11) {
			set bankId = ^KrediAktBank(KredOid)
		}
	}
	Quit +bankId
]]></Implementation>
</Method>

<Method name="GetAktiveBankId">
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit ..GetAktiveBankIdClass(..%Id())
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%Delete</METHOD> method to 
provide notification that the object specified by <VAR>oid</VAR> is being deleted.

<P>If this method returns an error then the object will not be deleted.
[Previously private]]]></Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	set kredOid = $lg(oid,1)
    
    do ..DeleteRelations(kredOid)	
	
	Quit $$$OK
]]></Implementation>
</Method>

<Trigger name="trgBeforeDelete">
<Code>	new myId
	
	Set myId = {ID}
    
	do ..DeleteRelations(myId)</Code>
<Event>DELETE</Event>
</Trigger>

<Method name="DeleteRelations">
<ClassMethod>1</ClassMethod>
<FormalSpec>kredOid:%String</FormalSpec>
<Implementation><![CDATA[
	//wenn Zahladresse auf den selben Debitor verweist -> nullen
	//damit der Kreditor gelöscht werden kann
	set kred = ##class(DBDebiKredi.Kreditor).%OpenId(kredOid)
	if ((kred '= "") && (kred.Zahladresse '= "")) {
		set zahladrId = kred.Zahladresse.%Id()
		if (zahladrId = kredOid) {
			set kred.Zahladresse = ""
			set st= kred.%Save()
		}
	}
	set kred = ""
	
	//nach Kreditorenbanken suchen und diese löschen
	&sql(DELETE FROM DBDebiKredi_SD.KBank WHERE Adresse = :kredOid)
]]></Implementation>
</Method>

<Method name="RecalcUmsatz">
<ClassMethod>1</ClassMethod>
<FormalSpec>mandantOid:%String</FormalSpec>
<Implementation><![CDATA[
	set myId = ""
	&sql(DECLARE C1 CURSOR FOR
    		SELECT ID InTo :myId
    		FROM DBDebiKredi.KreditorUmsatz 
    		WHERE Kreditor->Mandant=:mandantOid)
    		
 	&sql(OPEN C1)
 	&sql(FETCH C1)
 	
 	While (SQLCODE = 0) {
	 	
	 	Set res = ##class(DBDebiKredi.KreditorUmsatz).%DeleteId(myId)
		if ($$$ISERR(res)) {
			w "DBDebiKredi.Kreditor.RecalcUmsatz - Fehler beim Loeschen! "_res,!
		}
		
    	&sql(FETCH C1)
 	}
 	
    &sql(CLOSE C1)
    
	
    set debitor = ""
    set betragInklMwst = 0
    set fwBetrag = 0
    set valutadatum = 0
    set waehrung = ""
    set typ = 0
	&sql(DECLARE C2 CURSOR FOR
    		SELECT Kreditor, BetragInklMwst, FWBetrag, Valutadatum, Waehrung, Typ 
    			InTo :debitor, :betragInklMwst, :fwBetrag, :valutadatum, :waehrung, :typ 
    		FROM DBDebiKredi.OPKredi 
    		WHERE Kreditor->Mandant=:mandantOid)
    		
 	&sql(OPEN C2)
 	&sql(FETCH C2)
 	
 	While (SQLCODE = 0) {
	 	
 		Set faktor = 1
		if (typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()) {
			Set faktor = -1
		}
		Set betragEw = (faktor * betragInklMwst)
		Set betragFw = (faktor * fwBetrag)
		//Set datum = $ZDATEH(valutadatum,5)
		Set datum = valutadatum
		if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(betragEw, betragFw, datum, debitor, waehrung, 0)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(betragEw, betragFw, datum, debitor, waehrung, 0)
		}
		
    	&sql(FETCH C2)
 	}
 	
    &sql(CLOSE C2)
    
    
    set debitor = ""
    set zahlbetrag = 0
    set skontoAbzug = 0
    set fwZahlbetrag = 0
    set fwSkontoAbzug = 0
    set valutadatum = 0
    set waehrung = ""
    set typ = 0
    &sql(DECLARE C3 CURSOR FOR
    		SELECT (SELECT Kreditor 
    				FROM DBDebiKredi.OPKredi 
    				WHERE ID=OP) As Kreditor, 
    				Zahlbetrag, SkontoAbzug, FWZahlbetrag, FWSkontoAbzug, Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ 
    			InTo :debitor, :zahlbetrag, :skontoAbzug, :fwZahlbetrag, :fwSkontoAbzug, :valutadatum, :waehrung, :typ
    		FROM DBDebiKredi.OPZahlung 
    		WHERE OP IN (SELECT ID 
    					 FROM DBDebiKredi.OPKredi 
    					 WHERE Kreditor->Mandant=:mandantOid))
    						
    		
 	&sql(OPEN C3)
 	&sql(FETCH C3)
 	
 	While (SQLCODE = 0) {
	 	
		Set faktor = 1
		if (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) {
			Set faktor = -1
		}
		Set betragEw = (faktor * (zahlbetrag+skontoAbzug))
		Set betragFw = (faktor * (fwZahlbetrag+fwSkontoAbzug))
		//Set datum = $ZDATEH(valutadatum, 5)
		Set datum = valutadatum
		if (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ()) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(betragEw, betragFw, datum, debitor, waehrung, 0)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(betragEw, betragFw, datum, debitor, waehrung, 0)
		}
		
    	&sql(FETCH C3)
 	}
 	
    &sql(CLOSE C3)
]]></Implementation>
</Method>

<Method name="GetFibuKontoNrByDebiOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set res = ""
	set d = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	if (d '= "") {
		if (d.Adresse '= "") {
			set kOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(d.Mandant, d.Adresse.%Id())
			set k = ##class(DBDebiKredi.Kreditor).%OpenId(kOid)
			if (k '= "") {
				if (k.Zahladresse '= "") {
					if (k.Zahladresse.FibuKonto '= "") {
						set res = k.Zahladresse.FibuKonto.KontoNr
					} else {
						w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse.FibuKonto=''",!
					}
				} else {
					w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse=''",!
				}
			} else {
				w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k=''",!
			}
		} else {
			w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d.Adresse=''",!
		}
	} else {
		w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d=''",!
	}
	
	quit res
]]></Implementation>
</Method>

<Method name="GetFibuKontoJahrBezByDebiOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,MandJahrOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set res = ""
	set d = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	if (d '= "") {
		if (d.Adresse '= "") {
			set kOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(d.Mandant, d.Adresse.%Id())
			set k = ##class(DBDebiKredi.Kreditor).%OpenId(kOid)
			if (k '= "") {
				if (k.Zahladresse '= "") {
					if (k.Zahladresse.FibuKonto '= "") {
						//set res = ##class(DBFibu.KontoJahr).GetOidByKontoOidJahr(MandJahrOid,k.Zahladresse.FibuKonto.%Id())
						set res = k.Zahladresse.FibuKonto.GetKontoBezeichnung(MandJahrOid)
					} else {
						w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse.FibuKonto=''",!
					}
				} else {
					w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse=''",!
				}
			} else {
				w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k=''",!
			}
		} else {
			w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d.Adresse=''",!
		}
	} else {
		w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d=''",!
	}
	
	quit res
]]></Implementation>
</Method>

<Method name="GetFibuKontoJahrSollByDebiOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String,MandJahrOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set res = 0
	set d = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	if (d '= "") {
		if (d.Adresse '= "") {
			set kOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(d.Mandant, d.Adresse.%Id())
			set k = ##class(DBDebiKredi.Kreditor).%OpenId(kOid)
			if (k '= "") {
				if (k.Zahladresse '= "") {
					if (k.Zahladresse.FibuKonto '= "") {
						//set res = ##class(DBFibu.KontoJahr).GetOidByKontoOidJahr(MandJahrOid,
						set res = k.Zahladresse.FibuKonto.GetSoll(MandJahrOid)
					} else {
						w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse.FibuKonto=''",!
					}
				} else {
					w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse=''",!
				}
			} else {
				w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k=''",!
			}
		} else {
			w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d.Adresse=''",!
		}
	} else {
		w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d=''",!
	}
	
	quit res
]]></Implementation>
</Method>

<Method name="GetFibuKontoOidByDebiOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set res = ""
	set d = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	if (d '= "") {
		if (d.Adresse '= "") {
			set kOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(d.Mandant, d.Adresse.%Id())
			set k = ##class(DBDebiKredi.Kreditor).%OpenId(kOid)
			if (k '= "") {
				if (k.Zahladresse '= "") {
					if (k.Zahladresse.FibuKonto '= "") {
						set res = k.Zahladresse.FibuKonto.%Id()
					} else {
						w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse.FibuKonto=''",!
					}
				} else {
					w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k.Zahladresse=''",!
				}
			} else {
				w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", k=''",!
			}
		} else {
			w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d.Adresse=''",!
		}
	} else {
		w "GetFibuKontoOidByDebiOid, debiOid="_debiOid_", d=''",!
	}
	
	quit res
]]></Implementation>
</Method>

<Method name="AllianceLogin">
<ClassMethod>1</ClassMethod>
<FormalSpec>AdrNr:%Integer,Pwd:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set retval = 0
	
	set mandOid = ##class(DBCore.AppEinstellung).GetStringEinst(##class(DBCore.Konst).PLATTFORMMANDANT())
	if (mandOid '= "") {
		set kredId = ##class(DBDebiKredi.Kreditor).GetIdByAdrNr(mandOid, AdrNr)
		set kreditor = ##class(DBDebiKredi.Kreditor).%OpenId(kredId)
		if (kreditor '= "") {
			set pass = kreditor.ExtraNetPwd
			if (pass = Pwd) {
				set retval = 1
			}
		}
	}
	Quit retval
]]></Implementation>
</Method>

<Method name="GetAdrOidById">
<ClassMethod>1</ClassMethod>
<FormalSpec>id:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set adrId = ""
	&sql(SELECT Adresse->ID INTO :adrId FROM DBDebiKredi.Kreditor WHERE ID = :id)
	Quit adrId
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myOid:%String,mandJahr:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set total = 0
	&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollPeriodeEwClass(ID,:vonPeriode,:bisPeriode)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
	Quit total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myOid:%String,mandJahr:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set total = 0
	&sql(SELECT SUM(DBDebiKredi.KreditorUmsatz_GetUmsatzSollPeriodeVjEwClass(ID,:vonPeriode,:bisPeriode)) INTO :total FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:myOid AND MandantJahr=:mandJahr)
	Quit total
]]></Implementation>
</Method>

<Property name="InativeArticlesWeb">
<Type>DBPlattform.InactiveArticlesWeb</Type>
<Cardinality>many</Cardinality>
<Inverse>Lieferant</Inverse>
<Relationship>1</Relationship>
</Property>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.KreditorD</DataLocation>
<DefaultData>KreditorDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.KreditorD</IdLocation>
<IndexLocation>^DBDebiKredi.KreditorI</IndexLocation>
<StreamLocation>^DBDebiKredi.KreditorS</StreamLocation>
<Data name="KreditorDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>MwstSteuerungInklExkl</Value>
</Value>
<Value name="3">
<Value>Rabatt</Value>
</Value>
<Value name="4">
<Value>Bankleitzahl</Value>
</Value>
<Value name="5">
<Value>BankKontoNr</Value>
</Value>
<Value name="6">
<Value>Kundennummer</Value>
</Value>
<Value name="7">
<Value>MWSTNr</Value>
</Value>
<Value name="8">
<Value>Kreditlimit</Value>
</Value>
<Value name="9">
<Value>DatumLetzteBewegung</Value>
</Value>
<Value name="10">
<Value>Saldovortrag</Value>
</Value>
<Value name="11">
<Value>Zahladresse</Value>
</Value>
<Value name="12">
<Value>FibuKonto</Value>
</Value>
<Value name="13">
<Value>Fremdwaehrung</Value>
</Value>
<Value name="14">
<Value>AktBank</Value>
</Value>
<Value name="15">
<Value>Zahlungskondition</Value>
</Value>
<Value name="16">
<Value>Adresse</Value>
</Value>
<Value name="17">
<Value>Kundenidentifikation</Value>
</Value>
<Value name="18">
<Value>SpezArtikelAnsicht</Value>
</Value>
<Value name="19">
<Value>Lieferart</Value>
</Value>
<Value name="20">
<Value>Bestellart</Value>
</Value>
<Value name="21">
<Value>VorschlagBesteller</Value>
</Value>
<Value name="22">
<Value>VorschlagReferenz</Value>
</Value>
<Value name="23">
<Value>BestNrAktiv</Value>
</Value>
<Value name="24">
<Value>RabattAktiv</Value>
</Value>
<Value name="25">
<Value>BestMengeAktiv</Value>
</Value>
<Value name="26">
<Value>HerkunftAktiv</Value>
</Value>
<Value name="27">
<Value>GebindeAktiv</Value>
</Value>
<Value name="28">
<Value>AnzJeGebindeAktiv</Value>
</Value>
<Value name="29">
<Value>PrintDefFaxAktiv</Value>
</Value>
<Value name="30">
<Value>PrintDefMailAktiv</Value>
</Value>
<Value name="31">
<Value>PrintMailAdr</Value>
</Value>
<Value name="32">
<Value>PrintMailSubject</Value>
</Value>
<Value name="33">
<Value>PrintMailText</Value>
</Value>
<Value name="34">
<Value>FaktLieferart</Value>
</Value>
<Value name="35">
<Value>FaktBestellart</Value>
</Value>
<Value name="36">
<Value>ExtraNetPwd</Value>
</Value>
<Value name="37">
<Value>PrintDefEtiAktivState</Value>
</Value>
<Value name="38">
<Value>SSCCEinstellung</Value>
</Value>
<Value name="39">
<Value>AbrechnungPDFSpeichern</Value>
</Value>
<Value name="40">
<Value>PrintMailAdrCC</Value>
</Value>
<Value name="41">
<Value>NpNummer</Value>
</Value>
<Value name="42">
<Value>AuftragErfassungInaktiv</Value>
</Value>
<Value name="43">
<Value>PrintDefEinzelSelSAR</Value>
</Value>
<Value name="44">
<Value>Mandant</Value>
</Value>
<Value name="45">
<Value>AngebotWochenerfassung</Value>
</Value>
<Value name="46">
<Value>AngebotPreiserfassung</Value>
</Value>
<Value name="47">
<Value>AngebotErfassenMo</Value>
</Value>
<Value name="48">
<Value>AngebotErfassenDi</Value>
</Value>
<Value name="49">
<Value>AngebotErfassenMi</Value>
</Value>
<Value name="50">
<Value>AngebotErfassenDo</Value>
</Value>
<Value name="51">
<Value>AngebotErfassenFr</Value>
</Value>
<Value name="52">
<Value>AngebotErfassenSa</Value>
</Value>
<Value name="53">
<Value>AngebotErfassungArt</Value>
</Value>
<Value name="54">
<Value>BestellungErfassungArt</Value>
</Value>
<Value name="55">
<Value>Herkunftstyp</Value>
</Value>
</Data>
<Data name="PrintDefEtiketten">
<Attribute>PrintDefEtiketten</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefEtiketten"</Subscript>
</Data>
<Data name="PrintDefFax">
<Attribute>PrintDefFax</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefFax"</Subscript>
</Data>
<Data name="PrintDefMail">
<Attribute>PrintDefMail</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefMail"</Subscript>
</Data>
<Data name="PrintDefPDF">
<Attribute>PrintDefPDF</Attribute>
<Structure>subnode</Structure>
<Subscript>"PrintDefPDF"</Subscript>
</Data>
<Data name="UmsatzHaben">
<Attribute>UmsatzHaben</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHaben"</Subscript>
</Data>
<Data name="UmsatzHabenVorjahr">
<Attribute>UmsatzHabenVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVorjahr"</Subscript>
</Data>
<Data name="UmsatzSoll">
<Attribute>UmsatzSoll</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSoll"</Subscript>
</Data>
<Data name="UmsatzSollVorjahr">
<Attribute>UmsatzSollVorjahr</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVorjahr"</Subscript>
</Data>
<Data name="WarenEingangFieldsInaktiv">
<Attribute>WarenEingangFieldsInaktiv</Attribute>
<Structure>subnode</Structure>
<Subscript>"WarenEingangFieldsInaktiv"</Subscript>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AbrechnungPDFSpeichern">
</Property>
<Property name="Adresse">
</Property>
<Property name="AktBank">
</Property>
<Property name="AngebotErfassenDi">
</Property>
<Property name="AngebotErfassenDo">
</Property>
<Property name="AngebotErfassenFr">
</Property>
<Property name="AngebotErfassenMi">
</Property>
<Property name="AngebotErfassenMo">
</Property>
<Property name="AngebotErfassenSa">
</Property>
<Property name="AngebotErfassungArt">
</Property>
<Property name="AngebotPreiserfassung">
</Property>
<Property name="AngebotWochenerfassung">
</Property>
<Property name="AnzJeGebindeAktiv">
</Property>
<Property name="AuftragErfassungInaktiv">
</Property>
<Property name="BankKontoNr"/>
<Property name="Bankleitzahl"/>
<Property name="BestMengeAktiv">
</Property>
<Property name="BestNrAktiv">
</Property>
<Property name="Bestellart">
</Property>
<Property name="BestellungErfassungArt">
</Property>
<Property name="DatumLetzteBewegung">
</Property>
<Property name="ExtraNetPwd">
</Property>
<Property name="FaktBestellart"/>
<Property name="FaktLieferart"/>
<Property name="FibuKonto">
</Property>
<Property name="Fremdwaehrung">
</Property>
<Property name="GebindeAktiv">
</Property>
<Property name="HerkunftAktiv">
</Property>
<Property name="Herkunftstyp">
</Property>
<Property name="Kreditlimit">
</Property>
<Property name="Kundenidentifikation">
</Property>
<Property name="Kundennummer">
</Property>
<Property name="Lieferart">
</Property>
<Property name="MWSTNr">
</Property>
<Property name="Mandant">
</Property>
<Property name="MwstSteuerungInklExkl">
</Property>
<Property name="NpNummer">
</Property>
<Property name="PrintDefEinzelSelSAR">
</Property>
<Property name="PrintDefEtiAktivState"/>
<Property name="PrintDefFaxAktiv"/>
<Property name="PrintDefMailAktiv"/>
<Property name="PrintMailAdr">
</Property>
<Property name="PrintMailAdrCC">
</Property>
<Property name="PrintMailSubject">
</Property>
<Property name="PrintMailText">
</Property>
<Property name="Rabatt">
</Property>
<Property name="RabattAktiv">
</Property>
<Property name="SSCCEinstellung">
</Property>
<Property name="Saldo"/>
<Property name="SaldoFW"/>
<Property name="Saldovortrag"/>
<Property name="SpezArtikelAnsicht">
</Property>
<Property name="TotalUmsatzHaben"/>
<Property name="TotalUmsatzHabenVorjahr"/>
<Property name="TotalUmsatzSoll"/>
<Property name="TotalUmsatzSollVorjahr"/>
<Property name="VorschlagBesteller">
</Property>
<Property name="VorschlagReferenz">
</Property>
<Property name="Zahladresse">
</Property>
<Property name="Zahlungskondition">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.KreditorUmsatz">
<Description>
</Description>
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61494,37959.588967</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="SaldovortragEw">
<Description>
Saldovortrag Ew</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollEw">
<Description>
Umsatz Soll Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenEw">
<Description>
Umsatz Haben Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollVjEw">
<Description>
Umsatz Soll Vorjahr Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenVjEw">
<Description>
Umsatz Haben Vorjahr Ew</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="SaldovortragFw">
<Description>
Saldovortrag Fw</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollFw">
<Description>
Umsatz Soll Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenFw">
<Description>
Umsatz Haben Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzSollVjFw">
<Description>
Umsatz Soll Vorjahr Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="UmsatzHabenVjFw">
<Description>
Umsatz Haben Vorjahr Fw</Description>
<Type>%Decimal</Type>
<Collection>array</Collection>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Kreditor">
<Description>
Kreditor</Description>
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>parent</Cardinality>
<Inverse>Umsatz</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Kreditor"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="Waehrung">
<Description>
Waehrung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorUmsatzWaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Waehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="WaehrungIndex">
<Properties>Waehrung</Properties>
</Index>

<Property name="MandantJahr">
<Description>
MandantJahr</Description>
<Type>DBCore.MandantJahr</Type>
<Cardinality>one</Cardinality>
<Inverse>KreditorUmsatzMandantJahr</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="MandantJahr"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="MandantJahrIndex">
<Properties>MandantJahr</Properties>
</Index>

<Index name="UniqueIndex">
<Properties>Kreditor,Waehrung,MandantJahr</Properties>
<Unique>1</Unique>
</Index>

<Method name="GetUmsatzHabenEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzHabenEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzHabenTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzHabenEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzSollEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzSollEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenVjEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzHabenVjEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzHabenVjTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenVjEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzHabenVjEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollVjEw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollVjEw(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollVjTotalEw()
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjEw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollVjEw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzSollVjEw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetSaldoEw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set saldo = 0
	set saldo = ..SaldovortragEw - ..GetUmsatzSollTotalEw() + ..GetUmsatzHabenTotalEw()
	Quit +saldo
]]></Implementation>
</Method>

<Method name="GetSaldoEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetSaldoEw()
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//--------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
// Fremdwaehrung

]]></Content>
</UDLText>

<UDLText name="T">
<Content><![CDATA[
//--------------------------------------------------------------------------------------

]]></Content>
</UDLText>

<Method name="GetUmsatzHabenFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzHabenFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzSollFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzSollFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzHabenVjFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzHabenVjTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzHabenVjFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzHabenVjFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzHabenVjFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzHabenVjFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjFw">
<FormalSpec>KeyMonat:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ..UmsatzSollVjFw.GetAt(KeyMonat)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollVjTotalFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	FOR index=1:1:12 {
		set total = +total +..UmsatzSollVjFw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="SetUmsatzSollVjFw">
<FormalSpec>KeyMonat:%Integer,Value:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Do ..UmsatzSollVjFw.SetAt(Value,KeyMonat)
	Set sc = ..%Save()
	if ($$$ISERR(sc)) {
		w "DBDebiKredi.KreditorUmsatz.SetUmsatzSollVjFw - Fehler beim Speichern:"_sc,!
	}
	Quit sc
]]></Implementation>
</Method>

<Method name="GetSaldoFw">
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set saldo = 0
	set saldo = ..SaldovortragFw - ..GetUmsatzSollTotalFw() + ..GetUmsatzHabenTotalFw()
	Quit +saldo
]]></Implementation>
</Method>

<Method name="GetKreditorUmsatz">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,mandJahr:%String,waehrungOid:%String,erfassen:%Boolean</FormalSpec>
<ReturnType>DBDebiKredi.KreditorUmsatz</ReturnType>
<Implementation><![CDATA[
	Set myId = ""
	
	&sql(SELECT ID INTO :myId FROM DBDebiKredi.KreditorUmsatz WHERE Kreditor=:krediOid AND Waehrung=:waehrungOid AND MandantJahr=:mandJahr)
	
	if ((SQLCODE '= 0) || (myId = "")) {
		if (erfassen) {
			Set krediUmsatz = ##class(DBDebiKredi.KreditorUmsatz).%New()
			Set krediUmsatz.Kreditor = ##class(DBDebiKredi.Kreditor).%OpenId(krediOid)
			Set krediUmsatz.Waehrung = ##class(DBFibu.SD.Fremdwaehrung).%OpenId(waehrungOid)
			Set krediUmsatz.MandantJahr = ##class(DBCore.MandantJahr).%OpenId(mandJahr)
			Set status = krediUmsatz.%Save()
			if ($$$ISERR(status)) {
				w "DBDebiKredi.KreditorUmsatz.GetKreditorUmsatz - Fehler beim Speichern:"_status,!
			}
			Quit krediUmsatz
		} else {
			Quit ""
		}
	} else {
		Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(myId)
	}
]]></Implementation>
</Method>

<Method name="%OnAfterSave">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%Save</METHOD> method to 
provide notification that the object is being saved. It is called after 
the object's data has been successfully written to disk.

<P><VAR>insert</VAR> will be set to 1 if this object is being saved for the first time.

<P>If this method returns an error then the call to <METHOD>%Save</METHOD> will fail.]]></Description>
<FormalSpec>insert:%Boolean</FormalSpec>
<Private>1</Private>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	Set ..Kreditor.DatumLetzteBewegung = +$H
	Set sc = ..Kreditor.%Save()
	Quit sc
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEw">
<FormalSpec>vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if ((vonPeriode < 1) || (vonPeriode > 12)) {
		set vonPeriode = 1
	}
	if ((bisPeriode < 1) || (bisPeriode > 12)) {
		set bisPeriode = 12
	}	
	
	set total = 0
	FOR index=vonPeriode:1:bisPeriode {
		set total = +total +..UmsatzSollEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEw">
<FormalSpec>vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	if ((vonPeriode < 1) || (vonPeriode > 12)) {
		set vonPeriode = 1
	}
	if ((bisPeriode < 1) || (bisPeriode > 12)) {
		set bisPeriode = 12
	}	
	
	set total = 0
	FOR index=vonPeriode:1:bisPeriode {
		set total = +total +..UmsatzSollVjEw.GetAt(index)
  	}
	Quit +total
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollPeriodeEw(vonPeriode, bisPeriode)
]]></Implementation>
</Method>

<Method name="GetUmsatzSollPeriodeVjEwClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%String,vonPeriode:%Integer,bisPeriode:%Integer</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit ##class(DBDebiKredi.KreditorUmsatz).%OpenId(oid).GetUmsatzSollPeriodeVjEw(vonPeriode, bisPeriode)
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>{%%PARENT}("Umsatz")</DataLocation>
<DefaultData>KreditorUmsatzDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.KreditorC("Umsatz")</IdLocation>
<IndexLocation>^DBDebiKredi.KreditorUmsatzI</IndexLocation>
<StreamLocation>^DBDebiKredi.KreditorUmsatzS</StreamLocation>
<Data name="KreditorUmsatzDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>SaldovortragEw</Value>
</Value>
<Value name="3">
<Value>SaldovortragFw</Value>
</Value>
<Value name="4">
<Value>Waehrung</Value>
</Value>
<Value name="5">
<Value>MandantJahr</Value>
</Value>
</Data>
<Data name="UmsatzHabenEw">
<Attribute>UmsatzHabenEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenEw"</Subscript>
</Data>
<Data name="UmsatzHabenFw">
<Attribute>UmsatzHabenFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenFw"</Subscript>
</Data>
<Data name="UmsatzHabenVjEw">
<Attribute>UmsatzHabenVjEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVjEw"</Subscript>
</Data>
<Data name="UmsatzHabenVjFw">
<Attribute>UmsatzHabenVjFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzHabenVjFw"</Subscript>
</Data>
<Data name="UmsatzSollEw">
<Attribute>UmsatzSollEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollEw"</Subscript>
</Data>
<Data name="UmsatzSollFw">
<Attribute>UmsatzSollFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollFw"</Subscript>
</Data>
<Data name="UmsatzSollVjEw">
<Attribute>UmsatzSollVjEw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVjEw"</Subscript>
</Data>
<Data name="UmsatzSollVjFw">
<Attribute>UmsatzSollVjFw</Attribute>
<Structure>subnode</Structure>
<Subscript>"UmsatzSollVjFw"</Subscript>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Kreditor">
</Property>
<Property name="MandantJahr">
</Property>
<Property name="SaldovortragEw">
</Property>
<Property name="SaldovortragFw">
</Property>
<Property name="Waehrung">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.OP">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61384,36909.223975</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="ManuelleErfassung">
<Description>
Manuelle Erfassung</Description>
<Type>%Boolean</Type>
</Property>

<Property name="BelegNr">
<Description>
Beleg-Nummer</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Erfassungsdatum">
<Description>
Erfassungsdatum</Description>
<Type>%Date</Type>
</Property>

<Property name="Valutadatum">
<Description>
Valutadatum</Description>
<Type>%Date</Type>
</Property>

<Property name="Buchungstext1">
<Description>
Buchungstext 1</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Buchungstext2">
<Description>
Buchungstext 2</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Waehrung">
<Description>
Fremdwährung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>OPWaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Fremdwaehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="WaehrungIndex">
<Properties>Waehrung</Properties>
</Index>

<Property name="FWFaktor">
<Description>
Fremdwährung - Faktor</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWKurs">
<Description>
Fremdwährung - Kurs</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWBetrag">
<Description>
Fremdwährung - Buchungsbetrag</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BetragInklMwst">
<Description>
Betrag inkl. Mwst</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {BetragInklMwst}=##class(DBDebiKredi.OP).BetragInklMwstClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BetragExklMwst">
<Description>
Betrag exkl. Mwst</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {BetragExklMwst}=##class(DBDebiKredi.OP).BetragExklMwstClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BetragMwst">
<Description>
Mwst-Betrag</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {BetragMwst}=##class(DBDebiKredi.OP).BetragMwstClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Saldo">
<Description>
Saldo</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {Saldo}=##class(DBDebiKredi.OP).CalcSaldoClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWSaldo">
<Description>
FWSaldo</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {FWSaldo}=##class(DBDebiKredi.OP).CalcFWSaldoClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="ZKTage1">
<Description>
Zahlungskondition Tage 1</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="ZKProzentsatz1">
<Description>
Zahlungskondition Skonto Prozentsatz 1</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="ZKTage2">
<Description>
Zahlungskondition Tage 2</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="ZKProzentsatz2">
<Description>
Zahlungskondition Skonto Prozentsatz 2</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="ZKTage3">
<Description>
Zahlungskondition Tage 3</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="Mahnstufe">
<Description>
Mahnstufe</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="OPMwst">
<Description>
Mehrwehrtsteuer</Description>
<Type>DBDebiKredi.OPMwst</Type>
<Cardinality>children</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="OPZahlung">
<Description>
OPZahlung</Description>
<Type>DBDebiKredi.OPZahlung</Type>
<Cardinality>many</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FibuKonto">
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>OPFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Method name="BetragInklMwstClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	
	Set strSQL = "SELECT SUM(BetragInklMwst) AS Betrag FROM DBDebiKredi.OPMwst WHERE OP="_Id
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	Set status = $$$OK
	while (rs.Next(.sc)) {
		set betrag = (betrag + rs.Data("Betrag"))
	}
	
	Quit betrag
]]></Implementation>
</Method>

<Method name="BetragExklMwstClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	
	Set strSQL = "SELECT SUM(BetragExklMwst) AS Betrag FROM DBDebiKredi.OPMwst WHERE OP="_Id
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	Set status = $$$OK
	while (rs.Next(.sc)) {
		set betrag = (betrag + rs.Data("Betrag"))	
	}
	
	Quit betrag
]]></Implementation>
</Method>

<Method name="BetragMwstClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	
	Set strSQL = "SELECT SUM(MwstBetrag) AS Betrag FROM DBDebiKredi.OPMwst WHERE OP="_Id
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	Set status = $$$OK
	while (rs.Next(.sc)) {
		set betrag = (betrag + rs.Data("Betrag"))	
	}
	
	Quit betrag
]]></Implementation>
</Method>

<Property name="Typ">
<Description>
Typ</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="Vertreter">
<Type>DBAdressen.SD.Vertreter</Type>
<Cardinality>one</Cardinality>
<Inverse>OPVertreter</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Vertreter"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="VertreterIndex">
<Properties>Vertreter</Properties>
</Index>

<Property name="EB">
<Description>
Eroeffnungsbilanz</Description>
<Type>%Library.Boolean</Type>
</Property>

<Property name="FibuBuchung">
<Type>DBFibu.Buchung</Type>
<Cardinality>one</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuBuchung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuBuchungIndex">
<Properties>FibuBuchung</Properties>
</Index>

<Property name="Belegdatum">
<Description>
Belegdatum</Description>
<Type>%Date</Type>
</Property>

<Property name="FibuBuchungsart">
<Description>
Buchungsart</Description>
<Type>%Integer</Type>
</Property>

<Method name="DeleteOpByFibuBuchung">
<ClassMethod>1</ClassMethod>
<FormalSpec>BuchungOid:%String,MandantOid:%String,mitZahlungen:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set myId = ""
	Set status = $$$OK
	
	&sql(DECLARE CurDeleteOp CURSOR FOR
    		SELECT ID Into :myId 
    		FROM DBDebiKredi.OP 
    		WHERE FibuBuchung=:BuchungOid)
    		
 	&sql(OPEN CurDeleteOp)
 	&sql(FETCH CurDeleteOp)
 	
 	While (SQLCODE = 0) {
	 	
	 	w "OP löschen", !
	 	
	 	if (mitZahlungen = 1) {
		 	
		 	set status = ##class(DBDebiKredi.OP).DeleteZahlungenZuOp(BuchungOid, MandantOid)
		 	w "mit Zahlungen: status:",status, !
	 	}
	 	
	 	set auftragId = ""
	 	&sql(DECLARE CurAgrofresh CURSOR FOR
    		SELECT ID Into :auftragId 
    		FROM DBAgrofresh.Auftragskopf 
    		WHERE OP=:myId)
    		
	 	&sql(OPEN CurAgrofresh)
	 	&sql(FETCH CurAgrofresh)

	 	While (SQLCODE = 0) {
		 	do ##class(DBAgrofresh.Auftragskopf).SetFlagAutoMutiert(auftragId,1)
		 	
		 	set auftrag = ##class(DBAgrofresh.Auftragskopf).%OpenId(auftragId)
		 	set auftrag.OP = ""
		 	set auftrag.Verbucht = 0
		 	set auftrag.VerbuchungsjournalNr = 0
		 	
		 	d auftrag.%Save()
		 	
		 	do ##class(DBAgrofresh.Auftragskopf).SetFlagAutoMutiert(auftragId,0)
		 	
	 		&sql(FETCH CurAgrofresh)
	 	}
 	
	    &sql(CLOSE CurAgrofresh)
    
    	set auftragId = ""
	 	&sql(DECLARE CurFakturierung CURSOR FOR
    		SELECT ID Into :auftragId 
    		FROM DBFakturierung.Auftragskopf 
    		WHERE OP=:myId)
    		
	 	&sql(OPEN CurFakturierung)
	 	&sql(FETCH CurFakturierung)

	 	While (SQLCODE = 0) {
		 	do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftragId,1)
		 	
		 	set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(auftragId)
		 	set auftrag.OP = ""
		 	set auftrag.Verbucht = 0
		 	set auftrag.VerbuchungsjournalNr = 0
		 	
		 	d auftrag.%Save()
		 	
		 	do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftragId,0)
		 	
	 		&sql(FETCH CurFakturierung)
	 	}
 	
	    &sql(CLOSE CurFakturierung)
	    
	    set auftragId = ""
	 	&sql(DECLARE CurAgrofreshEK CURSOR FOR
    		SELECT ID Into :auftragId 
    		FROM DBAgrofreshEK.BestellungsKopf 
    		WHERE OP=:myId)
    		
	 	&sql(OPEN CurAgrofreshEK)
	 	&sql(FETCH CurAgrofreshEK)

	 	While (SQLCODE = 0) {
		 	do ##class(DBAgrofreshEK.BestellungsKopf).SetFlagAutoMutiert(auftragId,1)
		 	
		 	set auftrag = ##class(DBAgrofreshEK.BestellungsKopf).%OpenId(auftragId)
		 	set auftrag.OP = ""
		 	set auftrag.Verbucht = 0
		 	set auftrag.VerbuchungsjournalNr = 0
		 	
		 	d auftrag.%Save()
		 	
		 	do ##class(DBAgrofreshEK.BestellungsKopf).SetFlagAutoMutiert(auftragId,0)
		 	
	 		&sql(FETCH CurAgrofreshEK)
	 	}
 	
	    &sql(CLOSE CurAgrofreshEK)
	    
	 	w "myId:", myId, !
	 	set s = ##class(DBDebiKredi.OP).%DeleteId(myId)
		if ($$$ISERR(s)) {
			set status = s
			w "status:", s, !
		}
		
		&sql(FETCH CurDeleteOp)
 	}
 	
    &sql(CLOSE CurDeleteOp)
	
	
	set myId = ""
	&sql(DECLARE CurDeleteZahlung CURSOR FOR
    		SELECT ID Into :myId 
    		FROM DBDebiKredi.Zahlung 
    		WHERE FibuBuchung=:BuchungOid)
    		
 	&sql(OPEN CurDeleteZahlung)
 	&sql(FETCH CurDeleteZahlung)
 	
 	While (SQLCODE = 0) {
	 	
	 	set s = ##class(DBDebiKredi.Zahlung).%DeleteId(myId)
		if ($$$ISERR(s)) {
			set status = s
		}
		
    	&sql(FETCH CurDeleteZahlung)
 	}
 	
    &sql(CLOSE CurDeleteZahlung)
	
	Quit status
]]></Implementation>
</Method>

<UDLText name="T">
<Content><![CDATA[
//Property IsOPgeschlossen As %Library.Boolean [ Calculated, SqlComputeCode = { Set {IsOPgeschlossen}=##class(DBDebiKredi.OP).IsOPgeschlossenClass({ID}) }, SqlComputed ];

]]></Content>
</UDLText>

<Property name="IsOPgeschlossen">
<Description>
IsOPgeschlossen</Description>
<Type>%Library.Boolean</Type>
</Property>

<Index name="IsOPgeschlossenIndex">
<Properties>IsOPgeschlossen</Properties>
</Index>

<Property name="AuftragFakturierung">
<Type>DBFakturierung.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ErfasserBenutzername">
<Type>%Library.String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="VerrechnungsNr">
<Description>
VerrechnungsNr</Description>
<Type>%Integer</Type>
</Property>

<Property name="BestellungFakturierung">
<Type>DBFaktEK.Bestellungskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Method name="IsOPgeschlossenClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	Set zahlbetrag = 0
	Set skontoabzug = 0
	Set FWzahlbetrag = 0
	Set FWskontoabzug = 0
	Set kursdifferenz = 0
	
	&sql(SELECT SUM(NVL(Zahlbetrag,0)), 
				SUM(NVL(Skontoabzug,0)),
				SUM(NVL(FWZahlbetrag,0)), 
				SUM(NVL(FWSkontoabzug,0)),  
				SUM(NVL(Kursdifferenz,0))
				INTO :zahlbetrag, :skontoabzug, :FWzahlbetrag, :FWskontoabzug, :kursdifferenz  
			FROM DBDebiKredi.OPZahlung WHERE OP=:opOid)
	if (SQLCODE'=0) {
		Set zahlbetrag = 0
		Set skontoabzug = 0
		Set FWzahlbetrag = 0
		Set FWskontoabzug = 0
		Set kursdifferenz = 0
	}
	
	Set op = ##class(DBDebiKredi.OP).%OpenId(opOid)
	if ((op '= "") && (op '= $c(0))) {	
		if (($NORMALIZE(zahlbetrag+skontoabzug+kursdifferenz, 5) = $NORMALIZE(op.BetragInklMwst, 5)) && ($NORMALIZE(FWzahlbetrag+FWskontoabzug, 5) = $NORMALIZE(op.FWBetrag, 5))) {
			Quit 1
		} else {
			Quit 0
		}
	} else {
		Quit 0
	}
]]></Implementation>
</Method>

<Method name="CalcSaldoClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set zahlbetrag = 0
	Set skontoabzug = 0
	
	&sql(SELECT SUM(NVL(Zahlbetrag,0)), 
				SUM(NVL(Skontoabzug,0)),
				SUM(NVL(Kursdifferenz,0))
				INTO :zahlbetrag, :skontoabzug, :kursdifferenz 
			FROM DBDebiKredi.OPZahlung WHERE OP=:opOid)
	
	Set op = ##class(DBDebiKredi.OP).%OpenId(opOid)
	Quit (op.BetragInklMwst - (zahlbetrag+skontoabzug+kursdifferenz))
]]></Implementation>
</Method>

<Method name="CalcSaldoBisDatumClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,bisDatum:%Date</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set zahlbetrag = 0
	Set skontoabzug = 0
	
	&sql(SELECT SUM(NVL(Zahlbetrag,0)), 
				SUM(NVL(Skontoabzug,0)),
				SUM(NVL(Kursdifferenz,0))
				INTO :zahlbetrag, :skontoabzug, :kursdifferenz 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP=:opOid AND
				Zahlung->Valutadatum<=:bisDatum)
	
	Set op = ##class(DBDebiKredi.OP).%OpenId(opOid)
	Quit (op.BetragInklMwst - (zahlbetrag+skontoabzug+kursdifferenz))
]]></Implementation>
</Method>

<Method name="CalcFWSaldoClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	Set zahlbetrag = 0
	Set skontoabzug = 0
	
	&sql(SELECT SUM(NVL(FWZahlbetrag,0)), 
				SUM(NVL(FWSkontoabzug,0))
				INTO :zahlbetrag, :skontoabzug 
			FROM DBDebiKredi.OPZahlung WHERE OP=:opOid)
	
	Set op = ##class(DBDebiKredi.OP).%OpenId(opOid)
	Quit (op.FWBetrag - (zahlbetrag+skontoabzug))
]]></Implementation>
</Method>

<Method name="%OnBeforeSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	
	If ('Insert) {
		set opId = ..%Id()
		set oldValuta = 0
		set oldBetragFw = 0
		set oldTyp = 0
		&sql(SELECT Valutadatum, FWBetrag, Typ INTO :oldValuta, :oldBetragFw, :oldTyp FROM DBDebiKredi.OP WHERE ID=:opId)
		Set ^OpOldBetragFw(opId) = oldBetragFw
		Set ^OpOldValuta(opId) = oldValuta
		Set ^OpOldTyp(opId) = oldTyp
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnAfterSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	
	If ($GET(^DebiKrediOpStopTrg(..%Id()))="") {
		
		set opId = ..%Id()
		set eb = ..EB
		set waehrung = ..Waehrung.%Id()
	
		if ('Insert) {
			set oldBetragFw = ^OpOldBetragFw(opId)
			set oldValuta = ^OpOldValuta(opId)
			set oldTyp = ^OpOldTyp(opId)
		} else {
			set oldBetragFw = 0
			set oldValuta = 0
			set oldTyp = 0
		}
	
		do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(..%Id(),1)
		set op = ##class(DBDebiKredi.OP).%OpenId(opId)
		set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do op.%Save()
		do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(..%Id(),0)
	
		if ((oldBetragFw'=..FWBetrag) || (oldValuta'=..Valutadatum) || (oldTyp'=..Typ)) {
	
			if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
				set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
				set debiId = opDebi.Debitor.%Id()
		
				If ('Insert) {
					set storno = 1
					if ((oldTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
						set storno = 0
					}
										
					if (eb) {
						do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
					} else {
						if (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
							do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
						} else {
							do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
						}
					}
			
				}
		
				set newBetragFw = ..FWBetrag
				set newValuta = ..Valutadatum
				set newTyp = ..Typ
				set storno = 0
				if ((newTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
					set storno = 1
				}
				if (eb) {
					do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
				} else {
					if (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
						do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, newBetragFw, newValuta, debiId, waehrung, 0)
					} else {
						do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, newBetragFw, newValuta, debiId, waehrung, storno)
					}
				}
		
			} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
				set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
				set debiId = opKredi.Kreditor.%Id()
		
				If ('Insert) {
					set storno = 1
					if ((oldTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
						set storno = 0
					}
					if (eb) {
						do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
					} else {
						if (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
							do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
						} else {
							do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
						}
					}
			
				}
		
				set newBetragFw = ..FWBetrag
				set newValuta = ..Valutadatum
				set newTyp = ..Typ
				set storno = 0
				if ((newTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
					set storno = 1
				}
				if (eb) {
					do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
				} else {
					if (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
						do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, newBetragFw, newValuta, debiId, waehrung, 0)
					} else {
						do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, newBetragFw, newValuta, debiId, waehrung, storno)
					}
				}
			}
		}
	
		KILL ^OpOldBetragFw(opId)
		KILL ^OpOldValuta(opId)
		KILL ^OpOldTyp(opId)
	}
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description>
[Previously private]</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	
	set opId = $lg(oid,1)
	set oldBetragFw = 0
	set oldValuta = 0
	set eb = 0
	set waehrung = 0
	set typ = 0
	
	&sql(SELECT ID, 
				EB,
				Valutadatum,
				FWBetrag,
				Waehrung,
				Typ
			INTO 
				:opId, 
				:eb,
				:oldValuta,
				:oldBetragFw,
				:waehrung,
				:typ
			FROM DBDebiKredi.OP WHERE ID=:opId)	
	
	set storno = 1
	if ((typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
		set storno = 0
	}
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		if (eb) {
			if (opDebi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)		
			}
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
			}
		}
	
		set zusatzOid = ##class(DBDebiKredi.OPDebiZusatz).GetZusatzOid(opId)
		do ##class(DBDebiKredi.OPDebiZusatz).%DeleteId(zusatzOid)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		if (eb) {
			if (opKredi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)		
			}
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
			}
		}
	
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Trigger name="InsertBetrag">
<Code>	new eb
	new waehrung
	new newBetragFw
	new valuta
	new debiId
	new opDebi
	new opKredi
	new opId
	new typ
	new storno
	
	set opId = {ID*O}
	set newBetragFw = {FWBetrag*N}
	set eb = {EB*N}
	set waehrung = {Waehrung*N}
	set valuta = {Valutadatum*N}
	set typ = {Typ*N}
	set storno = 0
	if ((typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
		set storno = 1
	}
	
	do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(opId,1)
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(opId,0)
		
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHabe(0, newBetragFw, valuta, debiId, waehrung, 0)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, newBetragFw, valuta, debiId, waehrung, storno)
			}
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, newBetragFw, valuta, debiId, waehrung, 0)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, newBetragFw, valuta, debiId, waehrung, storno)
			}
		}
	}</Code>
<Event>INSERT</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="UpdateBetrag">
<Code>	
	
	new eb
	new waehrung
	new opId
	new debiId
	new oldBetragFw
	new oldValuta
	new newBetragFw
	new newValuta
	new opDebi
	new opKredi
	new oldTyp
	new newTyp
	new storno
	
	set opId = {ID*O}
	set oldBetragFw = {FWBetrag*O}
	set eb = {EB*O}
	set waehrung = {Waehrung*O}
	set oldValuta = {Valutadatum*O}
	set oldTyp = {Typ*O}
	set storno = 1
	if ((oldTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
		set storno = 0
	}
	
	do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(opId,1)
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(opId,0)
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
		} else {
			if (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
			}
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
		} else {
			if (oldTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, oldBetragFw, oldValuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, oldBetragFw, oldValuta, debiId, waehrung, storno)
			}
		}
	}
	
	set opId = {ID*N}
	set newBetragFw = {FWBetrag*N}
	set eb = {EB*N}
	set waehrung = {Waehrung*N}
	set newValuta = {Valutadatum*N}
	set newTyp = {Typ*N}
	set storno = 0
	if ((newTyp = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
		set storno = 1
	}
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
		} else {
			if (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, newBetragFw, newValuta, debiId, waehrung, 0)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, newBetragFw, newValuta, debiId, waehrung, storno)
			}
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, newBetragFw, debiId, waehrung, storno)
		} else {
			if (newTyp = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, newBetragFw, newValuta, debiId, waehrung, 0)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, newBetragFw, newValuta, debiId, waehrung, storno)
			}
		}
	}</Code>
<Event>UPDATE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="DeleteBetrag">
<Code>	
	
	new eb
	new waehrung
	new opId
	new debiId
	new oldBetragFw
	new valuta
	new opDebi
	new opKredi
	new typ
	new storno
	
	set opId = {ID*O}
	set oldBetragFw = {FWBetrag*O}
	set eb = {EB*O}
	set waehrung = {Waehrung*O}
	set valuta = {Valutadatum*O}
	set typ = {Typ*O}
	set storno = 1
	if ((typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()) || (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung())) {
		set storno = 0
	}
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			if (opDebi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
			}
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(0, oldBetragFw, valuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(0, oldBetragFw, valuta, debiId, waehrung, storno)
			}
		}	
			
		set zusatzOid = ##class(DBDebiKredi.OPDebiZusatz).GetZusatzOid(opId)
		do ##class(DBDebiKredi.OPDebiZusatz).%DeleteId(zusatzOid)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			if (opKredi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(0, oldBetragFw, debiId, waehrung, storno)
			}
		} else {
			if (typ = ##class(DBDebiKredi.Konst).OPTypVorauszahlung()) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(0, oldBetragFw, valuta, debiId, waehrung, 1)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(0, oldBetragFw, valuta, debiId, waehrung, storno)
			}
		}		
	}</Code>
<Event>DELETE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Method name="HasZahlungenClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	Set count = 0
	
	&sql(SELECT COUNT(ID) INTO :count 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP=:opOid)
	
	Quit (count>0)
]]></Implementation>
</Method>

<Method name="GetFirstOpOidbyFibubuchung">
<ClassMethod>1</ClassMethod>
<FormalSpec>buchungOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set oid = 0
	
	&sql(SELECT ID INTO :oid 
			FROM DBDebiKredi.OP 
			WHERE FibuBuchung=:buchungOid)
	
	Quit oid
]]></Implementation>
</Method>

<Method name="SetDebiKrediOpStopTrg">
<ClassMethod>1</ClassMethod>
<FormalSpec>opId:%String,stopp:%Boolean</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	if (stopp) {
		set ^DebiKrediOpStopTrg(opId) = stopp
	} else {
		kill ^DebiKrediOpStopTrg(opId)
	}
	Quit 1
]]></Implementation>
</Method>

<Method name="ResetIsOpGeschlossen">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
	
	set myId = ""
	&sql(DECLARE C10 CURSOR FOR
    		SELECT ID Into :myId 
    		FROM DBDebiKredi.OP)
    		
 	&sql(OPEN C10)
 	&sql(FETCH C10)
 	
 	While (SQLCODE = 0) {
	 	
	 	set s = ##class(DBDebiKredi.OP).%OpenId(myId)
	 	set s.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(myId)
	 	set status = s.%Save()
		if ($$$ISERR(status)) {
			w "ERROR: "_status,!
		}
		
    	&sql(FETCH C10)
 	}
 	
    &sql(CLOSE C10)
]]></Implementation>
</Method>

<Method name="DeleteZahlungenZuOp">
<ClassMethod>1</ClassMethod>
<FormalSpec>BuchungOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set status = $$$OK
	
	set zahlungId = ""
 	set verrechnungsnr = 0
 	set zahlungFibubuchung = ""
 	&sql(DECLARE C11 CURSOR FOR
    		SELECT Zahlung, NVL(Zahlung->VerrechnungsNr,0), Zahlung->Fibubuchung 
    				Into :zahlungId, :verrechnungsnr, :zahlungFibubuchung
    		FROM DBDebiKredi.OPZahlung 
    		WHERE OP->FibuBuchung=:BuchungOid)
	
 	&sql(OPEN C11)
 	&sql(FETCH C11)

 	While (SQLCODE = 0) {
	 	w "verrechnungsnr:", verrechnungsnr, !
 		
 		if (verrechnungsnr '= 0) {
	 		set vZahlungId = ""
	 		set vZahlungFibubuchung = ""
	 		&sql(DECLARE C111 CURSOR FOR
	 				SELECT Zahlung, Zahlung->FibuBuchung 
	 						Into :vZahlungId, :vZahlungFibubuchung
					FROM DBDebiKredi.OPZahlung 
					WHERE Zahlung->VerrechnungsNr=:verrechnungsnr AND
						(OP IN (SELECT ID 
							FROM DBDebiKredi.OPKredi 
							WHERE Kreditor->Mandant=:MandantOid)
						OR OP IN (SELECT ID 
							FROM DBDebiKredi.OPDebi 
							WHERE Debitor->Mandant=:MandantOid)))
			
			&sql(OPEN C111)
		 	&sql(FETCH C111)

		 	While (SQLCODE = 0) {
			 	w "vZahlungId:", vZahlungId, !
 		
			 	set s = ##class(DBDebiKredi.Zahlung).%DeleteId(vZahlungId)
				if ($$$ISERR(s)) {
					set status = s
					w "status:", s, !
				}
 	
		 		set s = ##class(DBFibu.Buchung).%DeleteId(vZahlungFibubuchung)
				
			 	&sql(FETCH C111)
		 	}

		    &sql(CLOSE C111)
		    
		    set vOpId = ""
	 		set vOpFibubuchung = ""
	 		&sql(DECLARE C112 CURSOR FOR
	 				SELECT ID, FibuBuchung
	 						Into :vOpId, :vOpFibubuchung
					FROM DBDebiKredi.OP 
					WHERE VerrechnungsNr=:verrechnungsnr AND
						(ID IN (SELECT ID 
							FROM DBDebiKredi.OPKredi 
							WHERE Kreditor->Mandant=:MandantOid)
						OR ID IN (SELECT ID 
							FROM DBDebiKredi.OPDebi 
							WHERE Debitor->Mandant=:MandantOid)))
			
			&sql(OPEN C112)
		 	&sql(FETCH C112)

		 	While (SQLCODE = 0) {
			 	w "vOpId:", vOpId, !
 		
			 	set s = ##class(DBDebiKredi.OP).%DeleteId(vOpId)
				if ($$$ISERR(s)) {
					set status = s
					w "status:", s, !
				}
 	
		 		set s = ##class(DBFibu.Buchung).%DeleteId(vOpFibubuchung)
				
			 	&sql(FETCH C112)
		 	}

		    &sql(CLOSE C112)
 		}
 		
 		w "zahlungId:", zahlungId, !
 			
 		set s = ##class(DBDebiKredi.Zahlung).%DeleteId(zahlungId)
		if ($$$ISERR(s)) {
			set status = s
			w "Zahlung loeschen, Status:", s, !
		}
 	
 		w "zahlungFibubuchung:", zahlungFibubuchung, !
 		
 		set s = ##class(DBFibu.Buchung).%DeleteId(zahlungFibubuchung)
		//if ($$$ISERR(s)) {
		//	set status = s
		//	w "status:", s, !
		//}
		
    	&sql(FETCH C11)
 	}

    &sql(CLOSE C11)
    
    Quit status
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.OPD</DataLocation>
<DefaultData>OPDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.OPD</IdLocation>
<IndexLocation>^DBDebiKredi.OPI</IndexLocation>
<StreamLocation>^DBDebiKredi.OPS</StreamLocation>
<Data name="OPDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>ManuelleErfassung</Value>
</Value>
<Value name="3">
<Value>BelegNr</Value>
</Value>
<Value name="4">
<Value>Erfassungsdatum</Value>
</Value>
<Value name="5">
<Value>Valutadatum</Value>
</Value>
<Value name="6">
<Value>Buchungstext1</Value>
</Value>
<Value name="7">
<Value>Buchungstext2</Value>
</Value>
<Value name="8">
<Value>Menge</Value>
</Value>
<Value name="9">
<Value>Mengeneinheit</Value>
</Value>
<Value name="10">
<Value>Waehrung</Value>
</Value>
<Value name="11">
<Value>FWFaktor</Value>
</Value>
<Value name="12">
<Value>FWKurs</Value>
</Value>
<Value name="13">
<Value>FWBetrag</Value>
</Value>
<Value name="14">
<Value>BetragInklMwst</Value>
</Value>
<Value name="15">
<Value>BetragExklMwst</Value>
</Value>
<Value name="16">
<Value>BetragMwst</Value>
</Value>
<Value name="17">
<Value>Saldo</Value>
</Value>
<Value name="18">
<Value>ZKTage1</Value>
</Value>
<Value name="19">
<Value>ZKSkonto1</Value>
</Value>
<Value name="20">
<Value>ZKTage2</Value>
</Value>
<Value name="21">
<Value>ZKSkonto2</Value>
</Value>
<Value name="22">
<Value>ZKTage3</Value>
</Value>
<Value name="23">
<Value>Mahnstufe</Value>
</Value>
<Value name="24">
<Value>FWSaldo</Value>
</Value>
<Value name="25">
<Value>FibuKonto</Value>
</Value>
<Value name="26">
<Value>ZKProzentsatz1</Value>
</Value>
<Value name="27">
<Value>ZKProzentsatz2</Value>
</Value>
<Value name="28">
<Value>Typ</Value>
</Value>
<Value name="29">
<Value>Vetreter</Value>
</Value>
<Value name="30">
<Value>EB</Value>
</Value>
<Value name="31">
<Value>Vertreter</Value>
</Value>
<Value name="32">
<Value>FibuBuchung</Value>
</Value>
<Value name="33">
<Value>OPZahlung</Value>
</Value>
<Value name="34">
<Value>Belegdatum</Value>
</Value>
<Value name="35">
<Value>FibuBuchungsart</Value>
</Value>
<Value name="36">
<Value>IsOPgeschlossen</Value>
</Value>
<Value name="37">
<Value>ErfasserBenutzername</Value>
</Value>
<Value name="38">
<Value>VerrechnungsNr</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="BelegNr">
</Property>
<Property name="Belegdatum">
</Property>
<Property name="BetragExklMwst">
</Property>
<Property name="BetragInklMwst">
</Property>
<Property name="BetragMwst">
</Property>
<Property name="Buchungstext1">
</Property>
<Property name="Buchungstext2">
</Property>
<Property name="EB">
</Property>
<Property name="ErfasserBenutzername">
</Property>
<Property name="Erfassungsdatum">
</Property>
<Property name="FWBetrag">
</Property>
<Property name="FWFaktor">
</Property>
<Property name="FWKurs">
</Property>
<Property name="FWSaldo">
</Property>
<Property name="FibuBuchung">
</Property>
<Property name="FibuBuchungsart">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="IsOPgeschlossen">
</Property>
<Property name="Mahnstufe">
</Property>
<Property name="ManuelleErfassung">
</Property>
<Property name="Saldo">
</Property>
<Property name="Typ">
</Property>
<Property name="Valutadatum">
</Property>
<Property name="VerrechnungsNr">
</Property>
<Property name="Vertreter">
</Property>
<Property name="Waehrung">
</Property>
<Property name="ZKProzentsatz1">
</Property>
<Property name="ZKProzentsatz2">
</Property>
<Property name="ZKTage1">
</Property>
<Property name="ZKTage2">
</Property>
<Property name="ZKTage3">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.OPDebi">
<Description>
</Description>
<Super>DBDebiKredi.OP,%XML.Adaptor</Super>
<TimeChanged>62340,60658.940089</TimeChanged>
<TimeCreated>61384,40431.202255</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="Zahlungskondition">
<Description>
Zahlungskondition</Description>
<Type>DBDebiKredi.SD.DZahlungskond</Type>
<Cardinality>one</Cardinality>
<Inverse>OPDebiZKond</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahlungskondition"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DebiZahlungskondIndex">
<Properties>Zahlungskondition</Properties>
</Index>

<Property name="Debitor">
<Type>DBDebiKredi.Debitor</Type>
<Cardinality>one</Cardinality>
<Inverse>OPDebiDebitor</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Adresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DebitorIndex">
<Properties>Debitor</Properties>
</Index>

<Property name="AuftragAgrofresh">
<Type>DBAgrofresh.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Zusatz">
<Type>DBDebiKredi.OPDebiZusatz</Type>
<Cardinality>many</Cardinality>
<Inverse>Offenposten</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="ZahlungskondIndividuellText">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Method name="AddBetragToSaldovortrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),debiId:%String,mandJahr:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	if (debiId '= "") {
		if (storno=1) {
			set betragEw = ((-1)*betragEw)
			set betragFw = ((-1)*betragFw)
		}
		
		Set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiId)
		do debi.SetSaldovortragEw(mandJahr,waehrungOid,(debi.GetSaldovortragEw(mandJahr,waehrungOid)+betragEw))
		do debi.SetSaldovortragFw(mandJahr,waehrungOid,(debi.GetSaldovortragFw(mandJahr,waehrungOid)+betragFw))
	}
]]></Implementation>
</Method>

<Method name="AddBetragToUmsatzSoll">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),valuta:%Date,debiId:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	if (debiId '= "") {
		set beginnGeschJahr = 0
		set endeGeschJahr = 0
		set mandId = 0
		
		&sql(SELECT Mandant INTO :mandId
			 FROM DBDebiKredi.Debitor WHERE ID=:debiId)
			
		Set rs = ##class(%Library.ResultSet).%New("DBCore.AF.MandantJahrAF.ListeNachMandant")
		Set sc=rs.Execute(mandId)
	
		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set mandJahrId = rs.Data("ID")
	 
				set j = ##class(DBCore.MandantJahr).%OpenId(mandJahrId)
				if (j '= "") {
					set beginnGeschJahr = j.GeschaeftsjahrBeginn
					set endeGeschJahr = j.GeschaeftsjahrEnde	
				}
		
				if (valuta < beginnGeschJahr) {
					do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(betragEw,betragFw,debiId,mandJahrId,waehrungOid,storno)
					
					set beginnVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(beginnGeschJahr),-1))
					set endeVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(endeGeschJahr),-1))
					if ((valuta >= beginnVorjahr)) {
						if (storno=1) {
							set betragEw = ((-1)*betragEw)
							set betragFw = ((-1)*betragFw)
						}
		
						set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeVorjahr, valuta)
			
						set oldUmsatzEw = 0
						set oldUmsatzFw = 0
						set oldUmsatzEw = ##class(DBDebiKredi.Debitor).GetUmsatzSollVjEwClass(debiId,mandJahrId,waehrungOid,periode)
						set oldUmsatzFw = ##class(DBDebiKredi.Debitor).GetUmsatzSollVjFwClass(debiId,mandJahrId,waehrungOid,periode)
			
						set newUmsatzEw = oldUmsatzEw + betragEw
						set newUmsatzFw = oldUmsatzFw + betragFw
			
						do ##class(DBDebiKredi.Debitor).SetUmsatzSollVjEwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzEw)
						do ##class(DBDebiKredi.Debitor).SetUmsatzSollVjFwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzFw)
					}
				} elseif (valuta < endeGeschJahr) {
					if (storno=1) {
						set betragEw = ((-1)*betragEw)
						set betragFw = ((-1)*betragFw)
					}
		
					set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeGeschJahr, valuta)
					
					set oldUmsatzEw = 0
					set oldUmsatzFw = 0
					set oldUmsatzEw = ##class(DBDebiKredi.Debitor).GetUmsatzSollEwClass(debiId,mandJahrId,waehrungOid,periode)
					set oldUmsatzFw = ##class(DBDebiKredi.Debitor).GetUmsatzSollFwClass(debiId,mandJahrId,waehrungOid,periode)
			
					set newUmsatzEw = oldUmsatzEw + betragEw
					set newUmsatzFw = oldUmsatzFw + betragFw
			
					do ##class(DBDebiKredi.Debitor).SetUmsatzSollEwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzEw)
					do ##class(DBDebiKredi.Debitor).SetUmsatzSollFwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzFw)
			
				}
			}
		}
	}
]]></Implementation>
</Method>

<Method name="AddBetragToUmsatzHaben">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),valuta:%Date,debiId:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	TRY {
		if (debiId '= "") {		
			set beginnGeschJahr = 0
			set endeGeschJahr = 0
			set mandId = 0
		
			&sql(SELECT Mandant INTO :mandId
				 FROM DBDebiKredi.Debitor WHERE ID=:debiId)
			 
			Set rs = ##class(%Library.ResultSet).%New("DBCore.AF.MandantJahrAF.ListeNachMandant")
			Set sc=rs.Execute(mandId)
	
			IF $$$ISOK(sc) {
				while (rs.Next(.sc)) {
					Set mandJahrId = rs.Data("ID")
				
					set j = ##class(DBCore.MandantJahr).%OpenId(mandJahrId)
					if (j '= "") {
						set beginnGeschJahr = j.GeschaeftsjahrBeginn
						set endeGeschJahr = j.GeschaeftsjahrEnde	
					}
		
					if (valuta < beginnGeschJahr) {
			
						// Invertierung, da Haben
						set betragEwSV = ((-1)*betragEw)
						set betragFwSV = ((-1)*betragFw)
						do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(betragEwSV,betragFwSV,debiId,mandJahrId,waehrungOid,storno)
			
						set beginnVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(beginnGeschJahr),-1))
						set endeVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(endeGeschJahr),-1))
						if ((valuta >= beginnVorjahr)) {
							if (storno=1) {
								set betragEw = ((-1)*betragEw)
								set betragFw = ((-1)*betragFw)
							}
		
							set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeVorjahr, valuta)
			
							set oldUmsatzEw = 0
							set oldUmsatzFw = 0
							set oldUmsatzEw = ##class(DBDebiKredi.Debitor).GetUmsatzHabenVjEwClass(debiId,mandJahrId,waehrungOid,periode)
							set oldUmsatzFw = ##class(DBDebiKredi.Debitor).GetUmsatzHabenVjFwClass(debiId,mandJahrId,waehrungOid,periode)
			
							set newUmsatzEw = oldUmsatzEw + betragEw
							set newUmsatzFw = oldUmsatzFw + betragFw
							do ##class(DBDebiKredi.Debitor).SetUmsatzHabenVjEwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzEw)
							do ##class(DBDebiKredi.Debitor).SetUmsatzHabenVjFwClass(debiId,mandJahrId,waehrungOid,periode,newUmsatzFw)
						}
					} elseif (valuta < endeGeschJahr) {
			
						if (storno=1) {
							set betragEw = ((-1)*betragEw)
							set betragFw = ((-1)*betragFw)
						}
			
						set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeGeschJahr, valuta)
						set oldUmsatzEw = 0
						set oldUmsatzFw = 0
						set oldUmsatzEw = ##class(DBDebiKredi.Debitor).GetUmsatzHabenEwClass(debiId, mandJahrId, waehrungOid, periode)
						set oldUmsatzFw = ##class(DBDebiKredi.Debitor).GetUmsatzHabenFwClass(debiId, mandJahrId, waehrungOid, periode)
			
						set newUmsatzEw = oldUmsatzEw + betragEw
						set newUmsatzFw = oldUmsatzFw + betragFw
						do ##class(DBDebiKredi.Debitor).SetUmsatzHabenEwClass(debiId, mandJahrId, waehrungOid, periode, newUmsatzEw)
						do ##class(DBDebiKredi.Debitor).SetUmsatzHabenFwClass(debiId, mandJahrId, waehrungOid, periode, newUmsatzFw)
					}
				}
			}
		}
	} 
	CATCH exceptionvar
	{
	  WRITE !,"DBDebiKredi.OPDebi.AddBetragToUmsatzHaben ERROR: ",$ZERROR
	  WRITE !,"DBDebiKredi.OPDebi.AddBetragToUmsatzHaben ECODE: ",$ECODE
	}
]]></Implementation>
</Method>

<Method name="CreateOpFromAgrofreshAuftrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>RgNr:%Integer,MandantOid:%String,buchungOid:%String,barzahlungsZahlungskondOid:%String,barzahlungskontoOid:%String,verbuchungsJnr:%Integer,opBuchungstext1:%String,opBuchungstext2:%String,opBelegNr:%String,zahlungBuchungstext1:%String,zahlungBuchungstext2:%String,zahlungBelegNr:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID FROM DBAgrofresh.Auftragskopf WHERE RechnungsNr="_RgNr_
					" AND Mandant="_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		
		Set op = ##class(DBDebiKredi.OPDebi).%New()
			
		while (rs.Next(.sc)) {
			
			Set auftrag = ##class(DBAgrofresh.Auftragskopf).%OpenId(rs.Data("ID"))
	
			Set op.BelegNr = opBelegNr
			Set op.Buchungstext1 = opBuchungstext1
			Set op.Buchungstext2 = opBuchungstext2
			Set op.Debitor = auftrag.ZahlAdresse
			Set op.EB = 0
			Set op.Erfassungsdatum = +$H //$ZDATE($HOROLOG)
			if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
				Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
			} else {
				Set op.FibuKonto = auftrag.ZahlAdresse.FibuKonto
			}
			Set op.Mahnstufe = 0
			Set op.ManuelleErfassung = 0
			Set op.Typ = ##class(DBDebiKredi.Konst).OPTypRechnung()
			Set op.Belegdatum = auftrag.Rechnungsdatum
			Set op.Valutadatum = auftrag.Rechnungsdatum
			Set op.Vertreter = auftrag.Vertreter
			Set op.Waehrung = auftrag.Waehrung
			Set op.FWFaktor = auftrag.Kurseinheit
			Set op.FWKurs = auftrag.Kurs
			Set op.FWBetrag = op.FWBetrag + auftrag.BetragFWInklMwst
			Set op.ZKProzentsatz1 = auftrag.Zahlungskondition.ProzentSatz1
			Set op.ZKProzentsatz2 = auftrag.Zahlungskondition.ProzentSatz2
			Set op.ZKTage1 = auftrag.Zahlungskondition.TageSatz1
			Set op.ZKTage2 = auftrag.Zahlungskondition.TageSatz2
			Set op.ZKTage3 = auftrag.Zahlungskondition.TageNetto
			Set op.Zahlungskondition = auftrag.Zahlungskondition
			Set op.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
			Set sc=op.%Save()
	
			do auftrag.OPSetObjectId(op.%Id())
			set auftrag.Verbucht = 1
			set auftrag.VerbuchungsjournalNr = verbuchungsJnr
			set sc=auftrag.%Save()
		}
	} else {
		w strSQL,!
		w "DBDebiKredi.OPDebi.CreateOpFromAgrofreshAuftrag: "_sc,!
	}
	
	Set strSQL = "SELECT Mwst, MwstSatz, "_
					"SUM(BetragExklMwst) As BetragExklMwst, "_
					"SUM(MwstBetrag) As MwstBetrag "_
					"FROM (SELECT Mwst, MwstSatz, "_
					"BetragExklMwst As BetragExklMwst, MwstBetrag As MwstBetrag "_
					"FROM DBAgrofresh.Auftragspos WHERE Auftragskopf->RechnungsNr="_RgNr_
					"AND Auftragskopf->Mandant="_MandantOid_" "_
					"AND NVL(Artikelcode, 0) <> 8 AND "_
					"(NVL(Artikelcode, 0) < 10 OR NVL(Artikelcode, 0) = 21) "_
					"UNION ALL SELECT GebKontr->Gebinde->MwstVK As Mwst, "_
					"GebKontr->Gebinde->MwstVK->MwstSatzFibu As MwstSatz, "_
					"GebindeSaldoBetragExklMwst As BetragExklMwst, GebindeSaldoBetragMwst As MwstBetrag "_
					"FROM DBAgrofresh.GebDetail WHERE Auftrag->RechnungsNr="_RgNr_
					" AND Auftrag->Mandant="_MandantOid_" AND "_
					"GebindeSaldoBetragExklMwst<>0) GROUP BY Mwst, MwstSatz"
	w !,strSQL,!
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
			Set opMwst.BetragExklMwst = rs.Data("BetragExklMwst")
			Set opMwst.Mwst = ##class(DBFibu.SD.Mwst).%OpenId(rs.Data("Mwst"))
			Set opMwst.MwstBetrag = rs.Data("MwstBetrag")
			Set opMwst.MwstSatz = rs.Data("MwstSatz")
			Set opMwst.OP = op
			do opMwst.%Save() 
		}
    } else {
		w strSQL,!
		w "DBDebiKredi.OPDebi.CreateOpFromAgrofreshAuftrag: "_sc,!
	}
    
    Set strSQL = "SELECT ID FROM DBAgrofresh.Auftragskopf WHERE RechnungsNr="_RgNr_
					" AND Mandant="_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		
		Set zahlung = ##class(DBDebiKredi.Zahlung).%New()
		Set opZahlung = ##class(DBDebiKredi.OPZahlung).%New()
					
		while (rs.Next(.sc)) {
			
			Set auftrag = ##class(DBAgrofresh.Auftragskopf).%OpenId(rs.Data("ID"))
	
			// Bei Barzahlung - Zahlung anlegen
			if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
				Set zahlung.BelegNr = zahlungBelegNr
				Set zahlung.Buchungstext1 = zahlungBuchungstext1
				Set zahlung.Buchungstext2 = zahlungBuchungstext2
				Set zahlung.Erfassungsdatum = +$H
				Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
				Set zahlung.FWFaktor = auftrag.Kurseinheit
				Set zahlung.FWKurs = auftrag.Kurs
				Set zahlung.ManuelleErfassung = 0
				Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
				Set zahlung.Belegdatum = auftrag.Rechnungsdatum
				Set zahlung.Valutadatum = auftrag.Rechnungsdatum
				Set zahlung.Verbuchungsjnr = 0
				Set zahlung.Waehrung = auftrag.Waehrung
				Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
				Set sc = zahlung.%Save()
		
				Set opZahlung.OP = op
				Set opZahlung.Zahlung = zahlung
				Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + auftrag.TotalMitGebinde
				Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + auftrag.Skonto
				Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + auftrag.SkontoFW
				Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + auftrag.BetragFWInklMwst
				Set sc = opZahlung.%Save()
			}
		}
	} else {
		w strSQL,!
		w "DBDebiKredi.OPDebi.CreateOpFromAgrofreshAuftrag: "_sc,!
	}
	
	Quit op.%Id()
]]></Implementation>
</Method>

<Method name="GetFirstOPOidByBelegNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>belegnr:%String,mandantOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set opOid = ""
	&sql(SELECT TOP 1 ID INTO :opOid FROM DBDebiKredi.OPDebi 
			WHERE BelegNr=:belegnr AND 
					Debitor->Mandant=:mandantOid AND
					IsOPgeschlossen=0)
			
	Quit opOid
]]></Implementation>
</Method>

<Method name="GetOPOidByBelegNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>belegnr:%String,mandantOid:%String,checkAdrNr:%Integer,adressNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set opOid = ""
	&sql(SELECT TOP 1 ID INTO :opOid FROM DBDebiKredi.OPDebi 
			WHERE BelegNr=:belegnr AND 
					Debitor->Mandant=:mandantOid AND
					(:checkAdrNr=0 OR Debitor->Adresse->Adressnummer=:adressNr)
		ORDER BY IsOPGeschlossen)
			
	Quit opOid
]]></Implementation>
</Method>

<Method name="ResetOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>mandantOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set strSQL="SELECT ID FROM DBDebiKredi.OPDebi WHERE Debitor->Mandant = "_mandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	set res = $$$OK
    IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set id=rs.Data("ID")
			
			Set strSQL="SELECT ID FROM DBFakturierung.Auftragskopf WHERE OP = "_id
			Set rsOpFakt = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rsOpFakt.Prepare(strSQL)
			Set scOpFakt=rsOpFakt.Execute()
			set res = $$$OK
		    IF $$$ISOK(scOpFakt) {
				while (rsOpFakt.Next(.scOpFakt)) {
					Set idOpFakt=rsOpFakt.Data("ID")
					set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(idOpFakt)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpFakt = auftrag.%Save()
					if ($$$ISERR(statusOpFakt)) {
						w "Fehler beim Loeschen des Fakturierung-Auftrags: ", statusOpFakt, !
						set res = statusOpFakt
					}
				}
		    }
		    
		    Set strSQL="SELECT ID FROM DBAgrofresh.Auftragskopf WHERE OP = "_id
		    Set rsOpAgrofresh = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		    Do rsOpAgrofresh.Prepare(strSQL)
			Set scOpAgrofresh=rsOpAgrofresh.Execute()
			IF $$$ISOK(scOpAgrofresh) {
				while (rsOpAgrofresh.Next(.scOpAgrofresh)) {
					Set idOpAgrofresh=rsOpAgrofresh.Data("ID")
					set auftrag = ##class(DBAgrofresh.Auftragskopf).%OpenId(idOpAgrofresh)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpAgrofresh = auftrag.%Save()
					if ($$$ISERR(statusOpAgrofresh)) {
						w "Fehler beim Loeschen des Agrofresh-Auftrags: ", statusOpAgrofresh, !
						set res = statusOpAgrofresh
					}
				}
		    }
		    
		    Set strSQL="SELECT ID FROM DBAgrofreshEK.Bestellungskopf WHERE OP = "_id
		    Set rsOpAgrofreshEK = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		    Do rsOpAgrofreshEK.Prepare(strSQL)
			Set scOpAgrofreshEK=rsOpAgrofreshEK.Execute()
			IF $$$ISOK(scOpAgrofreshEK) {
				while (rsOpAgrofreshEK.Next(.scOpAgrofreshEK)) {
					Set idOpAgrofreshEK=rsOpAgrofreshEK.Data("ID")
					set auftrag = ##class(DBAgrofreshEK.BestellungsKopf).%OpenId(idOpAgrofreshEK)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpAgrofreshEK = auftrag.%Save()
					if ($$$ISERR(statusOpAgrofreshEK)) {
						w "Fehler beim Loeschen des AgrofreshEK-Auftrags: ", statusOpAgrofreshEK, !
						set res = statusOpAgrofreshEK
					}
				}
		    }
		    
			Set strSQL="SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP = "_id
			Set rsOpZ = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rsOpZ.Prepare(strSQL)
			Set scOpZ=rsOpZ.Execute()
			IF $$$ISOK(scOpZ) {
				while (rsOpZ.Next(.scOpZ)) {
					Set idOpZ=rsOpZ.Data("Zahlung")
					set statusOpZ = ##class(DBDebiKredi.Zahlung).%DeleteId(idOpZ)
					if ($$$ISERR(statusOpZ)) {
						w "Fehler beim Loeschen der Debi-Zahlung: ", statusOpZ, !
						set res = statusOpZ
					}
				}
		    }
		   		   		    
			set status = ##class(DBDebiKredi.OPDebi).%DeleteId(id)
			if ($$$ISERR(status)) {
				w "Fehler beim Loeschen des Debi-OPs: ", status, !
				set res = status
			}
		}
    }
       
    Set strSQL="SELECT ID FROM DBDebiKredi.DebitorUmsatz WHERE Debitor->Mandant = "_mandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	set res = $$$OK
    IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set id=rs.Data("ID")
			set statusDebiUmsatz = ##class(DBDebiKredi.DebitorUmsatz).%DeleteId(id)
			if ($$$ISERR(statusDebiUmsatz)) {
				w "Fehler beim Loeschen der Debi-Umsaetze: ", statusDebiUmsatz, !
				set res = statusDebiUmsatz
			}
		}
    }
     
    Set strSQL="SELECT ID FROM DBDebiKredi.Debitor WHERE Mandant = "_mandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	set res = $$$OK
    IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set id=rs.Data("ID")
			set debi = ##class(DBDebiKredi.Debitor).%OpenId(id)
			set debi.DatumLetzteBewegung = ""
			set statusDebi = debi.%Save()
			if ($$$ISERR(statusDebi)) {
				w "Fehler beim Zuruecksetzen des Datums des Debitors: ", statusDebi, !
				set res = statusDebi
			}
		}
    }
    
	Quit res
]]></Implementation>
</Method>

<Method name="CreateOpFromFakturierungAuftrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>RgNr:%Integer,MandantOid:%String,buchungOid:%String,barzahlungsZahlungskondOid:%String,barzahlungskontoOid:%String,verbuchungsJnr:%Integer,opBuchungstext1:%String,opBuchungstext2:%String,opBelegNr:%String,zahlungBuchungstext1:%String,zahlungBuchungstext2:%String,zahlungBelegNr:%String,verbuchungsJnrDebiZahlungen:%Integer,pauschaleMwstAbrechnung:%Boolean,endeGeschJahr:%Date,rundungsEinst:%Integer,saldoSatzBrutto:%Boolean</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID FROM DBFakturierung.Auftragskopf WHERE RechnungsNr="_RgNr_
					" AND Mandant="_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		
		Set op = ##class(DBDebiKredi.OPDebi).%New()
		set garantieAuftrag = 0
		
		while (rs.Next(.sc)) {
			
			Set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(rs.Data("ID"))
	
			if (auftrag.IsGarantieAuftrag '= 1) {
				Set op.BelegNr = opBelegNr
				Set op.Buchungstext1 = opBuchungstext1
				Set op.Buchungstext2 = opBuchungstext2
				Set op.Debitor = auftrag.ZahlAdresse
				Set op.EB = 0
				Set op.Erfassungsdatum = +$H //$ZDATE($HOROLOG)
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					if ((auftrag.Barkonto = $c(0)) || (auftrag.Barkonto = "")) {
						Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
					} else {
						Set op.FibuKonto = auftrag.Barkonto
					}
				} else {
					Set op.FibuKonto = auftrag.ZahlAdresse.FibuKonto
				}
				Set op.Mahnstufe = 0
				Set op.ManuelleErfassung = 0
				Set op.Typ = ##class(DBDebiKredi.Konst).OPTypRechnung()
				Set op.Belegdatum = auftrag.Rechnungsdatum
				Set op.Valutadatum = auftrag.Rechnungsdatum
				Set op.Vertreter = auftrag.Vertreter
				Set op.Waehrung = auftrag.Waehrung
				Set op.FWFaktor = auftrag.Kurseinheit
				Set op.FWKurs = auftrag.Kurs
				Set op.FWBetrag = op.FWBetrag + auftrag.BetragFWInklMwst
				Set op.ZKProzentsatz1 = auftrag.Zahlungskondition.ProzentSatz1
				Set op.ZKProzentsatz2 = auftrag.Zahlungskondition.ProzentSatz2
				Set op.ZKTage1 = auftrag.Zahlungskondition.TageSatz1
				Set op.ZKTage2 = auftrag.Zahlungskondition.TageSatz2
				Set op.ZKTage3 = auftrag.Zahlungskondition.TageNetto
				Set op.Zahlungskondition = auftrag.Zahlungskondition
				Set op.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
				Set sc=op.%Save()
	
				do auftrag.OPSetObjectId(op.%Id())
			} else {
				set garantieAuftrag = 1
			}
			
			set auftrag.Verbucht = 1
			set auftrag.VerbuchungsjournalNr = verbuchungsJnr
			set auftrag.Buchungscode = ##class(DBFakturierung.Konst).ADBuchungstypRGKunde()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),1)
			set sc=auftrag.%Save()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),0)
		}
	} else {
		w strSQL,!
		w "DBDebiKredi.OPDebi.CreateOpFromFakturierungAuftrag: "_sc,!
	}
	
	if (garantieAuftrag '= 1) {
		
		/*
		&sql(SELECT Mwst, 
					MwstSatz, 
					SUM(BetragExklMwst) As BetragExklMwst,
					SUM(MwstBetrag) As MwstBetrag,
					Lieferdatum
				FROM (SELECT Mwst, 
							MwstSatz, 
							Nettobetrag2ExklMwstEW As BetragExklMwst, 
							Nettobetrag2MwstbetragEW As MwstBetrag,
							Auftragskopf->Lieferdatum As Lieferdatum 
						FROM DBFakturierung.Auftragspos 
						WHERE Auftragskopf->RechnungsNr=:RgNr AND 
							Auftragskopf->Mandant=:MandantOid AND 
							NVL(Artikelcode, 0) <> 8 AND 
							(NVL(Artikelcode, 0) < 10 OR 
								NVL(Artikelcode, 0) = 21 OR 
								NVL(Artikelcode, 0) = 23 OR 
								(NVL(Artikelcode, 0) >= 30 AND 
					NVL(Artikelcode, 0) <= 33))
						)
				GROUP BY Mwst, MwstSatz)
			*/
						
		Set strSQL = "SELECT Mwst, MwstSatz, Lieferdatum, "_
						"SUM(BetragExklMwst) As BetragExklMwst, "_
						"SUM(MwstBetrag) As MwstBetrag "_
						"FROM (SELECT Mwst, MwstSatz, "_
						"Nettobetrag2ExklMwstEW As BetragExklMwst, Nettobetrag2MwstbetragEW As MwstBetrag, "_
						"Auftragskopf->Lieferdatum As Lieferdatum "_
						"FROM DBFakturierung.Auftragspos WHERE Auftragskopf->RechnungsNr="_RgNr_
						"AND Auftragskopf->Mandant="_MandantOid_" "_
						"AND NVL(Artikelcode, 0) <> 8 AND "_
						"(NVL(Artikelcode, 0) < 10 OR NVL(Artikelcode, 0) = 21 OR NVL(Artikelcode, 0) = 23 OR (NVL(Artikelcode, 0) >= 30 AND NVL(Artikelcode, 0) <= 33))) "_
						"GROUP BY Mwst, MwstSatz"
		w strSQL,!
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
				Set opMwst.Mwst = ##class(DBFibu.SD.Mwst).%OpenId(rs.Data("Mwst"))
				
				if (pauschaleMwstAbrechnung=1) {
					set betragInklMwst = (rs.Data("BetragExklMwst")+rs.Data("MwstBetrag"))
					set mwstSatzPauschal = ##class(DBFibu.SD.Mwst).GetMwstSatzFibuClass(rs.Data("Mwst"),$ZDATEH(rs.Data("Lieferdatum"),3),endeGeschJahr)
					set mwstBetrag = ((betragInklMwst / (100 + mwstSatzPauschal)) * mwstSatzPauschal)
					set mwstBetrag = ##class(DBUtils.NumberUtils).RoundWithEinst(rundungsEinst,mwstBetrag)
	                if (saldoSatzBrutto=1) {
                    	set mwstBetrag=0
                    }
					set betragExklMwst = (betragInklMwst-mwstBetrag)
					
					w "DBDebiKredi.OPDebi.CreateOpFromFakturierungAuftrag",!
					w "betragInklMwst: "_betragInklMwst,!
					w "mwstSatzPauschal: "_mwstSatzPauschal,!
					w "mwstBetrag: "_mwstBetrag,!
					w "betragExklMwst: "_betragExklMwst,!
					
					Set opMwst.BetragExklMwst = betragExklMwst
					Set opMwst.MwstBetrag = mwstBetrag
					Set opMwst.MwstSatz = mwstSatzPauschal
					
				} else {
					Set opMwst.BetragExklMwst = rs.Data("BetragExklMwst")
					Set opMwst.MwstBetrag = rs.Data("MwstBetrag")
					Set opMwst.MwstSatz = rs.Data("MwstSatz")
				}
				Set opMwst.OP = op
				do opMwst.%Save() 
			}
	    } else {
			w strSQL,!
			w "DBDebiKredi.OPDebi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
    
	    set faktor = 1
    
	    if (op.BetragInklMwst < 0) {
		    set faktor = -1
		    Set op.Typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()
		    Set op.FWBetrag = ((-1)*op.FWBetrag)
			do op.%Save()
		
			Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_op.%Id()
			Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rs.Prepare(strSQL)
			Set sc=rs.Execute()
	
			IF $$$ISOK(sc) {
		
				while (rs.Next(.sc)) {
					Set opMwst = ##class(DBDebiKredi.OPMwst).%OpenId(rs.Data("ID"))
					Set opMwst.BetragExklMwst = ((-1)*opMwst.BetragExklMwst)
					Set opMwst.MwstBetrag = ((-1)*opMwst.MwstBetrag)
					do opMwst.%Save() 
				}
			}	
	    }
    
	    Set strSQL = "SELECT ID FROM DBFakturierung.Auftragskopf WHERE RechnungsNr="_RgNr_
						" AND Mandant="_MandantOid
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
		
			Set zahlung = ##class(DBDebiKredi.Zahlung).%New()
			Set opZahlung = ##class(DBDebiKredi.OPZahlung).%New()
					
			while (rs.Next(.sc)) {
			
				Set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(rs.Data("ID"))
	
				// Bei Barzahlung - Zahlung anlegen
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					if ((auftrag.Barkonto = $c(0)) || (auftrag.Barkonto = "")) {
						Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
					} else {
						Set zahlung.FibuKonto = auftrag.Barkonto
					}
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor > 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrDebiZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
				
					// Bei Check - Zahlung anlegen
				} elseif ((auftrag.Zahlungskondition.Code >= 40) && (auftrag.Zahlungskondition.Code <= 49)) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(auftrag.Zahlungskondition.FibuKonto.%Id())
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor > 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrDebiZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
				}
			}
		} else {
			w strSQL,!
			w "DBDebiKredi.OPDebi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
	
		Quit op.%Id()
	} else {
		Quit ""
	}
]]></Implementation>
</Method>

<Method name="GetMahnstufe">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set stufe = 0
	&sql(SELECT MAX(Mahnstufe) Into :stufe FROM DBDebiKredi.OPDebi WHERE Debitor=:debiOid AND IsOPgeschlossen=0)
	quit stufe
]]></Implementation>
</Method>

<Method name="GetFaellig">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set op = ##class(DBDebiKredi.OPDebi).%OpenId(opOid)
	
	set faellig = $ZD(op.Belegdatum)
	
	if (op.Zahlungskondition '= "") {
		set tageNetto = op.ZKTage3
		set faellig = ##class(DBUtils.DateUtils).DayAdd(faellig, tageNetto)
	}
	
	quit $ZDH(faellig)
]]></Implementation>
</Method>

<Method name="GetVerzugstage">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,stichtag:%Date</FormalSpec>
<ReturnType>%Integer</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set op = ##class(DBDebiKredi.OPDebi).%OpenId(opOid)
	
	if ('op.IsOPgeschlossen) {
		set faellig = $ZD(op.Belegdatum)
	
		if (op.Zahlungskondition '= "") {
			set tageNetto = op.ZKTage3
			set faellig = ##class(DBUtils.DateUtils).DayAdd(faellig, tageNetto)
		}
		
		set diff = ##class(DBUtils.DateUtils).DateDiffInDays(faellig,$ZD(stichtag))
	
		quit diff
		
	} else {
		quit 0
	}
]]></Implementation>
</Method>

<Method name="GetAlter">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,stichtag:%Date</FormalSpec>
<ReturnType>%Integer</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set op = ##class(DBDebiKredi.OPDebi).%OpenId(opOid)
	
	set belegdatum = $ZD(op.Belegdatum)		
	set diff = ##class(DBUtils.DateUtils).DateDiffInDays(belegdatum,$ZD(stichtag))
	
	quit diff
]]></Implementation>
</Method>

<Method name="RecalcOpFromFakturierungAuftrag">
<ClassMethod>1</ClassMethod>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID, OP, OP->Typ, OP->BelegNr, OP->BetragInklMwst, TotalMitGebinde FROM DBFakturierung.Auftragskopf WHERE Verbucht=1 AND ((OP->Typ=0 AND (OP->BetragInklMwst-TotalMitGebinde) <> 0) OR (OP->Typ=5 AND (OP->BetragInklMwst+TotalMitGebinde) <> 0)) AND OP IN (SELECT ID FROM DBDebiKredi.OPDebi)"
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set count = 0
	
	while (rs.Next(.sc)) {
		Set op = ##class(DBDebiKredi.OPDebi).%OpenId(rs.Data("OP"))
		
		Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_rs.Data("OP")
		Set rsB = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")

		Do rsB.Prepare(strSQL)
		Set scB=rsB.Execute()

		while (rsB.Next(.scB)) {
			set statusB = ##class(DBDebiKredi.OPMwst).%DeleteId(rsB.Data("ID"))
			if ($$$ISERR(statusB)) {
				w "Error Delete DBDebiKredi.OPMwst: "_statusB, !
			}
		}
		
		Set strSQL = "SELECT Mwst, MwstSatz, "_
						"SUM(BetragExklMwst) As BetragExklMwst, "_
						"SUM(MwstBetrag) As MwstBetrag "_
						"FROM (SELECT Mwst, MwstSatz, "_
						"Nettobetrag2ExklMwstEW As BetragExklMwst, Nettobetrag2MwstbetragEW As MwstBetrag "_
						"FROM DBFakturierung.Auftragspos WHERE Auftragskopf="_rs.Data("ID")_
						"AND NVL(Artikelcode, 0) <> 8 AND "_
						"(NVL(Artikelcode, 0) < 10 OR NVL(Artikelcode, 0) = 21) "_
						"UNION ALL SELECT GebKontr->Gebinde->MwstVK As Mwst, "_
						"GebKontr->Gebinde->MwstVK->MwstSatzFibu As MwstSatz, "_
						"GebindeSaldoBetragExklMwst As BetragExklMwst, GebindeSaldoBetragMwst As MwstBetrag "_
						"FROM DBFakturierung.GebDetail WHERE Auftrag="_rs.Data("ID")_
						" AND GebindeSaldoBetragExklMwst<>0) GROUP BY Mwst, MwstSatz"
		
		Set rsD = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rsD.Prepare(strSQL)
		Set scD=rsD.Execute()
	
		IF $$$ISOK(scD) {
			while (rsD.Next(.scD)) {
				Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
				Set opMwst.BetragExklMwst = rsD.Data("BetragExklMwst")
				Set opMwst.Mwst = ##class(DBFibu.SD.Mwst).%OpenId(rsD.Data("Mwst"))
				Set opMwst.MwstBetrag = rsD.Data("MwstBetrag")
				Set opMwst.MwstSatz = rsD.Data("MwstSatz")
				Set opMwst.OP = op
				do opMwst.%Save() 
			}
	    } else {
			w strSQL,!
			w "DBDebiKredi.OPDebi.CreateOpFromFakturierungAuftrag: "_scD,!
		}
    
	    if (op.BetragInklMwst < 0) {
		    Set op.Typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()
		    Set op.FWBetrag = ((-1)*op.FWBetrag)
			do op.%Save()
		
			Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_op.%Id()
			Set rsX = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rsX.Prepare(strSQL)
			Set scX=rsX.Execute()
	
			IF $$$ISOK(scX) {
		
				while (rsX.Next(.sc)) {
					Set opMwst = ##class(DBDebiKredi.OPMwst).%OpenId(rsX.Data("ID"))
					Set opMwst.BetragExklMwst = ((-1)*opMwst.BetragExklMwst)
					Set opMwst.MwstBetrag = ((-1)*opMwst.MwstBetrag)
					do opMwst.%Save() 
				}
			}	
	    }
	    
	    set count = count + 1
	}
]]></Implementation>
</Method>

<Method name="HasDebiOffeneFwOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>DebiOid:%String,EwWaehrungOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myOid = ""
	&sql(SELECT TOP 1 ID INTO :myOid FROM DBDebiKredi.OPDebi WHERE Debitor=:DebiOid AND IsOPgeschlossen<>1 AND Waehrung<>:EwWaehrungOid)
	
	if (SQLCODE '= 0) {
		set myOid = ""
	}
	quit (myOid'="")
]]></Implementation>
</Method>

<Method name="HasDebiAlleFwOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>DebiOid:%String,EwWaehrungOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myOid = ""
	&sql(SELECT TOP 1 ID INTO :myOid FROM DBDebiKredi.OPDebi WHERE Debitor=:DebiOid AND Waehrung<>:EwWaehrungOid)
	
	if (SQLCODE '= 0) {
		set myOid = ""
	}
	quit (myOid'="")
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DefaultData>OPDebiDefaultData</DefaultData>
<Data name="OPDebiDefaultData">
<Structure>listnode</Structure>
<Subscript>"OPDebi"</Subscript>
<Value name="1">
<Value>Zahlungskondition</Value>
</Value>
<Value name="2">
<Value>Debitor</Value>
</Value>
<Value name="3">
<Value>AuftragAgrofresh</Value>
</Value>
<Value name="4">
<Value>ZahlungskondIndividuellText</Value>
</Value>
</Data>
</Storage>
</Class>


<Class name="DBDebiKredi.OPDebiZusatz">
<Description>
</Description>
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62300,37761</TimeChanged>
<TimeCreated>61948,52697.090581</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="Offenposten">
<Type>DBDebiKredi.OPDebi</Type>
<Cardinality>one</Cardinality>
<Inverse>Zusatz</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="Prueffrist">
<Type>%Integer</Type>
</Property>

<Property name="ProjektbezeichnungExtern">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
</Property>

<Property name="ProjektleiterKunde">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
</Property>

<Property name="ProjektIntern">
<Type>DBIntrap.SD.Projekt</Type>
<Cardinality>one</Cardinality>
<Inverse>OPDebiZusatzProjekt</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="ProjektIntern"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ProjektInternIndex">
<Properties>ProjektIntern</Properties>
</Index>

<Property name="SachbearbeiterIntern">
<Type>DBCore.Mitarbeiter</Type>
<Cardinality>one</Cardinality>
<Inverse>OPDebiZusatzSachbearbeiter</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="SachbearbeiterIntern"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="SachbearbeiterInternIndex">
<Properties>SachbearbeiterIntern</Properties>
</Index>

<Property name="Projektleitung">
<Type>DBAdressen.Adresse</Type>
<Cardinality>one</Cardinality>
<Inverse>OPDebiZusatzProjektleitung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Projektleitung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ProjektleitungIndex">
<Properties>Projektleitung</Properties>
</Index>

<Property name="MahntextIndivid">
<Type>%String</Type>
<Parameter name="MAXLEN" value="32000"/>
</Property>

<Property name="ZahlTageIndivid">
<Type>%Integer</Type>
</Property>

<Method name="GetZusatzOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set zusatz = ""
	&sql(SELECT TOP 1 ID INTO :zusatz FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=:opOid)
			
	Quit zusatz
]]></Implementation>
</Method>

<Method name="GetProjektNrBezByOp">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set nummer = ""
	set extern = ""
	set zusatz = ""
	&sql(SELECT NVL(ProjektIntern->Hauptnummer,''), NVL(ProjektbezeichnungExtern,'') INTO :nummer, :extern FROM DBDebiKredi.OPDebiZusatz WHERE Offenposten=:opOid)
	if (SQLCODE = 0) {
		if (nummer '= "") {
			set zusatz = nummer_" - "_extern
		} else {
			set zusatz = extern
		}
	}
	Quit zusatz
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.OPDebiZusatzD</DataLocation>
<DefaultData>OPDebiZusatzDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.OPDebiZusatzD</IdLocation>
<IndexLocation>^DBDebiKredi.OPDebiZusatzI</IndexLocation>
<StreamLocation>^DBDebiKredi.OPDebiZusatzS</StreamLocation>
<Data name="OPDebiZusatzDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Prueffrist</Value>
</Value>
<Value name="3">
<Value>ProjektbezeichnungExtern</Value>
</Value>
<Value name="4">
<Value>ProjektleiterExtern</Value>
</Value>
<Value name="5">
<Value>ProjektIntern</Value>
</Value>
<Value name="6">
<Value>SachbearbeiterIntern</Value>
</Value>
<Value name="7">
<Value>Projektleitung</Value>
</Value>
<Value name="8">
<Value>OPDebi</Value>
</Value>
<Value name="9">
<Value>Offenposten</Value>
</Value>
<Value name="10">
<Value>ProjektleiterKunde</Value>
</Value>
<Value name="11">
<Value>MahntextIndivid</Value>
</Value>
<Value name="12">
<Value>ZahlTageIndivid</Value>
</Value>
</Data>
<Property name="MahntextIndivid"/>
<Property name="Offenposten"/>
<Property name="ProjektIntern"/>
<Property name="ProjektbezeichnungExtern"/>
<Property name="ProjektleiterKunde"/>
<Property name="Projektleitung"/>
<Property name="Prueffrist"/>
<Property name="SachbearbeiterIntern"/>
<Property name="ZahlTageIndivid"/>
</Storage>
</Class>


<Class name="DBDebiKredi.OPKredi">
<Description>
</Description>
<Super>DBDebiKredi.OP,%XML.Adaptor</Super>
<TimeChanged>62250,56658.624114</TimeChanged>
<TimeCreated>61494,38126.551736</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="Zahlungskondition">
<Description>
Zahlungskondition</Description>
<Type>DBDebiKredi.SD.KZahlungskond</Type>
<Cardinality>one</Cardinality>
<Inverse>OPKrediZKond</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahlungskondition"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="KrediZahlungskondIndex">
<Properties>Zahlungskondition</Properties>
</Index>

<Property name="Kreditor">
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>one</Cardinality>
<Inverse>OPKrediKreditor</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Adresse"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="KreditorIndex">
<Properties>Kreditor</Properties>
</Index>

<Property name="BestellungAgrofresh">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>OP</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="Bank">
<Type>DBDebiKredi.SD.KBank</Type>
<Cardinality>one</Cardinality>
<Inverse>OPKredi</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Bank"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="RefNrGrund">
<Description>
Referenznummer Grund</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Zahlungsvorschlag">
<Description>
Als Zahlungsvorschlag markiert</Description>
<Type>%Library.Boolean</Type>
</Property>

<Index name="ZahlungsvorschlagIndex">
<Properties>Zahlungsvorschlag</Properties>
</Index>

<Method name="AddBetragToSaldovortrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),krediId:%String,mandJahrId:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	if (krediId '= "") {
		if (storno=1) {
			set betragEw = ((-1)*betragEw)
			set betragFw = ((-1)*betragFw)
		}
		
		Set kredi = ##class(DBDebiKredi.Kreditor).%OpenId(krediId)
		do kredi.SetSaldovortragEw(mandJahrId,waehrungOid,(kredi.GetSaldovortragEw(mandJahrId,waehrungOid)+betragEw))
		do kredi.SetSaldovortragFw(mandJahrId,waehrungOid,(kredi.GetSaldovortragFw(mandJahrId,waehrungOid)+betragFw))
	}
]]></Implementation>
</Method>

<Method name="AddBetragToUmsatzSoll">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),valuta:%Date,krediId:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	if (krediId '= "") {
		set beginnGeschJahr = 0
		set endeGeschJahr = 0
		set mandId = 0
		
		&sql(SELECT Mandant INTO :mandId
			 FROM DBDebiKredi.Kreditor WHERE ID=:krediId)
			 
		Set rs = ##class(%Library.ResultSet).%New("DBCore.AF.MandantJahrAF.ListeNachMandant")
		Set sc=rs.Execute(mandId)
	
		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set mandJahrId = rs.Data("ID")
				
				set j = ##class(DBCore.MandantJahr).%OpenId(mandJahrId)
				if (j '= "") {
					set beginnGeschJahr = j.GeschaeftsjahrBeginn
					set endeGeschJahr = j.GeschaeftsjahrEnde	
				}
		
				if (valuta < beginnGeschJahr) {
					// Invertierung, da Soll
					set betragEwSV = ((-1)*betragEw)
					set betragFwSV = ((-1)*betragFw)
					do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(betragEwSV,betragFwSV,krediId,mandJahrId,waehrungOid,storno)
			
					set beginnVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(beginnGeschJahr),-1))
					set endeVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(endeGeschJahr),-1))
					if ((valuta >= beginnVorjahr)) {
						if (storno=1) {
							set betragEw = ((-1)*betragEw)
							set betragFw = ((-1)*betragFw)
						}
		
						set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeVorjahr, valuta)
			
						set oldUmsatzEw = 0
						set oldUmsatzFw = 0
						set oldUmsatzEw = ##class(DBDebiKredi.Kreditor).GetUmsatzSollVjEwClass(krediId,mandJahrId,waehrungOid,periode)
						set oldUmsatzFw = ##class(DBDebiKredi.Kreditor).GetUmsatzSollVjFwClass(krediId,mandJahrId,waehrungOid,periode)
			
						set newUmsatzEw = oldUmsatzEw + betragEw
						set newUmsatzFw = oldUmsatzFw + betragFw
			
						do ##class(DBDebiKredi.Kreditor).SetUmsatzSollVjEwClass(krediId,mandJahrId,waehrungOid,periode,newUmsatzEw)
						do ##class(DBDebiKredi.Kreditor).SetUmsatzSollVjFwClass(krediId,mandJahrId,waehrungOid,periode,newUmsatzFw)
					}
					
				} elseif (valuta < endeGeschJahr) {
					if (storno=1) {
						set betragEw = ((-1)*betragEw)
						set betragFw = ((-1)*betragFw)
					}
		
					set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeGeschJahr, valuta)
			
					set oldUmsatzEw = 0
					set oldUmsatzFw = 0
					set oldUmsatzEw = ##class(DBDebiKredi.Kreditor).GetUmsatzSollEwClass(krediId,mandJahrId,waehrungOid,periode)
					set oldUmsatzFw = ##class(DBDebiKredi.Kreditor).GetUmsatzSollFwClass(krediId,mandJahrId,waehrungOid,periode)
			
					set newUmsatzEw = oldUmsatzEw + betragEw
					set newUmsatzFw = oldUmsatzFw + betragFw
			
					do ##class(DBDebiKredi.Kreditor).SetUmsatzSollEwClass(krediId,mandJahrId,waehrungOid,periode,newUmsatzEw)
					do ##class(DBDebiKredi.Kreditor).SetUmsatzSollFwClass(krediId,mandJahrId,waehrungOid,periode,newUmsatzFw)
			
				}
			}
		}
	}
]]></Implementation>
</Method>

<Method name="AddBetragToUmsatzHaben">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragEw:%Decimal(SCALE=5),betragFw:%Decimal(SCALE=5),valuta:%Date,krediId:%String,waehrungOid:%String,storno:%Boolean</FormalSpec>
<Implementation><![CDATA[
	if (krediId '= "") {		
		set beginnGeschJahr = 0
		set endeGeschJahr = 0
		set mandId = 0
		
		&sql(SELECT Mandant INTO :mandId
			 FROM DBDebiKredi.Kreditor WHERE ID=:krediId)
			 
		Set rs = ##class(%Library.ResultSet).%New("DBCore.AF.MandantJahrAF.ListeNachMandant")
		Set sc=rs.Execute(mandId)

		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set mandJahrId = rs.Data("ID")
			
				set j = ##class(DBCore.MandantJahr).%OpenId(mandJahrId)
				if (j '= "") {
					set beginnGeschJahr = j.GeschaeftsjahrBeginn
					set endeGeschJahr = j.GeschaeftsjahrEnde	
				}
	
				if (valuta < beginnGeschJahr) {
					do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(betragEw,betragFw,krediId,mandJahrId,waehrungOid,storno)
		
					set beginnVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(beginnGeschJahr),-1))
					set endeVorjahr = $ZDH(##class(DBUtils.DateUtils).YearAdd($ZD(endeGeschJahr),-1))
					if ((valuta >= beginnVorjahr)) {
						if (storno=1) {
							set betragEw = ((-1)*betragEw)
							set betragFw = ((-1)*betragFw)
						}
		
						set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeVorjahr, valuta)
						set oldUmsatzEw = 0
						set oldUmsatzFw = 0
						set oldUmsatzEw = ##class(DBDebiKredi.Kreditor).GetUmsatzHabenVjEwClass(krediId, mandJahrId, waehrungOid, periode)
						set oldUmsatzFw = ##class(DBDebiKredi.Kreditor).GetUmsatzHabenVjFwClass(krediId, mandJahrId, waehrungOid, periode)
		
						set newUmsatzEw = oldUmsatzEw + betragEw
						set newUmsatzFw = oldUmsatzFw + betragFw
						do ##class(DBDebiKredi.Kreditor).SetUmsatzHabenVjEwClass(krediId, mandJahrId, waehrungOid, periode, newUmsatzEw)
						do ##class(DBDebiKredi.Kreditor).SetUmsatzHabenVjFwClass(krediId, mandJahrId, waehrungOid, periode, newUmsatzFw)
					}
				} elseif (valuta < endeGeschJahr) {
		
					if (storno=1) {
						set betragEw = ((-1)*betragEw)
						set betragFw = ((-1)*betragFw)
					}
		
					set periode = ##class(DBUtils.DateUtils).CalcPeriode(endeGeschJahr, valuta)
					set oldUmsatzEw = 0
					set oldUmsatzFw = 0
					set oldUmsatzEw = ##class(DBDebiKredi.Kreditor).GetUmsatzHabenEwClass(krediId, mandJahrId, waehrungOid, periode)
					set oldUmsatzFw = ##class(DBDebiKredi.Kreditor).GetUmsatzHabenFwClass(krediId, mandJahrId, waehrungOid, periode)
		
					set newUmsatzEw = oldUmsatzEw + betragEw
					set newUmsatzFw = oldUmsatzFw + betragFw
					do ##class(DBDebiKredi.Kreditor).SetUmsatzHabenEwClass(krediId, mandJahrId, waehrungOid, periode, newUmsatzEw)
					do ##class(DBDebiKredi.Kreditor).SetUmsatzHabenFwClass(krediId, mandJahrId, waehrungOid, periode, newUmsatzFw)
				}
			}
		}
	}
]]></Implementation>
</Method>

<Method name="CreateOpFromAgrofreshBestellung">
<ClassMethod>1</ClassMethod>
<FormalSpec>auftragOid:%String,buchungOid:%String,barzahlungsZahlungskondOid:%String,barzahlungskontoOid:%String,verbuchungsJnr:%Integer,opBuchungstext1:%String,opBuchungstext2:%String,opBelegNr:%String,zahlungBuchungstext1:%String,zahlungBuchungstext2:%String,zahlungBelegNr:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set bestellung = ##class(DBAgrofreshEK.BestellungsKopf).%OpenId(auftragOid)
	
	Set op = ##class(DBDebiKredi.OPKredi).%New()
	Set op.BelegNr = opBelegNr
	Set op.Buchungstext1 = opBuchungstext1
	Set op.Buchungstext2 = opBuchungstext2
	Set op.Kreditor = bestellung.ZahlAdresse
	Set op.EB = 0
	Set op.Erfassungsdatum = +$H //$ZDATE($HOROLOG)
	if (bestellung.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
		Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
	} else {
		Set op.FibuKonto = bestellung.ZahlAdresse.FibuKonto
	}
	Set op.Bank = ##class(DBDebiKredi.SD.KBank).%OpenId(bestellung.ZahlAdresse.AktBank)
	Set op.RefNrGrund = opBelegNr
	Set op.Mahnstufe = 0
	Set op.ManuelleErfassung = 0
	Set op.Typ = ##class(DBDebiKredi.Konst).OPTypRechnung()
	Set op.Valutadatum = bestellung.Abrechnungsdatum
	Set op.Vertreter = bestellung.Vertreter
	Set op.Waehrung = bestellung.Waehrung
	Set op.FWFaktor = bestellung.Kurseinheit
	Set op.FWKurs = bestellung.Kurs
	Set op.FWBetrag = bestellung.BetragFW
	Set op.ZKProzentsatz1 = bestellung.Zahlungskondition.ProzentSatz1
	Set op.ZKProzentsatz2 = bestellung.Zahlungskondition.ProzentSatz2
	Set op.ZKTage1 = bestellung.Zahlungskondition.TageSatz1
	Set op.ZKTage2 = bestellung.Zahlungskondition.TageSatz2
	Set op.ZKTage3 = bestellung.Zahlungskondition.TageNetto
	Set op.Zahlungskondition = bestellung.Zahlungskondition
	Set op.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
	Set sc=op.%Save()
	
	set bestellung.OP = op
	set bestellung.Verbucht = 1
	set bestellung.VerbuchungsjournalNr = verbuchungsJnr
	set sc=bestellung.%Save()
	
	Set strSQL = "SELECT Mwst, MwstSatz, "_
					"SUM(BetragExklMwst) As BetragExklMwst, "_
					"SUM(MwstBetrag) As MwstBetrag "_
					"FROM (SELECT Mwst, MwstSatz, "_
					"BetragExklMwst As BetragExklMwst, MwstBetrag As MwstBetrag "_
					"FROM DBAgrofreshEK.Bestellungspos WHERE Bestellungskopf="_auftragOid_" "_
					"UNION ALL SELECT GebKontr->Gebinde->MwstVK As Mwst, "_
					"GebKontr->Gebinde->MwstVK->MwstSatzFibu As MwstSatz, "_
					"GebindeSaldoBetrag As BetragExklMwst, 0 As MwstBetrag "_
					"FROM DBAgrofreshEK.GebDetail WHERE Bestellung="_auftragOid_" AND "_
					"GebindeSaldoBetrag<>0) GROUP BY Mwst, MwstSatz"
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
			Set opMwst.BetragExklMwst = rs.Data("BetragExklMwst")
			Set opMwst.Mwst = rs.Data("Mwst")
			Set opMwst.MwstBetrag = rs.Data("MwstBetrag")
			Set opMwst.MwstSatz = rs.Data("MwstSatz")
			Set opMwst.OP = op
			do opMwst.%Save() 
		}
    }
    
	// Bei Barzahlung - Zahlung anlegen
	if (bestellung.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
		Set zahlung = ##class(DBDebiKredi.Zahlung).%New()
		Set zahlung.BelegNr = zahlungBelegNr
		Set zahlung.Buchungstext1 = zahlungBuchungstext1
		Set zahlung.Buchungstext2 = zahlungBuchungstext2
		Set zahlung.Erfassungsdatum = +$H
		Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
		Set zahlung.FWFaktor = bestellung.Kurseinheit
		Set zahlung.FWKurs = bestellung.Kurs
		Set zahlung.ManuelleErfassung = 0
		Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
		Set zahlung.Valutadatum = bestellung.Rechnungsdatum
		Set zahlung.Verbuchungsjnr = 0
		Set zahlung.Waehrung = bestellung.Waehrung
		Set sc = zahlung.%Save()
		
		Set opZahlung = ##class(DBDebiKredi.OPZahlung).%New()
		Set opZahlung.OP = op
		Set opZahlung.Zahlung = zahlung
		Set opZahlung.Zahlbetrag = bestellung.TotalMitGebinde
		Set opZahlung.SkontoAbzug = bestellung.Skonto
		Set opZahlung.FWSkontoAbzug = bestellung.SkontoFW
		Set opZahlung.FWZahlbetrag = bestellung.BetragFW
		Set sc = opZahlung.%Save()
		
		Set buchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
		Set buchung.Zahlung = zahlung
		Set sc = buchung.%Save()
		
	}
	
	Quit op.%Id()
]]></Implementation>
</Method>

<Method name="GetFirstOPOidByBelegNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>belegnr:%String,mandantOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set opOid = ""
	&sql(SELECT TOP 1 ID INTO :opOid FROM DBDebiKredi.OPKredi 
			WHERE BelegNr=:belegnr AND 
					Kreditor->Mandant=:mandantOid AND
					IsOPgeschlossen=0)
			
	Quit opOid
]]></Implementation>
</Method>

<Method name="GetOPOidByBelegNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>belegnr:%String,mandantOid:%String,checkAdrNr:%Integer,adressNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set opOid = ""
	&sql(SELECT TOP 1 ID INTO :opOid FROM DBDebiKredi.OPKredi 
			WHERE BelegNr=:belegnr AND 
					Kreditor->Mandant=:mandantOid AND
					(:checkAdrNr=0 OR Kreditor->Adresse->Adressnummer=:adressNr)
		ORDER BY IsOPGeschlossen)
			
	Quit opOid
]]></Implementation>
</Method>

<Method name="ResetOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>mandantOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set strSQL="SELECT ID FROM DBDebiKredi.OPKredi WHERE Kreditor->Mandant = "_mandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	set res = $$$OK
    IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set id=rs.Data("ID")
			
			Set strSQL="SELECT ID FROM DBFakturierung.Auftragskopf WHERE OP = "_id
			Set rsOpFakt = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rsOpFakt.Prepare(strSQL)
			Set scOpFakt=rsOpFakt.Execute()
			set res = $$$OK
		    IF $$$ISOK(scOpFakt) {
				while (rsOpFakt.Next(.scOpFakt)) {
					Set idOpFakt=rsOpFakt.Data("ID")
					set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(idOpFakt)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpFakt = auftrag.%Save()
					if ($$$ISERR(statusOpFakt)) {
						w "Fehler beim Loeschen des Fakturierung-Auftrags: ", statusOpFakt, !
						set res = statusOpFakt
					}
				}
		    }
		    
		    Set strSQL="SELECT ID FROM DBAgrofresh.Auftragskopf WHERE OP = "_id
			Set rsOpAgrofresh = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		    Do rsOpAgrofresh.Prepare(strSQL)
			Set scOpAgrofresh=rsOpAgrofresh.Execute()
			IF $$$ISOK(scOpAgrofresh) {
				while (rsOpAgrofresh.Next(.scOpAgrofresh)) {
					Set idOpAgrofresh=rsOpAgrofresh.Data("ID")
					set auftrag = ##class(DBAgrofresh.Auftragskopf).%OpenId(idOpAgrofresh)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpAgrofresh = auftrag.%Save()
					if ($$$ISERR(statusOpAgrofresh)) {
						w "Fehler beim Loeschen des Agrofresh-Auftrags: ", statusOpAgrofresh, !
						set res = statusOpAgrofresh
					}
				}
		    }
		    
		    Set strSQL="SELECT ID FROM DBAgrofreshEK.BestellungsKopf WHERE OP = "_id
			Set rsOpAgrofreshEK = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		    Do rsOpAgrofreshEK.Prepare(strSQL)
			Set scOpAgrofreshEK=rsOpAgrofreshEK.Execute()
			IF $$$ISOK(scOpAgrofreshEK) {
				while (rsOpAgrofreshEK.Next(.scOpAgrofreshEK)) {
					Set idOpAgrofreshEK=rsOpAgrofreshEK.Data("ID")
					set auftrag = ##class(DBAgrofreshEK.BestellungsKopf).%OpenId(idOpAgrofreshEK)
					set auftrag.OP = ""
					set auftrag.Verbucht = 0
					set auftrag.VerbuchungsjournalNr = 0
					set statusOpAgrofreshEK = auftrag.%Save()
					if ($$$ISERR(statusOpAgrofreshEK)) {
						w "Fehler beim Loeschen des AgrofreshEK-Auftrags: ", statusOpAgrofreshEK, !
						set res = statusOpAgrofreshEK
					}
				}
		    }
		    
			Set strSQL="SELECT Zahlung FROM DBDebiKredi.OPZahlung WHERE OP = "_id
			Set rsOpZ = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rsOpZ.Prepare(strSQL)
			Set scOpZ=rsOpZ.Execute()
			set res = $$$OK
		    IF $$$ISOK(scOpZ) {
				while (rsOpZ.Next(.scOpZ)) {
					Set idOpZ=rsOpZ.Data("Zahlung")
					set statusOpZ = ##class(DBDebiKredi.Zahlung).%DeleteId(idOpZ)
					if ($$$ISERR(statusOpZ)) {
						w "Fehler beim Loeschen der Kredi-Zahlung: ", statusOpZ, !
						set res = statusOpZ
					}
				}
		    }
		   		   		    
			set status = ##class(DBDebiKredi.OPKredi).%DeleteId(id)
			if ($$$ISERR(status)) {
				w "Fehler beim Loeschen des KrediOPs: ", status, !
				set res = status
			}
		}
    }
        
	Quit res
]]></Implementation>
</Method>

<Method name="CreateOpFromFakturierungAuftrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>RgNr:%Integer,MandantOid:%String,buchungOid:%String,barzahlungsZahlungskondOid:%String,barzahlungskontoOid:%String,verbuchungsJnr:%Integer,opBuchungstext1:%String,opBuchungstext2:%String,opBelegNr:%String,zahlungBuchungstext1:%String,zahlungBuchungstext2:%String,zahlungBelegNr:%String,verbuchungsJnrKrediZahlungen:%Integer,firstIban:%Boolean</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID FROM DBFakturierung.Auftragskopf WHERE RechnungsNr="_RgNr_
					" AND Mandant="_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		
		Set op = ##class(DBDebiKredi.OPKredi).%New()
		set garantieAuftrag = 0
		
		while (rs.Next(.sc)) {
			
			Set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(rs.Data("ID"))
	
			if (auftrag.IsGarantieAuftrag '= 1) {
				set kOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(auftrag.Adresse.Mandant, auftrag.Adresse.Adresse.%Id())
				set kreditor = ##class(DBDebiKredi.Kreditor).%OpenId(kOid)
	
				Set op.BelegNr = opBelegNr
				Set op.Buchungstext1 = opBuchungstext1
				Set op.Buchungstext2 = opBuchungstext2
				Set op.Kreditor = kreditor.Zahladresse
				Set op.EB = 0
				Set op.Erfassungsdatum = +$H //$ZDATE($HOROLOG)
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					if ((auftrag.Barkonto = $c(0)) || (auftrag.Barkonto = "")) {
						Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
					} else {
						Set op.FibuKonto = auftrag.Barkonto
					}
				} else {
					if ((auftrag.Zahlungskondition.Code >= 40) && (auftrag.Zahlungskondition.Code <= 49)) {
						Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(auftrag.Zahlungskondition.FibuKonto.%Id())
					} else {
						Set op.FibuKonto = kreditor.Zahladresse.FibuKonto
					}
				}
			
				if (firstIban = 1) {
					Set op.Bank = ##class(DBDebiKredi.SD.KBank).%OpenId(##class(DBDebiKredi.SD.KBank).GetFirstIbanOid(kreditor.Zahladresse.%Id()))
				}
				if ((op.Bank = "") || (op.Bank = $c(0))) {
					Set op.Bank = ##class(DBDebiKredi.SD.KBank).%OpenId(kreditor.Zahladresse.AktBank)
				}
			
				Set op.RefNrGrund = opBelegNr
				Set op.Mahnstufe = 0
				Set op.ManuelleErfassung = 0
				Set op.Typ = ##class(DBDebiKredi.Konst).OPTypRechnung()
				Set op.Belegdatum = auftrag.Rechnungsdatum
				Set op.Valutadatum = auftrag.Rechnungsdatum
				Set op.Vertreter = auftrag.Vertreter
				Set op.Waehrung = auftrag.Waehrung
				Set op.FWFaktor = auftrag.Kurseinheit
				Set op.FWKurs = auftrag.Kurs
				Set op.FWBetrag = ((-1)*(op.FWBetrag + auftrag.BetragFWInklMwst))
				Set op.ZKProzentsatz1 = auftrag.Zahlungskondition.ProzentSatz1
				Set op.ZKProzentsatz2 = auftrag.Zahlungskondition.ProzentSatz2
				Set op.ZKTage1 = auftrag.Zahlungskondition.TageSatz1
				Set op.ZKTage2 = auftrag.Zahlungskondition.TageSatz2
				Set op.ZKTage3 = auftrag.Zahlungskondition.TageNetto
				Set op.Zahlungskondition = ##class(DBDebiKredi.SD.KZahlungskond).%OpenId(##class(DBDebiKredi.SD.KZahlungskond).GetKondOidByCode(MandantOid, auftrag.Zahlungskondition.Code))
				Set op.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
				Set sc=op.%Save()
	
				do auftrag.OPSetObjectId(op.%Id())
			} else {
				set garantieAuftrag = 1
			}
			
			set auftrag.Verbucht = 1
			set auftrag.VerbuchungsjournalNr = verbuchungsJnr
			set auftrag.Buchungscode = ##class(DBFakturierung.Konst).ADBuchungstypGUzuRG()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),1)
			set sc=auftrag.%Save()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),1)
		}
	} else {
		w strSQL,!
		w "DBDebiKredi.OPKredi.CreateOpFromFakturierungAuftrag: "_sc,!
	}
	
	if (garantieAuftrag '= 1) {
		Set strSQL = "SELECT Mwst, MwstSatz, "_
						"SUM(BetragExklMwst) As BetragExklMwst, "_
						"SUM(MwstBetrag) As MwstBetrag "_
						"FROM (SELECT Mwst, MwstSatz, "_
						"Nettobetrag2ExklMwstEW As BetragExklMwst, Nettobetrag2MwstbetragEW As MwstBetrag "_
						"FROM DBFakturierung.Auftragspos WHERE Auftragskopf->RechnungsNr="_RgNr_
						"AND Auftragskopf->Mandant="_MandantOid_" "_
						"AND NVL(Artikelcode, 0) <> 8 AND "_
						"(NVL(Artikelcode, 0) < 10 OR NVL(Artikelcode, 0) = 21)) "_
						"GROUP BY Mwst, MwstSatz"
		w !,strSQL,!
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
				Set opMwst.BetragExklMwst = ((-1)*rs.Data("BetragExklMwst"))
				Set opMwst.Mwst = ##class(DBFibu.SD.Mwst).%OpenId(rs.Data("Mwst"))
				Set opMwst.MwstBetrag = ((-1)*rs.Data("MwstBetrag"))
				Set opMwst.MwstSatz = rs.Data("MwstSatz")
				Set opMwst.OP = op
				do opMwst.%Save() 
			}
	    } else {
			w strSQL,!
			w "DBDebiKredi.OPKredi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
    
	     set faktor = -1
   
	     if (op.BetragInklMwst < 0) {
		    set faktor = 1
		    Set op.Typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()
		    Set op.FWBetrag = ((-1)*op.FWBetrag)
			do op.%Save()
		
			Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_op.%Id()
			Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rs.Prepare(strSQL)
			Set sc=rs.Execute()
	
			IF $$$ISOK(sc) {
		
				while (rs.Next(.sc)) {
					Set opMwst = ##class(DBDebiKredi.OPMwst).%OpenId(rs.Data("ID"))
					Set opMwst.BetragExklMwst = ((-1)*opMwst.BetragExklMwst)
					Set opMwst.MwstBetrag = ((-1)*opMwst.MwstBetrag)
					do opMwst.%Save() 
				}
			}	
	    }
    
	    Set strSQL = "SELECT ID FROM DBFakturierung.Auftragskopf WHERE RechnungsNr="_RgNr_
						" AND Mandant="_MandantOid
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
		
			Set zahlung = ##class(DBDebiKredi.Zahlung).%New()
			Set opZahlung = ##class(DBDebiKredi.OPZahlung).%New()
					
			while (rs.Next(.sc)) {
			
				Set auftrag = ##class(DBFakturierung.Auftragskopf).%OpenId(rs.Data("ID"))
	
				// Bei Barzahlung - Zahlung anlegen
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					if ((auftrag.Barkonto = $c(0)) || (auftrag.Barkonto = "")) {
						Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
					} else {
						Set zahlung.FibuKonto = auftrag.Barkonto
					}
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor < 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrKrediZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
			
					// Bei Check - Zahlung anlegen
				} elseif ((auftrag.Zahlungskondition.Code >= 40) && (auftrag.Zahlungskondition.Code <= 49)) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(auftrag.Zahlungskondition.FibuKonto.%Id())
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor < 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrKrediZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
				}
			}
		} else {
			w strSQL,!
			w "DBDebiKredi.OPKredi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
	
		Quit op.%Id()
	} else {
		Quit ""
	}
]]></Implementation>
</Method>

<Method name="HasKrediOffeneFwOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>KrediOid:%String,EwWaehrungOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myOid = ""
	&sql(SELECT TOP 1 ID INTO :myOid FROM DBDebiKredi.OPKredi WHERE Kreditor=:KrediOid AND IsOPgeschlossen<>1 AND Waehrung<>:EwWaehrungOid)
	
	if (SQLCODE '= 0) {
		set myOid = ""
	}
	Quit (myOid'="")
]]></Implementation>
</Method>

<Method name="HasKrediAlleFwOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>KrediOid:%String,EwWaehrungOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myOid = ""
	&sql(SELECT TOP 1 ID INTO :myOid FROM DBDebiKredi.OPKredi WHERE Kreditor=:KrediOid AND Waehrung<>:EwWaehrungOid)
	
	if (SQLCODE '= 0) {
		set myOid = ""
	}
	Quit (myOid'="")
]]></Implementation>
</Method>

<Method name="GetBankByFibubuchung">
<ClassMethod>1</ClassMethod>
<FormalSpec>BuchungOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myOid = ""
	
	&sql(SELECT TOP 1 Bank INTO :myOid FROM DBDebiKredi.OPKredi WHERE Fibubuchung=:BuchungOid)
	
	if (SQLCODE '= 0) {
		set myOid = ""
	}
	Quit myOid
]]></Implementation>
</Method>

<Method name="CreateOpFromFaktEKBestellung">
<ClassMethod>1</ClassMethod>
<FormalSpec>ArNr:%Integer,MandantOid:%String,buchungOid:%String,barzahlungsZahlungskondOid:%String,barzahlungskontoOid:%String,verbuchungsJnr:%Integer,opBuchungstext1:%String,opBuchungstext2:%String,opBelegNr:%String,zahlungBuchungstext1:%String,zahlungBuchungstext2:%String,zahlungBelegNr:%String,verbuchungsJnrKrediZahlungen:%Integer,firstIban:%Boolean</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID FROM DBFaktEK.Bestellungskopf WHERE AbrechnungsNr="_ArNr_
					" AND Mandant="_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF $$$ISOK(sc) {
		
		Set op = ##class(DBDebiKredi.OPKredi).%New()
		
		while (rs.Next(.sc)) {
			
			Set auftrag = ##class(DBFaktEK.Bestellungskopf).%OpenId(rs.Data("ID"))
		
				Set op.BelegNr = opBelegNr
				Set op.Buchungstext1 = opBuchungstext1
				Set op.Buchungstext2 = opBuchungstext2
				Set op.Kreditor = auftrag.ZahlAdresse
				Set op.EB = 0
				Set op.Erfassungsdatum = +$H //$ZDATE($HOROLOG)
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
				} else {
					if ((auftrag.Zahlungskondition.Code >= 40) && (auftrag.Zahlungskondition.Code <= 49)) {
						Set op.FibuKonto = ##class(DBFibu.Konto).%OpenId(auftrag.Zahlungskondition.FibuKonto.%Id())
					} else {
						Set op.FibuKonto = kreditor.Zahladresse.FibuKonto
					}
				}
			
				if (firstIban = 1) {
					Set op.Bank = ##class(DBDebiKredi.SD.KBank).%OpenId(##class(DBDebiKredi.SD.KBank).GetFirstIbanOid(kreditor.Zahladresse.%Id()))
				}
				if ((op.Bank = "") || (op.Bank = $c(0))) {
					Set op.Bank = ##class(DBDebiKredi.SD.KBank).%OpenId(kreditor.Zahladresse.AktBank)
				}
			
				Set op.RefNrGrund = opBelegNr
				Set op.Mahnstufe = 0
				Set op.ManuelleErfassung = 0
				Set op.Typ = ##class(DBDebiKredi.Konst).OPTypRechnung()
				Set op.Belegdatum = auftrag.Rechnungsdatum
				Set op.Valutadatum = auftrag.Rechnungsdatum
				Set op.Vertreter = auftrag.Vertreter
				Set op.Waehrung = auftrag.Waehrung
				Set op.FWFaktor = auftrag.Kurseinheit
				Set op.FWKurs = auftrag.Kurs
				Set op.FWBetrag = ((-1)*(op.FWBetrag + auftrag.BetragFWInklMwst))
				Set op.ZKProzentsatz1 = auftrag.Zahlungskondition.ProzentSatz1
				Set op.ZKProzentsatz2 = auftrag.Zahlungskondition.ProzentSatz2
				Set op.ZKTage1 = auftrag.Zahlungskondition.TageSatz1
				Set op.ZKTage2 = auftrag.Zahlungskondition.TageSatz2
				Set op.ZKTage3 = auftrag.Zahlungskondition.TageNetto
				Set op.Zahlungskondition = ##class(DBDebiKredi.SD.KZahlungskond).%OpenId(##class(DBDebiKredi.SD.KZahlungskond).GetKondOidByCode(MandantOid, auftrag.Zahlungskondition.Code))
				Set op.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
				Set sc=op.%Save()
	
				do auftrag.OPSetObjectId(op.%Id())
			
			set auftrag.Verbucht = 1
			set auftrag.VerbuchungsjournalNr = verbuchungsJnr
			set auftrag.Buchungscode = ##class(DBFakturierung.Konst).ADBuchungstypGUzuRG()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),1)
			set sc=auftrag.%Save()
			do ##class(DBFakturierung.Auftragskopf).SetFlagAutoMutiert(auftrag.%Id(),1)
		}
	} else {
		w strSQL,!
		w "DBDebiKredi.OPKredi.CreateOpFromFaktEKBestellung: "_sc,!
	}
	
		Set strSQL = "SELECT Mwst, MwstSatz, "_
						"SUM(BetragExklMwst) As BetragExklMwst, "_
						"SUM(MwstBetrag) As MwstBetrag "_
						"FROM (SELECT Mwst, MwstSatz, "_
						"Nettobetrag2ExklMwstEW As BetragExklMwst, Nettobetrag2MwstbetragEW As MwstBetrag "_
						"FROM DBFakturierung.Auftragspos WHERE Auftragskopf->RechnungsNr="_RgNr_
						"AND Auftragskopf->Mandant="_MandantOid_" "_
						"AND NVL(Artikelcode, 0) <> 8 AND "_
						"(NVL(Artikelcode, 0) < 10 OR NVL(Artikelcode, 0) = 21)) "_
						"GROUP BY Mwst, MwstSatz"
		w !,strSQL,!
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
			while (rs.Next(.sc)) {
				Set opMwst = ##class(DBDebiKredi.OPMwst).%New()
				Set opMwst.BetragExklMwst = ((-1)*rs.Data("BetragExklMwst"))
				Set opMwst.Mwst = ##class(DBFibu.SD.Mwst).%OpenId(rs.Data("Mwst"))
				Set opMwst.MwstBetrag = ((-1)*rs.Data("MwstBetrag"))
				Set opMwst.MwstSatz = rs.Data("MwstSatz")
				Set opMwst.OP = op
				do opMwst.%Save() 
			}
	    } else {
			w strSQL,!
			w "DBDebiKredi.OPKredi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
    
	     set faktor = -1
   
	     if (op.BetragInklMwst < 0) {
		    set faktor = 1
		    Set op.Typ = ##class(DBDebiKredi.Konst).OPTypGutschrift()
		    Set op.FWBetrag = ((-1)*op.FWBetrag)
			do op.%Save()
		
			Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_op.%Id()
			Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
			Do rs.Prepare(strSQL)
			Set sc=rs.Execute()
	
			IF $$$ISOK(sc) {
		
				while (rs.Next(.sc)) {
					Set opMwst = ##class(DBDebiKredi.OPMwst).%OpenId(rs.Data("ID"))
					Set opMwst.BetragExklMwst = ((-1)*opMwst.BetragExklMwst)
					Set opMwst.MwstBetrag = ((-1)*opMwst.MwstBetrag)
					do opMwst.%Save() 
				}
			}	
	    }
    
	    Set strSQL = "SELECT ID FROM DBFakturierung.Auftragskopf WHERE RechnungsNr="_RgNr_
						" AND Mandant="_MandantOid
		Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
		Do rs.Prepare(strSQL)
		Set sc=rs.Execute()
	
		IF $$$ISOK(sc) {
		
			Set zahlung = ##class(DBDebiKredi.Zahlung).%New()
			Set opZahlung = ##class(DBDebiKredi.OPZahlung).%New()
					
			while (rs.Next(.sc)) {
			
				Set auftrag = ##class(DBFaktEK.Bestellungskopf).%OpenId(rs.Data("ID"))
	
				// Bei Barzahlung - Zahlung anlegen
				if (auftrag.Zahlungskondition.%Id() = barzahlungsZahlungskondOid) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(barzahlungskontoOid)
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor < 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrKrediZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
			
					// Bei Check - Zahlung anlegen
				} elseif ((auftrag.Zahlungskondition.Code >= 40) && (auftrag.Zahlungskondition.Code <= 49)) {
					Set zahlung.BelegNr = zahlungBelegNr
					Set zahlung.Buchungstext1 = zahlungBuchungstext1
					Set zahlung.Buchungstext2 = zahlungBuchungstext2
					Set zahlung.Erfassungsdatum = +$H
					Set zahlung.FibuKonto = ##class(DBFibu.Konto).%OpenId(auftrag.Zahlungskondition.FibuKonto.%Id())
					Set zahlung.FWFaktor = auftrag.Kurseinheit
					Set zahlung.FWKurs = auftrag.Kurs
					Set zahlung.ManuelleErfassung = 0
					if (faktor < 0) {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypZahlung()
					} else {
						Set zahlung.Typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()
					}
					Set zahlung.Belegdatum = auftrag.Rechnungsdatum
					Set zahlung.Valutadatum = auftrag.Rechnungsdatum
					Set zahlung.Verbuchungsjnr = verbuchungsJnrKrediZahlungen
					Set zahlung.Waehrung = auftrag.Waehrung
					Set zahlung.FibuBuchung = ##class(DBFibu.Buchung).%OpenId(buchungOid)
					Set sc = zahlung.%Save()
		
					Set opZahlung.OP = op
					Set opZahlung.Zahlung = zahlung
					Set opZahlung.Zahlbetrag = opZahlung.Zahlbetrag + (faktor * auftrag.TotalMitGebinde)
					Set opZahlung.SkontoAbzug = opZahlung.SkontoAbzug + (faktor * auftrag.Skonto)
					Set opZahlung.FWSkontoAbzug = opZahlung.FWSkontoAbzug + (faktor * auftrag.SkontoFW)
					Set opZahlung.FWZahlbetrag = opZahlung.FWZahlbetrag + (faktor * auftrag.BetragFWInklMwst)
					Set sc = opZahlung.%Save()
				}
			}
		} else {
			w strSQL,!
			w "DBDebiKredi.OPKredi.CreateOpFromFakturierungAuftrag: "_sc,!
		}
	
		Quit op.%Id()
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DefaultData>OPKrediDefaultData</DefaultData>
<Data name="OPKrediDefaultData">
<Structure>listnode</Structure>
<Subscript>"OPKredi"</Subscript>
<Value name="1">
<Value>Zahlungskondition</Value>
</Value>
<Value name="2">
<Value>Kreditor</Value>
</Value>
<Value name="3">
<Value>Bank</Value>
</Value>
<Value name="4">
<Value>RefNrGrund</Value>
</Value>
<Value name="5">
<Value>Zahlungsvorschlag</Value>
</Value>
</Data>
</Storage>
</Class>


<Class name="DBDebiKredi.OPMwst">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61384,38820.06244</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Mwst">
<Description>
Mwst-Code</Description>
<Type>DBFibu.SD.Mwst</Type>
<Cardinality>one</Cardinality>
<Inverse>OPMwst</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Mwst"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="MwstIndex">
<Properties>Mwst</Properties>
</Index>

<Property name="MwstSatz">
<Description>
Mwst-Satz</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MwstBetrag">
<Description>
Mwst-Betrag</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BetragExklMwst">
<Description>
Betrag exkl. Mwst</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BetragInklMwst">
<Description>
Betrag inkl. Mwst</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {BetragInklMwst}=##class(DBDebiKredi.OPMwst).BetragInklMwstClass({BetragExklMwst},{MwstBetrag}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="OP">
<Description>
OP</Description>
<Type>DBDebiKredi.OP</Type>
<Cardinality>parent</Cardinality>
<Inverse>OPMwst</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="OP"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="OPIndex">
<Properties>OP</Properties>
</Index>

<Method name="GetOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,mwstOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set strSQL = "SELECT ID FROM DBDebiKredi.OPMwst WHERE OP="_opOid_" AND Mwst="_mwstOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	Set res = ""
	
	IF $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set res = rs.Data("ID")
		}
	}
	
	Quit res
]]></Implementation>
</Method>

<Method name="BetragInklMwstClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>betragExkl:%Decimal(SCALE=5),mwstBetrag:%Decimal(SCALE=5)</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[	Quit (betragExkl + mwstBetrag)
]]></Implementation>
</Method>

<Method name="%OnBeforeSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	If ('Insert) {
		set opMwstId = ..%Id()
		set oldBetrag = 0
		set oldValuta = 0
		set oldTyp = 0
		&sql(SELECT BetragInklMwst, OP->Valutadatum, OP->Typ INTO :oldBetrag, :oldValuta, :oldTyp FROM DBDebiKredi.OPMwst WHERE ID=:opMwstId)
		if (SQLCODE'=0) {
			set oldBetrag = 0
			set oldValuta = 0
			set oldTyp = 0
		}
		
		Set ^OpMwstOldBetragInklMwst(opMwstId) = oldBetrag
		Set ^OpMwstOldValuta(opMwstId) = oldValuta
		Set ^OpMwstOldTyp(opMwstId) = oldTyp
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnAfterSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set opMwstId = ..%Id()
	set opId = ..OP.%Id()
	set eb = ..OP.EB
	set waehrung = ..OP.Waehrung.%Id()
	
	//do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(..%Id(),1)
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	//do ##class(DBDebiKredi.OP).SetDebiKrediOpStopTrg(..%Id(),0)
	
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		If ('Insert) {
			set oldBetrag = ^OpMwstOldBetragInklMwst(opMwstId)
			set oldValuta = ^OpMwstOldValuta(opMwstId)
			set oldTyp = ^OpMwstOldTyp(opMwstId)
			set storno = 1
			if (oldTyp = 5) {
				set storno = 0
			}
			
			if (eb) {
				do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
			} else {
				do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
			}
			
		}
		
			
		set newBetrag = ..BetragInklMwst
		set newValuta = ..OP.Valutadatum
		set newTyp = ..OP.Typ
		set storno = 0
		if (newTyp = 5) {
			set storno = 1
		}
		
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(newBetrag, 0, newValuta, debiId, waehrung, storno)
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		If ('Insert) {
			set oldBetrag = ^OpMwstOldBetragInklMwst(opMwstId)
			set oldValuta = ^OpMwstOldValuta(opMwstId)
			set oldTyp = ^OpMwstOldTyp(opMwstId)
			set storno = 1
			if (oldTyp = 5) {
				set storno = 0
			}
			
			if (eb) {
				do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
			} else {
				do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
			}
			
		}
		
		set newBetrag = ..BetragInklMwst
		set newValuta = ..OP.Valutadatum
		set newTyp = ..OP.Typ
		set storno = 0
		if (newTyp = 5) {
			set storno = 1
		}
		
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(newBetrag, 0, newValuta, debiId, waehrung, storno)
		}
	}
	
	KILL ^OpMwstOldBetragInklMwst(opMwstId)
	KILL ^OpMwstOldValuta(opMwstId)
	KILL ^OpMwstOldTyp(opMwstId)
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description>
[Previously private]</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	set opMwstId = $lg(oid,1)
	set opId = ""
	set oldBetrag = 0
	set oldValuta = 0
	set eb = 0
	set waehrung = 0
	set typ = 0
	
	&sql(SELECT OP->ID, 
				BetragInklMwst,
				OP->EB,
				OP->Valutadatum,
				OP->Waehrung,
				OP->Typ
			INTO 
				:opId, 
				:oldBetrag,
				:eb,
				:oldValuta,
				:waehrung,
				:typ
			FROM DBDebiKredi.OPMwst WHERE ID=:opMwstId)	
	
	set storno = 1
	if (typ = 5) {
		set storno = 0
	}
	
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		if (eb) {
			if (opDebi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				set opDebi.FibuKonto.FibuEB = (opDebi.FibuKonto.FibuEB - oldBetrag)
				set sc = opDebi.%Save()
		
				do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)		
			}
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}
	
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		if (eb) {
			if (opKredi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				set opKredi.FibuKonto.FibuEB = (opKredi.FibuKonto.FibuEB - oldBetrag)
				set sc = opKredi.%Save()
		
				do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)		
			}
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}
	
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Trigger name="InsertBetrag">
<Code><![CDATA[	new eb
	new waehrung
	new newBetrag
	new valuta
	new debiId
	new opId
	new opDebi
	new opKredi
	new typ
	new storno
	
	set opId = {OP*O}
	//set newBetrag = {BetragInklMwst*N}
	set newBetrag = ({BetragExklMwst*N} + {MwstBetrag*N})
	
	&sql(SELECT EB, Valutadatum, Waehrung, Typ INTO :eb, :valuta, :waehrung, :typ FROM DBDebiKredi.OP WHERE ID=:opId)	
	
	set storno = 0
	if (typ = 5) {
		set storno = 1
	}
	
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(newBetrag, 0, valuta, debiId, waehrung, storno)
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(newBetrag, 0, valuta, debiId, waehrung, storno)
		}
	}]]></Code>
<Event>INSERT</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="UpdateBetrag">
<Code><![CDATA[	new eb
	new waehrung
	new opId
	new debiId
	new oldBetrag
	new oldValuta
	new newBetrag
	new newValuta
	new opDebi
	new opKredi
	new oldTyp
	new newTyp
	new storno
	
	set opId = {OP*O}
	set oldBetrag = {BetragInklMwst*O}
	
	&sql(SELECT EB, Valutadatum, Waehrung, Typ INTO :eb, :oldValuta, :waehrung, :oldTyp FROM DBDebiKredi.OP WHERE ID=:opId)	
	
	set storno = 1
	if (oldTyp = 5) {
		set storno = 0
	}
	
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}
	}
	
	set opId = {OP*N}
	set newBetrag = {BetragInklMwst*N}
	
	&sql(SELECT EB, Valutadatum, Waehrung, Typ INTO :eb, :newValuta, :waehrung, :newTyp FROM DBDebiKredi.OP WHERE ID=:opId)	
	
	set storno = 0
	if (newTyp = 5) {
		set storno = 1
	}
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(newBetrag, 0, newValuta, debiId, waehrung, storno)
		}
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(newBetrag, 0, debiId, waehrung, storno)
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(newBetrag, 0, newValuta, debiId, waehrung, storno)
		}
	}]]></Code>
<Event>UPDATE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="DeleteBetrag">
<Code><![CDATA[	new eb
	new waehrung
	new opId
	new debiId
	new oldBetrag
	new oldValuta
	new opDebi
	new opKredi
	new typ
	new storno
	
	set opId = {OP*O}
	set oldBetrag = {BetragInklMwst*O}
	
	&sql(SELECT EB, Valutadatum, Waehrung, Typ INTO :eb, :oldValuta, :waehrung, :typ FROM DBDebiKredi.OP WHERE ID=:opId)	
	
	set storno = 1
	if (typ = 5) {
		set storno = 0
	}
	
	set op = ##class(DBDebiKredi.OP).%OpenId(opId)
	set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
	do op.%Save()
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		if (eb) {
			if (opDebi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				set opDebi.FibuKonto.FibuEB = (opDebi.FibuKonto.FibuEB - oldBetrag)
				set sc = opDebi.%Save()
		
				do ##class(DBDebiKredi.OPDebi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
			}
		} else {
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzSoll(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}	
			
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		if (eb) {
			if (opKredi.FibuKonto.EBGesperrt) {
				Quit $$$ERROR($$$GeneralError,"EB auf Konto gesperrt")
			} else {
				set opKredi.FibuKonto.FibuEB = (opKredi.FibuKonto.FibuEB - oldBetrag)
				set sc = opKredi.%Save()
		
				do ##class(DBDebiKredi.OPKredi).AddBetragToSaldovortrag(oldBetrag, 0, debiId, waehrung, storno)
			}
		} else {
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzHaben(oldBetrag, 0, oldValuta, debiId, waehrung, storno)
		}		
	}]]></Code>
<Event>DELETE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.OPMwstD</DataLocation>
<DefaultData>OPMwstDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.OPMwstD</IdLocation>
<IndexLocation>^DBDebiKredi.OPMwstI</IndexLocation>
<StreamLocation>^DBDebiKredi.OPMwstS</StreamLocation>
<Data name="OPMwstDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Mwst</Value>
</Value>
<Value name="3">
<Value>MwstSatz</Value>
</Value>
<Value name="4">
<Value>MwstBetrag</Value>
</Value>
<Value name="5">
<Value>BetragExklMwst</Value>
</Value>
<Value name="6">
<Value>BetragInklMwst</Value>
</Value>
<Value name="7">
<Value>OP</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="BetragExklMwst">
</Property>
<Property name="BetragInklMwst">
</Property>
<Property name="Mwst">
</Property>
<Property name="MwstBetrag">
</Property>
<Property name="MwstSatz">
</Property>
<Property name="OP">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.OPZahlung">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61485,57888.224629</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="OP">
<Description>
OPZahlung</Description>
<Type>DBDebiKredi.OP</Type>
<Cardinality>one</Cardinality>
<Inverse>OPZahlung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="OP"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="OPIndex">
<Properties>OP</Properties>
</Index>

<Property name="Zahlung">
<Description>
Zahlung</Description>
<Type>DBDebiKredi.Zahlung</Type>
<Cardinality>one</Cardinality>
<Inverse>OPZahlung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Zahlung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ZahlungIndex">
<Properties>Zahlung</Properties>
</Index>

<Property name="Zahlbetrag">
<Description>
Zahlbetrag</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="SkontoAbzug">
<Description>
Skonto-Abzug</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWZahlbetrag">
<Description>
FWZahlbetrag</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWSkontoAbzug">
<Description>
Skonto-Abzug</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Kursdifferenz">
<Description>
Kursdifferenz</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Method name="%OnBeforeSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	If ('Insert) {
		set opZahlungId = ..%Id()
		set oldBetrag = 0
		set oldSkonto = 0
		set oldBetragFw = 0
		set oldSkontoFw = 0
		set oldTyp = 0
		&sql(SELECT Zahlbetrag, SkontoAbzug, FWZahlbetrag, FWSkontoAbzug, Zahlung->Typ INTO :oldBetrag, :oldSkonto, :oldBetragFw, :oldSkontoFw, :oldTyp FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)
		Set ^OpZahlungOldZahlbetrag(opZahlungId) = (oldBetrag+oldSkonto)
		Set ^OpZahlungOldZahlbetragFw(opZahlungId) = (oldBetragFw+oldSkontoFw)
		Set ^OpZahlungOldTyp(opZahlungId) = oldTyp
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnAfterSave">
<FormalSpec>Insert:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set opZahlungId = ..%Id()
	set opId = ..OP.%Id()
	set valuta = ..Zahlung.Valutadatum
	set waehrung = ..Zahlung.Waehrung.%Id()
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		set opDebi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opDebi.%Save()
		
		If ('Insert) {
			set oldBetrag = ^OpZahlungOldZahlbetrag(opZahlungId)
			set oldBetragFw = ^OpZahlungOldZahlbetragFw(opZahlungId)
			set oldTyp = ^OpZahlungOldTyp(opZahlungId)
			set storno = 1
			if ((oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
				set storno = 0
			}
			do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(oldBetrag, oldBetragFw, valuta, debiId, waehrung, storno)			
		}
		
		set newBetrag = (..Zahlbetrag+..SkontoAbzug)
		set newBetragFw = (..FWZahlbetrag+..FWSkontoAbzug)
		set newTyp = ..Zahlung.Typ
		set storno = 0
		if ((newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
			set storno = 1
		}
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(newBetrag, newBetragFw, valuta, debiId, waehrung, storno)
	
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		set opKredi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opKredi.%Save()
		
		If ('Insert) {
			set oldBetrag = ^OpZahlungOldZahlbetrag(opZahlungId)
			set oldBetragFw = ^OpZahlungOldZahlbetragFw(opZahlungId)
			set oldTyp = ^OpZahlungOldTyp(opZahlungId)
			set storno = 1
			if ((oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
				set storno = 0
			}
			do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(oldBetrag, oldBetragFw, valuta, debiId, waehrung, storno)			
		}
		
		set newBetrag = (..Zahlbetrag+..SkontoAbzug)
		set newBetragFw = (..FWZahlbetrag+..FWSkontoAbzug)
		set newTyp = ..Zahlung.Typ
		set storno = 0
		if ((newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
			set storno = 1
		}
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(newBetrag, newBetragFw, valuta, debiId, waehrung, storno)
	}
	
	KILL ^OpZahlungOldZahlbetrag(opZahlungId)
	KILL ^OpZahlungOldZahlbetragFw(opZahlungId)
	KILL ^OpZahlungOldTyp(opZahlungId)
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description>
[Previously private]</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	set opZahlungId = $lg(oid,1)
	set opId = ""
	set oldBetrag = 0
	set oldSkonto = 0
	set oldBetragFw = 0
	set oldSkontoFw = 0
	set oldValuta = 0
	set oldWaehrung = 0
	set typ = 0
	
	&sql(SELECT OP->ID, 
				Zahlbetrag,
				SkontoAbzug,
				FWZahlbetrag,
				FWSkontoAbzug,
				Zahlung->Valutadatum,
				Zahlung->Waehrung,
				Zahlung->Typ
			INTO 
				:opId, 
				:oldBetrag,
				:oldSkonto,
				:oldBetragFw,
				:oldSkontoFw,
				:oldValuta,
				:oldWaehrung,
				:typ
			FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)	
	
	set storno = 1
	if ((typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
		set storno = 0
	}
	
	Set ^OpZahlungOPbeforeDelete(opZahlungId) = opId
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		set opDebi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opDebi.%Save()
		
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben((oldBetrag+oldSkonto), (oldBetragFw+oldSkontoFw), oldValuta, debiId, oldWaehrung, storno)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		set opKredi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opKredi.%Save()
		
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll((oldBetrag+oldSkonto), (oldBetragFw+oldSkontoFw), oldValuta, debiId, oldWaehrung, storno)
		
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Trigger name="InsertBetrag">
<Code><![CDATA[	new newBetrag
	new newBetragFw
	new valuta
	new debiId
	new opId
	new opZahlungId
	new waehrung
	new opDebi
	new opKredi
	new typ
	new storno
	
	set opZahlungId = {ID*O}
	set opId = {OP*O}
	set newBetrag = ({Zahlbetrag*N}+{SkontoAbzug*N})
	set newBetragFw = ({FWZahlbetrag*N}+{FWSkontoAbzug*N})
	
	&sql(SELECT Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ INTO :valuta, :waehrung, :typ FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)	
	
	set storno = 0
	if ((typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
		set storno = 1
	}
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		set opDebi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opDebi.%Save()
		
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(newBetrag, newBetragFw, valuta, debiId, waehrung, storno)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		set opKredi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opKredi.%Save()
		
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(newBetrag, newBetragFw, valuta, debiId, waehrung, storno)
	}]]></Code>
<Event>INSERT</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="UpdateBetrag">
<Code><![CDATA[	new opId
	new opZahlungId
	new debiId
	new oldBetrag
	new oldBetragFw
	new oldValuta
	new oldWaehrung
	new newBetrag
	new newBetragFw
	new newValuta
	new newWaehrung
	new opDebi
	new opKredi
	new oldTyp
	new newTyp
	new storno
	
	set opZahlungId = {ID*O}
	set opId = {OP*O}
	set oldBetrag = ({Zahlbetrag*O}+{SkontoAbzug*O})
	set oldBetragFw = ({FWZahlbetrag*O}+{FWSkontoAbzug*O})
	
	&sql(SELECT Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ INTO :oldValuta, :oldWaehrung, :oldTyp FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)	
	
	set storno = 1
	if ((oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (oldTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
		set storno = 0
	}
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(oldBetrag, oldBetragFw, oldValuta, debiId, oldWaehrung, storno)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(oldBetrag, oldBetragFw, oldValuta, debiId, oldWaehrung, storno)
		
	}
	
	set opZahlungId = {ID*N}
	set opId = {OP*N}
	set newBetrag = ({Zahlbetrag*N}+{SkontoAbzug*N})
	set newBetragFw = ({FWZahlbetrag*N}+{FWSkontoAbzug*N})
	
	&sql(SELECT Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ INTO :newValuta, :newWaehrung, :newTyp FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)	
	
	set storno = 0
	if ((newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (newTyp = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
		set storno = 1
	}
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
		
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		set opDebi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opDebi.%Save()
		
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(newBetrag, newBetragFw, newValuta, debiId, newWaehrung, storno)
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
		
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		set opKredi.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do opKredi.%Save()
		
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(newBetrag, newBetragFw, newValuta, debiId, newWaehrung, storno)
	}]]></Code>
<Event>UPDATE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Trigger name="DeleteBetrag">
<Code><![CDATA[	new opZahlungId
	new opId
	new debiId
	new oldBetrag
	new oldBetragFw
	new oldValuta
	new oldWaehrung
	new opDebi
	new opKredi
	new typ
	new storno
	
	set opId = {OP*O}
	set opZahlungId = {ID*O}
	set oldBetrag = ({Zahlbetrag*O}+{SkontoAbzug*O})
	set oldBetragFw = ({FWZahlbetrag*O}+{FWSkontoAbzug*O})

	set oldValuta=""
	set oldWaehrung=""

	&sql(SELECT Zahlung->Valutadatum, Zahlung->Waehrung, Zahlung->Typ INTO :oldValuta, :oldWaehrung, :typ FROM DBDebiKredi.OPZahlung WHERE ID=:opZahlungId)	

	set storno = 1
	if ((typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungGU()) || (typ = ##class(DBDebiKredi.Konst).ZahlungTypVerrechnungVZ())) {
		set storno = 0
	}
	
	if (##class(DBDebiKredi.OPDebi).%ExistsId(opId)) {
	
		set opDebi = ##class(DBDebiKredi.OPDebi).%OpenId(opId)
		set debiId = opDebi.Debitor.%Id()
		
		do ##class(DBDebiKredi.OPDebi).AddBetragToUmsatzHaben(oldBetrag, oldBetragFw, oldValuta, debiId, oldWaehrung, storno)		
		
	} elseif (##class(DBDebiKredi.OPKredi).%ExistsId(opId)) {
	
		set opKredi = ##class(DBDebiKredi.OPKredi).%OpenId(opId)
		set debiId = opKredi.Kreditor.%Id()
		
		do ##class(DBDebiKredi.OPKredi).AddBetragToUmsatzSoll(oldBetrag, oldBetragFw, oldValuta, debiId, oldWaehrung, storno)		
		
	}]]></Code>
<Event>DELETE</Event>
<Foreach>row</Foreach>
</Trigger>

<Method name="GetOpZahlungOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,zahlungOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set oid = ""
	&sql(SELECT ID INTO :oid FROM DBDebiKredi.OpZahlung WHERE OP=:opOid AND Zahlung=:zahlungOid)
	Quit oid
]]></Implementation>
</Method>

<Method name="%OnAfterDelete">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%Delete</METHOD> method to 
provide notification that the object specified by <VAR>oid</VAR> has been deleted.
The callback occurs immediately after %DeleteData has been called. If %DeleteData returns
an error then %OnAfterDelete is not called.

<P>If %OnAfterDelete returns an error (%Status) then the transaction is rolled back.
[Previously private]]]></Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	
	set opZahlungId = $lg(oid,1)
	
	set opId = ^OpZahlungOPbeforeDelete(opZahlungId)
	
	if (##class(DBDebiKredi.OP).%ExistsId(opId)) {
		set op = ##class(DBDebiKredi.OP).%OpenId(opId)
		set op.IsOPgeschlossen = ##class(DBDebiKredi.OP).IsOPgeschlossenClass(opId)
		do op.%Save()
	}
	
	KILL ^OpZahlungOPbeforeDelete(opZahlungId)
	
	Quit $$$OK
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.OPZahlungD</DataLocation>
<DefaultData>OPZahlungDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.OPZahlungD</IdLocation>
<IndexLocation>^DBDebiKredi.OPZahlungI</IndexLocation>
<StreamLocation>^DBDebiKredi.OPZahlungS</StreamLocation>
<Data name="OPZahlungDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>OP</Value>
</Value>
<Value name="3">
<Value>Zahlung</Value>
</Value>
<Value name="4">
<Value>Zahlbetrag</Value>
</Value>
<Value name="5">
<Value>SkontoAbzug</Value>
</Value>
<Value name="6">
<Value>FWZahlbetrag</Value>
</Value>
<Value name="7">
<Value>FWSkontoAbzug</Value>
</Value>
<Value name="8">
<Value>Kursdifferenz</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="FWSkontoAbzug">
</Property>
<Property name="FWZahlbetrag">
</Property>
<Property name="Kursdifferenz">
</Property>
<Property name="OP">
</Property>
<Property name="SkontoAbzug">
</Property>
<Property name="Zahlbetrag">
</Property>
<Property name="Zahlung">
</Property>
</Storage>
</Class>


<Project name="DBDebiKredi">
  <Items>
    <ProjectItem name="DBDebiKredi.AF" type="PKG"></ProjectItem>
    <ProjectItem name="DBDebiKredi.Debitor" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.DebitorUmsatz" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.Konst" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.Kreditor" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.KreditorUmsatz" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OP" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OPDebi" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OPDebiZusatz" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OPKredi" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OPMwst" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.OPZahlung" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.DZahlungskond" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.KBank" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.KBankBuch" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.KZahlungskond" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.Mahneinst" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.SD.Mahntyp" type="CLS"></ProjectItem>
    <ProjectItem name="DBDebiKredi.Zahlung" type="CLS"></ProjectItem>
  </Items>
</Project>


<Class name="DBDebiKredi.SD.DZahlungskond">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61319,40094.702404</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Code">
<Type>%Integer</Type>
<Required>1</Required>
</Property>

<Index name="CodeIndex">
<Properties>Mandant,Code</Properties>
<Unique>1</Unique>
</Index>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
</Index>

<Property name="TageSatz1">
<Type>%Integer</Type>
</Property>

<Property name="ProzentSatz1">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="TageSatz2">
<Type>%Integer</Type>
</Property>

<Property name="ProzentSatz2">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="TageNetto">
<Type>%Integer</Type>
</Property>

<Property name="Bezeichnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="FibuKonto">
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>DebiZahlungskondFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Property name="DebitorZahlungskondition">
<Type>DBDebiKredi.Debitor</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="AKZahlungskondition">
<Type>DBAgrofresh.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Method name="GetKondOidByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Code:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set oid = ""
	QUIT:(MandantOid="")||(Code<0)
	&sql(SELECT ID INTO :oid
		 FROM DBDebiKredi_SD.DZahlungskond
		 WHERE Mandant = :MandantOid AND Code = :Code)
	Quit oid
]]></Implementation>
</Method>

<Method name="GetKondCodeByOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Oid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set code = 0
	QUIT:(MandantOid="")||(Oid="")
	&sql(SELECT Code INTO :code
		 FROM DBDebiKredi_SD.DZahlungskond
		 WHERE Mandant = :MandantOid AND ID = :Oid)
	Quit +code
]]></Implementation>
</Method>

<Method name="DeleteAll">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	&sql(DELETE FROM DBDebiKredi_SD.DZahlungskond
		 WHERE Mandant =:MandantOid)
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="GetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Bezeichnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBezeichnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.DZahlungskond).%OpenId(myID)
		set text = rs.GetBezeichnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="SetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Bezeichnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="CopyKondFromMandant">
<ClassMethod>1</ClassMethod>
<FormalSpec>OldMandOid:%String,NewMandOid:%String</FormalSpec>
<Implementation><![CDATA[
	Quit:(OldMandOid="")||(NewMandOid="")
	&sql(SELECT Count(*) InTo :Cnt From DBCore.Mandant WHERE ID=:NewMandOid)
	If (Cnt) {
		Set strSQL="SELECT ID FROM DBDebiKredi_SD.DZahlungskond WHERE Mandant = "_OldMandOid
		Set s=##class(%ResultSet).%New("%DynamicQuery:SQL")
		Do s.Prepare(strSQL)
		Do s.Execute()
		While s.Next(.osc) {
			If $$$ISERR(osc) Quit
			Set n=..%New()
			Set o=..%OpenId(s.ID)
			Set n=o.%ConstructClone(0)
			Set n.Mandant= NewMandOid
			Do n.%Save()
		}
	}
]]></Implementation>
</Method>

<Method name="ListeGesamt">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<ReturnType>%Library.ResultSet</ReturnType>
<Implementation><![CDATA[

	Set strSQL = "SELECT %ID,Code, TageSatz1, ProzentSatz1, TageSatz2, ProzentSatz2,TageNetto," +
				 "DBDebiKredi_SD.DZahlungskond_GetBezeichnungClass(%ID, "_MandantOid_", "_Lang_") As Bezeichnung,"+
		   		 "FibuKonto, Mandant" +
 				 "FROM DBDebiKredi_SD.DZahlungskond" +
 				 "WHERE Mandant="_MandantOid +
 				 "ORDER BY Code"
 				 
 	Set s = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
 	D s.Prepare(strSQL)
 	D s.Execute()
 	Quit s
]]></Implementation>
</Method>

<Property name="OPDebiZKond">
<Type>DBDebiKredi.OPDebi</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktAKZahlungskondition">
<Type>DBFakturierung.Auftragskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="BCheck">
<Type>DBFibu.SD.BCheck</Type>
<Cardinality>one</Cardinality>
<Inverse>Zahlungskond</Inverse>
<Relationship>1</Relationship>
</Property>

<Index name="BCheckIndex">
<Properties>BCheck</Properties>
</Index>

<Method name="IsZahlkondCheck">
<ClassMethod>1</ClassMethod>
<FormalSpec>zahlkondOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set code = ##class(DBDebiKredi.SD.KZahlungskond).%OpenId(zahlkondOid)
	quit ((code >= 40) && (code <= 49))
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.DZahlungskondD</DataLocation>
<DefaultData>DZahlungskondDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.DZahlungskondD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.DZahlungskondI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.DZahlungskondS</StreamLocation>
<Data name="Bezeichnung">
<Attribute>Bezeichnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Bezeichnung"</Subscript>
</Data>
<Data name="DZahlungskondDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Code</Value>
</Value>
<Value name="3">
<Value>Mandant</Value>
</Value>
<Value name="4">
<Value>TageSatz1</Value>
</Value>
<Value name="5">
<Value>ProzentSatz1</Value>
</Value>
<Value name="6">
<Value>TageSatz2</Value>
</Value>
<Value name="7">
<Value>ProzentSatz2</Value>
</Value>
<Value name="8">
<Value>TageNetto</Value>
</Value>
<Value name="9">
<Value>FibuKonto</Value>
</Value>
<Value name="10">
<Value>BCheck</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="BCheck">
</Property>
<Property name="Code">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="Mandant">
</Property>
<Property name="ProzentSatz1">
</Property>
<Property name="ProzentSatz2">
</Property>
<Property name="TageNetto">
</Property>
<Property name="TageSatz1">
</Property>
<Property name="TageSatz2">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.SD.KBank">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61319,40272.402988</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Adresse">
<Description>
Adressnr</Description>
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>one</Cardinality>
<Inverse>StammBanken</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="BankNr">
<Description>
Bank-Nr</Description>
<Type>%Integer</Type>
</Property>

<Index name="BankNrIndex">
<Properties>Adresse,BankNr</Properties>
<Unique>1</Unique>
</Index>

<Property name="Bankclearing">
<Description>
Bankclearing</Description>
<Type>%Integer</Type>
</Property>

<Property name="KtoBankPost">
<Description>
Konto Bank / Post PC-Konto</Description>
<Type>%String</Type>
</Property>

<Property name="KtoBankPostClear">
<Description>
Konto Bank / Post ohne ‘-’</Description>
<Type>%String</Type>
</Property>

<Property name="KtoBankIBAN">
<Description>
Bankkontonummer / IBAN</Description>
<Type>%String</Type>
</Property>

<Property name="KtoBesrBic">
<Description>
BESR-Kontonummer / BIC</Description>
<Type>%String</Type>
</Property>

<Property name="Verguetungscode">
<Description>
Vergütungscode</Description>
<Type>%Integer</Type>
</Property>

<Property name="Bezeichnung">
<Description>
Bezeichnung</Description>
<Type>%String</Type>
</Property>

<Property name="Kostenschluessel">
<Description>
Kostenschlüssel</Description>
<Type>%Integer</Type>
</Property>

<Property name="IBANTyp">
<Description>
IBAN-Typ</Description>
<Type>%Integer</Type>
</Property>

<Property name="Bankname">
<Description>
Bankname</Description>
<Type>%String</Type>
</Property>

<Property name="Ort">
<Description>
Ort</Description>
<Type>%String</Type>
</Property>

<Property name="KontennrBank">
<Description>
Kontennummer Bank</Description>
<Type>%Integer</Type>
</Property>

<Property name="SaveKonto">
<Description>
Konto speichern</Description>
<Type>%Boolean</Type>
</Property>

<Property name="SaveText">
<Description>
Text speichern </Description>
<Type>%Boolean</Type>
</Property>

<Property name="LaengeBelegNr">
<Description>
Länge der Belegnr</Description>
<Type>%Integer</Type>
</Property>

<Property name="StartBelegNr">
<Description>
Start der Belegnr</Description>
<Type>%Integer</Type>
</Property>

<Property name="OPKredi">
<Type>DBDebiKredi.OPKredi</Type>
<Cardinality>many</Cardinality>
<Inverse>Bank</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="BankBuchunungen">
<Description>
Bank Beziehung für Buchunungsvorlagen</Description>
<Type>DBDebiKredi.SD.KBankBuch</Type>
<Cardinality>many</Cardinality>
<Inverse>Bank</Inverse>
<Relationship>1</Relationship>
</Property>

<Method name="GetFirstOidByKrediOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT TOP 1 ID INTO :id FROM DBDebiKredi_SD.KBank
			WHERE Adresse =:krediOid
			ORDER BY BankNr)
	Quit id
]]></Implementation>
</Method>

<Method name="GetOidByKrediOidBankNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String,BankNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi_SD.KBank
			WHERE BankNr = :BankNr AND Adresse =:krediOid)
	Quit id
]]></Implementation>
</Method>

<Method name="GetBankNrByBankOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>Oid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set nr = ""
	&sql(SELECT BankNr INTO :nr FROM DBDebiKredi_SD.KBank
			WHERE ID = :Oid)
	Quit nr
]]></Implementation>
</Method>

<Method name="GetNextBankNrByKreditor">
<ClassMethod>1</ClassMethod>
<FormalSpec>krediOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set nr = ""
	&sql(SELECT MAX(BankNr) INTO :nr 
			FROM DBDebiKredi_SD.KBank
			WHERE Adresse = :krediOid)
			
	if (SQLCODE '= 0) {
		set nr = 0
	}
	Quit nr+1
]]></Implementation>
</Method>

<Method name="LastBank">
<ClassMethod>1</ClassMethod>
<FormalSpec>aktAdresse:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse,""),-1)
	set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse,banknr,""),-1)
	Quit oid
]]></Implementation>
</Method>

<Method name="FirstBank">
<ClassMethod>1</ClassMethod>
<FormalSpec>aktAdresse:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse,""))
	set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse,banknr,""))
	Quit oid
]]></Implementation>
</Method>

<Method name="NextBank">
<ClassMethod>1</ClassMethod>
<FormalSpec>aktAdresse:%String,Banknr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, Banknr))
	set oid = ""
	if banknr '= "" {
		set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, banknr, ""))
	
		if oid = "" {
			set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, Banknr),-1)
			if banknr '= "" {
				set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, banknr, ""),-1)
			}
		}
	} else {
		
		set oid = ##class(DBDebiKredi.SD.KBank).LastBank()
	}
	
	Quit oid
]]></Implementation>
</Method>

<Method name="PrevBank">
<ClassMethod>1</ClassMethod>
<FormalSpec>aktAdresse:%String,Banknr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, Banknr),-1)
	set oid = ""
	if banknr '= "" {
		set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, banknr, ""),-1)
	
		if oid = "" {
			set banknr = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, Banknr))
			if banknr '= "" {
				set oid = $Order(^DBDebiKredi.SD.KrediBankI("BankNrIndex",aktAdresse, banknr, ""))
			}
		}
	} else {
		
		set oid = ##class(DBDebiKredi.SD.KBank).FirstBank()
	}
	
	Quit oid
]]></Implementation>
</Method>

<Method name="GetOidByKontoESR">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Konto:%String,ESR:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi_SD.KBank
			WHERE Adresse->Mandant=:MandantOid 
				AND KtoBankPostClear=:Konto 
				AND KtoBesrBic %STARTSWITH :ESR
				AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3))
	
	if (SQLCODE '= 0) {
    	Quit ""
    } else {
	    Quit id
    }
]]></Implementation>
</Method>

<Method name="GetAnzahlKontoESR">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Konto:%String,ESR:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set anz = 0
	&sql(SELECT Count(ID) INTO :anz FROM DBDebiKredi_SD.KBank
			WHERE Adresse->Mandant=:MandantOid 
				AND KtoBankPostClear=:Konto 
				AND KtoBesrBic %STARTSWITH :ESR
				AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3))
    
    if (SQLCODE '= 0) {
    	set anz = 0
    } 
    
	Quit +anz
]]></Implementation>
</Method>

<Method name="GetAnzahlKonto">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Konto:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
    set anz = 0
    &sql(SELECT Count(ID) INTO :anz FROM DBDebiKredi_SD.KBank
         	WHERE Adresse->Mandant=:MandantOid 
            AND KtoBankPostClear=:Konto
            AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3))
    				
    if (SQLCODE '= 0) {
    	set anz = 0
    } 
    
    Quit +anz
]]></Implementation>
</Method>

<Method name="GetOidByKonto">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Konto:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
    set id = ""
    &sql(SELECT ID INTO :id FROM DBDebiKredi_SD.KBank
         	WHERE Adresse->Mandant=:MandantOid 
            AND KtoBankPostClear=:Konto
            AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3))
    				
    if (SQLCODE '= 0) {
    	Quit ""
    } else {
	    Quit id
    }
]]></Implementation>
</Method>

<Method name="GetOidByKrediOidKonto">
<ClassMethod>1</ClassMethod>
<FormalSpec>KreditorOid:%String,Konto:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
    set id = ""
    &sql(SELECT ID INTO :id FROM DBDebiKredi_SD.KBank
         	WHERE Adresse=:KreditorOid 
            AND KtoBankPostClear=:Konto
            AND (Verguetungscode = :BankTyp1
    				OR Verguetungscode = :BankTyp2
    				OR Verguetungscode = :BankTyp3))
    if (SQLCODE '= 0) {
    	Quit ""
    } else {
	    Quit id
    }
]]></Implementation>
</Method>

<Method name="GetOidByTyp">
<ClassMethod>1</ClassMethod>
<FormalSpec>KrediOid:%String,BankTyp1:%Integer,BankTyp2:%Integer,BankTyp3:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	/*
	set myId = ""
	
	&sql(SELECT ID INTO :myId FROM DBDebiKredi_SD.KBank
			WHERE Adresse=:KrediOid AND Verguetungscode=:BankTyp)
	Quit myId
	*/
	
	set myId = ""
	
	Set strSQL="SELECT ID FROM DBDebiKredi_SD.KBank WHERE Adresse="_KrediOid_" AND (Verguetungscode="_BankTyp1_" OR Verguetungscode="_BankTyp2_" OR Verguetungscode="_BankTyp3_")"
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	IF ($$$ISOK(sc)) {
		if (rs.Next(.sc)) {
			Set myId = rs.Data("ID")
		}
    }
		
	Quit myId
]]></Implementation>
</Method>

<Method name="DeleteKBankBuch">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set strSQL="SELECT ID FROM DBDebiKredi_SD.KBankBuch WHERE Bank="_BankOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set res = $$$OK
	
	IF ($$$ISOK(sc)) {
		while (rs.Next(.sc)) {
			set res = ##class(DBDebiKredi.SD.KBankBuch).%DeleteId(rs.Data("ID"))
		}
    }
    
    quit res
]]></Implementation>
</Method>

<Method name="HasOpenZahlungen">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set count = 0
	&sql(SELECT COUNT(ID) INTO :count FROM DBDebiKredi.OPKredi WHERE Bank = :BankOid AND IsOPgeschlossen = 0)
	
	if (count = 0) {
		quit 0
	} else {
		quit 1	
	}
]]></Implementation>
</Method>

<Method name="HasZahlungen">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set count = 0
	&sql(SELECT COUNT(ID) INTO :count FROM DBDebiKredi.OPKredi WHERE Bank = :BankOid)
	
	if (count = 0) {
		quit 0
	} else {
		quit 1	
	}
]]></Implementation>
</Method>

<Method name="SetBankAtZahlungenNull">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String</FormalSpec>
<Implementation><![CDATA[
	
	&sql(UPDATE DBDebiKredi.OPKredi SET Bank = '' WHERE Bank = NULL)
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description>
[Previously private]</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	set bankOid = $lg(oid,1)
	
	quit ##class(DBDebiKredi.SD.KBank).DeleteKBankBuch(bankOid)
]]></Implementation>
</Method>

<Trigger name="DeleteBetrag">
<Code>	new bankOid
	
	set bankOid = {ID*O}
	
	quit ##class(DBDebiKredi.SD.KBank).DeleteKBankBuch(bankOid)</Code>
<Event>DELETE</Event>
<Foreach>row</Foreach>
</Trigger>

<Index name="AdresseIndex">
<Properties>Adresse</Properties>
</Index>

<Method name="GetFirstIbanOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>KrediOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	
	set myId = ""
	
	&sql(SELECT TOP 1 ID Into :myId
			FROM DBDebiKredi_SD.KBank 
			WHERE Adresse=:KrediOid AND (
					Verguetungscode=2 OR 
					Verguetungscode=3 OR 
					Verguetungscode=4 OR 
					Verguetungscode=5))
	
	if (SQLCODE=0) {	
		Quit myId
	} else {
		Quit ""
	}
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.KBankD</DataLocation>
<DefaultData>KBankDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.KBankD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.KBankI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.KBankS</StreamLocation>
<Data name="KBankDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Adresse</Value>
</Value>
<Value name="3">
<Value>BankNr</Value>
</Value>
<Value name="4">
<Value>Bankclearing</Value>
</Value>
<Value name="5">
<Value>KtoBankPost</Value>
</Value>
<Value name="6">
<Value>KtoBankPostClear</Value>
</Value>
<Value name="7">
<Value>KtoBankIBAN</Value>
</Value>
<Value name="8">
<Value>KtoBesrBic</Value>
</Value>
<Value name="9">
<Value>Verguetungscode</Value>
</Value>
<Value name="10">
<Value>Bezeichnung</Value>
</Value>
<Value name="11">
<Value>Kostenschluessel</Value>
</Value>
<Value name="12">
<Value>IBANTyp</Value>
</Value>
<Value name="13">
<Value>Bankname</Value>
</Value>
<Value name="14">
<Value>Ort</Value>
</Value>
<Value name="15">
<Value>KontennrBank</Value>
</Value>
<Value name="16">
<Value>FibuKonto</Value>
</Value>
<Value name="17">
<Value>Buchungstext1</Value>
</Value>
<Value name="18">
<Value>Buchungstext2</Value>
</Value>
<Value name="19">
<Value>SaveKonto</Value>
</Value>
<Value name="20">
<Value>SaveText</Value>
</Value>
<Value name="21">
<Value>LaengeBelegNr</Value>
</Value>
<Value name="22">
<Value>StartBelegNr</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Adresse">
</Property>
<Property name="BankNr">
</Property>
<Property name="Bankclearing">
</Property>
<Property name="Bankname">
</Property>
<Property name="Bezeichnung">
</Property>
<Property name="Buchungstext1"/>
<Property name="Buchungstext2"/>
<Property name="FibuKonto"/>
<Property name="IBANTyp">
</Property>
<Property name="KontennrBank">
</Property>
<Property name="Kostenschluessel">
</Property>
<Property name="KtoBankIBAN">
</Property>
<Property name="KtoBankPost">
</Property>
<Property name="KtoBankPostClear">
</Property>
<Property name="KtoBesrBic">
</Property>
<Property name="LaengeBelegNr">
</Property>
<Property name="Ort">
</Property>
<Property name="SaveKonto">
</Property>
<Property name="SaveText">
</Property>
<Property name="StartBelegNr">
</Property>
<Property name="Verguetungscode">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.SD.KBankBuch">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61697,59484.81671</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Bank">
<Type>DBDebiKredi.SD.KBank</Type>
<Cardinality>one</Cardinality>
<Inverse>BankBuchunungen</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="Nummer">
<Description>
Nr</Description>
<Type>%Integer</Type>
</Property>

<Property name="Buchungstext1">
<Description>
Buchungstext1</Description>
<Type>%String</Type>
</Property>

<Property name="Buchungstext2">
<Description>
Buchungstext2</Description>
<Type>%String</Type>
</Property>

<Property name="FibuKonto">
<Description>
Fibu-Konto</Description>
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>KBankBuchKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Method name="GetOidByNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String,Nr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBDebiKredi_SD.KBankBuch
			WHERE Bank=:BankOid AND Nummer=:Nr)
	Quit id
]]></Implementation>
</Method>

<Method name="GetNextFreeNummer">
<ClassMethod>1</ClassMethod>
<FormalSpec>BankOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set nr = 0
	&sql(SELECT MAX(Nummer) INTO :nr FROM DBDebiKredi_SD.KBankBuch
			WHERE Bank=:BankOid)
	Quit (nr+1)
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.KBankBuchD</DataLocation>
<DefaultData>KBankBuchDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.KBankBuchD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.KBankBuchI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.KBankBuchS</StreamLocation>
<Data name="KBankBuchDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Bank</Value>
</Value>
<Value name="3">
<Value>Nummer</Value>
</Value>
<Value name="4">
<Value>FibuKonto</Value>
</Value>
<Value name="5">
<Value>Buchungstext1</Value>
</Value>
<Value name="6">
<Value>Buchungstext2</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Bank">
</Property>
<Property name="Buchungstext1">
</Property>
<Property name="Buchungstext2">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="Nummer">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.SD.KZahlungskond">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61319,40139.410115</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Code">
<Type>%Integer</Type>
<Required>1</Required>
</Property>

<Index name="CodeIndex">
<Properties>Mandant,Code</Properties>
<Unique>1</Unique>
</Index>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
</Index>

<Property name="TageSatz1">
<Type>%Integer</Type>
</Property>

<Property name="ProzentSatz1">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="TageSatz2">
<Type>%Integer</Type>
</Property>

<Property name="ProzentSatz2">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="TageNetto">
<Type>%Integer</Type>
</Property>

<Property name="Bezeichnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="FibuKonto">
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>KrediZahlungskondFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Property name="KreditorZahlungskondition">
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="BestellungsKopf">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Method name="GetKondOidByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Code:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set oid = ""
	QUIT:(MandantOid="")||(Code<0)
	&sql(SELECT ID INTO :oid
		 FROM DBDebiKredi_SD.KZahlungskond
		 WHERE Mandant = :MandantOid AND Code = :Code)
	Quit oid
]]></Implementation>
</Method>

<Method name="GetKondCodeByOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Oid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set code = 0
	QUIT:(MandantOid="")||(Oid="")
	&sql(SELECT Code INTO :code
		 FROM DBDebiKredi_SD.KZahlungskond
		 WHERE Mandant = :MandantOid AND ID = :Oid)
	Quit +code
]]></Implementation>
</Method>

<Method name="DeleteAll">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	&sql(DELETE FROM DBDebiKredi_SD.KZahlungskond
		 WHERE Mandant =:MandantOid)
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="GetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Bezeichnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBezeichnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.KZahlungskond).%OpenId(myID)
		set text = rs.GetBezeichnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="SetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Bezeichnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="CopyKondFromMandant">
<ClassMethod>1</ClassMethod>
<FormalSpec>OldMandOid:%String,NewMandOid:%String</FormalSpec>
<Implementation><![CDATA[
	Quit:(OldMandOid="")||(NewMandOid="")
	&sql(SELECT Count(*) InTo :Cnt From DBCore.Mandant WHERE ID=:NewMandOid)
	If (Cnt) {
		Set strSQL="SELECT ID FROM DBDebiKredi_SD.KZahlungskond WHERE Mandant = "_OldMandOid
		Set s=##class(%ResultSet).%New("%DynamicQuery:SQL")
		Do s.Prepare(strSQL)
		Do s.Execute()
		While s.Next(.osc) {
			If $$$ISERR(osc) Quit
			Set n=..%New()
			Set o=..%OpenId(s.ID)
			Set n=o.%ConstructClone(0)
			Set n.Mandant= NewMandOid
			Do n.%Save()
		}
	}
]]></Implementation>
</Method>

<Method name="ListeGesamt">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<ReturnType>%Library.ResultSet</ReturnType>
<Implementation><![CDATA[

	Set strSQL = "SELECT %ID,Code, TageSatz1, ProzentSatz1, TageSatz2, ProzentSatz2,TageNetto," +
				 "DBDebiKredi_SD.KZahlungskond_GetBezeichnungClass(%ID, "_MandantOid_", "_Lang_") As Bezeichnung,"+
		   		 "FibuKonto, Mandant" +
 				 "FROM DBDebiKredi_SD.KZahlungskond" +
 				 "WHERE Mandant="_MandantOid +
 				 "ORDER BY Code"
 				 
 	Set s = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
 	D s.Prepare(strSQL)
 	D s.Execute()
 	Quit s
]]></Implementation>
</Method>

<Property name="OPKrediZKond">
<Type>DBDebiKredi.OPKredi</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FaktEKAKZahlungsKond">
<Type>DBFaktEK.Bestellungskopf</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlungskondition</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.KZahlungskondD</DataLocation>
<DefaultData>KZahlungskondDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.KZahlungskondD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.KZahlungskondI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.KZahlungskondS</StreamLocation>
<Data name="Bezeichnung">
<Attribute>Bezeichnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Bezeichnung"</Subscript>
</Data>
<Data name="KZahlungskondDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Code</Value>
</Value>
<Value name="3">
<Value>Mandant</Value>
</Value>
<Value name="4">
<Value>TageSatz1</Value>
</Value>
<Value name="5">
<Value>ProzentSatz1</Value>
</Value>
<Value name="6">
<Value>TageSatz2</Value>
</Value>
<Value name="7">
<Value>ProzentSatz2</Value>
</Value>
<Value name="8">
<Value>TageNetto</Value>
</Value>
<Value name="9">
<Value>FibuKonto</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Code">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="Mandant">
</Property>
<Property name="ProzentSatz1">
</Property>
<Property name="ProzentSatz2">
</Property>
<Property name="TageNetto">
</Property>
<Property name="TageSatz1">
</Property>
<Property name="TageSatz2">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.SD.Mahneinst">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61773,55919.783395</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
<Unique>1</Unique>
</Index>

<Property name="BelegNr">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="BelegArt">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Belegdatum">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="VerfalleneOP">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="ZahlungenBis">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Faellig">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Verzug">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Betrag">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="TotalOP">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="MahnArt">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Uebertrag">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="AdressePositionLinks">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="AdressePositionOben">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="SchriftName">
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="SchriftGroesse">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Rechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Gutschrift">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="KundenNr">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="PositionObenFolgeseiten">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Seite">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Tage">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Teilrechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Schlussrechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Regierechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Situationsrechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Teuerungsrechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Akontozahlungsgesuch">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Akontorechnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="EzDruckAufNeueSeite">
<Type>%Boolean</Type>
</Property>

<Property name="EzDrucker">
<Type>%String</Type>
</Property>

<Property name="EzSchacht">
<Type>%String</Type>
</Property>

<Property name="Einschreiben">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Mahngebuehr">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Vorauszahlung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Method name="GetOidByMandant">
<ClassMethod>1</ClassMethod>
<FormalSpec>mandOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set oid = ""
	&sql(SELECT ID Into :oid FROM DBDebiKredi_SD.Mahneinst WHERE Mandant=:mandOid)
	quit oid
]]></Implementation>
</Method>

<Method name="GetBelegNr">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..BelegNr, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBelegNrClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetBelegNr(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBelegNrByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetBelegNrClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetBelegNr">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..BelegNr, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBelegArt">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..BelegArt, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBelegArtClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetBelegArt(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBelegArtByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetBelegArtClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetBelegArt">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..BelegArt, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBelegdatum">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Belegdatum, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBelegdatumClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetBelegdatum(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBelegdatumByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetBelegdatumClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetBelegdatum">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Belegdatum, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVerfalleneOP">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..VerfalleneOP, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVerfalleneOPClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetVerfalleneOP(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetVerfalleneOPByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetVerfalleneOPClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetVerfalleneOP">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..VerfalleneOP, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetZahlungenBis">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..ZahlungenBis, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetZahlungenBisClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetZahlungenBis(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetZahlungenBisByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetZahlungenBisClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetZahlungenBis">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..ZahlungenBis, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetFaellig">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Faellig, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetFaelligClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetFaellig(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetFaelligByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetFaelligClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetFaellig">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Faellig, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVerzug">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Verzug, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVerzugClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetVerzug(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetVerzugByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetVerzugClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetVerzug">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Verzug, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBetrag">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Betrag, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBetragClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetBetrag(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBetragByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetBetragClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetBetrag">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Betrag, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTotalOP">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..TotalOP, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTotalOPClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetTotalOP(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetTotalOPByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetTotalOPClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetTotalOP">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..TotalOP, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetMahnArt">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..MahnArt, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetMahnArtClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetMahnArt(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetMahnArtByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetMahnArtClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetMahnArt">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..MahnArt, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetUebertrag">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Uebertrag, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetUebertragClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetUebertrag(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetUebertragByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetUebertragClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetUebertrag">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Uebertrag, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetRechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Rechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetRechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetRechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetRechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetRechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetRechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Rechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetGutschrift">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Gutschrift, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetGutschriftClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetGutschrift(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetGutschriftByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetGutschriftClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetGutschrift">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Gutschrift, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetKundenNr">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..KundenNr, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetKundenNrClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetKundenNr(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetKundenNrByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetKundenNrClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetKundenNr">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..KundenNr, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSeite">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Seite, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSeiteClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetSeite(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetSeiteByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetSeiteClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetSeite">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Seite, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTage">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Tage, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTageClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetTage(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetTageByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetTageClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetTage">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Tage, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTeilrechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Teilrechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTeilrechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetTeilrechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetTeilrechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetTeilrechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetTeilrechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Teilrechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSchlussrechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Schlussrechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSchlussrechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetSchlussrechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetSchlussrechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetSchlussrechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetSchlussrechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Schlussrechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetRegierechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Regierechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetRegierechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetRegierechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetRegierechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetRegierechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetRegierechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Regierechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSituationsrechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Situationsrechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetSituationsrechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetSituationsrechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetSituationsrechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetSituationsrechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetSituationsrechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Situationsrechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTeuerungsrechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Teuerungsrechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetTeuerungsrechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetTeuerungsrechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetTeuerungsrechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetTeuerungsrechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetTeuerungsrechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Teuerungsrechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetAkontozahlungsgesuch">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Akontozahlungsgesuch, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetAkontozahlungsgesuchClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetAkontozahlungsgesuch(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetAkontozahlungsgesuchByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetAkontozahlungsgesuchClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetAkontozahlungsgesuch">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Akontozahlungsgesuch, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetAkontorechnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Akontorechnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetAkontorechnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetAkontorechnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetAkontorechnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetAkontorechnungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetAkontorechnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Akontorechnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetEinschreiben">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Einschreiben, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetEinschreibenClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetEinschreiben(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetEinschreibenByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetEinschreibenClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetEinschreiben">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Einschreiben, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetMahngebuehr">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Mahngebuehr, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetMahngebuehrClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetMahngebuehr(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetMahngebuehrByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetMahngebuehrClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetMahngebuehr">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Vorauszahlung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVorauszahlung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Vorauszahlung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetVorauszahlungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahneinst).%OpenId(myID)
		set text = rs.GetVorauszahlung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetVorauszahlungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiID:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiID)
	set MandOid = debi.Adresse.Mandant
	Set Lang = debi.Adresse.Sprachcode
	set myID = ##class(DBDebiKredi.SD.Mahneinst).GetOidByMandant(debi.Adresse.Mandant)
	
	Quit ##class(DBDebiKredi.SD.Mahneinst).GetVorauszahlungClass(myID,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetVorauszahlung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Vorauszahlung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.MahneinstD</DataLocation>
<DefaultData>MahneinstDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.MahneinstD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.MahneinstI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.MahneinstS</StreamLocation>
<Data name="Akontorechnung">
<Attribute>Akontorechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Akontorechnung"</Subscript>
</Data>
<Data name="Akontozahlungsgesuch">
<Attribute>Akontozahlungsgesuch</Attribute>
<Structure>subnode</Structure>
<Subscript>"Akontozahlungsgesuch"</Subscript>
</Data>
<Data name="BelegArt">
<Attribute>BelegArt</Attribute>
<Structure>subnode</Structure>
<Subscript>"BelegArt"</Subscript>
</Data>
<Data name="BelegNr">
<Attribute>BelegNr</Attribute>
<Structure>subnode</Structure>
<Subscript>"BelegNr"</Subscript>
</Data>
<Data name="Belegdatum">
<Attribute>Belegdatum</Attribute>
<Structure>subnode</Structure>
<Subscript>"Belegdatum"</Subscript>
</Data>
<Data name="Betrag">
<Attribute>Betrag</Attribute>
<Structure>subnode</Structure>
<Subscript>"Betrag"</Subscript>
</Data>
<Data name="Einschreiben">
<Attribute>Einschreiben</Attribute>
<Structure>subnode</Structure>
<Subscript>"Einschreiben"</Subscript>
</Data>
<Data name="Faellig">
<Attribute>Faellig</Attribute>
<Structure>subnode</Structure>
<Subscript>"Faellig"</Subscript>
</Data>
<Data name="Gutschrift">
<Attribute>Gutschrift</Attribute>
<Structure>subnode</Structure>
<Subscript>"Gutschrift"</Subscript>
</Data>
<Data name="KundenNr">
<Attribute>KundenNr</Attribute>
<Structure>subnode</Structure>
<Subscript>"KundenNr"</Subscript>
</Data>
<Data name="MahnArt">
<Attribute>MahnArt</Attribute>
<Structure>subnode</Structure>
<Subscript>"MahnArt"</Subscript>
</Data>
<Data name="MahneinstDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Mandant</Value>
</Value>
<Value name="3">
<Value>AdressePositionLinks</Value>
</Value>
<Value name="4">
<Value>AdressePositionOben</Value>
</Value>
<Value name="5">
<Value>SchriftName</Value>
</Value>
<Value name="6">
<Value>SchriftGroesse</Value>
</Value>
<Value name="7">
<Value>PositionObenFolgeseiten</Value>
</Value>
<Value name="8">
<Value>EzDruckAufNeueSeite</Value>
</Value>
<Value name="9">
<Value>EzDrucker</Value>
</Value>
<Value name="10">
<Value>EzSchacht</Value>
</Value>
</Data>
<Data name="Mahngebuehr">
<Attribute>Mahngebuehr</Attribute>
<Structure>subnode</Structure>
<Subscript>"Mahngebuehr"</Subscript>
</Data>
<Data name="Rechnung">
<Attribute>Rechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Rechnung"</Subscript>
</Data>
<Data name="Regierechnung">
<Attribute>Regierechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Regierechnung"</Subscript>
</Data>
<Data name="Schlussrechnung">
<Attribute>Schlussrechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Schlussrechnung"</Subscript>
</Data>
<Data name="Seite">
<Attribute>Seite</Attribute>
<Structure>subnode</Structure>
<Subscript>"Seite"</Subscript>
</Data>
<Data name="Situationsrechnung">
<Attribute>Situationsrechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Situationsrechnung"</Subscript>
</Data>
<Data name="Tage">
<Attribute>Tage</Attribute>
<Structure>subnode</Structure>
<Subscript>"Tage"</Subscript>
</Data>
<Data name="Teilrechnung">
<Attribute>Teilrechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Teilrechnung"</Subscript>
</Data>
<Data name="Teuerungsrechnung">
<Attribute>Teuerungsrechnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Teuerungsrechnung"</Subscript>
</Data>
<Data name="TotalOP">
<Attribute>TotalOP</Attribute>
<Structure>subnode</Structure>
<Subscript>"TotalOP"</Subscript>
</Data>
<Data name="Uebertrag">
<Attribute>Uebertrag</Attribute>
<Structure>subnode</Structure>
<Subscript>"Uebertrag"</Subscript>
</Data>
<Data name="VerfalleneOP">
<Attribute>VerfalleneOP</Attribute>
<Structure>subnode</Structure>
<Subscript>"VerfalleneOP"</Subscript>
</Data>
<Data name="Verzug">
<Attribute>Verzug</Attribute>
<Structure>subnode</Structure>
<Subscript>"Verzug"</Subscript>
</Data>
<Data name="Vorauszahlung">
<Attribute>Vorauszahlung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Vorauszahlung"</Subscript>
</Data>
<Data name="ZahlungenBis">
<Attribute>ZahlungenBis</Attribute>
<Structure>subnode</Structure>
<Subscript>"ZahlungenBis"</Subscript>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AdressePositionLinks">
</Property>
<Property name="AdressePositionOben">
</Property>
<Property name="EzDruckAufNeueSeite">
</Property>
<Property name="EzDrucker">
</Property>
<Property name="EzSchacht">
</Property>
<Property name="Mandant">
</Property>
<Property name="PositionObenFolgeseiten">
</Property>
<Property name="SchriftGroesse">
</Property>
<Property name="SchriftName">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.SD.Mahntyp">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61767,42113.347697</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="Code">
<Type>%Integer</Type>
<Required>1</Required>
</Property>

<Index name="CodeIndex">
<Properties>Mandant,Code</Properties>
<Unique>1</Unique>
</Index>

<Property name="Mandant">
<Type>%String</Type>
</Property>

<ForeignKey name="FKMandant">
<Properties>Mandant</Properties>
<ReferencedClass>DBCore.Mandant</ReferencedClass>
<ReferencedKey>MandIdIndex</ReferencedKey>
</ForeignKey>

<Index name="MandantIdx">
<Properties>Mandant</Properties>
</Index>

<Property name="Bezeichnung">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="KeineMahnungBisBetrag">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Mahngebuehr">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MahngebuehrNachAnzTagen">
<Type>%Integer</Type>
</Property>

<Property name="VerzugszinsProzent">
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Funktion">
<Type>%Integer</Type>
</Property>

<Property name="Mahntext">
<Type>%String</Type>
<Collection>array</Collection>
<Parameter name="MAXLEN" value="32767"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Einschreiben">
<Type>%Boolean</Type>
</Property>

<Method name="GetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Bezeichnung, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetBezeichnungClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		set text = rs.GetBezeichnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBezeichnungByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>code:%Integer,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCode(MandOid,code)
	if (myID = "") {
		set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCodeMax(MandOid)
	}
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		set text = rs.GetBezeichnung(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetBezeichnungByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	set MandOid = debi.Adresse.Mandant
	set Lang = debi.Adresse.Sprachcode
	set code = ##class(DBDebiKredi.OPDebi).GetMahnstufe(debiOid)
		
	Quit ##class(DBDebiKredi.SD.Mahntyp).GetBezeichnungByCode(code,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetBezeichnung">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Bezeichnung, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetOidByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandOid:%String,Code:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set oid = ""
	&sql(SELECT ID INTO :oid
		 FROM DBDebiKredi_SD.Mahntyp
		 WHERE Code = :Code AND Mandant=:MandOid)
	Quit oid
]]></Implementation>
</Method>

<Method name="GetOidByCodeMax">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set oid = ""
	&sql(SELECT TOP 1 ID INTO :oid
		 FROM DBDebiKredi_SD.Mahntyp
		 WHERE Mandant=:MandOid
		 ORDER BY Code DESC)
	Quit oid
]]></Implementation>
</Method>

<Method name="DeleteAll">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandOid:%String</FormalSpec>
<Implementation><![CDATA[
	&sql(DELETE
		 FROM DBDebiKredi_SD.Mahntyp
		 WHERE Mandant=:MandOid)
	Quit 1
]]></Implementation>
</Method>

<Method name="GetMahntext">
<FormalSpec>MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	Quit ##Class(DBUtils.StringUtils).GetText(..Mahntext, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetMahntextClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>myID:%String,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		set text = rs.GetMahntext(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetMahntextByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>code:%Integer,MandOid:%String,Lang:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCode(MandOid,code)
	if (myID = "") {
		set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCodeMax(MandOid)
	}
	set text = ""
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		set text = rs.GetMahntext(MandOid, Lang)
	}
	Quit text
]]></Implementation>
</Method>

<Method name="GetMahntextByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	set MandOid = debi.Adresse.Mandant
	set Lang = debi.Adresse.Sprachcode
	set code = ##class(DBDebiKredi.OPDebi).GetMahnstufe(debiOid)
	
	Quit ##class(DBDebiKredi.SD.Mahntyp).GetMahntextByCode(code,MandOid,Lang)
]]></Implementation>
</Method>

<Method name="SetMahntext">
<FormalSpec>MandOid:%String,Lang:%String,Value:%String</FormalSpec>
<Implementation><![CDATA[	Do ##class(DBUtils.StringUtils).SetText(..Mahntext, Value, Lang, MandOid)
]]></Implementation>
</Method>

<Method name="GetEinschreibenByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>code:%Integer,MandOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCode(MandOid,code)
	if (myID = "") {
		set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCodeMax(MandOid)
	}
	set einschreiben = 0
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		set einschreiben = rs.Einschreiben
	}
	Quit einschreiben
]]></Implementation>
</Method>

<Method name="GetEinschreibenByDebi">
<ClassMethod>1</ClassMethod>
<FormalSpec>debiOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set debi = ##class(DBDebiKredi.Debitor).%OpenId(debiOid)
	set MandOid = debi.Adresse.Mandant
	set code = ##class(DBDebiKredi.OPDebi).GetMahnstufe(debiOid)
	
	Quit ##class(DBDebiKredi.SD.Mahntyp).GetEinschreibenByCode(code,MandOid)
]]></Implementation>
</Method>

<Method name="GetMahngebuehrByCode">
<ClassMethod>1</ClassMethod>
<FormalSpec>code:%Integer,MandOid:%String,betrag:%Decimal</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCode(MandOid,code)
	if (myID = "") {
		set myID = ##class(DBDebiKredi.SD.Mahntyp).GetOidByCodeMax(MandOid)
	}
	set gebuehr = 0
	if (myID '= "") {
		Set rs=##Class(DBDebiKredi.SD.Mahntyp).%OpenId(myID)
		if ((rs.KeineMahnungBisBetrag = 0) || (rs.KeineMahnungBisBetrag = "") || (rs.KeineMahnungBisBetrag < betrag)) {
			set gebuehr = rs.Mahngebuehr
		}
	}
	Quit gebuehr
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.SD.MahntypD</DataLocation>
<DefaultData>MahntypDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.SD.MahntypD</IdLocation>
<IndexLocation>^DBDebiKredi.SD.MahntypI</IndexLocation>
<StreamLocation>^DBDebiKredi.SD.MahntypS</StreamLocation>
<Data name="Bezeichnung">
<Attribute>Bezeichnung</Attribute>
<Structure>subnode</Structure>
<Subscript>"Bezeichnung"</Subscript>
</Data>
<Data name="Mahntext">
<Attribute>Mahntext</Attribute>
<Structure>subnode</Structure>
<Subscript>"Mahntext"</Subscript>
</Data>
<Data name="MahntypDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Code</Value>
</Value>
<Value name="3">
<Value>Mandant</Value>
</Value>
<Value name="4">
<Value>KeineMahnungBisBetrag</Value>
</Value>
<Value name="5">
<Value>Mahngebuehr</Value>
</Value>
<Value name="6">
<Value>MahngebuehrNachAnzTagen</Value>
</Value>
<Value name="7">
<Value>VerzugszinsProzent</Value>
</Value>
<Value name="8">
<Value>Formular</Value>
</Value>
<Value name="9">
<Value>Funktion</Value>
</Value>
<Value name="10">
<Value>Einschreiben</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Code">
</Property>
<Property name="Einschreiben">
</Property>
<Property name="Formular"/>
<Property name="Funktion">
</Property>
<Property name="KeineMahnungBisBetrag">
</Property>
<Property name="Mahngebuehr">
</Property>
<Property name="MahngebuehrNachAnzTagen">
</Property>
<Property name="Mandant">
</Property>
<Property name="VerzugszinsProzent">
</Property>
</Storage>
</Class>


<Class name="DBDebiKredi.Zahlung">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,57053</TimeChanged>
<TimeCreated>61384,42123.418789</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="XMLIGNOREINVALIDATTRIBUTE">
<Description><![CDATA[
Controls how to handle attributes that are unexpected.
-> If this parameter is 1 (the default), such attributes are ignored.
-> If it is 0, they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNOREINVALIDTAG">
<Description><![CDATA[
Controls how to handle tags that are unexpected. 
-> If this parameter is 1, such tags are ignored. 
-> If it is 0 (the default), they are treated as errors, and import fails.]]></Description>
<Default>1</Default>
</Parameter>

<Parameter name="XMLIGNORENULL">
<Default>1</Default>
</Parameter>

<Property name="IdForExport">
<Type>%XML.Id</Type>
<Private>1</Private>
<Transient>1</Transient>
<Parameter name="XMLNAME" value="ID"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
</Property>

<Property name="BelegNr">
<Description>
Beleg-Nummer</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Erfassungsdatum">
<Description>
Erfassungsdatum</Description>
<Type>%Date</Type>
</Property>

<Property name="Valutadatum">
<Description>
Valutadatum</Description>
<Type>%Date</Type>
</Property>

<Property name="Buchungstext1">
<Description>
Buchungstext 1</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Buchungstext2">
<Description>
Buchungstext 2</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Waehrung">
<Description>
Fremdwährung</Description>
<Type>DBFibu.SD.Fremdwaehrung</Type>
<Cardinality>one</Cardinality>
<Inverse>ZahlungWaehrung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Fremdwaehrung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="WaehrungIndex">
<Properties>Waehrung</Properties>
</Index>

<Property name="FWFaktor">
<Description>
Fremdwährung - Faktor</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWKurs">
<Description>
Fremdwährung - Kurs</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Typ">
<Description>
Typ</Description>
<Type>%Library.Integer</Type>
</Property>

<Property name="ManuelleErfassung">
<Description>
Manuelle Erfassung</Description>
<Type>%Boolean</Type>
</Property>

<Property name="Verbuchungsjnr">
<Description>
Verbuchungsjournal-Nummer</Description>
<Type>%Integer</Type>
</Property>

<Property name="OPZahlung">
<Description>
OPZahlung</Description>
<Type>DBDebiKredi.OPZahlung</Type>
<Cardinality>many</Cardinality>
<Inverse>Zahlung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLPROJECTION" value="NONE"/>
</Property>

<Property name="FibuKonto">
<Description>
FibuKonto</Description>
<Type>DBFibu.Konto</Type>
<Cardinality>one</Cardinality>
<Inverse>ZahlungFibuKonto</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuKonto"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuKontoIndex">
<Properties>FibuKonto</Properties>
</Index>

<Property name="Zahlbetrag">
<Description>
Zahlbetrag</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {Zahlbetrag}=##class(DBDebiKredi.Zahlung).GetZahlbetragClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="Skontoabzug">
<Description>
Skontoabzug</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {Skontoabzug}=##class(DBDebiKredi.Zahlung).GetSkontoabzugClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWZahlbetrag">
<Description>
Zahlbetrag FW</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {FWZahlbetrag}=##class(DBDebiKredi.Zahlung).GetFWZahlbetragClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FWSkontoabzug">
<Description>
Skontoabzug FW</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {FWSkontoabzug}=##class(DBDebiKredi.Zahlung).GetFWSkontoabzugClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="FibuBuchung">
<Type>DBFibu.Buchung</Type>
<Cardinality>one</Cardinality>
<Inverse>Zahlung</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="FibuBuchung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="FibuBuchungIndex">
<Properties>FibuBuchung</Properties>
</Index>

<Property name="Belegdatum">
<Description>
Belegdatum</Description>
<Type>%Date</Type>
</Property>

<Property name="Bank">
<Description>
Bank</Description>
<Type>DBFibu.SD.Bank</Type>
<Cardinality>one</Cardinality>
<Inverse>ZahlungBank</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Bank"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="BankIndex">
<Properties>Bank</Properties>
</Index>

<Property name="VerrechnungsNr">
<Description>
VerrechnungsNr</Description>
<Type>%Integer</Type>
</Property>

<Property name="Kursdifferenz">
<Description>
Kursdifferenz</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {Kursdifferenz}=##class(DBDebiKredi.Zahlung).GetKursdifferenzClass({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="VerbuchungsjnrManuell">
<Description>
Verbuchungsjournal-Nummer Manuelle Zahlungen</Description>
<Type>%Integer</Type>
</Property>

<Property name="ErfasserBenutzername">
<Type>%Library.String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Method name="GetZahlbetragClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	&sql(SELECT SUM(Zahlbetrag) INTO :betrag FROM OPZahlung WHERE Zahlung=:Id)
	Quit betrag
]]></Implementation>
</Method>

<Method name="GetSkontoabzugClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	&sql(SELECT SUM(Skontoabzug) INTO :betrag FROM OPZahlung WHERE Zahlung=:Id)
	Quit betrag
]]></Implementation>
</Method>

<Method name="GetFWZahlbetragClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	&sql(SELECT SUM(FWZahlbetrag) INTO :betrag FROM OPZahlung WHERE Zahlung=:Id)
	Quit betrag
]]></Implementation>
</Method>

<Method name="GetFWSkontoabzugClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	&sql(SELECT SUM(FWSkontoabzug) INTO :betrag FROM OPZahlung WHERE Zahlung=:Id)
	Quit betrag
]]></Implementation>
</Method>

<Method name="%OnDelete">
<Description>
[Previously private]</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>oid:%ObjectIdentity</FormalSpec>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	w "DeleteStart",!
	set status = $$$OK
	
	set zahlungId = $lg(oid,1)
	
	set myId = ""
	&sql(DECLARE CurOpZahlung CURSOR FOR
    		SELECT ID INTO :myId
    		FROM DBDebiKredi.OPZahlung
    		WHERE Zahlung=:zahlungId)
    		
 	&sql(OPEN CurOpZahlung)
 	&sql(FETCH CurOpZahlung)
 	While (SQLCODE = 0) {
	 	
	 	w "DBDebiKredi.Zahlung.%OnDelete - myId: ", myId, !
	 	
	 	set s = ##class(DBDebiKredi.OPZahlung).%DeleteId(myId)
    	if ($$$ISERR(s)) {
	    	set status = s
	    	w "DBDebiKredi.Zahlung.%OnDelete - status: ", s, !
    	}
    	
    	&sql(FETCH CurOpZahlung)
 	}
 	
    &sql(CLOSE CurOpZahlung)
	
	w "Delete Ende",!		
	Quit status
]]></Implementation>
</Method>

<Trigger name="DeleteBetrag">
<Code><![CDATA[	new opZahlungId
	set opZahlungId = {ID*O}	
	
	set myId = ""
	&sql(DECLARE C1 CURSOR FOR
    		SELECT ID INTO :myId
    		FROM DBDebiKredi.OPZahlung
    		WHERE Zahlung=:zahlungId)
    		
 	&sql(OPEN C1)
 	&sql(FETCH C1)
 	While (SQLCODE = 0) {
	 	
	 	do ##class(DBDebiKredi.OPZahlung).%DeleteId(myId)
    	
    	&sql(FETCH C1)
 	}
 	
    &sql(CLOSE C1)]]></Code>
<Event>DELETE</Event>
<Time>AFTER</Time>
<Foreach>row</Foreach>
</Trigger>

<Method name="GetFirstOP">
<ClassMethod>1</ClassMethod>
<FormalSpec>zahlungOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set opOid = ""
	&sql(SELECT TOP 1 OP INTO :opOid FROM DBDebiKredi.OPZahlung WHERE Zahlung=:zahlungOid)
	Quit opOid
]]></Implementation>
</Method>

<Method name="GetZahlung">
<ClassMethod>1</ClassMethod>
<FormalSpec>opOid:%String,valutadatum:%Date,betrag:%Decimal</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set zOid = ""
	
	Set rs = ##class(%Library.ResultSet).%New("DBDebiKredi.AF.ZahlungAF.ZahlungByBetrag")
	Set sc=rs.Execute(opOid,valutadatum,betrag)
	
	Set status = $$$OK
	Set status = rs.Next(.sc)
	if ($$$ISOK(status)) {
		set zOid = rs.Data("Zahlung")
	}
	
	Quit zOid
]]></Implementation>
</Method>

<Method name="GetNextKrediVerbuchungJnr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set maxJnr = 0
	&sql(SELECT MAX(Zahlung->Verbuchungsjnr) INTO :maxJnr 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP IN (SELECT ID 
						FROM DBDebiKredi.OPKredi 
						WHERE Kreditor->Mandant=:MandantOid))
							
	Set maxJnr = maxJnr + 1
	Quit maxJnr
]]></Implementation>
</Method>

<Method name="GetNextDebiVerbuchungJnr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set maxJnr = 0
	&sql(SELECT MAX(Zahlung->Verbuchungsjnr) INTO :maxJnr 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP IN (SELECT ID 
						FROM DBDebiKredi.OPDebi 
						WHERE Debitor->Mandant=:MandantOid))
							
	Set maxJnr = maxJnr + 1
	Quit maxJnr
]]></Implementation>
</Method>

<Method name="GetBankByJnr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Verbuchungsjnr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set myId = ""
	&sql(SELECT TOP 1 Zahlung->Bank Into :myId FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID 
						FROM DBDebiKredi.OPKredi 
						WHERE Kreditor->Mandant=:MandantOid) AND 
						Zahlung->Verbuchungsjnr=:Verbuchungsjnr AND
						NVL(Zahlung->VerrechnungsNr,0)=0)
	if (SQLCODE'=0) {
		set myId = ""
	}					
	Quit myId
]]></Implementation>
</Method>

<Method name="DeleteZahlungByFibuBuch">
<ClassMethod>1</ClassMethod>
<FormalSpec>BuchungOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	Set status = $$$OK
	set myId = ""
	
	&sql(DECLARE C2 CURSOR FOR
    		SELECT ID Into :myId 
    		FROM DBDebiKredi.Zahlung 
    		WHERE FibuBuchung=:BuchungOid)
    		
 	&sql(OPEN C2)
 	&sql(FETCH C2)
 	
 	While (SQLCODE = 0) {
	 	
	 	set s = ##class(DBDebiKredi.Zahlung).%DeleteId(myId)
		if ($$$ISERR(status)) {
			set status = s
		}
		
    	&sql(FETCH C2)
 	}
 	
    &sql(CLOSE C2)
	
	Quit status
]]></Implementation>
</Method>

<Method name="GetNextVerrechnungsNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set maxJnr = 0
	&sql(SELECT MAX(NVL(Zahlung->VerrechnungsNr,0)) INTO :maxJnr 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP IN (SELECT ID 
						FROM DBDebiKredi.OPKredi 
						WHERE Kreditor->Mandant=:MandantOid)
				OR OP IN (SELECT ID 
						FROM DBDebiKredi.OPDebi 
						WHERE Debitor->Mandant=:MandantOid))
							
	Set maxJnr = maxJnr + 1
	Quit maxJnr
]]></Implementation>
</Method>

<Method name="GetKursdifferenzClass">
<ClassMethod>1</ClassMethod>
<FormalSpec>Id:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set betrag = 0
	&sql(SELECT SUM(Kursdifferenz) INTO :betrag FROM OPZahlung WHERE Zahlung=:Id)
	Quit betrag
]]></Implementation>
</Method>

<Method name="GetNextDebiVbJnrManuelle">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set maxJnr = 0
	&sql(SELECT MAX(Zahlung->VerbuchungsjnrManuell) INTO :maxJnr FROM DBDebiKredi.OPZahlung WHERE OP IN (SELECT ID 
				FROM DBDebiKredi.OPDebi 
				WHERE Debitor->Mandant=:MandantOid))
	Set maxJnr = maxJnr + 1
	Quit maxJnr
]]></Implementation>
</Method>

<Method name="GetFirstZahlungOidbyFibubuchung">
<ClassMethod>1</ClassMethod>
<FormalSpec>buchungOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	Set oid = 0
	
	&sql(SELECT ID INTO :oid 
			FROM DBDebiKredi.Zahlung 
			WHERE FibuBuchung=:buchungOid)
	
	Quit oid
]]></Implementation>
</Method>

<Method name="GetBelastungsdatumByJnr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Verbuchungsjnr:%Integer</FormalSpec>
<ReturnType>%Date</ReturnType>
<Implementation><![CDATA[
	set myId = ""
	&sql(SELECT TOP 1 Zahlung->Valutadatum Into :myId 
			FROM DBDebiKredi.OPZahlung 
			WHERE OP IN (SELECT ID 
							FROM DBDebiKredi.OPKredi 
							WHERE Kreditor->Mandant=:MandantOid) AND 
				Zahlung->Verbuchungsjnr=:Verbuchungsjnr AND
				NVL(Zahlung->VerrechnungsNr,0)=0 
			ORDER BY Zahlung->Valutadatum)
	if (SQLCODE'=0) {
		set myId = ""
	}					
	Quit myId
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBDebiKredi.ZahlungD</DataLocation>
<DefaultData>ZahlungDefaultData</DefaultData>
<IdLocation>^DBDebiKredi.ZahlungD</IdLocation>
<IndexLocation>^DBDebiKredi.ZahlungI</IndexLocation>
<StreamLocation>^DBDebiKredi.ZahlungS</StreamLocation>
<Data name="ZahlungDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>ManuelleErfassung</Value>
</Value>
<Value name="3">
<Value>Verbuchungsjnr</Value>
</Value>
<Value name="4">
<Value>Zahlbetrag</Value>
</Value>
<Value name="5">
<Value>SkontoAbzug</Value>
</Value>
<Value name="6">
<Value>FWZahlbetrag</Value>
</Value>
<Value name="7">
<Value>FWSkontoAbzug</Value>
</Value>
<Value name="8">
<Value>OP</Value>
</Value>
<Value name="9">
<Value>FibuKonto</Value>
</Value>
<Value name="10">
<Value>OPZahlung</Value>
</Value>
<Value name="11">
<Value>FibuBuchung</Value>
</Value>
<Value name="12">
<Value>BelegNr</Value>
</Value>
<Value name="13">
<Value>Erfassungsdatum</Value>
</Value>
<Value name="14">
<Value>Valutadatum</Value>
</Value>
<Value name="15">
<Value>Buchungstext1</Value>
</Value>
<Value name="16">
<Value>Buchungstext2</Value>
</Value>
<Value name="17">
<Value>Waehrung</Value>
</Value>
<Value name="18">
<Value>FWFaktor</Value>
</Value>
<Value name="19">
<Value>FWKurs</Value>
</Value>
<Value name="20">
<Value>Typ</Value>
</Value>
<Value name="21">
<Value>Verbucht</Value>
</Value>
<Value name="22">
<Value>Belegdatum</Value>
</Value>
<Value name="23">
<Value>Bank</Value>
</Value>
<Value name="24">
<Value>VerrechnungsNr</Value>
</Value>
<Value name="25">
<Value>VerbuchungsjnrManuell</Value>
</Value>
<Value name="26">
<Value>ErfasserBenutzername</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Bank">
</Property>
<Property name="BelegNr">
</Property>
<Property name="Belegdatum">
</Property>
<Property name="Buchungstext1">
</Property>
<Property name="Buchungstext2">
</Property>
<Property name="ErfasserBenutzername">
</Property>
<Property name="Erfassungsdatum">
</Property>
<Property name="FWFaktor">
</Property>
<Property name="FWKurs">
</Property>
<Property name="FWSkontoAbzug"/>
<Property name="FWSkontoabzug">
</Property>
<Property name="FWZahlbetrag">
</Property>
<Property name="FibuBuchung">
</Property>
<Property name="FibuKonto">
</Property>
<Property name="Kursdifferenz">
</Property>
<Property name="ManuelleErfassung">
</Property>
<Property name="SkontoAbzug"/>
<Property name="Skontoabzug">
</Property>
<Property name="Typ">
</Property>
<Property name="Valutadatum">
</Property>
<Property name="Verbuchungsjnr">
</Property>
<Property name="VerbuchungsjnrManuell">
</Property>
<Property name="VerrechnungsNr">
</Property>
<Property name="Waehrung">
</Property>
<Property name="Zahlbetrag">
</Property>
</Storage>
</Class>
</Export>
