<?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:28:53">
<Class name="DBPlattform.AF.AngebotAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61773,54212.613816</TimeCreated>

<Query name="GetMenge">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,LieferantOid:%String,AbnehmerOid:%String,Datum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT 
		SUM(pos.MengeGeliefert) As Menge
	FROM DBPlattform.BestPos pos 
	JOIN DBPlattform.BestKopf kopf ON pos.BestKopf = kopf.ID
	WHERE kopf.Mandant = :MandantOid 
	AND kopf.Lieferant = :LieferantOid
	AND kopf.Abnehmer = :AbnehmerOid
	AND kopf.Lieferdatum = TO_DATE(:Datum)
	AND pos.Artikel = :ArtikelOid</SqlQuery>
</Query>

<Query name="GetMengeProv">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,LieferantOid:%String,AbnehmerOid:%String,Datum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
		CASE WHEN SUM(pos.MengeBestellung) <> 0 THEN SUM(pos.MengeBestellung) 
		ELSE SUM(pos.MoeglicheLiefermenge) END As Menge
	FROM DBPlattform.BestPos pos 
	JOIN DBPlattform.BestKopf kopf ON pos.BestKopf = kopf.ID
	WHERE kopf.Mandant = :MandantOid 
	AND kopf.Lieferant = :LieferantOid
	AND kopf.Abnehmer = :AbnehmerOid
	AND kopf.Lieferdatum = TO_DATE(:Datum)
	AND pos.Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListeByProduzentVZArtikel">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,ArtikelVon:%String,ArtikelBis:%String,AdresseVon:%String,AdresseBis:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Menge, k.Abnehmer, p.Artikel, k.Lieferant, k.Lieferant->Adresse->Kurzname, k.Lieferant->Adresse->Adressnummer
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND k.Mandant = :MandantOid
	AND k.Abnehmer->Adresse->Adressnummer BETWEEN :AdresseVon AND :AdresseBis
	AND p.Artikel->ArtikelNr BETWEEN :ArtikelVon AND :ArtikelBis]]></SqlQuery>
</Query>

<Query name="ListAngebotsPlanTage">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,Zusatz:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, Menge, k.Abnehmer, p.Artikel, k.Lieferant, p.Artikel->Gebinde, p.Artikel->AnzahlJeGebinde, CONVERT(BIT, NVL(p.IsZusatzangebot,0)) As IsZusatzangebot
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND k.Mandant = :MandantOid
	AND ((:Zusatz = 1) OR (NVL(p.IsZusatzangebot,0) = 0))
	ORDER BY Artikel, Datum]]></SqlQuery>
</Query>

<Query name="ListAngebotsPlanWeek">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,DayDiff:%Integer,Zusatz:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select SUM(NVL(Menge,0)) AS Menge, k.Abnehmer, p.Artikel, k.Lieferant, p.Artikel->Gebinde, p.Artikel->AnzahlJeGebinde, CONVERT(BIT, NVL(p.IsZusatzangebot,0)) As IsZusatzangebot,
	DATEPART(WEEK,DATEADD(DAY, :DayDiff, Datum)) AS Woche,
	DATEPART(YEAR,Datum) AS Jahr
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND k.Mandant = :MandantOid
	AND ((:Zusatz = 1) OR (NVL(p.IsZusatzangebot,0) = 0))
	GROUP BY p.Artikel, k.Abnehmer, k.Lieferant, DATEPART(WEEK,DATEADD(DAY, :DayDiff, Datum)), NVL(p.IsZusatzangebot,0)
	ORDER BY Artikel, Jahr, Woche]]></SqlQuery>
</Query>

<Query name="ListAngebotPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Artikel:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, Menge, k.Abnehmer, p.Artikel, k.Lieferant, p.Artikel->Gebinde, p.Artikel->AnzahlJeGebinde, CONVERT(BIT, NVL(p.IsZusatzangebot,0)) As IsZusatzangebot
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum = {d :PerDatum}
	AND k.Mandant = :MandantOid
	AND (NVL(p.IsZusatzangebot,0) = 0)
	AND p.Artikel = :Artikel
	ORDER BY k.Abnehmer,k.Lieferant]]></SqlQuery>
</Query>

<Query name="ListZusatzangebotPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Artikel:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, Menge, k.Abnehmer, p.Artikel, k.Lieferant, p.Artikel->Gebinde, p.Artikel->AnzahlJeGebinde, CONVERT(BIT, NVL(p.IsZusatzangebot,0)) As IsZusatzangebot
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum = {d :PerDatum}
	AND k.Mandant = :MandantOid
	AND (NVL(p.IsZusatzangebot,0) = 1)
	AND p.Artikel = :Artikel
	ORDER BY k.Abnehmer,k.Lieferant]]></SqlQuery>
</Query>

<Query name="ListAngebotsPlanTageGrp">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,Zusatz:%Boolean</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, SUM(NVL(Menge,0)) as Menge, k.Abnehmer As Kunde, p.Artikel, p.Artikel->Gebinde, p.Artikel->AnzahlJeGebinde, CONVERT(BIT, NVL(p.IsZusatzangebot,0)) As IsZusatzangebot
	FROM DBPlattform.AngebotsPos p
	JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
	WHERE k.Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND k.Mandant = :MandantOid
	AND ((:Zusatz = 1) OR (NVL(p.IsZusatzangebot,0) = 0))
	GROUP BY p.Artikel, Datum, k.Abnehmer, NVL(p.IsZusatzangebot,0)
	ORDER BY Artikel, Datum]]></SqlQuery>
</Query>

<Query name="GetAngebotsmenge">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdressOidVZ:%String,AdressNr:%Integer,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Menge 
	FROM DBPlattform.AngebotsPos pos
	JOIN DBPlattform.AngebotsKopf kopf ON kopf.ID = pos.AngebotsKopf 
	WHERE kopf.Datum = TO_DATE(:Lieferdatum) 
	AND kopf.Lieferant->Adresse->Adressnummer = :AdressNr
		AND kopf.Abnehmer->Adresse->ID = :AdressOidVZ
		AND pos.Artikel = :ArtikelOid
		AND kopf.Mandant = :MandantOid]]></SqlQuery>
</Query>

<Query name="GetAngebotsmengeXNetGui">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,LieferantOid:%Integer,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT CASE WHEN (NVL(:AbnehmerOid,0) = 0) THEN SUM(Menge) ELSE Menge END As Menge
	FROM DBPlattform.AngebotsPos pos
	WHERE pos.AngebotsKopf->Datum = TO_DATE(:Lieferdatum) 
		AND  pos.AngebotsKopf->Lieferant = :LieferantOid
		AND  ((NVL(:AbnehmerOid,0) = 0) OR (NVL(:AbnehmerOid,0) <> 0 AND pos.AngebotsKopf->Abnehmer = :AbnehmerOid))
		AND pos.Artikel = :ArtikelOid
		AND pos.AngebotsKopf->Mandant = :MandantOid]]></SqlQuery>
</Query>

<Query name="GetSumAngMenge">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdressOidVZ:%String,AdressNr:%Integer,Startdatum:%Date,Enddatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(Menge) As SumMenge
	FROM DBPlattform.AngebotsPos pos
	JOIN DBPlattform.AngebotsKopf kopf ON kopf.ID = pos.AngebotsKopf 
	WHERE kopf.Datum BETWEEN TO_DATE(:Startdatum) AND TO_DATE(:Enddatum)
	AND kopf.Lieferant->Adresse->Adressnummer = :AdressNr
		AND kopf.Abnehmer->Adresse->ID = :AdressOidVZ
		AND pos.Artikel = :ArtikelOid
		AND kopf.Mandant = :MandantOid]]></SqlQuery>
</Query>

<Query name="GetSumAngMengeXNetGui">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,LieferantOid:%Integer,Startdatum:%Date,Enddatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(Menge) As SumMenge
	FROM DBPlattform.AngebotsPos pos
	WHERE pos.AngebotsKopf->Datum BETWEEN TO_DATE(:Startdatum) AND TO_DATE(:Enddatum)
	AND  pos.AngebotsKopf->Lieferant = :LieferantOid
		AND ((NVL(:AbnehmerOid,0) = 0) OR (NVL(:AbnehmerOid,0) <> 0 AND  pos.AngebotsKopf->Abnehmer = :AbnehmerOid))
		AND pos.Artikel = :ArtikelOid
		AND  pos.AngebotsKopf->Mandant = :MandantOid]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.AuftragsKopfAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61765,37790.098485</TimeCreated>

<Query name="ListeAuftrIdsByVZ">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,Datum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID
	FROM DBPlattform.AuftragsKopf 
	WHERE Mandant = :MandantOid
	AND Abnehmer = :AbnehmerOid
	AND Lieferdatum = :Datum
	ORDER BY Auftragsdatum, BestellNr</SqlQuery>
</Query>

<Query name="CheckNB">
<Type>%SQLQuery</Type>
<FormalSpec>OidKopf:%String,MandantOid:%String,AbnehmerOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[SELECT 1 As IsNB 
	FROM DBPlattform.AuftragsKopf k 
	WHERE k.%ID = :OidKopf
	AND EXISTS
		(SELECT 1 FROM DBPlattform.AuftragsKopf k2 
		WHERE k2.Mandant = :MandantOid 
		AND	k2.Lieferdatum = TO_DATE(:Lieferdatum)
		AND k2.Abnehmer = :AbnehmerOid
		AND k2.ZeitErstellung < k.Zeiterstellung)]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.AuftragsPosAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61765,40873.48884</TimeCreated>

<Query name="ListeArtikelByKopf">
<Type>%SQLQuery</Type>
<FormalSpec>KopfOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, Artikel->ID As ArtikelId,Artikel->ArtikelNr As ArtikelNr,
	Mengeneinheit, Gebinde, AnzahlGebinde, Menge
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag = :KopfOid
	ORDER BY Artikel->ArtikelNr]]></SqlQuery>
</Query>

<Query name="ListeArtikelByKopfDruck">
<Type>%SQLQuery</Type>
<FormalSpec>KopfOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    SELECT Artikel->ID As ArtikelId, Artikel->ArtikelNr As ArtikelNr, Auftrag->BestellNr as BestellNr,
    KundenSpezArtNr, DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, Artikel->Mandant, :Lang) As Artikeltext,
    Mengeneinheit, Gebinde, AnzahlGebinde, Menge, SaldoBestellpositionen, SaldoGeliefert
    FROM DBPlattform.AuftragsPos
    WHERE Auftrag = :KopfOid AND ((SaldoGeliefert- AnzahlGebinde) <> 0)
    ORDER BY Artikel->ArtikelNr]]></SqlQuery>
</Query>

<Query name="ListePositionenByKopf">
<Type>%SQLQuery</Type>
<FormalSpec>KopfOid:%String,Mandant:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID,
	DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, :Mandant, :Lang) As Artikeltext 
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag = :KopfOid
	ORDER BY Artikeltext, PositionsNr</SqlQuery>
</Query>

<Query name="ListeBudgetTage">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Auftrag->Lieferdatum AS Datum, AnzahlGebinde AS Menge,  Auftrag->Abnehmer as Kunde, Artikel, Artikel->Gebinde, Artikel->AnzahlJeGebinde
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag->Mandant = :MandantOid
	AND Auftrag->Lieferdatum BETWEEN {d :VonDatum} AND {d :BisDatum}
	ORDER BY Artikel, Datum]]></SqlQuery>
</Query>

<Query name="ListeBudgetWoche">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,DayDiff:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Auftrag->Lieferdatum AS Datum,	SUM(NVL(AnzahlGebinde,0)) as Menge,  Auftrag->Abnehmer as Kunde, Artikel, Artikel->Gebinde, Artikel->AnzahlJeGebinde,
	DATEPART(WEEK,DATEADD(DAY, :DayDiff, Auftrag->Lieferdatum)) AS Woche,
	DATEPART(YEAR,Auftrag->Lieferdatum) AS Jahr
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag->Mandant = :MandantOid
	AND Auftrag->Lieferdatum BETWEEN {d :VonDatum} AND {d :BisDatum}
	GROUP BY Artikel, Auftrag->Abnehmer, DATEPART(WEEK,DATEADD(DAY, :DayDiff, Auftrag->Lieferdatum))
	ORDER BY Artikel, Jahr, Woche]]></SqlQuery>
</Query>

<Query name="ListeBudgetTageGrp">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Auftrag->Lieferdatum AS Datum, SUM(NVL(AnzahlGebinde,0)) AS Menge,  Auftrag->Abnehmer as Kunde, Artikel
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag->Mandant = :MandantOid
	AND Auftrag->Lieferdatum BETWEEN {d :VonDatum} AND {d :BisDatum}
	GROUP BY Auftrag->Lieferdatum,  Auftrag->Abnehmer, Artikel
	ORDER BY Artikel, Datum]]></SqlQuery>
</Query>

<Query name="ListPosPerDatumArtikel">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Artikel:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Auftrag->Lieferdatum AS Datum, SUM(NVL(AnzahlGebinde,0)) AS Menge, Auftrag->Abnehmer as Kunde, Artikel
	FROM DBPlattform.AuftragsPos
	WHERE Auftrag->Mandant = :MandantOid
	AND Auftrag->Lieferdatum = {d :PerDatum}
	AND Auftrag->Mandant = :MandantOid
	AND Artikel = :Artikel
	GROUP BY Auftrag->Lieferdatum,  Auftrag->Abnehmer, Artikel
	ORDER BY  Auftrag->Abnehmer->Adresse->Name]]></SqlQuery>
</Query>

<Query name="ListeOnePos">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT ID FROM DBPlattform.AuftragsPos
			WHERE Auftrag->Mandant = :MandantOid
			AND Auftrag->Abnehmer = :AbnehmerOid
			AND Auftrag->BestellNr = :BestellNr
			AND Auftrag->Lieferdatum = :Lieferdatum
			AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.BestKopfAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61773,52558.888134</TimeCreated>

<Query name="GetIdByBestellNr">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,BestellNr:%String,LieferantOid:%String,AbnehmerOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND BestellNr = :BestellNr
	AND Lieferant = :LieferantOid
	AND Abnehmer = :AbnehmerOid</SqlQuery>
</Query>

<Query name="CheckNB">
<Type>%SQLQuery</Type>
<FormalSpec>OidKopf:%String,MandantOid:%String,AbnehmerOid:%String,LieferantOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 1 As IsNB 
	FROM DBPlattform.BestKopf k 
	WHERE k.%ID = :OidKopf
	AND EXISTS
		(SELECT 1 FROM DBPlattform.BestKopf k2 
		WHERE k2.Mandant = :MandantOid 
		AND	k2.Lieferdatum = TO_DATE(:Lieferdatum)
		AND k2.Abnehmer = :AbnehmerOid
		AND k2.Lieferant = :LieferantOid
		AND k2.ZeitErstellung < k.Zeiterstellung)]]></SqlQuery>
</Query>

<Query name="ListeVZByDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,LieferantOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT DISTINCT Abnehmer 
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND Lieferant = :LieferantOid AND Lieferdatum = TO_DATE(:Lieferdatum)</SqlQuery>
</Query>

<Query name="ListeBestellungen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,LieferantOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID, BestellNr 
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND Lieferant = :LieferantOid AND Abnehmer = :AbnehmerOid 
	AND Lieferdatum = TO_DATE(:Lieferdatum)</SqlQuery>
</Query>

<Query name="ListeVZAdrIdByDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,LieferantOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT Abnehmer AS Abnehmer, Abnehmer->Adresse AS AbnehmerAdresse
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND Lieferant = :LieferantOid AND Lieferdatum = TO_DATE(:Lieferdatum)]]></SqlQuery>
</Query>

<Query name="ListeBestellungenXNetGui">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerAdressOid:%String,LieferantOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, BestellNr 
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND Lieferant = :LieferantOid
	AND Abnehmer->Adresse = :AbnehmerAdressOid 
	AND Lieferdatum = TO_DATE(:Lieferdatum)
	AND IsFreigegeben = 1
	AND TotalMengeBestellung <> 0]]></SqlQuery>
</Query>

<Query name="ListeOffeneBestellungenXNetGui">
<Type>%SQLQuery</Type>
<FormalSpec>LieferantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT kopf.id AS ID,
		kopf.Mandant AS MandantId,
		kopf.Abnehmer AS AbnehmerId,
		kopf.Abnehmer->Adresse->ID AS AbnehmerAdressId,
		kopf.Abnehmer->Adresse->Name AS AbnehmerName,
		kopf.Abnehmer->Adresse->Ort AS AbnehmerOrt,
		kopf.BestellNr AS BestellNr,
		kopf.Lieferdatum AS Lieferdatum,
		kopf.DefinitiveBestellung As DefinitiveBestellung,
		CASE WHEN (SUM(moeglicheLiefermenge) > 0) THEN 1 ELSE 0 END AS LiefermengeErfasst,
		kopf.IsAuftragDefinitiv As IsAuftragDefinitiv,
		kopf.ZeitErstellung As ZeitErstellung
	FROM DBPlattform.BestKopf kopf
	JOIN DBPlattform.BestPos pos ON kopf.id = pos.bestKopf
	WHERE kopf.Lieferant = :LieferantOid
	AND kopf.Lieferdatum >= DATEADD('dd', -4, CURRENT_DATE)
	AND kopf.IsFreigegeben = 1
	AND kopf.TotalMengeBestellung <> 0
	group by kopf.id
	order by kopf.Lieferdatum desc]]></SqlQuery>
</Query>

<Query name="ListeLieferantenByVZDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerAdrOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT Lieferant->Adresse As LieferantAdrOid FROM DBPlattform.BestKopf
	WHERE Mandant = :MandantOid 
	AND Abnehmer->Adresse = :AbnehmerAdrOid
	AND Lieferdatum = :Lieferdatum]]></SqlQuery>
</Query>

<Query name="ListeBestellungenByVZAuftrag">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID
	FROM DBPlattform.BestKopf 
	WHERE Mandant = :MandantOid 
	AND Abnehmer = :AbnehmerOid
	AND BestellNr = :BestellNr
	AND Lieferdatum = :Lieferdatum</SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.BestPosAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61776,50250.714391</TimeCreated>

<Query name="ListePositionen">
<Type>%SQLQuery</Type>
<FormalSpec>BestKopfOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
	pos.Artikel As ArtikelId, 
	pos.Artikel->ArtikelNr,
	DBAgrofresh.Artikel_GetArtikeltextClass(pos.Artikel, pos.BestKopf->Mandant, 'de') As Artikeltext,
	pos.Gebinde As GebindeId,
	(DBAgrofresh_SD.Gebinde_GetBezeichnungClass(pos.Gebinde,pos.BestKopf->Mandant,'de')) As Gebinde,
	pos.AnzahlJeGebinde,
	pos.Mengeneinheit As EinheitId, DBAgrofresh_SD.Mengencode_GetTextClass(pos.Mengeneinheit, pos.BestKopf->Mandant, 'de') As Einheit,
	pos.MengeBestellung, pos.MoeglicheLiefermenge, pos.MengeGeliefert,
	(SELECT Menge FROM DBPlattform.AngebotsPos p
		JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf 
		WHERE k.Datum = BestKopf->Lieferdatum 
		AND k.Lieferant = BestKopf->Lieferant
		AND k.Abnehmer = BestKopf->Abnehmer
		AND p.Artikel = pos.Artikel
		AND k.Mandant = BestKopf->Mandant
	) As Angebotsmenge,
	CAST(DBAgrofresh.Preis_GetEngrosPreisPerDatumXNetGui(pos.BestKopf->Mandant, pos.BestKopf->Abnehmer->Mandant, BestKopf->Abnehmer->Adresse, pos.Artikel, BestKopf->Lieferdatum) AS DEC(10,2)) As PreisProd,
	CAST(DBAgrofresh.Preis_GetDetailPreisPerDatumXNetGui(pos.BestKopf->Mandant, pos.BestKopf->Abnehmer->Mandant, BestKopf->Abnehmer->Adresse, pos.Artikel, BestKopf->Lieferdatum) AS DEC(10,2)) As PreisAbnehmer
	FROM DBPlattform.BestPos pos
	WHERE BestKopf = :BestKopfOid AND MengeBestellung <> 0
	ORDER BY Artikeltext]]></SqlQuery>
</Query>

