Desarrollo en As400: Modulo. Lista para mantenimiento

Objetivo

Realizar un módulo que presenta una ventana con una lista de registros que servirá para el mantenimiento de los mismo. Tendrá opciones para acceder a la pantalla que permite dar de alta un nuevo registro o realizar las opciones de modificación, consulta o borrado de un registro existente. Además incorpora una búsqueda para seleccionar los registros que aparecen en la lista. La lista se cargará por páginas.

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 lista de registros para mantenimiento para la tabla de clientes.

Tiene el mandato F9 para dar de alta un nuevo registro. Las opciones sobre el subfichero 2, 4, 5 para realizar las opciones de mantenimiento de modificación, borrado y consulta respectivamente.

Tiene en la cabecera los campos de búsqueda para restringir la información que se muestra en la lista.

Adicionalmente he añadido una opción (8) en el subfichero para acceder a la lista de cuentas del cliente que será otra pantalla similar a esta y que utilizará la misma plantilla con el punto adicional que se presenta información del cliente al que pertenece (maestro-detalle)

Referencias: ILE estrategia, BD Pruebas

Configuración

Este programa utilizará un componente de acceso a base de datos de lista de clientes que se definió en la entrada de acceso a BD a través del uso del programa de servicio que lo contiene .

El nombre del módulo donde esta el ventana de lista de registros para mantenimiento BAN01P1

La definición de la pantalla estará definida como BAN01S1

Utiliza el programa de servicio BAN01SRV que contiene los componentes de acceso a BD.

El miembro (/Copy) con la definición del prototipo con los componentes y con la definición de estructuras será BAN01M1CP

Llamará a los módulos de mantenimiento de un registro de cliente (PAN02P1) y a la lista de cuentas asociadas a un cliente (PAN03P1)
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. BAN01S1

Se define la pantalla para presentar la lista de registros para mantenimiento.

