GeMIS_WEB/GUI/super/bestellfunktion.p

/*------------------------------------------------------------------------
    File        : bestellfunktion.p
    Purpose     : 

    Syntax      :

    Description : 

    Author(s)   : walter.riechsteiner
    Created     : Tue Aug 18 17:18:44 CEST 2020
    Notes       :
  ----------------------------------------------------------------------*/

/* ***************************  Definitions  ************************** */

BLOCK-LEVEL ON ERROR UNDO, THROW.

DEFINE VARIABLE AdFirma   AS CHARACTER NO-UNDO.
DEFINE VARIABLE rBesze    AS RECID     NO-UNDO.
DEFINE VARIABLE rGebKontr AS RECID     NO-UNDO.
DEFINE VARIABLE lBatch    AS LOGICAL   NO-UNDO. 

DEFINE TEMP-TABLE tBesko LIKE Besko
    FIELD Lieferant   AS CHARACTER
    FIELD Lieferungen AS CHARACTER
    FIELD BestelltBis AS CHARACTER   
    FIELD iStatus     AS INTEGER
    .
DEFINE VARIABLE htBesko AS HANDLE NO-UNDO.
htBesko = TEMP-TABLE tBesko:DEFAULT-BUFFER-HANDLE.

DEFINE TEMP-TABLE tBesze LIKE Besze
    FIELD GGebinde AS CHARACTER INIT ? 
    FIELD VGebinde AS CHARACTER INIT ?
    FIELD kGebinde AS CHARACTER INIT ?
    FIELD iStatus  AS INTEGER   INIT ?
    .
DEFINE VARIABLE htBesze AS HANDLE NO-UNDO.
htBesze = TEMP-TABLE tBesze:DEFAULT-BUFFER-HANDLE.

/* ********************  Preprocessor Definitions  ******************** */

/* ************************  Function Prototypes ********************** */


FUNCTION calculateBeskoTotal RETURNS DECIMAL 
    (ipcFirma AS CHARACTER,
    ipiBesnr AS INTEGER,
    OUTPUT opnTotale AS DECIMAL EXTENT 10) FORWARD.

FUNCTION calculateBeszeNetto RETURNS LOGICAL 
    (ipcFirma AS CHARACTER,
    ipiBesnr AS INTEGER,
    ipiPos AS INTEGER,
    ipiRecid AS RECID) FORWARD.

FUNCTION calculatetBeszeNetto RETURNS LOGICAL 
    (INPUT-OUTPUT iphtBesze AS HANDLE) FORWARD.

FUNCTION changeBestellStatus RETURNS LOGICAL 
    (INPUT-OUTPUT iohBesko AS HANDLE) FORWARD.

FUNCTION createBesGebKO RETURNS LOGICAL 
    (ipcFirma AS CHARACTER,
    ipiBesnr AS INTEGER) FORWARD.

FUNCTION createBestellnummer RETURNS INTEGER 
    (ipFirma AS CHARACTER) FORWARD.

FUNCTION fillBesze RETURNS INTEGER 
    (INPUT-OUTPUT iohtBesze AS HANDLE) FORWARD.

FUNCTION filltBesko RETURNS LOGICAL 
    (INPUT-OUTPUT iohtBesko AS HANDLE) FORWARD.

FUNCTION getBestand RETURNS DECIMAL 
    (ipcFirma AS CHARACTER,
    ipiArtnr AS INTEGER,
    ipiInhalt AS INTEGER,
    ipiJahr AS INTEGER,
    ipiLager AS INTEGER) FORWARD.

/* ***************************  Main Block  *************************** */



/* **********************  Internal Procedures  *********************** */

PROCEDURE CREATE_GEBKONTR:
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/
    
    DEFINE INPUT PARAMETER ipcGebKto    AS CHARACTER NO-UNDO.
    DEFINE INPUT PARAMETER ipiMwstCd    AS INTEGER   NO-UNDO.
    
    DEFINE VARIABLE ix AS INTEGER NO-UNDO.
    
    FIND FIRST tBesko.

    FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
        WHERE GebKonto.Firma  = tBesko.Firma
        AND   GebKonto.Geb_Cd = ipcGebKto  NO-ERROR.
        
    FIND LAST GebKontr NO-LOCK USE-INDEX GebKontr-k1
        WHERE GebKontr.Firma = tBesko.Firma
        AND   GebKontr.Knr   = tBesko.Knr NO-ERROR.
    IF NOT AVAILABLE GebKontr THEN ix = 1.
    ELSE                           ix = GebKontr.Trnr + 1.
    
    DO WHILE TRUE:
        CREATE  GebKontr.
        ASSIGN  
            GebKontr.Firma  = tBesko.Firma
            GebKontr.Knr    = tBesko.Knr
            GebKontr.Trnr   = ix
            GebKontr.Geb_Cd = ipcGebKto
            GebKontr.Doknr  = tBesko.Besnr
            GebKontr.Datum  = tBesko.Buch_Datum
            GebKontr.Preis  = GebKonto.Depot.
        rGebKontr = RECID(GebKontr).
    
        IF GebKonto.MWST_Art = 0 THEN 
        DO:
            ASSIGN  
                GebKontr.MWST_Cd   = 11
                GebKontr.MWST_%    = 0
                GebKontr.MWST_Inkl = TRUE.
            LEAVE.
        END.
        
        IF GebKonto.MWST_Art = 1 THEN 
        DO:
            FIND Wust NO-LOCK USE-INDEX Wust-k1
                WHERE Wust.CodeK = 99
                AND   Wust.CodeA = ipiMwstCd NO-ERROR.
            FIND LAST MwstAns NO-LOCK 
                WHERE MWSTAns.MWST_Cd = Wust.Wucd
                AND   MWSTAns.Datum   < tBesko.Buch_Datum NO-ERROR.
        END.
        
        IF GebKonto.MWST_Art = 2 THEN 
        DO:
            FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
                WHERE Wust.WuCd = GebKonto.MWST_Cd NO-ERROR.
            FIND LAST MwstAns NO-LOCK 
                WHERE MWSTAns.MWST_Cd = GebKonto.MWST_Cd
                AND   MWSTAns.Datum   < tBesko.Buch_Datum NO-ERROR.
        END.
        
        IF NOT AVAILABLE MWSTAns THEN 
        DO:
            ASSIGN  
                GebKontr.MWST_Cd   = 11
                GebKontr.MWST_%    = 0
                GebKontr.MWST_Inkl = TRUE.
            LEAVE.
        END.
        ASSIGN  
            GebKontr.MWST_Cd   = MWSTAns.MWST_Cd 
            GebKontr.MWST_%    = MWSTAns.Ansatz
            GebKontr.MWST_Inkl = (IF AVAILABLE Wust THEN Wust.Incl ELSE FALSE).
        
        LEAVE.
    END.

    RELEASE Wust    .
    RELEASE MWSTAns .        
    RELEASE GebKontr.
    RELEASE GebKonto.

END PROCEDURE.