<Query name="ListeOnePos">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,LieferantOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID FROM DBPlattform.BestPos
			WHERE BestKopf->Mandant = :MandantOid
			AND BestKopf->Abnehmer = :AbnehmerOid
			AND BestKopf->Lieferant->Adresse = :LieferantOid
			AND BestKopf->BestellNr = :BestellNr
			AND BestKopf->Lieferdatum = :Lieferdatum
			AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListeMengePositionen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(NVL(MoeglicheLiefermenge,0)) As Saldo FROM DBPlattform.BestPos
		WHERE BestKopf->Mandant = :MandantOid
		AND BestKopf->Abnehmer = :AbnehmerOid
		AND BestKopf->BestellNr = :BestellNr
		AND BestKopf->Lieferdatum = TO_DATE(:Lieferdatum)
		AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListeMengeGeliefertPositionen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT SUM(NVL(MengeGeliefert,0)) As Saldo FROM DBPlattform.BestPos
		WHERE BestKopf->Mandant = :MandantOid
		AND BestKopf->Abnehmer = :AbnehmerOid
		AND BestKopf->BestellNr = :BestellNr
		AND BestKopf->Lieferdatum = TO_DATE(:Lieferdatum)
		AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListeGesamtuebrsichtDruck">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Typ, ArtikelNr, Artikeltext, ArtikelgruppenNr, ArtikelgruppenBez, MengeVZ1, MengeVZ2, MengeVZ3, MengeVZ4, MengeEff FROM(
		Select 0 AS Typ, Artikel->ArtikelNr AS ArtikelNr, DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, Artikel->Mandant, :Lang) As Artikeltext, 
		 	Artikel->Artikelgruppe->ArtikelgruppenNr As ArtikelgruppenNr, DBAgrofresh_SD.Artikelgruppe_GetBezeichnungClass(Artikel->Artikelgruppe->ID, :MandantOid,:Lang) AS ArtikelgruppenBez,
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 1 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 0),0) AS MengeVZ1, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 2 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 0),0) AS MengeVZ2, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 3 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 0),0) AS MengeVZ3, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 4 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 0),0) AS MengeVZ4, 
			SUM(NVL(MengeGeliefert,0)) as MengeEff from DBPlattform.BestPos as b
		where BestKopf->Lieferdatum = {d :PerDatum} and BestKopf->Mandant = :MandantOid and BestKopf->IsNachbestellung = 0
		Group by Artikel->ArtikelNr
		UNION ALL
		Select 1 AS Typ, Artikel->ArtikelNr AS ArtikelNr, DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, Artikel->Mandant, :Lang) As Artikeltext, 
		 	Artikel->Artikelgruppe->ArtikelgruppenNr As ArtikelgruppenNr, DBAgrofresh_SD.Artikelgruppe_GetBezeichnungClass(Artikel->Artikelgruppe->ID, :MandantOid,:Lang) AS ArtikelgruppenBez,
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 1 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 1),0) AS MengeVZ1, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 2 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 1),0) AS MengeVZ2, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 3 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 1),0) AS MengeVZ3, 
			NVL((SELECT SUM(NVL(MengeBestellung,0)) from DBPlattform.BestPos where BestKopf->Abnehmer->Adresse->IndSel5->Code = 4 AND BestKopf->Lieferdatum = {d :PerDatum} and Artikel = b.Artikel and BestKopf->IsNachbestellung = 1),0) AS MengeVZ4, 
			SUM(NVL(MengeGeliefert,0)) as MengeEff from DBPlattform.BestPos as b
		where BestKopf->Lieferdatum = {d :PerDatum} and BestKopf->Mandant = :MandantOid and BestKopf->IsNachbestellung = 1
		Group by Artikel->ArtikelNr
		UNION ALL
		Select 2 AS Typ, Artikel->ArtikelNr AS ArtikelNr, DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, Artikel->Mandant, :Lang) As Artikeltext, 
		 	Artikel->Artikelgruppe->ArtikelgruppenNr As ArtikelgruppenNr, DBAgrofresh_SD.Artikelgruppe_GetBezeichnungClass(Artikel->Artikelgruppe->ID, :MandantOid,:Lang) AS ArtikelgruppenBez,
			NVL((SELECT SUM(NVL(AnzahlGebinde,0)) from DBAgrofreshEK.Bestellungspos where Bestellungskopf->Abnehmner->Adresse->IndSel5->Code = 1 AND Bestellungskopf->Annahmedatum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ1, 
			NVL((SELECT SUM(NVL(AnzahlGebinde,0)) from DBAgrofreshEK.Bestellungspos where Bestellungskopf->Abnehmner->Adresse->IndSel5->Code = 2 AND Bestellungskopf->Annahmedatum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ2, 
			NVL((SELECT SUM(NVL(AnzahlGebinde,0)) from DBAgrofreshEK.Bestellungspos where Bestellungskopf->Abnehmner->Adresse->IndSel5->Code = 3 AND Bestellungskopf->Annahmedatum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ3, 
			NVL((SELECT SUM(NVL(AnzahlGebinde,0)) from DBAgrofreshEK.Bestellungspos where Bestellungskopf->Abnehmner->Adresse->IndSel5->Code = 4 AND Bestellungskopf->Annahmedatum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ4, 
			SUM(NVL(MengeGeliefert,0)) as MengeEff from DBPlattform.BestPos as b
		where BestKopf->Lieferdatum = {d :PerDatum} and BestKopf->Mandant = :MandantOid
		Group by Artikel->ArtikelNr
		UNION ALL
		Select 3 AS Typ, Artikel->ArtikelNr AS ArtikelNr, AngebotsKopf->Lieferant->Adresse->Adressnummer || ' ' || AngebotsKopf->Lieferant->Adresse->Name || ', ' || AngebotsKopf->Lieferant->Adresse->Plz || ' ' || AngebotsKopf->Lieferant->Adresse->Ort As Artikeltext, 
		 	Artikel->Artikelgruppe->ArtikelgruppenNr As ArtikelgruppenNr, DBAgrofresh_SD.Artikelgruppe_GetBezeichnungClass(Artikel->Artikelgruppe->ID, :MandantOid,:Lang) AS ArtikelgruppenBez,
			NVL((SELECT SUM(NVL(Saldo,0)) from DBPlattform.AngebotsPos where AngebotsKopf->Abnehmer->Adresse->IndSel5->Code = 1 AND AngebotsKopf->Datum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ1, 
			NVL((SELECT SUM(NVL(Saldo,0)) from DBPlattform.AngebotsPos where AngebotsKopf->Abnehmer->Adresse->IndSel5->Code = 2 AND AngebotsKopf->Datum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ2, 
			NVL((SELECT SUM(NVL(Saldo,0)) from DBPlattform.AngebotsPos where AngebotsKopf->Abnehmer->Adresse->IndSel5->Code = 3 AND AngebotsKopf->Datum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ3, 
			NVL((SELECT SUM(NVL(Saldo,0)) from DBPlattform.AngebotsPos where AngebotsKopf->Abnehmer->Adresse->IndSel5->Code = 4 AND AngebotsKopf->Datum = {d :PerDatum} and Artikel = b.Artikel),0) AS MengeVZ4, 
			0 as MengeEff from DBPlattform.AngebotsPos as b
		where AngebotsKopf->Datum = {d :PerDatum} AND AngebotsKopf->Mandant = :MandantOid
		AND NVL((SELECT SUM(NVL(MengeGeliefert,0))-SUM(NVL(MengeBestellung,0)) FROM DBPlattform.BestPos where BestKopf->Lieferdatum = {d :PerDatum} AND Artikel = b.Artikel),0) <> 0
		Group by Artikel->ArtikelNr, AngebotsKopf->Lieferant
	)
	ORDER by ArtikelNr, Typ]]></SqlQuery>
</Query>

<Query name="ListeMengePositionenLieferant">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, 
			BestKopf->Lieferant->Adresse As AdressId,
			BestKopf->Lieferant->Adresse->Adressnummer As Adressnummer,
			BestKopf->Lieferant->Adresse->Kurzname As Kurzname,
			BestKopf->Lieferant->Adresse->Plz As Plz,
			BestKopf->Lieferant->Adresse->Ort As Ort,
			BestKopf->Lieferant->Adresse->Name As Name,
			MoeglicheLiefermenge, 
			MengeBestellung 
	FROM DBPlattform.BestPos
	WHERE BestKopf->Mandant = :MandantOid
		AND BestKopf->Abnehmer = :AbnehmerOid
		AND BestKopf->BestellNr = :BestellNr
		AND BestKopf->Lieferdatum = {d :Lieferdatum}
		AND Artikel = :ArtikelOid
	ORDER BY BestKopf->Lieferant->Adresse->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeMengePosInklUnbestaetigte">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[     SELECT SUM(NVL(MoeglicheLiefermenge,MengeBestellung)) As Saldo FROM DBPlattform.BestPos
     WHERE BestKopf->Mandant = :MandantOid
     AND BestKopf->Abnehmer = :AbnehmerOid
     AND BestKopf->BestellNr = :BestellNr
     AND BestKopf->Lieferdatum = :Lieferdatum
     AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListeAngebotBestellungenDruck">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,VonDatum:%Date,BisDatum:%Date,ArtikelVon:%String,ArtikelBis:%String,AdresseVon:%Integer,AdresseBis:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID,
	    pos.BestKopf->Abnehmer AS AbnehmerId,
        pos.BestKopf->Abnehmer->Adresse->Name AS AbnehmerName,
        pos.BestKopf->Abnehmer->Adresse->Ort AS AbnehmerOrt,
		pos.Artikel As ArtikelId, 
		pos.Artikel->ArtikelNr,
		DBAgrofresh.Artikel_GetArtikeltextClass(pos.Artikel, pos.BestKopf->Mandant, :Lang) As Artikeltext,
		DBAgrofresh_SD.Mengencode_GetTextClass(pos.Mengeneinheit, pos.BestKopf->Mandant, :Lang) As Einheit,
        CASE WHEN pos.BestKopf->IsNachbestellung = 0 THEN pos.MengeBestellung ELSE 0 END AS HauptBestMenge,
        CASE WHEN pos.BestKopf->IsNachbestellung = 0 THEN 0 ELSE pos.MengeBestellung END AS NachBestMenge
	FROM DBPlattform.BestPos pos
	WHERE pos.BestKopf->Mandant = :MandantOid
	AND pos.BestKopf->Lieferdatum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND pos.BestKopf->Abnehmer->Adresse->Adressnummer BETWEEN :AdresseVon AND :AdresseBis
	AND pos.Artikel->ArtikelNr BETWEEN :ArtikelVon AND :ArtikelBis]]></SqlQuery>
</Query>

<Query name="ListePosIds">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date,ArtikelOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID FROM DBPlattform.BestPos
			WHERE BestKopf->Mandant = :MandantOid
			AND BestKopf->Abnehmer = :AbnehmerOid
			AND BestKopf->BestellNr = :BestellNr
			AND BestKopf->Lieferdatum = :Lieferdatum
			AND Artikel = :ArtikelOid]]></SqlQuery>
</Query>

<Query name="ListePosIdsByKopfId">
<Type>%SQLQuery</Type>
<FormalSpec>BestKopfOid:%String,Mandant:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 
	ID,
	(SELECT ap.PositionsNr 
		FROM DBPlattform.AuftragsPos ap
		WHERE ap.Auftrag->Mandant = bp.BestKopf->Mandant
		AND ap.Auftrag->BestellNr = bp.BestKopf->BestellNr
		AND ap.Auftrag->Lieferdatum = bp.BestKopf->Lieferdatum
		AND ap.Artikel = bp.Artikel) As AuftragsPosNr,
	DBAgrofresh.Artikel_GetArtikeltextClass(bp.Artikel, :Mandant, :Lang) As Artikeltext
	FROM DBPlattform.BestPos bp
	WHERE BestKopf = :BestKopfOid
	ORDER BY Artikeltext, AuftragsPosNr]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.BestandAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>62087,55048.633988</TimeCreated>

<Query name="ListeBestandAktuell">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,PerDatum:%Date,Lagerort:%String,Prodart:%String,filterNonBio:%Boolean,Kundenkat:%String,ProduktionsJahr:%Integer,Direktverkauf:%Boolean,Qualitaet:%String,BisArtikelGrp:%Integer,Artikel:%String=""</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[    /*Verfügbare Menge von Chargen (ohne Menge welche in Verarbeitung ist) samt provisorischen Chargen welche aus Verarbeitung entstanden, aber nicht provisorische Kalibrierungen*/
    /*Falls Typ 1 editiert, Typ 6 nachtragen!*/
                   SELECT 1 AS Typ, ID as Charge, '' AS APos, Artikel, NVL(MengeVerfuegbar, 0) AS Menge, NVL(AnzahlGebindeVerfuegbar,0) AS AnzGebinde, 0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0) AND
                   (NVL(Provisorisch, 0) = 0 OR NVL(AusKalibrierung, 0) = 0)
    UNION ALL
    /*MengeDirektverkauf von Chargen*/
                   SELECT 2 AS Typ, ID as Charge, '' AS APos, Artikel, NVL(DirektverkaufVerfuegbar,0) AS Menge, NVL(AnzahlGebDirektverVerfuegbar,0) AS AnzGebinde, 0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE :Direktverkauf = 1 AND Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
    UNION ALL
    /*Bestellte Menge von Chargen welche noch nicht angenommen sind.*/
                   SELECT 3 AS Typ, ID as Charge, '' AS APos, Artikel, 0 AS Menge, 0 AS AnzGebinde, MengeBestellt AS OffeneBest, Bestellt AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) = 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
    UNION ALL
    /*Bestellte Menge von Auftragspositionen welche noch nicht ausgeliefert wurden und Dazugehörige Charge noch nicht angeliefert */
                   SELECT 4 AS Typ, Charge->Charge as Charge, ID AS APos, Artikel, Case NVL(pos.Charge->Charge, "") WHEN "" THEN 0 ELSE  BestellteMenge END AS Menge, Case NVL(pos.Charge->Charge, "") WHEN "" THEN 0 ELSE  BestellteGebinde END  AS AnzGebinde, 0 AS OffeneBest, 0 AS AnzGebOffeneBest, BestellteMenge AS Bestellt, BestellteGebinde AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos pos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= {d :PerDatum}
                   AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  AND 
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((:Kundenkat = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL AND 
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein()
                   /*AND NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = pos.Charge->Charge), 1) = 0 */
    UNION ALL
    /*Bestellte Menge von Auftragspositionen welche ausgeliefert wurden aber noch nicht angeliefert muss bei den offenen Bestellungen wieder direkt abgezogen werden*/
                   SELECT 5 AS Typ, Charge->Charge as Charge, ID AS APos, Artikel, 0 AS Menge, 0 AS AnzGebinde, ((-1)*BestellteMenge) AS OffeneBest, ((-1)*BestellteGebinde) AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos pos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= {d :PerDatum} AND  ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((:Kundenkat = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL
                   AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND NVL(Auftragskopf->Auftragsstatus,0) >= DBAgrofresh.Konst_AuftragstatusLieferschein() AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = pos.Charge->Charge), 1) = 0
    UNION ALL
    /*Chargen welche Provisorisch in Mischposten sind direkt abziehen, da sie bereits beim Mischposten dazuaddiert wurden*/
                   SELECT 8 AS Typ, ID as Charge, '' AS APos, Artikel, -1 * NVL(MengeEingang, 0) AS Menge, -1 * NVL(AnzahlGebinde,0) AS AnzGebinde, 0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0) AND
                   NVL(Provisorisch, 0) = 1 AND (Mischposten is not NULL)]]></SqlQuery>
</Query>

<Query name="ListeBestandPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,PerDatum:%Date,Lagerort:%String,Prodart:%String,filterNonBio:%Boolean,Kundenkat:%String,ProduktionsJahr:%Integer,Direktverkauf:%Boolean,Qualitaet:%String,BisArtikelGrp:%Integer,Artikel:%String=""</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	
    /*Eingangsmengen von Chargen*/
                   SELECT  1 AS Typ, ID as Charge, '' AS APos, Artikel, MengeEingang AS Menge, 
                   CASE NVL(MengeJeGebinde,1)WHEN 0 THEN MengeEingang ELSE MengeEingang /  NVL(MengeJeGebinde,1) END AS AnzGebinde,
                   0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND (NVL(ErledigtDatum,TO_DATE(0)) = TO_DATE(0) OR (ErledigtDatum >= :PerDatum) ) 
                   AND NVL(Mischposten,'') = '' AND NVL(RetourenPos,0) = 0
    UNION ALL
    /*Bestellte Menge von Chargen noch nicht angenommen sind.*/
                   SELECT 3 AS Typ, ID as Charge, '' AS APos, Artikel, 0 AS Menge, 0 AS AnzGebinde, MengeBestellt AS OffeneBest, 
                   CASE NVL(MengeJeGebinde,1)WHEN 0 THEN MengeBestellt ELSE MengeBestellt /  NVL(MengeJeGebinde,1) END AS AnzGebOffeneBest, 
                   0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0 AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID AND Bestellungskopf->Annahmedatum < {d :PerDatum}), 1) = 0
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0) AND (NVL(ErledigtDatum,TO_DATE(0)) = TO_DATE(0) or ErledigtDatum >= :PerDatum)
    UNION ALL
    /*Bestellte Menge von Auftragspositionen welche noch nicht ausgeliefert wurden und Dazugehörige Charge noch nicht angeliefert */
                   SELECT 4 AS Typ, Charge->Charge as Charge, ID AS APos, Artikel, 0 AS Menge, 0  AS AnzGebinde, 
                   0 AS OffeneBest, 0 AS AnzGebOffeneBest, BestellteMenge AS Bestellt, BestellteGebinde AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos pos
                   WHERE Auftragskopf->Mandant = :MandantOid 
                   AND (Auftragskopf->Auftragsdatum <= {d :PerDatum}) 
                   AND ((Auftragskopf->Lieferdatum > {d :PerDatum}) OR (NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein()))
                   AND NVL(Charge->Charge->RetourenPos,0) = 0
                   AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  AND 
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((:Kundenkat = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL AND 
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
    UNION ALL
    /*Chargenausgänge welche seit dem weg sind abziehen*/
                   SELECT 6 AS Typ, Charge->Charge AS Charge, ID AS APos, Artikel, ((-1)*Menge) AS Menge, 
                   ((-1)*(CASE NVL(Charge->Charge->MengeJeGebinde,1) WHEN 0 THEN Menge ELSE Menge /  NVL(Charge->Charge->MengeJeGebinde,1)END)) AS AnzGebinde, 
                   0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Charge->Charge->Produktionsart, Charge->Charge->Qualitaet, Charge->Charge->Herkunft, Charge->Charge->Gebinde, Charge->Charge->Lagerort, Charge->Charge->MengeJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos pos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= {d :PerDatum} AND  ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   Charge->Charge->EingangsDatum <= {d :PerDatum} AND
                   NVL(Charge->Charge->RetourenPos,0) = 0  AND
                   ((NVL(:Prodart, "") = "") OR (Charge->Charge->Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Charge->Charge->Produktionsart->Bio = 0)) AND 
                   ((NVL(:Qualitaet, "") = "") OR (Charge->Charge->Qualitaet = :Qualitaet)) AND ((:Kundenkat = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL
                   AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND NVL(Auftragskopf->Auftragsstatus,0) >= DBAgrofresh.Konst_AuftragstatusLieferschein()
                   AND (NVL(Charge->Charge->ErledigtDatum,TO_DATE(0)) = TO_DATE(0) or Charge->Charge->ErledigtDatum >= :PerDatum)
                   
    UNION ALL
    /*Verarbeitungen welche seit dem weg sind abziehen*/
                   SELECT 7 AS Typ, ID as Charge, '' AS APos, Artikel AS Artikel,
                   (SELECT SUM((-1)*NVL(Menge,0)) FROM DBAGrofreshEK.VerarbAuftrag WHERE Charge = ce.ID AND Lieferdatum <= {d :PerDatum}) AS Menge, 
                   (SELECT SUM((-1)*NVL(AnzahlGebinde,0)) FROM DBAGrofreshEK.VerarbAuftrag WHERE Charge = ce.ID AND Lieferdatum <= {d :PerDatum}) AS AnzGebinde, 
                   0 AS OffeneBest, 0 AS AnzGebOffeneBest, 0 AS Bestellt, 0 AS AnzGebBest, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Lagerort, MengeJeGebinde as MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) 
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND (NVL(ErledigtDatum,TO_DATE(0)) = TO_DATE(0) or ErledigtDatum >= :PerDatum) AND NVL(Mischposten,'') = '']]></SqlQuery>
</Query>

<Query name="ListeBestandProduzentAktuell">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,Lagerort:%String,Prodart:%String,Qualitaet:%String,Herkunft:%String,Gebinde:%String,Kundenkat:%String,ProduktionsJahr:%Integer,Direktverkauf:%Boolean,AnzJeGebinde:%Decimal,Artikel:%String=""</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[
    Select PositionsNr, Name, AdrNr, PLZ, Ort, Artikel as ParentId, Artikel->ArtikelNr AS "ArtikelNr", DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, :MandantOid, :Lang) AS Artikeltext,
    			Menge, OffeneBest, Bestellt, 
    			Einheit, DBAgrofresh_SD.Hilfstexte_GetTextClass(Einheit, :MandantOid, :Lang) AS "Einheit.Text",
				Produktionsart, DBAgrofresh_SD.Hilfstexte_GetTextClass(Produktionsart, :MandantOid, :Lang) AS "Produktionsart.Text",
				Qualitaet, DBAgrofresh_SD.Hilfstexte_GetTextClass(Qualitaet, :MandantOid, :Lang) AS "Qualitaet.Text",
				Herkunft, DBAgrofresh_SD.Hilfstexte_GetTextClass(Herkunft, :MandantOid, :Lang) As "Herkunft.Text", 
                Gebinde, DBAgrofresh_SD.Gebinde_GetBezeichnungClass(Gebinde, :MandantOid, :Lang) As "Gebinde.Text", 
                Abzugstyp, DBAgrofresh_SD.Hilfstexte_GetTextClass(Abzugstyp, :MandantOid, :Lang) As "Abzugstyp.Text", 
                Lagerort, DBAgrofresh_SD.Hilfstexte_GetTextClass(Lagerort, :MandantOid, :Lang) As "Lagerort.Text", 
                MengeJeGebinde, (Menge+OffeneBest) AS Total, (Menge+OffeneBest-Bestellt) AS ZuVerkaufen, (Menge-Bestellt) AS Verfuegbar
    FROM (
    /*Verfügbare Menge von Chargen (ohne Menge welche in Verarbeitung ist) samt provisorischen Chargen welche aus Verarbeitung entstanden*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
                   Artikel, AnzahlGebindeVerfuegbar AS Menge, 0 AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND 
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND 
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /*MengeDirektverkauf von Chargen*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
                   Artikel, NVL(AnzahlGebDirektverVerfuegbar,0) AS Menge, 0 AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE
                   Mandant = :MandantOid AND :Direktverkauf = 1 AND
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /*Bestellte Menge von Chargen welche noch nicht angenommen sind.*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
				   Artikel, 0 AS Menge, Bestellt AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((:Qualitaet = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((:Gebinde = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) = 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /* Bestellte Menge von Verkauf, welche noch nicht ausgeliefert wurde */
                   SELECT Charge->Charge->PositionsNr AS PositionsNr, 
                   CASE NVL(Charge->Charge, "") WHEN "" THEN DBAdressen.Adresse_GetName(Auftragskopf->Adresse->Adresse->Adresscode, Auftragskopf->Adresse->Adresse->Name, Auftragskopf->Adresse->Adresse->VornameZusatz1, 1)
                   ELSE DBAdressen.Adresse_GetName(Charge->Charge->Lieferant->Adresse->Adresscode, Charge->Charge->Lieferant->Adresse->Name, Charge->Charge->Lieferant->Adresse->VornameZusatz1, 1) END AS Name,
				   CASE NVL(Charge->Charge, "") WHEN "" THEN Auftragskopf->Adresse->Adresse->Adressnummer ELSE Charge->Charge->Lieferant->Adresse->Adressnummer END AS AdrNr,
				   CASE NVL(Charge->Charge, "") WHEN "" THEN Auftragskopf->Adresse->Adresse->Plz ELSE Charge->Charge->Lieferant->Adresse->Plz END AS PLZ,
				   CASE NVL(Charge->Charge, "") WHEN "" THEN Auftragskopf->Adresse->Adresse->Ort ELSE Charge->Charge->Lieferant->Adresse->Ort END AS Ort,
				   Artikel, Case NVL(Charge->Charge,"") WHEN "" THEN 0 ELSE BestellteGebinde END AS Menge, 0 AS OffeneBest, BestellteGebinde AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= CURRENT_DATE
                   AND  NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() AND 
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL AND
                   (AnzahlJeGebinde = :AnzJeGebinde) AND 
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
    )
    WHERE NVL(Menge,0) <> 0 OR NVL(OffeneBest,0) <> 0 OR NVL(Bestellt,0) <> 0]]></SqlQuery>
</Query>

<Query name="ListeBestandProduzentPerDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,PerDatum:%Date,Lagerort:%String,Prodart:%String,Qualitaet:%String,Herkunft:%String,Gebinde:%String,Kundenkat:%String,ProduktionsJahr:%Integer,Direktverkauf:%Boolean,AnzJeGebinde:%Decimal,Artikel:%String=""</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[
    Select PositionsNr, Name, AdrNr, PLZ, Ort, Artikel as ParentId, Artikel->ArtikelNr AS "ArtikelNr", DBAgrofresh.Artikel_GetArtikeltextClass(Artikel, :MandantOid, :Lang) AS Artikeltext,
    			Menge, OffeneBest, Bestellt, 
    			Einheit, DBAgrofresh_SD.Hilfstexte_GetTextClass(Einheit, :MandantOid, :Lang) AS "Einheit.Text",
				Produktionsart, DBAgrofresh_SD.Hilfstexte_GetTextClass(Produktionsart, :MandantOid, :Lang) AS "Produktionsart.Text",
				Qualitaet, DBAgrofresh_SD.Hilfstexte_GetTextClass(Qualitaet, :MandantOid, :Lang) AS "Qualitaet.Text",
				Herkunft, DBAgrofresh_SD.Hilfstexte_GetTextClass(Herkunft, :MandantOid, :Lang) As "Herkunft.Text", 
                Gebinde, DBAgrofresh_SD.Gebinde_GetBezeichnungClass(Gebinde, :MandantOid, :Lang) As "Gebinde.Text", 
                Abzugstyp, DBAgrofresh_SD.Hilfstexte_GetTextClass(Abzugstyp, :MandantOid, :Lang) As "Abzugstyp.Text", 
                Lagerort, DBAgrofresh_SD.Hilfstexte_GetTextClass(Lagerort, :MandantOid, :Lang) As "Lagerort.Text", 
                MengeJeGebinde, (Menge+OffeneBest) AS Total, (Menge+OffeneBest-Bestellt) AS ZuVerkaufen, (Menge-Bestellt) AS Verfuegbar
    FROM (
    /*Verfügbare Menge von Chargen (ohne Menge welche in Verarbeitung ist) samt provisorischen Chargen welche aus Verarbeitung entstanden*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
                   Artikel, DBAgrofreshEK.ChargenEingang_GetAnzGebVerfPerDatumClass(ce.ID, {d :PerDatum}) AS Menge, 0 AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND 
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND 
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /*Bestellte Menge von Auftragspositionen von welchen die Charge angeliefert wurde (fehlt in Verfügbare Menge von Charge) im Verkauf jedoch noch nicht geliefert*/
                   SELECT Charge->Charge->PositionsNr AS PositionsNr, DBAdressen.Adresse_GetName(Charge->Charge->Lieferant->Adresse->Adresscode, Charge->Charge->Lieferant->Adresse->Name, Charge->Charge->Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Charge->Charge->Lieferant->Adresse->Adressnummer AS AdrNr, Charge->Charge->Lieferant->Adresse->Plz AS PLZ, Charge->Charge->Lieferant->Adresse->Ort AS Ort,
				   Artikel, BestellteGebinde AS Menge, 0 AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos pos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= {d :PerDatum}
                   AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort)) AND NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() AND 
                   ((NVL(:Prodart, "") = "") OR (Produktionsart = :Prodart)) AND ((:filterNonBio = 0) OR (Produktionsart->Bio = 0)) AND 
                   ((NVL(:Qualitaet, "") = "") OR (Qualitaet = :Qualitaet)) AND ((:Kundenkat = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL AND Charge IS NOT NULL AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
                   AND (Artikel->Artikelgruppe->ArtikelgruppenNr <= :BisArtikelGrp OR NVL(:BisArtikelGrp,0) = 0)
                   AND (NVL(Charge->Charge->MengeVerfuegbar,1) = 0) AND
                   (AnzahlJeGebinde = :AnzJeGebinde) AND 
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = pos.Charge->Charge), 1) > 0
    UNION ALL         
    /*MengeDirektverkauf von Chargen*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
                   Artikel, NVL(AnzahlGebDirektverVerfuegbar,0) AS Menge, 0 AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE :Direktverkauf = 1 AND
                   Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND 
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND 
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /*Bestellte Menge von Chargen welche noch nicht angenommen sind.*/
                   SELECT PositionsNr, DBAdressen.Adresse_GetName(Lieferant->Adresse->Adresscode, Lieferant->Adresse->Name, Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Lieferant->Adresse->Adressnummer AS AdrNr, Lieferant->Adresse->Plz AS PLZ, Lieferant->Adresse->Ort AS Ort,
				   Artikel, 0 AS Menge, Bestellt AS OffeneBest, 0 AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, MengeJeGebinde
                   FROM DBAgrofreshEK.ChargenEingang ce
                   WHERE Mandant = :MandantOid AND EingangsDatum <= {d :PerDatum} AND
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((:Qualitaet = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((:Gebinde = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((:Kundenkat = "") OR (Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((OriginalCharge is null) AND(Jahr = :ProduktionsJahr)) OR ((OriginalCharge is not null) AND (OriginalCharge->Jahr = :ProduktionsJahr))) AND
                   NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) = 0 AND
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel)) AND 
                   (MengeJeGebinde = :AnzJeGebinde) AND NVL(RetourenPos,0) = 0
    UNION ALL
    /* Bestellte Menge von Verkauf, welche noch nicht ausgeliefert wurde */
                   SELECT Charge->Charge->PositionsNr AS PositionsNr, DBAdressen.Adresse_GetName(Charge->Charge->Lieferant->Adresse->Adresscode, Charge->Charge->Lieferant->Adresse->Name, Charge->Charge->Lieferant->Adresse->VornameZusatz1, 1) AS Name,
				   Charge->Charge->Lieferant->Adresse->Adressnummer AS AdrNr, Charge->Charge->Lieferant->Adresse->Plz AS PLZ, Charge->Charge->Lieferant->Adresse->Ort AS Ort,
				   Artikel, 0 AS Menge, 0 AS OffeneBest, BestellteGebinde AS Bestellt, Artikel->Mengeneinheit as Einheit,
                   Produktionsart, Qualitaet, Herkunft, Gebinde, Abzugstyp, Lagerort, AnzahlJeGebinde as MengeJeGebinde
                   FROM DBAgrofresh.Auftragspos
                   WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum <= {d :PerDatum}
                   AND  NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() AND 
                   (((NVL(:Lagerort, "") = "") AND (Lagerort is NULL))  OR (Lagerort = :Lagerort)) AND
                   (((NVL(:Prodart, "") = "") AND (Produktionsart is NULL)) OR (Produktionsart = :Prodart)) AND 
                   (((NVL(:Qualitaet, "") = "") AND (Qualitaet is NULL)) OR (Qualitaet = :Qualitaet)) AND 
                   (((NVL(:Herkunft, "") = "") AND (Herkunft is NULL)) OR (Herkunft = :Herkunft)) AND
                   (((NVL(:Gebinde, "") = "") AND (Gebinde is NULL)) OR (Gebinde = :Gebinde)) AND 
                   ((NVL(:Kundenkat, "") = "") OR (Charge->Charge->Lieferant->Adresse->Kundenkategorie = :Kundenkat)) AND
                   ((:ProduktionsJahr = 0) OR ((Charge->Charge->OriginalCharge is null) AND(Charge->Charge->Jahr = :ProduktionsJahr)) OR ((Charge->Charge->OriginalCharge is not null) AND (Charge->Charge->OriginalCharge->Jahr = :ProduktionsJahr)))
                   AND Artikel IS NOT NULL AND Charge IS NOT NULL AND
                   (AnzahlJeGebinde = :AnzJeGebinde) AND 
                   ((NVL(:Artikel, "") = "") OR (Artikel = :Artikel))
    )
    WHERE NVL(Menge,0) <> 0 OR NVL(OffeneBest,0) <> 0 OR NVL(Bestellt,0) <> 0]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.BudgetAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>62004,59630.586809</TimeCreated>

<Query name="ListeTage">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, Menge, Kunde, Artikel, Artikel->Gebinde, Artikel->AnzahlJeGebinde
	FROM DBPlattform.Budget
	WHERE Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND Mandant = :MandantOid
	ORDER BY Artikel, Datum]]></SqlQuery>
</Query>

<Query name="ListeWochen">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,VonDatum:%Date,BisDatum:%Date,DayDiff:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select SUM(NVL(Menge,0)) AS Menge, Kunde, Artikel, Artikel->Gebinde, Artikel->AnzahlJeGebinde,
	DATEPART(WEEK,DATEADD(DAY, :DayDiff, Datum)) AS Woche,
	DATEPART(YEAR,Datum) AS Jahr
	FROM DBPlattform.Budget
	WHERE Datum BETWEEN {d :VonDatum} AND {d :BisDatum}
	AND Mandant = :MandantOid
	GROUP BY Artikel, Kunde, DATEPART(WEEK,DATEADD(DAY, :DayDiff, Datum))
	ORDER BY Artikel, Jahr, Woche]]></SqlQuery>
</Query>

<Query name="ListeByArtikelDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Artikel:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	Select Datum, Menge, Kunde AS AdrOid, Kunde->Adressnummer AS AdrNr, Artikel,
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = b.Kunde AND Auftrag->Lieferdatum = CAST(DATEADD('week',-1,{d :PerDatum}) AS DATE)) AS VWO1,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = b.Kunde AND Auftrag->Lieferdatum = CAST(DATEADD('week',-2,{d :PerDatum}) AS DATE)) AS VWO2,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = b.Kunde AND Auftrag->Lieferdatum = CAST(DATEADD('week',-3,{d :PerDatum}) AS DATE)) AS VWO3,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = b.Kunde AND Auftrag->Lieferdatum = CAST(DATEADD('year',-1,{d :PerDatum}) AS DATE)) AS VJ
	FROM DBPlattform.Budget b
	WHERE b.Datum = {d :PerDatum}
	AND b.Mandant = :MandantOid
	AND b.Artikel = :Artikel
	
	UNION 
	
	SELECT
	NULL AS Datum, 0 AS Menge, Adresse AS AdrOid, Adresse->Adressnummer AS AdrNr, NULL AS Artikel,
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-1,{d :PerDatum}) AS DATE)) AS VWO1,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-2,{d :PerDatum}) AS DATE)) AS VWO2,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-3,{d :PerDatum}) AS DATE)) AS VWO3,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = :Artikel AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('year',-1,{d :PerDatum}) AS DATE)) AS VJ
	FROM DBDebiKredi.Debitor d 
	WHERE d.Adresse->Mandant = :MandantOid
	AND LENGTH(d.WebEdiId) > 0
	AND Adresse NOT IN (SELECT Kunde AS ID FROM DBPlattform.Budget 
		WHERE Datum = {d :PerDatum}
		AND Mandant = :MandantOid
		AND Artikel = :Artikel)
	ORDER BY AdrNr]]></SqlQuery>
</Query>

<Query name="ListeLeereArtikelDatum">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT
	Adresse AS AdrOid, Adresse->Adressnummer AS AdrNr, a.ID AS Artikel,
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = a.ID AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-1,{d :PerDatum}) AS DATE)) AS VWO1,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = a.ID AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-2,{d :PerDatum}) AS DATE)) AS VWO2,	
	(Select SUM(NVL(AnzahlGebinde,0)) From DBPlattform.AuftragsPos s WHERE s.Artikel = a.ID AND s.Auftrag->Abnehmer->Adresse = d.Adresse AND Auftrag->Lieferdatum = CAST(DATEADD('week',-3,{d :PerDatum}) AS DATE)) AS VWO3
	FROM DBDebiKredi.Debitor d CROSS JOIN DBAgrofresh.Artikel a
	WHERE d.Adresse->Mandant = :MandantOid
	AND LENGTH(d.WebEdiId) > 0
	AND Adresse NOT IN (SELECT Kunde AS ID FROM DBPlattform.Budget 
		WHERE Datum = {d :PerDatum}
		AND Mandant = :MandantOid
		AND Artikel = :Artikel)
	ORDER BY AdrNr]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.LieferanteilAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61669,32093.813373</TimeCreated>

<Query name="GetAnteileByKundeArtikel">
<Type>%SQLQuery</Type>
<FormalSpec>KundeOid:%String,ArtikelOid:%String,MandantOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT 	ID,
			Artikel,
			Kunde,
			Lieferant,
			Mandant,
			Einheit,
			Datum,
			AnteilProzent,
			Nachlieferung,
			MindestmengeNachlief,
			Lieferdifferenz,
			Abzuege,
			KopfId
	FROM 
	(	SELECT ID, Kopf->Artikel, Kopf->Kunde, Lieferant, Kopf->Mandant,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Kopf->Artikel->Mengeneinheit, :MandantOid, :Lang)  as Einheit,
		Kopf->Datum, AnteilProzent, Nachlieferung, MindestmengeNachlief, 
		Lieferdifferenz, Abzuege, Kopf As KopfId
		FROM DBPlattform.LieferanteilDet
		WHERE Kopf->Artikel = :ArtikelOid and Kopf->Kunde = :KundeOid 
		and Kopf->Mandant = :MandantOid 
	
		UNION ALL
	
		SELECT '' As ID, Artikel, Kunde, -1 As Lieferant, Mandant,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Artikel->Mengeneinheit, :MandantOid, :Lang)  as Einheit,
		Datum, 0 As AnteilProzent, 0 As Nachlieferung, 0 As MindestmengeNachlief,
		0 As Lieferdifferenz, NULL As Abzuege, ID As KopfId
		FROM DBPlattform.Lieferanteil
		WHERE 
		HasDetails = 0 AND
		Artikel = :ArtikelOid AND Kunde = :KundeOid AND Mandant = :MandantOid
		
	)
	ORDER BY Datum DESC]]></SqlQuery>
</Query>

<Query name="GetAnteileByKundeArtikelDat">
<Type>%SQLQuery</Type>
<FormalSpec>KundeOid:%String,ArtikelOid:%String,MandantOid:%String,Lang:%String,Datum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, Kopf->Artikel, Kopf->Kunde, Lieferant, Kopf->Mandant,
	DBAgrofresh_SD.Hilfstexte_GetTextClass(Kopf->Artikel->Mengeneinheit, :MandantOid, :Lang)  as Einheit,
	Kopf->Datum, AnteilProzent, Nachlieferung, MindestmengeNachlief, 
	Lieferdifferenz, Abzuege, Kopf As KopfId
	FROM DBPlattform.LieferanteilDet
	WHERE Kopf->Artikel = :ArtikelOid and Kopf->Kunde = :KundeOid 
	and Kopf->Mandant = :MandantOid 
	AND Kopf->Datum = :Datum
	order by Kopf->Datum DESC]]></SqlQuery>
</Query>

<Query name="GetDatumByKundeArtikel">
<Type>%SQLQuery</Type>
<FormalSpec>KundeOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT Datum 
	FROM DBPlattform.Lieferanteil
	WHERE Artikel = :ArtikelOid and Kunde = :KundeOid 
	and Mandant = :MandantOid group by Datum order by Datum DESC</SqlQuery>
</Query>