A DSPSIZ(24 80 *DS3)
A PRINT
A R BAN01S01 SFL
A SFLNXTCHG
A S_OPCION 1A B 10 4VALUES(' ' '2' '4' '5' '8')
A S_DSCLIENT 60A O 10 21
A S_IDCLIENT 10Y 0O 10 7
A R BAN01C01 SFLCTL(BAN01S01)
A SFLSIZ(0010)
A SFLPAG(0009)
A CF03(03 'Salir')
A CF04(04 'Consulta')
A CF09(09 'Alta')
A 42 ROLLUP(26 'PAGINA ADELANTE')
A RTNCSRLOC(*RECNAME &REGCUR &CAMCUR)
A OVERLAY
A N42 SFLEND(*MORE)
A 40 SFLDSP
A SFLDSPCTL
A 41 SFLCLR
A 61 SFLMSG('Solo se puede seleccionar u-
A n registro' 61)
A SFLCSRRRN(&CURS01)
A CURS01 5S 0H
A NRR 4S 0H SFLRCDNBR(CURSOR)
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_DSCLIENT 25A B 4 55DSPATR(HI)
A 4 48'Nombre'
A 9 3'Opc'
A DSPATR(HI)
A DSPATR(UL)
A 9 7'Cliente'
A DSPATR(HI)
A DSPATR(UL)
A 7 4'2-Modificar'
A 7 31'5-Consultar'
A 7 18'4-Eliminar'
A 1 30'Lista de clientes'
A DSPATR(HI)
A 1 3'BAN01P1'
A DSPATR(HI)
A 3 48'Codigo'
A D_IDCLIENT 10Y 0B 3 55DSPATR(HI)
A EDTCDE(4)
A 5 50'Pais'
A D_IDPAIS 3A B 5 55DSPATR(HI)
A 6 42'Tipo cliente'
A D_IDTIPCLI 1A B 6 55DSPATR(HI)
A 7 45'8-Cuentas'
A R BAN01P01
A 23 5'F3-Salir'
A 23 19'F4-Consulta'
A 23 36'F9-Alta'

Se define:

El subfichero (BAN01S01) con un campo que recogerá la opción (S_OPCION) y donde se presentan los campos de identificación y descripción de cliente (S_IDCLIENT y S_DSCLIENT)
El registro de control (BAN01C01). Tendrá un campo para buscar y para restringir los datos que aparecen en la lista y buscará por código de cliente (D_IDCLIENT), por nombre de cliente (D_DSCLIENT), por código de cliente (D_IDTIPCLI) y por país (D_DSPAIS)

Para las variables de cabecera de pantalla siempre utilizo el prefijo D_ y para las de subfichero S_ y el sufijo será el nombre del campo en el fichero.

Fuente del proceso. BAN01P1

Se presenta el fuente del modulo que controla la lista de registros para mantenimiento. Utilizará el componente de acceso de base de datos similar al que se presento 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.
En color rojo, podré parte de código que no forma parte general de la plantilla y que he añadido, en este caso para utilizar la opción 8 para acceder a la lista de cuentas de un cliente.

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 lista para mantenimimiento - V1.0
*=============================================================

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

FBan01S1 CF E WORKSTN USROPN
F INFDS(CURSOR)
F SFILE(Ban01S01:NRR)

D NRR S 4 0
D G_UltReg S 4 0

// Ds de DEFINICION de los campos de busqueda de cabecera
DDs_DatosBus DS QUALIFIED
D TipoOrden 2
D IdCliente 10 0
D IdPais 3
D IdTipCli 1
D DsCliente 60

// Ds de DEFINICION de los campos de seleccion del subfichero
DDs_ClaveSel DS QUALIFIED
D IdCliente 10 0

// Ds con la clave seleccionada
D W_ClaveSel Ds LikeDs(Ds_ClaveSel)

// Ds con los datos de busqueda
D W_DatosBus Ds LikeDs(Ds_DatosBus)

** Variables de trabajo
// Paginacion
D W_Pag S 10I 0
D W_NumRegCar S 10I 0
D W_MaxReg S 10I 0
D W_TotReg S 10 0

Definición de las estructuras de datos

(Ds_DatosBus). Campos de cabecera de la ventana que sirven para buscar y restringir los datos que aparecen en la lista. Hay un campo fijo siempre que es el tipo de orden (TipoOrden) que servirá para definir la ordenación de la sentencia SQL de lectura y que utilizará para llamar al componente de acceso a base de datos.
En este ejemplo será el id de cliente, el nombre del cliente, el id de pais y el id de tipo de cliente.

Tiene asociada la variable de trabajo (W_DatosBus) que se utilizará en el programa

(Ds_ClaveSel). Contiene los campos asociados al registro de la lista que ha seleccionado el usuario para realizar el mantenimiento de dicho registro. Será el valor que se pase a la pantalla de mantenimiento de un registro. En este ejemplo el id de cliente (IdCliente)

Tiene asociada la variable de trabajo (W_ClaveSel) que se utilizará en el programa

Por último tiene las variables de trabajo definidas para almacenar la pagina de datos que se mostrará (W_Pag), el número de registros por página (W_NumRegCar), el máximo de registros que se permitirá cargar en el subfichero (W_MaxReg) y el total de registros que hay en el fichero en base a la selección de búsqueda de cabecera (W_TotReg)

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 con los campos de llamada al programa de mantenimiento
DP_ParamMante DS Qualified
D IdCliente 10 0

DBAN02P1 PR
D P_ParamMante Const LikeDs(P_ParamMante)
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

// Ds con los campos de llamada al programa de lista de cuentas
DP_ParamCuenta DS Qualified
D IdCliente 10 0

DBAN03P1 PR
D P_ParamCuenta Const LikeDs(P_ParamCuenta)
D P_Resultado 3

/COPY *LIBL/QRPGLESRC,BAN01M1CP

DDsp_CargaDsp PR
D P_DatosBus LikeDs(Ds_DatosBus) Const

DDsp_DatosDspLst PR
D P_Accion Like(WAccActual)
D P_AccionCons 10

DDsp_ObtCab PR
D P_DatosBus LikeDs(Ds_DatosBus)

DDsp_ValidarLst PR
D P_Error n
* Seleccionado
D P_HaySeleccion n
D P_OpcionSel 1
D P_ClaveSel LikeDs(Ds_ClaveSel)

DEje_Pgm PR
D P_TipoPgm 3 Const

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. (Ver entrada de componente de acceso a base de datos)

Llamadas a módulos y programas

El nombre del modulo (BAN02P1) es el módulo de mantenimiento de un registro (lo veremos en otra entrada en este blog en unos días). 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.
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.

Siguiendo la misma línea anterior, he añadido una nueva opción para acceder a una pantalla que presenta la lista de cuentas de un cliente y para ello se llamará al módulo (BAN03P1) que será una lista de registros para mantenimiento igual que esta pero añadiendo que forma parte del detalle asociado a un maestro. Esta opción no pertenece a la plantilla pero es facilmente añadible para darle más funcionalidad. Tiene una estructura (P_ParamCuenta) con los campos de entrada que en este caso será el id de cliente (IdCliente) para el cual se presentarán sus cuentas.

Procedimientos internos

(Dsp_CargaDsp) Se utilizará para cargar los campos y datos de la ventana
(Dsp_DatosDspLst) Se utilizará para procesar la lista y obtener la acción realizada por el usuario
(Dsp_ObtCab) Se utilizará para obtener los campos de cabecera de pantalla (busqueda) rellenados por el usuario
(Dsp_ValidarLst) Se utilizará para validar las opciones de la lista y recuperar el registro y la opción seleccionada por el usuario
(Eje_Pgm) Se utilizará para controlar todas las llamadas a otros módulos (pantalla de mantenimiento, lista de cuentas) o llamadas a programas (lista de países, lista de tipos de clientes).

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 Ban01S1;

WSitActual= CSitCargarDsp;

Clear W_DatosBus;
W_DatosBus.TipoOrden ='1A';
W_Pag = *Zeros;
W_NumRegCar = 9; // Si es por pag, no poner 0
W_MaxReg = 99;

Dow WSitActual<>CSitFinalizar;
Select;

////////////////////////////////////////////////////////////
// VISTA: Cargar la pantalla /////////////////////////////
////////////////////////////////////////////////////////////
When WSitActual = CSitCargarDsp;
Dsp_CargaDsp(W_DatosBus);
WSitActual= CSitShowDatos;

////////////////////////////////////////////////////////////
// VISTA: Presenta datos de pantalla ///////////////////
////////////////////////////////////////////////////////////
When WSitActual = CSitShowDatos;
Dsp_DatosDspLst (W_Accion : W_AccionCons);
Select;
When W_Accion=CAccSalir;
WSitActual= CSitFinalizar;
When W_Accion=CAccAlta;
WSitActual = CSitAlta;
When W_Accion=CPagSig;
WSitActual= CSitCargarDsp;
When W_Accion=CAccEnter;
W_Pag = *Zeros;
WSitActual = CSitValidar;
When W_Accion=CAccCons;
Eje_Pgm('F4 ');
EndSl;

////////////////////////////////////////////////////////////
// VISTA: Valida los datos de pantalla ///////////////////
////////////////////////////////////////////////////////////
When WSitActual = CSitValidar;
Dsp_ValidarLst (W_Error : W_HaySeleccion : W_OpcionSel :
W_ClaveSel);
If Not W_Error;
If W_HaySeleccion;
Select;
When W_OpcionSel='2';
Eje_Pgm('Upd');
If w_Resultado = CRtnConfirmado;
WSitActual = CSitCargarDsp;
Else;
WSitActual = CSitShowDatos;
EndIf;
When W_OpcionSel='4';
Eje_Pgm('Dlt');
If w_Resultado = CRtnConfirmado;
WSitActual = CSitCargarDsp;
Else;
WSitActual = CSitShowDatos;
EndIf;
When W_OpcionSel='5';
Eje_Pgm('Dsp');
WSitActual = CSitShowDatos;

When W_OpcionSel='8';
Eje_Pgm('Cue');
If w_Resultado = CRtnConfirmado;
WSitActual = CSitShowDatos;
Else;
WSitActual = CSitShowDatos;
EndIf;
Other;
WSitActual= CSitShowDatos;
EndSl;
Else;
// Recarga la lista segun la selección
Dsp_ObtCab(W_DatosBus);
WSitActual = CSitCargarDsp;
EndIf;
Else;
WSitActual= CSitShowDatos;
EndIf;

////////////////////////////////////////////////////////
// CONTROLADOR: Llamar al proceso de alta //////////////
////////////////////////////////////////////////////////
When WSitActual = CSitAlta;
Eje_Pgm(CEjeAlt);
If w_Resultado = CRtnConfirmado;
W_Pag = *Zeros;
WSitActual = CSitCargarDsp;
Else;
WSitActual = CSitShowDatos;
EndIf;
EndSl;
EndDo;

Close Ban01S1;
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:

(CSitCargarDsp). Es la inicial. Realizará la carga de los campos de cabecera de pantalla (búsqueda) y la lista del registros del subfichero.
(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 alta (W_Accion=CAccAlta) accederá a las acciones asociadas a este mandato (WSitActual = CSitAlta).Si ha pulsado pagina siguiente (W_Accion=CPagSig) pasara a las acciones de cargar nueva página (WSitActual= CSitCargarDsp).
Si ha pulsado enter (W_Accion=CAccEnter) pasará a validar la pantalla (WSitActual = CSitValidar)
Si ha pulsado F4 (W_Accion=CAccCons) accederá a la rutina interna de control de llamadas indicando que se ha pulsado F4.
(CSitValidar). Valida el subfichero y si es correcto y el usuario ha seleccionado algo, recoge la selección de registro elegido por el usuario y llamará a la rutina interna de control de programas pasando la opción elegida. Al finalizar la llamada, recogerá el código de retorno y en base a ello y a la opción seleccionada, realizará una acción u otra.
Se ha añadido la opción 8 (W_OpcionSel='8') de acceder a la lista de cuentas del cliente.
(CSitAlta). Llama al procedimiento interno de control de llamada pasándole que la acción es alta.
(CSitFinalizar). Finaliza el proceso.

Componente interno de Carga de pantalla

Realiza la carga de la cabecera de la pantalla y del subfichero,

PDsp_CargaDsp B
DDsp_CargaDsp PI
D P_DatosBus LikeDs(Ds_DatosBus) Const

D W_DatosLst Ds Dim(99) LikeDs(Ds_BasClie)
D W_Sel DS LikeDs(Ds_SelClie)
D W_NumReg S 2 0
D WIdx S 4 0

/Free
// Carga los campos de cabecera de la pantalla
D_IdClient = P_DatosBus.IdCliente;
D_IdPais = P_DatosBus.IdPais;
D_IdTipCli = P_DatosBus.IdTipCli;
D_DsClient = P_DatosBus.DsCliente;

// Inicializa el subfichero
If W_Pag=*Zeros;
G_UltReg=*Zeros;
Nrr=*Zeros;
*In40=*Off; // Sfl Dsp
*in41=*On; // Sfl Clear
*in42=*On; // Permite RollUp
EndIf;
Write Ban01c01;
*in41=*Off; // Sfl Clear

W_Pag = W_Pag + 1;
Clear W_Sel;
W_Sel.K_IdCliente = P_DatosBus.IdCliente;
W_Sel.S_DsCliente = P_DatosBus.DsCliente;
W_Sel.S_IdPais = P_DatosBus.IdPais;
W_Sel.S_IdTipCli = P_DatosBus.IdTipCli;
Obt_LstClientes(w_DatosLst : W_NumReg : W_TotReg :
W_Pag : W_NumRegCar : P_DatosBus.TipoOrden :
W_Sel);

// Carga la lista del subfichero
For wIdx=1 to W_NumReg;
If G_UltReg<=W_Maxreg;
G_UltReg = G_UltReg+1;
S_Opcion = *Blanks;
S_IdClient = W_DatosLst(wIdx).IdCliente;
S_DsClient = %Trim(W_DatosLst(wIdx).Nombre) + ' ' +
%Trim(W_DatosLst(wIdx).Apellidos);
Nrr = G_UltReg;
Write Ban01S01;
EndIf;
EndFor;

// Verificar si ha cargado algun registro para presentarlo
If G_UltReg>=1;
*In40=*On;
Nrr = (W_Pag - 1) * W_NumRegCar + 1; // El primero de pag
EndIf;

If G_UltReg = W_TotReg;
*In42=*Off; // NO permite RollUp
EndIf;
/End-Free
P E

Primero carga las variables de cabecera de la pantalla que son los campos de búsqueda. Lo carga con el contenido que tenga en la estructura; inicialmente serán blancos/ceros pero posteriormente tendrá lo escrito por el usuario.
Después inicializa el subfichero.
Y por último cargará el subfichero. Para ello leerá el componente de acceso a base de datos (Obt_LstClientes) con los parámetros para que devuelva el máximo de registros y utilice la selección del campo de búsqueda indicado por el usuario. La pagina será la actual más uno ; en la primera ejecución será cero por lo que dará la página una y posteriormente cuando se pulse rollup sumará una página.
Leerá la tabla de registros devuelta y por cada uno de ellos, generará un registro en la lista.

Componente interno de Obtener campos de cabecera

PDsp_ObtCab B
DDsp_ObtCab PI
D P_DatosBus LikeDs(Ds_DatosBus)

/Free
Clear P_DatosBus;
P_DatosBus.IdCliente = D_IdClient;
// Si el campo codigo no esta informado,se recuperan el resto
If P_DatosBus.IdCliente = *Zeros;
P_DatosBus.IdPais = D_IdPais;
P_DatosBus.IdTipCli = D_IdTipCli;
P_DatosBus.DsCliente = D_DsClient;
EndIf;
/End-Free
P E

Recupera los datos de cabecera seleccionados por el usuario y los carga sobre la estructura de datos para búsqueda (P_DatosBus)

Componente interno de Presentar pantalla

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

PDsp_DatosDspLst B
DDsp_DatosDspLst PI
D P_Accion Like(WAccActual)
D P_AccionCons 10

/Free

// Pie de la ventana
Write Ban01P01;

Exfmt Ban01C01;

Select;
When *In03=*On;
P_Accion=CAccSalir;
When *In09=*On;
P_Accion=CAccAlta;
When *In26=*On;
P_Accion=CPagSig;
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

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 Validar pantalla

Se valida el subfichero y se recoge la selección realizada por el usuario.

PDsp_ValidarLst B
DDsp_ValidarLst PI
D P_Error n
* Seleccionado
D P_HaySeleccion n
D P_OpcionSel 1
D P_ClaveSel LikeDs(Ds_ClaveSel)

D WNrr S 4 0
D WNrrSel S 4 0
/Free
P_HaySeleccion=*Off;
P_Error=*off;
P_ClaveSel=*Zeros;

*In61=*Off;

If Nrr>*Zeros;
// Verifica que no hay errores en la seleccion
WNrr=1;
Chain WNrr Ban01S01;
Dow %Found and Not P_Error;
If S_Opcion<>*Blanks;
If Not P_HaySeleccion;
P_HaySeleccion=*On;
Else;
P_Error=*on;
*In61=*On;
Nrr=WNrr;
Iter;
EndIf;
EndIf;
Update Ban01S01;
WNrr=WNrr+1;
Chain WNrr Ban01S01;
EndDo;

// Comprueba la opcion seleccionada (si la hay)
If Not P_Error and P_HaySeleccion;
WNrr=1;
Chain WNrr Ban01S01;
Dow %Found and Not P_Error;
If S_Opcion<>*blanks;
P_ClaveSel.IdCliente = S_IdClient;
P_OpcionSel = S_Opcion;
S_Opcion = *Blanks;
WNrrSel=WNrr;
Update Ban01S01;
EndIf;
WNrr = WNrr+1;
Chain WNrr Ban01S01;
EndDo;
Nrr = WNrrSel;
EndIf;
EndIf;
/End-Free
P E

En el proceso se valida que solo se haya seleccionado un registro. Si no hay error, recupera los datos del registro seleccionado (S_IdCliente).

Componente interno de Control de llamadas a programas

Se encarga de realizar las llamadas a los módulos o programas según las acción recibida (alta, baja, etc.)

PEje_Pgm B
DEje_Pgm PI
D P_TipoPgm 3 Const

/Free
Select;
When P_TipoPgm = CEjeAlt;
P_ParamMante.IdCliente = *Zeros;
Ban02P1(P_ParamMante : P_TipoPgm : w_Resultado);
When P_TipoPgm = CEjeMod;
P_ParamMante.IdCliente = w_ClaveSel.IdCliente;
Ban02P1(P_ParamMante : P_TipoPgm : w_Resultado);
When P_TipoPgm = CEjeBor;
P_ParamMante.IdCliente = w_ClaveSel.IdCliente;
Ban02P1(P_ParamMante : P_TipoPgm : w_Resultado);
When P_TipoPgm = CEjeCon;
P_ParamMante.IdCliente = w_ClaveSel.IdCliente;
Ban02P1(P_ParamMante : P_TipoPgm : w_Resultado);
When P_TipoPgm = 'F4 ';
Select;
When W_AccionCons='PAIS';
BAN40P1EJ (P_ParamF4Pais : w_Resultado);
If w_Resultado = CRtnConfirmado;
W_DatosBus.IdPais = P_ParamF4Pais.IdPais;
W_Pag = *Zeros;
WSitActual = CSitCargarDsp;
Else;
WSitActual = CSitShowDatos;
EndIf;
When W_AccionCons='TPCL';
BAN40P2EJ (P_ParamF4TpCl : w_Resultado);
If w_Resultado = CRtnConfirmado;
W_DatosBus.IdTipCli = P_ParamF4TpCl.IdTipCli;
W_Pag = *Zeros;
WSitActual = CSitCargarDsp;
Else;
WSitActual = CSitShowDatos;
EndIf;
EndSl;

When P_TipoPgm = 'Cue';
P_ParamCuenta.IdCliente = w_ClaveSel.IdCliente;
Ban03P1(P_ParamCuenta : w_Resultado);
EndSl;
/End-Free
P E

Las opciones de consulta F4 son opcionales pero en este programa esta incluidas para las llamadas a la lista de países y de tipos de cliente.

Igualmente se han incluido sentencias (que no forman parte de la plantilla general) para realizar la llamada a la lista de cuentas del cliente.

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)

Desarrollo en As400

miércoles, 22 de mayo de 2013

Modulo. Lista para mantenimiento

Objetivo

Configuración

Fuente de la pantalla. BAN01S1

Fuente del proceso. BAN01P1

Definición ficheros y variables

Recursos y definición de prototipos internos.

Flujo principal

Componente interno de Carga de pantalla

Componente interno de Obtener campos de cabecera

Componente interno de Presentar pantalla

Componente interno de Validar pantalla

Componente interno de Control de llamadas a programas

Anexo. /Copy BAN00VAR declaraciones generales y comunes

No hay comentarios:

Publicar un comentario