Sviluppare una applicazione Oracle APEX in grado di generare Form Dinamiche è decisamente qualcosa di poco “low -code“.

Come scoprirai tra poco, è necessario avere un po’ di dimestichezza con il PL-SQL e bisogna conoscere le API che APEX mette a disposizione degli sviluppatori più intrepidi.

Per questo motivo tengo ad avvisarti che ci sarà da lavorare un po‘ ma ti assicuro che il risultato finale sarà molto interessante.

Una form dinamica è una pagina APEX i cui campi per inserire le informazioni non sono definiti a priori ma vengono costruiti dinamicamente da Oracle APEX in funzione di una serie di parametri di configurazione.

Per costruire una Form Dinamica in Oracle APEX utilizzeremo due oggetti in particolare:

• il componente PL-SQL Dynamic Layout che si usa per visualizzare codice HTML generato una una funzione PL-SQL
• la libreria PL/SQL APEX_ITEM

Sei pronto? Iniziamo!

Cos’è una Form Dinamica in Oracle APEX

Prima di addentrarci nei dettagli del tutorial vorrei spiegarti cosa andremo a sviluppare.

L’idea è di creare una applicazione che sia grado di generare delle form dinamiche, ossia delle pagine APEX i cui campi vengono generati a runtime.

Questo vuol dire che potrai estendere la tua applicazione APEX con delle maschere che non vanno implementate ogni volta da zero ma che, piuttosto, possono essere configurate utilizzando un Form Builder.

Ma cosa vuol dire tutto questo in pratica? Proviamo a darci qualche obiettivo più concreto.

• Vogliamo creare una applicazione che ci consenta di definire una maschera per inserire delle informazioni.
• Configurare una maschera significa definire quali e quanti campi visualizzare piuttosto che il loro ordinamento.
• Inoltre, cosa fondamentale, la maschera dinamica deve poter essere in grado di leggere e salvare nel database i dati.

Quindi, in estrema sintesi, abbiamo bisogno di creare 3 oggetti

• Dynamic Form Builder: un modulo per gestire la configurazione di una form
• Dynamic Form Viewer: un componente che si occupa di generare e la form
• Dynamic Form Data Parser: un componente che gestisce il comportamento della form, come ad esempio il salvataggio delle informazioni in un formato generico e riutilizzabile

Se lo desideri puoi vedere questa applicazione di esempio che ho creato per scrivere questo tutorial.

Fammi sapere cosa ne pensi!

Parte 1: Dynamic Form Builder

Una form o maschera è un elenco di campi dove l’utente può scrivere delle informazioni.

Esistono diversi tipi di campi che possono essere utilizzati in una applicazione APEX: Text Field, Text Area, Date Popup, Select List, ecc…

Ciascuno delle tipologie di campi è caratterizzata da proprietà specifiche.

Ad esempio, un campo di tipo Text Field avrà una lunghezza mentre un campo Date Field sarà caratterizzato da un formato.

Il Form Builder che andremo a creare non sarà altro che una tabella di configurazione in cui andremo a specificare per ciascuna form quali e quanti campi visualizzare.

Per ciascun campo l’utente dovrà indicare alcune informazioni generali (etichetta, ordinamento, tipologia) piuttosto che alcune informazioni specifiche per quel tipo di campo

Setup Database

Prima di tutto creiamo le tabelle del database che useremo per gestire le informazioni

• Accedi all’APP Builder di Oracle APEX
• Vai in SQL Workshop > SQL Commands
• Lancia i seguenti scripts SQL

create table dynamic_form (
	id          number,
	name        varchar2(250 char),
	description varchar2(4000 char),
        form_data   clob,
	constraint dynamic_id_pk primary key ( id )
);
create table dynamic_form_field (
	id                number,
	form_id           number not null enable,
	field_label       varchar2(2000 char),
	field_sorting     number,
	field_type        varchar2(500 char),
	field_length      number,
	field_max_length  number,
	field_n_rows      number,
	field_n_cols      number,
	field_list_values varchar2(4000 byte),
	field_date_format varchar2(250 byte),
	is_required       varchar2(20 byte),
	field_id          varchar2(20 byte),
	constraint dynamic_form_field_id_pk primary key ( id )
);
create or replace  trigger dynamic_form_field_tr1 before
	insert on dynamic_form_field
	referencing
			old as old
			new as new
	for each row