PROCEDURE EINBUCHEN_MENGEN:
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/
    
    DEFINE VARIABLE i1         AS INTEGER   NO-UNDO.
    DEFINE VARIABLE MwstCd     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE dBuchdatum AS DATE      NO-UNDO.
    DEFINE VARIABLE cGebKto    AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iEingang   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iGGeb_EG   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iVGeb_EG   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iKGeb_EG   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE lOk        AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE lGebucht   AS LOGICAL   NO-UNDO INIT FALSE.

    EINBUCHUNG:    
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND FIRST tBesko.
        dBuchdatum = tBesko.Lief_Datum.
    
        FOR EACH Besze
            WHERE Besze.Firma  = tBesko.Firma
            AND   Besze.Besnr  = tBesko.Besnr
            AND   Besze.Artnr  > 0
            AND   NOT Besze.Verbucht :
            
            rBesze = RECID(Besze).
            
            ASSIGN  
                iEingang = 0
                iGGeb_EG = 0
                iVGeb_EG = 0
                iKGeb_EG = 0.
            FOR EACH BesEing OF Besze:
                IF BesEing.Eingang = 0 THEN 
                DO:
                    DELETE  BesEing.
                    NEXT.
                END.
                IF NOT BesEing.lEingelagert THEN 
                DO:
                    RUN EINLAGERN_BESEINGANG ( RECID(BesEing), OUTPUT lOk ).
                    IF NOT lOk THEN UNDO EINBUCHUNG, LEAVE EINBUCHUNG.
                END.
                ASSIGN
                    BesEing.lEingelagert = TRUE
                    BesEing.lVerbucht    = TRUE    
                    iEingang             = iEingang + BesEing.Eingang
                    iGGeb_EG             = iGGeb_EG + BesEing.GGeb_EG
                    iVGeb_EG             = iVGeb_EG + BesEing.VGeb_EG
                    iKGeb_EG             = iKGeb_EG + BesEing.KGeb_EG.
                RELEASE BesEing.
            END.
            
            FIND Artst USE-INDEX Artst-k1
                WHERE Artst.Firma  = Besze.Firma
                AND   Artst.Artnr  = Besze.Artnr
                AND   Artst.Inhalt = Besze.Inhalt
                AND   Artst.Jahr   = Besze.Jahr.
            MwstCd = Artst.Mwst.
                      
            FIND Steuer
                WHERE Steuer.Firma = tBesko.Firma NO-LOCK.

            ASSIGN  
                Besze.GGeb_EG = iGGeb_EG
                Besze.VGeb_EG = iVGeb_EG
                Besze.KGeb_EG = iKGeb_EG
                Besze.GGeb_Me = iGGeb_EG
                Besze.VGeb_Me = iVGeb_EG
                Besze.KGeb_Me = iKGeb_EG
                Besze.MGeli   = iEingang
                Besze.MBest   = iEingang
                Besze.Eingang = 0.
                                              
            Artst.Letzt_Eing = tBesko.Lief_Datum.

            DO WHILE Besze.GGeb_EG <> 0:
                FIND GGebinde NO-LOCK USE-INDEX GGebinde-k1
                    WHERE GGebinde.Firma  = Besze.Firma
                    AND   GGebinde.Geb_Cd = Besze.GGeb_Cd NO-ERROR.
                IF NOT AVAILABLE GGebinde THEN LEAVE.
                IF GGebinde.Geb_Kto = ''  THEN LEAVE.
                IF Besze.GGebKto    = ''  THEN Besze.GGebKto = GGebinde.Geb_Kto.
                cGebKto = Besze.GGebKto.
                
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = Besze.Firma
                    AND   GebKonto.Geb_Cd = cGebKto  NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = GGebinde.Depot.
                IF GebKonto.Depot = 0       THEN LEAVE.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GEBKONTR ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Eingang = GebKontr.Eingang + Besze.GGeb_EG.
                LEAVE.
            END.

            DO WHILE Besze.VGeb_EG <> 0:
                FIND VGebinde NO-LOCK USE-INDEX VGebinde-k1
                    WHERE VGebinde.Firma  = Besze.Firma
                    AND   VGebinde.Geb_Cd = Besze.VGeb_Cd NO-ERROR.
                IF NOT AVAILABLE VGebinde THEN LEAVE.
                IF VGebinde.Geb_Kto = ''  THEN LEAVE.
                IF Besze.VGebKto    = ''  THEN Besze.VGebKto = VGebinde.Geb_Kto.
                cGebKto = Besze.VGebKto.
                
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = Besze.Firma
                    AND   GebKonto.Geb_Cd = Besze.VGebKto  NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = VGebinde.Depot.
                IF GebKonto.Depot = 0       THEN LEAVE.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GEBKONTR ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Eingang = GebKontr.Eingang + Besze.VGeb_EG.
                LEAVE.
            END.

            DO WHILE Besze.KGeb_EG <> 0:
                FIND KGebinde NO-LOCK USE-INDEX KGebinde-k1
                    WHERE KGebinde.Firma  = Besze.Firma
                    AND   KGebinde.Geb_Cd = Besze.KGeb_Cd NO-ERROR.
                IF NOT AVAILABLE KGebinde THEN LEAVE.
                IF KGebinde.Geb_Kto = ''  THEN LEAVE.
                IF Besze.KGebKto    = ''  THEN Besze.KGebKto = KGebinde.Geb_Kto.
                cGebKto = Besze.KGebKto.
                
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = Besze.Firma
                    AND   GebKonto.Geb_Cd = Besze.KGebKto  NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = KGebinde.Depot.
                IF GebKonto.Depot = 0       THEN LEAVE.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GEBKONTR ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Eingang = GebKontr.Eingang + Besze.KGeb_EG.
                LEAVE.
            END.
            
            RELEASE KGebinde.
            RELEASE VGebinde.
            RELEASE GGebinde.
            RELEASE GebKonto.
            RELEASE GebKontr.
            
            FIND KGebinde NO-LOCK USE-INDEX KGebinde-k1
                WHERE KGebinde.Firma  = Besze.Firma
                AND   KGebinde.Geb_Cd = Besze.KGeb_Cd NO-ERROR.
                      
            DO WHILE iEingang <> 0:
                FIND LAST Artbw NO-LOCK USE-INDEX Artbw-k1
                    WHERE Artbw.Firma = Besze.Firma NO-ERROR.
                IF AVAILABLE Artbw THEN i1 = Artbw.Trnr + 1.
                ELSE                    i1 = 1.

                FIND Wust NO-LOCK USE-INDEX Wust-k1
                    WHERE Wust.CodeK = Steuer.MWST-Exkl
                    AND   Wust.CodeA = Artst.MWST NO-ERROR.
                IF AVAILABLE Wust THEN MwstCd = Wust.WuCd.

                CREATE  Artbw.
                ASSIGN  
                    Artbw.Firma      = Besze.Firma
                    Artbw.Trnr       = i1
                    Artbw.Tr_Art     = 11
                    Artbw.Artnr      = Artst.Artnr
                    Artbw.Inhalt     = Artst.Inhalt
                    Artbw.Jahr       = Artst.Jahr
                    Artbw.Bez1       = Besze.Bez1
                    Artbw.Bez2       = Besze.Bez2
                    Artbw.Knr        = tBesko.Knr
                    Artbw.Menge      = Besze.MGel
                    Artbw.Alk_Gehalt = Artst.Alk_Gehalt
                    Artbw.Aktion     = Besze.Aktion
                    Artbw.Sk_Ber     = FALSE
                    Artbw.Netto      = FALSE
                    Artbw.Lager      = Besze.Lager
                    Artbw.KGeb_Cd    = Besze.KGeb_Cd
                    Artbw.VGeb_Cd    = Besze.VGeb_Cd
                    Artbw.GGeb_Cd    = Besze.GGeb_Cd
                    Artbw.KGeb_Me    = Besze.KGeb_EG
                    Artbw.VGeb_Me    = Besze.VGeb_EG
                    Artbw.GGeb_Me    = Besze.GGeb_EG
                    Artbw.Preis      = Besze.Preis
                    Artbw.Bru_Betr   = Besze.Preis  * Besze.MGeli
                    Artbw.Net_Betr   = Besze.Preis  * Besze.MGeli
                    Artbw.Liter      = Besze.MGeli  * KGebinde.Inhalt / 100
                    Artbw.Gewicht    = (Besze.MGeli * Artst.Gewicht) + KGebinde.Gewicht
                    Artbw.Datum      = tBesko.Lief_Datum
                    Artbw.Abhol      = FALSE
                    Artbw.FRW        = tBesko.FRW
                    Artbw.Faktor     = tBesko.Faktor
                    Artbw.Kurs       = tBesko.Kurs
                    Artbw.WC         = Artst.MWST
                    Artbw.WuCd       = MwstCd
                    Artbw.Aufnr      = Besze.Besnr.

                ASSIGN  
                    Besze.Trnr = Artbw.Trnr.

                LEAVE.
            END.
            
            RELEASE Artbw   .
            RELEASE Artst   .
            RELEASE Besze   .
            RELEASE KGebinde.        
        END.
    
        FOR EACH BesGebKo NO-LOCK USE-INDEX BesGebKo-k1
            WHERE BesGebKo.Firma  = tBesko.Firma
            AND   BesGebKo.Besnr  = tBesko.Besnr
            AND   BesGebKo.Menge <> 0 :
                
            MwstCd = 0.                
                
            DO WHILE BesGebKo.Anz_1 <> 0:
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = BesGebKo.Firma
                    AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd1 NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = BesGebKo.Wert_1.
                IF GebKonto.Depot = 0       THEN LEAVE.
                cGebKto = GebKonto.Geb_Cd.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GebKontr ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Ausgang = GebKontr.Ausgang + BesGebKo.Anz_1.
                LEAVE.
            END.

            DO WHILE BesGebKo.Anz_2 <> 0:
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = BesGebko.Firma
                    AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd2 NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = BesGebKo.Wert_1.
                IF GebKonto.Depot = 0       THEN LEAVE.
                cGebKto = GebKonto.Geb_Cd.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GebKontr ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Ausgang = GebKontr.Ausgang + BesGebKo.Anz_2.
                LEAVE.
            END.

            DO WHILE BesGebKo.Anz_3 <> 0:
                FIND GebKonto USE-INDEX GebKonto-k1
                    WHERE GebKonto.Firma  = BesGebko.Firma
                    AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd3 NO-ERROR.
                IF NOT AVAILABLE GebKonto   THEN LEAVE.
                IF GebKonto.Depot = 0       THEN GebKonto.Depot = BesGebKo.Wert_1.
                IF GebKonto.Depot = 0       THEN LEAVE.
                cGebKto = GebKonto.Geb_Cd.

                FIND FIRST GebKontr USE-INDEX GebKontr-k2
                    WHERE GebKontr.Firma  = tBesko.Firma
                    AND   GebKontr.Knr    = tBesko.Knr
                    AND   GebKontr.Geb_Cd = cGebKto
                    AND   GebKontr.Doknr  = tBesko.Besnr
                    AND   GebKontr.Datum  = dBuchdatum NO-ERROR.
                IF NOT AVAILABLE GebKontr THEN
                DO:
                    RUN CREATE_GebKontr ( cGebKto, MwstCd ).
                    FIND GebKontr WHERE RECID(GebKontr) = rGebKontr.
                END.
                GebKontr.Ausgang = GebKontr.Ausgang + BesGebKo.Anz_3.
                LEAVE.
            END.

            RELEASE GebKontr.
            RELEASE GebKonto.
        END.
        lGebucht = TRUE.
        LEAVE.
    END.

    RELEASE Artst.
    
    IF lGebucht THEN RETURN ''.
    ELSE             RETURN 'ERROR'. 