<Query name="ListeVZArtikelByLieferant">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdressNr:%Integer,AdressOidVZ:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT l.Kopf->Artikel->ID As ArtikelId,
	l.Kopf->Artikel->ArtikelNr As ArtikelNr, 
	DBAgrofresh.Artikel_GetArtikeltextClass(l.Kopf->Artikel, l.Kopf->Mandant, 'de') As Artikeltext,
	p.Gebinde As GebindeId,
	(DBAgrofresh_SD.Gebinde_GetBezeichnungClass(p.Gebinde, l.Kopf->Mandant,'de')) As Gebinde,
	p.AnzahlJeGebinde,
	p.Menge As EinheitId, DBAgrofresh_SD.Mengencode_GetTextClass(p.Menge, l.Kopf->Mandant, 'de') As Einheit,
	(SELECT Menge FROM DBPlattform.AngebotsPos pos
		JOIN DBPlattform.AngebotsKopf kopf ON kopf.ID = pos.AngebotsKopf 
		WHERE kopf.Datum = TO_DATE(:Lieferdatum) 
		AND kopf.Lieferant->Adresse->Adressnummer = :AdressNr
		AND kopf.Abnehmer->Adresse->ID = :AdressOidVZ
		AND pos.Artikel = l.Kopf->Artikel
		AND kopf.Mandant = l.Kopf->Mandant
	) As Angebotsmenge,
	(SELECT Bemerkung FROM DBPlattform.AngebotsPos pos
		JOIN DBPlattform.AngebotsKopf kopf ON kopf.ID = pos.AngebotsKopf 
		WHERE kopf.Datum = TO_DATE(:Lieferdatum) 
		AND kopf.Lieferant->Adresse->Adressnummer = :AdressNr
		AND kopf.Abnehmer->Adresse->ID = :AdressOidVZ
		AND pos.Artikel = l.Kopf->Artikel
		AND kopf.Mandant = l.Kopf->Mandant
	) As Bemerkung
	FROM (((DBPlattform.LieferanteilDet l
	JOIN DBPlattform.Lieferanteil liefK ON l.Kopf = liefK.ID)
	LEFT JOIN DBDebiKredi.Kreditor k ON l.Lieferant = k.Adresse)
	LEFT JOIN DBAgrofreshEK.LieferantenPreis p ON k.ID = p.Lieferant AND 
	liefK.Artikel = p.Artikel)
	WHERE l.Kopf->Mandant = :MandantOid AND l.Lieferant->Adressnummer = :AdressNr
	AND l.Kopf->Artikel->ArtikelAktiv = 1
	AND l.Kopf->Kunde = :AdressOidVZ
	AND l.Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(l.Kopf->Mandant, l.Kopf->Artikel, l.Kopf->Kunde, :Lieferdatum)
	ORDER BY l.Kopf->Artikel->ArtikelNr]]></SqlQuery>
</Query>

<Query name="ListeVZByLieferant">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdressNr:%Integer,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT Kopf->Kunde As AdressOidVZ
	FROM DBPlattform.LieferanteilDet
	WHERE Kopf->Mandant = :MandantOid AND Lieferant->Adressnummer = :AdressNr
	AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumDotNet(Kopf->Artikel, Kopf->Kunde, :Lieferdatum)
	ORDER BY Kopf->Kunde->Adressnummer]]></SqlQuery>
</Query>

<Query name="ListeLieferantenByArtVZCOS">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, Lieferant, Lieferant->Kurzname, AnteilProzent, Nachlieferung, Lieferdifferenz
	FROM DBPlattform.LieferanteilDet 
	WHERE Kopf->Kunde = :AdrOidAbnehmer 
	AND Kopf->Mandant = :MandantOid 
	AND Kopf->Artikel = :ArtikelOid
	AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, :Lieferdatum)]]></SqlQuery>
</Query>

<Query name="ListeLieferantenByArtVZDotNet">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT ID, Lieferant, Lieferant->Kurzname, AnteilProzent, Nachlieferung, Lieferdifferenz
	FROM DBPlattform.LieferanteilDet 
	WHERE Kopf->Kunde = :AdrOidAbnehmer 
	AND Kopf->Mandant = :MandantOid 
	AND Kopf->Artikel = :ArtikelOid
	AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKunde(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, :Lieferdatum)]]></SqlQuery>
</Query>

<Query name="ListeLieferantenByVZDotNet">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT Lieferant As LieferantAdrOid
	FROM DBPlattform.LieferanteilDet 
	WHERE Kopf->Kunde = :AdrOidAbnehmer 
	AND Kopf->Mandant = :MandantOid 
	AND Kopf->Datum = (SELECT MAX(Datum) FROM DBPlattform.Lieferanteil 
						WHERE Artikel =  Kopf->Artikel 
						AND Mandant = :MandantOid 
						AND Kunde = Kopf->Kunde
						AND Datum <= :Lieferdatum)]]></SqlQuery>
</Query>

<Query name="ListeLieferantenByArt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT DISTINCT Lieferant As LieferantAdrOid
	FROM DBPlattform.LieferanteilDet 
	WHERE Kopf->Artikel = :ArtikelOid 
	AND Kopf->Mandant = :MandantOid 
	AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, :Lieferdatum)]]></SqlQuery>
</Query>

<Query name="CheckDetails">
<Type>%SQLQuery</Type>
<FormalSpec>Oid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT 1 FROM DBPlattform.LieferanteilDet WHERE Kopf = :Oid</SqlQuery>
</Query>

<Query name="GetDatumByArtKunde">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT MAX(Datum) As Datum FROM DBPlattform.Lieferanteil 
			WHERE Artikel->ID = :ArtikelOid 
			AND Mandant = :MandantOid 
			AND Kunde = :AdrOidAbnehmer
			AND TO_DATE(Datum) <= :Lieferdatum
			ORDER BY Datum DESC]]></SqlQuery>
</Query>

<Query name="GetDatum">
<Type>%SQLQuery</Type>
<FormalSpec>ArtikelOid:%String,Kunde:%String,Datum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT MAX(Datum) As Datum FROM DBPlattform.Lieferanteil 
			WHERE Artikel = :ArtikelOid AND Kunde = :Kunde AND Datum <= :Datum
			ORDER BY Datum DESC]]></SqlQuery>
</Query>

<Query name="GetKopfId">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,KundeOid:%String,Datum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID FROM DBPlattform.Lieferanteil
		WHERE Mandant = :MandantOid
		AND Artikel = :ArtikelOid
		AND Kunde = :KundeOid
		AND Datum = :Datum</SqlQuery>
</Query>

<Query name="GetLieferdifferenz">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdrOidAbnehmer:%String,AdrOidLieferant:%String,ArtikelOid:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT Lieferdifferenz FROM DBPlattform.LieferanteilDet
		WHERE Kopf->Mandant = :MandantOid AND Kopf->Kunde = :AdrOidAbnehmer
		AND Lieferant = :AdrOidLieferant AND Kopf->Artikel = :ArtikelOid
		AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde,{d :Lieferdatum})]]></SqlQuery>
</Query>

<Query name="ListeVZArtByLiefSmall">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,AdressNr:%Integer,AdressOidVZ:%String,Lieferdatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[	SELECT l.Kopf->Artikel->ID As ArtikelId,
	l.Kopf->Artikel->ArtikelNr As ArtikelNr, 
	DBAgrofresh.Artikel_GetArtikeltextClass(l.Kopf->Artikel, l.Kopf->Mandant, 'de') As Artikeltext
	FROM DBPlattform.LieferanteilDet l
	WHERE l.Kopf->Mandant = :MandantOid AND l.Lieferant->Adressnummer = :AdressNr
	AND l.Kopf->Artikel->ArtikelAktiv = 1
	AND l.Kopf->Kunde = :AdressOidVZ
	AND l.Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(l.Kopf->Mandant, l.Kopf->Artikel, l.Kopf->Kunde, :Lieferdatum)
	ORDER BY l.Kopf->Artikel->ArtikelNr]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.MengendispoAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>62292,55710.462982</TimeCreated>

<Query name="ListePerDatumVK">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Lagerort:%String,VonArtGrp:%Integer,BisArtGrp:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  2 AS Typ, Auftragskopf AS AuftBestOid, Auftragskopf->AuftragsNr AS AuftBestNr, Auftragskopf->Adresse AS DebiKrediOid, Auftragskopf->Adresse->Adresse AS Adresse, Auftragskopf->Adresse->Adresse->Kurzname AS Kurzname,
   			Auftragskopf->Adresse->Adresse->Name AS Name, Auftragskopf->Adresse->Adresse->Ort AS Ort,
    		SUM(Case WHEN NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() THEN 0 ELSE  Menge END) AS Menge,
    		SUM(Case WHEN NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() THEN 0 ELSE  AnzahlGebinde END)  AS AnzGebinde,
     		SUM(BestellteMenge) AS Bestellt, SUM(BestellteGebinde) AS AnzGebBest, Artikel->Mengeneinheit as Einheit, 
     		NVL(Artikel->Einkaufsartikel, Artikel) AS Einkaufsartikel,
     		Artikel AS Artikel, Artikel->ArtikelNr AS ArtikelNr, AnzahlJeGebinde, Gebinde, 
     		SUM(Menge) AS BedarfMenge, SUM(AnzahlGebinde) AS BedarfAnzGebinde
		FROM DBAgrofresh.Auftragspos pos
		WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum = {d :PerDatum}
			AND Artikel is not NULL
			AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  
			AND (Artikel->Artikelgruppe->ArtikelgruppenNr Between :VonArtGrp AND :BisArtGrp OR NVL(:BisArtGrp,0) = 0)
		   
		Group by Artikel, Auftragskopf
		Order by Artikel->ArtikelNr, Auftragskopf->Adresse->Adresse]]></SqlQuery>
</Query>

<Query name="ListePerDatumEK">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Lagerort:%String,VonArtGrp:%Integer,BisArtGrp:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  1 AS Typ, Bestellungskopf AS AuftBestOid, Bestellungskopf->BestellungsNr AS AuftBestNr, Bestellungskopf->Adresse AS DebiKrediOid, Bestellungskopf->Adresse->Adresse AS Adresse, Bestellungskopf->Adresse->Adresse->Kurzname AS Kurzname,
    		Bestellungskopf->Adresse->Adresse->Name AS Name, Bestellungskopf->Adresse->Adresse->Ort AS Ort,
    		SUM(Case WHEN (NVL(BearbeitungsstatusTAS,0) = 0) THEN 0 ELSE Menge END) AS Menge,
    		SUM(Case WHEN (NVL(BearbeitungsstatusTAS,0) = 0) THEN 0 ELSE AnzahlGebinde END) AS AnzGebinde,
     		SUM(BestellteMenge) AS Bestellt, SUM(BestellteGebinde) AS AnzGebBest, Artikel->Mengeneinheit as Einheit, 
     		NVL(Artikel->Einkaufsartikel, Artikel) AS Einkaufsartikel,
     		Artikel AS Artikel, Artikel->ArtikelNr AS ArtikelNr, AnzahlJeGebinde, Gebinde, 
     		SUM(CASE WHEN NVL(BedarfMenge,0) = 0 THEN BestellteMenge ELSE BedarfMenge END) AS BedarfMenge, 
     		SUM(CASE WHEN NVL(BedarfAnzGebinde,0) = 0 THEN BestellteGebinde ELSE BedarfAnzGebinde END) AS BedarfAnzGebinde
		FROM DBAgrofreshEK.Bestellungspos pos
		WHERE Bestellungskopf->Mandant = :MandantOid AND Bestellungskopf->Annahmedatum = {d :PerDatum}
			AND Artikel is not NULL
		  	AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  
		  	AND (Artikel->Artikelgruppe->ArtikelgruppenNr Between :VonArtGrp AND :BisArtGrp OR NVL(:BisArtGrp,0) = 0)
		   
		Group by Artikel, Bestellungskopf
		Order by Artikel->ArtikelNr, Bestellungskopf->Adresse->Adresse]]></SqlQuery>
</Query>

<Query name="ListePerDatumLager">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Lagerort:%String,VonArtGrp:%Integer,BisArtGrp:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  Artikel->Mengeneinheit as Einheit, 
     		Artikel AS Artikel, Artikel->ArtikelNr AS ArtikelNr, Artikel->AnzahlJeGebinde, Artikel->Gebinde
		FROM DBAgrofresh.ArtikelTagesLager
			 WHERE Artikel->Mandant = :MandantOid
			 AND (Artikel->Artikelgruppe->ArtikelgruppenNr Between :VonArtGrp AND :BisArtGrp OR NVL(:BisArtGrp,0) = 0)
		   	 AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  
		   	 AND Datum = {d :PerDatum} AND LagerbestandGebinde > 0]]></SqlQuery>
</Query>

<Query name="ListePerDatumEKArtikel">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,PerDatum:%Date,Lagerort:%String,VonArtGrp:%Integer,BisArtGrp:%Integer</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  Artikel->EinkaufsArtikel->Mengeneinheit as Einheit, 
     		Artikel->EinkaufsArtikel AS Artikel, Artikel->EinkaufsArtikel->ArtikelNr AS ArtikelNr, Artikel->EinkaufsArtikel->AnzahlJeGebinde, Artikel->EinkaufsArtikel->Gebinde
		FROM DBAgrofresh.Auftragspos pos
		WHERE Auftragskopf->Mandant = :MandantOid AND Auftragskopf->Lieferdatum = {d :PerDatum}
			AND Artikel is not NULL AND Artikel->EinkaufsArtikel is not NULL
			AND ((NVL(:Lagerort, "") = "") OR (Lagerort = :Lagerort))  
			AND (Artikel->Artikelgruppe->ArtikelgruppenNr Between :VonArtGrp AND :BisArtGrp OR NVL(:BisArtGrp,0) = 0) 
		Group by Artikel]]></SqlQuery>
</Query>

<Query name="ListePerDatumArtikelEK">
<Type>%SQLQuery</Type>
<FormalSpec>ArtikelOid:%String,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  Bestellungskopf AS BestOid, Bestellungskopf->BestellungsNr, Bestellungskopf->Adresse AS KrediOid, 
    		Bestellungskopf->Adresse->Adresse AS Adresse, 
    		Bestellungskopf->Adresse->Adresse->Adressnummer AS Adressnummer,
    		Case WHEN (NVL(BearbeitungsstatusTAS,0) = 0) THEN 0 ELSE Menge END AS Menge,
    		Case WHEN (NVL(BearbeitungsstatusTAS,0) = 0) THEN 0 ELSE AnzahlGebinde END AS AnzahlGebinde,
     		BestellteMenge, BestellteGebinde, AnzahlJeGebinde, Gebinde, 
     		BedarfMenge, BedarfAnzGebinde,
     		Charge->PositionsNr AS "ChargenNr"
		FROM DBAgrofreshEK.Bestellungspos pos
		WHERE Bestellungskopf->Annahmedatum = {d :PerDatum}
			AND Artikel = :ArtikelOid
		Order by Adressnummer]]></SqlQuery>
</Query>

<Query name="ListePerDatumArtikelVK">
<Type>%SQLQuery</Type>
<FormalSpec>ArtikelOid:%String,PerDatum:%Date</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[            
    SELECT  Auftragskopf AS AuftragOid, Auftragskopf->AuftragsNr, Auftragskopf->Adresse AS DebiOid, 
    		Auftragskopf->Adresse->Adresse AS Adresse, 
    		Auftragskopf->Adresse->Adresse->Adressnummer AS Adressnummer,
    		Case WHEN NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() THEN 0 ELSE  Menge END AS Menge,
    		Case WHEN NVL(Auftragskopf->Auftragsstatus,0) < DBAgrofresh.Konst_AuftragstatusLieferschein() THEN 0 ELSE  AnzahlGebinde END  AS AnzahlGebinde,
     		BestellteMenge, BestellteGebinde, AnzahlJeGebinde, Gebinde, 
     		Auftragskopf->Lieferzeit,
     		Charge->Charge->PositionsNr As "ChargenNr"
		FROM DBAgrofresh.Auftragspos pos
		WHERE Auftragskopf->Lieferdatum = {d :PerDatum}
			AND Artikel = :ArtikelOid
		Order by Adressnummer]]></SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.SD.ZeitrasterAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>61774,60516.289416</TimeCreated>

<Query name="ListeGesamt">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,DebitorOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID, Mandant, Tag, Zeit, AngebotErfasst
 	FROM DBPlattform_SD.Zeitraster
 	WHERE Mandant=:MandantOid
 	AND Debitor = :DebitorOid
 	ORDER BY Tag</SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AF.TransportscheinAF">
<Super>%RegisteredObject</Super>
<TimeChanged>62417,33351</TimeChanged>
<TimeCreated>62143,51449.383554</TimeCreated>

<Query name="ListeDetailsByTransportschein">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String,TransportscheinOid:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery><![CDATA[SELECT 	ID, 
		PositionsNr AS ChargenNr,
		OriginalCharge->PositionsNr AS OriginalChargeNr,
		Status,
		Jahr,
		Lieferant, 
		Lieferant->Adresse->ID As Adresse,
		EingangsDatum, 
		Artikel->ArtikelNr As ArtikelNr, 
		DBAgrofresh.Artikel_GetArtikeltextClass(Artikel->ID, :MandantOid, :Lang) As Artikeltext, 
		Herkunft, 
		AnzahlGebinde,
		MengeJeGebinde,
		MengeEingang,
		Bestellt AS Bestellt,
		Provisorisch,
		Herkunft->IsoKennzeichen AS HerkunftIsoZeichen,
		DBAgrofresh_SD.Gebinde_GetBezeichnungClass(Gebinde, :MandantOid, :Lang) As GebindeText,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Qualitaet, :MandantOid, :Lang) As QualitaetText,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Abzugstyp, :MandantOid, :Lang) As AbzugText,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Herkunft, :MandantOid, :Lang) As HerkunftText,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Produktionsart, :MandantOid, :Lang) As ProduktionsartText,
		DBAgrofresh_SD.Hilfstexte_GetTextClass(Artikel->Mengeneinheit  ,Artikel->Mandant, :Lang) As Einheit
FROM DBAgrofreshEK.ChargenEingang ce
WHERE Mandant = :MandantOid AND Transportschein = :TransportscheinOid AND
NVL((SELECT NVL(Bestellungskopf->BearbeitungsstatusAS,0) FROM DBAgrofreshEK.Bestellungspos WHERE Charge = ce.ID), 1) > 0]]></SqlQuery>
</Query>

<Query name="ListeTransportscheineByMandant">
<Type>%SQLQuery</Type>
<FormalSpec>MandantOid:%String,Lang:%String</FormalSpec>
<SqlProc>1</SqlProc>
<SqlQuery>	SELECT ID, SrcAdresse, DstAdresse, SrcLagerort, DstLagerort,
	DBAgrofresh_SD.Hilfstexte_GetTextClass(DstLagerort, :MandantOid, :Lang) As DstLagerortText,
	ScheinGedruckt, Direktverkauf, TransportNr, Transportdatum
	FROM DBPlattform.Transportschein
	WHERE Mandant = :MandantOid</SqlQuery>
</Query>
</Class>


<Class name="DBPlattform.AngebotsKopf">
<Super>%Persistent,%Populate,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61779,52867.938337</TimeCreated>
<Inheritance>right</Inheritance>

<Parameter name="Alle">
<Default>alle</Default>
</Parameter>

<Parameter name="Gelistet">
<Default>gelistet</Default>
</Parameter>

<Parameter name="Zusatz">
<Default>zusatz</Default>
</Parameter>

<Parameter name="VonBis">
<Default>vonbis</Default>
</Parameter>

<Property name="AngebotsNr">
<Type>%String</Type>
<Required>1</Required>
</Property>

<Index name="AngebotsNrIdx">
<Properties>AngebotsNr,Mandant</Properties>
<Unique>1</Unique>
</Index>

<Property name="Datum">
<Type>%Date</Type>
<Required>1</Required>
</Property>

<Index name="DatumIdx">
<Properties>Datum</Properties>
</Index>

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

<Index name="LieferantIndex">
<Properties>Lieferant</Properties>
</Index>

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

<Index name="AbnehmerIndex">
<Properties>Abnehmer</Properties>
</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>

<Index name="AngebotIndex">
<Properties>Mandant,Abnehmer,Lieferant,Datum</Properties>
<Unique>1</Unique>
</Index>

<Property name="AngebotsPositionen">
<Type>DBPlattform.AngebotsPos</Type>
<Cardinality>children</Cardinality>
<Inverse>AngebotsKopf</Inverse>
<Relationship>1</Relationship>
</Property>

<Method name="GenerateAngebotsNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[	QUIT $INCREMENT(^DBPlattform.AngebotsNr("ID", MandantOid))
]]></Implementation>
</Method>

<Method name="%OnAddToSaveSet">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%AddToSaveSet</METHOD> method to 
provide notification that the current object is being included in a SaveSet, either
because %Save() was invoked on this object or an object that references this object.

<P>If this method returns an error status then %Save() will fail and the transaction
will be rolled back.]]></Description>
<FormalSpec>depth:%Integer=3,insert:%Integer=0,callcount:%Integer=0</FormalSpec>
<Private>1</Private>
<ProcedureBlock>1</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	if (insert) {
		if (..AngebotsNr = "") {
			set ..AngebotsNr = ..GenerateAngebotsNr(..Mandant)
		}
	}
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="GetId">
<ClassMethod>1</ClassMethod>
<FormalSpec>LieferantOid:%String,AbnehmerOid:%String,MandantOid:%String,Datum:%Date</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID into :id FROM DBPlattform.AngebotsKopf kopf WHERE kopf.Mandant = :MandantOid AND kopf.Lieferant = :LieferantOid AND kopf.Abnehmer = :AbnehmerOid AND kopf.Datum = TO_DATE(:Datum))
	if (SQLCODE '= 0) {
		set id = ""
	}
	
	Quit id
]]></Implementation>
</Method>

<Method name="GetIdDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>LieferantOid:%String,AbnehmerOid:%String,MandantOid:%String,Datum:%Date</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	if (AbnehmerOid = "") {
		&sql(SELECT ID into :id FROM DBPlattform.AngebotsKopf kopf WHERE kopf.Mandant = :MandantOid AND kopf.Lieferant = :LieferantOid AND kopf.Datum = :Datum)		
	} else {
		&sql(SELECT ID into :id FROM DBPlattform.AngebotsKopf kopf WHERE kopf.Mandant = :MandantOid AND kopf.Lieferant = :LieferantOid AND kopf.Abnehmer = :AbnehmerOid AND kopf.Datum = :Datum)	
	}
	if (SQLCODE '= 0) {
		set id = ""
	}
	
	Quit id
]]></Implementation>
</Method>

<Method name="CopyAngebote">
<Description>
Kopiert angebote auf andere Wochen
articleArt = gelistet || zusatz || vonbis</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>lieferantOid:%String,fromWeek:%Integer,fromWeekYear:%Integer,toWeek:%Integer,toWeekYear:%Integer,articleArt:%String,fromArt:%String="",toArt:%String="",overwrite:%Boolean=1</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	
	#dim akNew As DBPlattform.AngebotsKopf
	#dim pNew As DBPlattform.AngebotsPos
	#dim pExisting As DBPlattform.AngebotsPos
	#dim tmpPositions As %Library.ListOfObjects
	set retval = $$$OK
	set dstDate = ""
	
	//returns always the sunday or monday of the given week	
	set firstDateToCopy = $zdh(##class(DBUtils.DateUtils).GetFirstDateOfWeek(fromWeekYear, fromWeek),4)
	set tofirstDate = $zdh(##class(DBUtils.DateUtils).GetFirstDateOfWeek(toWeekYear, toWeek),4)
	set lastDateToCopy = firstDateToCopy + 6
	
	&sql(DECLARE C1 CURSOR FOR
			SELECT ID INTO :id 
			FROM DBPlattform.AngebotsKopf
			WHERE Lieferant = :lieferantOid
			AND Datum BETWEEN :firstDateToCopy AND :lastDateToCopy)
			
	&sql(OPEN C1)
	&sql(FETCH C1)
	while (SQLCODE = 0) {
		
		set ak = ##class(DBPlattform.AngebotsKopf).%OpenId(id)
		
		if (ak '= $$$NULLOREF) {
			// initialize list to cache the positions
			set tmpPositions = ##class(%ListOfObjects).%New()
			
			//set corresponding date of the 'toWeek'
			set srcDate = ak.Datum
			set srcWeekDay = ##class(DBUtils.DateUtils).DatePart("w",$zd(srcDate,1),##class(DBUtils.DateUtils).GetCacheParamFirstDayOfWeek(),##class(DBUtils.DateUtils).GetCacheParamFirstWeekOfYear())
			set dstDate = tofirstDate + (srcWeekDay-1)
			
			//list of articles listed in Lieferanteile
			set listArticles = ##class(%ListOfDataTypes).%New()
			
			set resultSet = ##class(%ResultSet).%New("DBPlattform.AF.LieferanteilAF:ListeVZArtByLiefSmall")
			set status = resultSet.Execute(ak.Mandant, ak.Lieferant.Adresse.Adressnummer, 
										   ak.Abnehmer.Adresse.%Id(), dstDate)
			
			while (resultSet.Next()) {
				set artId = $get(resultSet.Data("ArtikelId"))
				if (artId '= "") {
					do listArticles.Insert(artId)
				}
			}
			
			set key = ""
			
			do {
				set pos = ak.AngebotsPositionen.GetNext(.key)
				if (pos '= $$$NULLOREF) {
					set removePos = $$$NO
				
					if (articleArt = ..#Gelistet) {
						if (pos.IsZusatzangebot = $$$YES) {
							set removePos = $$$YES	
						}
				
				
					} elseif (articleArt = ..#Zusatz) {
						if (pos.IsZusatzangebot = $$$NO) {
							set removePos = $$$YES	
						}
				
				
					} elseif (articleArt = ..#VonBis) {
						if ((pos.Artikel.ArtikelNr < fromArt) || 
							(pos.Artikel.ArtikelNr > toArt)) {
								set removePos = $$$YES
						}
					}
						
					//Check if this position is allowed to save
					if ((##class(DBPlattform.SD.Zeitraster).AllowEdit(##class(DBPlattform.SD.Zeitraster).GetParamAngebotErfasst(), dstDate, ak.Abnehmer.%Id()) = $$$NO)		
						|| (((articleArt = ..#Gelistet) && (listArticles.Find(pos.Artikel.%Id()) = "")))
						|| (((articleArt = ..#Alle) || (articleArt = ..#VonBis)) && (pos.IsZusatzangebot = $$$NO) && (listArticles.Find(pos.Artikel.%Id()) = ""))) {					
							set removePos = $$$YES					
					} 
				
					//if position is ok, cache it
					if (removePos = $$$NO) {
						do tmpPositions.Insert(pos)
					}
				}
				
			} while (key '= "")
			
			//if there are positions -> save
			if (tmpPositions.Count() > 0) {
				
				TSTART
				
				// check if the header already exists
				set id = ..GetId(ak.Lieferant.%Id(), ak.Abnehmer.%Id(), ak.Mandant, dstDate)
				
				//if for this supplier, buyer and date doesn't exists a
				//header -> save the hole object with all positions
				if (id = "") { 
					set akNew = ##class(DBPlattform.AngebotsKopf).%New()
					do akNew.AbnehmerSetObjectId(ak.AbnehmerGetObjectId())
					do akNew.LieferantSetObjectId(ak.LieferantGetObjectId())
					set akNew.Mandant = ak.Mandant
					set akNew.Datum = dstDate
					set akNew.AngebotsNr = ""
					set state = akNew.%Save()
					if ($$$ISOK(state)) {
						for i=1:1:tmpPositions.Count() {
							set tmpPos = tmpPositions.GetAt(i)
							if (tmpPos '= $$$NULLOREF) {
								set t = ##class(DBPlattform.AngebotsPos).%New()
								do t.AngebotsKopfSetObjectId(akNew.%Id())
								do t.ArtikelSetObjectId(tmpPos.ArtikelGetObjectId())
								set t.Bemerkung = tmpPos.Bemerkung
								set t.IsZusatzangebot = tmpPos.IsZusatzangebot
								set t.Menge = tmpPos.Menge
								set posState = t.%Save()
								if ($$$ISERR(posState)) {
									//w "POS1ERROR:akid:"_akNew.%Id()_"#"_akNew.AbnehmerGetObjectId(),"#",akNew.LieferantGetObjectId(),"#",akNew.Datum,"#",t.Artikel.Kurztext,!
									set retval = posState
									Quit	
								}
							}
						}
					} else {
						set retval = state
					}

				//there is a header -> have to merge the articles
				} else {
					
					set existingHeader = ##class(DBPlattform.AngebotsKopf).%OpenId(id)
					if (existingHeader '= $$$NULLOREF) {
						
						set key = ""
						do {
							set pNew = tmpPositions.GetNext(.key)
							if (pNew '= $$$NULLOREF) {
								set pExisting = ##class(DBPlattform.AngebotsPos).GetPosByKopfIdArtikel(id,pNew.Artikel.%Id())
							
								//position exists -> modify amount
								if ((pExisting '= "") && (overwrite = $$$YES)) {
									set pExisting.Menge = pNew.Menge
									do pExisting.%Save()
							
								//position doesn't exist -> add to header	
								} else {
									//set pNew.AngebotsKopf = existingHeader
									
									set t = ##class(DBPlattform.AngebotsPos).%New()
									do t.AngebotsKopfSetObjectId(existingHeader.%Id())
									do t.ArtikelSebObjectId(pNew.ArtikelGetObjectId())
									set t.Bemerkung = pNew.Bemerkung
									set t.IsZusatzangebot = pNew.IsZusatzangebot
									set t.Menge = pNew.Menge
									set tmpposState = t.%Save()
									if ($$$ISERR(tmpposState)) {
										set retval = tmpposState											
									}
									
									//do pNew.%Save()
								}
							}
						} while (key '= "")			
					}				
				}
				if ($$$ISOK(retval)) {
					TCOMMIT
				} else {
					TROLLBACK	
				}
			}
		}
		
		&sql(FETCH C1)	
	}
	
	&sql(CLOSE C1)
	
	
	Quit retval
]]></Implementation>
</Method>

<Method name="DeleteAllByMandant">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<Implementation><![CDATA[	&sql(DELETE FROM DBPlattform.AngebotsKopf WHERE Mandant = :MandantOid)
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.AngebotsKopfD</DataLocation>
<DefaultData>AngebotsKopfDefaultData</DefaultData>
<IdLocation>^DBPlattform.AngebotsKopfD</IdLocation>
<IndexLocation>^DBPlattform.AngebotsKopfI</IndexLocation>
<StreamLocation>^DBPlattform.AngebotsKopfS</StreamLocation>
<Data name="AngebotsKopfDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>AngebotsNr</Value>
</Value>
<Value name="3">
<Value>Datum</Value>
</Value>
<Value name="4">
<Value>Lieferant</Value>
</Value>
<Value name="5">
<Value>Abnehmer</Value>
</Value>
<Value name="6">
<Value>Mandant</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Abnehmer">
</Property>
<Property name="AngebotsNr">
</Property>
<Property name="Datum">
</Property>
<Property name="Lieferant">
</Property>
<Property name="Mandant">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.AngebotsPos">
<Super>%Persistent,%Populate,%XML.Adaptor</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61779,52858.764366</TimeCreated>
<Inheritance>right</Inheritance>

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

<Property name="Artikel">
<Type>DBAgrofresh.Artikel</Type>
<Cardinality>one</Cardinality>
<Inverse>Angebot</Inverse>
<Relationship>1</Relationship>
<Required>1</Required>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Artikel"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

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

<Property name="Saldo">
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {Saldo}=##class(DBPlattform.AngebotsPos).GetSaldo({ID},0) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="ProvSaldo">
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {ProvSaldo}=##class(DBPlattform.AngebotsPos).GetSaldo({ID},1) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="AngebotsKopf">
<Type>DBPlattform.AngebotsKopf</Type>
<Cardinality>parent</Cardinality>
<Inverse>AngebotsPositionen</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="AngebotsKopf"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="AngebotsPosIndex">
<Properties>AngebotsKopf,Artikel</Properties>
<Unique>1</Unique>
</Index>

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

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

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

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

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

<Method name="GetSaldo">
<ClassMethod>1</ClassMethod>
<FormalSpec>Oid:%String,IsProv:%Boolean</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set mengeAngegeben = 0
	set menge = 0
	set angebot = ##class(DBPlattform.AngebotsPos).%OpenId(Oid)
	if (angebot '= "") {
		set dat = angebot.AngebotsKopf.Datum
		set lief = angebot.AngebotsKopf.Lieferant.%Id()
		set art = angebot.Artikel.%Id()
		set menge = angebot.Menge
		set abnehmer = angebot.AngebotsKopf.Abnehmer.%Id()
		set mand = angebot.AngebotsKopf.Mandant
		set q = ""
		
		if (IsProv = 0) {
			set q = "DBPlattform.AF.AngebotAF.GetMenge"		
		} else {
			set q = "DBPlattform.AF.AngebotAF.GetMengeProv"		
		}
		set rset = ##class(%ResultSet).%New(q)
		do rset.Execute(mand, lief,abnehmer,dat,art)

		if (rset.Next()) {
			set mengeAngegeben = rset.Data("Menge")
		}
	}
	
	Quit (menge - mengeAngegeben)
]]></Implementation>
</Method>

<Method name="GetAngebot">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.ProvSaldo As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE "_
				"k.Datum = "_Datum_" AND k.Abnehmer = "_AbnehmerOid_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotMenge">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.Menge As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE "_
				"k.Datum = "_Datum_" AND k.Abnehmer = "_AbnehmerOid_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotObj">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>DBPlattform.AngebotsPos</ReturnType>
<Implementation><![CDATA[
	set id = ""
	set obj = ""
	set strSQL = "SELECT p.ID FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf "_
			"WHERE k.Datum = "_Datum_" AND k.Abnehmer = "_AbnehmerOid_" AND k.Lieferant = "_LieferantOid_" "_
			"AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set id=rs.Data("ID")
		}
	}
	if (id '= "") {
		set obj = ##class(DBPlattform.AngebotsPos).%OpenId(id)
	}
	Quit obj
]]></Implementation>
</Method>

<Method name="GetAngebotDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.ProvSaldo As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE "_
				"k.Datum = TO_DATE("_Datum_") AND k.Abnehmer = "_AbnehmerOid_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotMengeDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.Menge As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE k.Datum = TO_DATE("_Datum_") "
	if (AbnehmerOid '= "") {
		set strSQL = strSQL_"AND k.Abnehmer = "_AbnehmerOid
	}			
	set strSQL = strSQL_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotSaldoDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.Saldo As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE "_
				"k.Datum = TO_DATE("_Datum_") AND k.Abnehmer = "_AbnehmerOid_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotMengeEinheitDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsmenge = 0
	set strSQL = "SELECT p.MengeMengeneinheit As Menge FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE k.Datum = TO_DATE("_Datum_") "
	if (AbnehmerOid '= "") {
		set strSQL = strSQL_"AND k.Abnehmer = "_AbnehmerOid
	}			
	set strSQL = strSQL_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsmenge=rs.Data("Menge")
		}
	}
	
	Quit angebotsmenge
]]></Implementation>
</Method>

<Method name="GetAngebotPreisDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>Datum:%Date,AbnehmerOid:%String,LieferantOid:%String,ArtikelOid:%String,MandantOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<Implementation><![CDATA[
	
	set angebotsPreis = 0
	set strSQL = "SELECT p.Preis As Preis FROM DBPlattform.AngebotsPos p JOIN DBPlattform.AngebotsKopf k ON k.ID = p.AngebotsKopf WHERE k.Datum = TO_DATE("_Datum_") "
	if (AbnehmerOid '= "") {
		set strSQL = strSQL_"AND k.Abnehmer = "_AbnehmerOid
	}			
	set strSQL = strSQL_" AND k.Lieferant = "_LieferantOid_" AND p.Artikel = "_ArtikelOid_" AND k.Mandant = "_MandantOid
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set angebotsPreis=rs.Data("Preis")
		}
	}
	
	Quit angebotsPreis
]]></Implementation>
</Method>