begin
	:new.field_id := 'P' || :new.form_id || '_' || :new.id;
end;
create sequence dynamic_form_s;
create sequence dynamic_form_field_s;

Setup Applicazione APEX

Ora che abbiamo creato le tabelle del database, possiamo procedere con lo sviluppo della nostra applicazione che sarà di tipo Interactive Report + Form.

La pagina principale sarà un Interactive Report. Da qui potrai vedere l’elenco di tutte le form che sono state configurate nell’applicazione

Cliccando sul link Edit Form sarà possibile visualizzare il dettaglio della form (nome e descrizione) e l’elenco dei campi che sono stati configurati.

• Accedi all’APP Builder e crea una nuova applicazione
• Crea una nuova pagina di tipo Report with Form

• Nella schermata di configurazione della pagina specifica il nome del report e della form
  • Report Page Name: My Forms
  • Form Page Name: Form Setup
• Premi Next

• Configura il Navigation Menu e premi Next

• Nella sezione Data Source specifica la tabella DYNAMIC_FORM che hai creato precedentemente

• Nella sezione Form Page indica la colonna Primary Key e premi Create

Alla fine dell’operazione dovresti vedere 2 nuove pagine nella tua APP: My Forms e Form Setup.

• Clicca sulla definizione della Page Form Setup

• Clicca sul Page Item PX_ID

Vai nelle proprietà del Page Item sotto la sezione Default ed imposta i seguenti valori

• Type: Sequence
• Sequence: DYNAMIC_FORM_S (è la sequence di database che dovresti aver creato precedentemente)

• Esegui la Preview
• Premi Create

• Inserisci un nome ed una descrizione della form e premi Create

• Il record è stato creato. Clicca su link Modifica

Completiamo la costruzione del Form Designer con la funzionalità che permetterà di definire il layout della form

• Accedi all’APP Builder e seleziona la Page Form Setup

• Aggiungi una nuova Page Region di tipo Interactive Grid

• Configura l’Interactive Grid in questo modo
  • Source: Local Database
  • Type: Table
  • Table Name: DYNAMIC_FORM_FIELD (la seconda delle due tabelle che abbiamo creato)
  • Where Clause: inserisci la stringa FORM_ID = :PX_ID dove PX_ID è il Page Item che abbiamo create precedentemente

• Vai in Attributes e attiva l’opzione Edit

• Espandi il nodo Columns e per configurare i campi dell’Interactive Grid

• Colonna ID
  • Type: Hidden
  • Default Value: Sequence DYNAMIC_FORM_FIELD_S

• Colonna FORM_ID
  • Type: Hidden
  • Default Value: Page Item PX_ID

• Colonna FIELD_ID
  • Type: Hidden
• Colonna FIELD_LABEL
  • Type: Text Field
  • Value Required: Yes
• Colonna FIELD_SORTING
  • Type: Numeric Field
  • Value Required: Yes
  • Minimum Value: 1
  • Maximum Value: 50
  • Format Mask: 999G999G999G999G999G999G990

• Colonna FIELD_TYPE
  • Type: Select List
  • Value Required: Yes
  • Select List Values: inserisci le seguenti opzioni.

• Colonna IS_REQUIRED
  • Type: Switch
  • Default Value: Static Value N

• Colonna FIELD_LENGTH
  • Type: Numeric Field
  • Minimum Value: 1
  • Format Mask: 999G999G999G999G999G999G990

• Colonna FIELD_MAX_LENGTH
  • Type: Numeric Field
  • Minimum Value: 1
  • Format Mask: 999G999G999G999G999G999G990

• Colonna FIELD_N_ROWS
  • Type: Numeric Field
  • Minimum Value: 1
  • Format Mask: 999G999G999G999G999G999G990

• Colonna FIELD_N_COLS
  • Type: Numeric Field
  • Minimum Value: 1
  • Format Mask: 999G999G999G999G999G999G990

• Colonna FIELD_LIST_VALUES
  • Type: Text Area

