GeMIS_WEB/GUI/super/auftragfunkt.p

&ANALYZE-SUSPEND _VERSION-NUMBER UIB_v9r12
&ANALYZE-RESUME
&ANALYZE-SUSPEND _UIB-CODE-BLOCK _CUSTOM _DEFINITIONS Procedure 
USING src.ch.adprime.algorithm.NumberSystems FROM PROPATH.
/*------------------------------------------------------------------------
    File        : 
    Purpose     :

    Syntax      :

    Description :

    Author(s)   :
    Created     :
    Notes       :
  ----------------------------------------------------------------------*/
/*          This .W file was created with the Progress AppBuilder.      */
/*----------------------------------------------------------------------*/

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

DEFINE VARIABLE AbhAufnr     AS INTEGER   NO-UNDO.
DEFINE VARIABLE Firma        AS CHARACTER NO-UNDO.
DEFINE VARIABLE AdFirma      AS CHARACTER NO-UNDO.
DEFINE VARIABLE fBatch       AS LOG       INIT FALSE NO-UNDO.
DEFINE VARIABLE lRueckstand  AS LOG       NO-UNDO.
DEFINE VARIABLE lEpProzBetr  AS LOG       NO-UNDO.
DEFINE VARIABLE lSummGrpSpPr AS LOG       NO-UNDO.
DEFINE VARIABLE Benutzer     AS CHARACTER NO-UNDO.
DEFINE VARIABLE hFeld        AS HANDLE    NO-UNDO.

DEFINE TEMP-TABLE tArtst LIKE Artst   .
DEFINE TEMP-TABLE tAufko LIKE Aufko   .
DEFINE TEMP-TABLE tAufze LIKE Aufze
    FIELD Knr     AS INTEGER 
    FIELD Datum   AS DATE 
    FIELD lAktion AS LOGICAL INIT TRUE
    .
DEFINE TEMP-TABLE tSavze LIKE Savze      .
DEFINE TEMP-TABLE tArtbw LIKE Artbw      .
DEFINE TEMP-TABLE tAufGKon LIKE AufGKon  .
DEFINE TEMP-TABLE tAufSpRab LIKE AufSpRab.
DEFINE TEMP-TABLE tAufRabSu LIKE AufRabSu.

DEFINE TEMP-TABLE rRuestAuf NO-UNDO LIKE RuestAuf.

DEFINE TEMP-TABLE tVerlauf
    FIELD FakArt  AS INTEGER
    FIELD AufSta  AS INTEGER
    FIELD wFakArt AS INTEGER
    FIELD wAufSta AS INTEGER
    FIELD zFakArt AS INTEGER
    FIELD zAufSta AS INTEGER
    FIELD dFakArt AS INTEGER
    FIELD dAufSta AS INTEGER
    FIELD wDruck  AS LOG
    FIELD zDruck  AS LOG
    FIELD dDruck  AS LOG

    INDEX tVerlauf-k1 IS PRIMARY
    FakArt
    AufSta.

DEFINE TEMP-TABLE tPreis
    FIELD iArt      AS INTEGER
    FIELD Preis     AS DECIMAL   DECIMALS 4
    FIELD Rab_Proz  AS DECIMAL   DECIMALS 4
    FIELD Rab_Wert  AS DECIMAL   DECIMALS 4
    FIELD Zus_Proz  AS DECIMAL   DECIMALS 4
    FIELD Zus_Wert  AS DECIMAL   DECIMALS 4
    FIELD Spe_Proz  AS DECIMAL   DECIMALS 4
    FIELD Spe_Wert  AS DECIMAL   DECIMALS 4
    FIELD Netto     AS DECIMAL   DECIMALS 4
    FIELD cAkt_Text AS CHARACTER
    
    INDEX tPreis-k1
    Netto
    iArt.
DEFINE BUFFER btPreis FOR tPreis.

DEFINE TEMP-TABLE tParam
    FIELD Firma        AS CHARACTER
    FIELD Knr          AS INTEGER
    FIELD Kond_Datum   AS DATE
    FIELD Mwst         AS INTEGER
    FIELD Preis_Grp    AS INTEGER
    FIELD Ku_Grp       AS INTEGER
    FIELD Rab_Grp      AS INTEGER
    FIELD Sprcd        AS INTEGER
    FIELD Frw          AS CHARACTER
    FIELD Kurs         AS DECIMAL   DECIMALS 4
    FIELD Faktor       AS INTEGER
    FIELD Lager        AS INTEGER
    FIELD Geb_Rg       AS LOG
    FIELD Zei_Rab_Art  AS INTEGER
    FIELD Zei_Rab_Wert AS DECIMAL
    FIELD Auf_Rab_Art  AS INTEGER
    FIELD Auf_Rab_Wert AS DECIMAL
    FIELD Abh_Rab_Art  AS INTEGER
    FIELD Abh_Rab_Wert AS DECIMAL
    FIELD Zuschl_Art   AS INTEGER
    FIELD Zuschl_Wert  AS DECIMAL
    .
    
{ properties.i     }
{ incl/tmwstcalc.i }

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ANALYZE-SUSPEND _UIB-PREPROCESSOR-BLOCK 

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

&Scoped-define PROCEDURE-TYPE Procedure
&Scoped-define DB-AWARE no



/* _UIB-PREPROCESSOR-BLOCK-END */
&ANALYZE-RESUME


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

&IF DEFINED(EXCLUDE-buchenArtikel) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD buchenArtikel Procedure 
FUNCTION buchenArtikel RETURNS LOGICAL
    ( ipKnr    AS INTEGER,
    ipBuffer AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-calculateAuftragsTotal) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD calculateAuftragsTotal Procedure 
FUNCTION calculateAuftragsTotal RETURNS CHARACTER
    ( ipcFirma AS CHARACTER, ipiAufnr AS INTEGER, OUTPUT opnTotal AS DECIMAL EXTENT 15 )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-calculateGebindeAusMenge) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD calculateGebindeAusMenge Procedure
FUNCTION calculateGebindeAusMenge RETURNS LOGICAL 
    (ipcFirma AS CHARACTER,
    ipiArtnr   AS INTEGER,
    ipiInhalt  AS INTEGER,
    ipiJahr    AS INTEGER,
    ipiMenge   AS INTEGER,
    OUTPUT opiGGebinde AS INTEGER,
    OUTPUT opiVGebinde AS INTEGER,
    OUTPUT opiKGebinde AS INTEGER) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-calculateZeilenTotal) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD calculateZeilenTotal Procedure 
FUNCTION calculateZeilenTotal RETURNS LOGICAL
    ( INPUT-OUTPUT iphAufze AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAktionspreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createAktionspreis Procedure 
FUNCTION createAktionspreis RETURNS LOGICAL
    ( ipiAktGrp AS INTEGER, iplAbweich AS LOG, ipiAktKuPr_Grp AS INTEGER, ipiKuPreisGrp AS INTEGER)  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufGebKo) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createAufGebKo Procedure 
FUNCTION createAufGebKo RETURNS LOGICAL
    ( ipAufnr AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufkoParam) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createAufkoParam Procedure 
FUNCTION createAufkoParam RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipAufnr AS INTEGER, ipKnr AS INTEGER, ipDatum AS DATE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufnr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createAufnr Procedure 
FUNCTION createAufnr RETURNS INTEGER
    ( ipFirma AS CHARACTER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createEpPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createEpPreis Procedure 
FUNCTION createEpPreis RETURNS LOGICAL
    ( iphbArtst AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createFaknr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createFaknr Procedure 
FUNCTION createFaknr RETURNS INTEGER
    ( ipFirma AS CHARACTER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createManuellerPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createManuellerPreis Procedure 
FUNCTION createManuellerPreis RETURNS LOGICAL
    ( /* parameter-definitions */ )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createSammnr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD createSammnr Procedure 
FUNCTION createSammnr RETURNS INTEGER
    ( ipFirma AS CHARACTER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-deleteArtbw) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD deleteArtbw Procedure
FUNCTION deleteArtbw RETURNS LOGICAL 
    (ipiTrnr AS INTEGER,
    iprArtbw AS RECID) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteAuflot) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD deleteAuflot Procedure
FUNCTION deleteAuflot RETURNS LOGICAL 
    (iprAufze AS RECID) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteAuftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD deleteAuftrag Procedure 
FUNCTION deleteAuftrag RETURNS LOGICAL
    ( ipRecid AS RECID )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-deleteAufzeile) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD deleteAufzeile Procedure
FUNCTION deleteAufzeile RETURNS LOGICAL 
    (ipRecid AS RECID) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteRuestAuf) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD deleteRuestAuf Procedure
FUNCTION deleteRuestAuf RETURNS LOGICAL 
    (iprRuestAuf AS RECID) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-fillArtbwFromAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD fillArtbwFromAufze Procedure 
FUNCTION fillArtbwFromAufze RETURNS LOGICAL
    ( INPUT-OUTPUT iohtAufze AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufko) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD fillAufko Procedure 
FUNCTION fillAufko RETURNS LOGICAL
    ( ipArt AS INTEGER, INPUT-OUTPUT iphAufko AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufRabSu) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD fillAufRabSu Procedure 
FUNCTION fillAufRabSu RETURNS LOGICAL
    ( /* parameter-definitions */ )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-FillAufSpRab) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD FillAufSpRab Procedure 
FUNCTION FillAufSpRab RETURNS LOGICAL
    (  )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD fillAufze Procedure 
FUNCTION fillAufze RETURNS INTEGER
    ( INPUT-OUTPUT iphAufze AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getAbholSeite) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getAbholSeite Procedure 
FUNCTION getAbholSeite RETURNS INTEGER
    ( /* parameter-definitions */ )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getAufstatus) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getAufstatus Procedure 
FUNCTION getAufstatus RETURNS CHARACTER
    ( ipAufstatus AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
&IF DEFINED(EXCLUDE-getDokumentArt) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getDokumentArt Procedure 
FUNCTION getDokumentArt RETURNS CHARACTER
    ( ipFakart AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getEpProz_Betr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getEpProz_Betr Procedure 
FUNCTION getEpProz_Betr RETURNS LOGICAL
    ( ipFirma AS CHARACTER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getFakart) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getFakart Procedure 
FUNCTION getFakart RETURNS CHARACTER
    ( ipFakart AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getHoReLagerId) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getHoReLagerId Procedure
FUNCTION getHoReLagerId RETURNS INTEGER 
    (ipiArtnr AS INTEGER,
    ipiInhalt AS INTEGER,
    ipiJahr AS INTEGER,
    ipiLager AS INTEGER) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-getPreisAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getPreisAufze Procedure 
FUNCTION getPreisAufze RETURNS INTEGER
    ( INPUT-OUTPUT iohtAufze AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getSummGrpSpPr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getSummGrpSpPr Procedure 
FUNCTION getSummGrpSpPr RETURNS LOGICAL
    ( ipFirma AS CHARACTER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-GET_ABH_AUFNR) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD GET_ABH_AUFNR Procedure 
FUNCTION GET_ABH_AUFNR RETURNS INTEGER
    ( /* parameter-definitions */ )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getVerbuchtTotale) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD getVerbuchtTotale Procedure
FUNCTION getVerbuchtTotale RETURNS CHARACTER 
    (ipcFirma AS CHARACTER,
    ipiAufnr AS INTEGER,
    OUTPUT opnTotal AS DECIMAL EXTENT 15) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-isFestAuftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD isFestAuftrag Procedure 
FUNCTION isFestAuftrag RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipFak_Art AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-setAufkoDruckFlag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD setAufkoDruckFlag Procedure 
FUNCTION setAufkoDruckFlag RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipAufnr AS INTEGER, ipFlag AS LOG )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-setAufzePreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD setAufzePreis Procedure 
FUNCTION setAufzePreis RETURNS INTEGER
    ( ipiSpezPreis AS INTEGER, iplNettoArtikel AS LOG, iplRabAufNetto AS LOG )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
&IF DEFINED(EXCLUDE-SET_ABH_AUFNR) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD SET_ABH_AUFNR Procedure 
FUNCTION SET_ABH_AUFNR RETURNS LOGICAL
    ( ipAufnr AS INTEGER )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-_getPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD _getPreis Procedure 
FUNCTION _getPreis RETURNS LOGICAL
    ( ipKnr AS INTEGER, ipDatum AS DATE, INPUT-OUTPUT iohAufze AS HANDLE )  FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-updateRuestauftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION-FORWARD updateRuestauftrag Procedure
FUNCTION updateRuestauftrag RETURNS LOGICAL 
    (ipiStatus AS INTEGER,
    iprAufze AS RECID) FORWARD.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


/* *********************** Procedure Settings ************************ */

&ANALYZE-SUSPEND _PROCEDURE-SETTINGS
/* Settings for THIS-PROCEDURE
   Type: Procedure
   Allow: 
   Frames: 0
   Add Fields to: Neither
   Other Settings: CODE-ONLY COMPILE
 */
&ANALYZE-RESUME _END-PROCEDURE-SETTINGS

/* *************************  Create Window  ************************** */

&ANALYZE-SUSPEND _CREATE-WINDOW
/* DESIGN Window definition (used by the UIB) 
  CREATE WINDOW Procedure ASSIGN
         HEIGHT             = 32
         WIDTH              = 82.
/* END WINDOW DEFINITION */
                                                                        */
&ANALYZE-RESUME

 


&ANALYZE-SUSPEND _UIB-CODE-BLOCK _CUSTOM _MAIN-BLOCK Procedure 


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

SUBSCRIBE TO 'NEUERMANDANT' ANYWHERE.

DO WHILE TRUE:

    EMPTY TEMP-TABLE tArtst.
    EMPTY TEMP-TABLE tAufko.
    EMPTY TEMP-TABLE tAufze.
    EMPTY TEMP-TABLE tArtbw.
    
    CREATE  tArtst.
    CREATE  tAufko.
    CREATE  tAufze.
    CREATE  tArtbw.

    LEAVE.
END.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


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

&IF DEFINED(EXCLUDE-ALSOFFERTE_CHANGED) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE ALSOFFERTE_CHANGED Procedure 
PROCEDURE ALSOFFERTE_CHANGED :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipAufnr     AS INTEGER          NO-UNDO.
    DEFINE INPUT PARAMETER ipOfferte   AS LOG          NO-UNDO.
    
    DEFINE VARIABLE VMenge AS DECIMAL NO-UNDO.
    
    DEFINE BUFFER bAufze    FOR Aufze   .
    DEFINE BUFFER bArtst    FOR Artst   .
    DEFINE BUFFER bArtLager FOR ArtLager.
    DEFINE BUFFER bArtbw    FOR Artbw   .
    
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FOR EACH bAufze
            WHERE bAufze.Firma = Firma
            AND   bAufze.Aufnr = ipAufnr
            AND   bAufze.Artnr > 0:
            FIND bArtst NO-LOCK
                WHERE bArtst.Firma  = bAufze.Firma
                AND   bArtst.Artnr  = bAufze.Artnr
                AND   bArtst.Inhalt = bAufze.Inhalt
                AND   bArtst.Jahr   = bAufze.Jahr NO-ERROR.
            bAufze.Lag_Buch = ( IF ipOfferte THEN FALSE ELSE bArtst.Lager ).
            FIND bArtbw OF bAufze.
            bArtbw.Lag_Buch = bAufze.Lag_Buch.
            
            RELEASE bArtst.
            RELEASE bArtbw.
            RELEASE bAufze.
            RELEASE bArtLager.
        END.
        LEAVE.
    END.
    
END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-ARTBWMUT) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE ARTBWMUT Procedure 
PROCEDURE ARTBWMUT :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipRecid     AS RECID                NO-UNDO.

    FIND FIRST tAufze.
    FIND Artbw WHERE RECID(Artbw) = ipRecid.
    FIND Aufko OF tAufze NO-LOCK NO-ERROR.
    
    BUFFER-COPY tAufze TO Artbw
        ASSIGN  
        Artbw.Menge     = tAufze.MGeli
        Artbw.Datum     = Aufko.Auf_Dat
        Artbw.Faktor    = 1
        Artbw.Kurs      = Aufko.Kurs
        Artbw.Faknr     = Aufko.Faknr
        Artbw.Fak_Dat   = Aufko.Fak_Dat
        Artbw.Fak_Art   = Aufko.Fak_Art
        Artbw.Knr       = Aufko.Knr
        Artbw.Fak_Knr   = Aufko.Fak_Knr
        Artbw.Abhol     = Aufko.Abhol
        Artbw.Vertr     = Aufko.Vertr.
                
    RELEASE Artbw.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-AUFTRAGFUNKTIONENINIT) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE AUFTRAGFUNKTIONENINIT Procedure 
PROCEDURE AUFTRAGFUNKTIONENINIT :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    Firma   = DYNAMIC-FUNCTION('GETMANDANT':U  ) NO-ERROR.
    AdFirma = DYNAMIC-FUNCTION('GETADMANDANT':U) NO-ERROR.

    lEpProzBetr  = DYNAMIC-FUNCTION('getEpProz_Betr':U, Firma ) NO-ERROR.
    lSummGrpSpPr = DYNAMIC-FUNCTION('getSummGrpSpPr':U, Firma ) NO-ERROR.

    RUN LADEN_DOKVERLAUF.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-AUFTRAGSTOTAL) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE AUFTRAGSTOTAL Procedure 
PROCEDURE AUFTRAGSTOTAL :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT  PARAMETER ipAufnr    AS INTEGER                      NO-UNDO.
    DEFINE OUTPUT PARAMETER ipTotal    AS CHARACTER                     NO-UNDO.

    DEFINE VARIABLE VTotal AS DECIMAL DECIMALS 4 EXTENT 15 NO-UNDO.
    DEFINE VARIABLE zz     AS INTEGER NO-UNDO.

    ipTotal = ''.

    DYNAMIC-FUNCTION('calculateAuftragsTotal':U, Firma, ipAufnr, OUTPUT VTotal ).

    DO zz = 1 TO 15:
        ipTotal = ipTotal
            + (IF ipTotal = '' THEN '' ELSE CHR(01))
            + STRING(VTotal[zz]).
    END.

    RETURN ''.
    
END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-AUFTRAG_GEDRUCKT) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE AUFTRAG_GEDRUCKT Procedure 
PROCEDURE AUFTRAG_GEDRUCKT :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipAufnr     AS INTEGER                  NO-UNDO.
    
    DEFINE VARIABLE AltSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE NeuSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE AltFakArt  AS INTEGER NO-UNDO.
    DEFINE VARIABLE iSammNr    AS INTEGER NO-UNDO.
    DEFINE VARIABLE lAltFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE lNeuFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE iRecid     AS RECID   NO-UNDO.

    DEFINE BUFFER xAufko FOR Aufko.

    STATUSAENDERUNG:
    REPEAT TRANSACTION:
        FIND Aufko EXCLUSIVE-LOCK USE-INDEX Aufko-k1
            WHERE Aufko.Firma = Firma
            AND   Aufko.Aufnr = ipAufnr NO-WAIT NO-ERROR.
        IF NOT AVAILABLE Aufko THEN 
        DO:
            RELEASE Aufko.
            RETURN 'Fehler'.
        END.
        IF Aufko.AlsOfferte THEN 
        DO:
            RELEASE Aufko.
            MESSAGE 'Auftrag ist Offerte! WEITER geht hier nicht! '
                VIEW-AS ALERT-BOX INFORMATION.
            RETURN 'Fehler'.
        END.
        ASSIGN  
            iRecid         = RECID(Aufko)
            Firma          = Aufko.Firma
            Aufko.Gedruckt = TRUE.
        
        FIND FIRST tVerlauf NO-LOCK USE-INDEX tVerlauf-k1
            WHERE tVerlauf.FakArt = Aufko.Fak_Art
            AND   tVerlauf.AufSta = Aufko.Auf_Sta  NO-ERROR.
        IF NOT AVAILABLE tVerlauf THEN 
        DO:
            RELEASE Aufko.
            RETURN 'ERROR'.
        END.
        
        IF Aufko.Fak_Art = tVerlauf.dFakArt AND
            Aufko.Auf_Sta = tVerlauf.dAufSta THEN 
        DO:
            RELEASE Aufko.
            RETURN ''.
        END.

        FIND Tabel NO-LOCK USE-INDEX Tabel-k1
            WHERE Tabel.Firma  = Firma
            AND   Tabel.RecArt = 'FAKART'
            AND   Tabel.CodeC  = ''
            AND   Tabel.CodeI  = Aufko.Fak_Art
            AND   Tabel.Sprcd  = 1 NO-ERROR.
        IF Tabel.Int_3 = 4 THEN AltSammFak = TRUE.
        ELSE                    AltSammFak = FALSE.

        ASSIGN  
            AltFakArt      = Aufko.Fak_Art
            lAltFest       = Tabel.Flag_1
            Aufko.Fak_Art  = tVerlauf.dFakArt
            Aufko.Auf_Sta  = tVerlauf.dAufSta
            Aufko.Gedruckt = (IF tVerlauf.dDruck = TRUE THEN FALSE ELSE TRUE).

        IF AltFakArt <> Aufko.Fak_Art THEN 
        DO:
            FIND Tabel NO-LOCK USE-INDEX Tabel-k1
                WHERE Tabel.Firma  = Firma
                AND   Tabel.RecArt = 'FAKART'
                AND   Tabel.CodeC  = ''
                AND   Tabel.CodeI  = Aufko.Fak_Art
                AND   Tabel.Sprcd  = 1 NO-ERROR.
            IF Tabel.Int_3 = 4 THEN NeuSammFak = TRUE.
            ELSE                    NeuSammFak = FALSE.
            lNeuFest = Tabel.Flag_1.
        END.
        ELSE 
        DO:
            ASSIGN  
                lNeufest   = lAltFest
                NeuSammFak = AltSammFak.
        END.

        DO WHILE TRUE:
            IF lAltFest OR
                lNeuFest THEN 
            DO:
                RELEASE Aufko.
                RUN PROCESSFESTAUFTRAG ( Firma, ipAufnr, lAltFest, lNeuFest ) NO-ERROR.
                FIND Aufko NO-LOCK WHERE RECID(Aufko) = iRecid.
                
                IF NeuSammFak        AND
                    NOT AltSammFak    AND
                    Aufko.Samm_Nr = 0 THEN 
                DO:
                    FIND FIRST xAufko NO-LOCK
                        WHERE xAufko.Firma   = Aufko.Firma
                        AND   xAufko.Fak_Art = Aufko.Fak_Art
                        AND   xAufko.Samm_Nr > 0
                        AND   xAufko.Aufnr  <> Aufko.Aufnr NO-ERROR.
                    IF AVAILABLE xAufko THEN 
                    DO:
                        FIND Aufko WHERE RECID(Aufko) = iRecid.
                        ASSIGN  
                            Aufko.Samm_Nr = xAufko.Samm_Nr.
                        RELEASE Aufko.
                    END.
                    FIND Aufko NO-LOCK WHERE RECID(Aufko) = iRecid.
                END.
                IF NeuSammFak      AND
                    tVerlauf.dDruck THEN 
                DO:
                    FOR EACH xAufko
                        WHERE xAufko.Firma   = Aufko.Firma
                        AND   xAufko.Fak_Art = Aufko.Fak_Art
                        AND   xAufko.Samm_Nr = Aufko.Samm_Nr
                        AND   xAufko.Aufnr  <> Aufko.Aufnr:
                        ASSIGN  
                            xAufko.Gedruckt = FALSE.
                    END.
                END.
                LEAVE.
            END.
            
            IF NOT AltSammFak   AND
                NOT NeuSammFak   THEN LEAVE.
            IF AltSammFak       AND
                NOT NeuSammFak   THEN 
            DO:
                ASSIGN  
                    Aufko.Samm_Nr = 0
                    Aufko.Faknr   = 0.
                LEAVE.
            END.
            IF AltSammFak   AND
                NeuSammFak   THEN 
            DO:
                FOR EACH xAufko USE-INDEX Aufko-k5
                    WHERE xAufko.Firma    = Aufko.Firma
                    AND   xAufko.Fak_Art  = AltFakArt
                    AND   xAufko.Samm_Nr  = Aufko.Samm_Nr :
                    ASSIGN  
                        xAufko.Fak_Art = Aufko.Fak_Art
                        xAufko.Auf_Sta = Aufko.Auf_Sta.
                END.
                LEAVE.
            END.
            
            RUN SETSAMMELNUMMER ( INPUT RECID(Aufko) ).
            IF RETURN-VALUE = 'ERROR' THEN 
            DO:
                UNDO STATUSAENDERUNG, RETURN 'ERROR'.
            END.
            LEAVE.
        END.

        RELEASE xAufko.
        RELEASE Aufko.
        LEAVE.
    END.
    RETURN ''.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
&IF DEFINED(EXCLUDE-BUFFER_TO_TAUFZE) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE BUFFER_TO_TAUFZE Procedure 
PROCEDURE BUFFER_TO_TAUFZE :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT-OUTPUT PARAMETER ipBuffer     AS HANDLE           NO-UNDO.

    DEFINE VARIABLE hFeld   AS HANDLE  NO-UNDO.
    DEFINE VARIABLE hBuffer AS HANDLE  NO-UNDO.
    DEFINE VARIABLE hRAufze AS HANDLE  NO-UNDO.
    DEFINE VARIABLE hFAufze AS HANDLE  NO-UNDO.
    DEFINE VARIABLE ii      AS INTEGER NO-UNDO.
    DEFINE VARIABLE ex      AS INTEGER NO-UNDO.

    FIND FIRST tAufze.
    IF NOT AVAILABLE tAufze THEN CREATE tAufze.
    hRAufze = BUFFER tAufze:HANDLE NO-ERROR.
    hRAufze:BUFFER-COPY(ipBuffer).
    
END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-COMBO_BEIFAHRER) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE COMBO_BEIFAHRER Procedure 
PROCEDURE COMBO_BEIFAHRER :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER IHandle     AS HANDLE                   NO-UNDO.
    
    DEFINE VARIABLE RecArt AS CHARACTER INIT 'BEIFAHR' NO-UNDO.
    DEFINE VARIABLE CodeC  AS CHARACTER INIT '' NO-UNDO.
    DEFINE VARIABLE CodeI  AS INTEGER   INIT 0 NO-UNDO.
    DEFINE VARIABLE Sprcd  AS INTEGER   INIT 1 NO-UNDO.
    DEFINE VARIABLE Art    AS INTEGER   INIT 1 NO-UNDO.

    RUN COMBO_TABELLE ( INPUT iHandle   ,
        INPUT RecArt    ,
        INPUT CodeC     ,
        INPUT CodeI     ,
        INPUT Sprcd     ,
        INPUT Art       ).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-COMBO_FAHRER) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE COMBO_FAHRER Procedure 
PROCEDURE COMBO_FAHRER :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER IHandle     AS HANDLE                   NO-UNDO.
    
    DEFINE VARIABLE RecArt AS CHARACTER INIT 'FAHRER' NO-UNDO.
    DEFINE VARIABLE CodeC  AS CHARACTER INIT '' NO-UNDO.
    DEFINE VARIABLE CodeI  AS INTEGER   INIT 0 NO-UNDO.
    DEFINE VARIABLE Sprcd  AS INTEGER   INIT 1 NO-UNDO.
    DEFINE VARIABLE Art    AS INTEGER   INIT 1 NO-UNDO.

    RUN COMBO_TABELLE ( INPUT iHandle   ,
        INPUT RecArt    ,
        INPUT CodeC     ,
        INPUT CodeI     ,
        INPUT Sprcd     ,
        INPUT Art       ).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-COMBO_IBESTELLUNG) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE COMBO_IBESTELLUNG Procedure 
PROCEDURE COMBO_IBESTELLUNG :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER IHandle     AS HANDLE                   NO-UNDO.
    
    DEFINE VARIABLE RecArt AS CHARACTER INIT 'IBEST' NO-UNDO.
    DEFINE VARIABLE CodeC  AS CHARACTER INIT '' NO-UNDO.
    DEFINE VARIABLE CodeI  AS INTEGER   INIT 0 NO-UNDO.
    DEFINE VARIABLE Sprcd  AS INTEGER   INIT 1 NO-UNDO.
    DEFINE VARIABLE Art    AS INTEGER   INIT 4 NO-UNDO.

    RUN COMBO_TABELLE ( INPUT iHandle   ,
        INPUT RecArt    ,
        INPUT CodeC     ,
        INPUT CodeI     ,
        INPUT Sprcd     ,
        INPUT Art       ).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-COMBO_LIEFBEDINGUNG) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE COMBO_LIEFBEDINGUNG Procedure 
PROCEDURE COMBO_LIEFBEDINGUNG :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER IHandle     AS HANDLE                   NO-UNDO.
    
    DEFINE VARIABLE RecArt AS CHARACTER INIT 'LIEFBED' NO-UNDO.
    DEFINE VARIABLE CodeC  AS CHARACTER INIT '' NO-UNDO.
    DEFINE VARIABLE CodeI  AS INTEGER   INIT 0 NO-UNDO.
    DEFINE VARIABLE Sprcd  AS INTEGER   INIT 1 NO-UNDO.
    DEFINE VARIABLE Art    AS INTEGER   INIT 1 NO-UNDO.

    RUN COMBO_TABELLE ( INPUT iHandle   ,
        INPUT RecArt    ,
        INPUT CodeC     ,
        INPUT CodeI     ,
        INPUT Sprcd     ,
        INPUT Art       ).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-COMBO_LKW) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE COMBO_LKW Procedure 
PROCEDURE COMBO_LKW :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER IHandle     AS HANDLE                   NO-UNDO.
    
    DEFINE VARIABLE RecArt AS CHARACTER INIT 'LKW' NO-UNDO.
    DEFINE VARIABLE CodeC  AS CHARACTER INIT '' NO-UNDO.
    DEFINE VARIABLE CodeI  AS INTEGER   INIT 0 NO-UNDO.
    DEFINE VARIABLE Sprcd  AS INTEGER   INIT 1 NO-UNDO.
    DEFINE VARIABLE Art    AS INTEGER   INIT 1 NO-UNDO.

    RUN COMBO_TABELLE ( INPUT iHandle   ,
        INPUT RecArt    ,
        INPUT CodeC     ,
        INPUT CodeI     ,
        INPUT Sprcd     ,
        INPUT Art       ).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-CREATE_AUFKO) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE CREATE_AUFKO Procedure 