<Method name="GetPosByKopfIdArtikel">
<ClassMethod>1</ClassMethod>
<FormalSpec>ID:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>DBPlattform.AngebotsPos</ReturnType>
<Implementation><![CDATA[

	set posid = ""
	
	&sql(SELECT ID INTO :posid 
		 FROM DBPlattform.AngebotsPos
		 WHERE AngebotsKopf = :ID
		 AND Artikel = :ArtikelOid)
	
	if (SQLCODE '= 0) {
		Quit ""
	
	//if found
	} else {
		Quit ##class(DBPlattform.AngebotsPos).%OpenId(posid)	
	}
]]></Implementation>
</Method>

<Method name="GetPosIdByKopfIdArtikel">
<ClassMethod>1</ClassMethod>
<FormalSpec>ID:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[

	set posid = ""
	
	&sql(SELECT ID INTO :posid 
		 FROM DBPlattform.AngebotsPos
		 WHERE AngebotsKopf = :ID
		 AND Artikel = :ArtikelOid)
	
	if (SQLCODE '= 0) {
		Quit ""
	
	//if found
	} else {
		Quit posid	
	}
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>{%%PARENT}("AngebotsPositionen")</DataLocation>
<DefaultData>AngebotsPosDefaultData</DefaultData>
<IdLocation>^DBPlattform.AngebotsKopfC("AngebotsPositionen")</IdLocation>
<IndexLocation>^DBPlattform.AngebotsPosI</IndexLocation>
<StreamLocation>^DBPlattform.AngebotsPosS</StreamLocation>
<Data name="AngebotsPosDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Menge</Value>
</Value>
<Value name="3">
<Value>Artikel</Value>
</Value>
<Value name="4">
<Value>Bemerkung</Value>
</Value>
<Value name="5">
<Value>IsZusatzangebot</Value>
</Value>
<Value name="6">
<Value>MengeMengeneinheit</Value>
</Value>
<Value name="7">
<Value>Mengeneinheit</Value>
</Value>
<Value name="8">
<Value>Preis</Value>
</Value>
<Value name="9">
<Value>AnzJeGeb</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AngebotsKopf">
</Property>
<Property name="AnzJeGeb">
</Property>
<Property name="Artikel">
</Property>
<Property name="Bemerkung">
</Property>
<Property name="IsZusatzangebot">
</Property>
<Property name="Menge">
</Property>
<Property name="MengeMengeneinheit">
</Property>
<Property name="Mengeneinheit">
</Property>
<Property name="Preis">
</Property>
<Property name="ProvSaldo">
</Property>
<Property name="Saldo">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.AuftragsKopf">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62427,55359.364477</TimeChanged>
<TimeCreated>61760,39300.076886</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="MasterID">
<Description>
MasterID der Order</Description>
<Type>%String</Type>
</Property>

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

<Property name="BestellNr">
<Description>
Bestell-Nr.</Description>
<Type>%String</Type>
<Parameter name="MAXLEN" value="255"/>
<Parameter name="TRUNCATE" value="1"/>
</Property>

<Property name="Auftragsdatum">
<Type>%Date</Type>
</Property>

<Property name="Lieferdatum">
<Type>%Date</Type>
</Property>

<Property name="Positionen">
<Type>DBPlattform.AuftragsPos</Type>
<Cardinality>children</Cardinality>
<Inverse>Auftrag</Inverse>
<Relationship>1</Relationship>
</Property>

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

<Index name="AbnehmerIndex">
<Properties>Abnehmer</Properties>
</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="ZeitErstellung">
<Type>%TimeStamp</Type>
<InitialExpression>$ZDT($ZUTIL(188),3)</InitialExpression>
</Property>

<Property name="IsNachbestellung">
<Type>%Boolean</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {IsNachbestellung}=##class(DBPlattform.AuftragsKopf).CheckNachbestellung({ID},{Mandant},{Lieferdatum},{Abnehmer}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
</Property>

<Property name="DefinitiverAuftrag">
<Type>DBAgrofresh.Auftragskopf</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformAuftrag</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="DefinitiverAuftrag"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DefinitiverAuftragIndex">
<Properties>DefinitiverAuftrag</Properties>
</Index>

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

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

<Method name="CheckNachbestellung">
<ClassMethod>1</ClassMethod>
<FormalSpec>OidKopf:%String,MandantOid:%String,Lieferdatum:%Date,Abnehmer:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set isNB = ""
	
	set rsetBK = ##class(%ResultSet).%New("DBPlattform.AF.AuftragsKopfAF.CheckNB")
	do rsetBK.Execute(OidKopf, MandantOid, Abnehmer, Lieferdatum)
	while (rsetBK.Next()) {
		set isNB = rsetBK.Data("IsNB")
	}
		
	if (isNB '= "") {
		Quit 1
	} else {
		Quit 0
	}
]]></Implementation>
</Method>

<Method name="GetAuftragByVerkaufAuftrag">
<ClassMethod>1</ClassMethod>
<FormalSpec>vkAuftragOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
    set oid = ""
    &sql(Select ID into :oid from DBPlattform.AuftragsKopf where DefinitiverAuftrag = :vkAuftragOid)
    quit oid
]]></Implementation>
</Method>

<Method name="GetOrdersByDate">
<ClassMethod>1</ClassMethod>
<FormalSpec>FromDate:%Date,ToDate:%Date</FormalSpec>
<ReturnType>%ListOfDataTypes</ReturnType>
<Implementation><![CDATA[
	//do rsetBP.Execute(mandOid, vz, bestellNr, liefDat, pos.Artikel.%Id())
	
	Set rs = ##class(%ResultSet).%New("Alliance.Agris.Logic.Qry.OrdersByDate")
	do rs.Execute()
	
	set list = ##class(%ListOfDataTypes).%New()
	
	while (rs.Next()) {
		set entry = ""
		set entry = entry_rs.Data("ID")_";"
		set entry = entry_rs.Data("OrderNo")_";"
		set entry = entry_rs.Data("Name1")_";"
		set entry = entry_rs.Data("Name2")_";"
		set entry = entry_rs.Data("ZIPCode")_";"
		set entry = entry_rs.Data("City")_";"
		set entry = entry_rs.Data("DocumentDateTime")_";"
		set entry = entry_rs.Data("ReqDeliveryDate")_";"
		set entry = entry_rs.Data("AnzLines")_";"
		set entry = entry_rs.Data("AuftragskopfOid")
		do list.Insert(entry)
	}
	
	quit list
]]></Implementation>
</Method>

<Method name="GenerateAuftragByOid">
<ClassMethod>1</ClassMethod>
<FormalSpec>OrderOid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set ClassName = "Alliance.Agris.Logic.Generator"
    set ClassmethodName = "GenerateAuftragByOid"
    quit $CLASSMETHOD(ClassName, ClassmethodName, OrderOid)
]]></Implementation>
</Method>

<Method name="GenerateDesAdv">
<ClassMethod>1</ClassMethod>
<FormalSpec>PlattformAkOid:%String,HeaderSenderId:%String,HeaderRecipientId:%String,Test:%Boolean</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set ClassName = "Alliance.Agris.Logic.Generator"
    set ClassmethodName = "GenerateDesAdv"
    quit $CLASSMETHOD(ClassName, ClassmethodName, PlattformAkOid, HeaderSenderId, HeaderRecipientId, Test)
]]></Implementation>
</Method>

<Method name="DeleteDesAdv">
<ClassMethod>1</ClassMethod>
<FormalSpec>DesAdvOid:%String</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set ClassName = "Alliance.Agris.Logic.Generator"
    set ClassmethodName = "DeleteDesAdv"
    quit $CLASSMETHOD(ClassName, ClassmethodName, DesAdvOid)
]]></Implementation>
</Method>

<Method name="GetIdByBestellNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>BestNr:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set retval = ""
	&sql(SELECT ID INTO :retval fROM DBPlattform.AuftragsKopf WHERE BestellNr = :BestNr)
	if (SQLCODE '= 0) {
		set retval = ""	
	}
	Quit retval
]]></Implementation>
</Method>

<Method name="ResetDefinitiv">
<ClassMethod>1</ClassMethod>
<FormalSpec>KopfOid:%String</FormalSpec>
<Implementation><![CDATA[
	
	set strSQL = "UPDATE DBPlattform.AuftragsKopf SET DefinitiverAuftrag = NULL WHERE ID = "_KopfOid
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set strSQL = "UPDATE DBPlattform.Auftragspos SET DefinitiveAuftragsPos = NULL WHERE Auftrag = '"_KopfOid_"'"
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	/*if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			set id=rs.Data("ID")
			if (id '= "") {
				set pos = ##class(DBPlattform.AuftragsPos).%OpenId(id)
				if (pos '= "") {
					set pos.DefinitiveAuftragsPos = ""
					do pos.%Save()	
					k pos
				}	
			}
			
			
			
		}
	}*/
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.AuftragsKopfD</DataLocation>
<DefaultData>AuftragsKopfDefaultData</DefaultData>
<IdLocation>^DBPlattform.AuftragsKopfD</IdLocation>
<IndexLocation>^DBPlattform.AuftragsKopfI</IndexLocation>
<StreamLocation>^DBPlattform.AuftragsKopfS</StreamLocation>
<Data name="AuftragsKopfDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>BestellNr</Value>
</Value>
<Value name="3">
<Value>Auftragsdatum</Value>
</Value>
<Value name="4">
<Value>Lieferdatum</Value>
</Value>
<Value name="5">
<Value>Abnehmer</Value>
</Value>
<Value name="6">
<Value>Mandant</Value>
</Value>
<Value name="7">
<Value>MasterID</Value>
</Value>
<Value name="8">
<Value>ZeitErstellung</Value>
</Value>
<Value name="9">
<Value>ItemID</Value>
</Value>
<Value name="10">
<Value>DefinitiverAuftrag</Value>
</Value>
<Value name="11">
<Value>NewProperty1</Value>
</Value>
<Value name="12">
<Value>DesAdvId</Value>
</Value>
<Value name="13">
<Value>IsFreigegeben</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Abnehmer">
</Property>
<Property name="Auftragsdatum">
</Property>
<Property name="BestellNr">
</Property>
<Property name="DefinitiverAuftrag">
</Property>
<Property name="DesAdvId">
</Property>
<Property name="IsFreigegeben">
</Property>
<Property name="IsNachbestellung">
</Property>
<Property name="ItemID">
</Property>
<Property name="Lieferdatum">
</Property>
<Property name="Mandant">
</Property>
<Property name="MasterID">
</Property>
<Property name="ZeitErstellung">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.AuftragsPos">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61760,39300.350754</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="PositionsNr">
<Description>
Pos-Nr</Description>
<Type>%Integer</Type>
</Property>

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

<Index name="GebindeIndex">
<Properties>Gebinde</Properties>
</Index>

<Property name="AnzahlGebinde">
<Description>
Anzahl Gebinde</Description>
<Type>%Integer</Type>
</Property>

<Property name="AnzahlJeGebinde">
<Description>
Anzahl je Gebinde</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

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

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

<Property name="Artikel">
<Description>
Artikel ab Artikelstamm</Description>
<Type>DBAgrofresh.Artikel</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformAuftragsPos</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Artikel"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

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

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

<Index name="MengeneinheitIndex">
<Properties>Mengeneinheit</Properties>
</Index>

<Property name="Auftrag">
<Type>DBPlattform.AuftragsKopf</Type>
<Cardinality>parent</Cardinality>
<Inverse>Positionen</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Auftrag"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Property name="SaldoBestellpositionen">
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {SaldoBestellpositionen}=##class(DBPlattform.AuftragsPos).GetSaldoBestPos({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="DefinitiveAuftragsPos">
<Type>DBAgrofresh.Auftragspos</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformAuftragsPos</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="DefinitiveAuftragsPos"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DefinitiveAuftragsPosIndex">
<Properties>DefinitiveAuftragsPos</Properties>
</Index>

<Property name="SaldoGeliefert">
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {SaldoGeliefert}=##class(DBPlattform.AuftragsPos).GetSaldoGeliefert({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

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

<Method name="GetSaldoBestPos">
<ClassMethod>1</ClassMethod>
<FormalSpec>PosOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	
	set retval = 0
	
	set pos = ##class(DBPlattform.AuftragsPos).%OpenId(PosOid)
	if (pos '= $$$NULLOREF) {
		
		set bestellNr = pos.Auftrag.BestellNr
		set liefDat = pos.Auftrag.Lieferdatum
		set vz = pos.Auftrag.Abnehmer.%Id()
		set mandOid = pos.Auftrag.Mandant
		
		set rsetBP = ##class(%ResultSet).%New("DBPlattform.AF.BestPosAF.ListeMengePositionen")
		do rsetBP.Execute(mandOid, vz, bestellNr, liefDat, pos.Artikel.%Id())
	
		while (rsetBP.Next()) {
			set retval = rsetBP.Data("Saldo")
		}
	}
	
	Quit retval
]]></Implementation>
</Method>

<Method name="GetSaldoGeliefert">
<ClassMethod>1</ClassMethod>
<FormalSpec>PosOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	
	set retval = 0
	
	set pos = ##class(DBPlattform.AuftragsPos).%OpenId(PosOid)
	if (pos '= $$$NULLOREF) {
		
		set bestellNr = pos.Auftrag.BestellNr
		set liefDat = pos.Auftrag.Lieferdatum
		set vz = pos.Auftrag.Abnehmer.%Id()
		set mandOid = pos.Auftrag.Mandant
		
		set rsetBP = ##class(%ResultSet).%New("DBPlattform.AF.BestPosAF.ListeMengeGeliefertPositionen")
		do rsetBP.Execute(mandOid, vz, bestellNr, liefDat, pos.Artikel.%Id())
	
		while (rsetBP.Next()) {
			set retval = rsetBP.Data("Saldo")
		}
	}
	
	if (retval = $$$NULLOREF) {
		set retval = 0	
	}
	
	Quit retval
]]></Implementation>
</Method>

<Method name="GetAktPosNummer">
<ClassMethod>1</ClassMethod>
<FormalSpec>AuftragOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set pos = ""
	Set strSQL="SELECT Max(PositionsNr) AS posNr FROM DBPlattform.AuftragsPos WHERE  Auftrag ='"_AuftragOid_"'"
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	IF $$$ISOK(sc) {
		While rs.Next(.sc) {
			Set pos=rs.Data("posNr")
		}
	}
	Quit +pos
]]></Implementation>
</Method>

<Method name="GetPosIdByKopfArtikel">
<ClassMethod>1</ClassMethod>
<FormalSpec>AuftKopfOid:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set retval = ""
	
	&sql(SELECT ID 
			INTO :retval 
			FROM DBPlattform.AuftragsPos
			WHERE Auftrag = :AuftKopfOid
			AND Artikel = :ArtikelOid)
	if (SQLCODE '= 0) {
		set retval = ""	
	}

	Quit retval
]]></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 retval = $$$OK
	if (insert) {
		
		set retval = ..GenerateTeilbestellungen(..OrderManuellEingelesen)
	}
	w "Status %OnAfterSave AuftragsPos: "_retval
	Quit retval
]]></Implementation>
</Method>

<Trigger name="trgAfterSave">
<Code>	do ##class(DBPlattform.AuftragsPos).GenerateTeilbestellungen()</Code>
<Event>INSERT</Event>
<Time>AFTER</Time>
</Trigger>

<Method name="GenerateTeilbestellungen">
<FormalSpec>Manuell:%Boolean=0</FormalSpec>
<ReturnType>%Status</ReturnType>
<Implementation><![CDATA[
	set mandOid = ##class(DBCore.AppEinstellung).GetStringEinst(##class(DBCore.Konst).PLATTFORMMANDANT())
	set vertArt = ##class(DBCore.MandantEinstellung).GetIntEinst(mandOid, ##class(DBCore.Konst).AGROFRESHVERARBEITUNGSTYP())
	set checkAngebot = ##class(DBCore.MandantEinstellung).GetBoolEinst(mandOid, ##class(DBCore.Konst).AGROFRESHDISPOCHECKANGEBOT())
	w "CHeckAng: "_checkAngebot,!
	set v = $$$NULLOREF
	// Verteilung vorbereiten
	if (vertArt = 1) {
		set v = ##class(DBPlattform.Verteilung).%New(..AnzahlGebinde, ..Gebinde.AnzahlJePalette)
	} else {
		set v = ##class(DBPlattform.VerteilungV2).%New(..AnzahlGebinde, ..Gebinde.AnzahlJePalette)	
	}
	
	//*******************************************************
	//  Lieferanten, welche für den aktuellen Artikel und VZ
	//  in Frage kommen durchlaufen
	//  HACK: da es für Caché anscheinend einen Unterschied macht, ob das Query
	//  von .net aus oder COS getriggert wird, obwohl das Datum immer hier in der DB
	//  ausgelesen wird, wurden 2 Queries geschrieben, wobei das Datum untersch. gewandelt wird
	//*******************************************************
	if (Manuell = 0) {
		set rsetLief = ##class(%ResultSet).%New("DBPlattform.AF.LieferanteilAF.ListeLieferantenByArtVZCOS")
		do rsetLief.Execute(mandOid, ..Artikel.%Id(), ..Auftrag.Abnehmer.Adresse.%Id(),..Auftrag.Lieferdatum)
	} else {
		set rsetLief = ##class(%ResultSet).%New("DBPlattform.AF.LieferanteilAF.ListeLieferantenByArtVZDotNet")
		do rsetLief.Execute(mandOid, ..Artikel.%Id(), ..Auftrag.Abnehmer.Adresse.%Id(), $zd(..Auftrag.Lieferdatum,3))
	}
		
	while (rsetLief.Next()) {
		w "lieferanteil found"
		do v.AddLieferanteil(mandOid, rsetLief.Data("ID"), ..Auftrag.Lieferdatum, Manuell, checkAngebot)
		
	} //end while
	
	//Eruieren, ob es sich um eine Nachbestellung handelt
	set isNB = ..Auftrag.IsNachbestellung
	if (isNB = 1) {
		do v.AdjustAnteile()
	}
	
	//NUR FÜR KONTROLLE
	for idx=1:1:v.Lieferanten.Count() {
		set e = v.Lieferanten.GetAt(idx)
		W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu," Anteile in Prozent: ", e.AnteilProzent," Anteile in Prozent alt: ", e.AnteilProzentAlt, " Mindestmenge: ", e.MindestmengeNachlief,!
	}
	
	
	//*******************************************************
	// Verteilung berechnen
	//*******************************************************
	
	do v.CalcVerteilung(isNB)

	//errechneten Liefermengen mit Angebot abgleichen und
	//evt umverteilen
	//nur wenn Typ 1
	if (vertArt = 1) {
		do v.AngebotsAbgleich(isNB)
	}
	
	w "---------------v:"_v_"Lieferanten: "_v.Lieferanten
	set anz = v.Lieferanten.Count()
	w !,"start bestellung + pos anlegen, anz Lieferanten: "_anz,!
	for idx=1:1:anz {
		
		set entry = v.Lieferanten.GetAt(idx)
		w !,"AUFTRAGSPOS SAVE DER VERT, anteilberechnet: "_entry.AnteileBerechnet,!
		//nur wenn auch eine Menge zugeteilt wurde > 0, eine Position anlegen
		// oder wenn es sich um eine Nachlieferung gehandelt hat, speziell anlegen
		//if (entry.AnteilInAnzGebinde > 0 || ((entry.AnteilInAnzGebinde = 0) && (entry.Nachlieferung = 2) && (entry.AnteileBerechnetAlt '= 0))) {
		
			//Lieferanten AdressId auslesen
			set lieferant = entry.LieferantID
			// Kreditor ID des Lieferanten auslesen
			set liefKrediOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(mandOid, lieferant)

			set oidBestKopf = ""
			
			set rsetBK = ##class(%ResultSet).%New("DBPlattform.AF.BestKopfAF.GetIdByBestellNr")
			do rsetBK.Execute(mandOid, ..Auftrag.BestellNr, liefKrediOid, ..Auftrag.Abnehmer.%Id())
	
			while (rsetBK.Next()) {
				set oidBestKopf = rsetBK.Data("ID")
			}

			//falls oidBestKopf = "" -> Bestellungskopf muss angelegt werden
			set bKopf = ""
			if (oidBestKopf = "") {
				set bKopf = ##class(DBPlattform.BestKopf).%New()
				set bKopf.Mandant = mandOid
				set bKopf.Abnehmer = ..Auftrag.Abnehmer
				set bKopf.BestellNr = ..Auftrag.BestellNr
				set bKopf.Auftragsdatum = ..Auftrag.Auftragsdatum
				set bKopf.Lieferdatum = ..Auftrag.Lieferdatum
				set bKopf.ItemID = ..Auftrag.ItemID
				set bKopf.MasterID = ..Auftrag.MasterID
				set bKopf.Lieferant = ##class(DBDebiKredi.Kreditor).%OpenId(liefKrediOid)
		
				set st = bKopf.%Save()
				if $$$ISOK(st) {
					set oidBestKopf = bKopf.%Id()
				} else {
					w "-----------------"_st	
				}
	
			} else {
				set bKopf = ##class(DBPlattform.BestKopf).%OpenId(oidBestKopf)		
			}

			// Bestellungsdetail generieren
			if (bKopf '= $$$NULLOREF) {
				w "start anlegen pos",!
				set bPos = ##class(DBPlattform.BestPos).%New()
				set bPos.Artikel = ..Artikel
				set bPos.BestKopf = bKopf
				//temporär: manchmal tritt es auf, dass AnteilInAnzGebinde neg. ist
				//erst mal auf 0 setzen
				if (entry.AnteilInAnzGebinde < 0) {
					set bPos.MengeBestellung = 0
				} else {
					set bPos.MengeBestellung = entry.AnteilInAnzGebinde
				}
				set bPos.Gebinde = ..Gebinde
				set bPos.Mengeneinheit = ..Mengeneinheit
				set bPos.AnzahlJeGebinde = ..AnzahlJeGebinde
				set bPos.Preis = ..Preis
				if (isNB = 1) {
					set bPos.MengeBerechnetNachSchluessel = entry.AnteileBerechnetAlt
				} else {
					set bPos.MengeBerechnetNachSchluessel = entry.AnteileBerechnet
				}
				set posState = bPos.%Save()
			
				//if ($$$ISERR(posState)) {
				w "Lieferant: "_bKopf.Lieferant.%Id()_" MengeBestellung: "_bPos.MengeBestellung,!
				w "---------------------"_posState,!
				//}
			}
			w "end bpos save",!
		//} //end if (entry.AnteilInAnzGebinde > 0)
	}
	
	
	kill v
	
	//Quit $$$ERROR()
	Quit $$$OK
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.AuftragsPosD</DataLocation>
<DefaultData>AuftragsPosDefaultData</DefaultData>
<IdLocation>^DBPlattform.AuftragsPosD</IdLocation>
<IndexLocation>^DBPlattform.AuftragsPosI</IndexLocation>
<StreamLocation>^DBPlattform.AuftragsPosS</StreamLocation>
<Data name="AuftragsPosDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>PositionsNr</Value>
</Value>
<Value name="3">
<Value>Gebinde</Value>
</Value>
<Value name="4">
<Value>AnzahlGebinde</Value>
</Value>
<Value name="5">
<Value>AnzahlJeGebinde</Value>
</Value>
<Value name="6">
<Value>Menge</Value>
</Value>
<Value name="7">
<Value>Preis</Value>
</Value>
<Value name="8">
<Value>Artikel</Value>
</Value>
<Value name="9">
<Value>Mengeneinheit</Value>
</Value>
<Value name="10">
<Value>DefinitiveAuftragsPos</Value>
</Value>
<Value name="11">
<Value>KundenSpezArtNr</Value>
</Value>
<Value name="12">
<Value>OrderManuellEingelesen</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AnzahlGebinde">
</Property>
<Property name="AnzahlJeGebinde">
</Property>
<Property name="Artikel">
</Property>
<Property name="Auftrag">
</Property>
<Property name="DefinitiveAuftragsPos">
</Property>
<Property name="Gebinde">
</Property>
<Property name="KundenSpezArtNr">
</Property>
<Property name="Menge">
</Property>
<Property name="Mengeneinheit">
</Property>
<Property name="OrderManuellEingelesen">
</Property>
<Property name="PositionsNr">
</Property>
<Property name="Preis">
</Property>
<Property name="SaldoBestellpositionen">
</Property>
<Property name="SaldoGeliefert">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.BestKopf">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61726,28177.718385</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="MasterID">
<Description>
MasterID der ursprünglichen VZ Order</Description>
<Type>%String</Type>
</Property>

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

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

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

<Index name="LieferantIndex">
<Properties>Lieferant</Properties>
</Index>

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

<Index name="AbnehmerIndex">
<Properties>Abnehmer</Properties>
</Index>

<Property name="Auftragsdatum">
<Type>%Date</Type>
<Required>1</Required>
</Property>

<Property name="Lieferdatum">
<Type>%Date</Type>
<Required>1</Required>
</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="BestDetails">
<Type>DBPlattform.BestPos</Type>
<Cardinality>children</Cardinality>
<Inverse>BestKopf</Inverse>
<Relationship>1</Relationship>
</Property>

<Property name="ZeitErstellung">
<Type>%TimeStamp</Type>
<InitialExpression>$ZDT($ZUTIL(188),3)</InitialExpression>
</Property>

<Property name="DefinitiveBestellung">
<Type>DBAgrofreshEK.BestellungsKopf</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformBestKopf</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="DefinitiveBestellung"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DefinitiveBestellungIndex">
<Properties>DefinitiveBestellung</Properties>
<Unique>1</Unique>
</Index>

<Property name="IsNachbestellung">
<Type>%Boolean</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {IsNachbestellung}=##class(DBPlattform.BestKopf).CheckNachbestellung({ID},{Mandant},{Lieferdatum},{Abnehmer},{Lieferant}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
</Property>

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

<Property name="TotalMengeBestellung">
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {TotalMengeBestellung}=##class(DBPlattform.BestKopf).CalcTotalMengeBest({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="IsAuftragDefinitiv">
<Type>%Boolean</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {IsAuftragDefinitiv}=##class(DBPlattform.BestKopf).IsAuftDef({BestellNr},{Abnehmer},{Lieferdatum}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
</Property>

<Index name="BestellNrIdx">
<Type>bitmap</Type>
<Properties>BestellNr</Properties>
</Index>

<Index name="LieferdatumIdx">
<Type>bitmap</Type>
<Properties>Lieferdatum</Properties>
</Index>

<Property name="ProvWebEdiCsv">
<Type>DBPlattform.CSVStream</Type>
<Cardinality>one</Cardinality>
<Inverse>BestKopf</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="ProvWebEdiCsv"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ProvWebEdiCsvIndex">
<Properties>ProvWebEdiCsv</Properties>
</Index>

<Method name="CheckNachbestellung">
<ClassMethod>1</ClassMethod>
<FormalSpec>OidKopf:%String,MandantOid:%String,Lieferdatum:%Date,Abnehmer:%String,Lieferant:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set isNB = ""
	
	set rsetBK = ##class(%ResultSet).%New("DBPlattform.AF.BestKopfAF.CheckNB")
	do rsetBK.Execute(OidKopf, MandantOid, Abnehmer, Lieferant, Lieferdatum)
	while (rsetBK.Next()) {
		set isNB = rsetBK.Data("IsNB")
	}
		
	if (isNB '= "") {
		Quit 1
	} else {
		Quit 0
	}
]]></Implementation>
</Method>