• Colonna FIELD_DATE_FORMAT
  • Type: Text Field

• Esegui la Preview dell’applicazione. Se hai fatto tutto correttamente dovresti essere in grado di definire tutti i campi che vuoi visualizzare nella form aggiungendo una riga alla tabella Setup Field
• La configurazione di un singolo campo della form dinamica richiede alcune informazioni obbligatorie ed alcune opzionali. Tra poco le vedremo nel dettaglio.

Parte 2: Dynamic Form Viewer

Ora che abbiamo costruito un applicazione tramite la quale possiamo configurare tutte le form dinamiche che desideriamo, passiamo alla parte forse un po’ più complicata di questo tutorial: la creazione di un componente in grado leggere la configurazione della form per generarla a runtime.

Procediamo per passi.

Prima di tutto creiamo un pulsante tramite il quale richiamare il Form Viewer.

Pulsante View Form

• Accedi all’APP Builder
• Clicca su Create Page e seleziona il Page Type Blank

• Dai il nome View Form alla pagina e seleziona il Page Mode Modal Dialog. Clicca Next.

• Seleziona l’opzione Do not associate this page with a navigation menu entry e clicca Next e successivamente Finish.

• Crea una nuova Page Region di tipo PL/SQL Dynamic Content
• Crea un Page Item di tipo Hidden Field

• Seleziona la Page Region Form Viewer. La peculiarità di questo componente sta nel fatto che è in grado di visualizzare il codice HTML che viene generato lato server da codice PL-SQL.
• Vai alla proprietà PL/SQL Code ed inserisci la seguente istruzione PL-SQL

sys.htp.p('<strong>Form Viewer - Form ID '||:p6_form_id||'</strong>');

Per testare il comportamento della pagina Form Viewer definiamo un link dalla pagina Form Setup.

• Apri l’APP Builder e seleziona la pagina Form Setup

• Crea un Page Button di nome View Form

• Vai alle proprietà del Page Button e specifica le seguenti proprietà
  • Action: Redirect do Page in this Application
  • Target: seleziona la pagina modale Form Viewer che hai creato pochi minuti fa

• Vai alle proprietà del Link e configura il parametro PX_FORM_ID

• Esegui la Preview dell’applicazione. Apri la definizione di una form che hai precedentemente creato e clicca sul bottone View Form

• Come risultato dovresti vedere aprirsi una pagina modale il cui contenuto altri non è che il risultato dell’istruzione PL-SQL che abbiamo inserito all’interno del componente PL-SQL Dynamic Content.

Penso che arrivati a questo punto dovrebbe esserti chiaro come costruiremo il Form Viewer: definiremo una funzione PL-SQL che accetta come parametro l’ID della form da visualizzare e restituisce in output il codice HTML della form.

Libreria APEX_ITEM

C’è un modo per visualizzare dei componenti APEX senza doverli creare esplicitamente nella definizione della pagina?

La risposta è si.

La libreria PL-SQL APEX_ITEM consente agli sviluppatori di generare i Page Items dinamicamente usando, ad esempio, una query SQL.

Usata spesso per creare tabella interattive, con l’avvento dell’Interactive Grid il suo utilizzo nel tempo è diventato meno frequente.

Tuttavia, nel nostro caso ritrova una sua utilità. Prima di tutto, cerchiamo di capire come funziona questa libreria facendo qualche esempio.

Se consultiamo la documentazione possiamo scoprire qualcosa in più su questa libreria: ad esempio, quale parametri accetta:

APEX_ITEM.TEXT(
    p_idx         IN    NUMBER,
    p_value       IN    VARCHAR2 DEFAULT NULL,
    p_size        IN    NUMBER DEFAULT NULL,
    p_maxlength   IN    NUMBER DEFAULT NULL,
    p_attributes  IN    VARCHAR2 DEFAULT NULL,
    p_item_id     IN    VARCHAR2 DEFAULT NULL,
    p_item_label  IN    VARCHAR2 DEFAULT NULL)
    RETURN VARCHAR2;

