Modulo. Mantenimiento de un registro

Objetivo

Realizar un módulo que presenta una ventana para el mantenimiento de los datos de un registro. Permitirá dar de alta un nuevo registro o realizar las opciones de modificación, consulta o borrado de un registro existente. Lógicamente validará la información introducida por el usuario antes de actualizar la información en la base de datos.

Para los campos de tipo tabla también se habilita el acceso a los programas de lista de selección (F4) en el ejemplo que se mostrará sobre el campo de país y de tipo de cliente.

En este ejemplo, se realizará una pantalla de mantenimiento de un cliente. Será llamado desde la pantalla de lista de clientes.

Tiene el mandato F10 para confirmar  la acción de alta, modificación o borrado. Con F4 accederá a la lista de selección de país y de tipo de cliente. Con F12 no realizará ninguna acción y volverá a la pantalla que le llamó.

Referencias: ILE estrategia, BD Pruebas

Configuración

Este programa utilizará un componente de acceso a base de datos de lista de clientes, los componentes de actualización (alta, baja y modificación) de un registro y los componentes de validación que se encuentran todos ellos en el programa de servicio correspondiente.

• El nombre del módulo donde esta el ventana de lista de registros para mantenimiento BAN02P1
• La definición de la pantalla estará definida como BAN02S1
• Utiliza el programa de servicio BAN01SRV que contiene los componentes de acceso a BD, de actualización y de validación
• El miembro (/Copy) con la definición del prototipo con los componentes y con la definición de estructuras será BAN01M1CP
• Llamará a los programas de lista de países (PAN40P1) y lista de tipos de cliente (PAN40P2) 

Este ejemplo sirve de plantilla para otro proceso similar.

Fuente de la pantalla. BAN02S1

Se define la pantalla para presentar el mantenimiento de un registro.

A                                      DSPSIZ(24 80 *DS3)
A                                      PRINT
A          R BAN02S01
A  66                                  CF04(04 'Consultar')
A  67                                  CF10(10 'Confirmar')
A                                      CF12(12 'Anterior')
A                                      RTNCSRLOC(*RECNAME &REGCUR &CAMCUR)
A            CAMCUR        10A  H
A            REGCUR        10A  H
A            WKSTNS        10A  O  1 71DSPATR(HI)
A                                  2  3DATE
A                                      EDTCDE(Y)
A                                      DSPATR(HI)
A                                  2 71USER
A                                      DSPATR(HI)
A            D_TIPOOPC     12A  O  2 32DSPATR(HI)
A                                  1  3'BAN02P1'
A                                      DSPATR(HI)
A                                  1 27'Mantenimiento de cliente'
A                                      DSPATR(HI)
A  69                              5  3'Cliente'
A  69        D_IDCLIENT    10Y 0O  5 12DSPATR(HI)
A                                      EDTCDE(4)
A                                  8  4'Nombre'
A            D_NOMBRE      50A  B  8 17CHECK(LC)
A  68                                  DSPATR(PR)
A  30                                  DSPATR(RI)
A  30                                  DSPATR(PC)
A  70                                  ERRMSG('Debe rellenarse' 70)
A                                  9  4'Apellidos'
A            D_APELLIDO   100A  B  9 17CHECK(LC)
A  68                                  DSPATR(PR)
A  31                                  DSPATR(RI)
A  31                                  DSPATR(PC)
A  71                                  ERRMSG('Debe rellenarse' 71)
A                                 11  4'Direccion'
A            D_DIRECCIO   100A  B 11 17CHECK(LC)
A  68                                  DSPATR(PR)
A  32                                  DSPATR(RI)
A  32                                  DSPATR(PC)
A  72                                  ERRMSG('Debe rellenarse' 72)
A                                 13  4'Pais'
A            D_IDPAIS       3A  B 13 17
A  68                                  DSPATR(PR)
A  33                                  DSPATR(RI)
A  33                                  DSPATR(PC)
A  73                                  ERRMSG('Debe rellenarse' 73)
A  74                                  ERRMSG('No existe' 74)
A            D_DSPAIS      50A  O 13 22
A                                 14  4'Tip cliente '
A            D_IDTIPCLI     1A  B 14 17
A  68                                  DSPATR(PR)
A  34                                  DSPATR(RI)
A  34                                  DSPATR(PC)
A  75                                  ERRMSG('Debe rellenarse' 75)
A  76                                  ERRMSG('No existe' 76)
A            D_DSTIPCLI    50A  O 14 22
A*
A  66                             23  4'F4-Consulta'
A  67                             23 24'F10-Confirmar'
A                                 23 47'F12-Anterior' 