END PROCEDURE.

PROCEDURE EINLAGERN_BESEINGANG:
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/
    
    DEFINE INPUT  PARAMETER iprBesEing AS RECID   NO-UNDO.
    DEFINE OUTPUT PARAMETER oplOk      AS LOGICAL NO-UNDO INIT FALSE.
    
    DEFINE VARIABLE cString    AS CHARACTER NO-UNDO.
    DEFINE VARIABLE rHoReLager AS RECID     NO-UNDO.
    DEFINE VARIABLE dVerfall   AS DATE      NO-UNDO.
    DEFINE VARIABLE ii         AS INTEGER   NO-UNDO. 
    
    DEFINE BUFFER bBesEing   FOR BesEing.
    DEFINE BUFFER bHoReLager FOR HoReLager.
    
    lBatch = DYNAMIC-FUNCTION ('getBatch':U).
    
    EINLAGERUNG:
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND bBesEing WHERE RECID(bBesEing) = iprBesEing.
        
        FIND ArtLager NO-LOCK OF bBesEing NO-ERROR.
        IF ArtLager.Ort = '' THEN 
        DO:
            FIND FIRST HoReLager NO-LOCK USE-INDEX HoReLager-k1
                WHERE HoReLager.Firma  = bBesEing.Firma
                AND   HoReLager.Lager  = 0
                AND   HoReLager.Art    = 3
                AND   HoReLager.Artnr  = 0 NO-ERROR.
            IF AVAILABLE HoReLager THEN LEAVE.
        
            FIND LAST HoReLager NO-LOCK USE-INDEX HoReLager-k1
                WHERE HoReLager.Firma  = bBesEing.Firma
                AND   HoReLager.Lager  = 0
                AND   HoReLager.Art    = 3
                AND   HoReLager.Sf     > '' NO-ERROR.
            IF NOT AVAILABLE HoReLager THEN LEAVE.
            IF HoReLager.Sf >= '98' THEN 
            DO:
                RELEASE     HoReLager.
                LEAVE.
            END.
            ii = INTEGER(HoReLager.Sf) + 1.
            CREATE  bHoreLager.
            BUFFER-COPY HoReLager
                USING   Firma Lager Art Regal Platz Niveau
                TO      bHoReLager
                ASSIGN  
                bHoReLager.Sf      = STRING(ii,'99')
                bHoReLager.iStatus = 0
                bHoReLager.cSort   = SUBSTITUTE('&1-&2-&3-&4', HoReLager.Regal, HoReLager.Platz, HoReLager.Niveau, STRING(ii,'99'))
                bHoReLager.Artnr   = bBesEing.Artnr
                bHoReLager.Inhalt  = bBesEing.Inhalt
                bHoReLager.Jahr    = bBesEing.Jahr
                bHoReLager.iStatus = 2.
            .
        END.
                
        DO WHILE TRUE:
            FIND FIRST HoReLager NO-LOCK 
                WHERE HoReLager.Firma   = bBesEing.Firma
                AND   HoReLager.Lager   = 0
                AND   HoReLager.Art     = 1
                AND   HoReLager.Artnr   = bBesEing.Artnr
                AND   HoReLager.Inhalt  = bBesEing.Inhalt
                AND ((bBesEing.GGeb_EG = 0)  
                OR   (bBesEing.GGeb_EG > 0 AND HoReLager.Bestand = 0)
                OR   (bBesEing.GGeb_EG < 0 AND HoReLager.Bestand > ABS(bBesEing.GGeb_EG))) NO-ERROR.
            IF AVAILABLE HoReLager THEN LEAVE.

            FIND FIRST HoReLager NO-LOCK 
                WHERE HoReLager.Firma   = bBesEing.Firma
                AND   HoReLager.Lager   = 0
                AND   HoReLager.Art     = 2
                AND   HoReLager.Artnr   = bBesEing.Artnr
                AND   HoReLager.Inhalt  = bBesEing.Inhalt
                AND ((bBesEing.GGeb_EG = 0)  
                OR   (bBesEing.GGeb_EG > 0 AND HoReLager.Bestand = 0)
                OR   (bBesEing.GGeb_EG < 0 AND HoReLager.Bestand > ABS(bBesEing.GGeb_EG))) NO-ERROR.
            IF AVAILABLE HoReLager THEN LEAVE.
            
            FIND FIRST HoReLager NO-LOCK 
                WHERE HoReLager.Firma   = bBesEing.Firma
                AND   HoReLager.Lager   = 0
                AND   HoReLager.Artnr   = bBesEing.Artnr
                AND   HoReLager.Inhalt  = bBesEing.Inhalt NO-ERROR.
            IF AVAILABLE HoReLager THEN LEAVE.
            
            IF NOT lBatch THEN 
            DO:
                cString = SUBSTITUTE('&1/&2/&3', bBesEing.Artnr, bBesEing.Inhalt, bBesEing.Jahr). 
                DYNAMIC-FUNCTION ('fehlerMeldung':U, 1117, cString ) NO-ERROR.
                UNDO EINLAGERUNG, LEAVE EINLAGERUNG.
            END.
            oplOK = TRUE.
            RELEASE BesEing.
            LEAVE EINLAGERUNG.
        END.
        
        rHoReLager = RECID(HoReLager).
        RELEASE HoReLager.
        
        FIND HoReLager WHERE RECID(HoReLager) = rHoReLager.
        ASSIGN  
            HoReLager.iStatus = 2
            HoReLager.Bestand = HoReLager.Bestand + bBesEing.Eingang.
        IF HoReLager.Eingang = ? THEN HoReLager.Eingang = TODAY.
        IF HoReLager.Bestand < 0 THEN HoReLager.Bestand = 0.
        
        IF  NOT bBesEing.lVerfall AND
            NOT bBesEing.lLotnr  THEN 
        DO:
            oplOk = TRUE.
            LEAVE.
        END.
        
        dVerfall = (IF bBesEing.lVerfall THEN bBesEing.Verfall ELSE bBesEing.Eing_Dat).
        IF dVerfall = ? THEN dVerfall = TODAY. 
        FIND FIRST LotLager USE-INDEX LotLager-k1
            WHERE LotLager.HoReLager_Id = HoReLager.HoReLager_Id
            AND   LotLager.Verfall      = dVerfall
            AND   LotLager.Lotnummer    = bBesEing.Lotnr NO-ERROR.
        IF  NOT AVAILABLE LotLager AND 
            bBesEing.Eingang > 0   THEN 
        DO:
            CREATE  LotLager.
            ASSIGN  
                LotLager.HoReLager_Id = HoReLager.HoReLager_Id
                LotLager.Artnr        = bBesEing.Artnr
                LotLager.Inhalt       = bBesEing.Inhalt
                LotLager.Jahr         = bBesEing.Jahr
                LotLager.Eingang      = bBesEing.Eing_Dat
                LotLager.Verfall      = dVerfall
                LotLager.Lotnummer    = bBesEing.Lotnr
                LotLager.Firma        = bBesEing.Firma
                LotLager.Barcode      = bBesEing.Barcode.
        END.
        IF AVAILABLE LotLager THEN LotLager.Bestand = LotLager.Bestand + bBesEing.Eingang.

        oplOk = TRUE.                    
        LEAVE.
    END. 