• p_idx è un numero che identificherà all’interno della sessione il campo specifico e servirà per recuperare il valore inserito dall’utente usando la libreria APEX_APPLICATION. Può assumere un valore da 1 a 50.
• p_value è il valore con il quale desideriamo inizializzare il Text Item
• p_size è la lunghezza del campo di test
• p_maxlenght è la lunghezza massima della stringa che può essere scritta all’interno del Text Item
• p_attributes è un parametro che serve ad specificare parametri aggiuntivi che verranno inclusi all’interno del codice HTML. Tra poco vedremo meglio come funziona.
• p_item_id: rappresenta l’attributo HTML ID che viene incluso all’interno del tag <input>
• p_item_label: etichetta del campo

Facciamo un esempio pratico. A tal proposito ho creato una nuova pagina APEX di test con un componente di tipo PL-SQL Dynamic Layout all’interno della quale visualizzeremo un semplice Text Item usando la funzione APEX_ITEM.TEXT

• Inserisci nella definizione della region il seguente script PL-SQL

sys.htp.p(apex_item.text(
	              p_idx => 1,
	              p_value => 'test value 1',
	              p_size => 35,
	              p_maxlength => 50,
	              p_attributes => null,
	              p_item_id => 'textitem01',
	              p_item_label => 'Text Items 1'
	));

sys.htp.p(apex_item.text(
	              p_idx => 2,
	              p_value => 'test value 2' ,
	              p_size => 15,
	              p_maxlength => 50,
	              p_attributes => null,
	              p_item_id => 'textitem02',
	              p_item_label => 'Text Items 2'
	));

• Esegui la Page Preview.

Il risultato, immagino concorderai con me, non è molto incoraggiante.

1. Le label non vengono visualizzate.
2. I campi sono in linea.
3. Il look & feel non è quello standard APEX.

La differenza è palese se li mettiamo a confronto con i campi standard

Come possiamo migliorare il risultato?

• Modifichiamo il codice PL-SQL valorizzando il parametro p_attributes come nello script seguente

sys.htp.p(
	apex_item.text(
	              p_idx => 1,
	              p_value => 'test value 1',
	              p_size => 35,
	              p_maxlength => 50,
	              p_attributes => ' class="text_field apex-item-text" ',
	              p_item_id => 'textitem01',
	              p_item_label => 'Text Items 1'
	)
);

sys.htp.p(
	apex_item.text(
	              p_idx => 2,
	              p_value => 'test value 2',
	              p_size => 15,
	              p_maxlength => 50,
	              p_attributes => ' class="text_field apex-item-text" ',
	              p_item_id => 'textitem02',
	              p_item_label => 'Text Items 2'
	)
);

• Esegui la Page Preview:

Come vedi l’aspetto dei campi dinamici è cambiato, tuttavia non è ancora quello che ci aspetteremmo, non credi?

Devo essere onesto con te.

Purtroppo, la libreria APEX_ITEM ha un limite: non permette di visualizzare i Page Items utilizzando i Template ed in effetti non possiamo fare molto di più in tale senso.

Tuttavia, possiamo ancora utilizzare la libreria APEX_ITEM a nostro vantaggio.

Vediamo insieme un metodo

• Dal menù del browser attiva la Developer Mode. In Google Chrome puoi trovarla qui:

• Seleziona con il mouse il form container che racchiude il Text Item standard.

• Con questa piccola tecnica riusciamo a scoprire qual è il codice HTML da usare visualizzare correttamente un Text Item di tipo Floating.

<div class="t-Form-fieldContainer t-Form-fieldContainer--floatingLabel lto33519637226746033913_0 apex-item-wrapper apex-item-wrapper--text-field" id="P2_STD_TEXT_ITEM_01_CONTAINER">
   <div class="t-Form-labelContainer">
      <label for="P2_STD_TEXT_ITEM_01" id="P2_STD_TEXT_ITEM_01_LABEL" class="t-Form-label">Standard Text Item 01</label>
   </div>
   <div class="t-Form-inputContainer">
      <div class="t-Form-itemWrapper"><input type="text" id="P2_STD_TEXT_ITEM_01" name="P2_STD_TEXT_ITEM_01" class="text_field apex-item-text" value="" size="30"></div>
      <span id="P2_STD_TEXT_ITEM_01_error_placeholder" class="a-Form-error" data-template-id="33453230398982002568_ET"></span>
   </div>