Se define:

• El registro de mantenimiento (BAN02S01) con todos los campos a presentar y mantener.

Para las variables de pantalla siempre utilizo el prefijo D_

Fuente del proceso. BAN02P1

Se presenta el fuente del modulo que controla el mantenimiento de un registro. Utilizará el componentes de acceso de base de datos, de mantenimiento y de validación similares a los que se presentaron en entradas previas en este blog.
Nota: pondré en color azul lo que debería cambiar en esta plantilla del fuente RPG para hacer un nuevo programa de selección de otra entidad.

Definición ficheros y variables

Se define la pantalla de lista para selección y las estructuras de datos que se utilizarán en el programa. Como en todos los fuentes anteriores, se utilizan estructuras de datos para no cambiar las llamadas entre funciones cuando hagamos otro proceso similar; sólo bastaría con cambiar las variables contenidas en las estructura.

 *===============================================================
 *   Plantilla Pantalla de mantenimimiento - V1.0
 *===============================================================

H DEBUG DECEDIT('0,') DATEDIT(*DMY.)

FBan02s1   CF   E             WORKSTN USROPN

 // Ds de DEFINCICION de los datos de pantalla
DDs_DatosDsp      DS
D IdCliente                     10  0
D Nombre                        50
D Apellidos                    100
D Direccion                    100
D IdPais                         3
D DsPais                        50
D IdTipCli                       1
D DsTipCli                      50

 // Ds con los datos del fichero y de pantalla
D W_DatosLst      Ds                  Dim(99) LikeDs(Ds_BasClie)
D W_NumReg        S              2  0
D W_TotReg        S             10  0
D W_DatosDsp      Ds                  LikeDs(Ds_DatosDsp)

 // Ds de actualizaciones
D W_DsAlt         Ds                  LikeDs(Ds_AddClie)
D W_DsMod         Ds                  LikeDs(Ds_UpdClie)

Definición de las estructuras de datos

• (Ds_DatosDsp). Campos que se presentan en la ventana. Tendrá asociada la variable de trabajo correspondiente (W_DatosDsp)

Por último tiene las variables de trabajo necesarias para acceder a los componentes de acceso a base de datos (W_DatosLst), de alta de registro (W_DsAlt) y de actualización de registro (W_DsMod). Se utilizarán en los componentes correspondientes y la definición de la estructura estará en el /Copy del programa de servicio

Recursos y definición de prototipos internos.

En esta parte se define recursos comunes y los componentes internos del programa.

 /COPY *LIBL/QRPGLESRC,BAN00VAR

 // Ds de DEFINCICION de los parametros de entrada
DDs_Parametros    DS                  Qualified
D IdCliente                     10  0

DBAN02P1          PR
D P_Parametros                        Const LikeDs(Ds_Parametros)
D P_TipoOpc                      3    Const
D P_Resultado                    3

DBAN02P1          PI
D P_Parametros                        Const LikeDs(Ds_Parametros)
D P_TipoOpc                      3    Const
D P_Resultado                    3



 // Ds con los campos de llamada al programa de F4 de pais
DP_ParamF4Pais    DS                  Qualified
D IdPais                         3
D DsPais                        50

DBan40P1Ej        PR                  EXTPGM('BAN40P1EJ')
D P_ParamF4Pais                       Const LikeDs(P_ParamF4Pais)
D P_Resultado                    3


 // Ds con los campos de llamada al programa de F4 tipo cliente
DP_ParamF4TpCl    DS                  Qualified
D IdTipCli                       1
D DsTipCli                      50

DBan40P2Ej        PR                  EXTPGM('BAN40P2EJ')
D P_ParamF4TpCl                       Const LikeDs(P_ParamF4TpCl)
D P_Resultado                    3

 /COPY *LIBL/QRPGLESRC,BAN01M1CP

DDsp_CargaDatos   PR
D P_LeerFil                       n   Const

DDsp_ObtDatos     PR

DDsp_DatosDsp     PR
D P_Accion                            Like(WAccActual)
D P_AccionCons                  10

DRec_Descripcion  PR

DValida           PR              n

La rutina /Copy (BAN00VAR) contiene definición de variables comunes a todos los programas de pantalla. Se detallará en un apartado.