END PROCEDURE.

/* ************************  Function Implementations ***************** */


FUNCTION calculateBeskoTotal RETURNS DECIMAL 
    ( ipcFirma AS CHARACTER, ipiBesnr AS INTEGER, OUTPUT opnTotale AS DECIMAL EXTENT 10 ):
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE nBetrag  AS DECIMAL NO-UNDO INIT 0.00.
    DEFINE VARIABLE iMwst_Cd AS INTEGER NO-UNDO.
    DEFINE VARIABLE iGGeb_Me AS DECIMAL NO-UNDO.
    DEFINE VARIABLE iVGeb_Me AS DECIMAL NO-UNDO.
    DEFINE VARIABLE iKGeb_Me AS DECIMAL NO-UNDO.
    DEFINE VARIABLE ii       AS INTEGER NO-UNDO.
    
    DEFINE BUFFER bBesko    FOR Besko   .
    DEFINE BUFFER bBesze    FOR Besze   .
    DEFINE BUFFER bBesGebKo FOR BesGebKo.
    
    opnTotale = 0.
    iMwst_Cd  = INTEGER(DYNAMIC-FUNCTION('getFehlwert':U, ipcFirma, 'MWSTLIEFERANT' )).
    
    REPEAT TRANSACTION:
        FIND bBesko
            WHERE bBesko.Firma = ipcFirma
            AND   bBesko.Besnr = ipiBesnr NO-ERROR.
        IF NOT AVAILABLE bBesko THEN RETURN nBetrag.
        
        FOR EACH bBesze NO-LOCK OF bBesko:
            IF bBesze.Artnr = 0 THEN NEXT.
            opnTotale[01] = opnTotale[01] + bBesze.Netto .
            opnTotale[02] = opnTotale[02] + bBesze.SpesenBetr.
            IF bBesze.MGel > 0 THEN
                ASSIGN  
                    iGGeb_Me = bBesze.GGeb_EG
                    iVGeb_Me = bBesze.VGeb_EG
                    iKGeb_Me = bBesze.KGeb_EG.
            ELSE
                ASSIGN
                    iGGeb_Me = bBesze.GGeb_Me
                    iVGeb_Me = bBesze.VGeb_Me
                    iKGeb_Me = bBesze.KGeb_Me.
            IF iGGeb_Me <> 0 THEN 
            DO:
                FIND GebKonto NO-LOCK
                    WHERE GebKonto.Firma  = bBesze.Firma
                    AND   GebKonto.Geb_Cd = bBesze.GGebKto NO-ERROR. 
                IF AVAILABLE GebKonto THEN 
                DO:
                    opnTotale[03] = opnTotale[03] + (iGGeb_Me * GebKonto.Depot  ).
                    opnTotale[04] = opnTotale[04] + (iGGeb_Me * GebKonto.Gebuehr).
                END.
            END.
            IF iVGeb_Me <> 0 THEN 
            DO:
                FIND GebKonto NO-LOCK
                    WHERE GebKonto.Firma  = bBesze.Firma
                    AND   GebKonto.Geb_Cd = bBesze.VGebKto.
                IF AVAILABLE GebKonto THEN 
                DO:
                    opnTotale[03] = opnTotale[03] + (iVGeb_Me * GebKonto.Depot  ).
                    opnTotale[04] = opnTotale[04] + (iVGeb_Me * GebKonto.Gebuehr).
                END.
            END.
            IF iKGeb_Me <> 0 THEN 
            DO:
                FIND GebKonto NO-LOCK
                    WHERE GebKonto.Firma  = bBesze.Firma
                    AND   GebKonto.Geb_Cd = bBesze.KGebKto.
                IF AVAILABLE GebKonto THEN 
                DO:
                    opnTotale[03] = opnTotale[03] + (iKGeb_Me * GebKonto.Depot  ).
                    opnTotale[04] = opnTotale[04] + (iKGeb_Me * GebKonto.Gebuehr).
                END.
            END.
            RELEASE bBesze.
        END.
        FOR EACH bBesGebKo NO-LOCK OF bBesko:
            opnTotale[05] = opnTotale[05] - bBesGebKo.Betrag_1 - bBesGebKo.Betrag_2 - bBesGebKo.Betrag_3.
            RELEASE bBesGebKo.
        END.
        ASSIGN  
            bBesko.SpesenBetr = opnTotale[02]
            bBesko.Best_Tot   = opnTotale[01].
        DO ii = 1 TO 9:
            opnTotale[10] = opnTotale[10] + opnTotale[ii].
        END.
        
        RELEASE bBesko.
        RELEASE bBesze.
        RELEASE bBesGebKo.
        
        nBetrag = opnTotale[10].
        
        LEAVE.
    END.

    RETURN nBetrag.
        