<Method name="CalcTotalMengeBest">
<ClassMethod>1</ClassMethod>
<FormalSpec>KopfOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set total = 0
	set strSQL = "SELECT SUM(MengeBestellung) As Total FROM DBPlattform.BestPos WHERE BestKopf = "_KopfOid
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set total =rs.Data("Total")
		}
	}
	
	Quit total
]]></Implementation>
</Method>

<Method name="IsAuftDef">
<ClassMethod>1</ClassMethod>
<FormalSpec>BestellNr:%String,AbnehmerOid:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set isDef = 0
	set strSQL = "SELECT DefinitiverAuftrag FROM DBPlattform.AuftragsKopf WHERE BestellNr = "_BestellNr_" AND Abnehmer = "_AbnehmerOid_" AND Lieferdatum = TO_DATE("_Lieferdatum_")"
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set defAuft = rs.Data("DefinitiverAuftrag")
			if (defAuft '= "") {
				set isDef = 1	
			}
		}
	}
	
	Quit isDef
]]></Implementation>
</Method>

<Method name="ResetDefinitiv">
<ClassMethod>1</ClassMethod>
<FormalSpec>KopfOid:%String</FormalSpec>
<Implementation><![CDATA[
	
	set strSQL = "UPDATE DBPlattform.BestKopf SET DefinitiveBestellung = NULL WHERE ID = '"_KopfOid_"'"
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set strSQL = "UPDATE DBPlattform.BestPos SET DefinitiveBestPos = NULL WHERE BestKopf = '"_KopfOid_"'"
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	/*if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			set id=rs.Data("ID")
			if (id '= "") {
				set pos = ##class(DBPlattform.BestPos).%OpenId(id)
				if (pos '= "") {
					set pos.DefinitiveBestPos = ""
					do pos.%Save()	
					k pos
				}	
			}
			
			
			
		}
	}*/
]]></Implementation>
</Method>

<Method name="OutputProvWebEdiCsvStream">
<ReturnType>%Library.GlobalBinaryStream</ReturnType>
<Implementation><![CDATA[
	Set tmpStream=##class(%Library.GlobalBinaryStream).%New()
	Set f = ..ProvWebEdiCsv
	Set Ret=""
	If (f'="") {
		Set Size=f.DataStream.Size
		Set Ret=tmpStream.CopyFromAndSave(f.DataStream)
	}
	Quit tmpStream
]]></Implementation>
</Method>

<Method name="InputProvWebEdiCsvStream">
<FormalSpec><![CDATA[&Stream:%Library.GlobalBinaryStream]]></FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	Set res=0
	Set fid = ""
	if (..ProvWebEdiCsv '= "") {
		Set fid = ..ProvWebEdiCsv.%Id()
	}
	Set sID = ""
	
		Set Cnt=0
		if (fid'="") {
			&sql(SELECT count(*) INTO :Cnt
		     	FROM DBPlattform.CSVStream
		     	WHERE ID = :fid)
		}
		If (Cnt=0) {
			Set myId=..%Id()
			Set v=##Class(DBPlattform.BestKopf).%OpenId(myId)
			Set n=##Class(DBPlattform.CSVStream).%New()
			Set Ret=n.%Save()
			Set v.ProvWebEdiCsv=n
			Set Ret=v.%Save()
			if (Ret=1) {
				do n.DataStream.CopyFromAndSave(Stream)
				Set Ret=n.%Save()
			}
			Set n = ""
			Set v = ""
			Set res=(Ret=1)
			Quit res
		}
		&sql(SELECT ID InTo :sID 
		     FROM DBPlattform.CSVStream
		     WHERE ID = :fid)
		     
		Set s=##Class(DBPlattform.CSVStream).%OpenId(sID)
		Set Ret=s.DataStream.CopyFromAndSave(Stream)
		Set RetS = s.%Save()
		set s = ""
		Set res=((Ret=1) && (RetS=1))
	
	Quit res
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.BestKopfD</DataLocation>
<DefaultData>BestKopfDefaultData</DefaultData>
<IdLocation>^DBPlattform.BestKopfD</IdLocation>
<IndexLocation>^DBPlattform.BestKopfI</IndexLocation>
<StreamLocation>^DBPlattform.BestKopfS</StreamLocation>
<Data name="BestKopfDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>BestellNr</Value>
</Value>
<Value name="3">
<Value>Lieferant</Value>
</Value>
<Value name="4">
<Value>Abnehmer</Value>
</Value>
<Value name="5">
<Value>Datum</Value>
</Value>
<Value name="6">
<Value>Mandant</Value>
</Value>
<Value name="7">
<Value>MasterID</Value>
</Value>
<Value name="8">
<Value>ZeitErstellung</Value>
</Value>
<Value name="9">
<Value>ItemID</Value>
</Value>
<Value name="10">
<Value>Auftragsdatum</Value>
</Value>
<Value name="11">
<Value>Lieferdatum</Value>
</Value>
<Value name="12">
<Value>DefinitiveBestellung</Value>
</Value>
<Value name="13">
<Value>IsFreigegeben</Value>
</Value>
<Value name="14">
<Value>ProvWebEdiCsv</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Abnehmer">
</Property>
<Property name="Auftragsdatum">
</Property>
<Property name="BestellNr">
</Property>
<Property name="DefinitiveBestellung">
</Property>
<Property name="IsAuftragDefinitiv">
</Property>
<Property name="IsFreigegeben">
</Property>
<Property name="IsNachbestellung">
</Property>
<Property name="ItemID">
</Property>
<Property name="Lieferant">
</Property>
<Property name="Lieferdatum">
</Property>
<Property name="Mandant">
</Property>
<Property name="MasterID">
</Property>
<Property name="ProvWebEdiCsv">
</Property>
<Property name="TotalMengeBestellung">
</Property>
<Property name="ZeitErstellung">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.BestPos">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61726,28138.06095</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="Artikel">
<Type>DBAgrofresh.Artikel</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformBestPos</Inverse>
<Relationship>1</Relationship>
<Required>1</Required>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="Artikel"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

<Property name="MengeBerechnetNachSchluessel">
<Description>
interner Gebrauch, um prov. Lieferdifferenz zu berechnen und einem Lieferanten
welcher keine Nachlieferung macht, die Anzahl Gebinde, welche er bei einer NB
zugute hätte, gutschreiben zu können</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MengeBestellung">
<Description>
Menge nach Split</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MoeglicheLiefermenge">
<Description>
Wird vom Produzent per Web eingetragen</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MengeDefinitiv">
<Description>
effektiv gelieferte Menge, welche nach definitiven Bestellungen eingetragen wird</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="MengeGeliefert">
<Description>
Menge, welche auf der definitiven Bestellung steht</Description>
<Type>%Decimal</Type>
<Calculated>1</Calculated>
<SqlComputeCode>Set {MengeGeliefert}=##class(DBPlattform.BestPos).GetMengeGeliefert({BestKopf},{Artikel}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
<Parameter name="SCALE" value="5"/>
</Property>

<Property name="BestKopf">
<Type>DBPlattform.BestKopf</Type>
<Cardinality>parent</Cardinality>
<Inverse>BestDetails</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="BestKopf"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

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

<Property name="AnzahlJeGebinde">
<Description>
Anzahl je Gebinde</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

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

<Index name="GebindeIndex">
<Properties>Gebinde</Properties>
</Index>

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

<Index name="MengeneinheitIndex">
<Properties>Mengeneinheit</Properties>
</Index>

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

<Property name="DefinitiveBestPos">
<Type>DBAgrofreshEK.Bestellungspos</Type>
<Cardinality>one</Cardinality>
<Inverse>PlattformBestPos</Inverse>
<Relationship>1</Relationship>
<Parameter name="XMLELEMENTREF" value="1"/>
<Parameter name="XMLNAME" value="DefinitiveBestPos"/>
<Parameter name="XMLPROJECTION" value="ATTRIBUTE"/>
<Parameter name="XMLREFERENCE" value="ID"/>
</Property>

<Index name="DefinitiveBestPosIndex">
<Properties>DefinitiveBestPos</Properties>
<Unique>1</Unique>
</Index>

<Method name="GetMengeGeliefert">
<ClassMethod>1</ClassMethod>
<FormalSpec>BestKopfOid:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<SqlProc>1</SqlProc>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set menge = 0
	//Oid Definitive Bestellung auslesen
	set plattformBKopf = ##class(DBPlattform.BestKopf).%OpenId(BestKopfOid)
	if ((plattformBKopf '= "") && (plattformBKopf.DefinitiveBestellung '= "")) {
		set defB = plattformBKopf.DefinitiveBestellung.%Id()
		&sql(SELECT SUM(AnzahlGebinde) INTO :menge FROM DBAgrofreshEK.Bestellungspos
				WHERE Bestellungskopf = :defB AND Artikel = :ArtikelOid)
		}
	Quit menge
]]></Implementation>
</Method>

<Method name="UpdateMoeglLiefermenge">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,Lieferdatum:%Date</FormalSpec>
<Implementation><![CDATA[
	
	&sql(UPDATE DBPlattform.BestPos SET MoeglicheLiefermenge = MengeBestellung
		WHERE BestKopf->Mandant = :MandantOid
		AND BestKopf->Abnehmer = :AbnehmerOid
		AND BestKopf->BestellNr = :BestellNr
		AND BestKopf->Lieferdatum = TO_DATE(:Lieferdatum)
		AND MoeglicheLiefermenge is NULL)
]]></Implementation>
</Method>

<Method name="GetKundenSpezArtNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AbnehmerOid:%String,BestellNr:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	
	set retval = ""
	
	&sql(SELECT KundenSpezArtNr INTO :retval FROM DBPlattform.Auftragspos 
			WHERE Auftrag->Mandant = :MandantOid
			AND Auftrag->Abnehmer = :AbnehmerOid
			AND Auftrag->BestellNr = :BestellNr
			AND Artikel = :ArtikelOid)
	
	Quit retval
]]></Implementation>
</Method>

<Method name="GetPosIdByKopfArtikel">
<ClassMethod>1</ClassMethod>
<FormalSpec>BestKopfOid:%String,ArtikelOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set retval = ""
	
	&sql(SELECT ID 
			INTO :retval 
			FROM DBPlattform.Bestpos
			WHERE BestKopf = :BestKopfOid
			AND Artikel = :ArtikelOid)
	if (SQLCODE '= 0) {
		set retval = ""	
	}

	Quit retval
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>{%%PARENT}("BestDetails")</DataLocation>
<DefaultData>BestPosDefaultData</DefaultData>
<IdLocation>^DBPlattform.BestKopfC("BestDetails")</IdLocation>
<IndexLocation>^DBPlattform.BestPosI</IndexLocation>
<StreamLocation>^DBPlattform.BestPosS</StreamLocation>
<Data name="BestPosDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Artikel</Value>
</Value>
<Value name="3">
<Value>MengeBestellung</Value>
</Value>
<Value name="4">
<Value>MoeglicheLiefermenge</Value>
</Value>
<Value name="5">
<Value>MengeGeliefert</Value>
</Value>
<Value name="6">
<Value>Bemerkung</Value>
</Value>
<Value name="7">
<Value>MengeBerechnetNachSchluessel</Value>
</Value>
<Value name="8">
<Value>AnzahlJeGebinde</Value>
</Value>
<Value name="9">
<Value>Gebinde</Value>
</Value>
<Value name="10">
<Value>Mengeneinheit</Value>
</Value>
<Value name="11">
<Value>Preis</Value>
</Value>
<Value name="12">
<Value>MengeDefinitiv</Value>
</Value>
<Value name="13">
<Value>DefinitiveBestPos</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AnzahlJeGebinde">
</Property>
<Property name="Artikel">
</Property>
<Property name="Bemerkung">
</Property>
<Property name="BestKopf">
</Property>
<Property name="DefinitiveBestPos">
</Property>
<Property name="Gebinde">
</Property>
<Property name="MengeBerechnetNachSchluessel">
</Property>
<Property name="MengeBestellung">
</Property>
<Property name="MengeDefinitiv">
</Property>
<Property name="MengeGeliefert">
</Property>
<Property name="Mengeneinheit">
</Property>
<Property name="MoeglicheLiefermenge">
</Property>
<Property name="Preis">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.Budget">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62416,57284.971476</TimeChanged>
<TimeCreated>62004,58673.245513</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>

<Index name="IdentIdx">
<Properties>Mandant,Kunde,Artikel,Datum</Properties>
<Unique>1</Unique>
</Index>

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

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

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

<Index name="KundeIndex">
<Properties>Kunde</Properties>
</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="Datum">
<Type>%Date</Type>
</Property>

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

<Method name="GetOidByVZArtikelDatum">
<ClassMethod>1</ClassMethod>
<FormalSpec>Artikel:%String,Kunde:%String,Datum:%Date</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set oid = ""
	&sql(SELECT ID INTO :oid FROM DBPlattform.Budget
		WHERE Artikel = :Artikel
		AND Kunde = :Kunde
		AND Datum = TO_DATE(:Datum))
	quit:(SQLCODE'=0) ""
	quit oid
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.BudgetD</DataLocation>
<DefaultData>BudgetDefaultData</DefaultData>
<IdLocation>^DBPlattform.BudgetD</IdLocation>
<IndexLocation>^DBPlattform.BudgetI</IndexLocation>
<StreamLocation>^DBPlattform.BudgetS</StreamLocation>
<Data name="BudgetDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Artikel</Value>
</Value>
<Value name="3">
<Value>Kunde</Value>
</Value>
<Value name="4">
<Value>Mandant</Value>
</Value>
<Value name="5">
<Value>Datum</Value>
</Value>
<Value name="6">
<Value>Menge</Value>
</Value>
</Data>
<Property name="Artikel"/>
<Property name="Datum"/>
<Property name="Kunde"/>
<Property name="Mandant"/>
<Property name="Menge"/>
</Storage>
</Class>


<Class name="DBPlattform.CSVStream">
<Super>%Persistent</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>62269,59910.613071</TimeCreated>

<Property name="DataStream">
<Type>%GlobalBinaryStream</Type>
</Property>

<Property name="BestKopf">
<Type>DBPlattform.BestKopf</Type>
<Cardinality>many</Cardinality>
<Inverse>ProvWebEdiCsv</Inverse>
<Relationship>1</Relationship>
</Property>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.CSVStreamD</DataLocation>
<DefaultData>CSVStreamDefaultData</DefaultData>
<IdLocation>^DBPlattform.CSVStreamD</IdLocation>
<IndexLocation>^DBPlattform.CSVStreamI</IndexLocation>
<StreamLocation>^DBPlattform.CSVStreamS</StreamLocation>
<Data name="CSVStreamDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>DataStream</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="DataStream">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.InactiveArticlesWeb">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>62268,55045.203022</TimeCreated>
<Inheritance>right</Inheritance>

<Property name="Lieferant">
<Type>DBDebiKredi.Kreditor</Type>
<Cardinality>one</Cardinality>
<Inverse>InativeArticlesWeb</Inverse>
<Relationship>1</Relationship>
</Property>

<Index name="LieferantIndex">
<Properties>Lieferant</Properties>
</Index>

<Property name="Artikel">
<Type>DBAgrofresh.Artikel</Type>
<Cardinality>one</Cardinality>
<Inverse>InactiveArticlesWeb</Inverse>
<Relationship>1</Relationship>
</Property>

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

<Index name="Ident">
<Properties>Lieferant,Artikel</Properties>
<Unique>1</Unique>
</Index>

<Method name="IsArticleInactive">
<ClassMethod>1</ClassMethod>
<FormalSpec>LieferantId:%String,ArtikelId:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set retval = $$$NO
	set id = ""
	&sql(SELECT ID INTO :id 
			FROM DBPlattform.InactiveArticlesWeb 
			WHERE Lieferant = :LieferantId
			AND Artikel = :ArtikelId)
	if (SQLCODE '= 0) {
		set id = ""
	}
	if (id '= "") {
		set retval = $$$YES	
	}		
	
	Quit retval
]]></Implementation>
</Method>

<Method name="DeleteInactiveArticle">
<ClassMethod>1</ClassMethod>
<FormalSpec>LieferantId:%String,ArtikelId:%String</FormalSpec>
<Implementation><![CDATA[	&sql(DELETE FROM DBPlattform.InactiveArticlesWeb WHERE Lieferant = :LieferantId AND Artikel = :ArtikelId)
]]></Implementation>
</Method>

<Method name="%OnNew">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%New</METHOD> method to 
provide notification that a new instance of an object is being created.

<P>If this method returns an error then the object will not be created.
<p>It is passed the arguments provided in the %New call.
When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
<p>Method %OnNew(dob as %Date = "", name as %Name = "") as %Status]]></Description>
<FormalSpec>LieferantId:%String="",ArtikelId:%String=""</FormalSpec>
<Private>1</Private>
<ProcedureBlock>1</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	if (LieferantId '= "") {
		do ..LieferantSetObjectId(LieferantId)	
	}
	if (ArtikelId '= "") {
		do ..ArtikelSetObjectId(ArtikelId)	
	}
	
	Quit $$$OK
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.InactiveArtD7F4D</DataLocation>
<DefaultData>InactiveArticlesWebDefaultData</DefaultData>
<IdLocation>^DBPlattform.InactiveArtD7F4D</IdLocation>
<IndexLocation>^DBPlattform.InactiveArtD7F4I</IndexLocation>
<StreamLocation>^DBPlattform.InactiveArtD7F4S</StreamLocation>
<Data name="InactiveArticlesWebDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Lieferant</Value>
</Value>
<Value name="3">
<Value>Artikel</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Artikel">
</Property>
<Property name="Lieferant">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.Lieferanteil">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61668,57827.907079</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>

<Index name="IdentIdx">
<Properties>Mandant,Kunde,Artikel,Datum</Properties>
<Unique>1</Unique>
</Index>

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

<Index name="ArtikelIndex">
<Properties>Artikel</Properties>
</Index>

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

<Index name="KundeIndex">
<Properties>Kunde</Properties>
</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="Datum">
<Type>%Date</Type>
</Property>

<Index name="DatumIdx">
<Properties>Datum</Properties>
</Index>

<Property name="HasDetails">
<Type>%Boolean</Type>
<Calculated>1</Calculated>
<SqlComputeCode> Set {HasDetails}=##class(DBPlattform.Lieferanteil).CheckHasDetails({ID}) </SqlComputeCode>
<SqlComputed>1</SqlComputed>
</Property>

<Property name="Details">
<Type>DBPlattform.LieferanteilDet</Type>
<Cardinality>children</Cardinality>
<Inverse>Kopf</Inverse>
<Relationship>1</Relationship>
</Property>

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

<Method name="CopyDatum">
<ClassMethod>1</ClassMethod>
<FormalSpec>KundeOid:%String,ArtikelOid:%String,Datum:%Date,DestDate:%Date,MandantOid:%String</FormalSpec>
<Implementation><![CDATA[
	TSTART
	
	set kopf = ##class(DBPlattform.Lieferanteil).%New()
	set kopf.Kunde = ##class(DBAdressen.Adresse).%OpenId(KundeOid)
	set kopf.Artikel = ##class(DBAgrofresh.Artikel).%OpenId(ArtikelOid)
	set kopf.Mandant = MandantOid
	set kopf.Datum = DestDate
	set kopf.Aktiv = $$$YES
	
	set stK = kopf.%Save()
	if ($$$ISOK(stK)) {
		
		Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetAnteileByKundeArtikelDat")
    	Set sc=rs.%Execute(KundeOid, ArtikelOid, MandantOid, "de", $zd(Datum,3))
    
    	set success = 1
    	while rs.Next(.sc) {
			set id = rs.Data("ID")
			set anteil = ##class(DBPlattform.LieferanteilDet).%OpenId(id)
			set newAnteil = ##class(DBPlattform.LieferanteilDet).%New()
		
			set newAnteil.Abzuege = anteil.Abzuege
			set newAnteil.Lieferant = anteil.Lieferant
			set newAnteil.AnteilProzent = anteil.AnteilProzent
			set newAnteil.Nachlieferung = anteil.Nachlieferung
			set newAnteil.MindestmengeNachlief = anteil.MindestmengeNachlief
			set newAnteil.Lieferdifferenz = anteil.Lieferdifferenz
			set newAnteil.Kopf = kopf
			
			set s = newAnteil.%Save()
			if ($$$ISOK(s) = 0) {
				set success = 0
				Quit
			}
			kill anteil
			kill newAnteil				
		}	
		if (success = 1) {
			TCOMMIT
		} else {
			TROLLBACK	
		}
	} else {
		TROLLBACK	
	}
]]></Implementation>
</Method>

<Method name="GetDatumByArtKunde">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	//w !,"in GetDatumByArtKunde Lieferdatum: "_Lieferdatum, "Mandant:"_MandantOid, "ArtikelOid: "_ArtikelOid, "Abnehmer: "_AdrOidAbnehmer,!
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatumByArtKunde")
	Set sc=rs.%Execute(MandantOid, ArtikelOid, AdrOidAbnehmer, Lieferdatum)
	//w !,"ERRORSTATUS: "_sc,!
	while rs.Next(.sc) {
	//	w "RSDATA_DATUM: "_rs.Data("Datum"),!
		set date = $ZDH(rs.Data("Datum"),3)
	}
	//w "DATE: "_date,!
	Quit date
]]></Implementation>
</Method>

<Method name="GetDatumByArtKundeCOS">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatumByArtKunde")
	Set sc=rs.%Execute(MandantOid, ArtikelOid, AdrOidAbnehmer, $zd(Lieferdatum,3))
	while rs.Next(.sc) {
		set date = $ZDH(rs.Data("Datum"),3)
	}
	Quit date
]]></Implementation>
</Method>

<Method name="GetDatumByArtKundeDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	//w "Kunde: "_AdrOidAbnehmer,!
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatumByArtKunde")
	Set sc=rs.%Execute(MandantOid, ArtikelOid, AdrOidAbnehmer, Lieferdatum)
	while rs.Next(.sc) {
		set date = rs.Data("Datum")
	}
	Quit date
]]></Implementation>
</Method>

<Method name="GetDatum">
<ClassMethod>1</ClassMethod>
<FormalSpec>ArtikelOid:%String,Kunde:%String,Datum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatum")
	Set sc=rs.%Execute(ArtikelOid, Kunde, Datum)
	while rs.Next(.sc) {
		set date = $ZDH(rs.Data("Datum"),3)
	}
	Quit date
]]></Implementation>
</Method>

<Method name="GetDatumCOS">
<ClassMethod>1</ClassMethod>
<FormalSpec>ArtikelOid:%String,Kunde:%String,Datum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatum")
	Set sc=rs.%Execute(ArtikelOid, Kunde, $zd(Datum,3))
	while rs.Next(.sc) {
		set date = $ZDH(rs.Data("Datum"),3)
	}
	Quit date
]]></Implementation>
</Method>

<Method name="GetDatumDotNet">
<ClassMethod>1</ClassMethod>
<FormalSpec>ArtikelOid:%String,Kunde:%String,Datum:%Date</FormalSpec>
<ReturnType>%Date</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set date = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetDatum")
	Set sc=rs.%Execute(ArtikelOid, Kunde, Datum)
	while rs.Next(.sc) {
		set date = rs.Data("Datum")
	}
	Quit date
]]></Implementation>
</Method>

<Method name="GetKopfId">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,KundeOid:%String,Datum:%Date</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetKopfId")
	Set sc=rs.%Execute(MandantOid, ArtikelOid, KundeOid, $zd(Datum,3))
	while rs.Next(.sc) {
		set id = rs.Data("ID")
	}
	Quit id
]]></Implementation>
</Method>

<Method name="CheckHasDetails">
<ClassMethod>1</ClassMethod>
<FormalSpec>Oid:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<SqlProc>1</SqlProc>
<Implementation><![CDATA[
	set exists = 0
	
	Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:CheckDetails")
	Set sc=rs.%Execute(Oid)

	while rs.Next(.sc) {
		set exists = 1
	}
	
	if (exists = 1) {
		Quit 1	
	} else {
		Quit 0
	}
]]></Implementation>
</Method>

<Method name="IsLieferantGelistet">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date,AdressOidLieferant:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set strSQL = "SELECT ID FROM DBPlattform.LieferanteilDet WHERE Kopf->Kunde="_AdrOidAbnehmer_" AND Kopf->Mandant="_MandantOid_" AND Lieferant="_AdressOidLieferant_" AND Kopf->Artikel="_ArtikelOid_" AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKunde(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, '"_$ZDATE(Lieferdatum,3)_"')"
	//w "horologdings:"_Lieferdatum_" SQL: "_strSQL,!
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set pos = ""
	IF $$$ISOK(sc) {
		While rs.Next(.sc) {
			Set pos=rs.Data("ID")
		}
	}
	quit (pos'="")
]]></Implementation>
</Method>

<Method name="IsLieferantGelistetWeb">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,ArtikelOid:%String,AdrOidAbnehmer:%String,Lieferdatum:%Date,AdressOidLieferant:%String</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	set strSQL = "SELECT ID FROM DBPlattform.LieferanteilDet WHERE Kopf->Kunde="_AdrOidAbnehmer_" AND Kopf->Mandant="_MandantOid_" AND Lieferant="_AdressOidLieferant_" AND Kopf->Artikel="_ArtikelOid_" AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, "_Lieferdatum_")"
	//w "horologdings:"_Lieferdatum_" SQL: "_strSQL,!
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	
	set pos = ""
	IF $$$ISOK(sc) {
		While rs.Next(.sc) {
			Set pos=rs.Data("ID")
		}
	}
	quit (pos'="")
]]></Implementation>
</Method>