La rutina /Copy (BAN01M1CP) contiene la definición de los componentes de acceso a base de datos, de actualización y de validación.

Parámetros de entrada

• El nombre del modulo (BAN02P1). Tiene asociada una estructura de datos (P_ParamMante) con los datos clave que es necesario pasarle. En este caso, el identificativo del cliente (IdCliente) sobre el que se realizará  la operación de mantenimiento.También tiene otro campo de entrada (P_TipoOpc) que es la operación a realizar (alta, baja, modificación o consulta) y tiene un campo de salida (P_Resultado) que tendrá si se ha realizado alguna operación o no se ha hecho nada.

Llamadas a módulos y programas 

• Llamada a programas de lista de registros F4 sobre los campos de búsqueda
  Las dos definiciones siguientes son opcionales ya que dependen de los campos de búsqueda que haya. Si no hay ninguno que tenga F4, no existirán estas definiciones (nota: yo, aunque no tenga ningún F4 dejo solo una definición "asteriscada" por si en el futuro pudiera tener una)
• (Ban40P1Ej) es la definición de llamada al programa de lista de selección de países. Tiene una estructura de datos (P_ParamF4Pais) con los campos que se devolverán del programa de lista. En este caso, la estructura tiene los campos de identificación de país y de nombre de país (IdPais y DsPais). Tiene un campo de salida (P_Resultado) que tendrá si se ha realizado alguna operación o no se ha hecho nada.
• (Ban40P2Ej) es la definición de llamada al programa de lista de selección de tipos de clientes. Tiene una estructura de datos (P_ParamF4TpCl) con los campos que se devolverán del programa de lista. En este caso, la estructura tiene los campos de identificación de tipo de cliente y de descripción de tipo de cliente (IdTipCli y DsTipCli). Tiene un campo de salida (P_Resultado) que tendrá si se ha realizado alguna operación o no se ha hecho nada.

Procedimientos internos

• (Dsp_CargaDatos) Se utilizará para cargar los campos y datos de la ventana
• (Dsp_ObtDatos) Se utilizará para obtener los campos de la ventana rellenados por el usuario
• (Dsp_DatosDsp) Se utilizará para presentar la pantalla y recoger la acción realizaad por el usuario.
• (Rec_Descripcion). Se utiliza  para recuperar las descripciones de campos de tipo tabla. Se utilizará para el campo de país y de tipo de cliente.
• (Valida) Validará que los datos introducidos son correctos.

Flujo principal