</div>

Quello che segue è, invece, l’HTML generato dalla funzione APEX_ITEM.TEXT

<label for="textitem01" class="u-VisuallyHidden">Text Items 1</label>
<input type="text" name="f01" size="35" maxlength="50" value="test value 1" class="text_field apex-item-text" id="textitem01">

Quello che possiamo fare è usare la libreria APEX_ITEM per generare il tag <input> ma poi definire una funzione PL-SQL custom per generare l’HTML completo.

Ecco una funzione di esempio che genera un Text Item APEX simile a quello classico.

create or replace  function appin5minuti_text (
        p_idx        in number
      , p_value      in varchar2 default null
      , p_size       in number default null
      , p_maxlength  in number default null
      , p_attributes in varchar2 default null
      , p_item_id    in varchar2 default null
      , p_item_label in varchar2 default null
    ) return clob is
        l_final_html       clob;
        l_input_html_tag      clob;
    begin
        /* generate text input html*/
        l_input_html_tag      := apex_item.text(
                                     p_idx => p_idx
                                   , p_value => p_value
                                   , p_size => p_size
                                   , p_maxlength => p_maxlength
                                   , p_attributes => p_attributes
                                   , p_item_id => p_item_id
                                   , p_item_label => p_item_label
                                    );
				l_final_html := '<div class="t-Form-fieldContainer t-Form-fieldContainer--floatingLabel lto33519637226746033913_0 apex-item-wrapper apex-item-wrapper--text-field" id="'|| p_item_id ||'_CONTAINER">
                                    <div class="t-Form-labelContainer">
                                        <label for="'|| p_item_id ||'" id="'|| p_item_id ||'_LABEL" class="t-Form-label">'|| p_item_label ||'</label>
                                    </div>
                                    <div class="t-Form-inputContainer">
                                        <div class="t-Form-itemWrapper">'||l_input_html_tag||'</div>
                                        <span id="'|| p_item_id ||'_error_placeholder" class="a-Form-error" data-template-id="33453230398982002568_ET"></span>
                                    </div>
                                </div>';
        return l_final_html;
    exception
        when others then return '<div>Error Displaying Field</div>';
    end;

Ora che abbiamo definito la nostra versione personalizzata della funzione TEXT, andiamo a sostituire nel componente PL-SQL Dynamic Content la chiamata alla funzione APEX_ITEM.TEXT con la funzione APPIN5MINUTI_TEXT.

sys.htp.p(
	APPIN5MINUTI_TEXT(
	              p_idx => 1,
	              p_value => 'test value 1',
	              p_size => 35,
	              p_maxlength => 50,
	              p_attributes => ' class="text_field apex-item-text" ',
	              p_item_id => 'textitem01',
	              p_item_label => 'Text Items 1'
	)
);

sys.htp.p(
	APPIN5MINUTI_TEXT(
	              p_idx => 2,
	              p_value => 'test value 2',
	              p_size => 15,
	              p_maxlength => 50,
	              p_attributes => ' class="text_field apex-item-text" ',
	              p_item_id => 'textitem02',
	              p_item_label => 'Text Items 2'
	)
);

• Esegui la Page Preview per vedere il risultato che, come puoi notare, è esattamente quello che ci aspettavamo. Perfetto!

A questo punto, seguendo lo stesso metodo, possiamo implementare anche le altre tipologie di Page Items.

Libreria APPIN5MINUTI_ITEM

Seguendo la stesso metodo che ti ho spiegato nel paragrafo precedente, ho creato un package PL-SQL che ti consente di visualizzare i seguenti tipi di Page Item

• Text Field
• Text Area
• Date Picker
• Number Field
• Select List di tipo Static Values
• Switch

• Accedi alla funzionalità SQL Workshop > SQL Commands
• Compila il seguente questo package PL-SQL che contiene una serie di funzioni che useremo tra poco per visualizzare le date nella form

• Se lo desideri puoi testare la libreria che ti ho fornito usando uno script di test che ho preparato per te.
  • Crea una region di tipo PL-SQL Dynamic Content
  • Inserisci il seguente script