<Method name="SelectArtikelByDays">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrOidLieferant:%String,AdressOidVZ:%String,FirstLieferdatum:%Date,AnzTage:%Integer</FormalSpec>
<ReturnType>%ScrollableResultSet</ReturnType>
<Implementation><![CDATA[
	/*
	 * Grundsätzlich ist diese Abfrage problematisch bzw. sehr langsam
	 * Es muss für jeden Tag abgefragt werden, welche Artikel ein Lieferant liefern kann,
	 * um danach auf dem GUI entscheiden zu können, ob er zu einem gewissen Tag ein
	 * Angebot für einen bestimmten Artikel eingeben darf oder nicht.
	 * Was quasi in einem 31-fachen Union all endet bzw. FirstLieferdatum plus Anzahl Tage,
	 * denn auf der Lieferanteil Tabelle existiert lediglich ein AbDatum. Somit muss AbDatum
	 * nicht in diesem angegebenen Bereich liegen
	 */
	
	
	Set startHorolog = FirstLieferdatum
	Set endHorolog = FirstLieferdatum + (AnzTage-1)
	Set strSQL = "SELECT * FROM ("
	
	For indexHorolog=startHorolog:1:endHorolog {
		
		Set strSQL = strSQL_"(SELECT DISTINCT l.Kopf->Artikel->ID As ArtikelId, "
		Set strSQL = strSQL_"l.Kopf->Artikel->ArtikelNr As ArtikelNr, "
		Set strSQL = strSQL_"DBAgrofresh.Artikel_GetArtikeltextClass(l.Kopf->Artikel, l.Kopf->Mandant, 'de') As Artikeltext, "
		Set strSQL = strSQL_"l.Kopf->Aktiv As Aktiv, "
		Set strSQL = strSQL_indexHorolog_" As Anfragedatum "
		Set strSQL = strSQL_"FROM DBPlattform.LieferanteilDet l "
		Set strSQL = strSQL_"WHERE l.Kopf->Mandant = '"_MandantOid_"' AND l.Lieferant = '"_AdrOidLieferant_"' "
		Set strSQL = strSQL_"AND l.Kopf->Artikel->ArtikelAktiv = 1 "
		if (AdressOidVZ '= -1) {
			Set strSQL = strSQL_"AND l.Kopf->Kunde = '"_AdressOidVZ_"' "
		}
		Set strSQL = strSQL_"AND l.Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeDotNet(l.Kopf->Mandant, l.Kopf->Artikel, l.Kopf->Kunde, "_indexHorolog_"))"
	
		if (indexHorolog '= endHorolog) {
			Set strSQL = strSQL_" UNION ALL "		
		}	
	}
	
	Set strSQL = strSQL_") ORDER BY ArtikelNr"

	Set rs = ##class(%Library.ScrollableResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()	
	IF $$$ISOK(sc) {
		quit rs
	} else {
		quit ""
	}
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.LieferanteilD</DataLocation>
<DefaultData>LieferanteilDefaultData</DefaultData>
<IdLocation>^DBPlattform.LieferanteilD</IdLocation>
<IndexLocation>^DBPlattform.LieferanteilI</IndexLocation>
<StreamLocation>^DBPlattform.LieferanteilS</StreamLocation>
<Data name="LieferanteilDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Artikel</Value>
</Value>
<Value name="3">
<Value>Kunde</Value>
</Value>
<Value name="4">
<Value>Lieferant</Value>
</Value>
<Value name="5">
<Value>Mandant</Value>
</Value>
<Value name="6">
<Value>Jahr</Value>
</Value>
<Value name="7">
<Value>AnteilProzent</Value>
</Value>
<Value name="8">
<Value>Nachlieferung</Value>
</Value>
<Value name="9">
<Value>ZielmengeCol</Value>
</Value>
<Value name="10">
<Value>MengeJeJahr</Value>
</Value>
<Value name="11">
<Value>Rundung</Value>
</Value>
<Value name="12">
<Value>Abzuege</Value>
</Value>
<Value name="13">
<Value>Datum</Value>
</Value>
<Value name="14">
<Value>Lieferdifferenz</Value>
</Value>
<Value name="15">
<Value>MindestmengeNachlief</Value>
</Value>
<Value name="16">
<Value>GueltigVon</Value>
</Value>
<Value name="17">
<Value>GueltigBis</Value>
</Value>
<Value name="18">
<Value>Aktiv</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Abzuege"/>
<Property name="Aktiv">
</Property>
<Property name="AnteilProzent"/>
<Property name="Artikel">
</Property>
<Property name="Datum">
</Property>
<Property name="GueltigBis"/>
<Property name="GueltigVon"/>
<Property name="HasDetails">
</Property>
<Property name="Jahr"/>
<Property name="Kunde">
</Property>
<Property name="Lieferant"/>
<Property name="Lieferdifferenz"/>
<Property name="Mandant">
</Property>
<Property name="MengeJeJahr"/>
<Property name="MindestmengeNachlief"/>
<Property name="Nachlieferung"/>
<Property name="Rundung"/>
<Property name="ZielmengeCol"/>
</Storage>
</Class>


<Class name="DBPlattform.LieferanteilDet">
<Super>%Persistent,%Populate,%XML.Adaptor</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61809,36433.29162</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="Kopf">
<Type>DBPlattform.Lieferanteil</Type>
<Cardinality>parent</Cardinality>
<Inverse>Details</Inverse>
<Relationship>1</Relationship>
</Property>

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

<Index name="LieferantIndex">
<Properties>Lieferant</Properties>
</Index>

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

<Property name="Nachlieferung">
<Description>
0 - Ja
1 - bedingt
2 - Nein</Description>
<Type>%Integer</Type>
</Property>

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

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

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

<Index name="AbzuegeIndex">
<Properties>Abzuege</Properties>
</Index>

<Method name="GetLieferdifferenz">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrOidAbnehmer:%String,AdrOidLieferant:%String,ArtikelOid:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%Decimal</ReturnType>
<ReturnTypeParams>SCALE=5</ReturnTypeParams>
<Implementation><![CDATA[
	set diff = 0
	set strSQL = "SELECT Lieferdifferenz FROM DBPlattform.LieferanteilDet"_
		" WHERE Kopf->Mandant = "_MandantOid_" AND Kopf->Kunde = "_AdrOidAbnehmer_
		" AND Lieferant = "_AdrOidLieferant_" AND Kopf->Artikel = "_ArtikelOid_
		" AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeCOS(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, "_Lieferdatum_")"
	
	//set diff = 0
	//Set rs = ##class(%Library.ResultSet).%New("DBPlattform.AF.LieferanteilAF:GetLieferdifferenz")
	//Set sc=rs.%Execute(MandantOid, AdrOidAbnehmer, AdrOidLieferant, ArtikelOid, Lieferdatum)
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		while (rs.Next(.sc)) {
			Set diff =rs.Data("Lieferdifferenz")
		}
	}
	
	Quit diff
]]></Implementation>
</Method>

<Method name="GetLieferanteilDetId">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,AdrOidAbnehmer:%String,AdrOidLieferant:%String,ArtikelOid:%String,Lieferdatum:%Date</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	set strSQL = "SELECT ID FROM DBPlattform.LieferanteilDet"_
		" WHERE Kopf->Mandant = "_MandantOid_" AND Kopf->Kunde = "_AdrOidAbnehmer_
		" AND Lieferant = "_AdrOidLieferant_" AND Kopf->Artikel = "_ArtikelOid_
		" AND Kopf->Datum = DBPlattform.Lieferanteil_GetDatumByArtKundeCOS(Kopf->Mandant, Kopf->Artikel, Kopf->Kunde, "_Lieferdatum_")"
	
	Set rs = ##class(%Library.ResultSet).%New("%DynamicQuery:SQL")
	Do rs.Prepare(strSQL)
	Set sc=rs.Execute()
	if $$$ISOK(sc) {
		if (rs.Next(.sc)) {
			Set id =rs.Data("ID")
		}
	}
	
	Quit id
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>{%%PARENT}("Details")</DataLocation>
<DefaultData>LieferanteilDetDefaultData</DefaultData>
<IdLocation>^DBPlattform.LieferanteilC("Details")</IdLocation>
<IndexLocation>^DBPlattform.LieferanteilDetI</IndexLocation>
<StreamLocation>^DBPlattform.LieferanteilDetS</StreamLocation>
<Data name="LieferanteilDetDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Lieferant</Value>
</Value>
<Value name="3">
<Value>AnteilProzent</Value>
</Value>
<Value name="4">
<Value>Nachlieferung</Value>
</Value>
<Value name="5">
<Value>MindestmengeNachlief</Value>
</Value>
<Value name="6">
<Value>Lieferdifferenz</Value>
</Value>
<Value name="7">
<Value>Abzuege</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="Abzuege">
</Property>
<Property name="AnteilProzent">
</Property>
<Property name="Kopf">
</Property>
<Property name="Lieferant">
</Property>
<Property name="Lieferdifferenz">
</Property>
<Property name="MindestmengeNachlief">
</Property>
<Property name="Nachlieferung">
</Property>
<Property name="childsub">
</Property>
</Storage>
</Class>


<Project name="DBPlattform" Target="##class(Alliance.Common.Generator).GetDesAdvEDIHeader()" TargetType="2">
  <Items>
    <ProjectItem name="DBPlattform.AF.AngebotAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.AuftragsKopfAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.AuftragsPosAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.BestKopfAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.BestPosAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.BestandAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.BudgetAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.LieferanteilAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.MengendispoAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.SD.ZeitrasterAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AF.TransportscheinAF" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AngebotsKopf" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AngebotsPos" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AuftragsKopf" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.AuftragsPos" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.BestKopf" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.BestPos" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.Budget" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.CSVStream" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.InactiveArticlesWeb" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.Lieferanteil" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.LieferanteilDet" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.ProvCSVGenerator" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.SD.Zeitraster" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.Transportschein" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.Verteilung" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.VerteilungEntry" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.VerteilungEntryV2" type="CLS"></ProjectItem>
    <ProjectItem name="DBPlattform.VerteilungV2" type="CLS"></ProjectItem>
  </Items>
</Project>


<Class name="DBPlattform.ProvCSVGenerator">
<Super>%RegisteredObject</Super>
<TimeChanged>62047,29665.584793</TimeChanged>
<TimeCreated>62047,29261.02518</TimeCreated>

<Parameter name="FilePath">
<Description>
Path to CSV File</Description>
<Default>C:\</Default>
</Parameter>

<Method name="Generate">
</Method>

<Method name="%OnNew">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%New</METHOD> method to 
provide notification that a new instance of an object is being created.

<P>If this method returns an error then the object will not be created.
<p>It is passed the arguments provided in the %New call.
When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
<p>Method %OnNew(dob as %Date = "", name as %Name = "") as %Status]]></Description>
<FormalSpec>initvalue:%CacheString</FormalSpec>
<Private>1</Private>
<ProcedureBlock>1</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	//read tmp file dir from agris settings to set the filepath parameter
	//TODO: Read Registry Key
	
	
	
	
	Quit $$$OK
]]></Implementation>
</Method>
</Class>


<Class name="DBPlattform.SD.Zeitraster">
<Super>%Persistent,%XML.Adaptor,DBCore.MandantRel</Super>
<TimeChanged>62423,58174</TimeChanged>
<TimeCreated>61774,31506.01603</TimeCreated>
<Inheritance>right</Inheritance>

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

<Parameter name="LiefermengeErfasst">
<Default>2</Default>
</Parameter>

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

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

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

<Property name="Tag">
<Description><![CDATA[
0-6, 0=Sonntag, 1=Montag etc. -> $zdate liefert auch diese wochentagszahlen, DayOfWeek in .Net ebenfalls]]></Description>
<Type>%Integer</Type>
<Required>1</Required>
</Property>

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

<Index name="DebitorIndex">
<Properties>Debitor</Properties>
</Index>

<Index name="Ident">
<Properties>Mandant,Debitor,Tag</Properties>
<Unique>1</Unique>
</Index>

<Property name="Zeit">
<Description>
Zeit Hauptbestellung</Description>
<Type>%Time</Type>
</Property>

<Property name="AngebotErfasst">
<Description>
relativer negativer Zeitpunkt in Bezug auf Zeit, an dem Angebot erfasst sein muss</Description>
<Type>%Integer</Type>
</Property>

<Method name="GetOidByTagVZ">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,Tag:%Integer,DebitorOid:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set retval = ""
	
	&sql(SELECT ID INTO :retval
		 FROM DBPlattform_SD.Zeitraster
		 WHERE Mandant = :MandantOid 
		 AND Tag = :Tag
		 AND Debitor = :DebitorOid)
	Set:(SQLCODE '= 0) retval = ""
	Quit retval
]]></Implementation>
</Method>

<Method name="AllowEdit">
<Description>
Überprüft anhand des Zeitrasters, ob ein Angebot/Liefermenge noch editiert/erfasst werden darf</Description>
<ClassMethod>1</ClassMethod>
<FormalSpec>type:%Integer,Lieferdatum:%Date,AbnehmerOid:%String,IsNachbestellung:%Boolean=0</FormalSpec>
<ReturnType>%Boolean</ReturnType>
<Implementation><![CDATA[
	
	set retval = $$$YES
	
	//type AngebotErfasst. Wenn type = LiefermengeErfasst, dann immer true zurück liefern
	if (type = ..#AngebotErfasst) {
		
		set debitor = ##class(DBDebiKredi.Debitor).%OpenId(AbnehmerOid)
		if (debitor '= $$$NULLOREF) {
			
			//Wochentag als Index 0 = Sonntag, 1 = Montag, etc.
			set weekday = $ZDATE(Lieferdatum,10)
			set oidZr = ##class(DBPlattform.SD.Zeitraster).GetOidByTagVZ(debitor.Adresse.Mandant,weekday, AbnehmerOid)
			set zr = ##class(DBPlattform.SD.Zeitraster).%OpenId(oidZr)
			if (zr '= $$$NULLOREF) {
				
				set dateHB = ##class(DBUtils.DateTime).newFromHorolog($PIECE(Lieferdatum,",",1))
				set dateHB = dateHB.addSeconds(zr.Zeit)
				set dateHB = dateHB.addDays(zr.AngebotErfasst)	
			
				set now = ##class(DBUtils.DateTime).now()
				if (dateHB.isAfter(now)) {
					set retval = $$$YES
				} else {
					set retval = $$$NO
				}
				kill zr
			}
			kill debitor
		}
	} 
	
	Quit retval
	
	
	/*
	//old
	set retval = 1
	set debitor = ##class(DBDebiKredi.Debitor).%OpenId(AbnehmerOid)
	if (debitor '= $$$NULLOREF) {
		set raster = $$$NULLOREF
		if (IsNachbestellung = 0) {
			set raster = debitor.Zeitraster
		} else {
			set raster = debitor.ZeitrasterNB
		}
		if (raster '= $$$NULLOREF) {
			set dateHB = ##class(DBUtils.DateTime).newFromHorolog($PIECE(Lieferdatum,",",1))
			set dateHB = dateHB.addSeconds(raster.ZeitHB)
			set dateHB = dateHB.addDays(raster.DifferenzTagHB)
			
			set val = 0
			if (type = ..#AngebotErfasst) {
				set val = raster.AngebotErfasst	
			} elseif (type = ..#LiefermengeErfasst) {
				set val = raster.LiefermengeErfasst	
			}
			
			set hours = $Normalize(val,-1)
			set minutes = 0
			if (hours '= 0) {
				set minutes = (val # hours)*100
			} else {
				set minutes = +(val*100)
			}
			//w "hours: "_hours,"minutes: "_minutes,!
			set angErf = dateHB.addHours(hours)
			set angErf = angErf.addMinutes(minutes)
			set now = ##class(DBUtils.DateTime).now()
			//do angErf.write()
			if (angErf.isAfter(now)) {
				set retval = 1
			} else {
				set retval = 0
			}
			  
			//Wenn kein Zeitraster zugewiesen ist, immer true zurückgeben
		} else {
			set retval = 1
		}
	}
	kill debitor
	
	*/
]]></Implementation>
</Method>

<Method name="GetEingabefristDateTime">
<ClassMethod>1</ClassMethod>
<FormalSpec>Lieferdatum:%Date,AbnehmerOid:%String</FormalSpec>
<ReturnType>DBUtils.DateTime</ReturnType>
<Implementation><![CDATA[
	//default
	set retval = ##class(DBUtils.DateTime).yesterday()
	
	set debitor = ##class(DBDebiKredi.Debitor).%OpenId(AbnehmerOid)
	if (debitor '= $$$NULLOREF) {
		
		//Wochentag als Index 0 = Sonntag, 1 = Montag, etc.
		set weekday = $ZDATE(Lieferdatum,10)
		set oidZr = ##class(DBPlattform.SD.Zeitraster).GetOidByTagVZ(debitor.Adresse.Mandant,weekday, AbnehmerOid)
		set zr = ##class(DBPlattform.SD.Zeitraster).%OpenId(oidZr)
		if (zr '= $$$NULLOREF) {
			
			set dateHB = ##class(DBUtils.DateTime).newFromHorolog($PIECE(Lieferdatum,",",1))
			set dateHB = dateHB.addSeconds(zr.Zeit)
			set dateHB = dateHB.addDays(zr.AngebotErfasst)	
			set retval = dateHB
			kill zr
		}
	
		kill debitor
	}
	Quit retval
]]></Implementation>
</Method>

<Method name="GetParamAngebotErfasst">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit ..#AngebotErfasst
]]></Implementation>
</Method>

<Method name="GetParamLiefermengeErfasst">
<ClassMethod>1</ClassMethod>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[	Quit ..#LiefermengeErfasst
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.SD.ZeitrasterD</DataLocation>
<DefaultData>ZeitrasterDefaultData</DefaultData>
<IdLocation>^DBPlattform.SD.ZeitrasterD</IdLocation>
<IndexLocation>^DBPlattform.SD.ZeitrasterI</IndexLocation>
<StreamLocation>^DBPlattform.SD.ZeitrasterS</StreamLocation>
<Data name="ZeitrasterDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>Mandant</Value>
</Value>
<Value name="3">
<Value>Tag</Value>
</Value>
<Value name="4">
<Value>Debitor</Value>
</Value>
<Value name="5">
<Value>Zeit</Value>
</Value>
<Value name="6">
<Value>AngebotErfasst</Value>
</Value>
</Data>
<Property name="%%CLASSNAME">
</Property>
<Property name="AngebotErfasst">
</Property>
<Property name="Debitor">
</Property>
<Property name="Mandant">
</Property>
<Property name="Tag">
</Property>
<Property name="Zeit">
</Property>
</Storage>
</Class>


<Class name="DBPlattform.Transportschein">
<Super>%Persistent,%XML.Adaptor</Super>
<TimeChanged>62416,57227.65807</TimeChanged>
<TimeCreated>62143,37683.98346</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="TransportNr">
<Description>
TransportNr</Description>
<Type>%Integer</Type>
</Property>

<Index name="MandantTransportNrIndex">
<Description>
Transpor tNr eingültig auf Mandant</Description>
<Properties>Mandant,TransportNr</Properties>
<Unique>1</Unique>
</Index>

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

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

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

<Property name="ScheinGedruckt">
<Description>
Transportscheingedruckt</Description>
<Type>%Boolean</Type>
</Property>

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

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

<Index name="SrcLagerortIndex">
<Properties>SrcLagerort</Properties>
</Index>

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

<Index name="DstLagerortIndex">
<Properties>DstLagerort</Properties>
</Index>

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

<Index name="SrcAdresseIndex">
<Properties>SrcAdresse</Properties>
</Index>

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

<Index name="DstAdresseIndex">
<Properties>DstAdresse</Properties>
</Index>

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

<Method name="GetIdByTransportNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,TransportNr:%Integer</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT ID INTO :id FROM DBPlattform.Transportschein WHERE Mandant = :MandantOid
		 AND TransportNr = :TransportNr)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetOpenIdByDstLagerort">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String,DstLagerort:%String</FormalSpec>
<ReturnType>%String</ReturnType>
<Implementation><![CDATA[
	set id = ""
	&sql(SELECT Top 1 ID INTO :id FROM DBPlattform.Transportschein WHERE Mandant = :MandantOid
		 AND DstLagerort = :DstLagerort AND NVL(ScheinGedruckt,0) = 0)
	Quit:(SQLCODE'=0) ""
	Quit id
]]></Implementation>
</Method>

<Method name="GetNextTransportscheinNr">
<ClassMethod>1</ClassMethod>
<FormalSpec>MandantOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set nr = 0
	set typ = ##class(DBCore.FormularNr).FormNrDispoTransportschein()
	// Neue Nummer auslessen
	SET nr=$INCREMENT(^FormularNr(MandantOid, typ))
	Quit nr
]]></Implementation>
</Method>

<Method name="GetAnzPosById">
<ClassMethod>1</ClassMethod>
<FormalSpec>TransportOid:%String</FormalSpec>
<ReturnType>%Integer</ReturnType>
<Implementation><![CDATA[
	set count = 0
	&sql(SELECT Count(ID) INTO :count FROM DBAgrofreshEK.ChargenEingang WHERE Transportschein = :TransportOid)
	Quit:(SQLCODE'=0) 0
	Quit count
]]></Implementation>
</Method>

<Storage name="Default">
<Type>%Library.CacheStorage</Type>
<DataLocation>^DBPlattform.TransportscheinD</DataLocation>
<DefaultData>TransportscheinDefaultData</DefaultData>
<IdLocation>^DBPlattform.TransportscheinD</IdLocation>
<IndexLocation>^DBPlattform.TransportscheinI</IndexLocation>
<StreamLocation>^DBPlattform.TransportscheinS</StreamLocation>
<Data name="TransportscheinDefaultData">
<Structure>listnode</Structure>
<Subscript/>
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>TransportNr</Value>
</Value>
<Value name="3">
<Value>Erfassungsdatum</Value>
</Value>
<Value name="4">
<Value>Transportdatum</Value>
</Value>
<Value name="5">
<Value>SrcLagerort</Value>
</Value>
<Value name="6">
<Value>DstLagerort</Value>
</Value>
<Value name="7">
<Value>Mandant</Value>
</Value>
<Value name="8">
<Value>Direktverkauf</Value>
</Value>
<Value name="9">
<Value>ScheinGedruckt</Value>
</Value>
<Value name="10">
<Value>SrcAdresse</Value>
</Value>
<Value name="11">
<Value>DstAdresse</Value>
</Value>
<Value name="12">
<Value>Bemerkung</Value>
</Value>
</Data>
<Property name="Bemerkung"/>
<Property name="Direktverkauf"/>
<Property name="DstAdresse"/>
<Property name="DstLagerort"/>
<Property name="Erfassungsdatum"/>
<Property name="Mandant"/>
<Property name="ScheinGedruckt"/>
<Property name="SrcAdresse"/>
<Property name="SrcLagerort"/>
<Property name="TransportNr"/>
<Property name="Transportdatum"/>
</Storage>
</Class>


<Class name="DBPlattform.Verteilung">
<Super>%RegisteredObject</Super>
<TimeChanged>62241,60461.686938</TimeChanged>
<TimeCreated>61766,37577.489309</TimeCreated>

<Property name="AnzahlGebinde">
<Description>
Anzahl Gebinde</Description>
<Type>%Integer</Type>
</Property>

<Property name="AnzahlJePalette">
<Description>
Anzahl Gebinde je Palette</Description>
<Type>%Integer</Type>
</Property>

<Property name="Lieferanten">
<Type>VerteilungEntry</Type>
<Collection>list</Collection>
</Property>

<Method name="AddLieferanteil">
<FormalSpec>FibuMandOid:%String,LieferanteilID:%String,Lieferdatum:%Date,ManuellEingelesen:%Boolean=0,CheckAngebot:%Boolean=1</FormalSpec>
<Implementation><![CDATA[
	set entry = ##class(DBPlattform.VerteilungEntry).%New()
	set lieferanteil = ##class(DBPlattform.LieferanteilDet).%OpenId(LieferanteilID)
	set entry.LieferantID = lieferanteil.Lieferant.%Id()
	set entry.AnteilProzent = lieferanteil.AnteilProzent
	set entry.Lieferdifferenz = lieferanteil.Lieferdifferenz
	set entry.MindestmengeNachlief = lieferanteil.MindestmengeNachlief
	set entry.Nachlieferung = lieferanteil.Nachlieferung
	
	//Angebot holen und setzen
	set abnehmerOid = ##class(DBDebiKredi.Debitor).GetIdByAdrOid(FibuMandOid, lieferanteil.Kopf.Kunde.%Id())
	set lieferantOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(FibuMandOid, lieferanteil.Lieferant.%Id())
	set angM = 0
	if (CheckAngebot = $$$YES) {
		if (ManuellEingelesen = 0) {
			set angM = ##class(DBPlattform.AngebotsPos).GetAngebot(Lieferdatum, abnehmerOid, lieferantOid, lieferanteil.Kopf.Artikel.%Id(), lieferanteil.Kopf.Mandant)
		} else {
			set angM = ##class(DBPlattform.AngebotsPos).GetAngebotDotNet(Lieferdatum, abnehmerOid, lieferantOid, lieferanteil.Kopf.Artikel.%Id(), lieferanteil.Kopf.Mandant)
		}
	// wenn Angebot nicht berücksichtigt werden soll, auf hohen Wert
	// setzen der nie in der Praxis vorkommt -> somit hat es keinen Einfluss
	// -> einfacher als überall zusätzlich nochmals zu checken
	} else {
		set angM = 99999999	
	}
	set entry.Angebotsmenge = angM
	
	do ..Lieferanten.Insert(entry)
]]></Implementation>
</Method>

<Method name="AdjustAnteile">
<Implementation><![CDATA[
	
	set anz = ..Lieferanten.Count()
	set sumAnteileOhneNachlief = 0
	set summeProzNeu = 0
	
	//Summe aller Prozente, welche Nachlieferungen machen berechnen
	for i = 1:1:anz {
		set e = ..Lieferanten.GetAt(i)
		if (e.Nachlieferung '= 2) {
			set sumAnteileOhneNachlief = sumAnteileOhneNachlief + e.AnteilProzent
		
			//Lieferant ohne Nachlieferungen		
		} else {
			set e.AnteilProzentAlt = e.AnteilProzent
			set e.AnteilProzent = 0
		}	
	}
	w "summe ant: "_sumAnteileOhneNachlief
	
	set maxProz = -1
	set liefMaxProz = -1
	
	//Schlüssel neu berechnen
	for idx = 1:1:anz {
		set lief = ..Lieferanten.GetAt(idx)
		//neue ProzentAnteile für Lieferanten mit Nachlieferung berechnen
		if (lief.Nachlieferung '= 2) {
			
			set pNeu = (lief.AnteilProzent / sumAnteileOhneNachlief ) * 100
			set lief.AnteilProzentAlt = lief.AnteilProzent
			set lief.AnteilProzent = $NORMALIZE(pNeu,2)
			set summeProzNeu = summeProzNeu + lief.AnteilProzent
			
			if (idx = 1) {
				set maxProz = lief.AnteilProzent
				set liefMaxProz = lief
				
			} elseif (lief.AnteilProzent > maxProz) {
				set maxProz = lief.AnteilProzent
				set liefMaxProz = lief
			}
		}
	}
	
	set diff = 100 - summeProzNeu
	if (liefMaxProz '= -1) {
		set liefMaxProz.AnteilProzent = liefMaxProz.AnteilProzent + diff
	}
]]></Implementation>
</Method>

<Method name="%OnNew">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%New</METHOD> method to 
provide notification that a new instance of an object is being created.

<P>If this method returns an error then the object will not be created.
<p>It is passed the arguments provided in the %New call.
When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
<p>Method %OnNew(AnzGeb As %Integer, AnzJePal As %Integer) as %Status]]></Description>
<FormalSpec>AnzGeb:%Integer,AnzJePal:%Integer</FormalSpec>
<Private>1</Private>
<ProcedureBlock>1</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	if ((AnzGeb <= 0) || (AnzJePal <= 0)) {
		Quit $$$ERROR($$$GeneralError,"AnzGeb oder AnzJePal ist 0")	
	}
	set ..AnzahlGebinde = AnzGeb
	set ..AnzahlJePalette = AnzJePal
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="CalcVerteilung">
<FormalSpec>IsNachBestellung:%Boolean</FormalSpec>
<Implementation><![CDATA[
	set anz = ..Lieferanten.Count()
	set anzGeb = ..AnzahlGebinde
	set anzJePal = ..AnzahlJePalette
	
	if (anzJePal <= 0) {
		w "ANZAHL JE PALETTE NICHT BEI ALLEN GEBINDEN EINGESTELLT"
		Quit 
	}
	set keineGanzePalette = 0
	set rest = 0
	set anzPalettenVergeben = 0
	set anzGebindeVergeben = 0
	set gesamteAnzahlPaletten = anzGeb / anzJePal
	set maxVollePaletten = ($NORMALIZE(gesamteAnzahlPaletten,-1))
	set groesseAnbruchPalette = 0
	if (maxVollePaletten = 0) {
		set groesseAnbruchPalette = gesamteAnzahlPaletten
	} else {
		set groesseAnbruchPalette = gesamteAnzahlPaletten # maxVollePaletten
	}
	
	set lieferantgroessteAnzPal = -1
	set groessteAnzPal = -1
	set cnt1 = 0
	
	for idx=1:1:anz {
		
		set entry = ..Lieferanten.GetAt(idx)
		set anzP = entry.AnteilProzent
		set liefD = entry.Lieferdifferenz
		
		//Menge alt berechnen (bei Nachlieferungen)
		set anzProzentAlt = entry.AnteilProzentAlt
		
		set entry.AnteileBerechnetAlt = $NORMALIZE(((anzGeb / 100) * anzProzentAlt),0)	
		w "Menge alt: "_entry.AnteileBerechnet
		
		
		//Menge berechnen
		set menge = $NORMALIZE(((anzGeb / 100) * anzP),0)
		set entry.AnteileBerechnet = menge
		w "Menge neu: "_menge
		set totPalOpt = menge + liefD
		
		//wenn lieferdifferenz stark im Minus -> totPalOpt auf 0 setzen
		if (totPalOpt < 0) {
			set totPalOpt = 0
		}
		
		//Kommastellen abschneiden
		set anzPal = $NORMALIZE((totPalOpt / anzJePal),-1)
		
		set totNeu = anzPal * anzJePal
		
		//muss kleiner oder gleich sein, weil sonst zuviel zugewiesen wird
		if (totNeu > anzGeb) {
			w "tot neu darf hier niht 0 sein",!
			set totNeu = $NORMALIZE(menge,-1)
			set anzPal = $NORMALIZE((anzJePal / totNeu),-1)
		
		//Anteil zu klein -> vorerst zu Rest hinzufügen	
		} elseif (totNeu = 0) {
			set rest = rest + menge
			set entry.AnzPaletten = 0
			set entry.AnteilInAnzGebinde = 0
			if (IsNachBestellung = 0) {
				set entry.LieferdifferenzNeu = liefD + entry.AnteileBerechnet
			} else {
				set entry.LieferdifferenzNeu = liefD + entry.AnteileBerechnetAlt
			}
			CONTINUE
		}
		w "check mindest",totNeu,!
		if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2) && (totNeu >= entry.MindestmengeNachlief))) {
			set cnt1 = cnt1 + 1
			// Beim ersten Durchlauf den ersten setzen
			if (cnt1 = 1) {
				set groessteAnzPal = anzPal
				set lieferantgroessteAnzPal = entry.LieferantID
		
			} elseif (groessteAnzPal < anzPal) {
				set groessteAnzPal = anzPal
				set lieferantgroessteAnzPal = entry.LieferantID
			}
		
			set entry.AnzPaletten = anzPal
			set anzPalettenVergeben = anzPalettenVergeben + anzPal
			set entry.AnteilInAnzGebinde = totNeu
			set anzGebindeVergeben = anzGebindeVergeben + totNeu
			if (IsNachBestellung = 0) {
				set entry.LieferdifferenzNeu = liefD + (menge - totNeu)
			} else {
				set entry.LieferdifferenzNeu = liefD + (entry.AnteileBerechnetAlt - totNeu)
			}
		}
		
	}
	w "check zuviele paletten vergeben",anzPalettenVergeben," ", maxVollePaletten,!
	// Zuviele Paletten vergeben
	if (anzPalettenVergeben > maxVollePaletten) {
		
		//Differenz dem Lieferanten abziehen, welcher am meisten Paletten hat
		set diff = anzPalettenVergeben - maxVollePaletten
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			if (e.LieferantID = lieferantgroessteAnzPal) {
				set e.AnzPaletten = e.AnzPaletten - diff
				
				//alte anz gebinde von saldo abziehen
				set anzGebindeVergeben = anzGebindeVergeben - e.AnteilInAnzGebinde 
				set e.AnteilInAnzGebinde = anzJePal *  e.AnzPaletten
				//neue anz gebinde zum saldo dazuzählen
				set anzGebindeVergeben = anzGebindeVergeben + e.AnteilInAnzGebinde
				set e.LieferdifferenzNeu = e.Lieferdifferenz + (e.AnteileBerechnet - e.AnteilInAnzGebinde)
			}
		}
	} 
	// keinem konnte eine ganze Palette zugewiesen werden
	// wähle den, mit dem höchsten Anteil + Lieferdiff aus und weise
	// ganzen Posten ihm zu
	if (rest = anzGeb) {
		
		set keineGanzePalette = 1
		
		set hoechsterAnteil = 0
		set liefMitHoechstemAnteil = -1
		
		//höchsten ermitteln
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			set antGesamt = e.AnteilInAnzGebinde + e.Lieferdifferenz
			if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && (anzGeb >= e.MindestmengeNachlief))) {
				if (idx = 1) {
					set hoechsterAnteil = antGesamt	
					set liefMitHoechstemAnteil = e.LieferantID
				}
				if (hoechsterAnteil < antGesamt) {
					set hoechsterAnteil = antGesamt	
					set liefMitHoechstemAnteil = e.LieferantID
				}
			}
		}
		
		//Werte setzen
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			if (e.LieferantID = liefMitHoechstemAnteil) {
				set e.AnteilInAnzGebinde = anzGeb
				set aP = maxVollePaletten
				if (groesseAnbruchPalette > 0) {
					set aP = aP + 1	
				}	
				set e.AnzPaletten = aP
				set anzPalettenVergeben = aP
				set anzGebindeVergeben = anzGeb
			
			} else {
				// alle kleineren Nullen
				set e.AnteilInAnzGebinde = 0
				set e.AnzPaletten = 0
			}
			set e.LieferdifferenzNeu = e.Lieferdifferenz + (e.AnteileBerechnet - e.AnteilInAnzGebinde)
			
		}
	
	}
	
	//Rest verteilen, sofern nicht alle schon einem einzigen zugeweisen wurden
	if (keineGanzePalette = 0) {
		
		set rest = anzGeb - anzGebindeVergeben
		w !,"NOCH ZU VERTEILEN: "_rest,!
		
		set hoechsteLieferDiff = 0
		set liefMitHoechsterDiff = -1
		
		//solange ganze Palletten verteilt werden können, jeweils immer
		//den mit der grössten Lieferdifferenz auswählen
		while (rest >= anzJePal) {
			w "in while ganze pal",anz,!
			set cnt2 = 0
			for idx=1:1:anz {
				set e = ..Lieferanten.GetAt(idx)
				w !," dif: "_e.LieferdifferenzNeu,!
				w !," prüfmenge: "_e.AnteilInAnzGebinde + anzJePal,!
				if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && ((e.AnteilInAnzGebinde + anzJePal)  >= e.MindestmengeNachlief))) {
					set cnt2 = cnt2 + 1
					if (cnt2 = 1) {
						set hoechsteLieferDiff = e.LieferdifferenzNeu
						set liefMitHoechsterDiff = e
				
					} elseif (hoechsteLieferDiff < e.LieferdifferenzNeu) {
						set hoechsteLieferDiff = e.LieferdifferenzNeu
						set liefMitHoechsterDiff = e
					}
				}
			}
			if (liefMitHoechsterDiff '= -1) {
				w "1palettgutschreiben",!
				// Werte auf höchstem anpassen, sprich 1 Palett gutschreiben
				set liefMitHoechsterDiff.AnzPaletten = liefMitHoechsterDiff.AnzPaletten + 1
				set anzPalettenVergeben = anzPalettenVergeben + 1
				set liefMitHoechsterDiff.AnteilInAnzGebinde = liefMitHoechsterDiff.AnteilInAnzGebinde + anzJePal
				set anzGebindeVergeben = anzGebindeVergeben + anzJePal
				set liefMitHoechsterDiff.LieferdifferenzNeu = liefMitHoechsterDiff.LieferdifferenzNeu - anzJePal
			
				set rest = rest - anzJePal
			} else {
				Quit	
			}
					
		}
		
		//Anbruch auf den Lieferanten ohne Nachlieferung geben
		//wenn keiner existiert, denjenigen mit der höchsten Lieferdifferenz
		//auswählen
		
		set lieferantOhneNachlief = -1
		set hoechsteDiffUnterLiefOhneNachlief = -1
		set hoechsteDiff = -1
		set lHoechsteDiff = -1
		set cntLieferantenOhneNachlief = 0
		set cnt3 = 0
		
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
		
			if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && ((e.AnteilInAnzGebinde + rest) >= e.MindestmengeNachlief))) {
				set cnt3 = cnt3 + 1
				//Initial Werte für die höchste Differenz setzen
				if (cnt3 = 1) {
					set hoechsteDiff = e.LieferdifferenzNeu
					set lHoechsteDiff = e
		
				} elseif (hoechsteDiff < e.LieferdifferenzNeu) {
						set hoechsteDiff = e.LieferdifferenzNeu
						set lHoechsteDiff = e
				}
			}
			if (IsNachBestellung = 0) {
				//Prüfung auf Nachlieferungen
				if (e.Nachlieferung = 2) {
					// Werte beim ersten setzen
					if (cntLieferantenOhneNachlief = 0) {
						set hoechsteDiffUnterLiefOhneNachlief = e.LieferdifferenzNeu
						set lieferantOhneNachlief = e
			
					} elseif(hoechsteDiffUnterLiefOhneNachlief < e.LieferdifferenzNeu) {
						set hoechsteDiffUnterLiefOhneNachlief = e.LieferdifferenzNeu
						set lieferantOhneNachlief = e
					}	
			
					set cntLieferantenOhneNachlief = cntLieferantenOhneNachlief +1
			
				}
			}
		
		}
		set restInPal = rest / anzJePal
	
		if (lieferantOhneNachlief '= (-1)) {
			set lieferantOhneNachlief.AnzPaletten = lieferantOhneNachlief.AnzPaletten + 1
			set anzPalettenVergeben = anzPalettenVergeben + 1
			set lieferantOhneNachlief.AnteilInAnzGebinde = lieferantOhneNachlief.AnteilInAnzGebinde + rest
			set anzGebindeVergeben = anzGebindeVergeben + rest
			set lieferantOhneNachlief.LieferdifferenzNeu = lieferantOhneNachlief.LieferdifferenzNeu - rest
		} else {
			if (lHoechsteDiff '= -1) {
				set lHoechsteDiff.AnzPaletten = lHoechsteDiff.AnzPaletten + 1
				set anzPalettenVergeben = anzPalettenVergeben + 1
				set lHoechsteDiff.AnteilInAnzGebinde = lHoechsteDiff.AnteilInAnzGebinde + rest
				set anzGebindeVergeben = anzGebindeVergeben + rest
				set lHoechsteDiff.LieferdifferenzNeu = lHoechsteDiff.LieferdifferenzNeu - rest
			}
		}
	
	}
	
	
	//NUR FÜR KONTROLLE
	for idx=1:1:anz {
		set e = ..Lieferanten.GetAt(idx)
		W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu," Ant berechnet: "_e.AnteileBerechnet,!
	}
	
	w !,"Paletten vergeben: "_anzPalettenVergeben,!
]]></Implementation>
</Method>