END FUNCTION.

FUNCTION calculateBeszeNetto RETURNS LOGICAL 
    ( ipcFirma AS CHARACTER, ipiBesnr AS INTEGER, ipiPos AS INTEGER,  ipiRecid AS RECID ):
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE nBetrag AS DECIMAL NO-UNDO DECIMALS 4.
    DEFINE VARIABLE nSpesen AS DECIMAL NO-UNDO DECIMALS 4.
    DEFINE VARIABLE nMenge  AS DECIMAL NO-UNDO.

    DEFINE BUFFER bBesko FOR Besko.
    DEFINE BUFFER bBesze FOR Besze.
    
    REPEAT TRANSACTION:
        IF ipiRecid <> ? THEN FIND bBesze WHERE RECID(bBesze) = ipiRecid NO-ERROR.
        ELSE 
        DO:
            FIND bBesze
                WHERE bBesze.Firma = ipcFirma
                AND   bBesze.Besnr = ipiBesnr
                AND   bBesze.Pos   = ipiPos NO-ERROR.
        END.
        IF NOT AVAILABLE bBesze THEN RETURN FALSE.
    
        FIND bBesko NO-LOCK OF bBesze NO-ERROR.
        IF NOT AVAILABLE bBesko THEN RETURN FALSE.
    
        IF bBesko.Best_Sta > 2 THEN nMenge = bBesze.MGel.
        ELSE                        nMenge = bBesze.MBest.
    
        nBetrag = bBesze.S_Preis_Frw * (100 - bBesze.Rabatt) / 100.
        nBetrag = nBetrag * (100 - bBesze.ZusRab) / 100.
        nSpesen = nBetrag * bBesze.Spesen / 100.
    
        ASSIGN  
            bBesze.Netto      = nBetrag * nMenge
            bBesze.SpesenBetr = nSpesen * nMenge
            bBesze.Preis      = nBetrag + nSpesen.
        /*            bBesze.L_EP_FRW   = nBetrag  + nSpesen                    */
        /*            bBesze.L_EP       = L_EP_Frw * bBesze.Kurs / bBesze.Faktor*/
        .
        RELEASE bBesze.
        LEAVE.
    END.
    
    RETURN TRUE.
        
END FUNCTION.

FUNCTION calculatetBeszeNetto RETURNS LOGICAL 
    ( INPUT-OUTPUT iphtBesze AS HANDLE  ):
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE nBetrag AS DECIMAL NO-UNDO DECIMALS 4.
    DEFINE VARIABLE nSpesen AS DECIMAL NO-UNDO DECIMALS 4.
    DEFINE VARIABLE nMenge  AS DECIMAL NO-UNDO.

    DEFINE BUFFER bBesko FOR Besko.
    
    REPEAT TRANSACTION:
        FIND bBesko NO-LOCK
            WHERE bBesko.Firma = iphtBesze::Firma
            AND   bBesko.Besnr = iphtBesze::Besnr NO-ERROR.
        IF NOT AVAILABLE bBesko THEN RETURN FALSE.
    
        IF bBesko.Best_Sta > 2 THEN nMenge = iphtBesze::MGel.
        ELSE                        nMenge = iphtBesze::MBest.
    
        nBetrag = iphtBesze::S_Preis_Frw * (100 - iphtBesze::Rabatt) / 100.
        nBetrag = nBetrag * (100 - iphtBesze::ZusRab) / 100.
        nSpesen = nBetrag * iphtBesze::Spesen / 100.
    
        ASSIGN  
            iphtBesze::Netto      = nBetrag * nMenge
            iphtBesze::SpesenBetr = nSpesen * nMenge
            iphtBesze::Preis      = nBetrag + nSpesen.
        .
        LEAVE.
    END.
    
    RETURN TRUE.
        
END FUNCTION.