PROCEDURE CREATE_AUFKO :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipBuffer    AS HANDLE       NO-UNDO.

    DEFINE VARIABLE cBenDaten AS CHARACTER NO-UNDO.
    DEFINE VARIABLE Aufnr     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Knr       AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwFakArt  AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwAufSta  AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwFahrer  AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwLKW     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwBeiFahr AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwSprcd   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE retValue  AS CHARACTER NO-UNDO.
    DEFINE VARIABLE ix        AS INTEGER   NO-UNDO.
    DEFINE VARIABLE ii        AS INTEGER   NO-UNDO.
    DEFINE VARIABLE hBuffer   AS HANDLE    NO-UNDO.
    DEFINE VARIABLE iLager    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE cBemerk   AS CHARACTER NO-UNDO.

    FwSprcd   = DYNAMIC-FUNCTION('GETFWSPRCD':U)         NO-ERROR.
    cBenDaten = DYNAMIC-FUNCTION('GETBENUTZERDATEN':U)   NO-ERROR.
    iLager    = DYNAMIC-FUNCTION('getBenLager':U)        NO-ERROR.

    FIND FIRST tAufko.
    hBuffer = TEMP-TABLE tAufko:DEFAULT-BUFFER-HANDLE.
    hBuffer:BUFFER-COPY(ipBuffer).

    FIND Adresse NO-LOCK USE-INDEX Adresse-k1
        WHERE Adresse.Firma = AdFirma
        AND   Adresse.Knr   = tAufko.Knr NO-ERROR.

    FIND Debst NO-LOCK USE-INDEX Debst-k1
        WHERE Debst.Firma = Firma
        AND   Debst.Knr   = Adresse.Knr NO-ERROR.
            
    FIND Steuer NO-LOCK
        WHERE Steuer.Firma = Firma NO-ERROR.

    cBemerk = ''.
    CASE Steuer.St05:
        WHEN 0 THEN 
            IF Debst.Bemerk   <> '' THEN cBemerk = Debst.Bemerk.
        WHEN 1 THEN 
            IF Adresse.Bem    <> '' THEN cBemerk = Adresse.Bem.
        WHEN 2 THEN 
            IF Debst.Auf_Text <> '' THEN cBemerk = Debst.Auf_Text.
    END CASE.
    
    IF tAufko.Abhol THEN 
    DO:
        FwFakArt = DYNAMIC-FUNCTION('getAbholFakart':U)    NO-ERROR.
        FwAufSta = DYNAMIC-FUNCTION('getAbholAufstatus':U) NO-ERROR.
    END.
    ELSE 
    DO:
        FwFakArt = Debst.Fak_Art.
        FwAufSta = 0.
    END.
    
    FwLKW     = 0.
    FwFahrer  = 0.
    FwBeiFahr = 0.
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwLKW'     VALUE retValue.
    IF retValue <> ? THEN FwLKW     = INTEGER(retValue).
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwFahrer'  VALUE retValue.
    IF retValue <> ? THEN FwFahrer  = INTEGER(retValue).
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwBeiFahr' VALUE retValue.
    IF retValue <> ? THEN FwBeiFahr = INTEGER(retValue).

    DO WHILE TRUE:
        IF Debst.KnrLie <> 0            AND
            Debst.KnrLie <> Debst.Knr    THEN 
        DO:
            ASSIGN  
                tAufko.Knr     = Debst.KnrLie
                tAufko.Fak_Knr = Debst.Knr.
            LEAVE.
        END.
        IF  Debst.KnrFak <> 0            AND
            Debst.KnrFak <> Debst.Knr    THEN 
        DO:
            ASSIGN  
                tAufko.Knr     = Debst.KnrLie
                tAufko.Fak_Knr = Debst.KnrFak.
            LEAVE.
        END.
        ASSIGN  
            tAufko.Knr     = Debst.Knr
            tAufko.Fak_Knr = Debst.Knr.
        LEAVE.
    END.

    FIND Waehrung NO-LOCK 
        WHERE Waehrung.Firma = Debst.Firma
        AND   Waehrung.FRW   = Debst.FRW NO-ERROR.
    Aufnr = DYNAMIC-FUNCTION('createAufnr':U, Firma) NO-ERROR.    

    ASSIGN  
        tAufko.Aufnr          = Aufnr
        tAufko.Auf_Datum      = TODAY
        tAufko.Lief_Datum     = TODAY
        tAufko.Kond_Datum     = TODAY
        tAufko.Fak_Datum      = ?
        tAufko.Fak_Art        = FwFakArt
        tAufko.I_Best         = ''
        tAufko.U_Ref          = ENTRY(2, cBenDaten, CHR(01))
        /*
        tAufko.Abhol            = FALSE
        */
        tAufko.Vertr          = Debst.Vertr
        tAufko.Rabatt         = 0
        tAufko.Preis_Grp      = Debst.Preis_Grp
        tAufko.Ku_Grp         = Debst.Ku_Grp
        tAufko.Rab_Grp        = Debst.Rab_Grp
        tAufko.Lief_Bed       = Debst.Lief_Bed
        tAufko.Avis           = Debst.Avis
        tAufko.Frw            = Debst.FRW
        tAufko.Kurs           = Waehrung.Kurs
        tAufko.Faktor         = Waehrung.Faktor
        tAufko.Gedruckt       = FALSE
        tAufko.WW             = 0
        tAufko.Wpfl           = 0
        tAufko.Wust           = 0
        tAufko.Auf_Tot        = 0
        tAufko.Faknr          = 0
        tAufko.Bar_Fak        = FALSE
        tAufko.Bar_Betr       = 0
        tAufko.Bar_Skonto     = 0
        tAufko.Bar_Konto      = ''
        tAufko.GG_Berech      = Debst.Geb_rg
        tAufko.Kopf_Text      = ''
        tAufko.Fuss_Text      = ''
        tAufko.Samm_Nr        = 0
        tAufko.SK_Ber         = 0
        tAufko.Verbucht       = FALSE
        tAufko.Rueckst        = FALSE
        tAufko.Fak_KTnr       = 0
        tAufko.Fak_FTnr       = 0
        tAufko.Filiale        = 0
        tAufko.Tour_Nr1       = Debst.Tour_Nr1
        tAufko.Tour_Nr2       = Debst.Tour_Nr2
        tAufko.Konto          = Debst.Konto
        tAufko.Geb_Rg         = Debst.Geb_Rg
        tAufko.MWST_Nr        = ''
        tAufko.Passant        = Debst.Passant
        tAufko.Auf_Text       = Debst.Auf_Text
        tAufko.Bar_Text       = Debst.Bar_Text
        tAufko.Abh_Text       = cBemerk
        tAufko.Zei_Rab_Art    = Debst.Zei_Rab_Art
        tAufko.Zei_Rab_Wert   = Debst.Zei_Rab_Wert
        tAufko.Auf_Rab_Art    = Debst.Auf_Rab_Art
        tAufko.Auf_Rab_Wert   = Debst.Auf_Rab_Wert
        /*
        tAufko.Abh_Rab_Art      = Debst.Abh_Rab_Art
        tAufko.Abh_Rab_Wert     = Debst.Abh_Rab_Wert
        */
        tAufko.Zuschl_Art     = Debst.Zuschl_Art
        tAufko.Zuschl_Wert    = Debst.Zuschl_Wert
        tAufko.Ablad_Vor      = Debst.Ablad_Vor
        tAufko.Wirt_So        = Debst.Wirt_So  
        tAufko.Ablad_Vor_Text = Debst.Ablad_Vor_Text
        tAufko.Wirt_So_Text   = Debst.Wirt_So_Text
        tAufko.MWST           = Debst.MWST
        tAufko.Kond           = Debst.Kond
        tAufko.LKW            = FwLKW
        tAufko.Fahrer         = FwFahrer
        tAufko.BeiFahrer      = FwBeiFahr
        tAufko.Gewicht        = 0
        tAufko.Transp         = 0
        tAufko.Verpack        = 0
        tAufko.Porto          = 0
        tAufko.Lager          = iLager
        .

    IF tAufko.Konto = '' THEN 
    DO:
        FIND SteuNr USE-INDEX SteuNr-k1
            WHERE SteuNr.Firma = Firma NO-LOCK.
        tAufko.Konto = SteuNr.Konto_Debi.
    END.

    ipBuffer:BUFFER-COPY(hBuffer) NO-ERROR.

    RELEASE Adresse.
    RELEASE Debst.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-CREATE_TABTEXTE) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE CREATE_TABTEXTE Procedure 
PROCEDURE CREATE_TABTEXTE :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/
    
    DEFINE INPUT        PARAMETER iphAufko     AS HANDLE.
    DEFINE INPUT-OUTPUT PARAMETER iphTabTexte  AS HANDLE.

   
    iphTabTexte:EMPTY-TEMP-TABLE().
  
    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'FAKART'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Fak_Art
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = Tabel.Bez1
            iphTabTexte::cFeld2  = Tabel.Bez2
            iphTabTexte::cFeld3  = Tabel.BezL
            iphTabTexte::iFeld1  = Tabel.Int_1
            iphTabTexte::iFeld2  = Tabel.Int_2
            iphTabTexte::iFeld3  = Tabel.Int_3.
    END.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'AUFSTATUS'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Auf_Sta
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = Tabel.Bez1
            iphTabTexte::cFeld2  = Tabel.Bez2
            iphTabTexte::cFeld3  = Tabel.BezL.
    END.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'LIEFART'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Lief_Bed
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = Tabel.Bez1
            iphTabTexte::cFeld2  = Tabel.Bez2
            iphTabTexte::cFeld3  = Tabel.BezL.
    END.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'TOUR1'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Tour_Nr1
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = Tabel.Bez1
            iphTabTexte::cFeld2  = Tabel.Bez2
            iphTabTexte::cFeld3  = Tabel.BezL.
    END.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'FAHRER'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Fahrer
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = Tabel.Bez1
            iphTabTexte::cFeld2  = Tabel.Bez2
            iphTabTexte::cFeld3  = Tabel.BezL.
    END.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'WISO'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Wirt_So
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF NOT AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = 'WISO'
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = iphAufko::Wirt_So
            iphTabTexte::cFeld2  = iphAufko::Wirt_So_Text
            iphTabTexte::cFeld3  = ''.
    END.
    ELSE 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = (IF LENGTH(Tabel.Bez1) > 4 THEN Tabel.Bez1 ELSE '')
            iphTabTexte::cFeld2  = iphAufko::Wirt_So_Text
            iphTabTexte::cFeld3  = (IF LENGTH(Tabel.Bez1) > 4 THEN Tabel.Bez1 ELSE '').
    END.
    iphTabTexte::cFeld3 = iphTabTexte::cFeld1.
    IF iphTabTexte::cFeld2 <> '' THEN iphTabTexte::cFeld3 = 
            iphTabTexte::cFeld3 +
            (IF iphTabTexte::cFeld3 <> '' THEN ' / ' ELSE '') +
            iphTabTexte::cFeld2.

    FIND Tabel NO-LOCK USE-INDEX Tabel-k1
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'ABLAD'
        AND   Tabel.CodeC  = ''
        AND   Tabel.CodeI  = iphAufko::Ablad_Vor
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF NOT AVAILABLE Tabel THEN 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = 'ABLAD'
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = iphAufko::Ablad_Vor
            iphTabTexte::cFeld2  = iphAufko::Ablad_Vor_Text
            iphTabTexte::cFeld3  = ''.
    END.
    ELSE 
    DO:
        iphTabTexte:BUFFER-CREATE().
        ASSIGN  
            iphTabTexte::cRecArt = Tabel.RecArt
            iphTabTexte::iZeile  = 1
            iphTabTexte::cFeld1  = (IF LENGTH(Tabel.Bez1) > 4 THEN Tabel.Bez1 ELSE '')
            iphTabTexte::cFeld2  = iphAufko::Ablad_Vor_Text
            iphTabTexte::cFeld3  = (IF LENGTH(Tabel.Bez1) > 4 THEN Tabel.Bez1 ELSE '').
    END.
    iphTabTexte::cFeld3 = iphTabTexte::cFeld1.
    IF iphTabTexte::cFeld2 <> '' THEN iphTabTexte::cFeld3 = iphTabTexte::cFeld3
            + (IF iphTabTexte::cFeld3 <> '' THEN ' / ' ELSE '')
            + iphTabTexte::cFeld2.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-FIND_IHREBESTELLUNG) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE FIND_IHREBESTELLUNG Procedure 
PROCEDURE FIND_IHREBESTELLUNG :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT-OUTPUT PARAMETER iocString AS CHARACTER NO-UNDO.
    
    DEFINE VARIABLE cString AS CHARACTER NO-UNDO.
    
    cString = iocString.
    FIND FIRST Tabel NO-LOCK
        WHERE Tabel.FIrma  = Firma
        AND   Tabel.RecArt = 'IBEST'
        AND   Tabel.CodeC  = cString NO-ERROR.
    IF AVAILABLE Tabel THEN iocString = Tabel.Bez1.
    
    RELEASE Tabel.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-GEBINDE_AUSGANG_RECHNEN) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE GEBINDE_AUSGANG_RECHNEN Procedure 
PROCEDURE GEBINDE_AUSGANG_RECHNEN :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipFirma AS CHARACTER     NO-UNDO.
    DEFINE INPUT PARAMETER ipAufnr AS INTEGER      NO-UNDO.
    DEFINE INPUT PARAMETER ipGebRg AS LOG      NO-UNDO.
    
    DEFINE VARIABLE MW AS INTEGER.
    
    DEFINE BUFFER xAufko FOR Aufko.

    EMPTY TEMP-TABLE tAufGKon.
    ipGebRg = TRUE.     /*  Neu wird Gebindekontrolle geführt, aber nicht dem Total zuaddiert   */

    FIND xAufko NO-LOCK
        WHERE xAufko.Firma = ipFirma
        AND   xAufko.Aufnr = ipAufnr NO-ERROR.
    
    FOR EACH Aufze NO-LOCK
        WHERE Aufze.Firma    = ipFirma
        AND   Aufze.Aufnr    = ipAufnr:
            
        DO WHILE Aufze.KGebKto <> '':
            IF Aufze.KGeb_Me = 0 THEN LEAVE.
            FIND GebKonto USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Aufze.Firma
                AND   GebKonto.Geb_Cd = Aufze.KGebKto NO-LOCK.
            IF GebKonto.MWST_Art = 0 THEN MW = 11.
            IF GebKonto.MWST_Art = 1 THEN MW = Aufze.WuCd.
            IF GebKonto.MWST_Art = 2 THEN MW = GebKonto.MWST_Cd.
            FIND tAufGKon USE-INDEX AufGKon-k1
                WHERE tAufGKon.Firma   = Aufze.Firma
                AND   tAufGKon.Aufnr   = Aufze.Aufnr
                AND   tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                AND   tAufGKon.MWSt_Cd = MW    NO-ERROR.
            IF NOT AVAILABLE tAufGKon THEN 
            DO:
                CREATE  tAufGKon.
                ASSIGN  
                    tAufGKon.Firma   = Aufze.Firma
                    tAufGKon.Aufnr   = Aufze.Aufnr
                    tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                    tAufGKon.MWSt_Cd = MW
                    tAufGKon.Gebuehr = GebKonto.Gebuehr
                    tAufGKon.Depot   = GebKonto.Depot
                    tAufGKon.Sort_Cd = GebKonto.Sort_Cd.
            END.
            DO WHILE TRUE:
                IF NOT ipGebRg           THEN LEAVE.
                IF Aufze.Preis = 0       AND
                    tAufGKon.Gebuehr <> 0 THEN LEAVE.
                IF xAufko.Abhol           AND
                    tAufGKon.Gebuehr <> 0 THEN LEAVE.
                tAufGKon.Ausgang = tAufGKon.Ausgang  + Aufze.KGeb_Me.
                tAufGKon.Betrag  = (tAufGKon.Ausgang - tAufGKon.Eingang)
                    * (tAufGKon.Depot   + tAufGKon.Gebuehr).
                LEAVE.
            END.
            LEAVE.
        END.
                              
        DO WHILE Aufze.VGebKto <> '':
            IF Aufze.VGeb_Me = 0 THEN LEAVE.
            FIND GebKonto USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Aufze.Firma
                AND   GebKonto.Geb_Cd = Aufze.VGebKto NO-LOCK.
            IF GebKonto.MWST_Art = 0 THEN MW = 11.
            IF GebKonto.MWST_Art = 1 THEN MW = Aufze.WuCd.
            IF GebKonto.MWST_Art = 2 THEN MW = GebKonto.MWST_Cd.
            FIND tAufGKon USE-INDEX AufGKon-k1
                WHERE tAufGKon.Firma   = Aufze.Firma
                AND   tAufGKon.Aufnr   = Aufze.Aufnr
                AND   tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                AND   tAufGKon.MWSt_Cd = MW     NO-ERROR.
            IF NOT AVAILABLE tAufGKon THEN 
            DO:
                CREATE  tAufGKon.
                ASSIGN  
                    tAufGKon.Firma   = Aufze.Firma
                    tAufGKon.Aufnr   = Aufze.Aufnr
                    tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                    tAufGKon.MWSt_Cd = MW
                    tAufGKon.Gebuehr = GebKonto.Gebuehr
                    tAufGKon.Depot   = GebKonto.Depot
                    tAufGKon.Sort_Cd = GebKonto.Sort_Cd.
            END.
            DO WHILE TRUE:
                IF NOT ipGebRg           THEN LEAVE.
                IF Aufze.Preis = 0       AND
                    tAufGKon.Gebuehr <> 0 THEN LEAVE.
                tAufGKon.Ausgang = tAufGKon.Ausgang  + Aufze.VGeb_Me.
                tAufGKon.Betrag  = (tAufGKon.Ausgang - tAufGKon.Eingang)
                    * (tAufGKon.Depot   + tAufGKon.Gebuehr).
                LEAVE.
            END.
            LEAVE.
        END.
                              
        DO WHILE Aufze.GGebKto <> '':
            IF Aufze.GGeb_Me = 0 THEN LEAVE.
            FIND GebKonto USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Aufze.Firma
                AND   GebKonto.Geb_Cd = Aufze.GGebKto NO-LOCK.
            IF GebKonto.MWST_Art = 0 THEN MW = 11.
            IF GebKonto.MWST_Art = 1 THEN MW = Aufze.WuCd.
            IF GebKonto.MWST_Art = 2 THEN MW = GebKonto.MWST_Cd.
            FIND tAufGKon USE-INDEX AufGKon-k1
                WHERE tAufGKon.Firma   = Aufze.Firma
                AND   tAufGKon.Aufnr   = Aufze.Aufnr
                AND   tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                AND   tAufGKon.MWSt_Cd = MW     NO-ERROR.
            IF NOT AVAILABLE tAufGKon THEN 
            DO:
                CREATE  tAufGKon.
                ASSIGN  
                    tAufGKon.Firma   = Aufze.Firma
                    tAufGKon.Aufnr   = Aufze.Aufnr
                    tAufGKon.Geb_Cd  = GebKonto.Geb_Cd
                    tAufGKon.MWSt_Cd = MW
                    tAufGKon.Gebuehr = GebKonto.Gebuehr
                    tAufGKon.Depot   = GebKonto.Depot
                    tAufGKon.Sort_Cd = GebKonto.Sort_Cd.
            END.
            DO WHILE TRUE:
                IF NOT ipGebRg           THEN LEAVE.
                IF Aufze.Preis = 0       AND
                    tAufGKon.Gebuehr <> 0 THEN LEAVE.
                tAufGKon.Ausgang = tAufGKon.Ausgang  + Aufze.GGeb_Me.
                tAufGKon.Betrag  = (tAufGKon.Ausgang - tAufGKon.Eingang)
                    * (tAufGKon.Depot   + tAufGKon.Gebuehr).
                LEAVE.
            END.
            LEAVE.
        END.
    END.
    
    FOR EACH AufGKon
        WHERE AufGKon.Firma = xAufko.Firma
        AND   AufGKon.Aufnr = xAufko.Aufnr:
        ASSIGN  
            AufGKon.Ausgang = 0
            AufGKon.Betrag  = 0.
        RELEASE AufGKon.
    END.
    
    FOR EACH tAufGKon:
        FIND AufGKon OF tAufGKon NO-ERROR.
        IF NOT AVAILABLE AufGKon THEN 
        DO:
            CREATE  AufGKon.
            BUFFER-COPY tAufGKon TO AufGKon.
            NEXT.
        END.
        ASSIGN  
            AufGKon.Ausgang = tAufGKon.Ausgang.
        RELEASE AufGKon.
    END.
    
    FOR EACH AufGKon
        WHERE AufGKon.Firma = xAufko.Firma
        AND   AufGKon.Aufnr = xAufko.Aufnr:
        AufGKon.Betrag  = (AufGKon.Ausgang - AufGKon.Eingang)
            * (AufGKon.Depot   + AufGKon.Gebuehr).
        RELEASE AufGKon.
    END.
    
    RETURN.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-GET_FORMTEXT) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE GET_FORMTEXT Procedure 
PROCEDURE GET_FORMTEXT :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT  PARAMETER ipcInstall AS CHARACTER             NO-UNDO.
    DEFINE INPUT  PARAMETER ipcDokArt  AS CHARACTER             NO-UNDO.
    DEFINE INPUT  PARAMETER ipiSprcd   AS INTEGER              NO-UNDO.
    DEFINE OUTPUT PARAMETER opcTexte   AS CHARACTER EXTENT 30   NO-UNDO.
    
    DEFINE VARIABLE cString AS CHARACTER NO-UNDO.
    
    cString  = CAPS(ipcInstall) + ':' + ipcDokArt.
    opcTexte = ''.

    FOR EACH LiBild NO-LOCK
        WHERE LiBild.Prog  = cString
        AND   LiBild.Sprcd = ipiSprcd:
        opcTexte[LiBild.TeNr] = LiBild.LiText.
    END.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-LADEN_DOKVERLAUF) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE LADEN_DOKVERLAUF Procedure 
PROCEDURE LADEN_DOKVERLAUF :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    REPEAT TRANSACTION:
        EMPTY TEMP-TABLE tVerlauf.
        FOR EACH Tabel NO-LOCK USE-INDEX Tabel-k2
            WHERE Tabel.Firma  = Firma
            AND   Tabel.RecArt = 'DOKVERLAUF'
            AND   Tabel.CodeI  = 0
            AND   Tabel.Sprcd  = 1 :
            CREATE  tVerlauf.
            ASSIGN  
                tVerlauf.FakArt  = INTEGER(SUBSTRING(Tabel.CodeC,01,06))
                tVerlauf.AufSta  = INTEGER(SUBSTRING(Tabel.CodeC,07,06))
                tVerlauf.wFakArt = INTEGER(SUBSTRING(Tabel.Bez1 ,01,06))
                tVerlauf.zFakArt = INTEGER(SUBSTRING(Tabel.Bez1 ,07,06))
                tVerlauf.dFakArt = INTEGER(SUBSTRING(Tabel.Bez1 ,13,06))
                tVerlauf.wAufSta = INTEGER(SUBSTRING(Tabel.Bez2 ,01,06))
                tVerlauf.zAufSta = INTEGER(SUBSTRING(Tabel.Bez2 ,07,06))
                tVerlauf.dAufSta = INTEGER(SUBSTRING(Tabel.Bez2 ,13,06)).
            IF ENTRY(1, Tabel.BezL, ';') = 'yes' THEN tVerlauf.wDruck = TRUE.
            ELSE tVerlauf.wDruck = FALSE.
            IF ENTRY(2, Tabel.BezL, ';') = 'yes' THEN tVerlauf.zDruck = TRUE.
            ELSE tVerlauf.zDruck = FALSE.
            IF ENTRY(3, Tabel.BezL, ';') = 'yes' THEN tVerlauf.dDruck = TRUE.
            ELSE tVerlauf.dDruck = FALSE.
        END.
        RELEASE Tabel.
        LEAVE.
    END.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-NEUERMANDANT) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE NEUERMANDANT Procedure 
PROCEDURE NEUERMANDANT :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipBenutzer  AS CHARACTER         NO-UNDO.
    DEFINE INPUT PARAMETER ipMandant   AS CHARACTER         NO-UNDO.
    
    Benutzer = ipBenutzer.
    Firma    = ipMandant.
    
    RUN AUFTRAGFUNKTIONENINIT.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-PROCESSFESTAUFTRAG) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE PROCESSFESTAUFTRAG Procedure 
PROCEDURE PROCESSFESTAUFTRAG :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipFirma     AS CHARACTER         NO-UNDO.
    DEFINE INPUT PARAMETER ipAufnr     AS INTEGER          NO-UNDO.
    DEFINE INPUT PARAMETER ipOld       AS LOG          NO-UNDO.
    DEFINE INPUT PARAMETER ipNew       AS LOG          NO-UNDO.

    DEFINE VARIABLE iSamm_Nr    AS INTEGER NO-UNDO.
    DEFINE VARIABLE iAufnr      AS INTEGER NO-UNDO.
    DEFINE VARIABLE iPos        AS INTEGER NO-UNDO.
    DEFINE VARIABLE dLief_Datum AS DATE    NO-UNDO.
    DEFINE VARIABLE lFirst      AS LOG     INIT TRUE NO-UNDO.
    DEFINE VARIABLE nTotale     AS DECIMAL EXTENT 15 NO-UNDO.
    
    DEFINE BUFFER bAufko  FOR Aufko.
    DEFINE BUFFER bAufze  FOR Aufze.
    DEFINE BUFFER bSteuer FOR Steuer.

    IF ipOld = ipNew THEN RETURN.
    
    FIND bSteuer NO-LOCK
        WHERE bSteuer.Firma = ipFirma.

    REPEAT TRANSACTION:
        FIND bAufko
            WHERE bAufko.Firma = ipFirma
            AND   bAufko.Aufnr = ipAufnr.
        IF NOT ipNew THEN 
        DO:
            ASSIGN  
                bAufko.Samm_Nr = 0
                bAufko.Faknr   = 0.
            RELEASE bAufko.
            LEAVE.
        END.
        FIND FIRST Aufko NO-LOCK
            WHERE Aufko.Firma   = bAufko.Firma
            AND   Aufko.Knr     = bAufko.Knr
            AND   Aufko.Fak_Art = bSteuer.Fwi22 NO-ERROR.
        IF AVAILABLE Aufko  THEN 
        DO:
            ASSIGN  
                bAufko.Samm_Nr = Aufko.Samm_Nr
                bAufko.Faknr   = Aufko.Faknr.
            RELEASE bAufko.
            LEAVE.
        END.
        RUN 'g-einlesen-datum.w' ( 'Eingabe Rücknahmedatum Rücknahmeschein',
            'Rücknahmedatum',
            INPUT-OUTPUT dLief_Datum ) NO-ERROR.
        IF dLief_Datum = ? THEN LEAVE.
        iSamm_Nr = DYNAMIC-FUNCTION('createSammNr':U, Firma) NO-ERROR.
        iAufnr   = DYNAMIC-FUNCTION('createAufnr':U,  Firma) NO-ERROR.
        EMPTY TEMP-TABLE tAufko.
        CREATE tAufko.
        BUFFER-COPY bAufko TO tAufko.
        ASSIGN  
            tAufko.Aufnr      = iAufnr
            tAufko.Auf_Datum  = dLief_Datum
            tAufko.Lief_Datum = dLief_Datum
            tAufko.Fak_Art    = bSteuer.Fwi22
            tAufko.Auf_Sta    = bSteuer.Fwi23
            tAufko.Samm_Nr    = iSamm_Nr.
        CREATE Aufko.
        BUFFER-COPY tAufko TO Aufko.
        RELEASE Aufko.
        bAufko.Samm_Nr = iSamm_Nr.
        
        FOR EACH bAufze NO-LOCK
            WHERE bAufze.Firma = ipFirma
            AND   bAufze.Aufnr = ipAufnr:
            IF bAufze.Artnr > 0 THEN LEAVE.
            FIND LAST Aufze NO-LOCK
                WHERE Aufze.Firma = ipFirma
                AND   Aufze.Aufnr = iAufnr NO-ERROR.
            IF NOT AVAILABLE Aufze THEN iPos = 5.
            ELSE iPos = Aufze.Pos - (Aufze.Pos MOD 5) + 5.
            CREATE  Aufze.
            BUFFER-COPY bAufze
                EXCEPT  Aufnr Pos
                TO      Aufze
                ASSIGN  
                Aufze.Aufnr = iAufnr
                Aufze.Pos   = iPos.
            RELEASE Aufze.
        END.
        DYNAMIC-FUNCTION('calculateAuftragsTotal':U, Firma, iAufnr, OUTPUT nTotale ) NO-ERROR.
        LEAVE.
    END.
    
    EMPTY TEMP-TABLE tAufko.
    
    RELEASE bAufko.
    RELEASE Aufko.
    RELEASE bSteuer.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-SETSAMMELNUMMER) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE SETSAMMELNUMMER Procedure 
PROCEDURE SETSAMMELNUMMER :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT  PARAMETER ipRecid    AS RECID                    NO-UNDO.

    DEFINE VARIABLE iSammFakArt AS INTEGER NO-UNDO.
    DEFINE VARIABLE iSammNr     AS INTEGER NO-UNDO.
    DEFINE VARIABLE iAufSta     AS INTEGER NO-UNDO.

    DEFINE BUFFER xAufko FOR Aufko.

    REPEAT TRANSACTION:
        FIND Aufko WHERE RECID(Aufko) = ipRecid NO-LOCK NO-ERROR.
        IF NOT AVAILABLE Aufko THEN RETURN.
        
        iSammFakArt = DYNAMIC-FUNCTION('GETFWSAMMFAKART':U) NO-ERROR.
        iAufSta     = Aufko.Auf_Sta.
        iSammNr     = 0.
        IF iSammFakArt = 0 THEN 
        DO: /*  Rechnung pro Fakturaadresse     */
            FIND FIRST xAufko NO-LOCK USE-INDEX Aufko-k6
                WHERE xAufko.Firma    = Aufko.Firma
                AND   xAufko.Fak_Knr  = Aufko.Fak_Knr
                AND   xAufko.Fak_Art  = Aufko.Fak_Art
                AND   xAufko.Auf_Sta  = Aufko.Auf_Sta
                AND   xAufko.Mwst     = Aufko.Mwst
                AND   xAufko.Frw      = Aufko.Frw
                AND   xAufko.Aufnr   <> Aufko.Aufnr
                AND   MONTH(xAufko.Lief_Datum) = MONTH(Aufko.Lief_Datum)
                AND   xAufko.Samm_Nr <> 0 NO-ERROR.
        END.
        IF iSammFakArt = 1 THEN 
        DO: /* Rechnung pro Lieferadresse       */
            FIND FIRST xAufko NO-LOCK USE-INDEX Aufko-k6
                WHERE xAufko.Firma    = Aufko.Firma
                AND   xAufko.Fak_Knr  = Aufko.Fak_Knr
                AND   xAufko.Fak_Art  = Aufko.Fak_Art
                AND   xAufko.Auf_Sta  = Aufko.Auf_Sta
                AND   xAufko.Knr      = Aufko.Knr
                AND   xAufko.Mwst     = Aufko.Mwst
                AND   xAufko.Frw      = Aufko.Frw
                AND   xAufko.Aufnr   <> Aufko.Aufnr
                AND   MONTH(xAufko.Lief_Datum) = MONTH(Aufko.Lief_Datum)
                AND   xAufko.Samm_Nr <> 0 NO-ERROR.
        END.

        IF NOT AVAILABLE xAufko THEN 
        DO:
            RUN NUMMER_LOESEN ( INPUT 5, OUTPUT iSammNr ).
            IF iSammNr = ? THEN 
            DO:
                RELEASE Aufko.
                RETURN 'ERROR'.
            END.
            Aufko.Samm_Nr  = iSammNr.
            Aufko.Faknr    = 0.
            Aufko.Gedruckt = FALSE.
            RELEASE xAufko.
            RELEASE Aufko.
            LEAVE.
        END.

        Aufko.Samm_Nr  = xAufko.Samm_Nr.
        Aufko.Faknr    = xAufko.Faknr.
        FOR EACH xAufko USE-INDEX Aufko-k5
            WHERE xAufko.Firma    = Aufko.Firma
            AND   xAufko.Fak_Art  = Aufko.Fak_Art
            AND   xAufko.Samm_Nr  = Aufko.Samm_Nr .
            xAufko.Gedruckt = FALSE.
            xAufko.Auf_Sta  = iAufSta.
        END.
        RELEASE xAufko.
        RELEASE Aufko.
        LEAVE.
    END.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-TAUFZE_TO_BUFFER) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE TAUFZE_TO_BUFFER Procedure 