Se presenta el flujo principal del programa. Igual que se comentó en la entrada que explicaba el programa de lista de registros, es necesario mencionar que es no está escrito linealmente sino que está incluido en un bucle y utiliza una variable (WSitActual) para ir cambiando de estado y para cada estado realiza un grupo de acciones determinado; A la finalización de las acciones de un grupo, la variable cambiará de estado y en el siguiente ciclo realizará otras acciones. Cuando alcance un estado de finalización (CSitFinalizar) terminará el proceso.
Si se quiere modificar el flujo de proceso, basta con cambiar el contenido de esta variable al finalizar su grupo de acciones. 
Si se desea incluir nuevas acciones, se crearía una nueva situación incluyendo las instrucciones que fuera y al finalizar estas acciones debería cambiar el contenido de la variables de situación para pasar a otro estado. Lógicamente, habría también que cambiar que alguien llamará a este nuevo grupo cambiado la variable de situación. 

 /Free
   Open Ban02s1;

   WSitActual= CSitRecuperar;

   Clear W_DatosDsp;

   Dow WSitActual<>CSitFinalizar;
     Select;
       ///////////////////////////////////////////////////////
       // MODELO: Obtener datos del registro ////////////////
       ///////////////////////////////////////////////////////
       When WSitActual = CSitRecuperar;
          Dsp_CargaDatos(*On);
          WSitActual= CSitShowDatos;

       ///////////////////////////////////////////////////////
       // VISTA: Presenta datos de pantalla    //////////////
       ///////////////////////////////////////////////////////
       When WSitActual = CSitShowDatos;
          Dsp_DatosDsp (W_Accion : W_AccionCons);
          Select;
            When W_Accion = CAccAnterior;
              P_Resultado = CRtnSalir;
              WSitActual = CSitFinalizar;
            When W_Accion = CAccConfirmar;
              WSitActual = CSitActualizar;
            When W_Accion = CAccEnter;
              WSitActual = CSitEnter;
            When W_Accion = CAccCons;
              Select;
                 When W_AccionCons='PAIS';
                    BAN40P1EJ (P_ParamF4Pais : w_Resultado);
                    If w_Resultado = CRtnConfirmado;
                       W_DatosDsp.IdPais = P_ParamF4Pais.IdPais;
                       W_DatosDsp.DsPais = P_ParamF4Pais.DsPais;
                    EndIf;
                 When W_AccionCons='TPCL';
                    BAN40P2EJ (P_ParamF4TpCl : w_Resultado);
                    If w_Resultado = CRtnConfirmado;
                      W_DatosDsp.IdTipCli=P_ParamF4TpCl.IdTipCli;
                      W_DatosDsp.DsTipCli=P_ParamF4TpCl.DsTipCli;
                    EndIf;
              EndSl;
              Dsp_CargaDatos(*Off);
              WSitActual = CSitShowDatos;
          EndSl;

       //////////////////////////////////////////////////////
       // VISTA: Valida los datos de pantalla  //////////////
       //////////////////////////////////////////////////////
       When WSitActual = CSitEnter;
           Dsp_ObtDatos  ();
           Valida ();
           Rec_Descripcion ();
           WSitActual = CSitShowDatos;

       //////////////////////////////////////////////////////
       // MODELO: Actualizar                   //////////////
       //////////////////////////////////////////////////////
       When WSitActual = CSitActualizar;
           Dsp_ObtDatos  ();
           If Valida ();
             Select;
               When P_TipoOpc = CEjeAlt;     // Alta
                    W_DsAlt.Nombre   = W_DatosDsp.Nombre;
                    W_DsAlt.Apellidos= W_DatosDsp.Apellidos;
                    W_DsAlt.Direccion= W_DatosDsp.Direccion;
                    W_DsAlt.IdPais   = W_DatosDsp.IdPais;
                    W_DsAlt.IdTipCli = W_DatosDsp.IdTipCli;
                    Add_Cliente(W_DsAlt);
               When P_TipoOpc = CEjeMod;     // Modificacion
                    W_DsMod.Nombre   = W_DatosDsp.Nombre;
                    W_DsMod.Apellidos= W_DatosDsp.Apellidos;
                    W_DsMod.Direccion= W_DatosDsp.Direccion;
                    W_DsMod.IdPais   = W_DatosDsp.IdPais;
                    W_DsMod.IdTipCli = W_DatosDsp.IdTipCli;
                    Upd_Cliente(P_Parametros.IdCliente: W_DsMod);
               When P_TipoOpc = CEjeBor;     // baja
                    Dlt_Cliente(P_Parametros.IdCliente);
             EndSl;

             P_Resultado = CRtnConfirmado;
             WSitActual  = CSitFinalizar;
           Else;
             WSitActual= CSitShowDatos;
           EndIf;

     EndSl;
   EndDo;

   Close Ban02s1;
   Eval *InLr=*On;

 /End-Free

Las situaciones por las que esta pasando el programa son constantes definidas en el /Copy común y son las siguientes:

• (CSitRecuperar). Es la inicial. Recupera la información del fichero y carga los campos de pantalla.
• (CSitShowDatos). Presenta la pantalla y esperará a que el usuario realice una acción y recogerá el mandato pulsado por el usuario.
  Si ha pulsado el mandato de salida (W_Accion=CAccSalir) y finalizará (P_Resultado = CRtnSalir).
  Si ha pulsado el mandato de confirmar(W_Accion=CAccConfirmar) accederá a las acciones asociadas a este mandato (WSitActual=CSitActualizar).
  Si ha pulsado enter (W_Accion=CSitEnter) accederá a las acciones asociadas a este mandato (WSitActual=CAccEnter)
  Si ha pulsado F4 (W_Accion=CAccCons) accederá al programa de lista de selección F4 correspondiente según el campo en el que el usuario haya pulsado.
• (CSitEnter). Recupera los datos grabados por el usuario en la pantalla y los valida.
• (CSitActualizar). Recupera los datos de pantalla y los valida. Si es correcto, realiza la acción de actualización que se trate a través del componente correspondiente del programa de servicio, para alta (Add_Cliente), modificación (Upd_Cliente) y para borrado (Dlt_Cliente) y después finaliza (WSitActual=CSitFinalizar) el programa devolviendo que ha realizado la operación (P_Resultado = CRtnConfirmado).
  Si hubo error de validación, vuelve a enseñar la pantalla con los errores detectados (WSitActual= CSitShowDatos)