FUNCTION changeBestellStatus RETURNS LOGICAL 
    ( INPUT-OUTPUT iohBesko AS HANDLE ):
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes:                                                                       */
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOGICAL NO-UNDO INIT FALSE.
    
    DEFINE BUFFER bBesko FOR Besko.
    DEFINE BUFFER bBesze FOR Besze.
    
    EMPTY TEMP-TABLE tBesko.
    CREATE tBesko.
    htBesko:BUFFER-COPY ( iohBesko ).
    
    IF tBesko.Best_Sta = 4 THEN RETURN lRetVal.
    
    REPEAT TRANSACTION WHILE tBesko.Best_Sta = 1 ON ERROR UNDO, LEAVE:
        FIND bBesko OF tBesko.
        bBesko.Best_Sta = bBesko.Best_Sta + 1.
        
        FOR EACH bBesze OF bBesko:
            IF bBesze.Artnr = 0 THEN NEXT.
            IF bBesze.MBest = 0 THEN 
            DO:
                DELETE  bBesze.
            END.
            FIND Artst   NO-LOCK OF bBesze.
            FIND ArtLief NO-LOCK
                WHERE ArtLief.Firma  = bBesze.Firma
                AND   ArtLief.Knr    = tBesko.Knr
                AND   ArtLief.Artnr  = bBesze.Artnr
                AND   ArtLief.Inhalt = bBesze.Inhalt
                AND   ArtLief.Jahr   = bBesze.Jahr NO-ERROR.
            
            ASSIGN  
                bBesze.Best_Sta = bBesko.Best_Sta
                bBesze.MRuek    = bBesze.MBest - bBesze.MGeli - bBesze.Eingang
                bBesze.lVerfall = Artst.lVerfall
                bBesze.lLotnr   = Artst.lLotnr
                bBesze.S_Artnr  = (IF ArtLief.S_Artnr <> '' THEN ArtLief.S_Artnr ELSE STRING(bBesze.Artnr,'999999'))
                bBesze.S_Bez1   = (IF ArtLief.S_Bez1  <> '' THEN ArtLief.S_Bez1  ELSE        bBesze.Bez1           )
                bBesze.S_Bez2   = (IF ArtLief.S_Bez2  <> '' THEN ArtLief.S_Bez2  ELSE        bBesze.Bez2           )
                .
            
            RELEASE bBesze.
            RELEASE Artst.
        END.
        
        BUFFER-COPY bBesko TO tBesko.
        iohBesko:BUFFER-COPY ( htBesko ).
        RELEASE bBesko.
        
        lRetVal = TRUE.
        RETURN lRetVal.
    END.
    
    EINGANGBUCHEN:    
    REPEAT TRANSACTION WHILE tBesko.Best_Sta = 2 ON ERROR UNDO, LEAVE:
        FIND bBesko OF tBesko.
        
        bBesko.Best_Sta = bBesko.Best_Sta + 1.
        
        FOR EACH bBesze OF bBesko:
            IF bBesze.Artnr = 0 THEN NEXT.
            IF bBesze.MBest = 0 THEN 
            DO:
                DELETE  bBesze.
                NEXT.
            END.
            bBesze.Best_Sta = bBesko.Best_Sta.
            RELEASE bBesze.
        END.
        
        BUFFER-COPY bBesko TO tBesko.
        iohBesko:BUFFER-COPY ( htBesko ).
        RELEASE bBesko.
        
        RUN EINBUCHEN_MENGEN.
        
        IF RETURN-VALUE = '' THEN 
        DO:
            lRetVal = TRUE.
            LEAVE EINGANGBUCHEN.
        END.
        
        UNDO EINGANGBUCHEN, LEAVE EINGANGBUCHEN.
    END.
        
    RETURN lRetVal.
        
END FUNCTION.

FUNCTION createBesGebKo RETURNS LOGICAL 
    ( ipcFirma AS CHARACTER, ipiBesnr AS INTEGER ):
    /*------------------------------------------------------------------------------
     Purpose:
     Notes:
    ------------------------------------------------------------------------------*/    

    FOR EACH GebRueck NO-LOCK
        WHERE GebRueck.Firma = Firma:
                
        CREATE  BesGebKo.
        ASSIGN  
            BesGebKo.Firma   = ipcFirma
            BesGebKo.Besnr   = ipiBesnr
            BesGebKo.Sort_Cd = GebRueck.Sort_Cd
            BesGebKo.Geb_Cd  = GebRueck.Geb_Cd
            BesGebKo.Anz_1   = GebRueck.Anz_1
            BesGebKo.Kto_Cd1 = GebRueck.Kto_Cd1
            BesGebKo.Anz_2   = GebRueck.Anz_2
            BesGebKo.Kto_Cd2 = GebRueck.Kto_Cd2
            BesGebKo.Anz_3   = GebRueck.Anz_3
            BesGebKo.Kto_Cd3 = GebRueck.Kto_Cd3.
        IF BesGebKo.Kto_Cd1 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = ipcFirma
                AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd1 NO-ERROR.
            IF AVAILABLE GebKonto THEN BesGebKo.Wert_1 = GebKonto.Depot.
        END.
        IF BesGebKo.Kto_Cd2 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = ipcFirma
                AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd2 NO-ERROR.
            IF AVAILABLE GebKonto THEN BesGebKo.Wert_2 = GebKonto.Depot.
        END.
        IF BesGebKo.Kto_Cd3 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = ipcFirma
                AND   GebKonto.Geb_Cd = BesGebKo.Kto_Cd3 NO-ERROR.
            IF AVAILABLE GebKonto THEN BesGebKo.Wert_3 = GebKonto.Depot.
        END.
        RELEASE BesGebKo.
    END.
    
    RETURN TRUE.
        
END FUNCTION.

FUNCTION createBestellnummer RETURNS INTEGER 
    ( ipFirma AS CHARACTER  ):
    /*------------------------------------------------------------------------------
     Purpose:
     Notes:
    ------------------------------------------------------------------------------*/    

    DEFINE VARIABLE iBesnr AS INTEGER INIT 0 NO-UNDO.

    REPEAT TRANSACTION:
        FIND SteuNr WHERE SteuNr.Firma = ipFirma
            EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
        IF AVAILABLE SteuNr THEN 
        DO:
            ASSIGN  
                SteuNr.Nr3 = SteuNr.Nr3 + 1
                iBesnr     = SteuNr.Nr3.
            RELEASE SteuNr.
            LEAVE.
        END.
        IF LOCKED SteuNr THEN 
        DO:
            MESSAGE 'SteuNr LOCKED' VIEW-AS ALERT-BOX INFORMATION.
            NEXT.
        END.
        RELEASE SteuNr.
        LEAVE.
    END.
    
    RETURN iBesnr.
    
END FUNCTION.