sys.htp.p(
	appin5minuti_item.text(
	              p_idx => 1,
	              p_value => 'Dynamic Text Item',
	              p_size => 35,
	              p_maxlength => 50,
	              p_attributes => ' class="text_field apex-item-text" ',
	              p_item_id => 'item01',
	              p_item_label => 'Dynamic Text Item Label'
	)
);

sys.htp.p(
	appin5minuti_item.textarea(
	              p_idx => 2,
	              p_value => 'Dynamic Text Area',
	              p_rows  => 5,
                  p_cols  => 15,
	              p_attributes => '  class="textarea apex-item-textarea" data-resizable="true" style="resize: both;" ',
	              p_item_id => 'item02',
	              p_item_label => 'Dynamic Text Area Label'
	)
);
sys.htp.p(
	appin5minuti_item.date_popup(
	              p_idx => 3,
	              p_value => null,
	              p_date_format => 'dd/MM/yyyy',
                  p_size        => null,
                  p_maxlength   => null,
	              p_attributes => ' class="oj-inputdatetime-input oj-text-field-input oj-component-initnode has-floating-label" ',
	              p_item_id => 'item03',
	              p_item_label => 'Dynamic Date Picker Label'
	)
);
sys.htp.p(
	appin5minuti_item.text(
	              p_idx => 4,
	              p_value => 999,
	              p_size => 35,
	              p_maxlength => 50,
	              p_attributes => ' class="number_field apex-item-text apex-item-number" style="text-align:right" ',
	              p_item_id => 'item03',
	              p_item_label => 'Dynamic Number Item Label'
	)
);
sys.htp.p(
	appin5minuti_item.select_list(
	              p_idx => 5,
	              p_value => null,
	              p_list_values => 'Display1;Return1,Display2;Return2',
	              p_attributes => ' class="selectlist apex-item-select" ',
	              p_item_id => 'item04',
	              p_item_label => 'Dynamic Select List Label'
	)
);
sys.htp.p(
	appin5minuti_item.switch(
	              p_idx => 6,
	              p_value => null,
	              p_attributes => null,
	              p_item_id => 'item05',
	              p_item_label => 'Dynamic Switch Label'
	)
);

Visualizzare la Form

Ora che abbiamo a disposizione una libreria custom che ci permette di creare all’interno di una applicazione dei Page Items, possiamo finalmente usarla all’interno del Form Viewer

• Accedi all’APP Builder.
• Seleziona la pagina View Form e seleziona il componente PL-SQL Dynamic Layout

• Vai alle proprietà del componente ed inserisci il seguente script PL-SQL

sys.htp.p(appin5minuti_item.print_form(:px_form_id));

La funzione print_form che puoi trovare nel package appin5minuti_item si occupa di generare automaticamente tutto il codice HTML necessario per visualizzare la form.

A questo punto non ci resta che provare.

• Accedi all’applicazione ed apri il Form Designer
• Configura una Form
• Quando hi fatto premi View Form

• Ecco il risultato

• Senza sviluppare ulteriore codice, posso configurare una form completamente diversa

• Il risultato

Parte 3: Dynamic Form Data Parser

Vorrei concludere l’ultima parte di questo tutorial spiegando come puoi recuperare e manipolare le informazioni che vengono inserite nella form.

In una applicazione APEX è possibile recuperare i valori inseriti nei Page Items in diversi modi.

Ad esempio nel codice PL-SQL che usi in una Dynamic Action o in un Page Process puoi utilizzare direttamente i placeholders (i nomi dei Page Items).

Se, d’altro canto, stai scrivendo JavaScript puoi usare l’istruzione apex.item(“ITEMNAME”).getValue().

Nel caso dei campi creati attraverso la libreria APEX_ITEM utilizzeremo un’altra libreria chiamata APEX_APPLICATION.

Libreria APEX_APPLICATION

Per recuperare il valore memorizzato in un campo generato dinamicamente utilizzeremo le variabili APEX_APPLICATION.G_F0n ( APEX_APPLICATION.G_F01, APEX_APPLICATION.G_F02, … APEX_APPLICATION.G_F50)

Supponiamo di voler creare il campo textitem01 usando il seguente script dove p_idx = 1