<Method name="AngebotsAbgleich">
<FormalSpec>IsNachBestellung:%Boolean</FormalSpec>
<Implementation><![CDATA[
	
	w !,"AngebotsAbgleich gestartet",!
	set anz = ..Lieferanten.Count()
	set anzGeb = ..AnzahlGebinde
	set anzJePal = ..AnzahlJePalette
	
	if (anzJePal <= 0) {
		w "ANZAHL JE PALETTE NICHT BEI ALLEN ARTIKELN EINGESTELLT"
		Quit 
	}
	
	//NUR FÜR KONTROLLE
	for idx=1:1:anz {
		set e = ..Lieferanten.GetAt(idx)
		W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu, " Angebot: ",e.Angebotsmenge,!
	}
	

	for idx=1:1:anz {
		set entry = ..Lieferanten.GetAt(idx)
		set rest = 0
		if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2))) {
			
			if (entry.AnteilInAnzGebinde > entry.Angebotsmenge) {
				
				set diff = 0
				//Angebot kann kleiner null sein, wenn er doch schon mehr liefern konnte
				if (entry.Angebotsmenge < 0) {
					set diff = entry.AnteilInAnzGebinde
				} else {
					set diff = (entry.AnteilInAnzGebinde - entry.Angebotsmenge)
				}
				set rest = rest + diff
				set entry.AnteilInAnzGebinde = entry.AnteilInAnzGebinde - diff
				set anzPal = $NORMALIZE((entry.AnteilInAnzGebinde / anzJePal),0)
				set entry.AnzPaletten = anzPal
				set entry.LieferdifferenzNeu = entry.LieferdifferenzNeu + diff
				
				w "verkleinern aufgrund angebotsmangel, neue menge: "_entry.AnteilInAnzGebinde,!
			
				//*******************************************************************************
				//Versuchen, die übriggebliebene Menge auf die anderen Lieferanten zu verteilen
				//gemäss deren Angebot
				//*******************************************************************************
				
				//Ganze Paletten verteilen, sofern noch genug Angebot übrig ist
				if (rest >= anzJePal) {
					for idx2=1:1:anz {
						//nochmals prüfen, da rest evt verändert wurde
						if (rest >= anzJePal) {
							set uebrigerLieferant = ..Lieferanten.GetAt(idx2)
							if (uebrigerLieferant.LieferantID '= entry.LieferantID) {
					
								if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (uebrigerLieferant.Nachlieferung '= 2) && (anzJePal >= uebrigerLieferant.MindestmengeNachlief))) {
		
									//Noch Menge verfügbar?
									if (uebrigerLieferant.AnteilInAnzGebinde < uebrigerLieferant.Angebotsmenge) {
										set uebrigeMenge = uebrigerLieferant.Angebotsmenge - uebrigerLieferant.AnteilInAnzGebinde
							
										//wenn übrige Menge grösser als ein Palett -> 1 Palett gutschreiben
										if (uebrigeMenge >= anzJePal) {
											set uebrigerLieferant.AnteilInAnzGebinde = uebrigerLieferant.AnteilInAnzGebinde + anzJePal
											set anzPal = $NORMALIZE((uebrigerLieferant.AnteilInAnzGebinde / anzJePal),0)
											set uebrigerLieferant.AnzPaletten = anzPal
											set uebrigerLieferant.LieferdifferenzNeu = uebrigerLieferant.LieferdifferenzNeu - anzJePal		
											set rest = rest - anzJePal
										}
						
									}
								
								}
							}
						}
					} 
				}
				//Restwert auf alle anderen Lieferanten aufteilen, bis zur Angebotsgrenze
				//1. Prio: Lieferanten mit einem Anbruchspalett und verfügbarem Angebot
				//2. Prio: übrige Lieferanten mit verfügbarem Angebot
				set lieferantenMitAnbruch = ""
		
				for idx3=1:1:anz {
					set uLieferant = ..Lieferanten.GetAt(idx3)
					if (uLieferant.LieferantID '= entry.LieferantID) {
						if (uLieferant.AnteilInAnzGebinde < uLieferant.Angebotsmenge) {
							if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (uLieferant.Nachlieferung '= 2))) {

								//Lieferanten mit Anbruch bestimmen
								if ((uLieferant.AnteilInAnzGebinde # anzJePal) '= 0) {
									set lieferantenMitAnbruch = lieferantenMitAnbruch_$lb(uLieferant.LieferantID)
								}
							}
						}
					}
				}
				//Anbruchlieferant auf ganze Palette auffüllen bzw. bis auf Angebotsgrenze auffüllen
				for i = 1:1:$ListLength(lieferantenMitAnbruch) {
					set liefID = $ListGet(lieferantenMitAnbruch, i)
					set lief = -1
					//passenden Entry holen
					for tmp=1:1:anz {
						set aktL = ..Lieferanten.GetAt(idx3)
						if (aktL.LieferantID = liefID) {
							set lief = aktL
							Quit
						}
					}
					if (lief '= -1) {
						w "lief: "_lief,"anteil: "_lief.AnteilInAnzGebinde,!
						set diffAufGanzesPal = anzJePal - (lief.AnteilInAnzGebinde # anzJePal)
						set verfuegbar = lief.Angebotsmenge - lief.AnteilInAnzGebinde
						set me = 0
						set updEntry = 0
				
						//wenn Rest grösser oder gleich Differenz auf ganze Palette -> Differenz gutschreiben
						if ((rest >= diffAufGanzesPal) && (diffAufGanzesPal <= verfuegbar)) {
							set updEntry = 1
							set me = diffAufGanzesPal

						// wenn Rest kleiner als Differenz auf ganze Palette und
						// kleiner oder gleich der noch verfügbaren Menge -> Rest gutschreiben
						} elseif((rest < diffAufGanzesPal) && (rest <= verfuegbar)) {
							set updEntry = 1
							set me = rest
				
						//wenn Rest > verfuegbar -> verfügbare Menge gutschreiben und von Rest abziehen
						} elseif((rest < diffAufGanzesPal) && (rest > verfuegbar)) {
							set updEntry = 1
							set me = verfuegbar
					
						}
						if (updEntry = 1) {
							if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (uLieferant.Nachlieferung '= 2) && ((lief.AnteilInAnzGebinde + me) >= lief.MindestmengeNachlief))) {

								set lief.AnteilInAnzGebinde = lief.AnteilInAnzGebinde + me
								set anzPal = $NORMALIZE((lief.AnteilInAnzGebinde / anzJePal),0)
								set lief.AnzPaletten = anzPal
								set lief.LieferdifferenzNeu = lief.LieferdifferenzNeu - me		
								set rest = rest - me
							}
						}
				
					}
				} 
			
				//wenn noch Rest vorhanden -> versuchen auf die noch übrig gebliebenen zu verteilen
				if (rest > 0) {
					for idx4=1:1:anz {
						set restlLieferant = ..Lieferanten.GetAt(idx4)
						if (restlLieferant.LieferantID '= entry.LieferantID) {
								if (restlLieferant.AnteilInAnzGebinde < restlLieferant.Angebotsmenge) {
									set verf = restlLieferant.Angebotsmenge - restlLieferant.AnteilInAnzGebinde
									set updateLiefEntry = 0
									set menge = 0
									if (rest > verf) {
										set menge = verf
									} else {
										set menge = rest
									}
									
									if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (restlLieferant.Nachlieferung '= 2) && ((restlLieferant.AnteilInAnzGebinde + menge) >= restlLieferant.MindestmengeNachlief))) {
										set restlLieferant.AnteilInAnzGebinde = restlLieferant.AnteilInAnzGebinde + menge
										set anzPal = $NORMALIZE((restlLieferant.AnteilInAnzGebinde / anzJePal),0)
										set restlLieferant.AnzPaletten = anzPal
										set restlLieferant.LieferdifferenzNeu = restlLieferant.LieferdifferenzNeu - menge		
										set rest = rest - menge
									}
							
								}
							
						}
					}
				}			
			}
		}
			
	} // end for
	
	w !,"AngebotsAbgleich beendet",!
	
	//NUR FÜR KONTROLLE
	for idx=1:1:anz {
		set e = ..Lieferanten.GetAt(idx)
		W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu, " Ant berechnet: ",e.AnteileBerechnet, " Ant ber. alt: ", e.AnteileBerechnetAlt,!
	}
]]></Implementation>
</Method>
</Class>


<Class name="DBPlattform.VerteilungEntry">
<Super>%RegisteredObject</Super>
<TimeChanged>61773,43246.330127</TimeChanged>
<TimeCreated>61766,37438.356444</TimeCreated>

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

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

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

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

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

<Property name="Nachlieferung">
<Description>
0 - Ja
1 - bedingt
2 - Nein</Description>
<Type>%Integer</Type>
</Property>

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

<Property name="AnteilInAnzGebinde">
<Type>%Integer</Type>
<InitialExpression>0</InitialExpression>
</Property>

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

<Property name="AnteileBerechnetAlt">
<Description>
Für Nachlieferungen, wenn die Schlüssel neu verteilt werden, hier den alten Wert speichern
um die Lieferdifferenz zum Schluss richtig rechnen zu können</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

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

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


<Class name="DBPlattform.VerteilungEntryV2">
<Super>%RegisteredObject</Super>
<TimeChanged>61864,37944.085664</TimeChanged>
<TimeCreated>61850,50079.170146</TimeCreated>

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

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

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

<Property name="AnteilProzentTmp">
<Description>
Wenn aufgrund Angebotsmangel auf andere aufgeteilt wird, haben diese mehr Anteil
umgerechnet auf 100% zugute</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

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

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

<Property name="Nachlieferung">
<Description>
0 - Ja
1 - bedingt
2 - Nein</Description>
<Type>%Integer</Type>
</Property>

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

<Property name="AnteilInAnzGebinde">
<Type>%Integer</Type>
<InitialExpression>0</InitialExpression>
</Property>

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

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

<Property name="AnteileBerechnetAlt">
<Description>
Für Nachlieferungen, wenn die Schlüssel neu verteilt werden, hier den alten Wert speichern
um die Lieferdifferenz zum Schluss richtig rechnen zu können</Description>
<Type>%Decimal</Type>
<Parameter name="SCALE" value="5"/>
</Property>

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

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

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

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

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


<Class name="DBPlattform.VerteilungV2">
<Super>%RegisteredObject</Super>
<TimeChanged>62241,60428.540788</TimeChanged>
<TimeCreated>61850,50055.890941</TimeCreated>

<Property name="AnzahlGebinde">
<Description>
Anzahl Gebinde</Description>
<Type>%Integer</Type>
</Property>

<Property name="AnzahlJePalette">
<Description>
Anzahl Gebinde je Palette</Description>
<Type>%Integer</Type>
</Property>

<Property name="Lieferanten">
<Type>VerteilungEntry</Type>
<Collection>list</Collection>
</Property>

<Method name="AddLieferanteil">
<FormalSpec>FibuMandOid:%String,LieferanteilID:%String,Lieferdatum:%Date,ManuellEingelesen:%Boolean=0,CheckAngebot:%Boolean=1</FormalSpec>
<Implementation><![CDATA[
	set entry = ##class(DBPlattform.VerteilungEntryV2).%New()
	set lieferanteil = ##class(DBPlattform.LieferanteilDet).%OpenId(LieferanteilID)
	set entry.LieferantID = lieferanteil.Lieferant.%Id()
	set entry.AnteilProzent = lieferanteil.AnteilProzent
	set entry.AnteilProzentTmp = entry.AnteilProzent
	set entry.Lieferdifferenz = lieferanteil.Lieferdifferenz
	set entry.MindestmengeNachlief = lieferanteil.MindestmengeNachlief
	set entry.Nachlieferung = lieferanteil.Nachlieferung
	
	//Angebot holen und setzen
	set abnehmerOid = ##class(DBDebiKredi.Debitor).GetIdByAdrOid(FibuMandOid, lieferanteil.Kopf.Kunde.%Id())
	set lieferantOid = ##class(DBDebiKredi.Kreditor).GetIdByAdrOid(FibuMandOid, lieferanteil.Lieferant.%Id())
	set angM = 0
	if (CheckAngebot = $$$YES) {
		if (ManuellEingelesen = 0) {
			set angM = ##class(DBPlattform.AngebotsPos).GetAngebot(Lieferdatum, abnehmerOid, lieferantOid, lieferanteil.Kopf.Artikel.%Id(), lieferanteil.Kopf.Mandant)
		} else {
			set angM = ##class(DBPlattform.AngebotsPos).GetAngebotDotNet(Lieferdatum, abnehmerOid, lieferantOid, lieferanteil.Kopf.Artikel.%Id(), lieferanteil.Kopf.Mandant)
		}
	// wenn Angebot nicht berücksichtigt werden soll, auf hohen Wert
	// setzen der nie in der Praxis vorkommt -> somit hat es keinen Einfluss
	// -> einfacher als überall zusätzlich nochmals zu checken
	} else {
		set angM = 99999999	
	}
	set entry.Angebotsmenge = angM
	
	do ..Lieferanten.Insert(entry)
]]></Implementation>
</Method>

<Method name="AdjustAnteile">
<Implementation><![CDATA[
	
	set anz = ..Lieferanten.Count()
	set sumAnteileOhneNachlief = 0
	set summeProzNeu = 0
	
	//Summe aller Prozente, welche Nachlieferungen machen berechnen
	for i = 1:1:anz {
		set e = ..Lieferanten.GetAt(i)
		if (e.Nachlieferung '= 2) {
			set sumAnteileOhneNachlief = sumAnteileOhneNachlief + e.AnteilProzent
		
			//Lieferant ohne Nachlieferungen		
		} else {
			set e.AnteilProzentAlt = e.AnteilProzent
			set e.AnteilProzent = 0
			set e.AnteilProzentTmp = e.AnteilProzent
		}	
	}
	w "summe ant: "_sumAnteileOhneNachlief
	
	set maxProz = -1
	set liefMaxProz = -1
	
	//Schlüssel neu berechnen
	for idx = 1:1:anz {
		set lief = ..Lieferanten.GetAt(idx)
		//neue ProzentAnteile für Lieferanten mit Nachlieferung berechnen
		if (lief.Nachlieferung '= 2) {
			if (sumAnteileOhneNachlief '= 0) {
				set pNeu = (lief.AnteilProzent / sumAnteileOhneNachlief ) * 100
			} else {
				set pNeu = 0
			}
			set lief.AnteilProzentAlt = lief.AnteilProzent
			set lief.AnteilProzent = $NORMALIZE(pNeu,2)
			set lief.AnteilProzentTmp = lief.AnteilProzent
			set summeProzNeu = summeProzNeu + lief.AnteilProzent
			
			if (idx = 1) {
				set maxProz = lief.AnteilProzent
				set liefMaxProz = lief
				
			} elseif (lief.AnteilProzent > maxProz) {
				set maxProz = lief.AnteilProzent
				set liefMaxProz = lief
			}
		}
	}
	
	set diff = 100 - summeProzNeu
	if (liefMaxProz '= -1) {
		set liefMaxProz.AnteilProzent = liefMaxProz.AnteilProzent + diff
		set liefMaxProz.AnteilProzentTmp = liefMaxProz.AnteilProzent
	}
]]></Implementation>
</Method>

<Method name="%OnNew">
<Description><![CDATA[
This callback method is invoked by the <METHOD>%New</METHOD> method to 
provide notification that a new instance of an object is being created.

<P>If this method returns an error then the object will not be created.
<p>It is passed the arguments provided in the %New call.
When customizing this method, override the arguments with whatever variables and types you expect to receive from %New().
For example, if you're going to call %New, passing 2 arguments, %OnNew's signature could be:
<p>Method %OnNew(AnzGeb As %Integer, AnzJePal As %Integer) as %Status]]></Description>
<FormalSpec>AnzGeb:%Integer,AnzJePal:%Integer</FormalSpec>
<Private>1</Private>
<ProcedureBlock>1</ProcedureBlock>
<ReturnType>%Status</ReturnType>
<ServerOnly>1</ServerOnly>
<Implementation><![CDATA[
	if ((AnzGeb <= 0) || (AnzJePal <= 0)) {
		Quit $$$ERROR($$$GeneralError,"AnzGeb oder AnzJePal ist 0")	
	}
	set ..AnzahlGebinde = AnzGeb
	set ..AnzahlJePalette = AnzJePal
	
	Quit $$$OK
]]></Implementation>
</Method>