FUNCTION fillBesze RETURNS INTEGER 
    ( INPUT-OUTPUT iohtBesze AS HANDLE ):
    /*------------------------------------------------------------------------------
     Purpose:
     Notes:
    ------------------------------------------------------------------------------*/    

    DEFINE VARIABLE iRetVal AS INTEGER NO-UNDO INIT 0.
    DEFINE VARIABLE iPos    AS INTEGER NO-UNDO.
    
    DEFINE BUFFER bBesko    FOR Besko.
    DEFINE BUFFER bBesze    FOR Besze.
    DEFINE BUFFER bArtst    FOR Artst.
    DEFINE BUFFER bArtBez   FOR ArtBez.
    DEFINE BUFFER bArtLager FOR ArtLager.
    DEFINE BUFFER bArtLief  FOR ArtLief.
    
    EMPTY TEMP-TABLE tBesze.
    CREATE  tBesze.
    htBesze:BUFFER-COPY ( iohtBesze ).
    
    IF tBesze.Pos = 0 THEN 
    DO:
        FIND LAST bBesze NO-LOCK 
            WHERE bBesze.Firma = tBesze.Firma
            AND   bBesze.Besnr = tBesze.Besnr NO-ERROR.
        iPos = (IF AVAILABLE bBesze THEN (bBesze.Pos - (bBesze.Pos MOD 10)) + 10 ELSE 10).
        tBesze.Pos = iPos.
    END.
    ELSE iPos = bBesze.Pos.

    FIND bBesko NO-LOCK 
        WHERE bBesko.Firma = tBesze.Firma
        AND   bBesko.Besnr = tBesze.Besnr NO-ERROR.
        
    CASE tBesze.iStatus:
        WHEN 0 THEN 
            DO:
                ASSIGN
                    tBesze.Lager    = bBesko.Lager
                    tBesze.Verbucht = bBesko.Verbucht
                    tBesze.Spesen   = bBesko.Spesen
                    tBesze.Rabatt   = bBesko.Rabatt
                    tBesze.ZusRab   = bBesko.ZusRab
                    tBesze.FRW      = bBesko.FRW
                    tBesze.Kurs     = bBesko.Kurs
                    tBesze.Faktor   = bBesko.Faktor
                    tBesze.Best_Sta = bBesko.Best_Sta.
            
                IF tBesze.Artnr = 0 THEN 
                DO:
                    ASSIGN
                        tBesze.Spesen   = 0.00
                        tBesze.Rabatt   = 0.00
                        tBesze.ZusRab   = 0.00
                        tBesze.Best_Sta = bBesko.Best_Sta.
                    iohtBesze:BUFFER-COPY ( htBesze ).
                    RETURN iRetVal.
                END.
            END.
        OTHERWISE 
        DO:
            IF tBesze.Artnr = 0 THEN RETURN iRetVal.
        END.
    END CASE.
    
    DO WHILE TRUE:
        FIND bArtst NO-LOCK 
            WHERE bArtst.Firma  = tBesze.Firma
            AND   bArtst.Artnr  = tBesze.Artnr
            AND   bArtst.Inhalt = tBesze.Inhalt
            AND   bArtst.Jahr   = tBesze.Jahr NO-ERROR.
        IF NOT AVAILABLE bArtst THEN 
        DO:
            iRetVal = 213.
            LEAVE.
        END.
        
        FIND FIRST bArtBez NO-LOCK 
            WHERE bArtBez.Firma  = tBesze.Firma
            AND   bArtBez.Artnr  = tBesze.Artnr
            AND   bArtBez.Inhalt = tBesze.Inhalt
            AND   bArtBez.Jahr   = tBesze.Jahr NO-ERROR.
        IF NOT AVAILABLE bArtBez THEN 
        DO:
            iRetVal = 222.
            RELEASE bArtst.
            LEAVE.
        END.
        
        FIND FIRST bArtLief NO-LOCK 
            WHERE bArtLief.Firma  = tBesze.Firma
            AND   bArtLief.Knr    = bBesko.Knr
            AND   bArtLief.Artnr  = tBesze.Artnr
            AND   bArtLief.Inhalt = tBesze.Inhalt
            AND   bArtLief.Jahr   = tBesze.Jahr NO-ERROR.
        IF NOT AVAILABLE bArtLief THEN 
        DO:
            iRetVal = 218.
            RELEASE bArtst.
            RELEASE bArtBez.
            LEAVE.
        END.
        
        FIND FIRST bArtLager NO-LOCK 
            WHERE bArtLager.Firma  = tBesze.Firma
            AND   bArtLager.Artnr  = tBesze.Artnr
            AND   bArtLager.Inhalt = tBesze.Inhalt
            AND   bArtLager.Jahr   = tBesze.Jahr
            AND   bArtLager.Lager  = bBesko.Lager NO-ERROR.
        IF NOT AVAILABLE bArtLager THEN 
        DO:
            iRetVal = 1107.
            RELEASE bArtst.
            RELEASE bArtBez.
            RELEASE bArtLief.
            LEAVE.
        END.
        LEAVE.
    END.
    
    IF iRetVal > 0 THEN RETURN iRetVal.
    
    IF tBesze.iStatus = 0 THEN 
    DO:
        ASSIGN
            tBesze.Bez1            = bArtBez.Bez1
            tBesze.Bez2            = bArtBez.Bez2
            tBesze.Zustext[ 1]     = bArtBez.Zustext[ 1]
            tBesze.Zustext[ 2]     = bArtBez.Zustext[ 2]
            tBesze.Zustext[ 3]     = bArtBez.Zustext[ 3]
            tBesze.Zustext[ 4]     = bArtBez.Zustext[ 4]
            tBesze.Zustext[ 5]     = bArtBez.Zustext[ 5]
            tBesze.Zustext[ 6]     = bArtBez.Zustext[ 6]
            tBesze.Zustext[ 7]     = bArtBez.Zustext[ 7]
            tBesze.Zustext[ 8]     = bArtBez.Zustext[ 8]
            tBesze.Zustext[ 9]     = bArtBez.Zustext[ 9]
            tBesze.Zustext[10]     = bArtBez.Zustext[10]
            tBesze.KGeb_Cd         = bArtst.KGeb_Cd
            tBesze.VGeb_Cd         = bArtst.VGeb_Cd
            tBesze.GGeb_Cd         = bArtst.GGeb_Cd
            tBesze.EP              = bArtst.DEP
            tBesze.Alter_EP        = bArtst.LEP
            tBesze.S_Artnr         = bArtLief.S_Artnr
            tBesze.S_Bez1          = bArtLief.S_Bez1
            tBesze.S_Bez2          = bArtLief.S_Bez2
            tBesze.S_Preis         = bArtLief.S_Preis 
            tBesze.S_Preis_FRW     = bArtLief.S_Preis_FRW
            tBesze.L_EP            = bArtLief.L_EP
            tBesze.L_EP_FRW        = bArtLief.L_EP_FRW
            tBesze.L_Rabatt        = bArtLief.L_Rabatt
            tBesze.Spesen          = (IF bArtLief.Spesen = 0 THEN bBesko.Spesen ELSE bArtLief.Spesen)
            tBesze.Rabatt          = (IF bArtLief.Rabatt = 0 THEN bBesko.Rabatt ELSE bArtLief.Rabatt)
            tBesze.ZusRab          = bBesko.ZusRab
            tBesze.FRW             = bBesko.FRW
            tBesze.Kurs            = bBesko.Kurs
            tBesze.Faktor          = bBesko.Faktor
            tBesze.Alter_Listen_EP = bArtst.Listen_EP
            tBesze.Alter_EP        = bArtst.EP
            tBesze.lLotnr          = bArtst.lLotnr
            tBesze.lVerfall        = bArtst.lVerfall
            tBesze.Best_Sta        = bBesko.Best_Sta
            tBesze.Preis           = ((bArtLief.S_Preis * (100 - tBesze.Rabatt)) * (100 - tBesze.ZusRab) / 10000 * (100 + tBesze.Spesen) / 100 )
            .
        IF tBesze.S_Artnr = '' THEN tBesze.S_Artnr = STRING(tBesze.Artnr,'999999').
        IF tBesze.S_Bez1  = '' THEN tBesze.S_Bez1  =        tBesze.Bez1           .
        IF tBesze.S_Bez2  = '' THEN tBesze.S_Bez2  =        tBesze.Bez2           .
            
        IF tBesze.GGeb_Cd <> '' THEN 
        DO:
            FIND GGebinde NO-LOCK 
                WHERE GGebinde.Firma  = tBesze.Firma
                AND   GGebinde.Geb_Cd = tBesze.GGeb_Cd NO-ERROR.
            ASSIGN  
                tBesze.GGebinde = GGebinde.KBez
                tBesze.GGebKto  = GGebinde.Geb_Kto.
        END.
        IF tBesze.VGeb_Cd <> '' THEN 
        DO:
            FIND VGebinde NO-LOCK 
                WHERE VGebinde.Firma  = tBesze.Firma
                AND   VGebinde.Geb_Cd = tBesze.VGeb_Cd NO-ERROR.
            ASSIGN  
                tBesze.VGebinde = VGebinde.KBez
                tBesze.VGebKto  = VGebinde.Geb_Kto.
        END.
        IF tBesze.KGeb_Cd <> '' THEN 
        DO:
            FIND KGebinde NO-LOCK 
                WHERE KGebinde.Firma  = tBesze.Firma
                AND   KGebinde.Geb_Cd = tBesze.KGeb_Cd NO-ERROR.
            ASSIGN  
                tBesze.KGebinde = KGebinde.KBez
                tBesze.KGebKto  = KGebinde.Geb_Kto.
        END.
    END.
    ELSE 
    DO:
        .
    END.

    RELEASE bBesko   .        
    RELEASE bBesze   .        
    RELEASE bArtst   .        
    RELEASE bArtBez  .        
    RELEASE bArtLager.       
    RELEASE bArtLief .        
    RELEASE GGebinde .        
    RELEASE VGebinde .        
    RELEASE KGebinde .
    
    iohtBesze:BUFFER-COPY ( htBesze ).        

    RETURN iRetVal.
        
