Identifier un type de lancement (Batch/Interactif) [Résolu]

[mutsum1]

Bonjour à tous,

J'ai un programme qui affiche une petite fenêtre d'attente le temps de son calcul. Cela ne nécessite aucune action utilisateur.

J'aimerais pouvoir lancer également ce programme en batch, mais dans ce cas le système me génère une erreur à l'ouverture de l'écran.

Est-il possible au niveau du programme de connaître la méthode de lancement, afin de conditionner l'ouverture de l'écran si le lancement est interactif ?

Merci


PS :
Je ne souhaite pas passer un paramètre en plus. Trop de programmes à recompiler, et aucun fun.
J'ai un palliatif pour l'instant en me basant sur le user QPGMR, mais ça reste du bricolage.

[FORMULARY]

Dans un CLP, il suffit d'utiliser RTVJOBA TYPE(&TYPE).
Si &TYPE = '0' c'est un travail batch
Si &TYPE = '1' c'est un travail interactif

Dans un RPG, je ne crois pas que l'info soit dans la SDS.
Il faut alors passer par une API. Je regardes dès que j'ai le temps.

On peut aussi déclarer le fichier en UserOpen et indiquer un indicateur d'erreur sur le Open.

[mutsum1]

Merci pour ta réponse.

J'ai oublié de préciser mais c'est bien un RPG qui est lancé.

L'idée d'intercepter l'erreur sur le OPEN est pas mal. C'est pas l'idéal mais ce sera toujours mieux que mon QPGMR.

Encore merci.

[m4k-Hurrican]

Je n'en suis pas l'auteur, mas je ne retrouve pas qui me l'avait fourni...

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
'*-------------------------------------------------------------------*
'* Procédure Rtv_jobType    :                                        *
'*   But   : Récupération du type de job (interactive/batch)         *
'*   Input :                                                         *
'*  Output : - B=Batch I=Intercatif                                  *
'*-------------------------------------------------------------------*
                                                                      
 * Begin prototype procedure                                          
P Rtv_jobType     B                   Export                          
D Rtv_jobType     PI             1                                    
                                                                      
DQUSI020000       DS                                                  
D QUSJT04                61     61                                    
                                                                      
DQUSEC            DS           116    inz                             
D QUSBPRV                 1      4B 0 inz(116)                        
D QUSBAVL                 5      8B 0 inz(0)                          
D QUSEI                   9     15                                    
D QUSERVED               16     16                                    
D QUSED01                17    116                                    
                                                                      
 * Variable returned to caller                                        
D Job_Type        S              1                                    
                                                                       * Program Variables                                   
D FormatName      S              8    Inz('JOBI0200')  
D InJobName       S             26                     
D IntJobName      S             16                     
D JobName         S             26    Inz('*')         
D Outcount        S              5  0                  
D ReceiveLen      S             10i 0 Inz(187)         
                                                       
 * Call the api to get the information for job type... 
C                   Eval      Job_Type = *Blanks       
C                   Call      'QUSRJOBI'               
C                   Parm                    QusI020000 
C                   Parm                    ReceiveLen 
C                   Parm                    FormatName 
C                   Parm                    JobName    
C                   Parm                    IntJobName 
C                   Parm                    QusEc      
                                                       
 * Load the job type...                                
C                   Eval      Job_Type = QUSJT04       
C                   Return    Job_Type                 
                                                       
P                 E

[mutsum1]

Un grand merci, je vais implémenter ça.