CALLP + SBMJOB

[muadeep]

ich möchte ein CL-Pgm durch ein ILE-Pgm (per SBMJOB) aufrufen!


in etwa so:

C                   Eval      Feld1 = %trim(Feld1)
C                   Eval      Feld2 = %trim(Feld2)
C                   Eval      Feld3 = %trim(Feld3)
C                   Eval      Feld4 = %trim(Feld4)

C                   CallP(e)  Cmd('SBMJOB CMD(CALL PGM(xxxxxxCL))' +
C                                       ' JOB(xxxxxx) ' +         
C                                       ' JOBQ(QBATCH)   ' +         
C                                       ' JOBD(QDFTJOBD) ' +         
C                                       ' JOBPTY(5)      ' +         
C                                       ' HOLD(*YES)     ') 

Der Aufruf des CALL's (bei SBMJOB) muß eigentlich die 4 Felder/Variablen (Feld1/Feld2/Feld3/Feld4) beinhalten!

wie muß ich das hier angeben?
geht das überhaupt?

muß ich auch "Prototypen" in den "D"-Bestimmungen angeben?
(fals ja, wie)

thx

[kuempi von stein]

Hello,



das geht bestimmt irgendwie. Habe son String aber noch nie zusammengebastelt. Mal sehen, was die anneren schreiben.

Eine "Notlösung" wäre auf jeden Fall ein vorgeschaltetes CLP mit den entsprechenden PARMS zu callen, welches dann den SBMJOB losjagt...

Nicht sehr elegant, aber schnell codiert und absolut useable...



kuempi

[muadeep]

ja, das mit dem vorgeschalteten CL hab ich schon so gemacht, gefällt mir aber nicht!

Deshalb auch meine Frage, ob es nicht vielleicht irgendwie anders geht!

[Fuerchau]

Du kannst natürlich eine CLLE-Routine in dein ILE-RPG einbinden, das ist auf jeden Fall die komfortabelste Variante (Bedienerführung des CMD's, Konzentrieren auf das Wesentliche) und auf keinen Fall eine Notlösung.

Ansonsten gehts halt nur per CALL 'QCMDEXC' mit Zusammenschustern des CMD's mit relativ vielen Test's bis es denn funktioniert.
Beim Zusammenbauen sind vor allem die Feldausprägungen (schon mehrfach hingewiesen) für das später aufzurufende Programm (Zeichen, Gezont, Gepackt, oder doch default 15,5).

Die tatsächlich "eleganteste" Variante ist die Übergabe per *LDA (wenn 1024 Bytes als Parameter reichen). Beim SBMJOB wird die lokale LDA immer kopiert !
Vorteil: man braucht auch nicht hinter sich aufzuräumen wie bei Parametern per Datei.

[malzusrex]

so mal uff die schnelle, ohne das ich es getestet habe

h dftactgrp(*no) Option( *NoDebugIO )   bnddir('QC2LE')                
h datfmt(*dmy.) timfmt(*hms:) datedit(*dmy.) decedit('0,') debug(*yes) 
                                                                       
d system          pr            10i 0 extproc('system')                
d                                 *   value options(*string)           
d                                                                      
d True            c                   *On                              
d False           c                   *Off                             
d                                                                      
d PGMName         s             10                                     
d JOBName         s             10                                     
                                                                       
c                                                                      
c                   CallP     System('sbmjob cmd(call pgm(' +          
c                                   %Trim(PGMName) + ') job(' +        
c                                   %Trim(JobName) + ')'         )     
c                   Eval      *InLr  = True 

gruß ronald

[muadeep]

und wie kann ich jetzt da parameter für den Programmaufruf mit übergeben?

cALLP  xxxxxxCL
PARM   FELD1
PARM   FELD2
PARM   FELD3
PARM   FELD4 

[malzusrex]

c                   CallP     System('sbmjob cmd(call pgm(' +          
c                                   %Trim(PGMName) + ')  ' +           
c                                   ' Parm(''' + %Trim(Feld1) + '''' + 
c                                   '))  job(' +                       
c                                   %Trim(JobName) + ')'         ) 

etwa so in der art. am besten ist du testet das mal aus. oder nim en befehl vorher auf eine variable

c                   Eval      CMD =  'sbmjob cmd(call pgm(' +          
c                                   %Trim(PGMName) + ')  ' +           
c                                   ' Parm(''' + %Trim(Feld1) + '''' + 
c                                   '))  job(' +                       
c                                   %Trim(JobName) + ')'               
c                                                                      
c                   CallP     System( cmd )                            
c                                                                      
c                   Eval      *InLr  = True 

gruß ronald

[muadeep]

So, hab das ganze mal versucht umzusetzen:

c                   Eval      CMD =  'SBMJOB CMD(CALL PGM(EXPEREMCL)' +
c                                   ' PARM(''' + %Trim(Von    ) + ''' +
c                                          ''' + %Trim(An     ) + ''' +
c                                          ''' + %Trim(AntwAn ) + ''' +
c                                          ''' + %Trim(Betref ) + ''' +
c                                          ''' + %Trim(Attach ) + ''' +
c                                          ''' + %Trim(TranBi ) + ''' + 
c                                          ''' + %Trim(JDebug ) + '''' +
c                                   ')) +                               
c                                   JOB(EXCELMAIL) JOBQ(QBATCH) +       
c                                   JOBD(QDFTJOBD) JOBPTY(5) +          
c                                   HOLD(*YES)'                         
c                   CallP     System(CMD) 

Der Job wird jetzt auch prima per SBMJOB übertragen!
Nach dem ich diesen "freigegeben" habe erhalte ich eine Fehlermeldung!

Wenn ich diesen Job(SBMJOB) debug'e(STRDBG), dann
stelle ich fest, daß in dem aufgerufenen CL-Pgm. die Parameter
nicht richtig übergeben werden!

CL:

PGM        PARM(&VON &AN &ANTWAN &BETREF &ATTACH +    
                         &TRANBI &JDEBUG)
DCL        VAR(&VON   ) TYPE(*CHAR) LEN(50) 
DCL        VAR(&AN    ) TYPE(*CHAR) LEN(50) 
DCL        VAR(&ANTWAN) TYPE(*CHAR) LEN(50)
DCL        VAR(&BETREFF) TYPE(*CHAR) LEN(50)
DCL        VAR(&ATTACH) TYPE(*CHAR) LEN(50)
DCL        VAR(&TRANBIN) TYPE(*CHAR) LEN(4)
DCL        VAR(&JDEBUG) TYPE(*CHAR) LEN(4) 

d.h. in der Variablen "&Von" steht noch ein Teil von der Variablen "&AN", etc.

es sollte eigentlich so sein(ausschauen):

&VON       = 'HUBER                   '
&AN        = 'MAIER                   '
&ANTWAN    = 'XYZ                     ' 

ist aber leider so:

&VON       = 'HUBER      MAIER        '
&AN        = 'MAIER      XYZ          '
&ANTWAN    = 'XYZ      .....          ' 

was mache ich da nu wieder falsch?
.

[Fuerchau]

Wie immer das selbe Problem !
Bei der Parameterübergabe ist die Felddefinition GENAU einzuhalten.
Lass also das %TRIM weg, da du damit die Felder doch verkürzt !!!

Im CL-Handbuch steht doch, wie Parameter an eine Programm durch das CMD "CALL" übergeben werden:
- Zeichenketten in der angegebenen Länge, mindestens jedoch 32 Zeichen
- Zahlen immer gepackt in 15,5

Wenn du also 50 Zeichen erwartest, musst du auch 50 Zeichen übergeben.