• (CSitFinalizar). Finaliza el proceso.

Componente interno de Carga de pantalla

Realiza la carga de la cabecera de la pantalla.

PDsp_CargaDatos   B
DDsp_CargaDatos   PI
D P_LeerFil                       n   Const

D W_Sel           DS                  LikeDs(Ds_SelClie)
 /Free
     If P_LeerFil;
       Clear W_DatosLst;
       If P_TipoOpc <> CEjeAlt;
          Clear W_Sel;
          W_Sel.K_IdCliente = P_Parametros.IdCliente;
          Obt_LstClientes(W_DatosLst : W_NumReg : W_TotReg :
                          0 : 0 : '1A' :
                          W_Sel);
       EndIf;

       W_DatosDsp.IdCliente = W_DatosLst(1).IdCliente;
       W_DatosDsp.Nombre    = W_DatosLst(1).Nombre   ;
       W_DatosDsp.Apellidos = W_DatosLst(1).Apellidos;
       W_DatosDsp.Direccion = W_DatosLst(1).Direccion;
       W_DatosDsp.IdPais    = W_DatosLst(1).IdPais   ;
       W_DatosDsp.DsPais    = W_DatosLst(1).DsPais   ;
       W_DatosDsp.IdTipCli  = W_DatosLst(1).IdTipCli ;
       W_DatosDsp.DsTipCli  = W_DatosLst(1).DsTipCli ;
     EndIf;

     D_IdClient  =  W_DatosDsp.IdCliente;
     D_Nombre    =  W_DatosDsp.Nombre;
     D_Apellido  =  W_DatosDsp.Apellidos;
     D_Direccio  =  W_DatosDsp.Direccion;
     D_IdPais    =  W_DatosDsp.IdPais;
     D_DsPais    =  W_DatosDsp.DsPais;
     D_IdTipCli  =  W_DatosDsp.IdTipCli;
     D_DsTipCli  =  W_DatosDsp.DsTipCli;

 /End-Free
P                 E

Primero, si no es acción de alta, recupera de la base de datos, a través del componente ((Obt_LstClientes)) de acceso a BD que está en el programa de servicio, los datos de la clave sobre la que se realiza el mantenimiento. Carga los datos recuperados de la base de datos sobre la estructura de datos de campos de pantalla.
Posteriormente, carga los campos de pantalla desde la información de la estructura de datos.

Componente interno de Obtener datos

PDsp_ObtDatos     B
DDsp_ObtDatos     PI

 /Free
    W_DatosDsp.Nombre   = D_Nombre   ;
    W_DatosDsp.Apellidos= D_Apellido ;
    W_DatosDsp.Direccion= D_Direccio ;
    W_DatosDsp.IdPais   = D_IdPais   ;
    W_DatosDsp.DsPais   = D_DsPais   ;
    W_DatosDsp.IdTipCli = D_IdTipCli ;
    W_DatosDsp.DsTipCli = D_DsTipCli ;
 /End-Free
P                 E

Recupera los datos de pantalla seleccionados por el usuario y los carga sobre la estructura de datos de campos de pantalla (W_DatosDsp)

Componente interno de Presentar pantalla

Presenta la pantalla al usuario y recoge el mandato pulsado por el usuario