PROCEDURE TAUFZE_TO_BUFFER :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT-OUTPUT PARAMETER ipBuffer     AS HANDLE           NO-UNDO.

    DEFINE VARIABLE hFeld   AS HANDLE  NO-UNDO.
    DEFINE VARIABLE hRAufze AS HANDLE  NO-UNDO.
    DEFINE VARIABLE hFAufze AS HANDLE  NO-UNDO.
    DEFINE VARIABLE ii      AS INTEGER NO-UNDO.
    DEFINE VARIABLE ex      AS INTEGER NO-UNDO.

    FIND FIRST tAufze.
    IF NOT AVAILABLE tAufze THEN CREATE tAufze.
    hRAufze = BUFFER tAufze:HANDLE NO-ERROR.

    ipBuffer:BUFFER-COPY(hRAufze).

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-WEITER) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE WEITER Procedure 
PROCEDURE WEITER :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipAufnr     AS INTEGER                  NO-UNDO.
    
    DEFINE VARIABLE AltSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE NeuSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE AltFakArt  AS INTEGER NO-UNDO.
    DEFINE VARIABLE iSammNr    AS INTEGER NO-UNDO.
    DEFINE VARIABLE lAltFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE lNeuFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE iRecid     AS RECID   NO-UNDO.

    DEFINE BUFFER xAufko FOR Aufko.

    STATUSAENDERUNG:
    REPEAT TRANSACTION:
        FIND Aufko EXCLUSIVE-LOCK USE-INDEX Aufko-k1
            WHERE Aufko.Firma = Firma
            AND   Aufko.Aufnr = ipAufnr NO-WAIT NO-ERROR.
        IF NOT AVAILABLE Aufko THEN 
        DO:
            RELEASE Aufko.
            RETURN 'Fehler'.
        END.
        IF Aufko.AlsOfferte THEN 
        DO:
            RELEASE Aufko.
            MESSAGE 'Auftrag ist Offerte! WEITER geht hier nicht! '
                VIEW-AS ALERT-BOX INFORMATION.
            RETURN 'Fehler'.
        END.
        ASSIGN  
            iRecid = RECID(Aufko)
            Firma  = Aufko.Firma.
        
        FIND FIRST tVerlauf NO-LOCK USE-INDEX tVerlauf-k1
            WHERE tVerlauf.FakArt = Aufko.Fak_Art
            AND   tVerlauf.AufSta = Aufko.Auf_Sta  NO-ERROR.
        IF NOT AVAILABLE tVerlauf THEN 
        DO:
            RELEASE Aufko.
            RETURN 'ERROR'.
        END.
        
        IF Aufko.Fak_Art = tVerlauf.wFakArt AND
            Aufko.Auf_Sta = tVerlauf.wAufSta THEN 
        DO:
            RELEASE Aufko.
            RETURN ''.
        END.

        FIND Tabel NO-LOCK USE-INDEX Tabel-k1
            WHERE Tabel.Firma  = Firma
            AND   Tabel.RecArt = 'FAKART'
            AND   Tabel.CodeC  = ''
            AND   Tabel.CodeI  = Aufko.Fak_Art
            AND   Tabel.Sprcd  = 1 NO-ERROR.
        IF Tabel.Int_3 = 4 THEN AltSammFak = TRUE.
        ELSE                    AltSammFak = FALSE.

        ASSIGN  
            AltFakArt      = Aufko.Fak_Art
            lAltFest       = Tabel.Flag_1
            Aufko.Fak_Art  = tVerlauf.wFakArt
            Aufko.Auf_Sta  = tVerlauf.wAufSta
            Aufko.Gedruckt = (IF tVerlauf.wDruck = TRUE THEN FALSE ELSE Aufko.Gedruckt).
        
        IF AltFakArt <> Aufko.Fak_Art THEN 
        DO:
            FIND Tabel NO-LOCK USE-INDEX Tabel-k1
                WHERE Tabel.Firma  = Firma
                AND   Tabel.RecArt = 'FAKART'
                AND   Tabel.CodeC  = ''
                AND   Tabel.CodeI  = Aufko.Fak_Art
                AND   Tabel.Sprcd  = 1 NO-ERROR.
        END.
        IF Tabel.Int_3 = 4 THEN NeuSammFak = TRUE.
        ELSE                    NeuSammFak = FALSE.
        lNeuFest = Tabel.Flag_1.
        
        DO WHILE TRUE:
            IF lAltFest OR
                lNeuFest THEN 
            DO:
                RELEASE Aufko.
                RUN PROCESSFESTAUFTRAG ( Firma, ipAufnr, lAltFest, lNeuFest ) NO-ERROR.
                FIND Aufko NO-LOCK WHERE RECID(Aufko) = iRecid.
                
                IF NeuSammFak        AND
                    NOT AltSammFak    AND
                    Aufko.Samm_Nr = 0 THEN 
                DO:
                    FIND FIRST xAufko NO-LOCK
                        WHERE xAufko.Firma   = Aufko.Firma
                        AND   xAufko.Fak_Art = Aufko.Fak_Art
                        AND   xAufko.Samm_Nr > 0
                        AND   xAufko.Aufnr  <> Aufko.Aufnr NO-ERROR.
                    IF AVAILABLE xAufko THEN 
                    DO:
                        FIND Aufko WHERE RECID(Aufko) = iRecid.
                        ASSIGN  
                            Aufko.Samm_Nr = xAufko.Samm_Nr.
                        RELEASE Aufko.
                    END.
                    FIND Aufko NO-LOCK WHERE RECID(Aufko) = iRecid.
                END.
                IF NeuSammFak      AND
                    tVerlauf.wDruck THEN 
                DO:
                    FOR EACH xAufko
                        WHERE xAufko.Firma   = Aufko.Firma
                        AND   xAufko.Fak_Art = Aufko.Fak_Art
                        AND   xAufko.Samm_Nr = Aufko.Samm_Nr
                        AND   xAufko.Aufnr  <> Aufko.Aufnr:
                        ASSIGN  
                            xAufko.Gedruckt = FALSE.
                    END.
                END.
                LEAVE.
            END.
            
            IF NOT AltSammFak   AND
                NOT NeuSammFak   THEN LEAVE.
            IF AltSammFak       AND
                NOT NeuSammFak   THEN 
            DO:
                ASSIGN  
                    Aufko.Samm_Nr = 0
                    Aufko.Faknr   = 0.
                LEAVE.
            END.
            IF AltSammFak   AND
                NeuSammFak   THEN 
            DO:
                FOR EACH xAufko USE-INDEX Aufko-k5
                    WHERE xAufko.Firma    = Aufko.Firma
                    AND   xAufko.Fak_Art  = AltFakArt
                    AND   xAufko.Samm_Nr  = Aufko.Samm_Nr :
                    ASSIGN  
                        xAufko.Gedruckt = FALSE
                        xAufko.Fak_Art  = Aufko.Fak_Art
                        xAufko.Auf_Sta  = Aufko.Auf_Sta.
                END.
                LEAVE.
            END.
            RUN SETSAMMELNUMMER ( INPUT RECID(Aufko) ).
            IF RETURN-VALUE = 'ERROR' THEN 
            DO:
                UNDO STATUSAENDERUNG, RETURN 'ERROR'.
            END.
            LEAVE.
        END.

        RELEASE xAufko.
        RELEASE Aufko.
        LEAVE.
    END.
    RETURN ''.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-ZEILEN_BETRAEGE) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE ZEILEN_BETRAEGE Procedure 
PROCEDURE ZEILEN_BETRAEGE :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE Rundbetr AS DECIMAL DECIMALS 4 NO-UNDO.

    FIND FIRST tAufze.

    FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
        WHERE Wust.Wucd  = tAufze.Wucd
        AND   Wust.CodeA = tAufze.WC
        AND   Wust.CodeK < 12 .
    DO WHILE TRUE:
        IF tAufze.Rab_Art = 1 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Preis * tAufze.Rab_Wert / 100 * tAufze.MGel.
            LEAVE.
        END.
        IF tAufze.Rab_Art = 2 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis    * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Rab_Wert * tAufze.MGeli.
            LEAVE.
        END.
        IF tAufze.Rab_Art = 3 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Preis * tAufze.Rab_Wert / 100 * tAufze.MGeli * -1.
            LEAVE.
        END.
        tAufze.Bru_Betr = tAufze.Preis * tAufze.MGeli.
        tAufze.Rab_Betr = 0.
        tAufze.Rab_Art  = 0.
        LEAVE.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Rab_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Rab_Betr = Rundbetr.
    END.

    DO WHILE TRUE:
        IF tAufze.Zus_Art = 1 THEN 
        DO:
            tAufze.Zus_Betr = tAufze.Preis * tAufze.Zus_Wert / 100 * tAufze.MGel.
            LEAVE.
        END.
        IF tAufze.Zus_Art = 2 THEN 
        DO:
            tAufze.Zus_Betr = tAufze.Zus_Wert * tAufze.MGeli.
            LEAVE.
        END.
        tAufze.Zus_Betr = 0.
        tAufze.Zus_Wert = 0.
        tAufze.Zus_Art  = 0.
        LEAVE.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Zus_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Zus_Betr = Rundbetr.
    END.
    
    tAufze.Net_Betr = tAufze.Bru_Betr - tAufze.Rab_Betr + tAufze.Zus_Betr.

    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Net_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Net_Betr = Rundbetr.
    END.
    
    RELEASE Wust.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-ZURUECK) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _PROCEDURE ZURUECK Procedure 
PROCEDURE ZURUECK :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE INPUT PARAMETER ipAufnr     AS INTEGER                  NO-UNDO.
    
    DEFINE VARIABLE AltSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE NeuSammFak AS LOG     NO-UNDO.
    DEFINE VARIABLE AltFakArt  AS INTEGER NO-UNDO.
    DEFINE VARIABLE iSammNr    AS INTEGER NO-UNDO.
    DEFINE VARIABLE lAltFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE lNeuFest   AS LOG     NO-UNDO.
    DEFINE VARIABLE iRecid     AS RECID   NO-UNDO.

    DEFINE BUFFER xAufko FOR Aufko.
    DEFINE BUFFER bDebst FOR Debst.

    STATUSAENDERUNG:
    REPEAT TRANSACTION:
        FIND Aufko USE-INDEX Aufko-k1
            WHERE Aufko.Firma = Firma
            AND   Aufko.Aufnr = ipAufnr NO-ERROR.
        IF NOT AVAILABLE Aufko THEN 
        DO:
            RELEASE Aufko.
            RETURN 'Fehler'.
        END.
        IF Aufko.AlsOfferte THEN 
        DO:
            RELEASE Aufko.
            MESSAGE 'Auftrag ist Offerte! ZURÜCK geht hier nicht! '
                VIEW-AS ALERT-BOX INFORMATION.
            RETURN 'Fehler'.
        END.
        ASSIGN  
            iRecid = RECID(Aufko)
            Firma  = Aufko.Firma.

        FIND FIRST tVerlauf NO-LOCK USE-INDEX tVerlauf-k1
            WHERE tVerlauf.FakArt = Aufko.Fak_Art 
            AND   tVerlauf.AufSta = Aufko.Auf_Sta NO-ERROR.
        IF NOT AVAILABLE tVerlauf THEN 
        DO:
            RELEASE Aufko.
            RETURN 'ERROR'.
        END.
        IF Aufko.Fak_Art = tVerlauf.zFakArt AND
            Aufko.Auf_Sta = tVerlauf.zAufSta THEN 
        DO:
            RELEASE Aufko.
            RETURN ''.
        END.

        FIND Tabel NO-LOCK USE-INDEX Tabel-k1
            WHERE Tabel.Firma  = Firma
            AND   Tabel.RecArt = 'FAKART'
            AND   Tabel.CodeC  = ''
            AND   Tabel.CodeI  = Aufko.Fak_Art
            AND   Tabel.Sprcd  = 1 NO-ERROR.
        IF Tabel.Int_3 = 4 THEN AltSammFak = TRUE.
        ELSE                    AltSammFak = FALSE.

        ASSIGN  
            AltFakArt      = Aufko.Fak_Art
            lAltFest       = Tabel.Flag_1
            Aufko.Fak_Art  = tVerlauf.zFakArt
            Aufko.Auf_Sta  = tVerlauf.zAufSta
            Aufko.Gedruckt = (IF tVerlauf.zDruck = TRUE THEN FALSE ELSE Aufko.Gedruckt).

        IF AltFakArt <> Aufko.Fak_Art THEN 
        DO:
            FIND Tabel NO-LOCK USE-INDEX Tabel-k1
                WHERE Tabel.Firma  = Firma
                AND   Tabel.RecArt = 'FAKART'
                AND   Tabel.CodeC  = ''
                AND   Tabel.CodeI  = Aufko.Fak_Art
                AND   Tabel.Sprcd  = 1 NO-ERROR.
        END.
        IF Tabel.Int_3 = 4 THEN NeuSammFak = TRUE.
        ELSE                    NeuSammFak = FALSE.
        lNeuFest = Tabel.Flag_1.

        DO WHILE TRUE:
            IF lAltFest OR
                lNeuFest THEN 
            DO:
                RELEASE Aufko.
                RUN PROCESSFESTAUFTRAG ( Firma, ipAufnr, lAltFest, lNeuFest ) NO-ERROR.
                FIND Aufko NO-LOCK WHERE RECID(Aufko) = iRecid.
                
                IF NeuSammFak      AND
                    tVerlauf.zDruck THEN 
                DO:
                    FOR EACH xAufko
                        WHERE xAufko.Firma   = Aufko.Firma
                        AND   xAufko.Fak_Art = AltFakArt
                        AND   xAufko.Samm_Nr = Aufko.Samm_Nr
                        AND   xAufko.Aufnr  <> Aufko.Aufnr:
                        ASSIGN  
                            xAufko.Gedruckt = FALSE
                            xAufko.Fak_Art  = Aufko.Fak_Art
                            xAufko.Auf_Sta  = Aufko.Auf_Sta.
                    END.
                END.

                LEAVE.
            END.
            
            IF NOT AltSammFak   AND
                NOT NeuSammFak   THEN LEAVE.
            IF AltSammFak       AND
                NOT NeuSammFak   THEN 
            DO:
                ASSIGN  
                    Aufko.Samm_Nr = 0
                    Aufko.Faknr   = 0.
                FIND bDebst NO-LOCK
                    WHERE bDebst.Firma = Aufko.Firma
                    AND   bDebst.Knr   = Aufko.Knr NO-ERROR.
                Aufko.Fak_Art = bDebst.Fak_Art.
                LEAVE.
            END.
            IF AltSammFak AND
                NeuSammFak THEN 
            DO:
                FOR EACH xAufko USE-INDEX Aufko-k5
                    WHERE xAufko.Firma    = Aufko.Firma
                    AND   xAufko.Fak_Art  = AltFakArt
                    AND   xAufko.Samm_Nr  = Aufko.Samm_Nr
                    AND   xAufko.Aufnr   <> Aufko.Aufnr :
                    ASSIGN  
                        xAufko.Gedruckt = Aufko.Gedruckt
                        xAufko.Fak_Art  = Aufko.Fak_Art
                        xAufko.Auf_Sta  = Aufko.Auf_Sta.
                END.
                LEAVE.
            END.
            RUN SETSAMMELNUMMER ( INPUT RECID(Aufko) ).
            IF RETURN-VALUE = 'ERROR' THEN 
            DO:
                UNDO STATUSAENDERUNG, RETURN 'ERROR'.
            END.
            LEAVE.
        END.

        RELEASE Tabel.
        RELEASE xAufko.
        RELEASE Aufko.
        LEAVE.
    END.
    
    RETURN ''.

END PROCEDURE.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
/* ************************  Function Implementations ***************** */

&IF DEFINED(EXCLUDE-buchenArtikel) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION buchenArtikel Procedure 
FUNCTION buchenArtikel RETURNS LOGICAL
    ( ipKnr    AS INTEGER, ipBuffer AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE hFeld   AS HANDLE    NO-UNDO.
    DEFINE VARIABLE MWSt_Cd AS INTEGER   NO-UNDO.
    DEFINE VARIABLE VBetr   AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VAufRab AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VAbhRab AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VSpeRab AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VGeli   AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VNetto  AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VLiter  AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VEp     AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE xFirma  AS CHARACTER NO-UNDO.
    DEFINE VARIABLE Aufnr   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Artnr   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Inhalt  AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Jahr    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Trnr    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Datum   AS DATE      NO-UNDO.
    DEFINE VARIABLE JJ      AS INTEGER   NO-UNDO.
    DEFINE VARIABLE MM      AS INTEGER   NO-UNDO.
    DEFINE VARIABLE nKurs   AS DECIMAL   DECIMALS 4 NO-UNDO.

    ASSIGN  
        hFeld   = ipBuffer:BUFFER-FIELD('WuCd')
        Mwst_Cd = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Firma')
        xFirma  = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Aufnr')
        Aufnr   = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Artnr')
        Artnr   = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Inhalt')
        Inhalt  = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Jahr')
        Jahr    = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Net_Betr')
        VBetr   = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('MGeli')
        VGeli   = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Auf_Rab')
        VAufRab = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Abh_Rab')
        VAbhRab = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Auf_Sp_Rab')
        VSpeRab = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Liter')
        VLiter  = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Ep')
        VEp     = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Trnr')
        Trnr    = hFeld:BUFFER-VALUE(0)
        hFeld   = ipBuffer:BUFFER-FIELD('Kurs')
        nKurs   = hFeld:BUFFER-VALUE(0)
        .
    IF  nKurs = ? OR
        nKurs = 0 THEN nKurs = 1.00.

    FIND Artbw NO-LOCK USE-INDEX Artbw-k1
        WHERE Artbw.Firma = Firma
        AND   Artbw.Trnr  = Trnr NO-ERROR.
    IF NOT AVAILABLE Artbw THEN RETURN FALSE.

    Datum = Artbw.Fak_Dat.
    JJ    = YEAR (Datum).
    MM    = MONTH(Datum).

    FIND FIRST Wust   USE-INDEX Wust-k2
        WHERE Wust.WuCd       = Mwst_Cd NO-LOCK NO-ERROR.
    FIND LAST MWSTAns USE-INDEX MWSTAns-k1
        WHERE MWSTAns.MWST_Cd = Mwst_Cd
        AND   MWSTAns.Datum  <= Datum NO-LOCK NO-ERROR.
    VNetto = VBetr - VAufRab - VAbhRab - VSpeRab.
    IF Wust.Incl THEN VNetto = VNetto * 100 / (100 + MWSTAns.Ansatz).
    VEp    = VEp * VGeli.

    FIND DebUms USE-INDEX DebUms-k1
        WHERE DebUms.Firma   = xFirma
        AND   DebUms.Jahr    = JJ
        AND   DebUms.Knr     = ipKnr
        AND   DebUms.Ums_Grp = 999 NO-ERROR.
    IF NOT AVAILABLE DebUms THEN 
    DO:
        CREATE  DebUms.
        ASSIGN  
            DebUms.Firma   = xFirma
            DebUms.Jahr    = JJ
            DebUms.Knr     = ipKnr
            DebUms.Ums_Grp = 999.
    END.
    ASSIGN  
        DebUms.Me_Mon[MM] = DebUms.Me_Mon[MM] + VGeli
        DebUms.Me_Kum     = DebUms.Me_Kum     + VGeli
        DebUms.Ep_Mon[MM] = DebUms.Ep_Mon[MM] + VEp
        DebUms.Ep_Kum     = DebUms.Ep_Kum     + VEp
        DebUms.Vp_Mon[MM] = DebUms.Vp_Mon[MM] + VNetto * nKurs
        DebUms.Vp_Kum     = DebUms.Vp_Kum     + VNetto * nKurs
        .
    RELEASE DebUms.

    FIND ArtUms USE-INDEX ArtUms-k1
        WHERE ArtUms.Firma   = xFirma
        AND   ArtUms.Jahr    = JJ
        AND   ArtUms.Artnr   = Artnr
        AND   ArtUms.Inhalt  = Inhalt
        AND   ArtUms.Jahrg   = Jahr NO-ERROR.
    IF NOT AVAILABLE ArtUms THEN 
    DO:
        CREATE  ArtUms.
        ASSIGN  
            ArtUms.Firma  = xFirma
            ArtUms.Jahr   = JJ
            ArtUms.Artnr  = Artnr
            ArtUms.Inhalt = Inhalt
            ArtUms.Jahrg  = Jahr.
    END.
    ASSIGN  
        ArtUms.Me_Mon[MM] = ArtUms.Me_Mon[MM] + VGeli
        ArtUms.Me_Kum     = ArtUms.Me_Kum     + VGeli
        ArtUms.Ep_Mon[MM] = ArtUms.Ep_Mon[MM] + VEp
        ArtUms.Ep_Kum     = ArtUms.Ep_Kum     + VEp
        ArtUms.Li_Mon[MM] = ArtUms.Li_Mon[MM] + VLiter
        ArtUms.Li_Kum     = ArtUms.Li_Kum     + VLiter
        ArtUms.Vp_Mon[MM] = ArtUms.Vp_Mon[MM] + VNetto * nKurs
        ArtUms.Vp_Kum     = ArtUms.Vp_Kum     + VNetto * nKurs
        .
    RELEASE ArtUms.
    
    FIND DeArUms USE-INDEX DeArUms-k1
        WHERE DeArUms.Firma   = xFirma
        AND   DeArUms.Jahr    = JJ
        AND   DeArUms.Knr     = ipKnr
        AND   DeArUms.Artnr   = Artnr
        AND   DeArUms.Inhalt  = Inhalt
        AND   DeArUms.Jahrg   = Jahr NO-ERROR.
    IF NOT AVAILABLE DeArUms THEN 
    DO:
        CREATE  DeArUms.
        ASSIGN  
            DeArUms.Firma  = xFirma
            DeArUms.Jahr   = JJ
            DeArUms.Knr    = ipKnr
            DeArUms.Artnr  = Artnr
            DeArUms.Inhalt = Inhalt
            DeArUms.Jahrg  = Jahr.
    END.
    ASSIGN  
        DeArUms.Me_Mon[MM] = DeArUms.Me_Mon[MM] + VGeli
        DeArUms.Me_Kum     = DeArUms.Me_Kum     + VGeli
        DeArUms.Ep_Mon[MM] = DeArUms.Ep_Mon[MM] + VEp
        DeArUms.Ep_Kum     = DeArUms.Ep_Kum     + VEp
        DeArUms.Li_Mon[MM] = DeArUms.Li_Mon[MM] + VLiter
        DeArUms.Li_Kum     = DeArUms.Li_Kum     + VLiter
        DeArUms.Vp_Mon[MM] = DeArUms.Vp_Mon[MM] + VNetto * nKurs
        DeArUms.Vp_Kum     = DeArUms.Vp_Kum     + VNetto * nKurs
        .
    RELEASE DeArUms.
    
    FIND Umsatz
        WHERE Umsatz.Firma   = xFirma
        AND   Umsatz.Ums_Art = 'TOTAL'
        AND   Umsatz.Jahr    = JJ
        AND   Umsatz.Grp_01  = 0 NO-ERROR.
    IF NOT AVAILABLE Umsatz THEN 
    DO:
        CREATE  Umsatz.
        ASSIGN  
            Umsatz.Firma   = xFirma
            Umsatz.Ums_Art = 'TOTAL'
            Umsatz.Jahr    = JJ
            Umsatz.Grp_01  = 0.
    END.
    ASSIGN  
        Umsatz.VP_Mon[MM] = Umsatz.Vp_Mon[MM] + (VNetto * nKurs)
        Umsatz.VP_Kum     = Umsatz.Vp_Kum     + (VNetto * nKurs)
        Umsatz.EP_Mon[MM] = Umsatz.EP_Mon[MM] + VEp
        Umsatz.EP_Kum     = Umsatz.EP_Kum     + VEp
        .
    RELEASE Umsatz.
        
    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-calculateAuftragsTotal) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION calculateAuftragsTotal Procedure 
FUNCTION calculateAuftragsTotal RETURNS CHARACTER
    ( ipcFirma AS CHARACTER, ipiAufnr AS INTEGER, OUTPUT opnTotal AS DECIMAL EXTENT 15 ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lJa         AS LOG       NO-UNDO.
    DEFINE VARIABLE VWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE VWust       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE NWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE TWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE VFakt       AS INTEGER   EXTENT 12 NO-UNDO.
    DEFINE VARIABLE NFakt       AS INTEGER   NO-UNDO.
    DEFINE VARIABLE VTotWu      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VTotNK      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VResNK      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VMaxWC      AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iRecid      AS RECID     NO-UNDO.
    DEFINE VARIABLE VGewicht    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE zz          AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Wert        AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VSkonto     AS DECIMAL   INIT 0 NO-UNDO.
    DEFINE VARIABLE Rundbetr    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE nMenge      AS DECIMAL   NO-UNDO.
    DEFINE VARIABLE cResult     AS CHARACTER NO-UNDO.
    DEFINE VARIABLE dMwstDat    AS DATE      NO-UNDO.
    DEFINE VARIABLE nKredLimite AS DECIMAL   INIT 0.00 NO-UNDO.
    DEFINE VARIABLE nAufTotal   AS DECIMAL   INIT 0.00 NO-UNDO.
    DEFINE VARIABLE htAufze     AS HANDLE    NO-UNDO.
    DEFINE VARIABLE cMessage    AS CHARACTER NO-UNDO.

    DEFINE BUFFER bAufze FOR Aufze.
    DEFINE BUFFER FDebst FOR Debst.

    /* ------------------------------------------------------------------------- */
    /* opnTotal[01] = Nettowarenwert                                             */
    /* opnTotal[02] = Skontoberechtigter Betrag                                  */
    /* opnTotal[03] = Nebenkosten                                                */
    /* opnTotal[04] = Transport                                                  */
    /* opnTotal[05] = Porto                                                      */
    /* opnTotal[06] = Verpackung                                                 */
    /* opnTotal[07] = Total Mehrwertsteuerpflichtig                              */
    /* opnTotal[08] = Total Mehrwertsteuerfrei                                   */
    /* opnTotal[09] = Total Mehrwertsteuer                                       */
    /* opnTotal[10] = Total Auftrag                                              */
    /* opnTotal[11] = Total Gebinde                                              */
    /* opnTotal[12] = Total Gebühren (Receycling)                                */
    /* ------------------------------------------------------------------------- */

    REPEAT TRANSACTION:
        opnTotal = 0.
        VWpfl    = 0.
        VWust    = 0.
        VTotWu   = 0.
        VTotNK   = 0.
        NWpfl    = 0.     /*  Anteil Nebenkosten  */
        TWpfl    = 0.     /*  Wpfl + Nebenkosten  */
        VGewicht = 0.

        DISABLE TRIGGERS FOR LOAD OF Aufko.

        FIND Steuer NO-LOCK USE-INDEX Steuer-k1
            WHERE Steuer.Firma = ipcFirma.

        FIND Aufko EXCLUSIVE-LOCK
            WHERE Aufko.Firma  = ipcFirma
            AND   Aufko.Aufnr  = ipiAufnr NO-WAIT NO-ERROR.
        IF LOCKED Aufko        THEN RETURN 'LOCKED'.
        IF NOT AVAILABLE Aufko THEN RETURN 'FEHLEND'.
        iRecid   = RECID(Aufko).
        dMwstDat = (IF Aufko.Lief_Datum <> ? THEN Aufko.Lief_Datum ELSE Aufko.Fak_Datum).
        IF dMwstDat = ? THEN dMwstDat = Aufko.Kond_Datum.
        IF dMwstDat = ? THEN dMwstDat = TODAY.
    
        FIND FDebst NO-LOCK
            WHERE FDebst.Firma = Aufko.Firma
            AND   FDebst.Knr   = Aufko.Fak_Knr.
        nKredLimite = FDebst.Kred_Lim.
        nAufTotal   = FDebst.Saldo.

        RUN GEBINDE_AUSGANG_RECHNEN ( ipcFirma, ipiAufnr, FDebst.Geb_Rg ).
        RELEASE AufGKon.

        ASSIGN  
            Aufko.Wpfl   = 0
            Aufko.Wust   = 0
            Aufko.WW     = 0
            Aufko.Sk_Ber = 0.

        opnTotal[04] = Aufko.Transp.
        opnTotal[05] = Aufko.Porto.
        opnTotal[06] = Aufko.Verpack.
        opnTotal[03] = opnTotal[04] + opnTotal[05] + opnTotal[06].

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Aufko.MWST
            AND   Wust.CodeA = Steuer.Fwi03   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Aufko.Transp.

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Aufko.MWST
            AND   Wust.CodeA = Steuer.Fwi04   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Aufko.Porto.

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Aufko.MWST
            AND   Wust.CodeA = Steuer.Fwi05   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Aufko.Verpack.

        zz  = 0.
        lJa = FALSE.
        EMPTY TEMP-TABLE tAufze.
        FOR EACH Aufze NO-LOCK
            WHERE Aufze.Firma = Aufko.Firma
            AND   Aufze.Aufnr = Aufko.Aufnr
            AND   Aufze.Artnr > 0    :
            CREATE  tAufze.
            BUFFER-COPY Aufze TO tAufze.
            IF  zz > 1  AND
                NOT lJa THEN NEXT.
           
            FIND Artbw NO-LOCK
                WHERE Artbw.Firma = Aufze.Firma
                AND   Artbw.Trnr  = Aufze.Trnr NO-ERROR.
            IF NOT AVAILABLE Artbw THEN NEXT.
            zz = zz + 1.
            IF Artbw.Datum = Aufko.Lief_Datum THEN NEXT.
            lJa = TRUE.
            FIND Artbw EXCLUSIVE-LOCK
                WHERE Artbw.Firma = Aufze.Firma
                AND   Artbw.Trnr  = Aufze.Trnr NO-WAIT NO-ERROR.
            IF NOT AVAILABLE Artbw THEN NEXT.
            Artbw.Datum = Aufko.Lief_Datum.
            RELEASE Artbw.
        END.

        FIND FIRST tAufze NO-ERROR.
        IF AVAILABLE tAufze THEN 
        DO:
            DYNAMIC-FUNCTION('fillAufRabSu':U) NO-ERROR.
            DYNAMIC-FUNCTION('fillAufSpRab':U) NO-ERROR.
        END.

        FOR EACH tAufze:

            zz = tAufze.WuCd.
            IF Aufko.Auf_Sta < 2 THEN nMenge = tAufze.MBest.
            ELSE                      nMenge = tAufze.MGeli.
            nMenge = tAufze.MGeli.

            DO WHILE TRUE:
                ASSIGN  
                    tAufze.Auf_Rab = 0
                    tAufze.Abh_Rab = 0.
                IF tAufze.Rab_Su_Grp = 0 THEN LEAVE.
                IF tAufze.Rab_Su_Art = 0 THEN LEAVE.

                FIND AufRabSu NO-LOCK
                    WHERE AufRabSu.Firma    = tAufze.Firma
                    AND   AufRabSu.Aufnr    = tAufze.Aufnr
                    AND   AufRabSu.Rab_Summ = tAufze.Rab_Su_Grp
                    AND   AufRabSu.MWST_Cd  = tAufze.WuCd.
                Wert = AufRabSu.F_Wert.
                DO WHILE Wert <> 0:
                    IF AufRabSu.F_Proz_Betr THEN 
                    DO:
                        tAufze.Auf_Rab = tAufze.Net_Betr * AufRabSu.F_Wert / 100.
                        LEAVE.
                    END.
                    IF AufRabSu.F_Art = 0 THEN 
                    DO:
                        tAufze.Auf_Rab = nMenge * AufRabSu.F_Wert.
                        LEAVE.
                    END.
                    IF AufRabSu.F_Art = 2 THEN 
                    DO:
                        tAufze.Auf_Rab = tAufze.Liter * AufRabSu.F_Wert / 100.
                        LEAVE.
                    END.
                    LEAVE.
                END.

                IF Aufko.Abhol = FALSE THEN Wert = 0.
                ELSE                        Wert = AufRabSu.A_Wert.
                DO WHILE Wert <> 0:
                    IF AufRabSu.A_Proz_Betr THEN 
                    DO:
                        tAufze.Abh_Rab = tAufze.Net_Betr * AufRabSu.A_Wert / 100.
                        LEAVE.
                    END.
                    IF AufRabSu.A_Art = 0 THEN 
                    DO:
                        tAufze.Abh_Rab = nMenge * AufRabSu.A_Wert.
                        LEAVE.
                    END.
                    IF AufRabSu.A_Art = 2 THEN 
                    DO:
                        tAufze.Abh_Rab = tAufze.Liter * AufRabSu.A_Wert / 100.
                        LEAVE.
                    END.
                    LEAVE.
                END.

                DO WHILE TRUE:
                    IF  tAufze.Abh_Rab = 0    AND
                        tAufze.Auf_Rab = 0    THEN LEAVE.

                    FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
                        WHERE Wust.WuCd = zz.
                    IF Wust.Incl = TRUE THEN 
                    DO:
                        Rundbetr       = tAufze.Abh_Rab.
                        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
                        tAufze.Abh_Rab = Rundbetr.
                        Rundbetr       = tAufze.Auf_Rab.
                        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
                        tAufze.Auf_Rab = Rundbetr.
                    END.
                    LEAVE.
                END.
                RELEASE AufRabSu.
                LEAVE.
            END.

            DO WHILE TRUE:
                IF tAufze.Auf_Sp_Grp = 0 THEN LEAVE.
        
                FIND AufSpRab NO-LOCK
                    WHERE AufSpRab.Firma   = tAufze.Firma
                    AND   AufSpRab.Aufnr   = tAufze.Aufnr
                    AND   AufSpRab.Rab_Grp = tAufze.Auf_Sp_Grp NO-ERROR.
                IF NOT AVAILABLE AufSpRab THEN LEAVE.

                ASSIGN  
                    tAufze.Auf_Sp_Proz_Betr = AufSpRab.Auf_Proz_Betr
                    tAufze.Auf_Sp_Wert      = AufSpRab.Auf_Wert.
                    
                IF NOT tAufze.Auf_Sp_Proz_Betr
                    THEN tAufze.Auf_Sp_Rab = nMenge      * tAufze.Auf_Sp_Wert.
                ELSE tAufze.Auf_Sp_Rab = tAufze.Net_Betr * tAufze.Auf_Sp_Wert / 100.
    
                FIND FIRST Wust USE-INDEX Wust-k2
                    WHERE Wust.WuCd = zz NO-LOCK.
                IF Wust.Incl = TRUE THEN 
                DO:
                    Rundbetr         = tAufze.Auf_Sp_Rab.
                    RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
                    tAufze.Auf_Sp_Rab = Rundbetr.
                END.
                RELEASE AufSpRab.
                LEAVE.
            END.

            htAufze = TEMP-TABLE tAufze:DEFAULT-BUFFER-HANDLE.
            DYNAMIC-FUNCTION('calculateZeilenTotal':U, INPUT-OUTPUT htAufze ) NO-ERROR.
        
            VWpfl   [zz] = VWpfl   [zz] + tAufze.Net_Betr
                - tAufze.Auf_Rab
                - tAufze.Abh_Rab
                - tAufze.Auf_Sp_Rab.
            Aufko.WW[zz] = Aufko.WW[zz] + tAufze.Net_Betr
                - tAufze.Auf_Rab
                - tAufze.Abh_Rab
                - tAufze.Auf_Sp_Rab.
            opnTotal[01] = opnTotal[01] + tAufze.Net_Betr
                - tAufze.Auf_Rab
                - tAufze.Abh_Rab
                - tAufze.Auf_Sp_Rab.
            IF tAufze.Sk_Ber THEN 
            DO:
                opnTotal[02] = opnTotal[02] + tAufze.Net_Betr
                    - tAufze.Auf_Rab
                    - tAufze.Abh_Rab
                    - tAufze.Auf_Sp_Rab.
            END.
            VGewicht = VGewicht + tAufze.Gewicht.
        END.

        FOR EACH tAufze:
            FIND Aufze NO-LOCK OF tAufze.
            BUFFER-COMPARE Aufze TO tAufze SAVE RESULT IN cResult.
            IF cResult = '' THEN NEXT.
            FIND bAufze OF tAufze.
            BUFFER-COPY tAufze TO bAufze.
            RELEASE bAufze.
        END.
    
        IF FDebst.Geb_Rg THEN 
        DO:
            FOR EACH AufGKon NO-LOCK USE-INDEX AufGKon-k1
                WHERE AufGKon.Firma = Aufko.Firma
                AND   AufGKon.Aufnr = Aufko.Aufnr :
                    
                zz        = AufGKon.MWSt_Cd.
                VWpfl[zz] = VWpfl[zz] + AufGKon.Betrag.
                IF AufGKon.Gebuehr = 0 THEN opnTotal[11] = opnTotal[11] + AufGKon.Betrag.
                ELSE                        opnTotal[12] = opnTotal[12] + AufGKon.Betrag.
            END.
        END.
        ELSE 
        DO:
            FOR EACH AufGKon NO-LOCK USE-INDEX AufGKon-k1
                WHERE AufGKon.Firma    = Aufko.Firma
                AND   AufGKon.Aufnr    = Aufko.Aufnr
                AND   AufGKon.Gebuehr <> 0.0
                AND   AufGKon.Betrag  <> 0.0 :
                    
                zz           = AufGKon.MWSt_Cd.
                VWpfl[zz]    = VWpfl[zz]    + AufGKon.Betrag.
                opnTotal[12] = opnTotal[12] + AufGKon.Betrag.
            END.
        END.

        FIND FIRST Wust NO-LOCK 
            WHERE Wust.CodeK = Aufko.Mwst
            AND   Wust.CodeA = 9 NO-ERROR.
        EMPTY TEMP-TABLE tMwstParam.
        CREATE tMwstParam.
        ASSIGN
            tMwstParam.Firma      = Aufko.Firma
            tMwstParam.Knr        = Aufko.Fak_Knr
            tMwstParam.Datum      = dMwstDat
            tMwstParam.Frw        = Aufko.Frw
            tMwstParam.MwstPfl    = VWpfl
            tMwstParam.MwstBetr   = VWust
            tMwstParam.MwstCdKd   = Aufko.Mwst
            tMwstParam.lInklusive = (IF AVAILABLE Wust THEN Wust.Incl ELSE FALSE)
            .
        DYNAMIC-FUNCTION('calculateMwstFaktura':U, INPUT TABLE tMwstParam, OUTPUT TABLE tMwstCalc, OUTPUT cMessage ).

        FOR EACH tMwstCalc:
            zz = tMwstCalc.Mwst_Cd.
            IF tMwstCalc.lInklusive THEN 
                ASSIGN
                    Aufko.Wpfl[zz] = tMwstCalc.Brutto
                    Aufko.Wust[zz] = 0.00
                    opnTotal  [07] = opnTotal[07] + (IF tMwstCalc.Ansatz = 0 THEN 0 ELSE tMwstCalc.Brutto)
                    opnTotal  [08] = opnTotal[08] + (IF tMwstCalc.Ansatz > 0 THEN 0 ELSE tMwstCalc.Brutto)
                    opnTotal  [09] = opnTotal[09] + 0.00.
            ELSE 
                ASSIGN
                    Aufko.Wpfl[zz] = tMwstCalc.Netto
                    Aufko.Wust[zz] = tMwstCalc.Mwst 
                    opnTotal  [07] = opnTotal[07] + (IF tMwstCalc.Ansatz = 0 THEN 0 ELSE tMwstCalc.Netto)
                    opnTotal  [08] = opnTotal[08] + (IF tMwstCalc.Ansatz > 0 THEN 0 ELSE tMwstCalc.Netto)
                    opnTotal  [09] = opnTotal[09] + tMwstCalc.Mwst.
        END.
        opnTotal[10] = DECIMAL(ENTRY(1, cMessage, ';')).
        
        ASSIGN  
            Aufko.Auf_Tot = opnTotal[10]
            Aufko.Gewicht = VGewicht
            Aufko.Sk_Ber  = opnTotal[02]
            
            nAufTotal     = nAufTotal + Aufko.Auf_Tot.
        RELEASE Aufko.
        RELEASE Aufze.
    
        LEAVE.

    END.

    RELEASE Aufko.
    RELEASE Aufze.
    RELEASE AufGKon.
    RELEASE AufSpRab.
    RELEASE AufRabSu.
    RELEASE Steuer.
    RELEASE Wust.
    RELEASE FDebst.
    
    IF  nKredLimite > 0           AND
        nAufTotal   > nKredLimite THEN RETURN 'KREDITLIMITE'.
    ELSE                              RETURN ''.
    
END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-calculateGebindeAusMenge) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION calculateGebindeAusMenge Procedure
FUNCTION calculateGebindeAusMenge RETURNS LOGICAL 
    ( ipcFirma AS CHARACTER,
    ipiArtnr   AS INTEGER ,
    ipiInhalt  AS INTEGER ,
    ipiJahr    AS INTEGER ,
    ipiMenge   AS INTEGER ,
    OUTPUT opiGGebinde AS INTEGER ,
    OUTPUT opiVGebinde AS INTEGER ,
    OUTPUT opiKGebinde AS INTEGER   ):
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*  Parameters:  <none>                                                         */
    /*  Notes:                                                                      */
    /*------------------------------------------------------------------------------*/

    DEFINE BUFFER bArtst    FOR Artst.
    DEFINE BUFFER bGGebinde FOR GGebinde.
    DEFINE BUFFER bVGebinde FOR VGebinde.
    DEFINE BUFFER bKGebinde FOR KGebinde.
    
    ASSIGN  
        opiGGebinde = 0
        opiVGebinde = 0
        opiKGebinde = ipiMenge.
    
    FIND bArtst NO-LOCK 
        WHERE bArtst.Firma  = ipcFirma
        AND   bArtst.Artnr  = ipiArtnr
        AND   bArtst.Inhalt = ipiInhalt
        AND   bArtst.Jahr   = ipiJahr NO-ERROR.
    FIND bGGebinde NO-LOCK 
        WHERE bGGebinde.Firma  = ipcFirma
        AND   bGGebinde.Geb_Cd = bArtst.GGeb_Cd NO-ERROR.
    FIND bVGebinde NO-LOCK 
        WHERE bVGebinde.Firma  = ipcFirma
        AND   bVGebinde.Geb_Cd = bArtst.VGeb_Cd NO-ERROR.
    FIND bKGebinde NO-LOCK 
        WHERE bKGebinde.Firma  = ipcFirma
        AND   bKGebinde.Geb_Cd = bArtst.KGeb_Cd NO-ERROR.
        
    IF  NOT AVAILABLE bVGebinde OR
        bVGebinde.Inhalt = 0    THEN RETURN FALSE.
    
    DO WHILE TRUE:
        opiKGebinde = ipiMenge.
        IF opiKGebinde >= bVGebinde.Inhalt THEN  opiVGebinde = (opiKGebinde - (opiKGebinde MOD bVGebinde.Inhalt)) / bVGebinde.Inhalt.
    
        IF  NOT AVAILABLE bGGebinde OR
            bGGebinde.Inhalt = 0    THEN LEAVE.

        IF opiVGebinde >= bGGebinde.Inhalt THEN opiGGebinde = (opiVGebinde - (opiVGebinde MOD bGGebinde.Inhalt)) / bGGebinde.Inhalt.
    
        LEAVE.
    END.
    
    RELEASE bArtst  .
    RELEASE bGGebinde.
    RELEASE bVGebinde.
    RELEASE bKGebinde.
    
    RETURN TRUE.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-calculateZeilenTotal) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION calculateZeilenTotal Procedure 