<Method name="CalcVerteilung">
<FormalSpec>IsNachBestellung:%Boolean</FormalSpec>
<Implementation><![CDATA[
	set anz = ..Lieferanten.Count()
	set anzGeb = ..AnzahlGebinde
	set anzJePal = ..AnzahlJePalette
	
	if (anzJePal <= 0) {
		w "ANZAHL JE PALETTE NICHT BEI ALLEN GEBINDEN EINGESTELLT"
		Quit 
	}
	set gesamteAnzahlPaletten = anzGeb / anzJePal
	set maxVollePaletten = ($NORMALIZE(gesamteAnzahlPaletten,-1))
	
	set angebotErschoepft = 0
	
	do {
		set anzPalettenVergeben = 0
		set anzGebindeVergeben = 0
			
		w "Aufzuteilende Menge in Anz. Geb: "_anzGeb,!
		
		set keineGanzePalette = 0
		set groesseAnbruchPalette = 0
		if (maxVollePaletten = 0) {
			set groesseAnbruchPalette = gesamteAnzahlPaletten
		} else {
			set groesseAnbruchPalette = gesamteAnzahlPaletten # maxVollePaletten
		}

		set rest = 0
		set lieferantgroessteAnzPal = ""
		set groessteAnzPal = -1
		set cnt1 = 0
	
		for idx=1:1:anz {
		
			set entry = ..Lieferanten.GetAt(idx)
			set anzP = entry.AnteilProzentTmp
			set liefD = entry.Lieferdifferenz
		
			//Menge alt berechnen (bei Nachlieferungen)
			set anzProzentAlt = entry.AnteilProzentAlt
		
			set mengeAlt = ((anzGeb / 100) * anzProzentAlt)
			set entry.AnteileBerechnetAltUngerundet = mengeAlt
			set entry.AnteileBerechnetAlt = $NORMALIZE(mengeAlt,0)	
			w "Menge alt: "_entry.AnteileBerechnet
		
		
			//Menge berechnen
			set menge = ((anzGeb / 100) * anzP)
			set entry.AnteileBerechnetUngerundet = menge
			set entry.AnteileBerechnet = $NORMALIZE(menge,0)
			w "Menge neu: "_menge, "AnteilPTemp"_anzP," LiefID: "_entry.LieferantID,!
			set totPalOpt = menge + liefD
		
			//wenn lieferdifferenz stark im Minus -> totPalOpt auf 0 setzen
			if (totPalOpt < 0) {
				set totPalOpt = 0
			}
			
			w !,"Total Pal Opt: "_totPalOpt,!
			
			//Kommastellen abschneiden
			set anzPal = $NORMALIZE((totPalOpt / anzJePal),-1)
			w !,"Anz Pal nach PalOpt: "_anzPal,!
			
			set totNeu = anzPal * anzJePal
			
			w !,"totNeu berechnet: "_totNeu,!
			
			//darf nicht mehr zugewiesen werden, als Angebot vorhanden ist
			//ansonsten auf letztes ganzes Palett zurück
			if ((totNeu > entry.Angebotsmenge) && (entry.Angebotsmenge >= 0)) {
				w !,"Versuch, mehr zuzuweisen, als durch angebot möglich",!
				set anzPal = $NORMALIZE((entry.Angebotsmenge / anzJePal),-1)
				set totNeu = anzPal * anzJePal
				w "totNeu: "_totNeu
				
			}
			
		
			//totNeu muss kleiner oder gleich sein, weil sonst zuviel zugewiesen wird
			//kann grösser werden je nach Lieferdifferenz
			if (totNeu > anzGeb) {
				w "tot neu darf hier nicht 0 sein",!
				//auf ganze Paletten zurück gehen
				set anzPal = $NORMALIZE((anzGeb/anzJePal),-1)
				set totNeu = anzPal * anzJePal
				
				if (totNeu > entry.Angebotsmenge) {
					set anzPal = $NORMALIZE((entry.Angebotsmenge / anzJePal),-1)
					set totNeu = anzPal * anzJePal
				}
				
		
			//Anteil zu klein -> vorerst zu Rest hinzufügen	
			} elseif (totNeu = 0) {
				w "Anteil zu klein -> vorerst zu Rest hinzufügen",!
				set rest = rest + menge
				set entry.AnzPaletten = 0
				set anzPal = 0
				set entry.AnteilInAnzGebinde = 0
				if (IsNachBestellung = 0) {
					set entry.LieferdifferenzNeu = liefD + entry.AnteileBerechnet
				} else {
					set entry.LieferdifferenzNeu = liefD + entry.AnteileBerechnetAlt
				}
				CONTINUE
			}
			
			w "check mindest",totNeu,!
			// Lieferant mit grösster Anz Paletten bestimmen
			if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2) && (totNeu >= entry.MindestmengeNachlief)) && (entry.AnteilProzent > 0)) {
				/*set cnt1 = cnt1 + 1
				// Beim ersten Durchlauf den ersten setzen
				if (cnt1 = 1) {
					set groessteAnzPal = anzPal
					set lieferantgroessteAnzPal = entry.LieferantID
		
				} elseif (groessteAnzPal < anzPal) {
					set groessteAnzPal = anzPal
					set lieferantgroessteAnzPal = entry.LieferantID
				}*/
		
				set entry.AnzPaletten = anzPal
				set anzPalettenVergeben = anzPalettenVergeben + anzPal
				set entry.AnteilInAnzGebinde = totNeu
				set anzGebindeVergeben = anzGebindeVergeben + totNeu
				if (IsNachBestellung = 0) {
					set entry.LieferdifferenzNeu = liefD + (menge - totNeu)
				} else {
					set entry.LieferdifferenzNeu = liefD + (entry.AnteileBerechnetAlt - totNeu)
				}
			}
		
		}
		
		do ..RoundAnteileBerechnet(IsNachBestellung)
		
		w "check zuviele paletten vergeben",anzPalettenVergeben," ", maxVollePaletten,!
		// Zuviele Paletten vergeben
		while (anzPalettenVergeben > maxVollePaletten) {
		
			set cntZ = 0
			for idx=1:1:anz {
				set e = ..Lieferanten.GetAt(idx)
				
				if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && (totNeu >= e.MindestmengeNachlief)) && (e.AnteilProzent > 0)) {
					set cntZ = cntZ + 1
					if (cntZ = 1) {
						set groessteAnzPal = e.AnzPaletten
						set lieferantgroessteAnzPal = e
					} elseif (groessteAnzPal < e.AnzPaletten) {
						set groessteAnzPal = e.AnzPaletten
						set lieferantgroessteAnzPal = e
					}
				}
			}
		
			//Differenz dem Lieferanten abziehen, welcher am meisten Paletten hat
			set diff = 1 //geändert->immer 1 abziehen --anzPalettenVergeben - maxVollePaletten
			set anzPalettenVergeben = anzPalettenVergeben - 1
			set lieferantgroessteAnzPal.AnzPaletten = lieferantgroessteAnzPal.AnzPaletten - diff
			//alte anz gebinde von saldo abziehen
			set anzGebindeVergeben = anzGebindeVergeben - lieferantgroessteAnzPal.AnteilInAnzGebinde 
			set lieferantgroessteAnzPal.AnteilInAnzGebinde = anzJePal *  lieferantgroessteAnzPal.AnzPaletten
			//neue anz gebinde zum saldo dazuzählen
			set anzGebindeVergeben = anzGebindeVergeben + lieferantgroessteAnzPal.AnteilInAnzGebinde
			set lieferantgroessteAnzPal.LieferdifferenzNeu = lieferantgroessteAnzPal.Lieferdifferenz + (lieferantgroessteAnzPal.AnteileBerechnet - lieferantgroessteAnzPal.AnteilInAnzGebinde)
			
			
			/*for idx=1:1:anz {
				set e = ..Lieferanten.GetAt(idx)
				if (e.LieferantID = lieferantgroessteAnzPal.LieferantID) {
					w !, "reduziere auf lieferantId: "_e.LieferantID,!
					set e.AnzPaletten = e.AnzPaletten - diff
				
					//alte anz gebinde von saldo abziehen
					set anzGebindeVergeben = anzGebindeVergeben - e.AnteilInAnzGebinde 
					set e.AnteilInAnzGebinde = anzJePal *  e.AnzPaletten
					//neue anz gebinde zum saldo dazuzählen
					set anzGebindeVergeben = anzGebindeVergeben + e.AnteilInAnzGebinde
					set e.LieferdifferenzNeu = e.Lieferdifferenz + (e.AnteileBerechnet - e.AnteilInAnzGebinde)
				}
			}*/
		} 
		
		set restNachAngebot = 0
		set restProzente = 0
		set isRestGroesser = 0
		do ..ReduziereAufAngebot(IsNachBestellung, .restNachAngebot, .restProzente, .anzPalettenVergeben,.anzGebindeVergeben)
		
		//if (restNachAngebot > 0) {
		//Restmenge auf die Lieferanten gem. Lieferanteilen aufteilen
		do ..RestGutschrift(IsNachBestellung, restNachAngebot, restProzente)
		//}
		
		do ..RoundAnteileBerechnet(IsNachBestellung)

		if (restNachAngebot > rest) {
			set isRestGroesser = 1	
		}
		set rest = restNachAngebot
	
		//Rest verteilen, sofern nicht alle schon einem einzigen zugeweisen wurden
		if (keineGanzePalette = 0) {
			
			set rest = anzGeb - anzGebindeVergeben
			w !,"NOCH ZU VERTEILEN: "_rest,!
		
			set hoechsteLieferDiff = 0
			set liefMitHoechsterDiff = -1
		
			//solange ganze Palletten verteilt werden können, jeweils immer
			//den mit der grössten Lieferdifferenz auswählen
			while (rest >= anzJePal) {
				w "in while ganze pal",anz,!
				set cnt2 = 0
				for idx=1:1:anz {
					set e = ..Lieferanten.GetAt(idx)
					w !," dif: "_e.LieferdifferenzNeu,!
					w !," prüfmenge: "_(e.AnteilInAnzGebinde + anzJePal),!
					if (((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && ((e.AnteilInAnzGebinde + anzJePal)  >= e.MindestmengeNachlief))) && (e.ProzenteAbgeschlagen '= 1) && ((e.AnteilInAnzGebinde + anzJePal) <= e.Angebotsmenge) && (e.AnteilProzent > 0)) {
						set cnt2 = cnt2 + 1
						if (cnt2 = 1) {
							set hoechsteLieferDiff = e.LieferdifferenzNeu
							set liefMitHoechsterDiff = e
				
						} elseif (hoechsteLieferDiff < e.LieferdifferenzNeu) {
							set hoechsteLieferDiff = e.LieferdifferenzNeu
							set liefMitHoechsterDiff = e
						}
					}
				}
				if (liefMitHoechsterDiff '= -1) {
					w "1palettgutschreiben",!
					// Werte auf höchstem anpassen, sprich 1 Palett gutschreiben
					set liefMitHoechsterDiff.AnzPaletten = liefMitHoechsterDiff.AnzPaletten + 1
					set anzPalettenVergeben = anzPalettenVergeben + 1
					set liefMitHoechsterDiff.AnteilInAnzGebinde = liefMitHoechsterDiff.AnteilInAnzGebinde + anzJePal
					set anzGebindeVergeben = anzGebindeVergeben + anzJePal
					set liefMitHoechsterDiff.LieferdifferenzNeu = liefMitHoechsterDiff.LieferdifferenzNeu - anzJePal
					if (isRestGroesser) {
						//set liefMitHoechsterDiff.AnteileBerechnet = liefMitHoechsterDiff.AnteilInAnzGebinde
					}
					set rest = rest - anzJePal
				} else {
					Quit	
				}
					
			}
		
			//Anbruch auf den Lieferanten ohne Nachlieferung geben
			//wenn keiner existiert, denjenigen mit der höchsten Lieferdifferenz
			//auswählen
		
			set lieferantOhneNachlief = -1
			set hoechsteDiffUnterLiefOhneNachlief = -1
			set hoechsteDiff = -1
			set lHoechsteDiff = -1
			set cntLieferantenOhneNachlief = 0
			set cnt3 = 0
		
			for idx=1:1:anz {
				set e = ..Lieferanten.GetAt(idx)
		
				if (((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (e.Nachlieferung '= 2) && ((e.AnteilInAnzGebinde + rest) >= e.MindestmengeNachlief))) && (e.ProzenteAbgeschlagen '= 1) && ((e.AnteilInAnzGebinde + rest) <= e.Angebotsmenge) && (e.AnteilProzent > 0)) {
					set cnt3 = cnt3 + 1
					//Initial Werte für die höchste Differenz setzen
					if (cnt3 = 1) {
						set hoechsteDiff = e.LieferdifferenzNeu
						set lHoechsteDiff = e
		
					} elseif (hoechsteDiff < e.LieferdifferenzNeu) {
							set hoechsteDiff = e.LieferdifferenzNeu
							set lHoechsteDiff = e
					}
				}
				if (IsNachBestellung = 0) {
					//Prüfung auf Nachlieferungen
					if ((e.Nachlieferung = 2) && (e.ProzenteAbgeschlagen '= 1)  && ((e.AnteilInAnzGebinde + rest) <= e.Angebotsmenge) && (e.AnteilProzent > 0)) {
						// Werte beim ersten setzen
						if (cntLieferantenOhneNachlief = 0) {
							set hoechsteDiffUnterLiefOhneNachlief = e.LieferdifferenzNeu
							set lieferantOhneNachlief = e
			
						} elseif(hoechsteDiffUnterLiefOhneNachlief < e.LieferdifferenzNeu) {
							set hoechsteDiffUnterLiefOhneNachlief = e.LieferdifferenzNeu
							set lieferantOhneNachlief = e
						}	
			
						set cntLieferantenOhneNachlief = cntLieferantenOhneNachlief +1
			
					}
				}
		
			}
			set restInPal = rest / anzJePal
	
			if (lieferantOhneNachlief '= (-1)) {
				set lieferantOhneNachlief.AnzPaletten = lieferantOhneNachlief.AnzPaletten + 1
				set anzPalettenVergeben = anzPalettenVergeben + 1
				set lieferantOhneNachlief.AnteilInAnzGebinde = lieferantOhneNachlief.AnteilInAnzGebinde + rest
				set anzGebindeVergeben = anzGebindeVergeben + rest
				set lieferantOhneNachlief.LieferdifferenzNeu = lieferantOhneNachlief.LieferdifferenzNeu - rest
				if (isRestGroesser) {
						set lieferantOhneNachlief.AnteileBerechnet = lieferantOhneNachlief.AnteileBerechnet + rest
					}
				set rest = 0
			} else {
				//w !,"Lieferant mit höchster diff auswählen: "_lHoechsteDiff.LieferantID,!
				if (lHoechsteDiff '= -1) {
					set lHoechsteDiff.AnzPaletten = lHoechsteDiff.AnzPaletten + 1
					set anzPalettenVergeben = anzPalettenVergeben + 1
					set lHoechsteDiff.AnteilInAnzGebinde = lHoechsteDiff.AnteilInAnzGebinde + rest
					set anzGebindeVergeben = anzGebindeVergeben + rest
					set lHoechsteDiff.LieferdifferenzNeu = lHoechsteDiff.LieferdifferenzNeu - rest
					if (isRestGroesser) {
						//set lHoechsteDiff.AnteilProzentTmp = $NORMALIZE((100 / anzGeb) * lHoechsteDiff.AnteilInAnzGebinde,2)
						//set lHoechsteDiff.AnteilProzentAlt =  lHoechsteDiff.AnteilProzentTmp
						//set lHoechsteDiff.AnteileBerechnet = lHoechsteDiff.AnteilInAnzGebinde
					}
					set rest = 0
				}
			}
	
		}
		w "Rest bevor Angebotsreduktion: "_rest
		//auf Angebot reduzieren
		set restNachAngebot = 0
		set restProzente = 0
		do ..ReduziereAufAngebot(IsNachBestellung, .restNachAngebot, .restProzente, .anzPalettenVergeben,.anzGebindeVergeben)
		
		//if (restNachAngebot > 0) {
		//Restmenge auf die Lieferanten gem. Lieferanteilen aufteilen
		do ..RestGutschrift(IsNachBestellung, restNachAngebot, restProzente)
		//}
		
		do ..RoundAnteileBerechnet(IsNachBestellung)
		
		set rest = restNachAngebot
		set verfAng = 0
		set cntKeinAngebot = 0
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu," Ant berechnet: "_e.AnteileBerechnet, "Angebot: "_e.Angebotsmenge,!
			
			//if ((e.AnteilInAnzGebinde >= e.Angebotsmenge) || (e.AnteilProzent = 0)) {
			if (((IsNachBestellung = 1) && (e.Nachlieferung = 2)) || (e.AnteilInAnzGebinde >= e.Angebotsmenge)) {
				set cntKeinAngebot = cntKeinAngebot + 1	
			
			//Angebot verfügbar
			} else {
				set verfAng = verfAng + (e.Angebotsmenge - e.AnteilInAnzGebinde)
			}	
		}
		if (anz = cntKeinAngebot || (rest > verfAng)) {
			set angebotErschoepft = 1	
		}
	
		w !,"Gesamtes noch verfügbares Angebot: "_verfAng,!
		//wenn noch Rest vorhanden -> versuchen auf die noch übrig gebliebenen zu verteilen
		//if ((rest > 0) && (verfAng > 0) && (rest > verfAng)) {
		if ((rest > 0) && (verfAng > 0)) {
			w !,"Es ist noch Angebot verfügbar: "_verfAng,!
			for idx4=1:1:anz {
				if ((rest > 0) && (verfAng > 0)) {
					set restlLieferant = ..Lieferanten.GetAt(idx4)
			
					if (restlLieferant.AnteilInAnzGebinde < restlLieferant.Angebotsmenge) {
						set verf = restlLieferant.Angebotsmenge - restlLieferant.AnteilInAnzGebinde
						set menge = 0
						if (rest > verf) {
							set menge = verf
						} else {
							set menge = rest
						}
						w !,"Menge die Lieferant: "_restlLieferant.LieferantID_" verteilt werden darf: "_menge,!
						if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (restlLieferant.Nachlieferung '= 2) && ((restlLieferant.AnteilInAnzGebinde + menge) >= restlLieferant.MindestmengeNachlief))) {
							set restlLieferant.AnteilInAnzGebinde = restlLieferant.AnteilInAnzGebinde + menge
							set anzPal = $NORMALIZE((restlLieferant.AnteilInAnzGebinde / anzJePal),0)
							set restlLieferant.AnzPaletten = anzPal
							set restlLieferant.LieferdifferenzNeu = restlLieferant.LieferdifferenzNeu - menge		
							set restlLieferant.AnteileBerechnet = restlLieferant.AnteilInAnzGebinde
							set restlLieferant.AnteileBerechnetAlt = restlLieferant.AnteilInAnzGebinde
							set rest = rest - menge
							set verfAng = verfAng - menge
						}
					}
				}
			}
		}
	
		w !,"Paletten vergeben: "_anzPalettenVergeben,!
		w !,"Rest nach allem: "_rest,!
		
		//überall wo Angebot = 0 ist, jedoch noch ein AnteilBerechnet vorhanden ist -> diesen nullen
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			if (e.Angebotsmenge = 0 && (e.AnteileBerechnet '= 0 || e.AnteileBerechnetAlt '= 0)) {
				set e.AnteileBerechnet = 0	
				set e.AnteileBerechnetAlt = 0
			}
		}

		//Solange ausführen, bis kein Rest mehr vorhanden ist und kein Lieferant mehr Angebot hat
	} while((rest > 0) && (angebotErschoepft = 0))
]]></Implementation>
</Method>

<Method name="ReduziereAufAngebot">
<FormalSpec><![CDATA[IsNachBestellung:%Boolean,&restMenge:%Integer,&restProzente:%Decimal(SCALE=5),&anzPalVergeben:%Integer,&anzGebVergeben:%Integer]]></FormalSpec>
<Implementation><![CDATA[
	
	w !,"Mengen auf Angebot reduzieren",!
	
	set anz = ..Lieferanten.Count()
	set anzGeb = ..AnzahlGebinde
	set anzJePal = ..AnzahlJePalette
	
	set anzGebTotVergeben = 0
	
	for idx=1:1:anz {
		set entry = ..Lieferanten.GetAt(idx)
		
		if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2))) {
			
			if (entry.AnteilInAnzGebinde > entry.Angebotsmenge) {
				
				set diff = 0
				//Angebot kann kleiner null sein, wenn er doch schon mehr liefern konnte
				if (entry.Angebotsmenge < 0) {
					set diff = entry.AnteilInAnzGebinde
				} else {
					set diff = (entry.AnteilInAnzGebinde - entry.Angebotsmenge)
				}
				set restMenge = restMenge + diff
				set entry.AnteilInAnzGebinde = entry.AnteilInAnzGebinde - diff
				set anzGebVergeben = anzGebVergeben - diff
				set anzPalVergeben = $NORMALIZE((anzGebVergeben / anzJePal),0)
				set entry.AnteileBerechnet = entry.AnteilInAnzGebinde
				set entry.AnteileBerechnetAlt = entry.AnteileBerechnet
				
				set entry.AnteileBerechnetUngerundet = entry.AnteileBerechnet
				set entry.AnteileBerechnetAltUngerundet = entry.AnteileBerechnetAlt
				
				set tmpPAlt = entry.AnteilProzentTmp
				//in Prozent umrechnen
				set entry.AnteilProzentTmp = $NORMALIZE((100 / anzGeb) * entry.AnteilInAnzGebinde,2)
				set entry.AnteilProzentAlt =  entry.AnteilProzentTmp
				w !,"Angebotsreduktion - AnteilProzentTmp: "_entry.AnteilProzentTmp," proz Alt: "_tmpPAlt," AnteileBerechnet: ",entry.AnteilInAnzGebinde,!
				//if ((tmpPAlt - entry.AnteilProzentTmp) > 0) {
					set restProzente = restProzente + (entry.AnteilProzentTmp)
				//}
				set anzPal = $NORMALIZE((entry.AnteilInAnzGebinde / anzJePal),0)
				set entry.AnzPaletten = anzPal
				set entry.LieferdifferenzNeu = entry.LieferdifferenzNeu + diff
				set entry.ReduziertAufgrundAngebot = 1
				
				
			} else {
				set entry.ReduziertAufgrundAngebot = 0	
			}
		}
		set anzGebTotVergeben = anzGebTotVergeben + entry.AnteilInAnzGebinde
	}
	w !,"Anz Geb Tot Vergeben in Angebotsreduktion: "_anzGebTotVergeben,!
	set restMenge = anzGeb - anzGebTotVergeben
]]></Implementation>
</Method>

<Method name="RestGutschrift">
<FormalSpec>IsNachBestellung:%Boolean,Rest:%Integer,RestProzente:%Decimal(SCALE=5)</FormalSpec>
<Implementation><![CDATA[
	w !,"Rest gem. Lieferanteilen den übrigen Lieferanten gutschreiben",!
	
	set anz = ..Lieferanten.Count()
	set anzGeb = ..AnzahlGebinde
	set anzJePal = ..AnzahlJePalette
	

	set summeUebrigeProzente = 0
	set summeUebrigeProzente = summeUebrigeProzente + RestProzente
	w !,"RestGutschrift RestProzente: "_RestProzente,!
	for idx=1:1:anz {
		set entry = ..Lieferanten.GetAt(idx)
		w !,"LiefId: "_entry.LieferantID_" bisherige anz geb: "_entry.AnteilInAnzGebinde, "Angebotsmenge: "_entry.Angebotsmenge_" ProzAbgeschlagen: "_entry.ProzenteAbgeschlagen, " Ant berechnet: "_entry.AnteileBerechnet,!
		if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2)) && (entry.AnteilProzent > 0)) {
			
			//if (((entry.AnteilInAnzGebinde < entry.Angebotsmenge) && (entry.Angebotsmenge '= 0)) || (entry.ProzenteAbgeschlagen = 1)) {
			if (((entry.AnteilInAnzGebinde <= entry.Angebotsmenge)) || (entry.ProzenteAbgeschlagen = 1) && (entry.Angebotsmenge '= 0)) {
				
				set summeUebrigeProzente = summeUebrigeProzente + entry.AnteilProzentTmp
				
				if (entry.ProzenteAbgeschlagen '= 1) {
					set entry.ProzenteAbgeschlagen = 0
				}
			
			
			} else {
				set entry.ProzenteAbgeschlagen = 1
			}
		}
	}
	
	w !,"Summe uebrige proz: "_summeUebrigeProzente,!
	
	//if ((summeUebrigeProzente > 0) && (summeUebrigeProzente '= 100)) {
	if ((summeUebrigeProzente > 0)) {
	
		set maxProz = -1
		set liefMaxProz = -1
		set summeProzNeu = 0
		set summeProzNeu = summeProzNeu
		set summeRestProzente = 0
		
		//Prüfen, ob noch Angebot verfügbar ist
		set verfAng = 0
		set cntKeinAngebot = 0
		for idx=1:1:anz {
			set e = ..Lieferanten.GetAt(idx)
			W !,"LieferantID: "_e.LieferantID_" Anteil in Gebinde: "_e.AnteilInAnzGebinde, "LieferdiffNeu: ", e.LieferdifferenzNeu," Ant berechnet: "_e.AnteileBerechnet, "Angebot: "_e.Angebotsmenge,!
			
			//if ((e.AnteilInAnzGebinde >= e.Angebotsmenge) || (e.AnteilProzent = 0)) {
			if (((IsNachBestellung = 1) && (e.Nachlieferung = 2)) || (e.AnteilInAnzGebinde >= e.Angebotsmenge)) {
				set cntKeinAngebot = cntKeinAngebot + 1	
			
			//Angebot verfügbar
			} else {
				set verfAng = verfAng + (e.Angebotsmenge - e.AnteilInAnzGebinde)
			}	
		}
	
		//Schlüssel neu berechnen
		for idx = 1:1:anz {
			set lief = ..Lieferanten.GetAt(idx)
			set diff = 0
			set pDiff = 0
			set diffUngerundet = 0
			//neue ProzentAnteile für Lieferanten berechnen
			//if ((IsNachBestellung = 0) || ((IsNachBestellung = 1) && (entry.Nachlieferung '= 2))) {
			
				//if (entry.AnteilInAnzGebinde > entry.Angebotsmenge) {
				if (lief.ProzenteAbgeschlagen = 0 && lief.ReduziertAufgrundAngebot = 0 && lief.Angebotsmenge '= 0) {
					if ((summeUebrigeProzente >= 100) || (verfAng = 0)) {
						set pNeu = lief.AnteilProzentTmp
					} else {
						set pNeu = (lief.AnteilProzent / summeUebrigeProzente ) * 100
					}
					set pNeuGerundet = $NORMALIZE(pNeu,2)
					set ber = $NORMALIZE((anzGeb / 100) * pNeuGerundet,0)
					if (ber > lief.Angebotsmenge) {					
						if (lief.Angebotsmenge < 0) {
							set diff = ber
						} else {
							set diff = (ber - lief.Angebotsmenge)
						}
						//Differenz in Prozent umrechnen
						set pDiff = $NORMALIZE(((100 / anzGeb) * diff),2)
						set summeRestProzente = summeRestProzente + pDiff
					} 
					
					set berUngerundet = (anzGeb / 100) * pNeu
					if (berUngerundet > lief.Angebotsmenge) {					
						if (lief.Angebotsmenge < 0) {
							set diffUngerundet = berUngerundet
						} else {
							set diffUngerundet = (berUngerundet - lief.Angebotsmenge)
						}
					} 
					
					set lief.AnteilProzentTmp = pNeuGerundet - pDiff
					set lief.AnteileBerechnet = ber - diff
					set lief.AnteileBerechnetUngerundet = berUngerundet - diffUngerundet
					set lief.AnteilProzentAlt =  lief.AnteilProzentTmp
					set lief.AnteileBerechnetAlt =  lief.AnteileBerechnet
					set lief.AnteileBerechnetAltUngerundet = lief.AnteileBerechnetUngerundet
					w !,"berechne anteileberechnet neu: "_lief.AnteileBerechnet," antproztmp: ",lief.AnteilProzentTmp,!
					set summeProzNeu = summeProzNeu + lief.AnteilProzentTmp
		
					if (idx = 1) {
						set maxProz = lief.AnteilProzentTmp
						set liefMaxProz = lief
			
					} 
					if (lief.AnteilProzentTmp > maxProz) {
						set maxProz = lief.AnteilProzentTmp
						set liefMaxProz = lief
					}
					
					
				} elseif (lief.Angebotsmenge = 0) {
					set lief.AnteilProzentTmp = 0
					set lief.AnteileBerechnet = 0
					set lief.AnteileBerechnetUngerundet = 0
					set lief.AnteilProzentAlt = 0
					set lief.AnteileBerechnetAlt = 0
					set lief.AnteileBerechnetAltUngerundet = 0
					
					//set lief.ProzenteAbgeschlagen = 0
				} else {
					set summeProzNeu = summeProzNeu + lief.AnteilProzentTmp
				}
			//}
		}
	
		/*set diff = 100 - summeProzNeu
		if (liefMaxProz '= -1) {
			set liefMaxProz.AnteilProzentTmp = liefMaxProz.AnteilProzentTmp + diff
			set liefMaxProz.AnteileBerechnet = $NORMALIZE((anzGeb / 100) * liefMaxProz.AnteilProzentTmp,0)
			set liefMaxProz.AnteilProzentAlt = liefMaxProz.AnteilProzentTmp
			set liefMaxProz.AnteileBerechnetAlt = liefMaxProz.AnteileBerechnet
		}*/
	
		//Restprozente gutschreiben auf den Lieferanten, welche noch Angebot verfügbar haben
		//Das Verhältnis unter den Lieferanten stimmt bereits -> gleichmässig auf die
		//Lieferanten verteilen, gem. Angebot
		set cntKeinAngebot = 0
		set pTeil = summeRestProzente / 50
		w !, "RestProzente bevor gleichmässig verteilt wird: "_summeRestProzente,!
		while ((summeRestProzente > 0) && (cntKeinAngebot '= anz)) {
			set cntKeinAngebot = 0
			for idx = 1:1:anz {
				if ((summeRestProzente > 0)  && (cntKeinAngebot '= anz)) {
					set lief = ..Lieferanten.GetAt(idx)
					if (lief.AnteilProzent > 0) {
						set tmpProzVerfuegbar = 0
						set verfGeb = lief.Angebotsmenge - lief.AnteileBerechnet
						if (verfGeb > 0) {
							set tmpProzVerfuegbar = $NORMALIZE(((100/anzGeb) * verfGeb),2)
							set t = (pTeil * (lief.AnteilProzent/100))
							if (tmpProzVerfuegbar >= t) {
								set lief.AnteilProzentTmp = lief.AnteilProzentTmp + t
								set summeRestProzente = summeRestProzente - t
							} else {
								set lief.AnteilProzentTmp = lief.AnteilProzentTmp + tmpProzVerfuegbar
								set summeRestProzente = summeRestProzente - tmpProzVerfuegbar
							}	
							set m = (anzGeb / 100) * lief.AnteilProzentTmp
							set lief.AnteileBerechnet = $NORMALIZE(m,0)				
							set lief.AnteileBerechnetUngerundet = m
							set lief.AnteileBerechnetAlt = lief.AnteileBerechnet
							set lief.AnteileBerechnetAltUngerundet = m
						} else {
							set cntKeinAngebot = cntKeinAngebot + 1	
						}
					} else {
						set cntKeinAngebot = cntKeinAngebot + 1	
					}
				}
			}
		}
		//nur kontrolle:
		for idx = 1:1:anz {
			set lief = ..Lieferanten.GetAt(idx)
			set lief.ReduziertAufgrundAngebot = 0
			w !,"Schlüssel neu berechnet Lieferant ID: "_lief.LieferantID, " anteil neu: "_lief.AnteilProzentTmp
		}
		
		
	}
]]></Implementation>
</Method>

<Method name="RoundAnteileBerechnet">
<FormalSpec>IsNachbestellung:%Boolean</FormalSpec>
<Implementation><![CDATA[
	
	set lieferantenGerundet = ""
	set anz = ..Lieferanten.Count()
	
	for idx = 1:1:anz {
		set lief = ..Lieferanten.GetAt(idx)
		set lieferantenGerundet = lieferantenGerundet_$lb(lief.LieferantID)
	
		set antBer = 0
		if (IsNachbestellung = 0) {
			set antBer = lief.AnteileBerechnetUngerundet
		} else {
			set antBer = lief.AnteileBerechnetAltUngerundet	
		}
		set rest = (antBer # 1)
		
		set gerundet = $NORMALIZE(antBer,0)
		//diff = negativ, wenn aufgerundet
		//diff = positiv, wenn abgerundet
		set diff = antBer - gerundet
		
		if (IsNachbestellung = 0) {
			set lief.AnteileBerechnet = gerundet
		} else {
			set lief.AnteileBerechnetAlt = gerundet
		}
		
		if (rest '= 0) {
			//w !,"RUNDEN: Rest gefunden: "_rest,!
				
			set cnt = 0
			for i = 1:1:anz {
				set r = ..Lieferanten.GetAt(i)
				set found = $ListFind(lieferantenGerundet, r.LieferantID)
				//w "found: "_found,!
				set isGanzzahl = 0
				if (IsNachbestellung = 0) {
					set isGanzzahl = ((r.AnteileBerechnetUngerundet # 1) = 0)
				} else {
					set isGanzzahl = ((r.AnteileBerechnetAltUngerundet # 1) = 0)
				}
			
				if ((found = 0) && (isGanzzahl = 0)) {
					set cnt = cnt + 1
				}
			}
			//w "Anzahl nicht ganzzahlige: "_cnt,!
			
			if (cnt > 0) {
				set teilDiff = diff / cnt
				for i = 1:1:anz {
					set r = ..Lieferanten.GetAt(i)
					set found = $ListFind(lieferantenGerundet, r.LieferantID)
					set isGanzzahl = 0
					if (IsNachbestellung = 0) {
						set isGanzzahl = ((r.AnteileBerechnetUngerundet # 1) = 0)
					} else {
						set isGanzzahl = ((r.AnteileBerechnetAltUngerundet # 1) = 0)
					}
					if ((found = 0) && (isGanzzahl = 0)) {
						
						if (IsNachbestellung = 0) {
							set r.AnteileBerechnetUngerundet = r.AnteileBerechnetUngerundet + teilDiff
							//w !,"passe ungerundete werte an:",r.AnteileBerechnetUngerundet,!
						} else {
							set r.AnteileBerechnetAltUngerundet = r.AnteileBerechnetAltUngerundet + teilDiff
							//w !,"passe ungerundete werte an:",r.AnteileBerechnetAltUngerundet,!
						}
					
					}
				}			
			}
		}
	}
	
	//kontrolle:
	/*for idx = 1:1:anz {
		set lief = ..Lieferanten.GetAt(idx)
		
		if (IsNachbestellung = 0) {
			w !,"----------------------------------------",!
			w "Anteile berechnet nach Rundung: ",!
			w "Lieferant: "_lief.LieferantID_" Anteile Berechnet: "_lief.AnteileBerechnet_ " Anteile Ungerundet: "_lief.AnteileBerechnetUngerundet
			w "----------------------------------------",!
		} else {
			w !,"----------------------------------------",!
			w "Anteile berechnet nach Rundung: ",!
			w "Lieferant: "_lief.LieferantID_" Anteile Berechnet: "_lief.AnteileBerechnetAlt_ " Anteile Ungerundet: "_lief.AnteileBerechnetAltUngerundet
			w "----------------------------------------",!
		}

	}*/
]]></Implementation>
</Method>
</Class>
</Export>