PDsp_DatosDsp     B
DDsp_DatosDsp     PI
D P_Accion                            Like(WAccActual)
D P_AccionCons                  10
 /Free
     Select;
       When P_TipoOpc=CEjeAlt;     // Alta
           D_TipoOpc = 'Alta';
           *In66=*On;                    // Boton f4
           *In67=*On;                    // Boton confirmar
           *In68=*Off;                   // Proteger No Claves
           *In69=*Off;                   // Proteger Claves
       When P_TipoOpc=CEjeMod;     // Modificacion
           D_TipoOpc = 'Modificacion';
           *In66=*On;                    // Boton f4
           *In67=*On;                    // Boton confirmar
           *In68=*Off;                   // Proteger No Claves
           *In69=*On;                    // Proteger Claves
       When P_TipoOpc=CEjeBor;     // baja
           D_TipoOpc = 'Borrado';
           *In66=*Off;                   // Boton f4
           *In67=*On;                    // Boton confirmar
           *In68=*On;                    // Proteger No Claves
           *In69=*On;                    // Proteger Claves
       When P_TipoOpc=CEjeCon;     // consulta
           D_TipoOpc = 'Consulta';
           *In66=*Off;                   // Boton f4
           *In67=*Off;                   // Boton confirmar
           *In68=*On;                    // Proteger No Claves
           *In69=*On;                    // Proteger Claves
       Other;
           D_TipoOpc = '***ERR';
           *In66=*Off;                   // Boton f4
           *In67=*Off;                   // Boton confirmar
           *In68=*On;                    // Proteger No Claves
           *In69=*On;                    // Proteger Claves
     EndSl;

     Exfmt Ban02S01;
     // Apagar indicadores de error
     *In30=*Off;             // Error. Visual
     *In31=*Off;             // Error. Visual
     *In32=*Off;             // Error. Visual
     *In33=*Off;             // Error. Visual
     *In34=*Off;             // Error. Visual
     *In70=*Off;             // Error. Msg
     *In71=*Off;             // Error. Msg
     *In72=*Off;             // Error. Msg
     *In73=*Off;             // Error. Msg
     *In74=*Off;             // Error. Msg
     *In75=*Off;             // Error. Msg
     *In76=*Off;             // Error. Msg
     Select;
       When *In12=*On;
          P_Accion=CAccAnterior;
       When *In10=*On;
          P_Accion=CAccConfirmar;
       When *In04=*On;
          Select;
            When CAMCUR='D_IDPAIS';
              P_Accion=CAccCons;
              P_AccionCons='PAIS';
            When CAMCUR='D_IDTIPCLI';
              P_Accion=CAccCons;
              P_AccionCons='TPCL';
            Other;
              P_Accion=CAccEnter;
          EndSl;
       Other;
          P_Accion=CAccEnter;
     EndSl;
 /End-Free
P                 E

Inicializará variables e indicadores de pantalla según la acción que se realiza (alta, baja, modificación o consulta) y presenta la pantalla.
Recoge el mandato pulsado por el usuario.
Según cada programa que se desarrolle habrá (o no) funciones de lista de registros de ayuda (F4). En este programa está la lista para seleccionar pais y habrá que comprobar el campo asociado (D_IDPAIS) y para el tipo de cliente (D_IDTIPCLI)

Componente interno de Recuperar descripción

Se utiliza para recuperar descripciones de campos de tipo tabla. Si no los hubiera, la rutina podría estar vacía. En este caso se recuperan descripciones del nombre de país y  de descripción de tipo de cliente.

PRec_Descripcion  B
DRec_Descripcion  PI

D W_DatosPais     Ds                  Dim(99) LikeDs(Ds_BasPais)
D W_NumRegPais    S              2  0
D W_SelPais       Ds                  LikeDs(Ds_SelPais)

D W_DatosTpCl     Ds                  Dim(99) LikeDs(Ds_BasTpCl)
D W_NumRegTpCl    S              2  0
D W_SelTpCl       Ds                  LikeDs(Ds_SelTpCl)

D W_TotReg        S             10  0

 /Free
      // Recupera descripcion de codigo de pais.
      Clear W_SelPais;
      W_SelPais.K_IdPais = W_DatosDsp.IdPais;
      Obt_LstPais(W_DatosPais : W_NumRegPais : W_TotReg :
                  0 : 0 : '1A' :
                  W_SelPais);
      If W_NumRegPais > *Zeros;
         W_DatosDsp.DsPais = W_DatosPais(1).DsPais;
         D_DsPais = W_DatosDsp.DsPais;
      EndIf;

      // Recupera descripcion de tipo de cliente
      Clear W_SelTpCl;
      W_SelTpCl.K_IdTipCli = W_DatosDsp.IdTipCli;
      Obt_LstTpClient(W_DatosTpCl : W_NumRegTpCl : W_TotReg :
                      0 : 0 : '1A' :
                      W_SelTpCl);
      If W_NumRegTpCl > *Zeros;
         W_DatosDsp.DsTipCli = W_DatosTpCl(1).DsTipCli;
         D_DsTipCli = W_DatosDsp.DsTipCli;
      EndIf;
 /End-Free
P                 E

Por cada campo de tabla que tenga un campo de descripción, se accede al componente (Obt_LstTpClient) de acceso de BD con la clave (W_DatosDsp.IdTipCli) recuperada de los campos de pantalla y del registro que se recupera del componente (W_DatosTpCl(1).DsTipCli), se carga el campo pantalla (D_DsTipCli) de descripción.