FUNCTION calculateZeilenTotal RETURNS LOGICAL
    ( INPUT-OUTPUT iphAufze AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE Rundbetr AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE iMwstCd  AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iMwstArt AS INTEGER   NO-UNDO.
    DEFINE VARIABLE cFirma   AS CHARACTER NO-UNDO.
    DEFINE VARIABLE cKGeb_Cd AS CHARACTER NO-UNDO.
    DEFINE VARIABLE cVGeb_Cd AS CHARACTER NO-UNDO.
    DEFINE VARIABLE cGGeb_Cd AS CHARACTER NO-UNDO.
    
    DEFINE BUFFER bKGebinde FOR KGebinde.
    DEFINE BUFFER bVGebinde FOR VGebinde.
    DEFINE BUFFER bGGebinde FOR GGebinde.
    DEFINE BUFFER bArtst    FOR Artst.
    
    iMwstCd  = iphAufze::WuCd.
    iMwstArt = iphAufze::Wc.
    cFirma   = iphAufze::Firma.
    cKGeb_Cd = iphAufze::KGeb_Cd.
    cVGeb_Cd = iphAufze::VGeb_Cd.
    cGGeb_Cd = iphAufze::GGeb_Cd.
    
    FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
        WHERE Wust.Wucd  = iMwstCd
        AND   Wust.CodeA = iMwstArt
        AND   Wust.CodeK < 12 .
    DO WHILE TRUE:
        IF iphAufze::Rab_Art = 1 THEN 
        DO:
            iphAufze::Bru_Betr = iphAufze::Preis * iphAufze::MGeli.
            iphAufze::Rab_Betr = iphAufze::Preis * iphAufze::Rab_Wert / 100 * iphAufze::MGeli.
            LEAVE.
        END.
        IF iphAufze::Rab_Art = 2 THEN 
        DO:
            iphAufze::Bru_Betr = iphAufze::Preis    * iphAufze::MGeli.
            iphAufze::Rab_Betr = iphAufze::Rab_Wert * iphAufze::MGeli.
            LEAVE.
        END.
        IF iphAufze::Rab_Art = 3 THEN 
        DO:
            IF lEpProzBetr THEN 
            DO:
                iphAufze::Bru_Betr = iphAufze::Preis * iphAufze::MGeli.
                iphAufze::Rab_Betr = iphAufze::Preis * iphAufze::Rab_Wert / 100 * iphAufze::MGeli * -1.
            END.
            ELSE 
            DO:
                iphAufze::Bru_Betr = iphAufze::Preis    * iphAufze::MGeli.
                iphAufze::Rab_Betr = iphAufze::Rab_Wert * iphAufze::MGeli * -1.
            END.
            LEAVE.
        END.
        iphAufze::Bru_Betr = iphAufze::Preis * iphAufze::MGeli.
        iphAufze::Rab_Betr = 0.
        iphAufze::Rab_Art  = 0.
        LEAVE.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = iphAufze::Rab_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        iphAufze::Rab_Betr = Rundbetr.
    END.

    DO WHILE TRUE:
        IF iphAufze::Zus_Art = 1 THEN 
        DO:
            iphAufze::Zus_Betr = iphAufze::Preis * iphAufze::Zus_Wert / 100 * iphAufze::MGeli.
            LEAVE.
        END.
        IF iphAufze::Zus_Art = 2 THEN 
        DO:
            iphAufze::Zus_Betr = iphAufze::Zus_Wert * iphAufze::MGeli.
            LEAVE.
        END.
        iphAufze::Zus_Betr = 0.
        iphAufze::Zus_Wert = 0.
        iphAufze::Zus_Art  = 0.
        LEAVE.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = iphAufze::Zus_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        iphAufze::Zus_Betr = Rundbetr.
    END.
    
    iphAufze::Net_Betr = iphAufze::Bru_Betr - iphAufze::Rab_Betr + iphAufze::Zus_Betr.

    IF Wust.Incl THEN 
    DO:
        Rundbetr = iphAufze::Net_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        iphAufze::Net_Betr = Rundbetr.
    END.
    
    FIND bGGebinde NO-LOCK
        WHERE bGGebinde.Firma  = cFirma
        AND   bGGebinde.Geb_Cd = cGGeb_Cd NO-ERROR.
    FIND bVGebinde NO-LOCK
        WHERE bVGebinde.Firma  = cFirma
        AND   bVGebinde.Geb_Cd = cVGeb_Cd NO-ERROR.
    FIND bKGebinde NO-LOCK
        WHERE bKGebinde.Firma  = cFirma
        AND   bKGebinde.Geb_Cd = cKGeb_Cd NO-ERROR.
    FIND bArtst NO-LOCK
        WHERE bArtst.Firma  = cFirma
        AND   bArtst.Artnr  = iphAufze::Artnr
        AND   bArtst.Inhalt = iphAufze::Inhalt
        AND   bArtst.Jahr   = iphAufze::Jahr.
                        
    /*  --------------------------------------------------------------  */
    /*  Liter und Gewicht                                               */
    /*  --------------------------------------------------------------  */
    iphAufze::Liter   =  bKGebinde.Inhalt  * iphAufze::KGeb_Me / 100.
    iphAufze::Gewicht = (bArtst.Gewicht    * iphAufze::KGeb_Me)
        + (bKGebinde.Gewicht * iphAufze::KGeb_Me)
        + (bVGebinde.Gewicht * iphAufze::VGeb_Me)
        + (bGGebinde.Gewicht * iphAufze::GGeb_Me).
                   
    RELEASE Wust.
    RELEASE bGGebinde.
    RELEASE bVGebinde.
    RELEASE bKGebinde.
    RELEASE bArtst.

    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAktionspreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createAktionspreis Procedure 
FUNCTION createAktionspreis RETURNS LOGICAL
    ( ipiAktGrp AS INTEGER, iplAbweich AS LOG, ipiAktKuPr_Grp AS INTEGER, ipiKuPreisGrp AS INTEGER) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE ii       AS INTEGER NO-UNDO.
    DEFINE VARIABLE nNetto   AS DECIMAL DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE nKleinst AS DECIMAL DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE iArt     AS INTEGER NO-UNDO.
    DEFINE VARIABLE lAktion  AS LOG     INIT FALSE NO-UNDO.
    
    DEFINE BUFFER bAktPreis FOR AktPreis.
    DEFINE BUFFER btPreis   FOR tPreis.
    
    FIND FIRST tParam.
    FIND FIRST tAufze.

    ASSIGN  
        nKleinst = 999999.9999
        iArt     = -1.
    FOR EACH tPreis BY tPreis.iArt:
        nNetto = tPreis.Preis.
        IF tPreis.Rab_Proz <> 0 THEN nNetto = tPreis.Preis * (100 - tPreis.Rab_Proz) / 100.
        IF tPreis.Rab_Wert <> 0 THEN nNetto = tPreis.Preis - tPreis.Rab_Wert.
        IF tPreis.Spe_Proz <> 0 THEN nNetto = tPreis.Preis * (100 - tPreis.Spe_Proz) / 100.
        IF tPreis.Spe_Wert <> 0 THEN nNetto = tPreis.Preis - tPreis.Spe_Wert.

        IF tPreis.Zus_Proz <> 0 THEN nNetto = nNetto + (tPreis.Preis * tPreis.Zus_Proz / 100).
        IF tPreis.Zus_Wert <> 0 THEN nNetto = nNetto + tPreis.Zus_Wert.
        IF nNetto < nKleinst THEN 
        DO:
            ASSIGN  
                nKleinst = nNetto
                iArt     = tPreis.iArt.
        END.
    END.

    IF iArt < 0 THEN RETURN lAktion.
    FIND FIRST btPreis
        WHERE btPreis.iArt = 4 NO-ERROR.    /*  Spezialpreis Warengruppe    */
    IF NOT AVAILABLE  btPreis THEN 
    DO:
        FIND FIRST btPreis NO-LOCK NO-ERROR. 
    END.
    IF NOT AVAILABLE btPreis THEN RETURN lAktion.

    DO ii = 1 TO 2:
        FIND LAST bAktPreis NO-LOCK
            WHERE bAktPreis.Firma      = tAufze.Firma
            AND   bAktPreis.Artnr      = tAufze.Artnr
            AND   bAktPreis.Inhalt     = tAufze.Inhalt
            AND   bAktPreis.Jahr       = tAufze.Jahr
            AND   bAktPreis.Grp        = ipiAktGrp
            AND   bAktPreis.Ab_Datum  <= tParam.Kond_Datum
            AND   bAktPreis.Bis_Datum >= tParam.Kond_Datum NO-ERROR.
        IF AVAILABLE bAktPreis THEN 
        DO:
            CREATE  tPreis.
            BUFFER-COPY btPreis
                EXCEPT btPreis.iArt btPreis.Netto
                TO     tPreis
                ASSIGN 
                tPreis.iArt = (IF ii = 1 THEN 5 ELSE 6)  
                tPreis.cAkt_Text = bAktPreis.Bemerkung.

            IF bAktPreis.Art = 0 THEN tPreis.Preis = tPreis.Preis - bAktPreis.Wert.
            IF bAktPreis.Art = 1 THEN tPreis.Preis = tPreis.Preis * (100 - bAktPreis.Wert) / 100.
            lAktion = TRUE.
            LEAVE.
        END.
        IF ii = 2             THEN LEAVE.
        IF NOT iplAbweich     THEN LEAVE.     /*  Keine abweichende Preisgruppe vorhanden     */
        IF ipiAktKuPr_Grp > 0 THEN LEAVE.     /*  Die Aktion ist auf die Kundengruppe bezogen */
        ipiAktGrp = ipiKuPreisGrp.
    END.
    
    RELEASE bAktPreis.
    
    RETURN lAktion.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufGebKo) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createAufGebKo Procedure 
FUNCTION createAufGebKo RETURNS LOGICAL
    ( ipAufnr AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    FOR EACH GebRueck NO-LOCK
        WHERE GebRueck.Firma = Firma TRANSACTION:
        FIND AufGebKo
            WHERE AufGebKo.Firma   = Firma
            AND   AufGebKo.Aufnr   = ipAufnr
            AND   AufGebKo.Sort_Cd = GebRueck.Sort_Cd
            AND   AufGebKo.Geb_Cd  = GebRueck.Geb_Cd NO-ERROR.
        IF NOT AVAILABLE AufGebKo THEN 
        DO:
            CREATE  AufGebKo.
            ASSIGN  
                AufGebKo.Firma   = Firma
                AufGebKo.Aufnr   = ipAufnr
                AufGebKo.Sort_Cd = GebRueck.Sort_Cd
                AufGebKo.Geb_Cd  = GebRueck.Geb_Cd
                AufGebKo.Anz_1   = GebRueck.Anz_1
                AufGebKo.Kto_Cd1 = GebRueck.Kto_Cd1
                AufGebKo.Anz_2   = GebRueck.Anz_2
                AufGebKo.Kto_Cd2 = GebRueck.Kto_Cd2
                AufGebKo.Anz_3   = GebRueck.Anz_3
                AufGebKo.Kto_Cd3 = GebRueck.Kto_Cd3.
        END.
                
        IF AufGebKo.Kto_Cd1 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Firma
                AND   GebKonto.Geb_Cd = AufGebKo.Kto_Cd1 NO-ERROR.
            IF AVAILABLE GebKonto THEN AufGebKo.Wert_1 = GebKonto.Depot.
        END.
        IF AufGebKo.Kto_Cd2 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Firma
                AND   GebKonto.Geb_Cd = AufGebKo.Kto_Cd2 NO-ERROR.
            IF AVAILABLE GebKonto THEN AufGebKo.Wert_2 = GebKonto.Depot.
        END.
        IF AufGebKo.Kto_Cd3 <> '' THEN 
        DO:
            FIND GebKonto NO-LOCK USE-INDEX GebKonto-k1
                WHERE GebKonto.Firma  = Firma
                AND   GebKonto.Geb_Cd = AufGebKo.Kto_Cd3 NO-ERROR.
            IF AVAILABLE GebKonto THEN AufGebKo.Wert_3 = GebKonto.Depot.
        END.
        RELEASE GebRueck.
        RELEASE AufGebKo.
        RELEASE GebKonto.
    END.
    
END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufkoParam) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createAufkoParam Procedure 
FUNCTION createAufkoParam RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipAufnr AS INTEGER, ipKnr AS INTEGER, ipDatum AS DATE ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE BUFFER bDebst   FOR Debst   .
    DEFINE BUFFER bAufko   FOR Aufko   .
    DEFINE BUFFER bAdresse FOR Adresse .

    EMPTY TEMP-TABLE tParam.
    CREATE  tParam.
    
    DO WHILE ipKnr > 0:
        FIND bDebst NO-LOCK
            WHERE bDebst.Firma = ipFirma
            AND   bDebst.Knr   = ipKnr.
        ASSIGN  
            tParam.Firma        = ipFirma
            tParam.Knr          = ipKnr
            tParam.Mwst         = bDebst.Mwst
            tParam.Preis_Grp    = bDebst.Preis_Grp
            tParam.Ku_Grp       = bDebst.Ku_Grp
            tParam.Frw          = bDebst.Frw
            tParam.Kond_Datum   = ipDatum
            tParam.Lager        = 0
            tParam.Rab_Grp      = bDebst.Rab_Grp
            tParam.Geb_Rg       = bDebst.Geb_Rg
            tParam.Zei_Rab_Art  = bDebst.Zei_Rab_Art
            tParam.Zei_Rab_Wert = bDebst.Zei_Rab_Wert
            tParam.Auf_Rab_Art  = bDebst.Auf_Rab_Art
            tParam.Auf_Rab_Wert = bDebst.Auf_Rab_Wert
            tParam.Abh_Rab_Art  = bDebst.Abh_Rab_Art
            tParam.Abh_Rab_Wert = bDebst.Abh_Rab_Wert
            tParam.Zuschl_Art   = bDebst.Zuschl_Art
            tParam.Zuschl_Wert  = bDebst.Zuschl_Wert
            .
        FIND bAdresse NO-LOCK USE-INDEX Adresse-k1
            WHERE bAdresse.Firma = AdFirma
            AND   bAdresse.Knr   = bDebst.Knr NO-ERROR.
        tParam.Sprcd = (IF AVAILABLE bAdresse THEN bAdresse.Sprcd ELSE 1).
        
        FIND Waehrung NO-LOCK
            WHERE Waehrung.Firma = bDebst.Firma
            AND   Waehrung.FRW   = bDebst.FRW NO-ERROR.
        IF AVAILABLE Waehrung THEN 
        DO:
            ASSIGN  
                tParam.Kurs   = Waehrung.Kurs
                tParam.Faktor = Waehrung.Faktor.
        END.
        ELSE 
        DO:
            ASSIGN  
                tParam.Frw    = 'CHF'
                tParam.Kurs   = 1.0
                tParam.Faktor = 1.
        END.

        RELEASE bDebst.
        RELEASE bAdresse.
        RETURN TRUE.
    END.
    
    FIND bAufko NO-LOCK
        WHERE bAufko.Firma = ipFirma
        AND   bAufko.Aufnr = ipAufnr.
    ASSIGN  
        tParam.Firma        = ipFirma
        tParam.Knr          = bAufko.Knr
        tParam.Mwst         = bAufko.Mwst
        tParam.Preis_Grp    = bAufko.Preis_Grp
        tParam.Ku_Grp       = bAufko.Ku_Grp
        tParam.Kond_Datum   = (IF bAufko.Kond_Datum <> ? THEN bAufko.Kond_Datum ELSE bAufko.Lief_Datum)
        tParam.Rab_Grp      = bAufko.Rab_Grp
        tParam.Frw          = bAufko.Frw
        tParam.Kurs         = bAufko.Kurs
        tParam.Faktor       = bAufko.Faktor
        tParam.Lager        = bAufko.Lager
        tParam.Rab_Grp      = bAufko.Rab_Grp
        tParam.Geb_Rg       = bAufko.Geb_Rg
        tParam.Zei_Rab_Art  = bAufko.Zei_Rab_Art
        tParam.Zei_Rab_Wert = bAufko.Zei_Rab_Wert
        tParam.Auf_Rab_Art  = bAufko.Auf_Rab_Art
        tParam.Auf_Rab_Wert = bAufko.Auf_Rab_Wert
        tParam.Abh_Rab_Art  = bAufko.Abh_Rab_Art
        tParam.Abh_Rab_Wert = bAufko.Abh_Rab_Wert
        tParam.Zuschl_Art   = bAufko.Zuschl_Art
        tParam.Zuschl_Wert  = bAufko.Zuschl_Wert.
    IF tParam.Kond_Datum = ? THEN tParam.Kond_Datum = ipDatum.
    FIND bAdresse NO-LOCK USE-INDEX Adresse-k1
        WHERE bAdresse.Firma = AdFirma
        AND   bAdresse.Knr   = bAufko.Knr NO-ERROR.
    tParam.Sprcd = (IF AVAILABLE bAdresse THEN bAdresse.Sprcd ELSE 1).
    
    RELEASE bAufko.
    RELEASE bAdresse.
    
    RETURN TRUE.
        
END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createAufnr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createAufnr Procedure 
FUNCTION createAufnr RETURNS INTEGER
    ( ipFirma AS CHARACTER ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iAufnr 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.Nr1 = SteuNr.Nr1 + 1
                iAufnr     = SteuNr.Nr1.
            RELEASE SteuNr.
            LEAVE.
        END.
        IF LOCKED SteuNr THEN 
        DO:
            MESSAGE 'SteuNr LOCKED' VIEW-AS ALERT-BOX INFORMATION.
            NEXT.
        END.
        LEAVE.
    END.
    
    RETURN iAufnr.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createEpPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createEpPreis Procedure 
FUNCTION createEpPreis RETURNS LOGICAL
    ( iphbArtst AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    CREATE  tPreis.
    ASSIGN  
        tPreis.iArt     = 2
        tPreis.Preis    = 0
        tPreis.Rab_Proz = (IF lEpProzBetr THEN - tAufze.Rab_Wert ELSE 0)
        tPreis.Rab_Wert = (IF lEpProzBetr THEN 0 ELSE - tAufze.Rab_Wert)
        tPreis.Spe_Proz = 0
        tPreis.Spe_Wert = 0
        tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
        tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).
    IF iphbArtst::DEP       <> 0 THEN tPreis.Preis = iphbArtst::DEP.
    IF iphbArtst::LEP       <> 0 THEN tPreis.Preis = iphbArtst::LEP.
    IF iphbArtst::Listen_EP <> 0 THEN tPreis.Preis = iphbArtst::Listen_EP.

    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createFaknr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createFaknr Procedure 
FUNCTION createFaknr RETURNS INTEGER
    ( ipFirma AS CHARACTER ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iFaknr 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.Nr2 = SteuNr.Nr2 + 1
                iFaknr     = SteuNr.Nr2.
            RELEASE SteuNr.
            LEAVE.
        END.
        IF LOCKED SteuNr THEN 
        DO:
            MESSAGE 'SteuNr LOCKED' VIEW-AS ALERT-BOX INFORMATION.
            NEXT.
        END.
        RELEASE SteuNr.
        LEAVE.
    END.
    
    RETURN iFaknr.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createManuellerPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createManuellerPreis Procedure 
FUNCTION createManuellerPreis RETURNS LOGICAL
    ( /* parameter-definitions */ ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    FIND FIRST tAufze.

    EMPTY TEMP-TABLE tPreis.
    CREATE  tPreis.
    ASSIGN  
        tPreis.iArt     = 1
        tPreis.Preis    = tAufze.Preis
        tPreis.Rab_Proz = 0
        tPreis.Rab_Wert = 0
        tPreis.Spe_Proz = 0
        tPreis.Spe_Wert = 0
        tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
        tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).
    CASE tAufze.Rab_Art:
        WHEN 1 THEN 
            ASSIGN 
                tPreis.Rab_Proz = + tAufze.Rab_Wert.
        WHEN 2 THEN 
            ASSIGN 
                tPreis.Rab_Wert = + tAufze.Rab_Wert.
        WHEN 3 THEN 
            DO:
                IF lEpProzBetr THEN tPreis.Rab_Proz = - tAufze.Rab_Wert.
                ELSE                tPreis.Rab_Wert = - tAufze.Rab_Wert.
            END.
    END CASE.
    
    ASSIGN  
        tAufze.Auf_Sp_Grp  = 0
        tAufze.Auf_Sp_Rab  = 0
        tAufze.Auf_Sp_Wert = 0.
    
    RETURN TRUE.
    
END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-createSammnr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION createSammnr Procedure 
FUNCTION createSammnr RETURNS INTEGER
    ( ipFirma AS CHARACTER ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iSammnr AS INTEGER INIT 0 NO-UNDO.

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

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-deleteArtbw) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION deleteArtbw Procedure
FUNCTION deleteArtbw RETURNS LOGICAL 
    ( ipiTrnr AS INTEGER, iprArtbw AS RECID ):
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOGICAL NO-UNDO INIT TRUE.

    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        IF ipiTrnr > 0 THEN 
        DO:
            FIND Artbw NO-LOCK USE-INDEX Artbw-k1
                WHERE Artbw.Firma = Firma
                AND   Artbw.Trnr  = ipiTrnr NO-ERROR.
            IF AVAILABLE Artbw THEN iprArtbw = RECID(Artbw).
            RELEASE Artbw.
        END.
        
        IF  iprArtbw <> ? AND
            iprArtbw <> 0 THEN 
        DO:
            FIND Artbw WHERE RECID(Artbw) = iprArtbw EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
        END.
        
        IF  NOT AVAILABLE Artbw AND
            NOT LOCKED Artbw    THEN LEAVE.
            
        IF LOCKED Artbw THEN 
        DO: 
            DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, iprArtbw), ?, ?) NO-ERROR.
            lRetVal = FALSE.
            LEAVE.
        END.
        
        DELETE  Artbw.
        RELEASE Artbw.
        LEAVE.
    END.
    
    RETURN lRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteAuflot) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION deleteAuflot Procedure
FUNCTION deleteAufLot RETURNS LOGICAL 
    ( iprAufze AS RECID ):
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal       AS LOGICAL   NO-UNDO INIT TRUE.
    DEFINE VARIABLE cArtnr        AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iHoReLager_Id AS INTEGER   NO-UNDO.
    
    DEFINE BUFFER bAufze  FOR Aufze.
    DEFINE BUFFER bAufLot FOR AufLot.
    
    FIND bAufze NO-LOCK WHERE RECID(bAufze) = iprAufze NO-ERROR.
    IF NOT AVAILABLE bAufze THEN RETURN lRetVal.
    
    TRANS00:
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FOR EACH AufLot NO-LOCK OF bAufze:
            FIND bAufLot WHERE RECID(bAufLot) = RECID(AufLot) EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
            IF LOCKED bAufLot THEN 
            DO: 
                DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, RECID(AufLot)), ?, ?) NO-ERROR.
                lRetVal = FALSE.
                LEAVE TRANS00.
            END.
            
            iHoReLager_Id = DYNAMIC-FUNCTION('getHoReLagerId':U, AufLot.Artnr, AufLot.Inhalt, AufLot.Jahr, AufLot.Lager) NO-ERROR.
            
            DO WHILE iHoReLager_Id > 0:
                FIND FIRST LotLager
                    WHERE LotLager.Firma     = AufLot.Firma
                    AND   LotLager.Lager     = AufLot.Lager
                    AND   LotLager.Artnr     = AufLot.Artnr
                    AND   LotLager.Inhalt    = AufLot.Inhalt
                    AND   LotLager.Jahr      = AufLot.Jahr
                    AND   LotLager.Verfall   = AufLot.Verfall
                    AND   LotLager.Lotnummer = AufLot.Nummer NO-ERROR.
                IF  NOT AVAILABLE LotLager                 OR
                    LotLager.HoReLager_Id <> iHoReLager_Id THEN 
                DO:
                    CREATE  LotLager.
                    ASSIGN  
                        LotLager.Firma        = AufLot.Firma
                        LotLager.Lager        = AufLot.Lager
                        LotLager.Artnr        = AufLot.Artnr
                        LotLager.Inhalt       = AufLot.Inhalt
                        LotLager.Jahr         = AufLot.Jahr
                        LotLager.Verfall      = AufLot.Verfall
                        LotLager.Lotnummer    = AufLot.Nummer
                        LotLager.HoReLager_Id = iHoReLager_Id
                        LotLager.Eingang      = AufLot.Datum.
                END.
                
                LotLager.Bestand = LotLager.Bestand + AufLot.Menge.
            
                RELEASE LotLager.
                LEAVE.
            END.
            
            DELETE  bAufLot.
            RELEASE bAuflot.
        END.
        RELEASE LotLager.
        RELEASE AufLot  .
        LEAVE.
    END.
        
    RETURN lRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteAuftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION deleteAuftrag Procedure 