apex_item.text(p_idx => 1,
	       p_value => 'test value 1',
	       p_size => 35,
	       p_maxlength => 50,
	       p_attributes => null,
	       p_item_id => 'textitem01',
	       p_item_label => 'Text Items 1');

Per recuperare il valore scritto nel campo di testo textitem01 dovrai usare il seguente script PL-SQL.

declare
    l_field_value varchar2(2000);
begin
    for i in 1..apex_application.g_f01.count loop
        l_field_value := apex_application.g_f01(i);
    end loop;
end;

Lo script riportato sopra è un esempio generico che dovrai utilizzare per recuperare il valore memorizzato nel campo con p_idx=1.

Allo stesso modo, puoi recuperare i valori degli altri campi con p_idx = 2,3,5,..,50 usando le variabili apex_application.g_f01(1), apex_application.g_f02(1),…, apex_application.g_f50(1).

Nel package APPIN5MINUTI_ITEM troverai una funzione PL-SQL che accetta come parametro il valore del parametro p_idx che hai usato per creare il Page Item e restituisce il valore contenuto in esso.

    function get_apex_application_g_fn ( 
        p_column in number 
    ) return clob --wwv_flow_global.vc_arr2 
     is 
        ret_value   wwv_flow_global.vc_arr2; 
        sql_qry     varchar2(2000); 
        v_value     clob; 
        l_col_index varchar2(2); 
    begin 
        if ( p_column > 50 ) then return null; 
        end if; 
        l_col_index := trim(to_char(p_column, '00')); 
        execute immediate 'begin :x := apex_application.g_f' || l_col_index || '(1); end;' 
            using out v_value; 
        return v_value; 
    end; 

Salvataggio dei Campi

Ora che sai come recuperare il valore dei Page Items possiamo andare a salvare le informazioni nel database.

In questo esempio ho deciso di salvare tutto il contenuto della form in un documento di formato JSON.

Sempre nel package APPIN5MINUTI_ITEM puoi trovare la funzione get_form_data che restituisce i dati inseriti nella form in formato JSON.

   function get_form_data ( 
        p_form_id in number 
    ) return clob is 
        l_json_data clob; 
    begin 
 
        select 
            json_object( 
                'form_id' value dynamic_form_field.form_id, 
                'fields' value json_arrayagg( 
                    json_object( 
                        'field_id' value field_id, 
                        'field_value' value get_apex_application_g_fn(field_sorting) 
                    ) 
                ) 
            ) 
        into l_json_data 
        from 
            dynamic_form_field 
        where 
                1 = 1 
            and form_id = p_form_id
            group by form_id; 
 
        return l_json_data; 
    end; 

Ecco come fare:

• Accedi all’APP Builder e seleziona la pagina View Form.
• Crea il bottone GET_FORM_DATA
• Crea un campo di tipo Display Only di nome PX_FORM_DATA

• Vai alla sezione Page Processing e crea un nuovo Page Process

• Inserisci il seguente script PL-SQL che si occupa di generare il documento JSON e di salvarlo nel campo FORM_DATA della tabella DYNAMIC_FORM

begin 
    :p6_form_data := appin5minuti_item.get_form_data (p_form_id => :p6_form_id);
    update dynamic_form set form_data = :p6_form_data where id = :p6_form_id;
commit;

In questo caso le informazioni vengono salvate direttamente nella tabella DYNAMIC_FORM nel campo CLOB FORM_DATA.

Tuttavia, ricorda che è un esempio: nella realtà dovresti utilizzare un’altra tabella dati in modo tale cha ciascun record possa contenere dati recuperati da form dinamiche che usato lo stesso template (form_id).

• Questo è il risultato

Conclusioni

Bene, siamo arrivati alla fine.

Spero con tutto il cuore che tu abbia trovato interessante questo tutorial.

Creare una applicazione che sia in grado di generare form dinamiche non è semplicissimo da realizzare, come ha visto.

Tuttavia, una volta fatto, ti consentirà di estendere molto velocemente le tue applicazioni APEX creando tutte le form che vuoi senza dover scrivere codice.

Fammi sapere cosa ne pensi!

Un abbraccio

Daniele