END FUNCTION.

FUNCTION filltBesko RETURNS LOGICAL 
    ( INPUT-OUTPUT iohtBesko AS HANDLE  ):
    /*------------------------------------------------------------------------------
     Purpose:
     Notes:
    ------------------------------------------------------------------------------*/    

    DEFINE VARIABLE lRetVal  AS LOG       NO-UNDO INIT TRUE.
    DEFINE VARIABLE cKontakt AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iRecid   AS RECID     NO-UNDO.
    DEFINE VARIABLE lOK      AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE hFeld    AS HANDLE    NO-UNDO.
    
    DEFINE BUFFER bAdresse  FOR Adresse .
    DEFINE BUFFER bAnsprech FOR Ansprech.
    DEFINE BUFFER bLiefst   FOR Liefst  .
    DEFINE BUFFER bWaehrung FOR Waehrung  .
    
    EMPTY TEMP-TABLE tBesko.
    CREATE  tBesko.
    ASSIGN  
        tBesko.Lieferungen = ''
        tBesko.Lieferant   = ''
        tBesko.BestelltBis = ''
        tBesko.iStatus     = 9.
    htBesko:BUFFER-COPY( iohtBesko ).
    
    cKontakt = ''.
    AdFirma  = DYNAMIC-FUNCTION ('GETADMANDANT') NO-ERROR.
    FIND bAdresse NO-LOCK 
        WHERE bAdresse.Firma = AdFirma
        AND   bAdresse.Knr   = tBesko.Knr.
    FIND bLiefst NO-LOCK
        WHERE bLiefst.Firma = tBesko.Firma
        AND   bLiefst.Knr   = tBesko.Knr
        AND   bLiefst.Aktiv = TRUE NO-ERROR.
    IF NOT AVAILABLE bLiefst THEN 
    DO:
        RUN FEHLER ( 1027 ).
        RETURN TRUE.
    END.
    FIND FIRST bAnsprech NO-LOCK
        WHERE bAnsprech.Firma      = tBesko.Firma
        AND   bAnsprech.Knr        = tBesko.Knr
        AND   bAnsprech.Bestellung = TRUE NO-ERROR.
    IF AVAILABLE bAnsprech THEN cKontakt = TRIM(bAnsprech.Vorname + ' ' + bAnsprech.Name).
    ELSE                        cKontakt = bLiefst.Kontakt.
    ASSIGN  
        tBesko.Frw       = bLiefst.Frw
        tBesko.Rabatt    = bLiefst.Rabatt
        tBesko.ZusRab    = bLiefst.ZusRab
        tBesko.Kopf      = bLiefst.Kopf
        tBesko.Schluss   = bLiefst.Schluss
        tBesko.Bemerkung = bLiefst.Bemerkung
        tBesko.Abholtext = ''
        tBesko.Abgeholt  = FALSE
        tBesko.Verbucht  = FALSE
        tBesko.Gedruckt  = FALSE
        tBesko.I_Best    = cKontakt
        tBesko.Spesen    = bLiefst.Spesen
        tBesko.Bemerkung = bLiefst.Bemerkung
        tBesko.Kopf      = bLiefst.Kopf
        tBesko.Schluss   = bLiefst.Schluss
        tBesko.Kond      = bLiefst.Kond NO-ERROR.
        
    FIND bWaehrung NO-LOCK
        WHERE bWaehrung.Firma = bLiefst.Firma
        AND   bWaehrung.Frw   = bLiefst.Frw NO-ERROR.
    ASSIGN  
        tBesko.Kurs   = bWaehrung.Kurs
        tBesko.Faktor = bWaehrung.Faktor.
        
    ASSIGN  
        tBesko.Lieferungen = bLiefst.Lieferungen
        tBesko.BestelltBis = bLiefst.BestBis
        tBesko.Lieferant   = bAdresse.Anzeig_br.
    
    IF tBesko.iStatus = 0 THEN 
    DO:
        ASSIGN  
            tBesko.Best_Datum = TODAY
            tBesko.Lief_Datum = TODAY + 7.
    END.        
            
    RELEASE bAdresse .
    RELEASE bLiefst  .
    RELEASE bAnsprech.
    RELEASE bWaehrung  .
    
    iohtBesko:BUFFER-COPY(htBesko).
        
END FUNCTION.

FUNCTION getBestand RETURNS DECIMAL 
    ( ipcFirma AS CHARACTER, ipiArtnr AS INTEGER, ipiInhalt AS INTEGER, ipiJahr AS INTEGER, ipiLager AS INTEGER ):
    /*------------------------------------------------------------------------------
     Purpose:
     Notes:
    ------------------------------------------------------------------------------*/    

    DEFINE VARIABLE nBestand AS DECIMAL NO-UNDO INIT 0.00.

    DEFINE BUFFER bArtLager FOR ArtLager.
    
    FIND bArtLager NO-LOCK 
        WHERE bArtLager.Firma  = ipcFirma
        AND   bArtLager.Artnr  = ipiArtnr
        AND   bArtLager.Inhalt = ipiInhalt
        AND   bArtLager.Jahr   = ipiJahr
        AND   bArtLager.Lager  = ipiLager NO-ERROR.
        
    nBestand = (IF AVAILABLE bArtLager THEN bArtLager.Bestand ELSE 0.00).
    RELEASE bArtLager.
    
    RETURN nBestand.
        
END FUNCTION.