FUNCTION deleteAuftrag RETURNS LOGICAL
    ( ipRecid AS RECID ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lSammFak  AS LOG       NO-UNDO.
    DEFINE VARIABLE hAufko    AS HANDLE    NO-UNDO.
    DEFINE VARIABLE hrawTable AS HANDLE    NO-UNDO.
    DEFINE VARIABLE lRetVal   AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE lJa       AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE cString   AS CHARACTER NO-UNDO.
    
    DEFINE BUFFER bAufko FOR Aufko.
    DEFINE BUFFER xAufko FOR Aufko.
    DEFINE BUFFER bAufze FOR Aufze.
    
    hAufko    = BUFFER bAufko:HANDLE.
    hrawTable = BUFFER rawTable:HANDLE.
    
    DISABLE TRIGGERS FOR LOAD OF AufLot     .
    DISABLE TRIGGERS FOR LOAD OF RuestAuf   .

    lRetVal = FALSE.
    
    TRANS00:        
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND Aufko WHERE RECID(Aufko) = ipRecid EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
        IF  NOT AVAILABLE Aufko  AND
            LOCKED Aufko         THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, ipRecid), ?, ?) NO-ERROR.
            UNDO TRANS00, LEAVE TRANS00.
        END.
        IF NOT AVAILABLE Aufko THEN UNDO TRANS00, LEAVE TRANS00. 
    
        FIND Tabel NO-LOCK USE-INDEX Tabel-k1
            WHERE Tabel.Firma  = Aufko.Firma
            AND   Tabel.RecArt = 'FAKART'
            AND   Tabel.CodeC  = ''
            AND   Tabel.CodeI  = Aufko.Fak_Art
            AND   Tabel.Sprcd  = 1 NO-ERROR.
        lSammFak = IF Tabel.Int_3 = 4 THEN TRUE ELSE FALSE.
        
        FOR EACH bAufze NO-LOCK OF Aufko:
            FIND Aufze WHERE RECID(Aufze) = RECID(bAufze) EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
            IF  NOT AVAILABLE Aufze  AND
                LOCKED Aufze         THEN 
            DO:
                lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, ipRecid), ?, ?) NO-ERROR.
                UNDO TRANS00, LEAVE TRANS00.
            END.
            
            IF Aufze.Artnr = 0 THEN 
            DO:
                DELETE  Aufze.
                NEXT.
            END.
            
            IF Aufze.Trnr > 0 THEN 
            DO:
                lJa = DYNAMIC-FUNCTION ('deleteArtbw':U, Aufze.Trnr, 0) NO-ERROR.
                IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
            END.
            
            DYNAMIC-FUNCTION ('updateRuestAuftrag':U, 9, RECID(Aufze) ) NO-ERROR.
        
            FIND FIRST RuestAuf NO-LOCK OF Aufze NO-ERROR.
            IF AVAILABLE RuestAuf THEN 
            DO:
                lJa = DYNAMIC-FUNCTION ('deleteRuestAuf':U, RECID(RuestAuf)) NO-ERROR.
                IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
            END.
            
            IF  Aufze.lVerfall OR
                Aufze.lLotnr   THEN 
            DO:
                lJa = DYNAMIC-FUNCTION ('deleteAufLot':U, RECID(Aufze)) NO-ERROR.
                IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
            END.
            
            DELETE Aufze.
        END.

        DO WHILE TRUE:
            IF Aufko.Samm_Nr = 0 THEN LEAVE.
            IF NOT lSammFak      THEN LEAVE.
        
            FOR EACH bAufko NO-LOCK USE-INDEX Aufko-k4
                WHERE bAufko.Firma    = Aufko.Firma
                AND   bAufko.Knr      = Aufko.Knr
                AND   bAufko.Fak_Art  = Aufko.Fak_Art
                AND   bAufko.Samm_Nr  = Aufko.Samm_Nr
                AND   bAufko.Aufnr   <> Aufko.Aufnr:
                
                FIND xAufko WHERE RECID(xAufko) = RECID(bAufko) EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
                IF  NOT AVAILABLE xAufko AND
                    LOCKED xAufko        THEN 
                DO:
                    lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, RECID(bAufko)), ?, ?) NO-ERROR.
                    UNDO TRANS00, LEAVE TRANS00.
                END.
                xAufko.Gedruckt = FALSE.
                IF Tabel.Int_2 = xAufko.Auf_Sta THEN xAufko.Auf_Sta = xAufko.Auf_Sta - 1.
                RELEASE xAufko.
            END.
            LEAVE.
        END.
            
        FOR EACH AufGebKo OF Aufko:
            DELETE  AufGebKo.
        END.
        FOR EACH AufGKon OF Aufko:
            DELETE  AufGKon.
        END.
        FOR EACH AufRabSu OF Aufko:
            DELETE  AufRabSu.
        END.
        FOR EACH AufSpRab USE-INDEX AufSpRab-k1
            WHERE AufSpRab.Firma = Aufko.Firma
            AND   AufSpRab.Aufnr = Aufko.Aufnr:
            DELETE AufSpRab.
        END.
    
        DELETE  Aufko.
        RELEASE Aufko.
        
        lRetVal = TRUE.
        LEAVE.
    END.

    RETURN lRetVal.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-deleteAufzeile) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION deleteAufzeile Procedure
FUNCTION deleteAufzeile RETURNS LOGICAL 
    ( ipRecid AS RECID ) :
    /*------------------------------------------------------------------------------*/
    /*  Purpose:                                                                    */
    /*    Notes:                                                                    */  
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lSammFak  AS LOG       NO-UNDO.
    DEFINE VARIABLE hAufko    AS HANDLE    NO-UNDO.
    DEFINE VARIABLE hrawTable AS HANDLE    NO-UNDO.
    DEFINE VARIABLE lRetVal   AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE lJa       AS LOGICAL   NO-UNDO.
    DEFINE VARIABLE cString   AS CHARACTER NO-UNDO.
    
    DEFINE BUFFER bAufko FOR Aufko.
    DEFINE BUFFER xAufko FOR Aufko.
    
    DISABLE TRIGGERS FOR LOAD OF AufLot     .
    DISABLE TRIGGERS FOR LOAD OF RuestAuf   .

    lRetVal = FALSE.
    
    TRANS00:        
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND Aufze WHERE RECID(Aufze) = ipRecid EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
        IF  NOT AVAILABLE Aufze  AND
            LOCKED Aufze         THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, ipRecid), ?, ?) NO-ERROR.
            UNDO TRANS00, LEAVE TRANS00.
        END.
        IF NOT AVAILABLE Aufze THEN UNDO TRANS00, LEAVE TRANS00.
        
        FIND Aufko NO-LOCK OF Aufze NO-ERROR.
        IF NOT AVAILABLE Aufko THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getMeldung':U, 305, 1), ?, ?) NO-ERROR.
            UNDO TRANS00, LEAVE TRANS00.
        END. 
    
        FIND Tabel NO-LOCK USE-INDEX Tabel-k1
            WHERE Tabel.Firma  = Aufko.Firma
            AND   Tabel.RecArt = 'FAKART'
            AND   Tabel.CodeC  = ''
            AND   Tabel.CodeI  = Aufko.Fak_Art
            AND   Tabel.Sprcd  = 1 NO-ERROR.
        lSammFak = (IF Tabel.Int_3 = 4 THEN TRUE ELSE FALSE).
        
        IF Aufze.Trnr > 0 THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('deleteArtbw':U, Aufze.Trnr, 0) NO-ERROR.
            IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
        END.
            
        DYNAMIC-FUNCTION ('updateRuestAuftrag':U, 9, RECID(Aufze) ).
        
        FIND FIRST RuestAuf NO-LOCK OF Aufze NO-ERROR.
        IF AVAILABLE RuestAuf THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('deleteRuestAuf':U, RECID(RuestAuf)) NO-ERROR.
            IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
        END.
            
        IF  Aufze.lVerfall OR
            Aufze.lLotnr   THEN 
        DO:
            lJa = DYNAMIC-FUNCTION ('deleteAufLot':U, RECID(Aufze)) NO-ERROR.
            IF NOT lJa THEN UNDO TRANS00, LEAVE TRANS00.
        END.

        DELETE Aufze.

        DO WHILE TRUE:
            IF Aufko.Samm_Nr = 0 THEN LEAVE.
            IF NOT lSammFak      THEN LEAVE.
        
            FOR EACH bAufko NO-LOCK USE-INDEX Aufko-k4
                WHERE bAufko.Firma    = Aufko.Firma
                AND   bAufko.Knr      = Aufko.Knr
                AND   bAufko.Fak_Art  = Aufko.Fak_Art
                AND   bAufko.Samm_Nr  = Aufko.Samm_Nr:
                
                FIND xAufko WHERE RECID(xAufko) = RECID(bAufko) EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
                IF  NOT AVAILABLE xAufko AND
                    LOCKED xAufko        THEN 
                DO:
                    lJa = DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, RECID(bAufko)), ?, ?) NO-ERROR.
                    UNDO TRANS00, LEAVE TRANS00.
                END.
                xAufko.Gedruckt = FALSE.
                IF Tabel.Int_2 = xAufko.Auf_Sta THEN xAufko.Auf_Sta = xAufko.Auf_Sta - 1.
                RELEASE xAufko.
            END.
            LEAVE.
        END.
            
        lRetVal = TRUE.
        
        RELEASE Aufze   .
        RELEASE Aufko   .
        RELEASE Tabel   .
        RELEASE bAufko  .
        RELEASE xAufko  .
        RELEASE Artbw   .
        RELEASE RuestAuf.
        RELEASE AufLot  .
        RELEASE rawTable.
        
        LEAVE.
    END.

    RETURN lRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-deleteRuestAuf) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION deleteRuestAuf Procedure
FUNCTION deleteRuestAuf RETURNS LOGICAL 
    ( iprRuestAuf AS RECID ):
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOGICAL NO-UNDO INIT TRUE.

    TRANS00:
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND RuestAuf WHERE RECID(RuestAuf) = iprRuestAuf EXCLUSIVE-LOCK NO-WAIT NO-ERROR.
        
        IF  NOT AVAILABLE RuestAuf AND
            NOT LOCKED RuestAuf    THEN LEAVE.
            
        IF LOCKED RuestAuf THEN 
        DO: 
            DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, iprRuestAuf), ?, ?) NO-ERROR.
            lRetVal = FALSE.
            LEAVE.
        END.
        
        DO WHILE lHoReLager:    /*  aus properties.i    */
            FIND FIRST HoReLager EXCLUSIVE-LOCK
                WHERE HoReLager.Firma = Firma
                AND   HoReLager.cSort = RuestAuf.Lagerort NO-WAIT NO-ERROR.
                
            IF  NOT AVAILABLE HoReLager  AND
                NOT LOCKED HoReLager     THEN LEAVE.
            
            IF LOCKED HoReLager THEN 
            DO:
                FIND FIRST HoReLager NO-LOCK 
                    WHERE HoReLager.Firma = Firma
                    AND   HoReLager.cSort = RuestAuf.Lagerort NO-ERROR.
                DYNAMIC-FUNCTION ('setErrorMessage':U, 'CHARACTER', DYNAMIC-FUNCTION('getLockedUser':U, RECID(HoReLager)), ?, ?) NO-ERROR.
                RELEASE HoReLager.
                lRetVal = FALSE.
                LEAVE TRANS00.
            END.
            
            HoReLager.Bestand = HoReLager.Bestand + RuestAuf.MGeli.
            RELEASE HoReLager.
            LEAVE.
        END.
        
        DELETE  RuestAuf .
        RELEASE RuestAuf .
        RELEASE HoReLager.
        LEAVE.
    END.
    
    RETURN lRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-fillArtbwFromAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION fillArtbwFromAufze Procedure 
FUNCTION fillArtbwFromAufze RETURNS LOGICAL
    ( INPUT-OUTPUT iohtAufze AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iAufnr AS INTEGER NO-UNDO.
    DEFINE VARIABLE iArtnr AS INTEGER NO-UNDO.
    DEFINE VARIABLE iTrnr  AS INTEGER NO-UNDO.
    DEFINE VARIABLE hArtbw AS HANDLE  NO-UNDO.

    DEFINE BUFFER bAufko FOR Aufko.
    DEFINE BUFFER bArtbw FOR Artbw.
    DEFINE BUFFER bArtst FOR Artst.
    
    iAufnr = iohtAufze::Aufnr.
    iArtnr = iohtAufze::Artnr.
    iTrnr  = iohtAufze::Trnr .
    
    IF iArtnr = 0 THEN RETURN TRUE.
    
    FIND bAufko NO-LOCK
        WHERE bAufko.Firma = Firma
        AND   bAufko.Aufnr = iAufnr.

    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FIND bArtbw
            WHERE bArtbw.Firma = Firma
            AND   bArtbw.Trnr  = iTrnr NO-ERROR.
        IF NOT AVAILABLE bArtbw THEN 
        DO:
            IF iTrnr = 0 THEN 
            DO:
                FIND LAST bArtbw NO-LOCK USE-INDEX Artbw-k1
                    WHERE bArtbw.Firma = Firma NO-ERROR.
                IF AVAILABLE bArtbw THEN iTrnr = bArtbw.Trnr + 1.
                ELSE                     iTrnr = 1.
                iohtAufze::Trnr = iTrnr.
            END.
        
            CREATE  bArtbw.
            ASSIGN  
                bArtbw.Tr_Art = 01.
        END.
        
                
        hArtbw = BUFFER bArtbw:HANDLE.
        hArtbw:BUFFER-COPY(iohtAufze).
        ASSIGN  
            bArtbw.Menge   = iohtAufze::MGeli
            bArtbw.Datum   = bAufko.Lief_Datum
            bArtbw.Faknr   = bAufko.Faknr
            bArtbw.Fak_Dat = bAufko.Fak_Datum
            bArtbw.Knr     = bAufko.Knr
            bArtbw.Fak_Knr = bAufko.Fak_Knr
            bArtbw.Fak_Art = bAufko.Fak_Art
            bArtbw.Abhol   = bAufko.Abhol
            bArtbw.Vertr   = bAufko.Vertr
            bArtbw.Kurs    = iohtAufze::Kurs
            bArtbw.Faktor  = iohtAufze::Faktor
            .
            
        IF bArtbw.EP = 0 THEN 
        DO:
            FIND bArtst NO-LOCK OF bArtbw.
            IF bArtst.DEP <> 0      THEN iohtAufze::EP = bArtst.DEP.
            ELSE
                IF bArtst.LEP <> 0 THEN iohtAufze::EP = bArtst.LEP.
                ELSE                    iohtAufze::EP = bArtst.Listen_EP.
            bArtbw.EP = iohtAufze::EP.
        END.
    
        RELEASE bAufko.
        RELEASE bArtbw.
        RELEASE bArtst.
        LEAVE.
    END.
            
    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufko) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION fillAufko Procedure 
FUNCTION fillAufko RETURNS LOGICAL
    ( ipArt AS INTEGER, INPUT-OUTPUT iphAufko AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE cBenDaten   AS CHARACTER NO-UNDO.
    DEFINE VARIABLE vFirma      AS CHARACTER NO-UNDO.
    DEFINE VARIABLE AufAdr      AS CHARACTER EXTENT 5 NO-UNDO.
    DEFINE VARIABLE Knr         AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwFakArt    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwAufSta    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwFahrer    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwLKW       AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwBeiFahr   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FwSprcd     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE retValue    AS CHARACTER NO-UNDO.
    DEFINE VARIABLE hAufko      AS HANDLE    NO-UNDO.
    DEFINE VARIABLE ii          AS INTEGER   NO-UNDO.
    DEFINE VARIABLE i1          AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iBinary     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE cBinary     AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iWoTag      AS INTEGER   NO-UNDO.
    DEFINE VARIABLE cLieferZeit AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iTime       AS INTEGER   NO-UNDO.
    
    DEFINE BUFFER FTabel FOR Tabel.
    DEFINE BUFFER ATabel FOR Tabel.

    iTime       = 0.
    vFirma      = iphAufko::Firma.
    Knr         = iphAufko::Knr.
    cBenDaten   = DYNAMIC-FUNCTION('GETBENUTZERDATEN':U).
    AdFirma     = DYNAMIC-FUNCTION('getAdMandant':U    ).
    FwSprcd     = DYNAMIC-FUNCTION('GETFWSPRCD':U      ).
    cLieferZeit = DYNAMIC-FUNCTION('getFehlwert':U, vFirma, 'LIEFERDATUM').
    IF  cLieferZeit <> '' AND 
        cLieferZeit <> ?  THEN 
    DO:
        cLieferzeit = REPLACE(cLieferzeit, '.', ':').
        cLieferzeit = REPLACE(cLieferzeit, '-', ':').
        cLieferzeit = REPLACE(cLieferzeit, '/', ':').
        DO ii = 1 TO NUM-ENTRIES(cLieferzeit, ':'):
            CASE ii:
                WHEN 1 THEN 
                    iTime = iTime + (INTEGER(ENTRY(1, cLieferzeit, ':')) * 3600).
                WHEN 2 THEN 
                    iTime = iTime + (INTEGER(ENTRY(2, cLieferzeit, ':')) * 60  ).
            END CASE.
        END.
    END.

    FIND Adresse NO-LOCK USE-INDEX Adresse-k1
        WHERE Adresse.Firma = AdFirma
        AND   Adresse.Knr   = Knr NO-ERROR.
    IF NOT AVAILABLE Adresse THEN RETURN FALSE.

    FIND Debst NO-LOCK USE-INDEX Debst-k1
        WHERE Debst.Firma = vFirma
        AND   Debst.Knr   = Adresse.Knr NO-ERROR.
    IF NOT AVAILABLE Debst THEN RETURN FALSE.

    FIND FIRST tAufko NO-ERROR.
    IF NOT AVAILABLE tAufko THEN CREATE tAufko.
    hAufko = TEMP-TABLE tAufko:DEFAULT-BUFFER-HANDLE.
    hAufko:BUFFER-COPY(iphAufko).
    
    IF tAufko.Aufnr = 0 THEN 
    DO:
        RUN NUMMER_LOESEN ( 1, OUTPUT tAufko.Aufnr ) NO-ERROR.
    END.

    DO WHILE ipArt = 0:     /*  Normale Auftragsbearbeitung     */
        FwFakArt     = Debst.Fak_Art.
        FwAufSta     = 0.
        tAufko.Abhol = FALSE.
        LEAVE.
    END.

    DO WHILE ipArt = 1:     /*  Abholverkauf ( Kasse )          */
        IF Debst.Fak_Art < 99 THEN FwFakArt = DYNAMIC-FUNCTION('GETABHOLFAKART':U) NO-ERROR.
        ELSE                       FwFakArt = Debst.Fak_Art.
        FwAufSta     = DYNAMIC-FUNCTION('GETABHOLAUFSTATUS':U)  NO-ERROR.
        tAufko.Abhol = TRUE.
        LEAVE.
    END.

    FIND FTabel NO-LOCK USE-INDEX Tabel-k1
        WHERE FTabel.Firma  = vFirma
        AND   FTabel.RecArt = 'FAKART'
        AND   FTabel.Sprcd  = FwSprcd
        AND   FTabel.CodeC  = ''
        AND   FTabel.CodeI  = FwFakArt NO-ERROR.
    IF NOT AVAILABLE FTabel THEN 
    DO:
        FIND FIRST FTabel NO-LOCK USE-INDEX Tabel-k1
            WHERE FTabel.Firma  = vFirma
            AND   FTabel.RecArt = 'FAKART'
            AND   FTabel.CodeC  = ''
            AND   FTabel.CodeI  = FwFakArt NO-ERROR.
    END.
    IF NOT AVAILABLE FTabel THEN RETURN FALSE.

    FIND ATabel NO-LOCK USE-INDEX Tabel-k1
        WHERE ATabel.Firma  = vFirma
        AND   ATabel.RecArt = 'AUFSTATUS'
        AND   ATabel.Sprcd  = FwSprcd
        AND   ATabel.CodeC  = ''
        AND   ATabel.CodeI  = FwAufSta NO-ERROR.
    IF NOT AVAILABLE ATabel THEN 
    DO:
        FIND FIRST ATabel NO-LOCK USE-INDEX Tabel-k1
            WHERE ATabel.Firma  = vFirma
            AND   ATabel.RecArt = 'AUFSTATUS'
            AND   ATabel.CodeC  = ''
            AND   ATabel.CodeI  = FwAufSta NO-ERROR.
    END.
    IF NOT AVAILABLE ATabel THEN RETURN FALSE.

    FwLKW     = 0.
    FwFahrer  = 0.
    FwBeiFahr = 0.
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwLKW'     VALUE retValue.
    IF retValue <> ? THEN FwLKW     = INTEGER(retValue).
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwFahrer'  VALUE retValue.
    IF retValue <> ? THEN FwFahrer  = INTEGER(retValue).
    GET-KEY-VALUE SECTION 'FwAuftrag' KEY 'FwBeiFahr' VALUE retValue.
    IF retValue <> ? THEN FwBeiFahr = INTEGER(retValue).

    ASSIGN  
        tAufko.Fak_Art = FwFakArt
        tAufko.Auf_Sta = FwAufSta.

    DO WHILE TRUE:
        IF  Debst.KnrLie <> 0            AND
            Debst.KnrLie <> Debst.Knr    THEN 
        DO:
            ASSIGN  
                tAufko.Knr     = Debst.KnrLie
                tAufko.Fak_Knr = Debst.Knr.
            LEAVE.
        END.
        IF  Debst.KnrFak <> 0            AND
            Debst.KnrFak <> Debst.Knr    THEN 
        DO:
            ASSIGN  
                tAufko.Fak_Knr = Debst.KnrFak.
            LEAVE.
        END.
        ASSIGN  
            tAufko.Knr     = Debst.Knr
            tAufko.Fak_Knr = Debst.Knr.
        LEAVE.
    END.

    FIND Waehrung NO-LOCK
        WHERE Waehrung.Firma = Debst.Firma
        AND   Waehrung.FRW   = Debst.FRW NO-ERROR.

    ASSIGN  
        tAufko.Auf_Datum      = TODAY
        tAufko.Lief_Datum     = (IF iTime = 0 THEN TODAY ELSE (IF TIME > iTime THEN TODAY + 2 ELSE TODAY + 1))
        tAufko.Kond_Datum     = TODAY
        tAufko.Fak_Datum      = ?
        tAufko.I_Best         = ''
        tAufko.U_Ref          = ENTRY(2, cBenDaten, CHR(01))
        tAufko.Vertr          = Debst.Vertr
        tAufko.Rabatt         = 0
        tAufko.Preis_Grp      = Debst.Preis_Grp
        tAufko.Ku_Grp         = Debst.Ku_Grp
        tAufko.Rab_Grp        = Debst.Rab_Grp
        tAufko.Lief_Bed       = Debst.Lief_Bed
        tAufko.Avis           = Debst.Avis
        tAufko.Frw            = Debst.FRW
        tAufko.Kurs           = Waehrung.Kurs
        tAufko.Faktor         = Waehrung.Faktor
        tAufko.Gedruckt       = FALSE
        tAufko.WW             = 0
        tAufko.Wpfl           = 0
        tAufko.Wust           = 0
        tAufko.Auf_Tot        = 0
        tAufko.Faknr          = 0
        tAufko.Bar_Fak        = FALSE
        tAufko.Bar_Betr       = 0
        tAufko.Bar_Skonto     = 0
        tAufko.Bar_Konto      = ''
        tAufko.Adresse        = ''
        tAufko.GG_Berech      = Debst.Geb_rg
        tAufko.Kopf_Text      = ''
        tAufko.Fuss_Text      = ''
        tAufko.Samm_Nr        = 0
        tAufko.SK_Ber         = 0
        tAufko.Verbucht       = FALSE
        tAufko.Rueckst        = FALSE
        tAufko.Fak_KTnr       = 0
        tAufko.Fak_FTnr       = 0
        tAufko.Filiale        = 0
        tAufko.Tour_Nr1       = Debst.Tour_Nr1
        tAufko.Tour_Nr2       = Debst.Tour_Nr2
        tAufko.Konto          = Debst.Konto
        tAufko.Geb_Rg         = Debst.Geb_Rg
        tAufko.MWST_Nr        = ''
        tAufko.Passant        = Debst.Passant
        tAufko.Auf_Text       = Debst.Auf_Text
        tAufko.Bar_Text       = Debst.Bemerk
        tAufko.Abh_Text       = Debst.Bar_Text
        tAufko.Zei_Rab_Art    = Debst.Zei_Rab_Art
        tAufko.Zei_Rab_Wert   = Debst.Zei_Rab_Wert
        tAufko.Auf_Rab_Art    = Debst.Auf_Rab_Art
        tAufko.Auf_Rab_Wert   = Debst.Auf_Rab_Wert
        tAufko.Abh_Rab_Art    = Debst.Abh_Rab_Art
        tAufko.Abh_Rab_Wert   = Debst.Abh_Rab_Wert
        tAufko.Zuschl_Art     = Debst.Zuschl_Art
        tAufko.Zuschl_Wert    = Debst.Zuschl_Wert
        tAufko.Ablad_Vor      = Debst.Ablad_Vor
        tAufko.Wirt_So        = Debst.Wirt_So  
        tAufko.Ablad_Vor_Text = Debst.Ablad_Vor_Text
        tAufko.Wirt_So_Text   = Debst.Wirt_So_Text
        tAufko.MWST           = Debst.MWST
        tAufko.Kond           = Debst.Kond
        tAufko.LKW            = FwLKW
        tAufko.Fahrer         = FwFahrer
        tAufko.BeiFahrer      = FwBeiFahr.

    IF tAufko.Konto = '' THEN 
    DO:
        FIND SteuNr USE-INDEX SteuNr-k1
            WHERE SteuNr.Firma = vFirma NO-LOCK.
        tAufko.Konto = SteuNr.Konto_Debi.
    END.
    IF tAufko.Passant THEN 
    DO:
        i1 = 5.
        DO ii = 11 TO 1 BY -1:
            IF Adresse.Anschrift[ii] = '' THEN NEXT.
            tAufko.Adresse[i1] = Adresse.Anschrift[ii].
            i1 = i1 - 1.
            IF i1 = 0 THEN LEAVE.
        END.
    END.

    IF ipArt = 1 THEN tAufko.Lief_Datum = TODAY.
    ELSE 
    DO:
        /*  --------------------------------------------------------------------------  */
        /*  Lieferdatum anhand eines möglichen Liefertages ermitteln                    */
        /*  --------------------------------------------------------------------------  */
        DO WHILE TRUE:
            FIND Kalender NO-LOCK
                WHERE Kalender.Firma         = Firma
                AND   Kalender.EreignisDatum = DATETIME-TZ (tAufko.Lief_Datum) NO-ERROR.
            IF NOT AVAILABLE Kalender THEN LEAVE.
            tAufko.Lief_Datum = tAufko.Lief_Datum + 1.
        END.
                 
        iBinary = Debst.Liefertag.
        iBinary = NumberSystems:integer2Binary(iBinary).
        cBinary = STRING(iBinary,'9999999').

        DO WHILE iBinary > 0: 
            iWoTag  = WEEKDAY(tAufko.Lief_Datum).

            IF SUBSTRING(cBinary, iWoTag, 01) = '1' THEN LEAVE.
            tAufko.Lief_Datum = tAufko.Lief_Datum + 1.
         
            DO WHILE TRUE:
                FIND Kalender NO-LOCK
                    WHERE Kalender.Firma         = Firma
                    AND   Kalender.EreignisDatum = DATETIME-TZ (tAufko.Lief_Datum) NO-ERROR.
                IF NOT AVAILABLE Kalender THEN LEAVE.
                tAufko.Lief_Datum = tAufko.Lief_Datum + 1.
            END.
        END.
    END.
        
    iphAufko:BUFFER-COPY(hAufko).

    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufRabSu) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION fillAufRabSu Procedure 
FUNCTION fillAufRabSu RETURNS LOGICAL
    ( /* parameter-definitions */ ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE nMenge AS DECIMAL NO-UNDO.

    DEFINE BUFFER bRabSumm  FOR RabSumm .
    DEFINE BUFFER bAufRabSu FOR AufRabSu.

    FIND FIRST tAufze NO-ERROR.

    EMPTY TEMP-TABLE tAufRabSu.
    FOR EACH bAufRabSu NO-LOCK
        WHERE bAufRabSu.Firma = tAufze.Firma
        AND   bAufRabSu.Aufnr = tAufze.Aufnr:
        CREATE  tAufRabSu.
        BUFFER-COPY bAufRabSu TO tAufRabSu
            ASSIGN  
            tAufRabSu.M_Menge  = 0.0
            tAufRabSu.M_Betrag = 0.0
            tAufRabSu.M_Inhalt = 0.0
            tAufRabSu.R_Menge  = 0.0
            tAufRabSu.R_Betrag = 0.0
            tAufRabSu.R_Inhalt = 0.0
            tAufRabSu.F_Wert   = 0.0
            tAufRabSu.A_Wert   = 0.0.
        RELEASE bAufRabSu.
    END.

    nMenge = 0.
    FOR EACH tAufze:
        IF  tAufze.Artnr      = 0 OR
            tAufze.Rab_Su_Grp = 0 OR
            tAufze.Preis      = 0 THEN 
        DO:
            ASSIGN  
                tAufze.Auf_Rab    = 0
                tAufze.Abh_Rab    = 0
                tAufze.Rab_Su_Art = 0
                tAufze.Rab_Su_Grp = 0.
            NEXT.
        END.
        
        FIND tAufRabSu
            WHERE tAufRabSu.Firma    = tAufze.Firma
            AND   tAufRabSu.Aufnr    = tAufze.Aufnr
            AND   tAufRabSu.Rab_Summ = tAufze.Rab_Su_Grp
            AND   tAufRabSu.MWST_Cd  = tAufze.WuCd  NO-ERROR.
        IF NOT AVAILABLE tAufRabSu THEN 
        DO:
            FIND FIRST bRabSumm
                WHERE bRabSumm.Firma    = tAufze.Firma
                AND   bRabSumm.Rab_Summ = tAufze.Rab_Su_Grp.
            CREATE  tAufRabSu.
            ASSIGN  
                tAufRabSu.Firma       = tAufze.Firma
                tAufRabSu.Aufnr       = tAufze.Aufnr
                tAufRabSu.Rab_Summ    = tAufze.Rab_Su_Grp
                tAufRabSu.MWST_Cd     = tAufze.WuCd
                tAufRabSu.F_Art       = bRabSumm.F_Rab_Art
                tAufRabSu.F_Proz_Betr = bRabSumm.F_Proz_Betr
                tAufRabSu.A_Art       = bRabSumm.A_Rab_Art
                tAufRabSu.A_Proz_Betr = bRabSumm.A_Proz_Betr.
        END.
    
        ASSIGN  
            tAufRabSu.M_Menge  = tAufRabSu.M_Menge  + tAufze.MGeli
            tAufRabSu.M_Betrag = tAufRabSu.M_Betrag + tAufze.Net_Betr
            tAufRabSu.M_Inhalt = tAufRabSu.M_Inhalt + tAufze.Liter.
                
        CASE tAufRabSu.F_Art:
            WHEN 0 THEN 
                nMenge = nMenge + tAufze.MGeli   .
            WHEN 1 THEN 
                nMenge = nMenge + tAufze.Net_Betr.
            WHEN 2 THEN 
                nMenge = nMenge + tAufze.Liter   .
        END CASE.
        
        IF tAufze.Rab_Su_Art = 0 THEN NEXT.
        ASSIGN  
            tAufRabSu.R_Menge  = tAufRabSu.R_Menge  + tAufze.MGeli
            tAufRabSu.R_Betrag = tAufRabSu.R_Betrag + tAufze.Net_Betr
            tAufRabSu.R_Inhalt = tAufRabSu.R_Inhalt + tAufze.Liter.
    END.

    nMenge = ABS(nMenge).
    FOR EACH tAufRabSu:
        IF tAufRabSu.F_Art = 0 THEN 
        DO:
            FIND LAST bRabSumm NO-LOCK
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge   <= nMenge NO-ERROR.
        END.
        IF tAufRabSu.F_Art = 1 THEN 
        DO:
            FIND LAST bRabSumm
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge    = 0
                AND   bRabSumm.Betrag  <= nMenge NO-LOCK NO-ERROR.
        END.
        IF tAufRabSu.F_Art = 2 THEN 
        DO:
            FIND LAST bRabSumm
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge    = 0
                AND   bRabSumm.Betrag   = 0
                AND   bRabSumm.Inhalt  <= (nMenge / 100) NO-LOCK NO-ERROR.
        END.
        IF NOT AVAILABLE bRabSumm THEN tAufRabSu.F_Wert = 0.
        ELSE                           tAufRabSu.F_Wert = bRabSumm.F_Wert.

        IF tAufRabSu.A_Art = 0 THEN 
        DO:
            FIND LAST bRabSumm NO-LOCK
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge   <= nMenge NO-ERROR.
        END.
        IF tAufRabSu.A_Art = 1 THEN 
        DO:
            FIND LAST bRabSumm
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge    = 0
                AND   bRabSumm.Betrag  <= nMenge NO-LOCK NO-ERROR.
        END.
        IF tAufRabSu.A_Art = 2 THEN 
        DO:
            FIND LAST bRabSumm
                WHERE bRabSumm.Firma    = tAufRabSu.Firma
                AND   bRabSumm.Rab_Summ = tAufRabSu.Rab_Summ
                AND   bRabSumm.Menge    = 0
                AND   bRabSumm.Betrag   = 0
                AND   bRabSumm.Inhalt  <= (nMenge / 100) NO-LOCK NO-ERROR.
        END.
        IF NOT AVAILABLE bRabSumm THEN tAufRabSu.A_Wert = 0.
        ELSE                           tAufRabSu.A_Wert = bRabSumm.A_Wert.

    END.

    FOR EACH tAufRabSu:
        FIND bAufRabSu OF tAufRabSu NO-ERROR.
        IF NOT AVAILABLE bAufRabSu THEN 
        DO:
            CREATE  bAufRabSu.
            BUFFER-COPY tAufRabSu TO bAufRabSu.
            RELEASE bAufRabSu.
            NEXT.
        END.
        BUFFER-COPY tAufRabSu
            EXCEPT  Firma Aufnr /* Rab_Su_Grp WuCd */
            TO      bAufRabSu.
        RELEASE bAufRabSu.
    END.

    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-FillAufSpRab) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION FillAufSpRab Procedure 