Componente interno de Validación

Se encarga de realizar las validaciones de los datos introducidos por el usuario

PValida           B
DValida           PI              n

D W_IdError       S              3
 /Free
   If Not Val_Nombre(W_DatosDsp.Nombre : W_IdError);
      If w_IdError='E01';              // Vacio
         *In10=*On;
         *In70=*On;
      EndIf;
      Return *Off;
   Endif;

   If Not Val_Apellidos(W_DatosDsp.Apellidos : W_IdError);
      If w_IdError='E01';              // Vacio
         *In31=*On;
         *In71=*On;
      EndIf;
      Return *Off;
   Endif;

   If Not Val_Direccion(W_DatosDsp.Direccion : W_IdError);
      If w_IdError='E01';              // Vacio
         *In32=*On;
         *In72=*On;
      EndIf;
      Return *Off;
   Endif;

   If Not Val_IdPais(W_DatosDsp.IdPais : W_IdError);
      If w_IdError='E01';              // Vacio
         *In33=*On;
         *In73=*On;
      EndIf;
      If w_IdError='E02';              // No existe
         *In33=*On;
         *In74=*On;
      EndIf;
      Return *Off;
   Endif;

   If Not Val_IdTipCli(W_DatosDsp.IdTipCli : W_IdError);
      If w_IdError='E01';              // Vacio
         *In34=*On;
         *In75=*On;
      EndIf;
      If w_IdError='E02';              // No existe
         *In34=*On;
         *In76=*On;
      EndIf;
      Return *Off;
   Endif;

   // Correcto
   Return *On;
 /End-Free
P                 E

Va realizando llamadas a los componentes de validación según los campos que haya en la pantalla. Si una validación no es correcta, se enciende los indicadores de error correspondiente y finaliza la ejecución de la rutina de validación de  forma insatisfactoria (Return *Off).
Si no hay error, devuelve que todo es correcto (Return *On)

Anexo. /Copy BAN00VAR declaraciones generales y comunes

Presenta la pantalla al usuario y recoge el mandato pulsado por el usuario

 // Estructuras y campos de control de pantalla
D Sistema        SDS
D Usuario               254    263
D WKSTNS                244    253

D CURSOR          DS
D  PXCUR                370    371B 0
D  PXNRC                378    379B 0


 // Constantes de acciones dentro del programa
DWAccActual       S             15
D CAccSalir       C                   'Salir          '
D CAccAlta        C                   'Alta           '
D CAccEnter       C                   'Enter          '
D CAccCons        C                   'ConsultaF4     '
D CAccAnterior    C                   'Anterior       '
D CAccConfirmar   C                   'Confirmar      '
D CPagSig         C                   'PaginaSig      '


 // Constantes de posibles situaciones del programa
D W_Accion        S                   Like(WAccActual)
D W_AccionCons    S             10
D WSitActual      S             15
D CSitCargarDsp   C                   'Cargar_Dsp     '
D CSitFinalizar   C                   'Finalizar      '
D CSitShowDatos   C                   'ShowDatos      '
D CSitValidar     C                   'Validar        '
D CSitAlta        C                   'Alta           '
D CSitRecuperar   C                   'Recuperar      '
D CSitCargarDat   C                   'Cargar_Datos   '
D CSitActualizar  C                   'Actualizar     '
D CSitEnter       C                   'Enter          '

 // Constantes de tipos de ejecucion programa
D CEjeAlt         C                   'Add'
D CEjeMod         C                   'Upd'
D CEjeBor         C                   'Dlt'
D CEjeCon         C                   'Dsp'

*  Validacion
D W_Error         S               n

*  Datos seleccionados de la lista
D W_HaySeleccion  S               n
D W_OpcionSel     S              1


** Variables de trabajo
D w_Resultado     S              3
D CRtnConfirmado  C                   'OK'
D CRtnSalir       C                   'Sal'

Se define para reutilizar en todos los programas de pantalla las siguientes variables que estarán en las diferentes plantillas:

• Estructuras y variables para pantalla
• Constantes de acciones realizadas por el usuario (CAccAlta, CAccSalir etc.) 
• Variables y constantes por las que pasa el programa (WSitActual, CSitValidar etc.)
• Constantes de tipo de ejecución para programa mantenimiento (CEjeAlt , CEjeBor etc)
• Constantes de retorno al programa que le llamó (CRtnConfirmado, CRtnSalir etc)