FUNCTION FillAufSpRab RETURNS LOGICAL
    (  ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE cFirma AS CHARACTER NO-UNDO.
    DEFINE VARIABLE iAufnr AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iPos   AS INTEGER   NO-UNDO.
    
    DEFINE BUFFER bSpPrRab  FOR SpPrRab .
    DEFINE BUFFER bAufSpRab FOR AufSpRab.
    DEFINE BUFFER bAufko    FOR Aufko   .

    FIND FIRST tAufze.
        
    FIND bAufko NO-LOCK
        WHERE bAufko.Firma = tAufze.Firma
        AND   bAufko.Aufnr = tAufze.Aufnr.
    
    EMPTY TEMP-TABLE tAufSpRab.
    FOR EACH bAufSpRab
        WHERE bAufSpRab.Firma = bAufko.Firma
        AND   bAufSpRab.Aufnr = bAufko.Aufnr:
        CREATE  tAufSpRab.
        BUFFER-COPY bAufSpRab TO tAufSpRab
            ASSIGN  
            tAufSpRab.Auf_Wert = 0
            tAufSpRab.Menge    = 0.
    END.
        
    FOR EACH tAufze
        WHERE tAufze.Artnr      > 0
        AND   tAufze.Auf_Sp_Grp > 0:
        FIND tAufSpRab USE-INDEX AufSpRab-k1
            WHERE tAufSpRab.Firma   = tAufze.Firma
            AND   tAufSpRab.Aufnr   = tAufze.Aufnr
            AND   tAufSpRab.Rab_Grp = tAufze.Auf_Sp_Grp NO-ERROR.
        IF NOT AVAILABLE tAufSpRab THEN 
        DO:
            CREATE  tAufSpRab.
            ASSIGN  
                tAufSpRab.Firma   = tAufze.Firma
                tAufSpRab.Aufnr   = tAufze.Aufnr
                tAufSpRab.Rab_Grp = tAufze.Auf_Sp_Grp.
        END.
        tAufSpRab.Menge = tAufSpRab.Menge + tAufze.MBest.
    END.
    FOR EACH tAufSpRab:
        FIND LAST bSpPrRab NO-LOCK
            WHERE bSpPrRab.Firma      = bAufko.Firma
            AND   bSpPrRab.Knr        = bAufko.Knr
            AND   bSpPrRab.Rab_Grp    = tAufSpRab.Rab_Grp
            AND   bSpPrRab.Menge     <= ABS(tAufSpRab.Menge)
            AND   bSpPrRab.Ab_Datum  <= bAufko.Kond_Datum
            AND   bSpPrRab.Bis_Datum >= bAufko.Kond_Datum NO-ERROR.
        IF AVAILABLE bSpPrRab THEN 
        DO:
            ASSIGN  
                tAufSpRab.Auf_Proz_Betr = bSpPrRab.Auf_Proz_Betr
                tAufSpRab.Auf_Wert      = bSpPrRab.Auf_Wert.
        END.
        ELSE 
        DO:
            FOR EACH tAufze
                WHERE tAufze.Firma      = bAufko.Firma
                AND   tAufze.Aufnr      = bAufko.Aufnr
                AND   tAufze.Auf_Sp_Grp = tAufSpRab.Rab_Grp:
                ASSIGN  
                    tAufze.Auf_Sp_Rab  = 0
                    tAufze.Auf_Sp_Wert = 0.
            END.
        END.
    END.
    
    FOR EACH tAufSpRab:
        FIND bAufSpRab OF tAufSpRab NO-ERROR.
        IF NOT AVAILABLE bAufSpRab THEN 
        DO:
            CREATE  bAufSpRab.
            BUFFER-COPY tAufSpRab TO bAufSpRab.
        END.
        ELSE 
        DO:
            ASSIGN  
                bAufSpRab.Auf_Proz_Betr = tAufSpRab.Auf_Proz_Betr
                bAufSpRab.Auf_Wert      = tAufSpRab.Auf_Wert.
        END.
        RELEASE bAufSpRab.
    END.
    
    RELEASE bAufko   .
    RELEASE bSpPrRab .
    RELEASE bAufSpRab.
    
    RETURN TRUE.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-fillAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION fillAufze Procedure 
FUNCTION fillAufze RETURNS INTEGER
    ( INPUT-OUTPUT iphAufze AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE hAufze     AS HANDLE  NO-UNDO.
    DEFINE VARIABLE xx         AS INTEGER NO-UNDO.
    DEFINE VARIABLE iKnr       AS INTEGER NO-UNDO.
    DEFINE VARIABLE hFeldKnr   AS HANDLE  NO-UNDO.
    DEFINE VARIABLE dDatum     AS DATE    NO-UNDO.
    DEFINE VARIABLE hFeldDatum AS HANDLE  NO-UNDO.
    DEFINE VARIABLE iPos       AS INTEGER NO-UNDO.
    
    DEFINE BUFFER bArtst    FOR Artst   .
    DEFINE BUFFER bAufze    FOR Aufze   .
    DEFINE BUFFER bArtbez   FOR Artbez  .
    DEFINE BUFFER bWust     FOR Wust    .
    DEFINE BUFFER bMWStAns  FOR MWStAns .
    DEFINE BUFFER bKGebinde FOR KGebinde.
    DEFINE BUFFER bVGebinde FOR VGebinde.
    DEFINE BUFFER bGGebinde FOR GGebinde.
    DEFINE BUFFER bGebKonto FOR GebKonto.
    
    EMPTY TEMP-TABLE tAufze.
    CREATE tAufze.
    hAufze = TEMP-TABLE tAufze:DEFAULT-BUFFER-HANDLE.
    hAufze:BUFFER-COPY(iphAufze).

    hFeldKnr = iphAufze:BUFFER-FIELD('Knr') NO-ERROR.
    IF VALID-HANDLE ( hFeldKnr ) THEN iKnr = hFeldKnr:BUFFER-VALUE(0).
    ELSE                              iKnr = 0.
    hFeldDatum = iphAufze:BUFFER-FIELD('Datum') NO-ERROR.
    IF VALID-HANDLE ( hFeldDatum ) THEN dDatum = hFeldDatum:BUFFER-VALUE(0).
    ELSE                                dDatum = TODAY.
    DYNAMIC-FUNCTION('createAufkoParam':U, tAufze.Firma, tAufze.Aufnr, iKnr, dDatum ) NO-ERROR.
    
    FIND FIRST tParam.

    IF tAufze.Artnr > 0 THEN 
    DO:
        FIND bArtst NO-LOCK
            WHERE bArtst.Firma  = tAufze.Firma
            AND   bArtst.Artnr  = tAufze.Artnr
            AND   bArtst.Inhalt = tAufze.Inhalt
            AND   bArtst.Jahr   = tAufze.Jahr NO-ERROR.
        IF NOT AVAILABLE bArtst THEN RETURN 213.
        FIND bArtbez NO-LOCK
            WHERE bArtbez.Firma  = bArtst.Firma 
            AND   bArtbez.Artnr  = bArtst.Artnr
            AND   bArtbez.Inhalt = bArtst.Inhalt
            AND   bArtbez.Jahr   = bArtst.Jahr
            AND   bArtbez.Sprcd  = tParam.Sprcd NO-ERROR.
        IF NOT AVAILABLE bArtbez THEN 
        DO:
            FIND FIRST bArtbez NO-LOCK
                WHERE bArtbez.Firma  = bArtst.Firma 
                AND   bArtbez.Artnr  = bArtst.Artnr
                AND   bArtbez.Inhalt = bArtst.Inhalt
                AND   bArtbez.Jahr   = bArtst.Jahr NO-ERROR.
        END.
        IF NOT AVAILABLE bArtbez THEN RETURN 222.
    END.
    
    IF tAufze.Pos = 0 THEN 
    DO:
        FIND LAST bAufze NO-LOCK
            WHERE bAufze.Firma = tAufze.Firma
            AND   bAufze.Aufnr = tAufze.Aufnr NO-ERROR.
        IF AVAILABLE bAufze THEN iPos = bAufze.Pos + 5.
        ELSE                     iPos = 5.
        RELEASE bAufze.
        tAufze.Pos = iPos.
    END.
    
    ASSIGN  
        tAufze.MBest            = 0
        tAufze.MGeli            = 0
        tAufze.MRuek            = 0
        tAufze.MKumm            = 0
        tAufze.KGeb_Me          = 0
        tAufze.VGeb_Me          = 0
        tAufze.GGeb_Me          = 0
        tAufze.KGeb_Be          = 0
        tAufze.VGeb_Be          = 0
        tAufze.GGeb_Be          = 0
        tAufze.KGeb_Ru          = 0
        tAufze.VGeb_Ru          = 0
        tAufze.GGeb_Ru          = 0
        tAufze.Preis            = 0
        tAufze.Rab_Art          = 0
        tAufze.Rab_Wert         = 0
        tAufze.Rab_Betr         = 0
        tAufze.Zus_Art          = 0
        tAufze.Zus_Wert         = 0
        tAufze.Zus_Betr         = 0
        tAufze.Bru_Betr         = 0
        tAufze.Net_Betr         = 0
        tAufze.WC               = 0
        tAufze.Alk_Gehalt       = 0
        tAufze.Aktion           = FALSE
        tAufze.TrNr             = 0
        tAufze.Verbucht         = FALSE
        tAufze.Aktion_Text      = ''
        tAufze.Rab_Su_Grp       = 0
        tAufze.Rab_Su_Art       = 0
        tAufze.Liter            = 0
        tAufze.Gewicht          = 0
        tAufze.Auf_Rab          = 0
        tAufze.Abh_Rab          = 0
        tAufze.KGebKto          = ''
        tAufze.VGebKto          = ''
        tAufze.GGebKto          = ''
        tAufze.EP               = 0
        tAufze.Auf_Sp_Proz_Betr = TRUE
        tAufze.Auf_Sp_Wert      = 0
        tAufze.Auf_Sp_Rab       = 0
        tAufze.Auf_Sp_Grp       = 0
        tAufze.Frw              = tParam.Frw
        tAufze.Kurs             = tParam.Kurs
        tAufze.Faktor           = tParam.Faktor
        tAufze.Preis_Mut        = FALSE.

    IF tAufze.Artnr > 0 THEN 
    DO:        
        ASSIGN  
            tAufze.Bez1       = bArtbez.Bez1
            tAufze.Bez2       = (IF bArtbez.Bez2_Druck THEN bArtbez.Bez2 ELSE '' )
            tAufze.Rab_Art    = tParam.Zei_Rab_Art
            tAufze.Rab_Wert   = tParam.Zei_Rab_Wert
            tAufze.Zus_Art    = tParam.Zuschl_Art
            tAufze.Zus_Wert   = tParam.Zuschl_Wert
            tAufze.WC         = bArtst.MWST
            tAufze.Alk_Gehalt = bArtst.Alk_Gehalt
            tAufze.Aktion     = FALSE
            tAufze.Sk_Ber     = bArtst.Sk_Ber
            tAufze.Netto      = bArtst.Netto
            tAufze.Lager      = tParam.Lager
            tAufze.TrNr       = 0
            tAufze.Verbucht   = FALSE
            tAufze.KGeb_Cd    = bArtst.KGeb_Cd
            tAufze.VGeb_Cd    = bArtst.VGeb_Cd
            tAufze.GGeb_Cd    = bArtst.GGeb_Cd
            tAufze.Lag_Buch   = bArtst.Lager
            tAufze.lLotnr     = bArtst.lLotnr
            tAufze.lVerfall   = bArtst.lVerfall.
            
        IF bArtst.DEP <> 0      THEN tAufze.EP = bArtst.DEP.
        ELSE
            IF bArtst.LEP <> 0 THEN tAufze.EP = bArtst.LEP.
            ELSE                    tAufze.EP = bArtst.Listen_EP.
    
        IF bArtst.Netto THEN 
        DO:
            ASSIGN  
                tAufze.Rab_Art  = 0
                tAufze.Rab_Wert = 0.
        END.
    
        DO xx = 1 TO 10:
            tAufze.Zustext[xx] = bArtbez.Zustext[xx].
        END.
        FIND bWust NO-LOCK USE-INDEX Wust-k1
            WHERE bWust.CodeK = tParam.MWSt
            AND   bWust.CodeA = bArtst.MWSt NO-ERROR.
        tAufze.WuCd = bWust.WuCd.

        FIND LAST bMWSTAns NO-LOCK
            WHERE bMWSTAns.MWST_Cd  = tAufze.WuCd
            AND   bMWSTAns.Datum   <= tParam.Kond_Datum.
        tAufze.MWST%     = bMWSTAns.Ansatz.
        tAufze.MWST_Inkl = bWust.Incl.
    
        DO WHILE TRUE:
            FIND bKGebinde NO-LOCK 
                WHERE bKGebinde.Firma  = tAufze.Firma
                AND   bKGebinde.Geb_Cd = tAufze.KGeb_Cd NO-ERROR.
            IF NOT AVAILABLE bKGebinde THEN RETURN 1055.
            IF bKGebinde.Geb_Kto = ''  THEN LEAVE. 
            FIND bGebKonto NO-LOCK
                WHERE bGebKonto.Firma  = tAufze.Firma
                AND   bGebKonto.Geb_Cd = bKGebinde.Geb_Kto NO-ERROR.
            IF NOT AVAILABLE bGebKonto THEN RETURN 1060.
            tAufze.KGebKto = bGebKonto.Geb_Cd.
            LEAVE.
        END.
    
        DO WHILE TRUE:
            FIND bVGebinde NO-LOCK 
                WHERE bVGebinde.Firma  = tAufze.Firma
                AND   bVGebinde.Geb_Cd = tAufze.VGeb_Cd NO-ERROR.
            IF NOT AVAILABLE bVGebinde THEN RETURN 1056.
            IF bVGebinde.Geb_Kto = ''  THEN LEAVE. 
            FIND bGebKonto NO-LOCK
                WHERE bGebKonto.Firma  = tAufze.Firma
                AND   bGebKonto.Geb_Cd = bVGebinde.Geb_Kto NO-ERROR.
            IF NOT AVAILABLE bGebKonto THEN RETURN 1061.
            tAufze.VGebKto = bGebKonto.Geb_Cd.
            LEAVE.
        END.
    
        DO WHILE TRUE:
            FIND bGGebinde NO-LOCK 
                WHERE bGGebinde.Firma  = tAufze.Firma
                AND   bGGebinde.Geb_Cd = tAufze.GGeb_Cd NO-ERROR.
            IF NOT AVAILABLE bGGebinde THEN RETURN 1057.
            IF bGGebinde.Geb_Kto = ''  THEN LEAVE. 
            FIND bGebKonto NO-LOCK
                WHERE bGebKonto.Firma  = tAufze.Firma
                AND   bGebKonto.Geb_Cd = bGGebinde.Geb_Kto NO-ERROR.
            IF NOT AVAILABLE bGebKonto THEN RETURN 1062.
            tAufze.GGebKto = bGebKonto.Geb_Cd.
            LEAVE.
        END.
    
        DO WHILE TRUE:
            FIND RabTab NO-LOCK USE-INDEX RabTab-k1
                WHERE RabTab.Firma   = tAufze.Firma
                AND   RabTab.Ku_Rab  = tParam.Rab_Grp
                AND   RabTab.Art_Rab = bArtst.Rab_Grp NO-ERROR.
            IF NOT AVAILABLE RabTab THEN LEAVE.
            ASSIGN  
                tAufze.Rab_Su_Grp = RabTab.Rab_Summ
                tAufze.Rab_Su_Art = RabTab.Add_Art.
            LEAVE.
        END.
    END.
    iphAufze:BUFFER-COPY(hAufze).
    
    RELEASE bArtst   .
    RELEASE bArtbez  .
    RELEASE bKGebinde.
    RELEASE bVGebinde.
    RELEASE bGGebinde.
    RELEASE bGebKonto.
    RELEASE bWust    .
    RELEASE bMWStAns .

    RETURN 0.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getAbholSeite) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getAbholSeite Procedure 
FUNCTION getAbholSeite RETURNS INTEGER
    ( /* parameter-definitions */ ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    FIND Steuer USE-INDEX Steuer-k1
        WHERE Steuer.Firma = Firma NO-LOCK.
    RETURN Steuer.Fwi18.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getAufstatus) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getAufstatus Procedure 
FUNCTION getAufstatus RETURNS CHARACTER
    ( ipAufstatus AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    FIND Tabel NO-LOCK USE-INDEX Tabel-k2
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'AUFSTATUS'
        AND   Tabel.CodeI  = ipAufstatus
        AND   Tabel.CodeC  = ''
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN RETURN Tabel.Bez1.
    ELSE                    RETURN "??????????".

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
&IF DEFINED(EXCLUDE-getDokumentArt) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getDokumentArt Procedure 
FUNCTION getDokumentArt RETURNS CHARACTER
    ( ipFakart AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    FIND Tabel NO-LOCK USE-INDEX Tabel-k2
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'FAKART'
        AND   Tabel.CodeI  = ipFakart
        AND   Tabel.CodeC  = ''
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN RETURN Tabel.Bez2.
    ELSE                    RETURN "??????????".

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getEpProz_Betr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getEpProz_Betr Procedure 
FUNCTION getEpProz_Betr RETURNS LOGICAL
    ( ipFirma AS CHARACTER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOG INIT TRUE NO-UNDO.

    FIND Steuer NO-LOCK
        WHERE Steuer.Firma = ipFirma NO-ERROR.
    IF NOT AVAILABLE Steuer THEN RETURN lRetVal.
    
    lRetVal = (IF Steuer.Fwi09 = 0 THEN TRUE ELSE FALSE).
    RELEASE Steuer.

    RETURN lRetVal.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getFakart) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getFakart Procedure 
FUNCTION getFakart RETURNS CHARACTER
    ( ipFakart AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    FIND Tabel NO-LOCK USE-INDEX Tabel-k2
        WHERE Tabel.Firma  = Firma
        AND   Tabel.RecArt = 'FAKART'
        AND   Tabel.CodeI  = ipFakart
        AND   Tabel.CodeC  = ''
        AND   Tabel.Sprcd  = 1 NO-ERROR.
    IF AVAILABLE Tabel THEN RETURN Tabel.Bez1.
    ELSE                    RETURN "??????????".

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getHoReLagerId) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getHoReLagerId Procedure
FUNCTION getHoReLagerId RETURNS INTEGER 
    ( ipiArtnr AS INTEGER, ipiInhalt AS INTEGER, ipiJahr AS INTEGER, ipiLager AS INTEGER ):
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iRetVal AS INTEGER NO-UNDO INIT 0.

    IF NOT lHoReLager THEN 
    DO:
        iRetVal = INTEGER(STRING(ipiArtnr,'999999') + STRING(ipiInhalt,'9999') + STRING(ipiJahr)) NO-ERROR.
        IF ERROR-STATUS:ERROR THEN RETURN 0.
        RETURN iRetVal.
    END.
    
    FIND FIRST HoReLager NO-LOCK
        WHERE HoReLager.Firma  = Firma
        AND   HoReLager.Lager  = ipiLager
        AND   HoReLager.Art    = 1
        AND   HoReLager.Artnr  = ipiArtnr
        AND   HoReLager.Inhalt = ipiInhalt
        AND   HoReLager.Jahr   = ipiJahr NO-ERROR.
    IF NOT AVAILABLE HoReLager THEN 
    DO:
        FIND FIRST HoReLager NO-LOCK
            WHERE HoReLager.Firma  = Firma
            AND   HoReLager.Lager  = ipiLager
            AND   HoReLager.Art    = 1
            AND   HoReLager.Artnr  = ipiArtnr
            AND   HoReLager.Inhalt = ipiInhalt NO-ERROR.
    END.
    IF NOT AVAILABLE HoReLager THEN 
    DO:
        FIND FIRST HoReLager NO-LOCK
            WHERE HoReLager.Firma  = Firma
            AND   HoReLager.Lager  = ipiLager
            AND   HoReLager.Art    = 3
            AND   HoReLager.Artnr  = ipiArtnr
            AND   HoReLager.Inhalt = ipiInhalt
            AND   HoReLager.Jahr   = ipiJahr NO-ERROR.
    END.
    IF NOT AVAILABLE HoReLager THEN 
    DO:
        FIND FIRST HoReLager NO-LOCK
            WHERE HoReLager.Firma  = Firma
            AND   HoReLager.Lager  = ipiLager
            AND   HoReLager.Art    = 3
            AND   HoReLager.Artnr  = ipiArtnr
            AND   HoReLager.Inhalt = ipiInhalt NO-ERROR.
    END.
    
    IF AVAILABLE HoReLager THEN iRetVal = HoReLager.HoReLager_Id.
        
    RETURN iRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-getPreisAufze) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getPreisAufze Procedure 
FUNCTION getPreisAufze RETURNS INTEGER
    ( INPUT-OUTPUT iohtAufze AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE htAufze       AS HANDLE    NO-UNDO.
    DEFINE VARIABLE iMengeKond    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE nMengeBetr    AS DECIMAL   NO-UNDO.
    DEFINE VARIABLE lRueckstand   AS LOG       NO-UNDO.
    DEFINE VARIABLE lKeineAktion  AS LOG       NO-UNDO.
    DEFINE VARIABLE iKuPreisGrp   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iFwPreisGrp   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iAbPreisGrp   AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iPreisGrp     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iSpezPreis    AS INTEGER   NO-UNDO.
    DEFINE VARIABLE lAbweich      AS LOG       NO-UNDO.
    DEFINE VARIABLE lRabAufNetto  AS LOG       NO-UNDO.
    DEFINE VARIABLE lAktAufSpezPr AS LOG       INIT FALSE NO-UNDO.
    DEFINE VARIABLE lAktion       AS LOG       INIT FALSE NO-UNDO.
    DEFINE VARIABLE lNettoArtikel AS LOG       NO-UNDO.
    DEFINE VARIABLE nNormalPreis  AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE iAktionen     AS INTEGER   NO-UNDO.
    /*  0 = Keine Aktionen, wenn Spezpreis oder Spezrabgruppe   */
    /*  1 = Aktionen auch bei SpezPreisen                       */
    /*  2 = Aktionen auch bei SpezRabAufRabgruppen              */
    /*  3 = Immer Aktionen berücksichtigen                      */
    DEFINE VARIABLE iAktGrp       AS INTEGER   NO-UNDO.
    /*  Kundengruppe oder Preisgruppe (eventuell abweichend)    */
    /*  welche für die Aktionspreisermittlung verwendet wird    */
    DEFINE VARIABLE iAktKuPr_Grp  AS INTEGER   NO-UNDO.
    /*  0 = Preisgruppen    */
    /*  1 = Kundengruppen   */
    DEFINE VARIABLE cAktiontext   AS CHARACTER NO-UNDO.
    DEFINE VARIABLE ii            AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iKnr          AS INTEGER   NO-UNDO.
    DEFINE VARIABLE dDatum        AS DATE      NO-UNDO.
    DEFINE VARIABLE hFeldKnr      AS HANDLE    NO-UNDO.
    DEFINE VARIABLE hFeldDatum    AS HANDLE    NO-UNDO.
    DEFINE VARIABLE hbArtst       AS HANDLE    NO-UNDO.

    /* DEFINE BUFFER bAufko    FOR Aufko   . */
    DEFINE BUFFER bArtst    FOR Artst   .
    DEFINE BUFFER bAbwPrGrp FOR AbwPrGrp.
    DEFINE BUFFER bRabTab   FOR RabTab  .
    DEFINE BUFFER bRabSumm  FOR RabSumm .
    DEFINE BUFFER bSpezPrei FOR SpezPrei.
    DEFINE BUFFER bSpPrRab  FOR SpPrRab .
    DEFINE BUFFER bAktKeine FOR AktKeine.
    DEFINE BUFFER bWust     FOR Wust    .
    DEFINE BUFFER bArtPreis FOR ArtPreis.
    DEFINE BUFFER bAktPreis FOR AktPreis.
    DEFINE BUFFER bArtStaff FOR ArtStaff.
    DEFINE BUFFER bMwstAns  FOR MwstAns .
    /*  0 = Normalpreis                              */
    /*  1 = manueller Preis                          */
    /*  2 = EP+ - Preis                              */
    /*  3 = Kundenspezialpreis auf Artikel           */
    /*  4 = Spezialrabatt auf Artikel_Rabattgruppe   */
    /*  5 = Aktionspreis ohne Abweichende Preisgruppe*/
    /*  6 = Aktionspreis mit abweichender Preisgruppe*/
    /*  7 = Preis aus Summengruppe                   */

    EMPTY TEMP-TABLE tAufze.
    CREATE  tAufze.
    htAufze = TEMP-TABLE tAufze:DEFAULT-BUFFER-HANDLE.
    htAufze:BUFFER-COPY(iohtAufze) NO-ERROR.
    
    hFeldKnr = iohtAufze:BUFFER-FIELD('Knr') NO-ERROR.
    IF VALID-HANDLE ( hFeldKnr ) THEN iKnr = hFeldKnr:BUFFER-VALUE(0).
    ELSE                              iKnr = 0.
    hFeldDatum = iohtAufze:BUFFER-FIELD('Datum') NO-ERROR.
    IF VALID-HANDLE ( hFeldDatum ) THEN dDatum = hFeldDatum:BUFFER-VALUE(0).
    ELSE                                dDatum = TODAY.
    DYNAMIC-FUNCTION('createAufkoParam':U, tAufze.Firma, tAufze.Aufnr, iKnr, dDatum ) NO-ERROR.
    FIND FIRST tParam.

    lRueckstand  = DYNAMIC-FUNCTION('isMakeRueckstand':U)    NO-ERROR.
    lRabAufNetto = (IF DYNAMIC-FUNCTION('getFWNettoRab':U) = 0 THEN TRUE ELSE FALSE).
    iAktionen    = DYNAMIC-FUNCTION('getFWAktionsrab':U)     NO-ERROR.
    iAktKuPr_Grp = DYNAMIC-FUNCTION('getFWAktionspreise':U)  NO-ERROR.

    IF NOT lRueckstand THEN 
    DO:
        ASSIGN  
            tAufze.GGeb_Be = tAufze.GGeb_Me
            tAufze.VGeb_Be = tAufze.VGeb_Me
            tAufze.KGeb_Be = tAufze.KGeb_Me
            tAufze.MBest   = tAufze.MGeli
            tAufze.GGeb_Ru = 0
            tAufze.VGeb_Ru = 0
            tAufze.KGeb_Ru = 0
            tAufze.MRuek   = 0.
    END.
    ELSE 
    DO:
        ASSIGN  
            tAufze.GGeb_Ru = tAufze.GGeb_Be - tAufze.GGeb_Me
            tAufze.VGeb_Ru = tAufze.VGeb_Be - tAufze.VGeb_Me
            tAufze.KGeb_Ru = tAufze.KGeb_Be - tAufze.KGeb_Me
            tAufze.MRuek   = tAufze.KGeb_Ru.
    END.

    iMengeKond = ABS(tAufze.MBest).
    nMengeBetr = tAufze.MGeli.
    iSpezPreis = 0.

    EMPTY TEMP-TABLE tPreis.

    /* FIND bAufko NO-LOCK OF tAufze. */

    FIND bArtst NO-LOCK
        WHERE bArtst.Firma  = tAufze.Firma
        AND   bArtst.Artnr  = tAufze.Artnr
        AND   bArtst.Inhalt = tAufze.Inhalt
        AND   bArtst.Jahr   = tAufze.Jahr.
    lNettoArtikel = bArtst.Netto.
    hbArtst       = BUFFER bArtst:HANDLE.
    FIND bWust NO-LOCK
        WHERE bWust.CodeK = tParam.Mwst
        AND   bWust.CodeA = bArtst.Mwst.
    FIND LAST bMwstAns NO-LOCK
        WHERE bMwstAns.Mwst_Cd  = bWust.WuCd
        AND   bMwstAns.Datum   <= tParam.Kond_Datum NO-ERROR.
    ASSIGN  
        tAufze.WC        = bWust.CodeA
        tAufze.WuCd      = bWust.Wucd
        tAufze.MWST_Inkl = bWust.Incl
        tAufze.Mwst%     = (IF AVAILABLE bMwstAns THEN bMwstAns.Ansatz ELSE 0.0).
        
    FIND bWust NO-LOCK
        WHERE bWust.CodeK   = tParam.Mwst
        AND   bWust.CodeA   = 99.

    /*  --------------------------------------------------------------  */
    /*  Aktionspreise auf dieser Warengruppe möglich ?                  */
    /*  --------------------------------------------------------------  */
    FIND bAktKeine NO-LOCK
        WHERE bAktKeine.Firma  = tParam.Firma
        AND   bAktKeine.Knr    = tParam.Knr
        AND   bAktKeine.Wgr    = bArtst.Wg_Grp NO-ERROR.
    IF AVAILABLE bAktKeine THEN lKeineAktion = TRUE.
    ELSE                        lKeineAktion = FALSE.

    /*  --------------------------------------------------------------  */
    /*  Zu berücksichtigende Preisgruppe ermitteln                      */
    /*  --------------------------------------------------------------  */
    iKuPreisGrp = tParam.Preis_Grp.
    iFwPreisGrp = DYNAMIC-FUNCTION('getFwPreisgrp':U) NO-ERROR.
    lAbweich    = FALSE.
    FIND bAbwPrGrp NO-LOCK
        WHERE bAbwPrGrp.Firma  = tParam.Firma
        AND   bAbwPrGrp.Knr    = tParam.Knr
        AND   bAbwPrGrp.Wg_Grp = bArtst.Wg_Grp NO-ERROR.
    IF AVAILABLE bAbwPrGrp THEN 
    DO:
        iAbPreisGrp = bAbwPrGrp.Preis_Grp.
        lAbweich    = TRUE.
    END.
    IF lAbweich THEN iPreisGrp = iAbPreisGrp.
    ELSE             iPreisGrp = iKuPreisGrp.
    iAktGrp = (IF iAktKuPr_Grp = 0 THEN iPreisGrp ELSE tParam.Ku_Grp).

    /*  --------------------------------------------------------------  */
    /*  Normalpreis / Staffelpreis ermitteln                            */
    /*  --------------------------------------------------------------  */
    nNormalPreis = -1.0.
    ii           = (IF lAbweich THEN 0 ELSE 1).

    DO WHILE TRUE:
        ii = ii + 1.
        FIND LAST bArtPreis NO-LOCK
            WHERE bArtPreis.Firma      = tAufze.Firma
            AND   bArtPreis.Artnr      = tAufze.Artnr
            AND   bArtPreis.Inhalt     = tAufze.Inhalt
            AND   bArtPreis.Jahr       = tAufze.Jahr
            AND   bArtPreis.Preis_Grp  = iPreisGrp
            AND   bArtPreis.Aktion     = FALSE
            AND   bArtPreis.Ab_Datum  <= tParam.Kond_Datum NO-ERROR.
        IF NOT AVAILABLE bArtPreis THEN 
        DO:
            IF ii = 1 THEN 
            DO:
                iPreisGrp = iKuPreisGrp.
                NEXT.
            END.
            IF ii = 2 THEN 
            DO:
                iPreisGrp = iFwPreisGrp.
                NEXT.
            END.
            LEAVE.
        END.
        IF AVAILABLE bArtPreis THEN nNormalPreis = (IF bWust.Incl THEN bArtPreis.VK_Brutto ELSE bArtPreis.VK_Netto).

        FIND LAST bArtStaff NO-LOCK
            WHERE bArtStaff.Firma      = bArtPreis.Firma
            AND   bArtStaff.Artnr      = bArtPreis.Artnr
            AND   bArtStaff.Inhalt     = bArtPreis.Inhalt
            AND   bArtStaff.Jahr       = bArtPreis.Jahr
            AND   bArtStaff.Preis_Grp  = bArtPreis.Preis_Grp
            AND   bArtStaff.Ab_Datum   = bArtPreis.Ab_Datum
            AND   bArtStaff.Menge     <= INTEGER(iMengeKond) NO-ERROR.
        IF NOT AVAILABLE bArtStaff THEN LEAVE.

        nNormalPreis = (IF bWust.Incl THEN bArtStaff.VK_Brutto ELSE bArtStaff.VK_Netto).
        LEAVE.
    END.

    A000:
    REPEAT ON ERROR UNDO, LEAVE:
        IF nNormalPreis < 0.0 THEN LEAVE.
        /*  --------------------------------------------------------------  */
        /*  Summengruppe ermitteln                                          */
        /*  --------------------------------------------------------------  */
        ASSIGN  
            tAufze.Rab_Su_Grp       = 0
            tAufze.Rab_Su_Art       = 0
            tAufze.Auf_Sp_Proz_Betr = TRUE
            tAufze.Auf_Sp_Wert      = 0
            tAufze.Auf_Sp_Rab       = 0
            tAufze.Auf_Sp_Grp       = 0.

        FIND bRabTab NO-LOCK
            WHERE bRabTab.Firma   = tAufze.Firma
            AND   bRabTab.Ku_Rab  = tParam.Rab_Grp
            AND   bRabTab.Art_Rab = bArtst.Rab_Grp NO-ERROR.
        IF AVAILABLE bRabTab THEN 
        DO:
            IF bRabTab.Rab_Summ > 0 THEN 
            DO:
                FIND FIRST bRabSumm NO-LOCK
                    WHERE bRabSumm.Firma    = bRabTab.Firma
                    AND   bRabSumm.Rab_Summ = bRabTab.Rab_Summ NO-ERROR.
                IF AVAILABLE bRabSumm THEN 
                DO:
                    ASSIGN  
                        tAufze.Rab_Su_Grp = bRabTab.Rab_Summ
                        tAufze.Rab_Su_Art = bRabTab.Add_Art.
                END.
            END.
            IF  bRabTab.Wert    > 0 AND
                bRabTab.Rab_Art = 1 THEN 
            DO:
                CREATE  tPreis.
                ASSIGN  
                    tPreis.iArt     = 7
                    tPreis.Preis    = nNormalPreis
                    tPreis.Rab_Proz = (IF bRabTab.Proz_Betr THEN bRabTab.Wert ELSE 0)
                    tPreis.Rab_Wert = (IF bRabTab.Proz_Betr THEN 0 ELSE bRabTab.Wert)
                    tPreis.Spe_Proz = 0
                    tPreis.Spe_Wert = 0
                    tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
                    tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).
            END.
        END.
        
        /*  --------------------------------------------------------------  */
        /*  Manuelle Preiseingabe                                           */
        /*  --------------------------------------------------------------  */
        IF tAufze.Preis_Mut THEN 
        DO:
            DYNAMIC-FUNCTION('createManuellerPreis':U) NO-ERROR.
            LEAVE A000.
        END.
        
        /*  --------------------------------------------------------------  */
        /*      Kunde hat Ep + Zuschlag als Preis                           */
        /*  --------------------------------------------------------------  */
        IF tAufze.Rab_Art = 3 THEN 
        DO:
            DYNAMIC-FUNCTION('createEpPreis':U, hbArtst ) NO-ERROR.
            LEAVE A000.
        END.
        
        /*  --------------------------------------------------------------  */
        /*  Normalpreis / Staffelpreis                                      */
        /*  --------------------------------------------------------------  */
        CREATE  tPreis.
        ASSIGN  
            tPreis.iArt     = 0
            tPreis.Preis    = nNormalPreis
            tPreis.Rab_Proz = 0
            tPreis.Rab_Wert = 0
            tPreis.Spe_Proz = 0
            tPreis.Spe_Wert = 0
            tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
            tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).
        IF nNormalPreis = 0 THEN LEAVE.
         
        CASE tParam.Zei_Rab_Art:
            WHEN 1 THEN 
                ASSIGN 
                    tPreis.Rab_Proz = + tParam.Zei_Rab_Wert.
            WHEN 2 THEN 
                ASSIGN 
                    tPreis.Rab_Wert = + tParam.Zei_Rab_Wert.
            WHEN 3 THEN 
                ASSIGN 
                    tPreis.Rab_Proz = - tParam.Zei_Rab_Wert.
        END CASE.
        
        /*  --------------------------------------------------------------  */
        /*      Kundenspezialpreis auf Artikel                              */
        /*  --------------------------------------------------------------  */
        DO WHILE TRUE:
            FIND LAST bSpezPrei NO-LOCK
                WHERE bSpezPrei.Firma      = tAufze.Firma
                AND   bSpezPrei.Knr        = tParam.Knr
                AND   bSpezPrei.Artnr      = tAufze.Artnr
                AND   bSpezPrei.Inhalt     = tAufze.Inhalt
                AND   bSpezPrei.Jahr       = tAufze.Jahr
                AND   bSpezPrei.Menge     <= iMengeKond
                AND   bSpezPrei.Ab_Datum  <= tParam.Kond_Datum
                AND   bSpezPrei.Bis_Datum >= tParam.Kond_Datum NO-ERROR.
            IF NOT AVAILABLE bSpezPrei THEN LEAVE.
            
            IF  lNettoArtikel        AND
                NOT bSpezPrei.lNetto AND
                bSpezPrei.Proz_Betr  THEN 
            DO:
                RELEASE bSpezPrei.
                LEAVE.
            END. 

            CREATE  tPreis.
            ASSIGN  
                tPreis.iArt     = 3
                tPreis.Preis    = 0
                tPreis.Rab_Proz = 0
                tPreis.Rab_Wert = 0
                tPreis.Spe_Proz = 0
                tPreis.Spe_Wert = 0
                tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
                tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).
            IF bSpezPrei.Proz_Betr THEN ASSIGN tPreis.Rab_Proz = bSpezPrei.Wert
                    tPreis.Preis    = nNormalPreis.
            ELSE                        ASSIGN tPreis.Preis    = bSpezPrei.Wert
                    tPreis.Rab_Proz = 0.

            IF NOT lSummGrpSpPr THEN 
            DO:
                ASSIGN  
                    tAufze.Rab_Su_Grp = 0
                    tAufze.Rab_Su_Art = 0.
            END.
            ASSIGN  
                iSpezPreis    = 1
                lAktAufSpezPr = bSpezPrei.lAktion.
            RELEASE bSpezPrei.
            LEAVE.
        END.
        
        /*  --------------------------------------------------------------  */
        /*      Kundenspezialpreis auf Artikel-Rabattgruppe (Zeilenrabatt)  */
        /*      Nur wenn nicht schon Spezialpreis auf Artikel               */
        /*  --------------------------------------------------------------  */
        DO WHILE iSpezPreis = 0 :   /*  Kein Spezialpreis auf Artikel   */
            ASSIGN  
                tAufze.Auf_Sp_Grp  = 0
                tAufze.Auf_Sp_Rab  = 0
                tAufze.Auf_Sp_Wert = 0.
                
            FIND FIRST bSpPrRab NO-LOCK
                WHERE bSpPrRab.Firma      = tAufze.Firma
                AND   bSpPrRab.Knr        = tParam.Knr
                AND   bSpPrRab.Rab_Grp    = bArtst.Rab_Grp
                AND   bSpPrRab.Ab_Datum  <= tParam.Kond_Datum
                AND   bSpPrRab.Bis_Datum >= tParam.Kond_Datum NO-ERROR.
            IF NOT AVAILABLE bSpPrRab THEN LEAVE.

            FIND LAST bSpPrRab NO-LOCK
                WHERE bSpPrRab.Firma      = tAufze.Firma
                AND   bSpPrRab.Knr        = tParam.Knr
                AND   bSpPrRab.Rab_Grp    = bArtst.Rab_Grp
                AND   bSpPrRab.Menge     <= iMengeKond
                AND   bSpPrRab.Ab_Datum  <= tParam.Kond_Datum
                AND   bSpPrRab.Bis_Datum >= tParam.Kond_Datum NO-ERROR.
            IF NOT AVAILABLE bSpPrRab THEN LEAVE. 

            IF  lNettoArtikel       AND
                NOT bSpPrRab.lNetto THEN LEAVE.
                
            ASSIGN  
                tAufze.Auf_Sp_Grp = bSpPrRab.Rab_Grp. 
            CREATE  tPreis.
            ASSIGN  
                tPreis.iArt     = 4
                tPreis.Preis    = nNormalPreis
                tPreis.Rab_Proz = 0
                tPreis.Rab_Wert = 0
                tPreis.Spe_Proz = 0
                tPreis.Spe_Wert = 0
                tPreis.Zus_Proz = (IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Wert ELSE 0)
                tPreis.Zus_Wert = (IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Wert ELSE 0).

            IF bSpPrRab.Proz_Betr THEN ASSIGN tPreis.Spe_Proz = bSpPrRab.Wert.
            ELSE                              tPreis.Spe_Wert = bSpPrRab.Wert.
                
            IF NOT lSummGrpSpPr THEN 
            DO:
                ASSIGN  
                    tAufze.Rab_Su_Grp = 0
                    tAufze.Rab_Su_Art = 0.
            END.
            ASSIGN  
                iSpezPreis    = 2
                lAktAufSpezPr = bSpPrRab.lAktion.
            RELEASE bSpPrRab.
            LEAVE.
        END.

        DO WHILE TRUE:
            /*  --------------------------------------------------------------  */
            /*      Aktionspreise                                               */
            /*  --------------------------------------------------------------  */
            IF  lKeineAktion      THEN LEAVE.                /*  Auf aktuelle Wgr gibt es keine Aktionen     */
            IF  iSpezPreis = 0    THEN lAktAufSpezPr = TRUE. /*  Kein Spezialpreis = immer Aktionen          */
            IF  iAktionen = 3     THEN lAktAufSpezPr = TRUE. /*  3 = es gibt immer Aktionspreis              */
            IF  iAktionen = 0     AND                        /*  Auf Spezialpreis nie Aktionen ausser bei    */
                NOT lAktAufSpezPr THEN LEAVE.                /*  Beim Kunden speziell zugelassen             */
            IF  iSpezPreis = 1    AND                        /*  Aktionen auf Artikel-Spezialpreise          */
                iAktionen  = 1    THEN lAktAufSpezPr = TRUE. 
            IF  iSpezPreis = 2    AND                        /*  Aktionen auf Artikel-Rabattgruppe           */
                iAktionen  = 2    THEN lAktAufSpezPr = TRUE. 

            IF NOT lAktAufSpezPr THEN LEAVE.
            
            hFeld = htAufze:BUFFER-FIELD('lAktion') NO-ERROR.
            IF VALID-HANDLE(hFeld) THEN
            DO:
                IF hFeld:BUFFER-VALUE BEGINS 'n' THEN
                DO:
                    lAktion = FALSE.
                    LEAVE.
                END.
            END.
            lAktion = DYNAMIC-FUNCTION('createAktionsPreis':U, iAktGrp, lAbweich, iAktKuPr_Grp, iKuPreisGrp ) NO-ERROR.
            IF lAktion THEN 
            DO:
                FIND FIRST tPreis
                    WHERE tPreis.iArt >= 5
                    AND   tPreis.iArt <= 6.
                cAktiontext = tPreis.cAkt_Text.
            END.
            LEAVE.
        END.
        
        LEAVE A000.
    END.

    ii = DYNAMIC-FUNCTION('setAufzePreis':U, iSpezPreis, lNettoArtikel, lRabAufNetto) NO-ERROR.
    FIND FIRST tAufze.
    iohtAufze:BUFFER-COPY(htAufze).

    /*     RELEASE bAufko   . */
    RELEASE bArtst   .
    RELEASE bAbwPrGrp.
    RELEASE bRabTab  .
    RELEASE bRabSumm .
    RELEASE bSpezPrei.
    RELEASE bSpPrRab .
    RELEASE bAktKeine.
    RELEASE bWust    .
    RELEASE bArtPreis.
    RELEASE bAktPreis. 
    RELEASE bArtStaff.
    RELEASE bMwstAns .

    RETURN ii.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getSummGrpSpPr) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getSummGrpSpPr Procedure 
FUNCTION getSummGrpSpPr RETURNS LOGICAL
    ( ipFirma AS CHARACTER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOG INIT FALSE NO-UNDO.

    FIND Steuer NO-LOCK
        WHERE Steuer.Firma = ipFirma NO-ERROR.
    IF NOT AVAILABLE Steuer THEN RETURN lRetVal.
    
    lRetVal = (IF Steuer.Fwi24 = 0 THEN FALSE ELSE TRUE).
    RELEASE Steuer.

    RETURN lRetVal.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-GET_ABH_AUFNR) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION GET_ABH_AUFNR Procedure 
FUNCTION GET_ABH_AUFNR RETURNS INTEGER
    ( /* parameter-definitions */ ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    RETURN AbhAufnr.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-getVerbuchtTotale) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION getVerbuchtTotale Procedure
FUNCTION getVerbuchtTotale RETURNS CHARACTER  
    ( ipcFirma AS CHARACTER, ipiAufnr AS INTEGER, OUTPUT opnTotal AS DECIMAL EXTENT 15 ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lJa         AS LOG       NO-UNDO.
    DEFINE VARIABLE VWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE VWust       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE NWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE TWpfl       AS DECIMAL   DECIMALS 4 EXTENT 12 NO-UNDO.
    DEFINE VARIABLE VFakt       AS INTEGER   EXTENT 12 NO-UNDO.
    DEFINE VARIABLE NFakt       AS INTEGER   NO-UNDO.
    DEFINE VARIABLE VTotWu      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VTotNK      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VResNK      AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VMaxWC      AS INTEGER   NO-UNDO.
    DEFINE VARIABLE iRecid      AS RECID     NO-UNDO.
    DEFINE VARIABLE VGewicht    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE zz          AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Wert        AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VSkonto     AS DECIMAL   INIT 0 NO-UNDO.
    DEFINE VARIABLE Rundbetr    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE nMenge      AS DECIMAL   NO-UNDO.
    DEFINE VARIABLE cResult     AS CHARACTER NO-UNDO.
    DEFINE VARIABLE dMwstDat    AS DATE      NO-UNDO.
    DEFINE VARIABLE nKredLimite AS DECIMAL   INIT 0.00 NO-UNDO.
    DEFINE VARIABLE nAufTotal   AS DECIMAL   INIT 0.00 NO-UNDO.
    DEFINE VARIABLE htSavze     AS HANDLE    NO-UNDO.

    DEFINE BUFFER bSavze FOR Savze.
    DEFINE BUFFER FDebst FOR Debst.

    /* ------------------------------------------------------------------------- */
    /* opnTotal[01] = Nettowarenwert                                             */
    /* opnTotal[02] = Skontoberechtigter Betrag                                  */
    /* opnTotal[03] = Nebenkosten                                                */
    /* opnTotal[04] = Transport                                                  */
    /* opnTotal[05] = Porto                                                      */
    /* opnTotal[06] = Verpackung                                                 */
    /* opnTotal[07] = Total Mehrwertsteuerpflichtig                              */
    /* opnTotal[08] = Total Mehrwertsteuerfrei                                   */
    /* opnTotal[09] = Total Mehrwertsteuer                                       */
    /* opnTotal[10] = Total Auftrag                                              */
    /* opnTotal[11] = Total Gebinde                                              */
    /* opnTotal[12] = Total Gebühren (Receycling)                                */
    /* ------------------------------------------------------------------------- */

    REPEAT TRANSACTION:
        opnTotal = 0.
        VWpfl    = 0.
        VWust    = 0.
        VTotWu   = 0.
        VTotNK   = 0.
        NWpfl    = 0.     /*  Anteil Nebenkosten  */
        TWpfl    = 0.     /*  Wpfl + Nebenkosten  */
        VGewicht = 0.

        DISABLE TRIGGERS FOR LOAD OF Savko.

        FIND Steuer NO-LOCK USE-INDEX Steuer-k1
            WHERE Steuer.Firma = ipcFirma.

        FIND Savko EXCLUSIVE-LOCK
            WHERE Savko.Firma  = ipcFirma
            AND   Savko.Aufnr  = ipiAufnr NO-WAIT NO-ERROR.
        IF LOCKED Savko        THEN RETURN 'LOCKED'.
        IF NOT AVAILABLE Savko THEN RETURN 'FEHLEND'.
        iRecid   = RECID(Savko).
        dMwstDat = (IF Savko.Fak_Datum <> ? THEN Savko.Fak_Datum ELSE Savko.Kond_Datum).
        IF dMwstDat = ? THEN dMwstDat = Savko.Lief_Datum.
        IF dMwstDat = ? THEN dMwstDat = TODAY.
    
        FIND FDebst NO-LOCK
            WHERE FDebst.Firma = Savko.Firma
            AND   FDebst.Knr   = Savko.Fak_Knr.
        nKredLimite = FDebst.Kred_Lim.
        nAufTotal   = FDebst.Saldo.

        opnTotal[04] = Savko.Transp.
        opnTotal[05] = Savko.Porto.
        opnTotal[06] = Savko.Verpack.
        opnTotal[03] = opnTotal[04] + opnTotal[05] + opnTotal[06].

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Savko.MWST
            AND   Wust.CodeA = Steuer.Fwi03   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Savko.Transp.

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Savko.MWST
            AND   Wust.CodeA = Steuer.Fwi04   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Savko.Porto.

        FIND Wust USE-INDEX Wust-k1
            WHERE Wust.CodeK = Savko.MWST
            AND   Wust.CodeA = Steuer.Fwi05   NO-LOCK.
        zz        = Wust.WuCd.
        VWpfl[zz] = VWpfl[zz] + Savko.Verpack.

        zz  = 0.
        lJa = FALSE.
        EMPTY TEMP-TABLE tSavze.
        FOR EACH Savze NO-LOCK
            WHERE Savze.Firma = Savko.Firma
            AND   Savze.Aufnr = Savko.Aufnr
            AND   Savze.Artnr > 0    :
            CREATE  tSavze.
            BUFFER-COPY Savze TO tSavze.
        END.

        FOR EACH tSavze:

            zz = tSavze.WuCd.
            IF Savko.Auf_Sta < 2 THEN nMenge = tSavze.MBest.
            ELSE                      nMenge = tSavze.MGeli.
            nMenge = tSavze.MGeli.

            DO WHILE TRUE:
                ASSIGN  
                    tSavze.Auf_Rab = 0
                    tSavze.Abh_Rab = 0.
                IF tSavze.Rab_Su_Grp = 0 THEN LEAVE.
                IF tSavze.Rab_Su_Art = 0 THEN LEAVE.

                FIND SavRabSu NO-LOCK
                    WHERE SavRabSu.Firma    = tSavze.Firma
                    AND   SavRabSu.Aufnr    = tSavze.Aufnr
                    AND   SavRabSu.Rab_Summ = tSavze.Rab_Su_Grp
                    AND   SavRabSu.MWST_Cd  = tSavze.WuCd.
                Wert = SavRabSu.F_Wert.
                DO WHILE Wert <> 0:
                    IF SavRabSu.F_Proz_Betr THEN 
                    DO:
                        tSavze.Auf_Rab = tSavze.Net_Betr * SavRabSu.F_Wert / 100.
                        LEAVE.
                    END.
                    IF SavRabSu.F_Art = 0 THEN 
                    DO:
                        tSavze.Auf_Rab = nMenge * SavRabSu.F_Wert.
                        LEAVE.
                    END.
                    IF SavRabSu.F_Art = 2 THEN 
                    DO:
                        tSavze.Auf_Rab = tSavze.Liter * SavRabSu.F_Wert / 100.
                        LEAVE.
                    END.
                    LEAVE.
                END.

                IF Savko.Abhol = FALSE THEN Wert = 0.
                ELSE                        Wert = SavRabSu.A_Wert.
                DO WHILE Wert <> 0:
                    IF SavRabSu.A_Proz_Betr THEN 
                    DO:
                        tSavze.Abh_Rab = tSavze.Net_Betr * SavRabSu.A_Wert / 100.
                        LEAVE.
                    END.
                    IF SavRabSu.A_Art = 0 THEN 
                    DO:
                        tSavze.Abh_Rab = nMenge * SavRabSu.A_Wert.
                        LEAVE.
                    END.
                    IF SavRabSu.A_Art = 2 THEN 
                    DO:
                        tSavze.Abh_Rab = tSavze.Liter * SavRabSu.A_Wert / 100.
                        LEAVE.
                    END.
                    LEAVE.
                END.

                DO WHILE TRUE:
                    IF  tSavze.Abh_Rab = 0    AND
                        tSavze.Auf_Rab = 0    THEN LEAVE.

                    FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
                        WHERE Wust.WuCd = zz.
                    IF Wust.Incl = TRUE THEN 
                    DO:
                        Rundbetr       = tSavze.Abh_Rab.
                        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
                        tSavze.Abh_Rab = Rundbetr.
                        Rundbetr       = tSavze.Auf_Rab.
                        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
                        tSavze.Auf_Rab = Rundbetr.
                    END.
                    LEAVE.
                END.
                RELEASE SavRabSu.
                LEAVE.
            END.

            VWpfl   [zz] = VWpfl   [zz] + tSavze.Net_Betr
                - tSavze.Auf_Rab
                - tSavze.Abh_Rab
                - tSavze.Auf_Sp_Rab.
            opnTotal[01] = opnTotal[01] + tSavze.Net_Betr
                - tSavze.Auf_Rab
                - tSavze.Abh_Rab
                - tSavze.Auf_Sp_Rab.
            IF tSavze.Sk_Ber THEN 
            DO:
                opnTotal[02] = opnTotal[02] + tSavze.Net_Betr
                    - tSavze.Auf_Rab
                    - tSavze.Abh_Rab
                    - tSavze.Auf_Sp_Rab.
            END.
            VGewicht = VGewicht + tSavze.Gewicht.
        END.

        IF FDebst.Geb_Rg THEN 
        DO:
            FOR EACH SavGKon NO-LOCK USE-INDEX SavGKon-k1
                WHERE SavGKon.Firma = Savko.Firma
                AND   SavGKon.Aufnr = Savko.Aufnr :
                zz        = SavGKon.MWSt_Cd.
                VWpfl[zz] = VWpfl[zz] + SavGKon.Betrag.
                IF SavGKon.Gebuehr = 0 THEN opnTotal[11] = opnTotal[11] + SavGKon.Betrag.
                ELSE                        opnTotal[12] = opnTotal[12] + SavGKon.Betrag.
            END.
        END.
        ELSE 
        DO:
            FOR EACH SavGKon NO-LOCK USE-INDEX SavGKon-k1
                WHERE SavGKon.Firma    = Savko.Firma
                AND   SavGKon.Aufnr    = Savko.Aufnr
                AND   SavGKon.Gebuehr <> 0.0
                AND   SavGKon.Betrag  <> 0.0 :
                zz        = SavGKon.MWSt_Cd.
                VWpfl[zz] = VWpfl[zz] + SavGKon.Betrag.
                opnTotal[12] = opnTotal[12] + SavGKon.Betrag.
            END.
        END.

        VMaxWC = 0.
        VTotNK = VWpfl[12].
        VResNK = VWpfl[12].
        DO zz = 1 TO 11:
            IF VWpfl[zz] < 0 THEN VFakt[zz] = -1.
            ELSE                  VFakt[zz] = +1.
            VTotWu = VTotWu + (VWpfl[zz] * VFakt[zz]).
            IF VWpfl[zz] <> 0 THEN VMaxWC = zz.
        END.
        NFakt  = +1.
        IF VTotNK < 0 THEN 
        DO:
            VTotNK = - VTotNK.
            VResNK = - VResNK.
            NFakt  = -1.
        END.

        DO zz = 1 TO 11:
            IF VWpfl[zz] = 0 THEN NEXT.
            IF zz = VMaxWC THEN 
            DO:
                NWpfl[zz] = VResNK * NFakt.
                TWpfl[zz] = VWpfl[zz] + (VResNK * NFakt).
                LEAVE.
            END.
            Rundbetr = (((VWpfl[zz] * 100 * VFakt[zz]) / VTotWu) * VTotNK) / 100.
            NWpfl[zz] = Rundbetr  * NFakt.
            TWpfl[zz] = VWpfl[zz] + (Rundbetr * NFakt).
            VResNK    = VResNK    - Rundbetr.
        END.

        DO zz = 1 TO 10:
            IF TWpfl[zz] = 0 THEN NEXT.

            opnTotal[07] = opnTotal[07] + TWpfl[zz].
            opnTotal[10] = opnTotal[10] + TWpfl[zz].

            FIND FIRST Wust USE-INDEX Wust-k2
                WHERE Wust.WuCd = zz NO-LOCK.
            IF Wust.Incl THEN NEXT.
            FIND LAST MWSTAns NO-LOCK USE-INDEX MWSTAns-k1
                WHERE MWSTAns.MWST_Cd  = Wust.WuCd
                AND   MWSTAns.Datum   <= dMwstDat .
            Rundbetr   = TWpfl[zz] * MWSTAns.Ansatz / 100.
            VWust [zz] = Rundbetr.
            opnTotal[09] = opnTotal[09] + Rundbetr.
            opnTotal[10] = opnTotal[10] + Rundbetr.
        END.

        opnTotal[08] = opnTotal[08] + TWpfl[11].
        opnTotal[10] = opnTotal[10] + TWpfl[11].
        Rundbetr   = opnTotal[10].
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        opnTotal[10] = Rundbetr.

        ASSIGN  
            nAufTotal = nAufTotal + Savko.Auf_Tot.
    
        LEAVE.

    END.

    RELEASE Savko.
    RELEASE Savze.
    RELEASE SavGKon.
    RELEASE SavSpRab.
    RELEASE SavRabSu.
    RELEASE Steuer.
    RELEASE Wust.
    RELEASE FDebst.
    
END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF


&IF DEFINED(EXCLUDE-isFestAuftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION isFestAuftrag Procedure 
FUNCTION isFestAuftrag RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipFak_Art AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    FIND FIRST Tabel NO-LOCK
        WHERE Tabel.Firma  = ipFirma
        AND   Tabel.RecArt = 'FAKART'
        AND   Tabel.CodeI  = ipFak_Art
        AND   Tabel.CodeC  = '' NO-ERROR.
    IF NOT AVAILABLE Tabel THEN RETURN FALSE.

    RETURN Tabel.Flag_1.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-setAufkoDruckFlag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION setAufkoDruckFlag Procedure 
FUNCTION setAufkoDruckFlag RETURNS LOGICAL
    ( ipFirma AS CHARACTER, ipAufnr AS INTEGER, ipFlag AS LOG ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE iSammNr AS INTEGER NO-UNDO.

    DEFINE BUFFER bAufko FOR Aufko.

    REPEAT TRANSACTION:
        FIND bAufko
            WHERE bAufko.Firma = ipFirma
            AND   bAufko.Aufnr = ipAufnr.
        bAufko.Gedruckt = ipFlag.
        IF bAufko.Gedruckt = FALSE THEN 
        DO:
            IF bAufko.Samm_Nr > 0 THEN 
            DO:
                iSammnr = bAufko.Samm_Nr.
                FOR EACH bAufko
                    WHERE bAufko.Firma    = ipFirma
                    AND   bAufko.Samm_Nr  = iSammNr
                    AND   bAufko.Gedruckt = TRUE:
                    bAufko.Gedruckt = FALSE.
                END.
            END.
        END.
        RELEASE bAufko.
        LEAVE.
    END.

    RETURN FALSE.   /* Function return value. */

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-setAufzePreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION setAufzePreis Procedure 
FUNCTION setAufzePreis RETURNS INTEGER
    ( ipiSpezPreis AS INTEGER, iplNettoArtikel AS LOG, iplRabAufNetto AS LOG ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE Rundbetr AS DECIMAL DECIMALS 4 NO-UNDO.

    FIND FIRST tAufze.
    
    IF ipiSpezPreis > 0 THEN 
    DO:
        FOR EACH tPreis:
            IF  tPreis.iArt < 3 OR
                tPreis.iArt > 6 THEN DELETE tPreis.
        END.
    END.
    
    /*  Kein Rabatt auf NettoArtikel ausser mit lRabAufNetto zugelassen  */
    /*  oder explizit auf SpezialRabtt wieder zugelassen                 */

    IF  iplNettoArtikel    AND
        NOT iplRabAufNetto THEN 
    DO:
        FOR EACH tPreis
            WHERE tPreis.iArt <> 2  /*  Ep + %-Zuschlag                 */
            AND   tPreis.iArt <> 3: /* Kundenspezialpreis auf Artikel   */
            ASSIGN  
                tPreis.Rab_Proz = 0
                tPreis.Rab_Wert = 0.
        END.
    END.

    FOR EACH tPreis BY tPreis.iArt:
        tPreis.Netto = tPreis.Preis.
        IF tPreis.Rab_Proz <> 0 THEN tPreis.Netto = tPreis.Preis * (100 - tPreis.Rab_Proz) / 100.
        IF tPreis.Rab_Wert <> 0 THEN tPreis.Netto = tPreis.Preis - tPreis.Rab_Wert.
        IF tPreis.Spe_Proz <> 0 THEN tPreis.Netto = tPreis.Preis * (100 - tPreis.Spe_Proz) / 100.
        IF tPreis.Spe_Wert <> 0 THEN tPreis.Netto = tPreis.Preis - tPreis.Spe_Wert.

        IF tPreis.Zus_Proz <> 0 THEN tPreis.Netto = tPreis.Netto + (tPreis.Preis * tPreis.Zus_Proz / 100).
        IF tPreis.Zus_Wert <> 0 THEN tPreis.Netto = tPreis.Netto + tPreis.Zus_Wert.
    END.

    FIND FIRST tPreis USE-INDEX tPreis-k1
        WHERE tPreis.Netto >= 0 NO-ERROR.

    DO WHILE TRUE:
        IF NOT AVAILABLE tPreis THEN 
        DO:
            ASSIGN  
                tAufze.Preis    = 0
                tAufze.Rab_Art  = 0
                tAufze.Rab_Wert = 0
                tAufze.Rab_Betr = 0
                tAufze.Bru_Betr = 0
                tAufze.Net_Betr = 0.
            LEAVE.
        END.
        ASSIGN  
            tAufze.Preis       = tPreis.Preis
            tAufze.Aktion      = (IF tPreis.cAkt_Text = '' THEN FALSE ELSE TRUE)
            tAufze.Aktion_Text = tPreis.cAkt_Text
            tAufze.Rab_Art     = 0
            tAufze.Zus_Art     = 0
            tAufze.Rab_Wert    = 0
            tAufze.Zus_Wert    = 0
            tAufze.Rab_Betr    = 0
            tAufze.Zus_Betr    = 0.
        IF tPreis.Rab_Proz > 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 1
                tAufze.Rab_Wert = + tPreis.Rab_Proz.
        IF tPreis.Rab_Proz < 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 3
                tAufze.Rab_Wert = - tPreis.Rab_Proz.
        IF tPreis.Rab_Wert > 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 2
                tAufze.Rab_Wert = + tPreis.Rab_Wert.
        IF tPreis.Spe_Proz > 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 1
                tAufze.Rab_Wert = + tPreis.Spe_Proz.
        IF tPreis.Spe_Proz < 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 1
                tAufze.Rab_Wert = + tPreis.Spe_Proz.
        IF tPreis.Spe_Wert > 0 THEN
            ASSIGN
                tAufze.Rab_Art  = 2
                tAufze.Rab_Wert = + tPreis.Spe_Wert.
        IF tPreis.Zus_Proz > 0 THEN
            ASSIGN
                tAufze.Zus_Art  = 1
                tAufze.Zus_Wert = + tPreis.Zus_Proz.
        IF tPreis.Zus_Proz < 0 THEN
            ASSIGN
                tAufze.Zus_Art  = 1
                tAufze.Zus_Wert = + tPreis.Zus_Proz.
        IF tPreis.Zus_Wert > 0 THEN
            ASSIGN
                tAufze.Zus_Art  = 2
                tAufze.Zus_Wert = + tPreis.Zus_Wert.
        IF tPreis.iArt = 2     THEN
            ASSIGN
                tAufze.Rab_Art = 3.     /*  Ep-Plus  */
        LEAVE.
    END.
    
    IF tAufze.Rab_Art = 1 THEN tAufze.Rab_Betr = tAufze.Preis * tAufze.Rab_Wert / 100.
    IF tAufze.Rab_Art = 2 THEN tAufze.Rab_Betr = tAufze.Rab_Wert      .
    IF tAufze.Rab_Art = 3 THEN 
    DO:
        IF lEpProzBetr THEN tAufze.Rab_Betr = tAufze.Preis * tAufze.Rab_Wert / 100 * -1.
        ELSE                tAufze.Rab_Betr = tAufze.Rab_Wert.
    END.
    IF tAufze.Zus_Art = 1 THEN tAufze.Zus_Betr = tAufze.Preis * tAufze.Zus_Wert / 100.
    IF tAufze.Zus_Art = 2 THEN tAufze.Zus_Betr = tAufze.Zus_Wert      .
    
    ASSIGN  
        tAufze.Rab_Betr = tAufze.Rab_Betr * tAufze.MGeli
        tAufze.Zus_Betr = tAufze.Zus_Betr * tAufze.MGeli.
                                               
    tAufze.Bru_Betr = tAufze.Preis    * tAufze.MGeli.
    tAufze.Net_Betr = tAufze.Bru_Betr - tAufze.Rab_Betr + tAufze.Zus_Betr.
    
    IF tAufze.Mwst_Inkl THEN 
    DO:
        Rundbetr = tAufze.Net_Betr.
        RUN RUNDEN ( INPUT 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Net_Betr = Rundbetr.
    END.
    
    RETURN (IF AVAILABLE tPreis THEN tPreis.iArt ELSE -1).

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF
&IF DEFINED(EXCLUDE-SET_ABH_AUFNR) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION SET_ABH_AUFNR Procedure 
FUNCTION SET_ABH_AUFNR RETURNS LOGICAL
    ( ipAufnr AS INTEGER ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    AbhAufnr = ipAufnr.

END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-_getPreis) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION _getPreis Procedure 
FUNCTION _getPreis RETURNS LOGICAL
    ( ipKnr AS INTEGER, ipDatum AS DATE, INPUT-OUTPUT iohAufze AS HANDLE ) :
    /*------------------------------------------------------------------------------*/
    /*      Purpose:                                                                */
    /*      Parameters:  <none>                                                     */
    /*      Notes:                                                                  */       
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE hBuffer      AS HANDLE    NO-UNDO.
    DEFINE VARIABLE Firma        AS CHARACTER NO-UNDO.
    DEFINE VARIABLE VPreis       AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VRab_Betr    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VRab_Proz    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VZus_Betr    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VZus_Proz    AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE Rundbetr     AS DECIMAL   DECIMALS 4 NO-UNDO.
    DEFINE VARIABLE VAktion      AS LOG       NO-UNDO.
    DEFINE VARIABLE VAktion_Text AS CHARACTER NO-UNDO.
    DEFINE VARIABLE VP_Grp       AS INTEGER   NO-UNDO.
    DEFINE VARIABLE VGrp         AS INTEGER   NO-UNDO.
    DEFINE VARIABLE NettoRab     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE Aktionen     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE PosMenge     AS INTEGER   NO-UNDO.
    DEFINE VARIABLE FAbweich     AS LOG       NO-UNDO.
    DEFINE VARIABLE KeineAkt     AS LOG       NO-UNDO.
    DEFINE VARIABLE FSpezPreis   AS INTEGER   NO-UNDO.
    /*  0 = Kein Spezialpreis               */
    /*  1 = Spezialpreis auf Artikel        */
    /*  2 = Spezialpreis auf Rabattgruppe   */
    DEFINE VARIABLE FwPreisGrp   AS INTEGER   NO-UNDO.

    EMPTY TEMP-TABLE tAufze.    
    CREATE  tAufze.
    hBuffer = TEMP-TABLE tAufze:DEFAULT-BUFFER-HANDLE.
    hBuffer:BUFFER-COPY(iohAufze).
    
    Firma = tAufze.Firma.
    FIND Steuer NO-LOCK
        WHERE Steuer.Firma = Firma NO-ERROR.
    ASSIGN  
        FwPreisGrp = Steuer.Fwi14
        Aktionen   = Steuer.Fwi20
        NettoRab   = Steuer.Fwi15
        PosMenge   = ABS(tAufze.MBest)
        .
    
    FIND Debst NO-LOCK
        WHERE Debst.Firma = Firma
        AND   Debst.Knr   = ipKnr NO-ERROR.
    IF NOT AVAILABLE Debst THEN RETURN FALSE.

    ASSIGN  
        tAufze.Rab_Art  = Debst.Zei_Rab_Art
        tAufze.Rab_Wert = Debst.Zei_Rab_Wert
        tAufze.Rab_Betr = 0
        tAufze.Zus_Art  = Debst.Zuschl_Art
        tAufze.Zus_Wert = Debst.Zuschl_Wert
        tAufze.Zus_Betr = 0
        tAufze.Bru_Betr = 0
        tAufze.Net_Betr = 0.
            
    FIND Artst NO-LOCK
        WHERE Artst.Firma  = Firma
        AND   Artst.Artnr  = tAufze.Artnr
        AND   Artst.Inhalt = tAufze.Inhalt
        AND   Artst.Jahr   = tAufze.Jahr NO-ERROR.
    IF NOT AVAILABLE Artst THEN RETURN FALSE.
            
    FIND Wust NO-LOCK USE-INDEX Wust-k1
        WHERE Wust.CodeK = Debst.MWST
        AND   Wust.CodeA = Artst.MWST NO-ERROR.
    tAufze.WuCd = Wust.WuCd.

    FIND FIRST Wust NO-LOCK USE-INDEX Wust-k2
        WHERE Wust.WuCd  = tAufze.WuCd NO-ERROR.
    FIND LAST MWSTAns NO-LOCK USE-INDEX MWSTAns-k1
        WHERE MWSTAns.MWST_Cd  = tAufze.WuCd
        AND   MWSTAns.Datum   <= ipDatum NO-ERROR.
    tAufze.MWST%     = MWSTAns.Ansatz.
    tAufze.MWST_Inkl = Wust.Incl.

    VPreis       = 0.
    VRab_Betr    = 0.
    VRab_Proz    = 0.
    VAktion      = FALSE.
    VAktion_Text = ''.
    VP_Grp       = 0.
    FAbweich     = FALSE.
    PosMenge     = ABS(tAufze.MBest).
    
    FIND AbwPrGrp USE-INDEX AbwPrGrp-k1
        WHERE AbwPrGrp.Firma  = Firma
        AND   AbwPrGrp.Knr    = ipKnr
        AND   AbwPrGrp.Wg_Grp = Artst.Wg_Grp NO-LOCK NO-ERROR.
    IF AVAILABLE AbwPrGrp THEN 
    DO:
        VP_Grp   = AbwPrGrp.Preis_Grp.
        FAbweich = TRUE.
    END.
    ELSE VP_Grp = Debst.Preis_Grp.
    
    IF Steuer.AktionsPreise = 0 THEN VGrp = VP_Grp.
    IF Steuer.AktionsPreise = 1 THEN VGrp = Debst.Ku_Grp.
    
    /*  --------------------------------------------------------------  */
    /*  Aktionspreise auf dieser Warengruppe möglich ?                  */
    /*  --------------------------------------------------------------  */
    FIND AktKeine NO-LOCK USE-INDEX AktKeine-k1
        WHERE AktKeine.Firma  = Firma
        AND   AktKeine.Knr    = ipKnr
        AND   AktKeine.Wgr    = Artst.Wg_Grp NO-ERROR.
    IF AVAILABLE AktKeine THEN KeineAkt = TRUE.
    ELSE                       KeineAkt = FALSE.

    DO WHILE TRUE:
        ASSIGN  
            tAufze.Rab_Su_Grp = 0
            tAufze.Rab_Su_Art = 0.
                
        FIND RabTab NO-LOCK USE-INDEX RabTab-k1
            WHERE RabTab.Firma   = Firma
            AND   RabTab.Ku_Rab  = Debst.Rab_Grp
            AND   RabTab.Art_Rab = Artst.Rab_Grp NO-ERROR.
        IF NOT AVAILABLE RabTab THEN LEAVE.
        ASSIGN  
            tAufze.Rab_Su_Grp = RabTab.Rab_Summ
            tAufze.Rab_Su_Art = RabTab.Add_Art.
                
        IF tAufze.Netto     THEN LEAVE.
        IF RabTab.Wert = 0  THEN LEAVE.
        
        IF RabTab.Rab_Art = 1 THEN 
        DO:
            tAufze.Rab_Wert  = RabTab.Wert.
            tAufze.Rab_Art   = (IF RabTab.Proz_Betr THEN 1 ELSE 2).
        END.
        LEAVE.
    END.

    DO WHILE TRUE:
        IF tAufze.Rab_Art = 3 THEN 
        DO:
            IF Artst.DEP       <> 0 THEN VPreis = Artst.DEP.
            IF Artst.LEP       <> 0 THEN VPreis = Artst.LEP.
            IF Artst.Listen_EP <> 0 THEN VPreis = Artst.Listen_EP.
            LEAVE.
        END.
        
        FIND LAST ArtPreis NO-LOCK USE-INDEX ArtPreis-k1
            WHERE ArtPreis.Firma      = Firma
            AND   ArtPreis.Artnr      = tAufze.Artnr
            AND   ArtPreis.Inhalt     = tAufze.Inhalt
            AND   ArtPreis.Jahr       = tAufze.Jahr
            AND   ArtPreis.Preis_Grp  = VP_Grp
            AND   ArtPreis.Aktion     = FALSE
            AND   ArtPreis.Ab_Datum  <= ipDatum NO-ERROR.
        DO WHILE TRUE:
            IF AVAILABLE ArtPreis THEN LEAVE.
            IF FAbweich THEN 
            DO:
                FIND LAST ArtPreis NO-LOCK USE-INDEX ArtPreis-k1
                    WHERE ArtPreis.Firma      = Firma
                    AND   ArtPreis.Artnr      = tAufze.Artnr
                    AND   ArtPreis.Inhalt     = tAufze.Inhalt
                    AND   ArtPreis.Jahr       = tAufze.Jahr
                    AND   ArtPreis.Preis_Grp  = Debst.Preis_Grp
                    AND   ArtPreis.Aktion     = FALSE
                    AND   ArtPreis.Ab_Datum  <= ipDatum NO-ERROR.
                IF AVAILABLE ArtPreis THEN LEAVE.
            END.
            FIND LAST ArtPreis NO-LOCK USE-INDEX ArtPreis-k1
                WHERE ArtPreis.Firma      = Firma
                AND   ArtPreis.Artnr      = tAufze.Artnr
                AND   ArtPreis.Inhalt     = tAufze.Inhalt
                AND   ArtPreis.Jahr       = tAufze.Jahr
                AND   ArtPreis.Preis_Grp  = FwPreisGrp
                AND   ArtPreis.Aktion     = FALSE
                AND   ArtPreis.Ab_Datum  <= ipDatum NO-ERROR.
            IF AVAILABLE ArtPreis THEN LEAVE.
            FIND FIRST ArtPreis NO-LOCK USE-INDEX ArtPreis-k1
                WHERE ArtPreis.Firma      = Firma
                AND   ArtPreis.Artnr      = tAufze.Artnr
                AND   ArtPreis.Inhalt     = tAufze.Inhalt
                AND   ArtPreis.Jahr       = tAufze.Jahr
                AND   ArtPreis.Preis_Grp  = VP_Grp
                AND   ArtPreis.Aktion     = FALSE
                AND   ArtPreis.Ab_Datum  >= ipDatum NO-ERROR.
            LEAVE.
        END.
        IF AVAILABLE ArtPreis THEN 
        DO:
            FIND LAST ArtStaff NO-LOCK USE-INDEX ArtStaff-k1
                WHERE ArtStaff.Firma      = ArtPreis.Firma
                AND   ArtStaff.Artnr      = ArtPreis.Artnr
                AND   ArtStaff.Inhalt     = ArtPreis.Inhalt
                AND   ArtStaff.Jahr       = ArtPreis.Jahr
                AND   ArtStaff.Preis_Grp  = ArtPreis.Preis_Grp
                AND   ArtStaff.Ab_Datum   = ArtPreis.Ab_Datum
                AND   ArtStaff.Menge     <= PosMenge NO-ERROR.
            IF AVAILABLE ArtStaff THEN 
            DO:
                IF Wust.Incl THEN VPreis = ArtStaff.VK_Brutto.
                ELSE              VPreis = ArtStaff.VK_Netto.
            END.
            ELSE 
            DO.
                IF Wust.Incl THEN VPreis = ArtPreis.VK_Brutto.
                ELSE              VPreis = ArtPreis.VK_Netto.
            END.
        END.

        FIND LAST SpezPrei NO-LOCK USE-INDEX SpezPrei-k1
            WHERE SpezPrei.Firma      = Firma
            AND   SpezPrei.Knr        = ipKnr
            AND   SpezPrei.Artnr      = tAufze.Artnr
            AND   SpezPrei.Inhalt     = tAufze.Inhalt
            AND   SpezPrei.Jahr       = tAufze.Jahr
            AND   SpezPrei.Menge     <= PosMenge
            AND   SpezPrei.Ab_Datum  <= ipDatum
            AND   SpezPrei.Bis_Datum >= ipDatum NO-ERROR.
        IF AVAILABLE SpezPrei THEN 
        DO:
            IF SpezPrei.Proz_Betr THEN 
            DO.
                VRab_Proz = SpezPrei.Wert.
                VRab_Betr = 0.
            END.
            ELSE 
            DO:
                VPreis    = SpezPrei.Wert.
                VRab_Betr = 0.
                VRab_Proz = 0.
            END.
            
            tAufze.Rab_Su_Grp = 0.
            tAufze.Rab_Su_Art = 0.
            FSpezPreis        = 1.
        END.

        DO WHILE TRUE:
            tAufze.Auf_Sp_Proz_Betr = TRUE.
            tAufze.Auf_Sp_Wert      = 0.
            tAufze.Auf_Sp_Rab       = 0.
            tAufze.Auf_Sp_Grp       = 0.
            IF FSpezPreis > 0 THEN LEAVE.

            FIND FIRST SpPrRab NO-LOCK USE-INDEX SpPrRab-k1
                WHERE SpPrRab.Firma      = Firma
                AND   SpPrRab.Knr        = ipKnr
                AND   SpPrRab.Rab_Grp    = Artst.Rab_Grp
                AND   SpPrRab.Ab_Datum  <= ipDatum
                AND   SpPrRab.Bis_Datum >= ipDatum NO-ERROR.
            IF AVAILABLE SpPrRab THEN 
            DO:
                tAufze.Auf_Sp_Grp = SpPrRab.Rab_Grp.
            END.

            FIND LAST SpPrRab NO-LOCK USE-INDEX SpPrRab-k1
                WHERE SpPrRab.Firma      = Firma
                AND   SpPrRab.Knr        = ipKnr
                AND   SpPrRab.Rab_Grp    = Artst.Rab_Grp
                AND   SpPrRab.Menge     <= PosMenge
                AND   SpPrRab.Ab_Datum  <= ipDatum
                AND   SpPrRab.Bis_Datum >= ipDatum NO-ERROR.
            IF AVAILABLE SpPrRab THEN 
            DO:
                IF SpPrRab.Wert <> 0 THEN 
                DO:
                    IF SpPrRab.Proz_Betr THEN 
                    DO.
                        VRab_Proz = SpPrRab.Wert.
                        VRab_Betr = 0.
                    END.
                    ELSE 
                    DO:
                        VRab_Betr = SpPrRab.Wert.
                        VRab_Proz = 0.
                    END.
                    /*                    IF tAufze.Netto = TRUE THEN*/
                    /*                    DO:                        */
                    /*                        IF NettoRab = 1 THEN   */
                    /*                        DO:                    */
                    /*                            VRab_Proz = 0.     */
                    /*                            VRab_Betr = 0.     */
                    /*                        END.                   */
                    /*                    END.                       */
                    tAufze.Rab_Su_Grp = 0.
                    tAufze.Rab_Su_Art = 0.
                    FSpezPreis        = 2.
                END.
            END.
            LEAVE.
        END.

        DO WHILE TRUE:
            IF KeineAkt THEN LEAVE.

            IF  FSpezpreis > 0 AND
                Aktionen = 0   THEN LEAVE.
            IF FSpezpreis = 1 THEN 
            DO:
                IF Aktionen = 2 THEN LEAVE.
            END.
            IF FSpezpreis = 2 THEN 
            DO:
                IF Aktionen = 1 THEN LEAVE.
            END.

            FIND LAST AktPreis NO-LOCK USE-INDEX AktPreis-k2
                WHERE AktPreis.Firma      = Firma
                AND   AktPreis.Artnr      = tAufze.Artnr
                AND   AktPreis.Inhalt     = tAufze.Inhalt
                AND   AktPreis.Jahr       = tAufze.Jahr
                AND   AktPreis.Grp        = VGrp
                AND   AktPreis.Ab_Datum  <= ipDatum
                AND   AktPreis.Bis_Datum >= ipDatum NO-ERROR.
            IF AVAILABLE AktPreis THEN 
            DO:
                IF AktPreis.Art = 0 THEN VPreis = VPreis - AktPreis.Wert.
                IF AktPreis.Art = 1 THEN VPreis = VPreis * (100 - AktPreis.Wert) / 100.
                VAktion      = TRUE.
                VAktion_Text = AktPreis.Bemerkung.
                LEAVE.
            END.
            IF NOT FAbweich             THEN LEAVE.
            IF Steuer.AktionsPreise > 0 THEN LEAVE.
            FIND LAST AktPreis NO-LOCK USE-INDEX AktPreis-k2
                WHERE AktPreis.Firma      = Firma
                AND   AktPreis.Artnr      = tAufze.Artnr
                AND   AktPreis.Inhalt     = tAufze.Inhalt
                AND   AktPreis.Jahr       = tAufze.Jahr
                AND   AktPreis.Grp        = Debst.Preis_Grp
                AND   AktPreis.Ab_Datum  <= ipDatum
                AND   AktPreis.Bis_Datum >= ipDatum NO-ERROR.
            IF AVAILABLE AktPreis THEN 
            DO:
                IF AktPreis.Art = 0 THEN VPreis = VPreis - AktPreis.Wert.
                IF AktPreis.Art = 1 THEN VPreis = VPreis * (100 - AktPreis.Wert) / 100.
                VAktion      = TRUE.
                VAktion_Text = AktPreis.Bemerkung.
                LEAVE.
            END.
            LEAVE.
        END.

        IF tAufze.Netto     THEN LEAVE.
        IF FSpezPreis > 0   THEN LEAVE.
        IF AVAILABLE RabTab THEN 
        DO:
            IF RabTab.Wert = 0  THEN LEAVE.
        END.
        
        IF tAufze.Rab_Art > 0 THEN 
        DO:
            IF tAufze.Rab_Art = 1 THEN 
            DO:
                VRab_Proz = tAufze.Rab_Wert.
                VRab_Betr = 0.
                LEAVE.
            END.
            IF tAufze.Rab_Art = 2 THEN 
            DO:
                VRab_Betr = tAufze.Rab_Wert.
                VRab_Proz = 0.
                LEAVE.
            END.
        END.

        IF AVAILABLE RabTab THEN 
        DO:
            IF RabTab.Rab_Art = 0 THEN VRab_Betr = RabTab.Wert.
            IF RabTab.Rab_Art = 1 THEN VRab_Proz = RabTab.Wert.
        END.
        LEAVE.
    END.

    ASSIGN  
        tAufze.Preis       = VPreis
        tAufze.Aktion      = VAktion
        tAufze.Aktion_Text = VAktion_Text.
    IF tAufze.Rab_Art <> 3 THEN 
    DO:
        ASSIGN  
            tAufze.Rab_Art  = 0
            tAufze.Rab_Wert = 0.
    END.
    IF VRab_Proz <> 0 THEN 
    DO:
        ASSIGN  
            tAufze.Rab_Art  = 1
            tAufze.Rab_Wert = VRab_Proz.
    END.
    IF VRab_Betr <> 0 THEN 
    DO:
        ASSIGN  
            tAufze.Rab_Art  = 2
            tAufze.Rab_Wert = VRab_Betr.
    END.

    DO WHILE TRUE:
        IF tAufze.Rab_Art = 1 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis    * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Rab_Wert * tAufze.Bru_Betr / 100.
            LEAVE.
        END.
        IF tAufze.Rab_Art = 2 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis    * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Rab_Wert * tAufze.MGeli.
            LEAVE.
        END.
        IF tAufze.Rab_Art = 3 THEN 
        DO:
            tAufze.Bru_Betr = tAufze.Preis    * tAufze.MGeli.
            tAufze.Rab_Betr = tAufze.Rab_Wert * tAufze.MGeli * -1.
            LEAVE.
        END.
        tAufze.Bru_Betr = tAufze.Preis * tAufze.MGeli.
        tAufze.Rab_Betr = 0.
        tAufze.Rab_Art  = 0.
        LEAVE.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Rab_Betr.
        RUN RUNDEN ( 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Rab_Betr = Rundbetr.
    END.

    tAufze.Zus_Betr = 0.              
    IF tAufze.Zus_Art > 0 THEN 
    DO:
        IF tAufze.Zus_Art = 1
            THEN tAufze.Zus_Betr = tAufze.Bru_Betr * tAufze.Zus_Wert / 100.
        IF tAufze.Zus_Art = 2
            THEN tAufze.Zus_Betr = tAufze.MGeli    * tAufze.Zus_Wert.
    END.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Zus_Betr.
        RUN RUNDEN ( 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Zus_Betr = Rundbetr.
    END.
    
    tAufze.Net_Betr = tAufze.Bru_Betr - tAufze.Rab_Betr + tAufze.Zus_Betr.
    
    IF Wust.Incl THEN 
    DO:
        Rundbetr = tAufze.Net_Betr.
        RUN RUNDEN ( 1, INPUT-OUTPUT Rundbetr ).
        tAufze.Net_Betr = Rundbetr.
    END.
    
    iohAufze:BUFFER-COPY(hBuffer).
    RETURN TRUE.
   
END FUNCTION.

/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME

&ENDIF

&IF DEFINED(EXCLUDE-updateRuestauftrag) = 0 &THEN

&ANALYZE-SUSPEND _UIB-CODE-BLOCK _FUNCTION updateRuestauftrag Procedure
FUNCTION updateRuestauftrag RETURNS LOGICAL 
    ( ipiStatus AS INTEGER, iprAufze AS RECID  ):
    /*------------------------------------------------------------------------------*/
    /* Purpose:                                                                     */
    /* Notes: ipiStatus = 0 -> Zeile erfasstt                                       */
    /* Notes: ipiStatus = 1 -> Zeile mutiert                                        */
    /* Notes: ipiStatus = 9 -> Zeile geloescht                                      */
    /*------------------------------------------------------------------------------*/

    DEFINE VARIABLE lRetVal AS LOGICAL NO-UNDO INIT TRUE.

    DEFINE BUFFER bAufze FOR Aufze.
    DEFINE BUFFER bAufko FOR Aufko.
    
    DEFINE VARIABLE hrawTable  AS HANDLE NO-UNDO.
    DEFINE VARIABLE hrRuestAuf AS HANDLE NO-UNDO.
    
    hrawTable  = BUFFER rawTable:HANDLE.
    hrRuestAuf = TEMP-TABLE rRuestAuf:DEFAULT-BUFFER-HANDLE. 

    FIND bAufze NO-LOCK WHERE RECID(bAufze) = iprAufze NO-ERROR.
    IF bAufze.Artnr = 0 THEN RETURN lRetVal.
    
    FIND FIRST RuestAuf NO-LOCK 
        WHERE RuestAuf.Firma = bAufze.Firma
        AND   RuestAuf.Aufnr = bAufze.Aufnr NO-ERROR.
    IF NOT AVAILABLE RuestAuf THEN RETURN lRetVal.
    
    FIND bAufko NO-LOCK OF bAufze NO-ERROR.
    IF bAufko.Faknr   > 0 THEN RETURN lRetVal.
    IF bAufko.Auf_Sta > 1 THEN RETURN lRetVal.
    IF bAufko.Fahrer  = 0 THEN RETURN lRetVal.
    
    /*    FIND FIRST RuestAuf NO-LOCK                  */
    /*        WHERE RuestAuf.Firma    = bAufze.Firma   */
    /*        AND   RuestAuf.Aufnr    = bAufze.Aufnr   */
    /*        AND   RuestAuf.lGeladen = TRUE  NO-ERROR.*/
    /*    IF AVAILABLE RuestAuf THEN RETURN lRetVal.   */
    
    FIND FIRST RuestAuf NO-LOCK OF bAufze NO-ERROR.
    IF  NOT AVAILABLE RuestAuf  AND
        ipiStatus = 9           THEN 
    DO:
        REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
            FOR EACH rawTable
                WHERE rawTable.Firma      = bAufze.Firma
                AND   rawTable.Tabelle    = 'RUESTAUF'
                AND   rawTable.Tabelle_Id = RECID(bAufze):
                DELETE  rawTable.
                RELEASE rawTable.
            END.
            LEAVE.
        END.
        RETURN lRetVal.    /*  Löschen einer noch nicht existierenden RuestPosition    */
    END.
    IF  AVAILABLE RuestAuf            AND 
        RuestAuf.MGeli = 0            AND 
        RuestAuf.MBest = bAufze.MBest THEN RETURN lRetVal.   
    
    IF  NOT AVAILABLE RuestAuf  AND
        ipiStatus = 1           THEN ipiStatus = 0. 
    IF  AVAILABLE RuestAuf      AND
        ipiStatus = 0           THEN ipiStatus = 1. 
    
    EMPTY TEMP-TABLE rRuestAuf.
    CASE ipiStatus:    
        WHEN 0 THEN 
            DO:
                CREATE  rRuestAuf.
                BUFFER-COPY bAufze
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.MBest     = 0
                    rRuestAuf.GGeb_Best = 0
                    rRuestAuf.VGeb_Best = 0
                    rRuestAuf.KGeb_Best = 0
                    rRuestAuf.SubPos    = 0.
                
                CREATE  rRuestAuf.
                BUFFER-COPY bAufze
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.MBest     = bAufze.MBest
                    rRuestAuf.GGeb_Best = bAufze.GGeb_Be
                    rRuestAuf.VGeb_Best = bAufze.VGeb_Be
                    rRuestAuf.KGeb_Best = bAufze.KGeb_Be
                    rRuestAuf.SubPos    = 1.
            END.
        WHEN 1 THEN 
            DO:
                CREATE  rRuestAuf.
                BUFFER-COPY RuestAuf
                    EXCEPT  SubPos
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.SubPos = 0.
                
                CREATE  rRuestAuf.
                BUFFER-COPY RuestAuf
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.MBest     = bAufze.MBest
                    rRuestAuf.GGeb_Best = bAufze.GGeb_Be
                    rRuestAuf.VGeb_Best = bAufze.VGeb_Be
                    rRuestAuf.KGeb_Best = bAufze.KGeb_Be
                    rRuestAuf.SubPos    = 1.
            END.
        WHEN 9 THEN 
            DO:
                CREATE  rRuestAuf.
                BUFFER-COPY RuestAuf
                    EXCEPT  SubPos
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.SubPos = 0.
                
                CREATE  rRuestAuf.
                BUFFER-COPY RuestAuf
                    EXCEPT  SubPos MBest GGeb_Best VGeb_Best KGeb_Best
                    TO      rRuestAuf
                    ASSIGN  
                    rRuestAuf.SubPos = 1.
            END.
    END.
    
    REPEAT TRANSACTION ON ERROR UNDO, LEAVE:
        FOR EACH rRuestAuf:
            FIND FIRST rawTable 
                WHERE rawTable.Firma       = bAufze.Firma 
                AND   rawTable.Tabelle     = 'RUESTAUF'
                AND   rawTable.Tabelle_Id  = RECID(bAufze)
                AND   rawTable.Tabelle_Key = SUBSTITUTE ('&1&2&3&4', STRING(bAufze.Artnr,'999999'), STRING(bAufze.Inhalt,'999999'), STRING(bAufze.Jahr,'9999'), STRING(bAufze.Pos,'9999') )
                AND   rawTable.iTrans      = rRuestAuf.SubPos NO-ERROR.
            IF NOT AVAILABLE rawTable THEN 
            DO:
                CREATE  rawTable.
                ASSIGN  
                    rawTable.Firma       = bAufze.Firma 
                    rawTable.Tabelle     = 'RUESTAUF'
                    rawTable.Tabelle_Id  = RECID(bAufze)
                    rawTable.Tabelle_Key = SUBSTITUTE ('&1&2&3&4', STRING(bAufze.Artnr,'999999'), STRING(bAufze.Inhalt,'999999'), STRING(bAufze.Jahr,'9999'), STRING(bAufze.Pos,'9999') )
                    rawTable.iTrans      = rRuestAuf.SubPos
                    rawTable.iStatus     = ipiStatus.
                hrRuestAuf:RAW-TRANSFER (TRUE, hrawTable:BUFFER-FIELD('rawData')).
                RELEASE rawTable.
                NEXT.
            END.
            IF rRuestAuf.SubPos = 0 THEN 
            DO:
                RELEASE rawTable.
                NEXT.
            END.
        
            hrRuestAuf:RAW-TRANSFER (TRUE, hrawTable:BUFFER-FIELD('rawData')).
            RELEASE rawTable.
        END.
        RELEASE rawTable.
        
        CREATE  ASMutation.
        ASSIGN
            ASMutation.ASMutation_id = NEXT-VALUE(ASMutation_id)
            ASMutation.MutArt        = 'RUESTDRUCK'
            ASMutation.Firma         = bAufze.Firma
            ASMutation.AdFirma       = ''
            ASMutation.Datum         = TODAY
            ASMutation.cStatus       = ''
            ASMutation.Aktiv         = TRUE
            ASMutation.iKey_1        = bAufze.Aufnr
            ASMutation.iKey_2        = 01
            ASMutation.iFeld_1       = bAufze.Pos
            ASMutation.iFeld_2       = 0
            ASMutation.iFeld_3       = TIME
            ASMutation.cFeld_2       = 'TRIGGER'
            ASMutation.cFeld_3       = (IF ipiStatus = 0 THEN 'CREATE' ELSE 'UPDATE').
        .
        IF ipiStatus = 9 THEN ASMutation.cFeld_3 = 'DELETE'. 
        RELEASE ASMutation.
        LEAVE.
    END.

    RETURN lRetVal.

END FUNCTION.
    
/* _UIB-CODE-BLOCK-END */
&ANALYZE-RESUME


&ENDIF