lato server
annuncio pubblicitario
Definizione delle specifiche software
del sistema Norma-System
lato server
Docu Code:
Sommario:
NORMAGEN/001/0.1 Tale documento ha lo scopo di fornire le specifiche software del sistema Norma-
System lato server.
Date: 21/3/2000
Author(s):
Coppari
Authorised by:
Prof. Pattaro
To:
Cc:
Specifiche Software del lato server
INDICE
1 ARCHITETTURA DEL SERVER ..................................................................... 4
1.1L’ARCHIVIO NORMATIVO ....................................................................................... 5
1.2LE STRUTTURE DINAMICHE ................................................................................. 10
1.2.1
Struttura S_User_Input ........................................................................................... 10
1.2.2
Struttura S_Data_Output ....................................................................................... 11
1.2.3
Struttura S_Search_Request ..................................................................................... 12
1.2.4
Struttura S_Doc_Identifiers ...................................................................................... 12
1.2.5
Struttura S_Ver_Identifiers...................................................................................... 12
1.2.6
Struttura S_Part_Identifiers ..................................................................................... 13
1.2.7
Struttura S_VerInfo ................................................................................................. 13
1.2.8
Struttura S_Part_Info .............................................................................................. 14
1.2.9
Struttura S_Type_Info ............................................................................................. 15
1.3GLI SCRIPT CGI PER LA CONSULTAZIONE DEGLI ATTI ................................... 17
1.3.1
Script GetListByTypeBody ........................................................................................ 17
1.3.2
Script GetPartitionBody ............................................................................................ 17
1.3.3
Script GetSearchByTypeBody .................................................................................... 18
1.3.4
Script GetSearchFormBody ....................................................................................... 19
1.3.5
Script GetVerListBody ............................................................................................. 19
1.3.6
Script GetVersionBody ............................................................................................. 20
1.4GLI SCRIPT CGI PER LA COLLABORAZIONE CON L'EDITOR ........................... 21
1.4.1
Script EdGetVerInfo ................................................................................................ 21
1.4.2
Script EdVerifyDocInfo ............................................................................................ 22
1.4.3
Script EdNewDoc ................................................................................................. 22
1.4.4
Script EdNewOriginal .............................................................................................. 23
1.4.5
Script EdNewMM.................................................................................................. 23
1.5LA LIBRERIA GRAFICA ........................................................................................... 23
1.6LA LIBRERIA DI INTERFACCIAMENTO AL DATABASE........................................ 27
1.7L’ARCHITETTURA DISTRIBUITA DEL SERVER ..................................................... 31
2 ASPETTO E FUNZIONAMENTO DELL’INTERFACCIA PER LA
CONSULTAZIONE DEGLI ATTI IN INTERNET
............................................ 35
2.1LA RICERCA DEI DOCUMENTI .............................................................................. 36
2.2IL RISULTATO DELLA RICERCA ............................................................................ 42
2.3LA VISUALIZZAZIONE DEL TESTO DEI DOCUMENTI ........................................ 44
2.4LA VISUALIZZAZIONE DEI RIFERIMENTI NEL TESTO ....................................... 46
2.5LA VISUALIZZAZIONE DELLA CATENA DELLE VERSIONI DI UN
TESTO...................................................................................................................... 47
2.6LA VISUALIZZAZIONE DEL TESTO DI UNA SINGOLA PARTIZIONE ................. 48
2.7MODELLI E VIDEATE DELL’INTERFACCIA ......................................................... 48
2.7.1
Il modello per selezionare il tipo di atti da ricercare..................................................... 49
2.7.2
Il modello per la visualizzazione di un documento ...................................................... 49
2.7.3
Il modello per la visualizzazione del risultato della ricerca .......................................... 53
3 IL LINGUAGGIO DI MARCATURA NML....................................................... 57
3.1SPECIFICHE DEL LINGUAGGIO............................................................................ 57
3.2ESEMPI DI DESCRIZIONE DI ATTI TRAMITE NML ............................................ 59
Specifiche Software del lato server
1 Architettura del Server
Il sistema per la diffusione della normativa in Internet dell’applicazione Norma
SQL costituisce l’interfaccia tra client e server del database (middle-tier). I gli
strumenti per la consultazione (client) non fanno mai richieste direttamente al
server di database, ma al server dall’applicazione, che poi gira le richieste al server
del database. In questa maniera i client possono essere “leggeri”, e quindi non
necessitare
di
complicati
aggiornamenti
o
installazioni.
La
“logica”
dell’applicazione (composizione delle query, conoscenza della struttura del
database) risiede sul server.
Il sistema di consultazione in Internet del database Norma è basato sullo standard
HTML 3.0, in modo da assicurare una perfetta fruibilità da tutti i più diffusi
programmi di navigazione. In particolare la consultazione è possibile con i
programmi Microsoft Internet Explorer, Netscape Navigator ed Opera (in questo
documento verranno usate delle immagini esemplificative tratte da Internet
Explorer, ma risultati molto simili si ottengono anche con gli altri programmi). Una
compatibilità così ampia è stata resa possibile dal fatto che tutte le elaborazioni
sono risolte dal server Norma tramite interfaccia CGI, senza demandare alcuna
elaborazione ai diversi programmi client. Non sono state quindi usate tecnologie
di programmazione del client quali Java, JavaScript o DHTML, che potrebbero non
essere supportate da alcuni programmi di navigazione in Internet.
La struttura dell’application server è mostrata in Figura 1.
Utente
Internet
Web
Server
Cript CGI Perl
Libreria grafica
Libreria di
interfaccamento
Modelli
al DB
Documenti
grafici
SQL
Figura 1: Struttura del server dell’applicazione
I documenti creati con l’editor saranno memorizzati in un server comune in modo
da essere reperibili e consultabili in Internet. Essi sono documenti Word originali
e la loro traduzione in documenti HTML; entrambi sono memorizzati in directory
prestabilite nel file-system. Per rendere veloce ed efficace il reperimento dei
documenti, al momento dell’inserimento nel server essi vengono "parserizzati"
alla ricerca delle informazioni marcate (data emanazione, autorità emanante ecc.)
le quali vengono poi memorizzate nel database. Attraverso la base di dati così
costruita è possibile reperire ad esempio la lista dei documenti che sono stati
emanati ad una particolare data o da un particolare organo.
1.1 L’ARCHIVIO NORMATIVO
Per organizzare la base di dati, si è scelto un sistema di gestione di basi di dati
relazionale (RDBMS), che fornisce un linguaggio di interrogazione compatibile
con lo standard SQL (Structured Query Language). In questa maniera qualsiasi
RDBMS che supporti tale standard (Microsoft SQL server, Oracle, Informix e
molti altri) può essere utilizzato come database per il sistema Norma. L’attuale
versione del sistema è realizzata utilizzando un motore Microsoft SQL Server su
Windows NT Server, ma il software viene realizzato e periodicamente testato
anche sotto altri sistemi (in particolare Oracle e Unix) in modo da mantenere alta
la portabilità.
Specifiche Software del lato server
Una rappresentazione semplificata della base di dati è mostrata in Figura 2, che
presenta lo schema E-R (Entity-Relationship) delle entità e delle relazioni
principali. Un documento normativo può avere più versioni, in dipendenza ad
esempio della lingua usata o del periodo di vigore (lo stesso documento può
subire nel tempo diverse modifiche testuali, che producono testi consolidati
diversi dal documento originario). Tutte le versioni dello stesso documento hanno
comunque caratteristiche identificative comuni, come la data di emanazione (della
versione originale). Le caratteristiche comuni sono memorizzate nell’archivio
Documenti. Per ogni versione sono invece specificate le caratteristiche particolari,
come la data di inizio vigore o la lingua usata. Ovviamente, ad ogni versione è
associato il documento vero e proprio in formato HTML registrato in directory
predefinite.
data emissione
data pubb.
identificativo
titolo
autorità emanante
oggetto
1
Documenti
n
Versioni
lingua
data inizio vigore
data fine vigore
data inizio efficacia
data fine efficacia
keyword (materia)
Documenti
HTML
Figura 2: Schema E-R delle entità e relazioni principali
Importante è anche la relazione riflessiva “Riferimenti” costruita sull’archivio
"Versioni" mostrata in Figura 3. In essa sono contenuti tutti i rinvii informativi ed
i riferimenti di modifica in partenza da una particolare versione del documento ad
un’altra. La relazione è ternaria (cioè coinvolge tre oggetti), in quanto riflessiva
sull’entità “Versioni” ed associata all’entità “Tipi di riferimento”. In pratica, ogni
riferimento associa la versione di partenza e la versione di arrivo del riferimento al
tipo di riferimento. I riferimenti sono, infatti, classificabili in tipi predefiniti in
base alle loro caratteristiche peculiari: rinvio informativo o modifica testuale,
rinvio informativo statico o dinamico ecc.
Attraverso le informazioni contenute in questa relazione sarà possibile conoscere,
ad esempio, tutti i rinvii informativi in arrivo ad una particolare partizione di un
documento, oppure tutti i documenti che l'hanno modificata testualmente. Le
informazioni contenute in "Riferimenti" sono particolarmente importanti nella
creazione di un ipertesto normativo, in cui sarà possibile navigare, ad esempio,
dalla versione precedente alla successiva, visualizzare il provvedimento di modifica
che ha generato la nuova versione, e quindi spostarsi su uno qualsiasi dei
documenti che citano la nuova versione.
Nome del tipo di riferimento
riferimento modificativo/rinvio Informativo
Rinvio statico/dinamico
1
Partizione di partenza
Partizione di arrivo
1
Versioni
Riferimenti
Tipo di riferimento
1
Figura 3: Schema E-R dei riferimenti
L’ultimo aspetto interessante emerso da questa analisi è la necessità di uno
strumento di classificazione dei documenti onde facilitare il loro reperimento. Lo
schema E-R in Figura 4 mostra che i documenti possono essere classificati per
tipo e per materie trattate. L’entità tipo di documento contiene anche
informazioni generali su quel tipo, come l’autorità emanante o il luogo di
pubblicazione.
Nome del tipo di documento
Autorita emanante
Gazzetta di pubblicazione
1
Tipo di documento
Appartengno a
n
Documenti
n
Nome della materia
Trattano di
n
Materie
Figura 4: Schema E-R della classificazione dei documenti
Un esempio di tipo di documento può essere la “Deliberazione del Senato
Accademico dell’Università degli Studi di Bologna”, la cui autorità emanante è
appunto il “Senato Accademico dell’Università degli Studi di Bologna” ed il cui
luogo di pubblicazione è il “Bollettino d’Ateneo”.
Grazie alle due entità descritte in Figura 4 sarà possibile cercare, ad esempio, tutti i
documenti che trattano di “personale”.
Specifiche Software del lato server
Materie
Tipo di
riferimenti
Documenti
Versioni
Tipo di
documenti
Documenti HTML
Figura 5: Scema E-R Generale
In Figura 5 è riassunto lo schema generale dell'intera architettura, fino a qui
analizzata solo per sottoinsiemi ai fini di una maggiore chiarezza espositiva.
Di seguito è invece indicato lo schema logico risultante:
DOCUMENTTYPE( -- Tabella con le informazioni sui tipi di atti.
DOC_TYPE_ID NUMERIC(10) , -- identificativo del tipo di documento
ATTACH_TYPE_ID CHAR(1), -- identificativo del tipo di attach (null = default = 0)
ID_NUMBER NUMERIC(1), -- Numero di identificativi associati al tipo (max 4)
TITLE_UNIQUE CHAR(1), -- Y/N indica se il titolo e' univoco
ID1_NAME CHAR(20), -- Nomi degli identificativi
ID2_NAME CHAR(20),
ID3_NAME CHAR(20),
ID4_NAME CHAR(20),
ID1_FORMAT CHAR(20), -- Formato degli identificativi: %s=stringa, %n=numero, %r=numero romano
ID2_FORMAT CHAR(20),
ID3_FORMAT CHAR(20),
ID4_FORMAT CHAR(20),
ID1_UNIQUE CHAR(2), - Y/N indica se l'identificativo è univoco
ID2_UNIQUE CHAR(2),
ID3_UNIQUE CHAR(2),
ID4_UNIQUE CHAR(2),
DOT_LIST_STR CHAR(1), -- Strutturazione ammessa: S=Strutturato, P=Punti, B=Entrambe
LIV_NUMBER NUMERIC(2), -- Numero di livelli (max 12)
LIV_UNIQUE NUMERIC(2), -- Numero del livello univoco
LIV1_NAME CHAR(20), -- Nomi dei livelli
LIV2_NAME CHAR(20),
LIV3_NAME CHAR(20),
LIV4_NAME CHAR(20),
LIV5_NAME CHAR(20),
LIV6_NAME CHAR(20),
LIV7_NAME CHAR(20),
LIV8_NAME CHAR(20),
LIV9_NAME CHAR(20),
LIV10_NAME CHAR(20),
LIV11_NAME CHAR(20),
LIV12_NAME CHAR(20),
LIV1_FORMAT CHAR(20),
LIV2_FORMAT CHAR(20),
LIV3_FORMAT CHAR(20),
LIV4_FORMAT CHAR(20),
LIV5_FORMAT CHAR(20),
LIV6_FORMAT CHAR(20),
LIV7_FORMAT CHAR(20),
LIV8_FORMAT CHAR(20),
LIV9_FORMAT CHAR(20),
LIV10_FORMAT CHAR(20),
LIV11_FORMAT CHAR(20),
LIV12_FORMAT CHAR(20),
LIV1_GENDER CHAR(1), -- M/F Genere del livello (serve per deciderele preposizioni e gli articoli)
LIV2_GENDER CHAR(1),
LIV3_GENDER CHAR(1),
LIV4_GENDER CHAR(1),
LIV5_GENDER CHAR(1),
LIV6_GENDER CHAR(1),
LIV7_GENDER CHAR(1),
LIV8_GENDER CHAR(1),
LIV9_GENDER CHAR(1),
LIV10_GENDER CHAR(1),
LIV11_GENDER CHAR(1),
LIV12_GENDER CHAR(1),
AUTHORITY CHAR(250), -- Autorita' emanante
ACT_TYPE CHAR(250), -- Tipologia di atto
LOCATION CHAR(250), -- Luogo di emanazione
PUBLISHED_IN CHAR(250), -- Luogo (bollettino, gazzetta...) di pubblicazione
DOC_TYPE_NAME CHAR(250), -- Nome del tipo di atto
DOC_TYPE_DEFINITION CHAR(200), -- Definizione del tipo di atto (solo se derivato da altri)
COMPOSITE_TYPE CHAR(1), -- Y/N tipo derivato da altri (default=Null=N)
INTERFACE_ID NUMERIC(10), -- Codice di interfaccia associata al tipo
INTERFACE_ORDER NUMERIC(10), -- Ordine nel quale il tipo deve essere listato
LAST_DOC_ID NUMERIC(10), -- Ultimo identificativo di documento assegnato per questo tipo
LAST_VER_ID NUMERIC(10), -- Ultimo identificativo di versione assegnato per questo tipo
HOST CHAR(250), -- HOSR che gestisce il tipo
URL_ED_GET_DOC_INFO CHAR(100), -- URL da chiamare per avere informazioni sul documento
URL_ED_GET_VER_INFO CHAR(100), -- URL da chiamare per avere informazioni sulla versione
URL_ED_VERIFY_ANCHOR_LIST CHAR(100), -- URL da chiamare per avere informazioni sui riferimenti
URL_GET_DOC CHAR(100), -- URL da chiamare per visualizzare il documento
CONSTRAINT PK_DOCUMENTTYPE PRIMARY KEY (DOC_TYPE_ID, ATTACH_TYPE_ID)
)
LINKTYPE(
LINK_TYPE_ID CHAR(10), -- Identificativo del tipo di Link
LINK_TYPE_NAME CHAR(80), -- Nome associato al tipo di Link
MOD_OR_REF CHAR(1), -- M = Modifica, R = Riferimento
REF_DYN CHAR(1), -- Y/N Indica se il riferimento è dinamico
MOD_TXT CHAR(1), -- Y/N Indica se il riferimanto è una modifica testuale
MOD_MAT CHAR(1), -- Y/M Indica se il riferimento è una modifica materiale
LINK_LABEL CHAR(80), -- Etichetta da associare al riferimento
LINK_REVERSE_LABEL CHAR(80), -- Etichetta da associare al riferimento seguito in senso inverso
CONSTRAINT PK_DOCUMENTTYPE PRIMARY KEY (LINK_TYPE_ID)
)
DOCUMENT( -- Tabella con le informazioni dei documenti
DOC_ID NUMERIC(10), -- Identificativo del documento
DELIVER_DATE CHAR(8), -- Data di emanazione
DOC_TYPE_ID NUMERIC(10), -- FK al tipo di documento
ATTACH_TYPE_ID CHAR(1),
PUBLICATION_DATE CHAR(8), -- Data di pubblicazione
TITLE CHAR(250), -- Titolo
ID1 CHAR(20), -- Identificativi
ID2 CHAR(20),
ID3 CHAR(20),
ID4 CHAR(20),
ATTACH_NUMBER CHAR(20), -- Numero dell'attach (null se non e' un attach)
LOCKED_BY CHAR(40), -- Utente che ha bloccato il documento per il consolidamento (null se non bloccato)
CONSTRAINT PK_DOCUMENT PRIMARY KEY (DOC_ID, DOC_TYPE_ID, ATTACH_TYPE_ID)
)
VERSION( -- Tabella con le informazioni sulle versioni
VER_ID NUMERIC(10), -- Identificativo versione
DOC_ID NUMERIC(10), -- FK al documento
DOC_TYPE_ID NUMERIC(10), -- FK al tipo di documento
ATTACH_TYPE_ID CHAR(1),
LAST_LINK_ID NUMERIC(10), -- Primo identificativo dei link all'internod ella versione (i minori vengono
da versioni precedenti)
FIRST_LINK_ID NUMERIC(10), -- Ultimo identificativo dei link all'internod ella versione (i maggiori
vengono da versioni successive)
MOD_VER_ID NUMERIC(10), -- Identiticativo del modificativo che ha generato la versione (null se
originale)
MOD_DOC_ID NUMERIC(10),
MOD_DOC_TYPE_ID NUMERIC(10),
MASTER_VER_ID NUMERIC(10), -- Identificativo del documento principale (null se non e' un allegato)
MASTER_DOC_ID NUMERIC(10),
MASTER_DOC_TYPE_ID NUMERIC(10),
MASTER_ATTACH_TYPE_ID CHAR(1),
VERSION_STATUS CHAR(20), -- Stato della versione: O = Originale, M = Modificato, A = Abrogato, S =
Sospeso, P = Prorogato)
START_VIG_DATE CHAR(8), -- Data inizio vigore
END_VIG_DATE CHAR(8), -- Data di fine vigore
START_EFF_DATE CHAR(8), -- Data di inzio efficacia
END_EFF_DATE CHAR(8), -- Data di fine efficacia
INSERT_DATE CHAR(8), -- Data di inserimento
INSERTED_BY CHAR(20), -- Utente che lo ha inserito
ALTERNATE_FORMATS CHAR(20), -- Formati alternativi (sequenza delle estensioni separate da spazio)
CONSTRAINT PK_VERSION PRIMARY KEY (VER_ID, DOC_TYPE_ID, ATTACH_TYPE_ID)
)
PARTITION( -- Tabella con le informazionei su una singola partizione
PART_VER_ID NUMERIC(10), -- FK alla versione nella quale la partizione e' contenuta
PART_DOC_ID NUMERIC(10),
PART_DOC_TYPE_ID NUMERIC(10),
PART_ATTACH_TYPE_ID CHAR(1),
PART_ID CHAR(30), -- Identificativo partizione
PART_ORDER NUMERIC(4), -- Ordine della partizione all'interno del documento (part_id non e' ordinato)
RUBRICA CHAR(100), -- Rubrica della partizione
FILE_NAME CHAR(100), -- Nome del file dove e' registarato il testo della partizione
CONSTRAINT PK_PARTITION PRIMARY KEY (PART_VER_ID, PART_DOC_TYPE_ID, PART_ATTACH_TYPE_ID, PART_ID)
)
VERSION_FILE( -- Archivio che memerizza le corrispondenze tra le versione ed i files dove sono registrate
FILE_VER_ID NUMERIC(10), -- Identificativi della versione
Specifiche Software del lato server
FILE_DOC_TYPE_ID NUMERIC(10),
FILE_ATTACH_TYPE_ID CHAR(10),
FILE_NAME CHAR(100), -- Nome del file dove e' registarato il testo della versione
CONSTRAINT PK_VERSION_FILE PRIMARY KEY (FILE_VER_ID, FILE_DOC_TYPE_ID, FILE_ATTACH_TYPE_ID)
)
LINK( -- Archivio con i riferimenti risolti
LINK_ID NUMERIC(10), -- Identificativo del link (univoco all'interno del doc di partenza)
FROM_VER_ID NUMERIC(10), -- FK alla partizione di partenza
FROM_ANCHOR CHAR(30),
FROM_DOC_TYPE_ID NUMERIC(10),
FROM_ATTACH_TYPE_ID CHAR(1),
TO_VER_ID NUMERIC(10), -- FK alla partizione di partenza
TO_DOC_ID NUMERIC(10),
TO_DOC_TYPE_ID NUMERIC(10),
TO_ATTACH_TYPE_ID CHAR(1),
TO_ANCHOR CHAR(30),
LINK_TYPE_ID CHAR(10), -- FK al tipo di link
TO_UPDATED CHAR(1), -- T/F T se il link modificativo e' stato consolidato
MOD_DATE CHAR(10), -- Data di inizio efficacia della modifica
)
UNRES_LINK( -- Archivio con i riferimenti non risolti
LINK_ID NUMERIC(10), -- Identificativo del link (univoco all'interno del doc di partenza)
FROM_VER_ID NUMERIC(10), -- FK alla partizione di partenza
FROM_DOC_TYPE_ID NUMERIC(10),
FROM_ATTACH_TYPE_ID CHAR(1),
FROM_ANCHOR CHAR(30),
TO_DOC_TYPE_ID NUMERIC(10), -- Dati della partizione di arrivo (non risolta, non ho il ver_id)
TO_ATTACH_TYPE_ID CHAR(1),
TO_ID1 CHAR(30),
TO_ID2 CHAR(30),
TO_ID3 CHAR(30),
TO_ID4 CHAR(30),
TO_VIG_DATE CHAR(8),
TO_DELIVER_DATE CHAR(8),
TO_ANCHOR CHAR(30),
LINK_TYPE_ID CHAR(10) -- FK al tipo di link
)
1.2 LE STRUTTURE DINAMICHE
Il linguaggio di programmazione scelto per la realizzazione dell'application server
norma è il Perl, che per leggere e manipolare i dati presenti nell'archivio
relazionale deve "mapparli" in strutture dinamiche in memoria, quali variabili
semplici o vettori. In Perl le strutture dati complesse non possono essere definite,
tuttavia è possibile usare una struttura dinamica chiamata "hash" (array
associativo), polimorfa ed in grado di rappresentare qualsiasi struttura dati al
momento dell'esecuzione. Attraverso gli hash è infatti possibile associare ad una
qualsiasi chiave un qualsiasi valore, che può essere una stringa, un intero, un array
o, ricorsivamente, un altro hash.
Unicamente per questioni di leggibilità, elenchiamo le principali strutture dati
usate dal norma server.
1.2.1 Struttura S_User_Input
La funzione che legge l'input CGI dell'utente è polimorfa, e converte tale input
nella struttura S_User_Input che viene poi restituita in output. La struttura può
variare, in dipendenza della funzione chiamata e della richiesta specifica. In
particolare essa può essere un S_Search_Request se viene chiamata la funzione di
ricerca di documenti, un S_Ver_Identifiers se viene chiamata la funzione di
visualizzazione
di
una particolare versione di
un documento o un
S_Part_Identifiers se viene chiamata la funzione di visualizzazione di una
particolare
versione.
Le
strutture
S_Search_Request,
S_Ver_Identifiers,
S_Part_Identifiers saranno definite più aventi nel testo. Il codice verifica che
l'input dell'utente corrisponda effettivamente alla struttura richiesta. Alcune
procedure
possono
essere
polimorfe
come,
ad
esempio,
lo
script
GetVersionBody.pl (descritto piu' avanti nel testo), che dopo aver tentato di
interpretare S_User_Input come Ver_Identifiers, nel caso non sia possibile
reperire una particolare versione tentano di interpretare lo stesso S_User_Input
come S_Search_Request.
Struct S_User_Input{
variant{
S_Search_Request,
S_Ver_Identifiers,
S_Part_Identifiers
}
}
1.2.2 Struttura S_Data_Output
E' la struttura dove vengono raccolti i dati da restituire in output secondo il
formato grafico definito dai templates di interfaccia. La struttura può variare, in
dipendenza della funzione chiamata e della richiesta specifica. In particolare essa
può essere un S_Type_info se debbono essere visualizzate in output (secondo la
formattazione grafica decisa dal relativo template) le informazioni su un
particolare tipo di atto, un S_Ver_Info se debbono essere visualizzate in output le
informazioni su una particolare versione di un documento (o il documento stesso,
il cui file è reperibile dalle informazioni su di esso), un S_Doc_info, un
S_Part_info, o infine un array delle già citate strutture. Le strutture S_Type_info,
S_Ver_Info, S_Doc_info, S_Part_info verranno descritte in dettaglio più avanti
nel testo.
La procedura che parserizza i templates è polimorfa e può ricevere in input una
qualsiasi struttura dati da utilizzare per interpretare il template di interfaccia
Specifiche Software del lato server
corrispondente. Il template deve ovviamente essere sincronizzato con la struttura
dei dati da restituire in output.
Struct S_Data_Output{
variant{
S_Type_Info,
S_Ver_Info,
S_Doc_Info,
S_Part_Info,
array of S_Type_Info,
array of S_Ver_Info,
array of S_Doc_Info,
array of S_Part_Info
}
}
1.2.3 Struttura S_Search_Request
E' usata per formalizzare una richiesta di ricerca di un documento da parte
dell'utente:
Struct S_Search_Request{
or_request array{ -- Vettore che contiene le ricerche tra loro in or
doc_type_id int; -- Identificativo tipo di atto
doc_id int; -- Identificativo documento
ver_id int; -- Identificativo versione
attach_type_id char; -- Identificativo di attach
full_text_search string; -- Stringa di ricerca full-text
deliver_date date; -- data di emanazione
deliver_date_op string; -- operatore da applicare alla data di emanazione (=,<,>,between)
publication_date date; -- data di pubblicazione
publication_date_op string; -- operatore da applicare alla data di pubblicazione (=,<,>,between)
id1 string; -- valore primo identificativo
id1_op string; -- operatore da applicare al primo identificativo (=, contains)
id2 string; -- valore secondo identificativo
id2_op string; -- operatore da applicare al secondo identificativo (=, contains)
id3 string; -- valore terzo identificativo
id3_op string; -- operatore da applicare al terzo identificativo (=, contains)
title string; -- titolo
title_op string; -- operatore da applicare al titolo (=, contains)
auithority string; -- autorita' emanante
}
vig_date date; -- Data di vigore richiesta
vig_date_op string; -- Data di vigore richiesta
eff_date date; -- Data di efficacia richiesta
eff_date_op string; -- Data di vigore richiesta
reply_format string; -- Formato della risposta (lista documenti, lista partizioni, testo)
reply_order string; -- Ordinamento della risposta
}
1.2.4 Struttura S_Doc_Identifiers
E' usata per contenere gli identificativi univoci di un documento:
Struct S_Doc_Identifiers{
doc_type_id int; -- Identificativo tipo
attach_type_id int; -- Identificativo Attach (Opzionale, defaut=Null=0)
doc_id int; -- identificativo documento
}
1.2.5 Struttura S_Ver_Identifiers
E' usata per contenere gli identificativi univoci di una particolare versione di un
documento:
Struct S_Ver_Identifiers{
doc_type_id int; -- Identificativo tipo
attach_type_id int; -- Identificativo Attach (Opzionale, defaut=Null=0)
ver_id int; -- identificativo versione
}
1.2.6 Struttura S_Part_Identifiers
E' usata per contenere gli identificativi univoci di una particolare partizione di una
particolare versione di un documento:
Struct S_Part_Identifiers{
doc_type_id int; -- Identificativo tipo
attach_type_id int; -- Identificativo Attach (Opzionale, defaut=Null=0)
ver_id int; -- identificativo versione
part_id int; -- identificativo partizione all'interno della versione
}
1.2.7 Struttura S_VerInfo
E' usata per contenere tutte le informazioni riguardanti una particolare versione di
un documento. Le informazioni sono estratte dal database, ed i nomi dei campi
sono gli stessi delle colonne della tabelle del database. Per la descrizione del
significato riferirsi alla descrizione delle tabelle di database.
Struct S_Ver_Info{
doc_id long
deliver_date date
publication_date date
title string
id1 string
id2 string
id3 string
id4 string
attach_number string
locked_by string
doc_type_id long
attach_type_id char
title_unique char
id_number int
id1_name string
id2_name string
id3_name string
id4_name string
id1_format string
id2_format string
id3_format string
id4_format string
id1_unique char
id2_unique char
id3_unique char
id4_unique char
dot_list_str char
liv_number int
liv_unique int
liv1_name string
liv2_name string
liv3_name string
liv4_name string
liv5_name string
liv6_name string
liv7_name string
liv8_name string
liv9_name string
liv10_name string
liv11_name string
liv12_name string
liv1_format string
liv2_format string
liv3_format string
liv4_format string
Specifiche Software del lato server
liv5_format string
liv6_format string
liv7_format string
liv8_format string
liv9_format string
liv10_format string
liv11_format string
liv12_format string
liv1_gender char
liv2_gender char
liv3_gender char
liv4_gender char
liv5_gender char
liv6_gender char
liv7_gender char
liv8_gender char
liv9_gender char
liv10_gender char
liv11_gender char
liv12_gender char
authority string
act_type string
location string
published_in string
doc_type_name string
doc_type_definition string
composite_type char
interface_id long
interface_order long
last_doc_id long
last_ver_id long
host string
url_ed_get_doc_info string
url_ed_get_ver_info string
url_ed_verify_anchor_list string
url_get_doc string
ver_id long
mod_doc_id long
mod_ver_id long
mod_doc_type_id long
master_doc_id long
master_ver_id long
master_doc_type_id long
master_attach_type_id char
insert_date date
start_vig_date date
end_vig_date date
start_eff_date date
end_eff_date date
alternate_formats string
file_name string
}
1.2.8 Struttura S_Part_Info
E' usata per contenere tutte le informazioni riguardanti una particolare partizione
di una particolare versione di un documento. Le informazioni sono estratte dal
database, ed i nomi dei campi sono gli stessi delle colonne della tabelle del
database. Per la descrizione del significato riferirsi alla descrizione delle tabelle di
database.
Struct S_Part_Info{
doc_id long
part_id long
deliver_date date
publication_date date
title string
id1 string
id2 string
id3 string
id4 string
attach_number string
locked_by string
doc_type_id long
attach_type_id char
title_unique char
id_number int
id1_name string
id2_name string
id3_name string
id4_name string
id1_format string
id2_format string
id3_format string
id4_format string
id1_unique char
id2_unique char
id3_unique char
id4_unique char
dot_list_str char
liv_number int
liv_unique int
liv1_name string
liv2_name string
liv3_name string
liv4_name string
liv5_name string
liv6_name string
liv7_name string
liv8_name string
liv9_name string
liv10_name string
liv11_name string
liv12_name string
liv1_format string
liv2_format string
liv3_format string
liv4_format string
liv5_format string
liv6_format string
liv7_format string
liv8_format string
liv9_format string
liv10_format string
liv11_format string
liv12_format string
liv1_gender char
liv2_gender char
liv3_gender char
liv4_gender char
liv5_gender char
liv6_gender char
liv7_gender char
liv8_gender char
liv9_gender char
liv10_gender char
liv11_gender char
liv12_gender char
authority string
act_type string
location string
published_in string
doc_type_name string
doc_type_definition string
composite_type char
interface_id long
interface_order long
last_doc_id long
last_ver_id long
host string
url_ed_get_doc_info string
url_ed_get_ver_info string
url_ed_verify_anchor_list string
url_get_doc string
ver_id long
mod_doc_id long
mod_ver_id long
mod_doc_type_id long
master_doc_id long
master_ver_id long
master_doc_type_id long
master_attach_type_id char
insert_date date
start_vig_date date
end_vig_date date
start_eff_date date
end_eff_date date
alternate_formats string
file_name string
}
1.2.9 Struttura S_Type_Info
E' usata per contenere tutte le informazioni su un particolare tipo di atto
contenuto nel database. Le informazioni sono estratte dal database, ed i nomi dei
Specifiche Software del lato server
campi sono gli stessi delle colonne della tabelle del database. Per la descrizione del
significato riferirsi alla descrizione delle tabelle di database.
Struct S_Type_Info{
doc_type_id not null long
attach_type_id not null char
id_number int
title_unique char
id1_name string
id2_name string
id3_name string
id4_name string
id1_format string
id2_format string
id3_format string
id4_format string
id1_unique char
id2_unique char
id3_unique char
id4_unique char
dot_list_str char
liv_number int
liv_unique int
liv1_name string
liv2_name string
liv3_name string
liv4_name string
liv5_name string
liv6_name string
liv7_name string
liv8_name string
liv9_name string
liv10_name string
liv11_name string
liv12_name string
liv1_format string
liv2_format string
liv3_format string
liv4_format string
liv5_format string
liv6_format string
liv7_format string
liv8_format string
liv9_format string
liv10_format string
liv11_format string
liv12_format string
liv1_gender char
liv2_gender char
liv3_gender char
liv4_gender char
liv5_gender char
liv6_gender char
liv7_gender char
liv8_gender char
liv9_gender char
liv10_gender char
liv11_gender char
liv12_gender char
authority string
act_type string
location string
published_in string
doc_type_name string
doc_type_definition string
composite_type char
interface_id long
interface_order long
last_doc_id long
last_ver_id long
host string
url_ed_get_doc_info string
url_ed_get_ver_info string
url_ed_verify_anchor_list string
url_get_doc string
}
1.3 GLI SCRIPT CGI PER LA CONSULTAZIONE DEGLI
ATTI
Gli script CGI costituiscono la porta di accesso al sistema di consultazione della
base di dati Norma. Essi possono essere richiamati da un browser come una
qualsiasi pagina HTML, ma alla loro invocazione corrisponde l’esecuzione dello
script anziché la sua visualizzazione. Gli script, usando alcune funzioni di libreria,
eseguono ricerche sulla base di dati e restituiscono all’utente il risultato delle
ricerche in un documento HTML.
Gli script principali sono in dettaglio:
1.3.1 Script GetListByTypeBody
Cerca nel DB la lista dei tipi di documenti e la restituisce in output. Utilizza la
libreria di connessione al database per cercare la lista dei tipi di atti e la libreria
grafica per restituire la lista in output. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
array of S_Type_Info: norma_db::getTypes() #ritorna la lista dei tipi
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
boolean:
norma_cgi::printParseTemplate(Template_id,
S_Data_Output)
#stampa il risultato
boolean: norma_cgi::printError() #stampa una pagina di errore
1.3.2 Script GetPartitionBody
Prende in input i dati univoci di una partizione e la restituisce in una pagina
HTML. Utilizza la libreria grafica per leggere le richieste dell’utente e restituire in
output la partizione cercata, e la libreria di connessione al database per reperire la
partizione. In caso di errore restituisce un messaggio. Funzioni chiamate:
Specifiche Software del lato server
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
S_Part_Info:
norma_db::getPartInfo(S_Part_Identifiers)
#ritorna
le
informazioni sulla partizione specificata in $in.
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean:
norma_cgi::printParseTemplate(Template_id,
S_Data_Output)
#stampa il risultato
boolean: norma_cgi::printError() #stampa una pagina di errore
1.3.3 Script GetSearchByTypeBody
Cerca nel DB la lista dei tipi di documenti e restituisce in output una lista di
riferimenti a moduli per la ricerca specifici per il tipo selezionato. Utilizza la
libreria di connessione al database per cercare la lista dei tipi di atti e la libreria
grafica per restituire la lista in output. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
array of S_Type_Info: norma_db::getTypes() #ritorna la lista dei tipi
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
boolean:
norma_cgi::printParseTemplate(Template_id,
S_Data_Output)
#stampa il risultato
boolean: norma_cgi::printError() #stampa una pagina di errore
1.3.4 Script GetSearchFormBody
Restituisce in output un modulo per la ricerca dei documenti nel database,
inizializzato con i dati presi in input. Utilizza la libreria di connessione al database
per cercare la lista dei tipi di atti e la libreria grafica per restituire la lista in output.
Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
array of S_Type_Info: norma_db::getTypes () #ritorna la lista dei tipi
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean:
norma_cgi::printParseTemplate(Template_id,
S_Data_Output)
#stampa il risultato
boolean: norma_cgi::printError() #stampa una pagina di errore
1.3.5 Script GetVerListBody
Prende in input i dati per la ricerca di un documento, e restituisce una pagina
HTML con la lista dei documenti che soddisfano la ricerca. Utilizza la libreria
grafica per leggere le richieste dell’utente e restituire in output la lista, e la libreria
di connessione al database per reperire i documenti che soddisfano la ricerca. In
caso di errore restituisce un messaggio. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
array of S_Ver_Info: norma_db::getVerInfoList (S_Search_Request) #ritorna
un array di informazioni sui documenti che soddisfano le condizioni
specificate attraverso il vettore associativo in input.
Specifiche Software del lato server
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean:
norma_cgi::printParseTemplate(Template_id,
S_Data_Output)
#stampa il risultato
boolean: norma_cgi::printError() #stampa una pagina di errore
1.3.6 Script GetVersionBody
Prende in input i dati univoci di un documento e lo restituisce in una pagina
HTML. Utilizza la libreria grafica per leggere le richieste dell’utente e restituire in
output il documento cercato, e la libreria di connessione al database per reperire il
documento. In caso di errore restituisce un messaggio. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
S_Ver_Info:
norma_db::getVerInfo
(S_Ver_Identifiers)
#ritorna
le
informazioni sulla versione specificata attraverso il vettore associativo $in.
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean: norma_cgi::printParseTemplate(string $template_id, pointer to
S_Ver_Info $info) #stampa il risultato, ritorna true se la stampa termina
correttamente.
boolean: norma_cgi::printError() #stampa una pagina di errore
1.4 GLI SCRIPT CGI PER LA COLLABORAZIONE CON
L'EDITOR
Gli script CGI costituiscono anche la porta attraverso il quale l'editor del sistema
norma dialoga con la base di dati Norma, al fine di inserire documenti o costruire
riferimenti a documenti in essa già presenti. Gli script, usando alcune funzioni di
libreria, eseguono ricerche sulla base di dati e restituiscono all'Editor il risultato
delle ricerche secondo un formato di interscambio dati predefinito.
Gli script principali sono in dettaglio:
1.4.1 Script EdGetVerInfo
prende in input i dati univoci di una versione di un documento, e restituisce le
informazioni si di esso in un formato comprensibile all'editor. Utilizza la libreria
grafica per leggere le richieste dell’utente e restituire in output il documento
cercato, e la libreria di connessione al database per reperire il documento. In caso
di errore restituisce un messaggio. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
S_Ver_Info:
norma_db::getVerInfo
(S_Ver_Identifiers)
#ritorna
le
informazioni sulla versione specificata attraverso il vettore associativo $in.
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean: norma_cgi::printParseTemplate(string $template_id, pointer to
S_Ver_Info $info) #stampa il risultato, ritorna true se la stampa termina
correttamente.
boolean: norma_cgi::printError() #stampa una pagina di errore
Specifiche Software del lato server
1.4.2 Script EdVerifyDocInfo
prende in input i dati di un documento, e ne verifica la compatibilità
all'inserimento all'interno della base di dati. In particolare verifica, in dipendenza
di quanto stabilito dalla descrizione del tipo di atto da verificare, se il titolo e/o gli
identificativi sono già presenti nella base di dati. Verifica inoltre, nel caso si tratti
di un documento consolidato, che esista la versione precedente. Utilizza la libreria
grafica per leggere le richieste dell’utente e restituire in output la risposta, e la
libreria di connessione al database per verificare la correttezza delle informazione.
In caso di errore restituisce un messaggio. Funzioni chiamate:
norma_db: norma_db::connect() #stabilisce una connessione con il
database server
S_Ver_Info:
norma_db::getVerInfo(S_Ver_Identifiers)
#ritorna
le
informazioni sulla versione specificata attraverso il vettore associativo in.
norma_cgi: norma_cgi::openCgi() #stabilisce una connessione con il Web
Server per l'I/O
S_User_Input: norma_cgi::getHashIn() #ritorna l'input in un array
associativo
boolean: norma_cgi::printParseTemplate(string $template_id, pointer to
S_Ver_Info $info) #stampa il risultato, ritorna true se la stampa termina
correttamente.
boolean: norma_cgi::printError() #stampa una pagina di errore
1.4.3 Script EdNewDoc
Registra il documento HTML spedito in POST dall'editor nella posizione
predisposta Non comunica con la base di dati, utilizza quindi solo la libreria
norma_cgi per leggere l'input dell'utente. Chiama le funzioni:
norma_cgi: norma_cgi::readFile() #stabilisce una connessione con il Web
Server, legge l'input contenente il documento in POST e lo salva.
1.4.4 Script EdNewOriginal
Registra il documento Word spedito in POST dall'editor nella posizione
predisposta Non comunica con la base di dati, utilizza quindi solo la libreria
norma_cgi per leggere l'input dell'utente. Chiama le funzioni:
norma_cgi: norma_cgi::readOriginal() #stabilisce una connessione con il
Web Server, legge l'input contenente il documento in POST e lo salva.
1.4.5 Script EdNewMM
Registra nella posizione predisposta le componenti multimediali (tipicamente
immagini) di un documento, spedite in POST dall'editor. Non comunica con la
base di dati, utilizza quindi solo la libreria norma_cgi per leggere l'input
dell'utente. Chiama le funzioni:
norma_cgi: norma_cgi::readMM() #stabilisce una connessione con il Web
Server, legge l'input contenente il documento in POST e lo salva.
1.5 LA LIBRERIA GRAFICA
La libreria grafica è il modulo che gestisce la connessione CGI con il server
HTTP. In essa sono definite ed esportate tutte le funzioni utili per la lettura
dell’input e per la scrittura dell’output cgi.
Per consentire una facile personalizzazione dell’output del sistema Norma, la
grafica è sempre definita attraverso modelli di documenti HTML, che vengono
letti da funzioni di questa libreria. I modelli contengono comandi che, interpretati
dalle funzioni stesse, consentono di inserire informazioni come ad esempio il
titolo di un particolare documento all’interno del modello. In questa maniera si
ottiene una suddivisione tra la rappresentazione grafica ed i dati in essa inserita, e
quindi tra l’aspetto ed il contenuto. L’aspetto potrà quindi essere modificato con
estrema semplicità senza intaccare le procedure.
Un esempio di modello per l’interfaccia è il seguente:
Specifiche Software del lato server
<HTML>
<HEAD>
<TITLE>Ricerca per tipo di documento</TITLE>
</HEAD>
<BODY bgcolor=”white”>
<p>&nbsp;</p>
<center>
<table align=”center” border=”0” cellspacing=”0” cellpadding=”0” HEIGHT=”40”>
<tr border=”0”>
<td colspan=”2” border=”0”>
<img src=”/norma/nuoviss/tipolo.gif”><p>&nbsp;</p>
</td>
</tr>
<tr border=”0”>
<td border=”0”><img src=”/norma/nuoviss/list1.gif”></td>
<td align=”left”> </td>
</tr>
<!--n_FOREACH TYPE-->
<tr border=”0”>
<td border=”0”><img src=”/norma/nuoviss/list.gif” HEIGHT=”40” border=”0”></td>
<td align=”left” border=”0”><a href=”<!--n_PRINT_PROCEDURE GET_VER_LIST_PARENT-->?doc_type_id=<!-n_PRINT_PROPERTY DOC_TYPE_ID-->&order_by=start_vig_date&vig_date=<!--n_PRINT_PROPERTY PARENT.CUR_DATE->&vig_date_op=ON” target=”_parent”><!--n_PRINT_PROPERTY DOC_TYPE_NAME--></a></td>
</tr>
<!--/n_FOREACH TYPE-->
<tr>
<td colspan=”2” border=”0”><img src=”/norma/nuoviss/list2.gif”></td>
</tr>
</table>
</center>
</BODY>
</HTML>
Possiamo notare che, assieme ai normali marker del linguaggio HTML, sono
presenti dei commenti (per l’HTML) che vengono poi interpretati dalle procedure
della libreria grafica. Ad esempio il marker <!--n_foreach type--> consente di ripetere
tutto ciò che segue, fino al corrispondente marker di chiusura, per tutti i tipi di
atti. Il risultato dell’interpretazione è mostrato in Figura 6.
Figura 6: Visualizzazione di un modello di documento del sistema Norma: a) non interpretato;
b) interpretato
In dettaglio, i comandi che possono essere inseriti all’interno dei modelli di
documenti HTML interpretati dalle procedure del modulo grafico di norma, sono:
PRINT_PROPERTY, che conserte di stampare proprietà, ad esempio nella
pagine che visualizza le informazioni su di un documento, è possibile inserire
un
comando
per
stamparne
l’intitolazione
con
il
comando
PRINT_PROPERTY DOCUMENT.TITLE;
PRINT_FILE, consente di inserire un file esterno all’interno della pagina. Può
essere usato ad esempio per inserire un intero documento all’interno di una
pagina;
PRINT_DOC_WITH_LINK, consente di stampare un documento inserendo
però all’interno di esso le informazioni sui suoi riferimenti passivi.
PRINT_PROCEDURE, consente di stampare il nome di una procedura.
Questo comando è utile perché grazie ad esso le chiamate a procedura
possono essere parametrizzate, il cambiamento del nome delle procedure non
implica quindi il cambiamento dei modelli di interfaccia;
PRINT_IF_DEFINED, consente di stampare del testo se e solo se è definita
una certa proprietà;
PRINT_IF_NOT_DEFINED, consente di stampare del testo se e solo se non
è definita una certa proprietà;
PRINT_IF_MATCH, consente di stampare del testo se e solo se è verificata
una condizione di uguaglianza tra due variabili;
PRINT_IF_DONT_MATCH, consente di stampare del testo se e solo se non
è verificata una condizione di uguaglianza tra due variabili;
FOREACH, consente di ripetere la scrittura di una porzione di testo per ogni
elemento di un vettore;
FOR, consente di ripetere la scrittura di una porzione di testo per un numero
di volte stabilito.
In appendice A, è disponibile il listato della libreria grafica di Norma, denominata
Norma_cgi, mentre in appendice B sono elencati i principali modelli di pagine
HTML, e le videate (interpretate e non) ad essi corrispondenti.
Specifiche Software del lato server
Il modulo, contiene alcune procedure ad esclusivo uso interno, altre invece fanno
parte della sua definizione pubblica, e sono quindi eseguibili anche se invocate
dall’esterno del modulo. Le principali procedure sono:
Metodo di classe \hash: cgi2hash (string), usato solo internamente al modulo,
converte la stringa cgi in input in un vettore associativo più comodo per
successive elaborazioni;
Metodo di istanza string: hash2cgi ($hashIn: \hash), usato solo internamente al
modulo, procedura che restituisce una stringa CGI corrispondente alla query
inserita dall’utente e presa in input in un vettore associativo;
Metodo di classe string: readCgiIn, usato solo internamente al modulo, legge
dalle variabili di environment l’input cgi
Metodo di classe \norma_cgi: openCgi, metodo pubblico usabile dall’esterno del
modulo, apre un’interfaccia CGI con il Web server ritorna l’handler
all’interfaccia, legge la stringa cgi in input e la ricorda come, proprietà
dell’oggetto;
Metodo di classe boolean: readFile, metodo pubblico usabile dall’esterno del
modulo, riceve un file dallo standard input e lo salva ritornando il codice
temporaneo con cui e’ stato salvato il file oppure ritorna un errore se
l’operazione fallisce;
Metodo di istanza S_User_Input: getHashIn, metodo pubblico usabile
dall’esterno del modulo, restituisce un vettore associativo contenente l’input
dell’utente;
Metodo di istanza string: getCgiIn, metodo pubblico usabile dall’esterno del
modulo, restituisce una stringa codificata CGI contenente l’input dell’utente;
Metodo di istanza boolean: printParseTemplate (TemplateId, S_Data_Output),
metodo pubblico usabile dall’esterno del modulo, procedura che parserizza un
file e restituisce una pagina HTML in cui i comandi all’interno del modello
sono correttamente sostituiti con i valori in input secondo le modalità già
descritte. Usa la printParseString per sostituire i comandi.
Metodo di istanza boolean: printParseString(string, S_Data_Output), metodo
pubblico usabile dall’esterno del modulo, procedura che parserizza un
generico modello, e restituisce una pagina HTML in cui i comandi all’interno
del modello sono correttamente sostituiti con i valori in input secondo le
modalità già descritte. La procedura e’ ricorsiva.
1.6 LA LIBRERIA DI INTERFACCIAMENTO AL
DATABASE
Modulo che implementa un interfaccia indipendente dal DBMS al database
norma. Si basa su un modulo di interfacciamento a database già implementato di
nome DBI, esso stesso indipendente dal DBMS e di cui vengono ereditate tutte le
proprietà. In sostanza quindi il modulo Norma Database è anche un normale
database DBI. Vengono però ridefinite alcune funzioni del database DBI, quali ad
esempio, la funzione di connessione al fine di consentire la connessione al solo
DB norma e non ad altri. Vengono inoltre aggiunte alcune funzionalità utili allo
specifico database Norma, ed esportate un insieme di funzioni per manipolare il
DB ed estrarre informazioni.
In questa libreria sono quindi racchiusi tutti i pezzi di codice rilevanti che hanno a
che fare con il DB norma, e tutte le chiamate al DB debbono passare per questa
libreria.
Una delle maggiori funzionalità offerte da questa libreria è quella di tradurre una
richiesta effettuata dall’utente usando un form HTML in Internet, in una query
SQL sul database norma. La richiesta dell’utente, deve comunque arrivare alla
libreria secondo una particolare codifica, studiata in maniera da essere versatile e
facilmente realizzabile in HTML.
NUMBER_OF_FORMS numero di form in or tra i loro. Se non e’ definito
viene assunto il valore 1.
FORM<NUMERO_FORM>_ACTIVE, può assumere i valori “true” o
“false”, ed indica se il form deve essere valutato o meno;
Specifiche Software del lato server
[FORM<NUMERO_FORM>_]<NOME CAMPO> valore del campo, viene
tradotto in: “campo = valore”;
[FORM<NUMERO_FORM>_]<NOME
CAMPO>_OP
operatore
da
applicare. gli operatori accettabili sono tutti quelli accettati da SQL
(<,>,<=,>=,=,LIKE...), viene inoltre anche accettato l’operatore RANGE,
che viene tradotto in: “campo RANGE val1,val2 === campo > val1 AND
campo < val2”;
[FORM<NUMERO_FORM>_]<NOME CAMPO>_SUP indica l’estremo
superiore del campo. Viene tradotto in: “campo < valore”;
[FORM<NUMERO_FORM>_]<NOME CAMPO>_INF indica l’estremo
inferiore del campo. Viene tradotto in “campo >= valore”;
ORDER_BY nome del campo su cui fare l’ordinamento;
ORDER_ORIENTATION,
può
assumere
i
valori
“ascendent”
o
“descendent”, e determina l’orientamento discendente o ascendente
dell’ordinamento.
La conversione appena descritta viene operata dalla procedura getJoinQuery. Come
per la libreria grafica, alcune procedure sono private e possono essere usate solo
all’interno della libreria stessa, mentre altre possono essere anche chiamate
dall’esterno. In dettaglio, le procedure ed i metodi della libreria sono:
Metodo di classe \norma_db: connect, ridefinisce una funzione DBI, consente la
connessione al db norma, ritorna un handler al db norma, o un errore in caso
di fallimento;
Metodo di classe norma_db: prepare, ad uso interno, ridefinisce una funzione
DBI, consente di comunicare al database una istruzione SQL per una sua
futura esecuzione;
Metodo di classe norma_db: execute, ad uso interno, ridefinisce una funzione
DBI, consente di eseguire una istruzione SQL precedentemente comunicata al
database.
Metodo di classe norma_db: begintran, ad uso interno, inizia una transazione, se
necessario in maniera esplicita in dipendenza del DBMS;
Metodo di classe norma_db: commit, ad uso interno, tenta di committare, se ci
riesce la transazione termina;
Metodo di classe norma_db: rollback, ad uso interno, annulla gli aggiornamenti
operati nella transazione corrente;
Metodo di classe norma_db: do, ad uso interno, ridefinisce una funzione DBI,
prepara ed esegue una istruzione SQL.
Metodo S_Data_Output: getPrintableFormat(S_Data_Output), ad uso interno,
trasforma in formato leggibile il risultato di una query, in particolare per i
campi di tipo data si applica la funzione str2date;
Metodo di istanza string: getSQLformat($table: string, $col: string, $val: string), ad uso
interno, ritorna il formato per una query SQL del valore, se il valore
corrisponde ad un campo stringa del database lo quota, altrimenti resta
invariato, ritorna un codice di errore se l’operazione fallisce;
Metodo di istanza string: getConTextQueryStr($values: \hash, $formId: int), ad uso
interno, ritorna il formato per una query testuale del valore, dipende dal
sistema di indicizzazione usato, ritorna undef se l’operazione fallisce;
Metodo di istanza string: getSQLQueryStr($table: string, $values: \hash, $formId: int),
ad uso interno, ritorna la stringa di query sulla tabella specificata con i valori
passati in input su un array associativo, in caso di forms multipli restituisce la
stringa di query corrispondente, al form specificato dal parametro di input
$formId;
Metodo di istanza \hash: normaliseInfo(info: \hash), ad uso interno, normalizza i
dati presenti nel vettore associativo docInfo, in modo da essere paragonabili a
quelli presenti nel DB. ad esempio trasformale date di qualsiasi formato in
“gg-mm-aa” (due cifre per il giorno, due per il mese e due per l’anno). Se le
informazioni riguardano un singolo tipo di documento la normalizzazione
Specifiche Software del lato server
avviene per tipo. Ritorna un errore per quei valori che non possono essere
normalizzati;
Metodo di istanza string: getJoinQuery ($tables: \array, $inref: \hash), ad uso
interno, procedura che restituisce la stringa di query SQL sulle tabelle, in input
in $tables, utilizzando i valori presi in input in $inref, aggiunge anche le
condizioni di Join e gestisce le query di form, multipli in or.
Metodo di istanza boolean: writeHash ($table: string, $prop: \hash), ad uso interno,
inserisce nel DB i dati passati come parametro di input, tramite un vettore
associativo, restituisce il valore “true” se l’inserimento va a buon fine;
Metodo di istanza boolean: updateHash ($table: string, $prop: hash), ad uso interno,
inserisce nel DB i dati passati come parametro di input tramite un vettore
associativo, restituisce il valore “true” se l’inserimento va a buon fine;
Metodo di istanza string: hash2txt ($inref: \hash), procedura che restituisce una
stringa testuale leggibile corrispondente alla query inserita dall’utente e presa in
input nel vettore associativo $inref
Metodo di istanza \hash: addNewType ($inref: \hash), controlla se ci sono tutte le
caratteristiche essenziali per i tipi di documenti, se si, crea il tipo, lo inserisce
nel DB e nel file di configurazione e ritorna un nuovo codice di tipo, se no,
ritorna un codice di errore;
Metodo di istanza array of S_Type_Info: getTypeInfoList (), procedura che
restituisce la lista delle proprietà dei tipo di atti;
Metodo di istanza array of S_Doc_Info g: getDocInfoList ($inref: hash), procedura
che trova i documenti che verificano le condizioni in input, restituisce un
vettore di proprietà di documenti;
Metodo di istanza array of S_Ver_Info: getVerInfoList ($inref: hash), procedura che
trova le versioni che verificano le condizioni in input, restituisce un vettore di
proprietà di documenti;
Metodo di istanza array of S_Part_Info: getPartInfoList ($inref: hash), procedura
che trova le partizioni che verificano le condizioni in input, restituisce un
vettore di proprietà di documenti;
Metodo di istanza array of S_Ver_Info: getDocVersionList ($inref: hash), procedura
che trova tutte le versioni di un documento, richiede gli identificativi univoci
del documento, restituisce un vettore di proprietà di documenti;
Metodo di istanza array of hash: getVersionLinkList ($inref: hash), procedura che
trova tutti i link di un documento, richiede gli identificativi univoci del
documento, restituisce un vettore di proprieta’ di documenti;
Metodo di istanza array of S_Ver_Info: getVersionAttachList ($inref: hash),
procedura che trova tutti i link di un documento, richiede gli identificativi
univoci del documento, restituisce un vettore di proprieta’ di documenti.
1.7 L’ARCHITETTURA DISTRIBUITA DEL SERVER
Il server è stato concepito in maniera distribuita. Ogni base dati, per far parte del
sistema, deve comunicare al gestore centrale quali atti normativi gestisce e la
modalità di accesso ad essi (URL per accedere). Il server Internet centrale sarà
quindi in grado di compilare una tabella contenente le informazioni che gli
vengono inviate, e cioè la lista dei tipi di documenti (emanati da una particolare
fonte normativa) che sono reperibili in Internet, in corrispondenza dei quali sarà
indicata l’URL che dovrà essere utilizzata per reperire i documenti in questione.
Di seguito mostriamo un esempio di questa tabella.
Tipo di documento
URL
Delibera del Consiglio Comunale di Bologna
http://www.comune.bologna.it/delcons/getDoc
Delibera del Consiglio Comunale di Milano
http://www.comune.milano.it/delcons/getDoc
Regolamento del Consiglio Comunale di Milano
http://www.comune.milano.it/relcons/getDoc
Legge dello Stato Italiano
http://www.parlamento.it/leggi/getlegge
Figura 7 Tabella di corrispondenza tra tipi ed URL
Il server centrale sarà poi in grado di distribuire la tabella a chiunque ne faccia
richiesta, in modo che ogni sito sia in grado di recuperare qualsiasi tipo di
documento.
Specifiche Software del lato server
Vista la scarsa frequenza di aggiornamento, per la distribuzione di questa tabella
dal server centrale agli altri non abbiamo ritenuto opportuno adottare sistemi
sofisticati. La tabella infatti varia solo quando una fonte normativa decide di
pubblicare in Internet i propri atti, oppure quando cambia l’URL di pubblicazione
di un determinato tipo di atto. A nostro parere sarebbe sufficiente un
aggiornamento giornaliero. Un certo numero di server, in grado di sostituire
quello principale, potranno in futuro essere predisposti, al fine di distribuire la
tabella ai server secondari, nel caso in cui il server principale non sia raggiungibile.
Un esempio di URL corrispondente ad un programma che realizza la funzione di
ricerca potrebbe essere “http://www.cirfid.unibo.it/cgi-bin/search”, a cui
potranno essere inviati i parametri identificati precedentemente. In pratica, se
l’utente sceglie di ricercare un atto normativo emanato il 12/12/1968, gli sarà
sufficiente inviare una sola richiesta del tipo “search?data_em=12/12/1968” al
suo sistema, che la lancerà in parallelo su tutti i siti, secondo le procedure stabilite
da ognuno di essi, attenderà i risultati, li unirà e li mostrerà all’utente in una
finestra, in modo che possa consultare l’atto di suo interesse.
Fino ad ora abbiamo puntato l’attenzione sul recupero del documento,
trascurando l’individuazione della partizione cercata. In realtà, se si pretende la
precisione nel seguire i collegamenti è necessario che questo programma CGI sia
in grado di riconoscere la struttura interna degli atti normativi gestiti dal proprio
sistema, così da poter riconoscere ad esempio l’articolo 3 distinguendolo dal resto
del testo, e restituire il documento aperto al suo inizio. Il collegamento ipertestuale
tra i testi normativi si realizza costruendo un metodo comune di referenziamento
prima di una norma all’interno delle norme dello stesso tipo (ad esempio, per
individuare la legge 12 del 1985 tra tutte le altre leggi dello stato) e poi delle
singole partizioni al suo interno (ad esempio, per individuare il terzo articolo della
stessa legge).
Disponendo di queste informazioni sarà possibile referenziare l’articolo 3 della
legge 12 del 1985. L’informazione sulla strutturazione ci è indispensabile per
riconoscere che gli articoli sono al sesto posto nella gerarchia e quindi
l’indicazione dell’articolo cercato deve comparire al sesto posto.
La stringa di referenziamento così costruita sarà poi inviata al server Internet su
cui sono pubblicate le Leggi dello Stato Italiano, attraverso una chiamata del tipo
“http://www.parlamento.it/leggi/getlegge?12/1985#art3”. La funzione di ricerca
delle partizioni testuali all’interno di un testo normativo è una funzione di
secondo livello, ma ogni server sarà comunque in grado di reperire e restituire
correttamente almeno l’intero documento. Come mostrano gli esempi fatti, le
funzionalità di primo livello possono essere aggiunte in modo semplice, senza
alcuna modifica al sistema esistente, utilizzando ad esempio un linguaggio come il
Perl, particolarmente adatto alla comunicazione CGI che permette di scrivere
facilmente una interfaccia di livello base. Per fare ciò dovrà indicare al programma
di consultazione della banca dati qual è l’inizio dell’articolo 3, inserendo in quel
punto il testo “<A NAME=”art3”>“, magari deducendo il pinto di inserimento
di questa stringa dal testo stesso.
Per realizzare una interfaccia al livello base è infatti sufficiente un programma che
legga i parametri passati e provveda ad effettuare le chiamate necessarie a
recuperare il documento cercato. Ad esempio, se il sistema utilizzato fosse un
Data Base si dovrebbe collegare al Data Base stesso lanciando una ricerca per il
recupero del documento, restituendo poi al chiamante il risultato; se invece il
sistema mantenesse semplicemente i documenti in un archivio dovrebbe
possedere una mappa che gli permetta di risalire dall’identificativo unico al nome
del file in cui è memorizzato il documento che deve essere restituito; altro caso
ancora, se si disponesse di un sistema di information retrieval, ma anche in questo
caso sarebbe sufficiente passare al motore di ricerca gli identificativi univoci e
restituire il risultato.
Per implementare una interfaccia di livello superiore è necessario come minimo
disporre di un sistema di ricerca testuale, che individui la parola cercata nel
documento, senza preoccuparsi della posizione all’interno del documento. Sarà
quindi sufficiente scrivere un programma CGI che riceve i parametri da ricercare,
li passa al sistema di ricerca e restituisce il risultato dopo averlo tradotto in
chiamate di tipo URL per il recupero dei documenti in questione tramite il CGI di
cui si è parlato all’inizio del presente paragrafo.
Specifiche Software del lato server
Se poi si dispone di un sistema per la ricerca all’interno delle singole partizioni, si
sarà in grado di fare ricerche, ad esempio, sulla data di emanazione, ed anche in
questo caso il CGI ricevendo i parametri in input li passerà in modo opportuno al
sistema di ricerca e convertirà i risultati.
2 Aspetto e funzionamento
dell’interfaccia per la consultazione
degli atti in Internet
Al sistema ci si connette specificando l’URL dell’home page Norma (mostrata in
Figura 81), dalla quale è possibile accedere a tutte le funzionalità del sistema.
Sempre da questa pagina iniziale è anche possibile accedere ad una pagina di
informazioni sul sistema (sempre mostrata in Figura 8), semplicemente cliccando
con il mouse sulla corrispondente voce della barra di navigazione. Dalla pagina delle
informazioni si può quindi accedere alla documentazione sul programma (in
diversi formati) e ad altre informazioni quali l’indirizzo di posta elettronica
dell’assistenza in linea.
1
Le immagini mostrate in questo paragrafo, si riferiscono ad una personalizzazione grafica del
sistema del settembre 1999 ed attualmente non più in uso. Alcune videate della
personalizzazione grafica attualmente in uso sono mostrate in appendice B. La grafica, sia nella
versione mostrata in queste immagini, sia nella versione attuale, è stata curata da Luca Baroncini.
Specifiche Software del lato server
Figura 8 Home page e pagina di informazioni sul sistema
Si noterà che la barra di navigazione è rimasta costante nelle due immagini
mostrate in Figura 8 in modo da fornire all’utente un punto di riferimento fisso e
costante nella navigazione all’interno del sito Norma. La barra di navigazione sarà
sempre presente: in un qualsiasi momento e da qualsiasi punto della navigazione
sarà possibile ritornare alla pagina iniziale o in uno dei punti previsti dalla barra.
Accorgimenti di questo tipo, che rendono semplice e coerente la consultazione
della base di dati, sono uno dei punti di forza del database Norma rispetto alla
gran parte delle banche dati normative che sono molto spesso difficilmente
consultabili. Riteniamo infatti molto importante consentire a chiunque di reperire
tutto quello che desidera all’interno della base di dati, pur non essendo esperto di
informatica. In particolare, il database Norma ha come finalità ultima quella di
essere utilizzato non già da esperti di informatica, ma da giuristi a cui non può
essere richiesta una conoscenza approfondita di informatica e documentazione
elettronica.
2.1 LA RICERCA DEI DOCUMENTI
Tutte le funzionalità di ricerca all’interno del database sono accessibili cliccando
alla voce ricerca della barra di navigazione. L’utente (come mostrato in Figura 9)
potrà quindi selezionare diversi criteri di ricerca predefiniti, di solito
corrispondenti alle diverse tipologie di documenti presenti nel database. Possono
essere tuttavia presenti delle voci generiche come “cerca in tutti i documenti
presenti sul database” o anche personalizzate dall’amministratore della base di
dati2, che potrebbero consentire di eseguire ricerche su tutte le tipologie di atto
che
hanno efficacia
in una
determinato ambito territoriale
(ricerche
contemporanee sulla normativa comunale, regionale e Statale relativa ad un
determinato argomento). Il meccanismo è simile a quello dei canali di ricerca
dell’Italgiure-Find (cfr. paragrafo 2.3.1), ma è molto più flessibile, in quanto i
diversi criteri di ricerca di Norma non corrispondono realmente ad archivi
disgiunti tra loro, che costringono l’utente ad una scelta sull’archivio su cui
cercare, ma corrispondono semplicemente ad una selezione di documenti scelta
dall’amministratore del sistema (su suggerimento, evidentemente, di un giurista)
basata sull’uniformità degli atti rispetto ad una o più caratteristiche (ad esempio
tutti ed i soli atti efficaci nel comune di Bologna, o tutti ed i soli regolamenti
comunali emanati dopo una certa data).
Figura 9 Accesso ai criteri di ricerca e maschera di ricerca per le Leggi dello Stato
2
La personalizzazione della base di dati viene effettuata operativamente dall'amministratore del
sistema, in quanto richiede competenze tecniche, ma deve essere fatta in collaborazione con un
giurista in grado di definire quali siano ile selezioni predefinite rilevanti all'interno della base di
dati e quali siano i parametri cercabili all'interno di questa selezione.
Specifiche Software del lato server
Sempre in Figura 9 è invece mostrato il caso della ricerca nell’archivio delle “Leggi
dello Stato”, il dettaglio di Figura 10 rende evidenti i parametri cercabili per questa
tipologia di atti, che analizzeremo uno per uno.
Numero della Legge. E’ questo il nome dell’unico l’identificativo per una
Legge dello Stato. Vale la pena di notare che ogni tipologia di atto può avere
identificativi di nome e numero diversi, ad esempio le delibere di una giunta
comunale hanno solitamente due identificativi, l’ordine del giorno (O.d.G.) ed
un progressivo generale (PG). Il sistema è in grado di adattarsi
automaticamente alle caratteristiche degli atti che gestisce, e nel caso di
ricerche all’interno delle delibere comunali verrà presentata all’utente la
possibilità di specificare “O.d.G.” e “PG”. anziché “n.”. Se inoltre il criterio di
ricerca selezionato non corrispondesse a una particolare tipologia di atti,
compare una generica voce “identificativo”.
Date di Emanazione e Pubblicazione. Sono parametri molto importanti
nella ricerca di atti normativi, è tipico (e corretto) infatti indicare un
riferimento normativo non solo con il suo identificativo, ma anche con la sua
data e luogo di pubblicazione. E’ importante inoltre rilevare la possibilità del
sistema di cercare non solo gli atti emanati o pubblicati in una particolare data,
ma anche quelli emanati o pubblicati prima o dopo la data specificata. Questo
consente, ad esempio, di cercare tutti gli atti emanati successivamente l’entrata
in vigore di una nuova norma, in modo da verificare eventuali incompatibilità
al fine di una revisione della norma stessa.
Date di Vigore ed Efficacia In generale le banche dati normative
propongono i documenti o nella loro forma originale (quella approvata
dall’autorità emanante) con allegate tutte le novelle che hanno operato su di
essa (così fa ad esempio “Italgiure-Find”), oppure il testo unico che recepisce
tutte le modifiche operate dalle varie novelle (questo è il modo di operare ad
esempio delle “Leggi d’Italia”). Non è quindi possibile, nelle comuni banche
dati, richiedere testo consolidato vigente ad una particolare data del passato.
La disponibilità di tutti i testi consolidati costituisce invece una delle
innovazioni introdotte dal sistema Norma di portata maggiore. In caso di
contenziosi penali relativi ad un evento accaduto un particolare periodo infatti,
la normativa da applicare non è quella efficace al momento del dibattimento in
aula, ma quella efficace al momento in cui si sono svolti i fatti. Con le
metodologie tradizionali tale normativa dovrebbe essere ogni volta
faticosamente ricostruita o dal testo unico vigente, sottraendo le modifiche al
testo intervenute dal fatto da giudicare al giudizio, oppure dal documento
originale aggiungendo le modifiche intervenute dalla sua approvazione al
momento del fatto da giudicare. Il sistema Norma mantiene invece tutte le
successive versioni del testo unico, ed è in grado di reperire quella vigente e/o
efficace ad una determinata data. Per evitare comunque confusione vengono
trovati , se non diversamente specificato, i soli documenti attualmente in
vigore (nella versione del testo consolidato corrispondente al loro attuale stato
di efficacia). Eseguendo una ricerca ad una determinata data di vigore, la
navigazione viene bloccata a quella specifica data. Tutti i link che verranno
seguiti da quel momento in poi permetteranno di accedere, se non
diversamente specificato, al testo dei documenti in vigore alla data prescelta.
Contenuto del testo. E’ questo un parametro di ricerca divenuto piuttosto
comune, che consente di trovare tutti i testi che contengono al loro interno
una o più parole identificative del concetto cercato, eventualmente correlate
tra loro da operatori di vicinanza o esclusione. Questo tipo di ricerca è
indispensabile a compensare i difetti intrinseci in una indicizzazione a priori di
un documento (classificazione). Non sempre infatti i documenti sono
classificati correttamente, per cui è molto frequente la possibilità di non
trovare all’interno di una possibile categoria di documenti tutti quelli che
riguardano un determinato argomento (ad esempio è possibile che una ricerca
nei documenti comunali archiviati alla voce “personale” non siano tutti ed i
soli che riguardano il personale comunale per errore di chi ha classificato i
documenti). Generalmente, però, non è possibile eseguire ricerche testuali
combinandole con gli altri parametri di ricerca quali le date di vigore o
emanazione. Il sistema Norma invece, come altra innovazione di portata
Specifiche Software del lato server
considerevole, consente, ad esempio, di cercare tutta la normativa contenente
una determinata parola (eventualmente solo se vicina ad un’altra) e che
contemporaneamente sia stata emanata dopo una particolare data o da un
particolare organo dello stato.
Figura 10 Maschera per la ricerca all’interno delle Leggi dello Stato: a) Dettaglio dei parametri
di ricerca utilizzabili; b) Dettaglio delle opzioni di visualizzazione.
Il dettaglio b) in Figura 10, mostra la possibilità di scegliere il formato di
visualizzazione del risultato E’ possibile scegliere se visualizzare semplicemente la
lista dei riferimenti agli atti che soddisfano la ricerca, o anche la lista dei singoli
articoli che soddisfano la ricerca o ancora il testo integrale degli articoli E’
possibile inoltre scegliere l’ordinamento con cui il risultato viene presentato. I
diversi formati disponibili verranno descritti più in dettaglio nel paragrafo
riguardante il risultato della ricerca.
Eseguendo una ricerca ad una determinata data di vigore, la navigazione viene
bloccata a quella specifica data. Tutti i link che verranno seguiti da quel momento
in poi permetteranno di accedere, se non diversamente specificato, al testo dei
documenti in vigore alla data prescelta.
Sempre nello stesso dettaglio in Figura 10 è evidenziata la possibilità di aggiungere
una nuova richiesta alternativa alla precedente, in modo da poter effettuare
ricerche contemporanee su più criteri di ricerca, situazione questa evidenziata dalla
Figura 11. Il risultato sarà costituito dai documenti che soddisfano una qualsiasi
delle due ricerche (può trattarsi in realtà di un numero qualsiasi).
Figura 11 Ricerca contemporanea su due diversi criteri di ricerca, il risultato sarà costituito dai
documenti che soddisfano anche una sola delle richieste.
In conclusione, la ricerca all’interno della base di dati consente di:
Cercare in tutta la base di dati o in selezioni predefinite su di essa
dall’amministratore, usando maschere di ricerca “mirate” alla tipologia di atto
cercata, che quindi consentono di specificare tutti i possibili parametri, quali
gli identificativi (di nome e numero diversi a seconda della tipologia di atto), la
specificazione geografica, le date di emanazione o pubblicazione, l’autorità
emanante.
Cercare un documento in un suo particolare stato di vigore e/o efficacia,
caratteristica questa particolarmente innovativa.
Cercare un documento in base alle parole contenute nel testo. Particolarmente
interessante a questo riguardo è la possibilità di combinare queste ricerche
“testuali” con le altre descritte in precedenza.
Cercare contemporaneamente su più canali di ricerca, cioè su più selezioni
predefinite della base di dati tipicamente corrispondenti alle diverse tipologie
di atti.
Tutte queste potenzialità, unite alla estrema gradevolezza dell’interfaccia ed alla
sua facilità d’uso, rendono Norma un potentissimo strumento per la ricerca della
normativa.
Specifiche Software del lato server
2.2 IL RISULTATO DELLA RICERCA
Il risultato della ricerca può essere visualizzato in diverse maniere, in dipendenza
delle scelte dell’utente. In ogni caso, però, sarà presente un riassunto della richiesta
che è stata effettuata, la lista di riferimenti hai documenti che soddisfano la ricerca,
e la possibilità di cambiare la visualizzazione, come mostrato in Figura 12. A
questi elementi si possono aggiungere, cambiando la modalità di visualizzazione,
anche la lista dei riferimenti alle partizioni (ad esempio articoli) che per ogni
documento soddisfano la ricerca effettuata testuali come mostrato in Figura 13, o
addirittura il testo integrale di dette partizioni, come mostrato in Figura 14.
Ovviamente, da ogni elemento della lista dei documenti è possibile con un
semplice “click” del mouse risalire all’intero documento, come pure da ogni
elemento della lista delle partizioni al testo della partizione e da questo all’intero
documento che la contiene. Ci occuperemo nel paragrafo successivo di descrivere
con maggior dettaglio le modalità di visualizzazione dei documenti e delle
partizioni al loro interno.
Figura 12 Il risultato della ricerca: a) Dettaglio con sintesi della richiesta effettuata; b) Dettaglio
della scelta della modalità di visualizzazione; c) Dettaglio del riferimento al documento.
Dal dettaglio c) di Figura 12, è possibile notare che ogni elemento della lista è
identificato anche dallo stato di vigore del documento. La lista può visualizzare
infatti il riferimento allo stesso documento in versioni corrispondenti a stati di
vigore o efficacia diversi (sempre se tutte queste versioni soddisfano la ricerca, il
che succede solo se non è stata specificata una particolare data di vigore nella
maschera di ricerca).
Dalla pagina risultato si può in ogni momento raffinare la ricerca per escludere i
documenti indesiderati tornando alla maschera di ricerca ed introducendo dei
criteri più selettivi o, in alternativa, tornare ad eseguire una ricerca completamente
nuova.
La pagina risultato della ricerca può essere salvata in locale come file HTML,
oppure stampata. Il riassunto indicante la ricerca effettuata consentirà in questo
caso di sapere a quale ricerca corrispondono i documenti contenuti nel file o nella
stampa. Anche dal documento salvato in locale è inoltre possibile seguire i
collegamenti, in quanto sono collegamenti “assoluti” e non “relativi”, specificano
cioè l’intero percorso dove i documenti debbono essere cercati. Il documento può
così, ad esempio, essere spedito per posta elettronica, ed il ricevente può accedere
ai documenti in esso elencati senza alcuna difficoltà. Particolare rilevanza, nel caso
di archiviazione dei risultati della ricerca o di sua trasmissione a terzi, ha il
riassunto della richiesta effettuata, stampato in formato leggibile in testa ad ogni
pagina risultato di una ricerca. Esso qualifica infatti il contenuto della pagina,
permettendo di conoscere a quali requisiti corrispondano i documenti elencati.
Figura 13 Risultato della ricerca con evidenziazione dei riferimenti alle partizioni testuali che
soddisfano la ricerca effettuata.
Molto interessante è anche la possibilità di cambiare il formato di visualizzazione
della pagina. La lista delle partizioni testuali che soddisfano una ricerca, ed ancor
di più il loro testo, può essere molto lunga, e rendere così il documento di risposta
molto voluminoso e praticamente illeggibile. E’ invece possibile visualizzare solo
la lista dei documenti e raffinare la ricerca, finché non si isola un numero di
documenti tale da rendere accettabile la gestione delle singole partizioni al loro
interno, e solo allora visualizzare (o stampare) le partizioni.
Specifiche Software del lato server
Figura 14 Risultato della ricerca con evidenziazione testo delle partizioni testuali che soddisfano
la ricerca effettuata.
Da notare, infine, anche la possibilità di accedere diversi formati del documento
trovato. In tutte le possibili modalità di visualizzazione è evidenziata infatti,
accanto ai dati identificativi del documento, la presenza o meno nel database di
formati alternativi all’HTML del documento. Il sistema prevede la gestione del
formato Microsoft Word, Adobe Acrobat ed Immagine, (tipicamente indicati
rispettivamente con le estensioni “.doc”, “.pdf”, “.gif”). Selezionando con il mouse
l’immagine corrispondente all’eventuale formato alternativo, il documento in quel
formato verrà memorizzato sull’elaboratore per essere consultato o stampato con
gli strumenti appositi.
In conclusione, anche la visualizzazione del risultato della ricerca è stata
particolarmente curata, con l’intenzione di fornire un riferimento flessibile
(diverse modalità di visualizzazione), potente (possibilità di archiviazione, di
accesso al documento ed alle sue partizioni in diversi formati) e facile da usare.
2.3 LA VISUALIZZAZIONE DEL TESTO DEI
DOCUMENTI
Per la visualizzazione del testo dei documenti si è preferito dividere la
visualizzazione in due parti. La prima, mostrata nel dettaglio a) di Figura 15, è
un’intestazione sempre ben visibile sopra al testo del documento, riassume i suoi
dati essenziali (il titolo, gli identificativi, le date di inizio e fine vigore ed efficacia
della versione del testo consolidato che si sta consultando). Sempre
nell’intestazione del documento sono presenti alcuni pulsanti che consentono di
cambiare la modalità di visualizzazione del documento sottostante. Oltre al testo
del documento è possibile infatti
mostrare informazioni aggiuntive sul
documento (ad esempio le date di emanazione e pubblicazione), la catena delle
versioni successive di uno stesso documento (con la possibilità di accedere ad un
punto qualsiasi della catena) ed i riferimenti in arrivo o partenza al/dal
documento. Di queste alternative modalità di visualizzazione ci occuperemo più in
dettaglio nei prossimi paragrafi.
Figura 15 Visualizzazione del documento: a) Dettaglio dell’intestazione del documento; b)
Dettaglio del testo del documento in visualizzazione normale.
Se non diversamente specificato invece, il testo del documento è visualizzato
senza alcuna informazione aggiuntiva, in una maniera che rispecchia il più
possibile corrispondente alla pubblicazione ufficiale. Il sommario (presente
obbligatoriamente in tutti gli atti normativi suddivisi in un articolato di più di venti
articoli) viene reso navigabile, è possibile cioè arrivare al testo dell’articolo il cui
riferimento è presente nel sommario con un semplice click del mouse. Sono
navigabili anche tutti i riferimenti interni al documento, ed i riferimenti esterni al
documento che si riferiscono ad altri documenti presenti all’interno della base di
dati. E’ cosi’ possibile navigare all’interno della base di dati, percorrendo la fitta
catena di citazioni tipiche degli atti normativi. I riferimenti restano inoltre
navigabili anche nel caso in cui il documento che si sta consultando venga salvato
in locale. E’ quindi possibile, dopo aver archiviato sul proprio personal computer i
documenti letti dal server Norma per una veloce e facile consultazione, accedere
di nuovo al server solo per seguire i riferimenti in esso contenuti o verificare la
presenza di una nuova versione in vigore del documento stesso.
Specifiche Software del lato server
2.4 LA VISUALIZZAZIONE DEI RIFERIMENTI NEL
TESTO
Quando richiesto, è possibile visualizzare, in testa al testo del documento, la lista
dei riferimenti passivi, cioè la lista di tutti i documenti (contenuti nel database) che
citano (o modificano) quello che si sta attualmente leggendo, come mostrato in
Figura 16. I riferimenti passivi, spesso non reperibili in altre basi di dati, sono
molto utili per conoscere tutti i documenti correlati al corrente, e consentono ad
esempio di conoscere tutte le norme attuative di una legge quadro (tali norme non
sarebbero altrimenti reperibili).
Figura 16 Visualizzazione dei riferimenti passivi del documento.
L’informazione sui riferimenti passivi è inoltre presente anche all’interno del testo
stesso. All’inizio di ogni partizione (articolo, comma ecc.) sono indicati i suoi
riferimenti passivi, specificando anche se si tratta di citazioni o modifiche (e nel
qual caso quale tipo di modifica hanno operato, se un inserimento, una
sostituzione, una sospensione ecc.). La visualizzazione dei riferimenti partizione
per partizione si è resa necessaria a causa dell’esistenza di documenti molto lunghi,
con moltissimi riferimenti passivi. In questi casi non è spesso significativo
conoscere quali sono tutti i riferimenti in arrivo al documento, mentre può esserlo
per un suo sottoinsieme che tratta di una specifica materia.
I riferimenti sono inoltre tipizzati e descrivono il tipo di relazione che intercorre
tra i documenti. Nella lista è così evidenziato, ad esempio, se il riferimento è un
normale rinvio informativo o se si tratta invece di una modifica della destinazione.
Nel complesso questa visualizzazione consente di posizionare il documento
all'interno di una mappa della normativa che ad essa si riferisce, e di evidenziare il
contesto nel quale si inserisce. E' questo il primo passo verso la realizzazione di
mappe della conoscenza normativa descritte nel primo capitolo.
2.5 LA VISUALIZZAZIONE DELLA CATENA DELLE
VERSIONI DI UN TESTO
La modalità di visualizzazione che mostra tutte le versioni disponibili di un
determinato atto normativo, anch’essa selezionabile dall’intestazione del
documento, consente di navigare in versioni precedenti e successive del
documento. Anche questa è una funzionalità non presente in altre banche dati
normative, ma molto utile per molteplici motivi, ad esempio per vedere come il
documento è cambiato nel tempo, o per conoscere quale versione della normativa
era applicabile in un determinato momento della storia, o ancora per visualizzare il
documento originale (unico approvato dall’autorità emanante, unico quindi ad
avere valore normativo e non informativo).
La navigazione, come mostrato in Figura 17, è assicurata da un set di pulsanti che
consentono di risalire alla versione precedente, alla successiva, all’originale ed a
quella attualmente in vigore. Se la versione corrispondente non è raggiungibile (ad
esempio se non c’è alcuna versione successiva, perché quella che si sta
consultando è quella in vigore e quindi l’ultima) il corrispondente pulsante è
disabilitato. E’ possibile anche raggiungere una specifica versione attraverso la lista
di tutte le altre versioni disponibili (presente immediatamente sotto ai pulsanti
descritti) che mostra gli intervalli di validità di ogni versione.
Figura 17 Visualizzazione della catena delle versioni di un documento
Specifiche Software del lato server
2.6 LA VISUALIZZAZIONE DEL TESTO DI UNA
SINGOLA PARTIZIONE
E’ possibile visualizzare il testo di una singola partizione del documento, come
mostrato in Figura 18. Anche in questo caso, la visualizzazione si divide in due
parti: un’intestazione contenente i dati riassuntivi della partizione ed il testo della
partizione stessa. Visualizzare il testo di una sola partizione può essere necessario
nei casi in cui, il documento nel suo complesso sia eccessivamente lungo, o ancora
nei casi in cui l’unica parte rilevante del documento sia la partizione in questione.
Figura 18 Visualizzazione di una singola partizione
Da questa modalità di visualizzazione è possibile momento:
visualizzare l’intero documento (aperto sulla partizione)
reperire la partizione precedente o successiva;
visualizzare i riferimenti passivi della partizione;
reperire la versione precedente o successiva della stessa partizione.
2.7 MODELLI E VIDEATE DELL’INTERFACCIA
I modelli di videate dell'interfaccia servono a definire l'aspetto grafico del sistema.
Il funzionamento dei modelli è spiegato nel paragrafo 4.2.2, in questa appendice
forniremo il listato dei modelli più significativi e le immagini dell'interfaccia da essi
risultanti.
2.7.1 Il modello per selezionare il tipo di atti da ricercare
Questo modello definisce l'aspetto della maschera di accesso ai form di ricerca
specifici per le varie tipologie di atto.
<HTML>
<HEAD>
<TITLE>Ricerca per tipo di documento</TITLE>
</HEAD>
<BODY bgcolor=”white”>
<p>&nbsp;</p>
<center>
<table align=”center” border=”0” cellspacing=”0” cellpadding=”0” HEIGHT=”40”>
<tr border=”0”>
<td colspan=”2” border=”0”>
<img src=”/norma/nuoviss/tipolo.gif”><p>&nbsp;</p>
</td>
</tr>
<tr border=”0”>
<td border=”0”><img src=”/norma/nuoviss/list1.gif”></td>
<td align=”left”> </td>
</tr>
<!--n_FOREACH TYPE-->
<tr border=”0”>
<td border=”0”><img src=”/norma/nuoviss/list.gif” HEIGHT=”40” border=”0”></td>
<td align=”left” border=”0”><a href=”<!--n_PRINT_PROCEDURE GET_VER_LIST_PARENT-->?doc_type_id=<!-n_PRINT_PROPERTY DOC_TYPE_ID-->&order_by=start_vig_date&vig_date=<!--n_PRINT_PROPERTY PARENT.CUR_DATE->&vig_date_op=ON” target=”_parent”><!--n_PRINT_PROPERTY DOC_TYPE_NAME--></a></td>
</tr>
<!--/n_FOREACH TYPE-->
<tr>
<td colspan=”2” border=”0”><img src=”/norma/nuoviss/list2.gif”></td>
</tr>
</table>
</center>
</BODY>
</HTML>
Figura 19: Modello per la visualizzazione della lista dei tipi di atti su cui effettuare la ricerca
interpretato e non interpretato.
2.7.2 Il modello per la visualizzazione di un documento
Questo modello definisce l'aspetto con il quale verranno visualizzati i documenti
presenti nella base di dati. Esso è molto complesso perché tiene conto delle
diverse modalità possibili di visualizzazione e prevede, ad esempio, la
Specifiche Software del lato server
visualizzazione dei riferimenti passivi, piuttosto che la visualizzazione della catena
del versioning, piuttosto che la visualizzazione delle informazioni generali (data di
emanazione, pubblicazione, documenti allegati ecc.) sul documento.
<html>
<head>
<title> Dati riassuntivi documento</title>
<meta name="n_generator" value="getVersionBody.pl">
<meta name="n_template" value="getVersionBody.nss">
</head>
<body bgcolor="white">
<!-# Questo template definisce la visualizzazione del testo di una particolare versione di un documento.
# In base alle impostazioni della variabile VIEW_MODE possono o meno essere visualizzate informazioni
aggiuntive al testo.
-->
<!--n_PRINT_IF_MATCH VIEW_MODE "LINKS"-->
<!--Se VIEW_MODE contiene la stringa "LINKS", vengono visualizzate le informazioni sul documento in base a
quanto segue-->
<table border="1" width="80%" cellpadding="0" align="center" cellspacing="0" marginwidth="50%"
style="border: 1px solid rgb(0,0,0)" background="../nuoviss/ff1.gif">
<tr><td width="100%" valign="middle" align="left"><center><img src="../nuoviss/riftit.gif"></center><br>
<!--n_PRINT_IF_NOT_DEFINED LINK-->
<center><b>Non ci sono riferimenti passivi</b></center>
<!--/n_PRINT_IF_NOT_DEFINED LINK-->
<!--n_PRINT_IF_DEFINED LINK-->
<table>
<tr>
<td valign="top" width ="160"><center><b>Partizione citata</b></center><br></td>
<td valign="top" width = "350"><center><b>Citata da</b></center><br></td>
<td valign="top" width = "100"><center><b>Tipo di citazione</b></center><br></td>
</tr>
<!--n_FOREACH LINK-->
<tr>
<td valign="top"><small><a href="#<!--n_PRINT_PROPERTY TO_ANCHOR-->">
<!--n_PRINT_PROPERTY TO_PART_NAME-->
</a></small></td>
<td valign="top"><small><a href="<!--n_PRINT_PROCEDURE GET_VERSION_PARENT->?view_mode=links&follow_mode=static&doc_type_id=<!--n_PRINT_PROPERTY FROM_DOC_TYPE_ID->&attach_type_id=<!--n_PRINT_PROPERTY FROM_ATTACH_TYPE_ID-->&ver_id=<!--n_PRINT_PROPERTY FROM_VER_ID->&part_id=<!--n_PRINT_PROPERTY FROM_ANCHOR-->" target="_parent">
<!--n_PRINT_PROPERTY TITLE--> <!--n_PRINT_PROPERTY FROM_PART_NAME-->
</a></small></td>
<td valign="top"><small>
<!--n_PRINT_PROPERTY LINK_TYPE_NAME-->
</small></td>
</tr>
<!--/n_FOREACH LINK-->
</table>
<!--/n_PRINT_IF_DEFINED LINK-->
</td></tr></table>
<br><br>
<!--ora stampo il documento, includendo i links-->
<table align="center" border=0 width="95%"><tr><td>
<!--n_PRINT_DOC_WITH_LINK FILE_NAME-->
<table width="80%" align="center" border = "1" cellpadding="0" cellspacing="0"
background="../nuoviss/ff1.gif">
<tr><td><small>
La partizione <!--n_print_property TO_PART_NAME--> e' stata citata dalla partizione<br>
<a href="<!--n_PRINT_PROCEDURE GET_VERSION_PARENT->?view_mode=links&follow_mode=static&doc_type_id=<!--n_PRINT_PROPERTY FROM_DOC_TYPE_ID->&attach_type_id=<!--n_PRINT_PROPERTY FROM_ATTACH_TYPE_ID-->&ver_id=<!--n_PRINT_PROPERTY FROM_VER_ID->&part_id=n_<!--n_PRINT_PROPERTY FROM_ANCHOR-->" target="_parent">
<!--n_print_property FROM_PART_NAME--> del documento <!--n_print_property TITLE-->
</a>
</small></td>
</tr></table><br>
<!--/n_PRINT_DOC_WITH_LINK FILE_NAME-->
</td></tr></table>
<!--/n_PRINT_IF_MATCH VIEW_MODE "LINKS"-->
<!--n_PRINT_IF_MATCH VIEW_MODE "INFO"-->
<!--Se VIEW_MODE contiene la stringa "INFO", vengono visualizzate le informazioni sul documento in base a
quanto segue-->
<table border="1" align="center" width="80%" cellpadding="0" cellspacing="0" marginwidth="50%"
style="border: 1px solid rgb(0,0,0)" background="../nuoviss/ff1.gif">
<tr><td width="100%" valign="middle" align="left"><center><img
src="../nuoviss/infotit.gif"></center><br>
<!--n_PRINT_IF_DEFINED title-->
<b>&nbsp;&nbsp;<!--n_print_property title--></b><br>
<!--/n_PRINT_IF_DEFINED title-->
<!--n_PRINT_IF_DEFINED doc_type_name-->
&nbsp;&nbsp;<!--n_print_property doc_type_name--><br>
<!--/n_PRINT_IF_DEFINED doc_type_name-->
<!--n_PRINT_IF_DEFINED id1-->
&nbsp;&nbsp;<!--n_print_property id1_name-->: <!--n_print_property id1--><br>
<!--/n_PRINT_IF_DEFINED id1-->
<!--n_PRINT_IF_DEFINED id2-->
&nbsp;&nbsp;<!--n_print_property id2_name-->: <!--n_print_property id2--> <br>
<!--/n_PRINT_IF_DEFINED id2-->
<!--n_PRINT_IF_DEFINED authority-->
&nbsp;&nbsp;emanato da: <!--n_print_property authority-->
<!--/n_PRINT_IF_DEFINED authority-->
<!--n_PRINT_IF_DEFINED deliver_date-->
il: <!--n_print_property deliver_date-->
<!--/n_PRINT_IF_DEFINED deliver_date-->
<!--n_PRINT_IF_DEFINED publication_date-->
<br>
&nbsp;&nbsp;pubblicato su: <!--n_print_property published_in-->
&nbsp;in data: <!--n_print_property publication_date-->
<!--/n_PRINT_IF_DEFINED publication_date-->
<!--n_PRINT_IF_DEFINED start_vig_date-->
<br>
&nbsp;&nbsp;nella versione in vigore dal: <!--n_print_property start_vig_date-->
<!--/n_PRINT_IF_DEFINED start_vig_date-->
<!--n_PRINT_IF_DEFINED end_vig_date-->
al: <!--n_print_property end_vig_date-->
<!--/n_PRINT_IF_DEFINED end_vig_date-->
<!--n_PRINT_IF_DEFINED start_eff_date-->
<br>
&nbsp;&nbsp;nella versione efficace dal: <!--n_print_property start_eff_date-->
<!--/n_PRINT_IF_DEFINED start_eff_date-->
<!--n_PRINT_IF_DEFINED end_eff_date-->
al: <!--n_print_property end_eff_date-->
<!--/n_PRINT_IF_DEFINED end_eff_date-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "\w+"-->
<br>Altri formati disponibili:<dir>
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "doc"-->
<li><A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID
"A"-->_A<!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY VER_ID-->/document.doc" TARGET =
"_blank">Microsoft Word Document (doc)</a> &nbsp; &nbsp; &nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "doc"-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "pdf"-->
<li><A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID
"A"-->_A<!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY VER_ID-->/document.pdf" TARGET =
"_blank">Adobe Portable Document Format (pdf)</a> &nbsp; &nbsp; &nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "pdf"-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "gif"-->
<li><A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID
"A"-->_A<!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY VER_ID-->/document.gif" TARGET =
"_blank">Immagine (gif)</a> &nbsp; &nbsp; &nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "gif"-->
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "\w+"-->
</dir>
<br>
<!--n_PRINT_IF_DEFINED ATTACH-->
Documenti allegati: <dir>
<!--n_foreach ATTACH-->
<li><a href="<!--n_PRINT_PROCEDURE GET_VERSION_PARENT->?follow_mode=static&view_mode=info&doc_type_id=<!--n_PRINT_PROPERTY DOC_TYPE_ID-->&attach_type_id=<!-n_PRINT_PROPERTY ATTACH_TYPE_ID-->&ver_id=<!--n_PRINT_PROPERTY VER_ID-->" target="_parent"><!-n_PRINT_PROPERTY TITLE--></a>
<!--/n_foreach ATTACH-->
</DIR>
<!--/n_PRINT_IF_DEFINED ATTACH-->
<!--n_PRINT_IF_DEFINED MASTER-->
Documento allegato al <!--n_PRINT_PROPERTY MASTER.DOC_TYPE_NAME--><a href="<!--n_PRINT_PROCEDURE
GET_VERSION_PARENT-->?follow_mode=static&view_mode=info&doc_type_id=<!--n_PRINT_PROPERTY
MASTER_DOC_TYPE_ID-->&attach_type_id=<!--n_PRINT_PROPERTY MASTER_ATTACH_TYPE_ID-->&ver_id=<!-n_PRINT_PROPERTY MASTER_VER_ID-->" target="_parent"> <!--n_PRINT_PROPERTY MASTER.TITLE--></a>
<!--/n_PRINT_IF_DEFINED MASTER-->
<br>
</td></tr>
</table>
<br><br>
<table align="center" border=0 width="95%"><tr><td>
<!--n_PRINT_FILE FILE_NAME-->
</td></tr></table>
<!--/n_PRINT_IF_MATCH VIEW_MODE "INFO"-->
<!--n_PRINT_IF_MATCH VIEW_MODE "VERSIONS"-->
<!--Se VIEW_MODE contiene la stringa "VERSIONS", vengono visualizzate le informazioni sulle altre versioni
in base a quanto segue-->
<table border="1" align="center" width="80%" cellpadding="0" cellspacing="0" marginwidth="50%"
style="border: 1px solid rgb(0,0,0)" background="../nuoviss/ff1.gif">
<tr><td align="center" ><img src="../nuoviss/vertit.gif"><br><br>
<!--n_PRINT_IF_DEFINED FIRST_VER_ID-->
<a href="<!--n_print_procedure GET_VERSION_PARENT->?follow_mode=static&view_mode=versions&ver_id=<!--n_print_property FIRST_VER_ID-->&doc_type_id=<!-n_print_property DOC_TYPE_ID-->&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->" target="_parent">
<img src="../nuoviss/verorig.gif" alt="Versione Originale" border="0"></A>
<!--/n_PRINT_IF_DEFINED FIRST_VER_ID-->
<!--n_PRINT_IF_NOT_DEFINED FIRST_VER_ID-->
<img src="../nuoviss/verorigs.gif" alt="Il documento è in versione originale" border="0">
Specifiche Software del lato server
<!--/n_PRINT_IF_NOT_DEFINED FIRST_VER_ID-->
<!--n_PRINT_IF_DEFINED PREC_VER_ID-->
<a href="<!--n_print_procedure GET_VERSION_PARENT->?follow_mode=static&view_mode=versions&ver_id=<!--n_print_property PREC_VER_ID-->&doc_type_id=<!-n_print_property DOC_TYPE_ID-->&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->" target="_parent">
<img src="../nuoviss/verprec.gif" alt="Versione Precedente" border="0"></a>
<!--/n_PRINT_IF_DEFINED PREC_VER_ID-->
<!--n_PRINT_IF_NOT_DEFINED PREC_VER_ID-->
<img src="../nuoviss/verprecs.gif" alt="Non esistono versioni precedenti" border="0">
<!--/n_PRINT_IF_NOT_DEFINED PREC_VER_ID-->
<!--n_PRINT_IF_DEFINED SUCC_VER_ID-->
<a href="<!--n_print_procedure GET_VERSION_PARENT->?follow_mode=static&view_mode=versions&ver_id=<!--n_print_property SUCC_VER_ID-->&doc_type_id=<!-n_print_property DOC_TYPE_ID-->&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->" target="_parent">
<img src="../nuoviss/versucc.gif" alt="Versione Successiva" border="0"></a>
<!--/n_PRINT_IF_DEFINED SUCC_VER_ID-->
<!--n_PRINT_IF_NOT_DEFINED SUCC_VER_ID-->
<img src="../nuoviss/versuccs.gif" alt="Non esistono versioni successive" border="0">
<!--/n_PRINT_IF_NOT_DEFINED SUCC_VER_ID-->
<!--n_PRINT_IF_DEFINED VIG_VER_ID-->
<a href="<!--n_print_procedure GET_VERSION_PARENT->?follow_mode=static&view_mode=versions&ver_id=<!--n_print_property VIG_VER_ID-->&doc_type_id=<!-n_print_property DOC_TYPE_ID-->>&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->" target="_parent">
<img src="../nuoviss/vervig.gif" alt="Versione in vigore" border="0"></A>
<!--/n_PRINT_IF_DEFINED VIG_VER_ID-->
<!--n_PRINT_IF_NOT_DEFINED VIG_VER_ID-->
<img src="../nuoviss/vervigs.gif" alt="Il documento è nella versione in vigore" border="0">
<!--/n_PRINT_IF_NOT_DEFINED VIG_VER_ID-->
<br>
<br>
<table>
<tr>
<td valign="top" width ="10"><center><b>&nbsp;</b></center></td>
<td valign="top" width = "300"><center><b>Versione</b></center></td>
<td valign="top" width = "300"><center><b>Modificata da</b></center></td>
</tr>
<!--n_foreach VERSION-->
<tr>
<td>
<!--n_PRINT_IF_MATCH VER_ID PARENT.VER_ID-->
<img src="../images/usm.gif" alt="versione attualmente visualizzata" border="0">
</td><td>
in vigore dal <!--n_print_property START_VIG_DATE--> <!--n_PRINT_IF_DEFINED END_VIG_DATE-->al
<!--n_print_property END_VIG_DATE--><!--/n_PRINT_IF_DEFINED END_VIG_DATE-->
<!--/n_PRINT_IF_MATCH VER_ID PARENT.VER_ID-->
<!--n_PRINT_IF_DONT_MATCH VER_ID PARENT.VER_ID-->
</td><td>
<a href="<!--n_PRINT_PROCEDURE GET_VERSION_PARENT->?view_mode=versions&follow_mode=static&ver_id=<!--n_print_property VER_ID-->&doc_type_id=<!-n_print_property DOC_TYPE_ID-->" target="_parent">in vigore dal <!--n_print_property START_VIG_DATE--> <!-n_PRINT_IF_DEFINED END_VIG_DATE-->al <!--n_print_property END_VIG_DATE--><!--/n_PRINT_IF_DEFINED
END_VIG_DATE--></a>
<!--/n_PRINT_IF_DONT_MATCH VER_ID PARENT.VER_ID-->
</td>
<td><!--n_PRINT_IF_DEFINED MODIFIER-->
<a href="<!--n_PRINT_PROCEDURE GET_VERSION_PARENT->?view_mode=versions&follow_mode=static&ver_id=<!--n_print_property MOD_VER_ID-->&doc_type_id=<!-n_print_property MOD_DOC_TYPE_ID-->" target="_parent">
<!--n_print_property MODIFIER.TITLE-->
</a>
<!--/n_PRINT_IF_DEFINED MODIFIER--></td>
</tr>
<!--/n_foreach VERSION-->
</table>
<br>
</td></tr>
</table>
<br><br>
<table align="center" border=0 width="95%"><tr><td>
<!--n_PRINT_FILE FILE_NAME-->
</td></tr></table>
<!--/n_PRINT_IF_MATCH VIEW_MODE "VERSIONS"-->
<!--n_PRINT_IF_MATCH VIEW_MODE "DOCUMENT"-->
<table align="center" border=0 width="95%"><tr><td>
<!--n_PRINT_FILE FILE_NAME-->
</td></tr></table>
<!--/n_PRINT_IF_MATCH VIEW_MODE "DOCUMENT"-->
</body>
</html>
Il risultato dell'applicazione del modello al singolo documento può cambiare in
dipendenza della modalità di visualizzazione selezionata. Di seguito sono mostrate
alcune possibili interpretazioni. Il modello non interpretato visualizza una pagina
vuota.
Figura 20: Risultato di una possibile interpretazione del modello per la visualizzazione di un
documento con modalità di visualizzazione "testo".
Figura 21: Risultato di una possibile interpretazione del modello per la visualizzazione di un
documento con modalità di visualizzazione "informazioni".
2.7.3 Il modello per la visualizzazione del risultato della
ricerca
Questo modello definisce l'aspetto grafico della lista dei riferimenti ai documenti
che soddisfano la richiesta effettuata.
<!-#
# Template list.nss
# Copyright Gruppo Norma 1997
#
# porzione di file HTML personalizzabile
#
usato dalla norma_cgi::printList per stampare la lista dei
#
summaries dei documenti che soddisfano la ricerca.
#
# Possono essere inclusi in questo file i seguenti comandi:
#
Specifiche Software del lato server
#
I comandi vanno inclusi tra commenti HTML
-->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>Norma System</title>
</head>
<body>
<center>
<table width="650" style="border: 2px solid" background="../nuoviss/ff1.gif" cellspacing="5"
cellpadding="0">
<tr><td><img src="../nuoviss/modali0.gif"><br><!--n_PRINT_PROPERTY READABLE_QUERY--><br>
</td></tr>
<tr><td><img src="../nuoviss/modali.gif"></td></tr>
<tr><td>
<form
name = "searchForm"
method="GET"
action="<!--n_print_procedure SUBMIT_QUERY-->"
target="_parent"
>
<center>
</td></tr>
<tr valign="middle"><td>
<br>
<p>
&nbsp;&nbsp;Visulizza&nbsp;
<select name="reply_format">
<option value="1" <!--n_print_if_match REPLY_FORMAT "1"--> SELECTED <!--/n_print_if_match
REPLY_FORMAT "1"--> >Lista documenti</option>
<option value="2" <!--n_print_if_match REPLY_FORMAT "2"--> SELECTED <!--/n_print_if_match
REPLY_FORMAT "2"--> >Lista partizioni</option>
<option value="3" <!--n_print_if_match REPLY_FORMAT "3"--> SELECTED <!--/n_print_if_match
REPLY_FORMAT "3"--> >Testo partizioni</option>
</select>
&nbsp;&nbsp;Ordina per&nbsp;
<select name="order_by">
<option value="id1" <!--n_print_if_match ORDER_BY "id1"--> SELECTED <!--/n_print_if_match ORDER_BY
"id1"--> >primo identificativo</option>
<option value="id2" <!--n_print_if_match ORDER_BY "id2"--> SELECTED <!--/n_print_if_match ORDER_BY
"id2"--> >secondo identificativo</option>
<option value="deliver_date" <!--n_print_if_match ORDER_BY deliver_date--> SELECTED <!-/n_print_if_match order_by DELIVER_DATE--> >data di emanazione</option>
<option value="pubblication_date" <!--n_print_if_match ORDER_BY "pubblication_date"--> SELECTED <!-/n_print_if_match ORDER_BY "pubblication_date"--> >data di pubblicazione</option>
<option value="start_vig_date" <!--n_print_if_match ORDER_BY "start_vig_date"--> SELECTED <!-/n_print_if_match ORDER_BY "start_vig_date"--> >data di inizio vigore</option>
<option value="start_eff_date" <!--n_print_if_match ORDER_BY "start_eff_date"--> SELECTED <!-/n_print_if_match ORDER_BY "start_eff_date"--> >data di inizio efficacia</option>
</select>
&nbsp;In ordine&nbsp;
<select name="order_orientation">
<option value="ascendent" <!--n_print_if_match ORDER_ORIENTATION "ascendent"--> SELECTED <!-/n_print_if_match ORDER_ORIENTATION "ascendent"--> >ascendente</option>
<option value="descendent" <!--n_print_if_match ORDER_ORIENTATION "descendent"--> SELECTED <!-/n_print_if_match ORDER_ORIENTATION "descendent"--> >discendente</option>
</select>
</p>
<center>
<input type="hidden" value="<!--n_print_property CGI_QUERY-->" name="CGI_QUERY">
<input type="submit" value="Cambia Modalita di Visualizzazione" name="submit_form">&nbsp;&nbsp;&nbsp;
</form>
</td></tr>
</table>
<br>
<table width="650" cellspacing="5" cellpadding="0">
<tr><td align="left" valign="center">
<font color="blue"><strong><big><img src="../nuoviss/modali3.gif"> <!--n_PRINT_PROPERTY
DOCUMENT_NUMBER--></strong></big></font>
</td></tr>
</table>
<br>
<table align="center" cellpadding="0" cellspacing="0" border="0" width="750">
<tr>
<td colspan="2" ><img src="../nuoviss/listt2.gif" border="0"></td>
</tr>
<!--n_print_if_not_defined DOCUMENT-->
<tr height="77">
<td height="77"><img src="../nuoviss/listt.gif" height="77" border="0"></td>
<td height="77" valign="top">Nessun documento soddisfa la ricerca effettuata<td>
<!--/n_print_if_not_defined DOCUMENT-->
<!--n_FOREACH DOCUMENT-->
<tr height="77">
<td height="77"><img src="../nuoviss/listt.gif" height="77" border="0"></td>
<td height="77" valign="top">
<small>
<!--n_PRINT_IF_DEFINED title-->
<A HREF="<!--n_print_procedure GET_VERSION_PARENT-->?follow_mode=static&doc_type_id=<!-n_PRINT_PROPERTY doc_type_id-->&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->&ver_id=<!-n_PRINT_PROPERTY ver_id-->&doc_id=<!--n_PRINT_PROPERTY doc_id-->" TARGET = "_parent" >
<b><!--n_PRINT_PROPERTY title--></b>
</A>
<!--/n_PRINT_IF_DEFINED title-->
<!--n_PRINT_IF_NOT_DEFINED title-->
<A HREF="<!--n_print_procedure GET_VERSION_PARENT-->?follow_mode=static&doc_type_id=<!-n_PRINT_PROPERTY doc_type_id-->&attach_type_id=<!--n_PRINT_PROPERTY ATTACH_TYPE_ID-->&ver_id=<!-n_PRINT_PROPERTY ver_id-->&doc_id=<!--n_PRINT_PROPERTY doc_id-->" TARGET = "_blank" >
<b>Senza Titolo</b>
</A>
<!--/n_PRINT_IF_NOT_DEFINED title-->
<br>
<!--n_PRINT_PROPERTY doc_type_name-->
<!--n_PRINT_IF_DEFINED deliver_date-->
del <!--n_PRINT_PROPERTY deliver_date-->
<!--/n_PRINT_IF_DEFINED deliver_date-->
<!--n_PRINT_IF_DEFINED id1-->
, <!--n_PRINT_PROPERTY id1_name--> <!--n_PRINT_PROPERTY id1-->
<!--/n_PRINT_IF_DEFINED id1-->
<!--n_PRINT_IF_DEFINED id2-->
, <!--n_id2_PRINT_PROPOERTY name--> <!--n_PRINT_PROPERTY id2-->
<!--/n_PRINT_IF_DEFINED id2-->
<!--n_PRINT_IF_DEFINED start_vig_date-->
<br>
nella versione in vigore dal <!--n_PRINT_PROPERTY start_vig_date-->
<!--/n_PRINT_IF_DEFINED start_vig_date-->
<!--n_PRINT_IF_DEFINED end_vig_date-->
al <!--n_PRINT_PROPERTY end_vig_date-->
<!--/n_PRINT_IF_DEFINED end_vig_date-->
<!--n_PRINT_IF_DEFINED start_eff_date-->
, efficace dal <!--n_PRINT_PROPERTY start_eff_date-->
<!--/n_PRINT_IF_DEFINED start_eff_date-->
<!--n_PRINT_IF_DEFINED end_eff_date-->
al <!--n_PRINT_PROPERTY end_eff_date-->
<!--/n_PRINT_IF_DEFINED end_eff_date-->
</small>
</td>
<td height="77" valign="top" align="right">
<small>
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "\w+"-->
Disponibile in formato:<br>
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "\w+"-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "doc"-->
<A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID "A"->_<!--n_PRINT_PROPERTY ATTACH_TYPE_ID--><!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY
VER_ID-->/document.doc" TARGET = "_blank"><img src="../nuoviss/icoword.gif" border="0"></a> &nbsp; &nbsp;
&nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "doc"-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "pdf"-->
<A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID "A"->_<!--n_PRINT_PROPERTY ATTACH_TYPE_ID--><!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY
VER_ID-->/document.pdf" TARGET = "_blank"><img src="../nuoviss/icopdf.gif" border="0"></a> &nbsp; &nbsp;
&nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "pdf"-->
<!--n_PRINT_IF_MATCH ALTERNATE_FORMATS "gif"-->
<A HREF="../datafile/<!--n_PRINT_PROPERTY DOC_TYPE_ID--><!--n_print_if_match ATTACH_TYPE_ID "A"->_<!--n_PRINT_PROPERTY ATTACH_TYPE_ID--><!--/n_print_if_match ATTACH_TYPE_ID "A"-->/<!--n_PRINT_PROPERTY
VER_ID-->/document.gif" TARGET = "_blank"><img src="../nuoviss/icopdf.gif" border="0"></a> &nbsp; &nbsp;
&nbsp;
<!--/n_PRINT_IF_MATCH ALTERNATE_FORMATS "gif"-->
</small>
</td>
</tr>
<!--/n_FOREACH DOCUMENT-->
<tr>
<td colspan="2"><img src="../nuoviss/listt3.gif" border="0"></td>
</tr>
</table>
</center>
</body>
</html>
Di seguito è mostrata una immagine del modello interpretato.
Specifiche Software del lato server
Figura 22: Risultato di una possibile interpretazione del modello per la lista dei documenti.
3 Il linguaggio di marcatura NML
Il linguaggio NML è il metalinguaggio usato dal sistema norma per la descrizione
dei documenti. I tratti essenziali del linguaggio sono spiegati nel paragrafo 3.3, in
questa appendice verranno esposti dettagli tecnici ed esempi.
3.1 SPECIFICHE DEL LINGUAGGIO
In Tabella 1 sono elencati i tag inseriti sotto forma di commento all’interno del
testo HTML. Essi, identificano semanticamente porzioni di testo, isolando dal
resto il titolo, l’intestazione, il corpo normativo ecc.
Alcuni di questi tag hanno associate delle proprietà, ad esempio nella Tabella 2
mostriamo quelle, particolarmente importanti, del tag Link, che ci permettono di
distinguere, un riferimento modificativo (indicato come <!--n_link RT=MT-->)
da un rinvio informativo (indicato come <!--n_link RT=RI-->).
In Tabella 3 sono infine mostrate le proprietà del documento espresse attraverso il
tag standard HTML “META”.
Specifiche Software del Server
Tag di apertura
<!--n_Int-->
<!--n_Title-->
<!--n_GID-->
<!--n_SID-->
<!--n_DD-->
<!--n_VD-->
<!--n_PD-->
<!--n_Pre-->
<!--n_DT-->
<!--n_DA-->
<!--n_Sum-->
<!--n_Disp-->
<!--n_P1-->
<!--n_P2-->
<!--n_P3-->
<!--n_P4-->
<!--n_P5-->
<!--n_P6-->
<!--n_P7-->
<!--n_P8-->
<!--n_P9-->
<!--n_TP1-->
<!--n_TP2-->
<!--n_TP3-->
<!--n_TP4-->
<!--n_TP5-->
<!--n_TP6-->
<!--n_TP7-->
<!--n_TP8-->
<!--n_TP9-->
<!--n_Link-->
<!--n_Sub-->
Tag di chiusura
<!--/n_Int-->
<!--/n_Title-->
<!--/n_GI-->
<!--/n_SI-->
<!--/n_DD-->
<!--/n_VD-->
<!--/n_PD-->
<!--/n_Pre-->
<!--/n_DT-->
<!--/n_DA-->
<!--/n_Sum-->
<!--/n_Disp-->
<!--/n_P1-->
<!--/n_P2-->
<!--/n_P3-->
<!--/n_P4-->
<!--/n_P5-->
<!--/n_P6-->
<!--/n_P7-->
<!--/n_P8-->
<!--/n_P9-->
<!--/n_TP1-->
<!--/n_TP2-->
<!--/n_TP3-->
<!--/n_TP4-->
<!--/n_TP5-->
<!--/n_TP6-->
<!--/n_TP7-->
<!--/n_TP8-->
<!--/n_TP9-->
<!--/n_Link-->
<!--/n_Sub-->
Descrizione
Intestazione
Titolo del documento
Identificativo generale
Identificativo specifico
Data di Emissione
Data di vigore
Data di pubblicazione
Preambolo
Tipo di documento
Autorità emanante
Sommario
Dispositivo
Partizione di livello 1
Partizione di livello 2
Partizione di livello 3
Partizione di livello 4
Partizione di livello 5
Partizione di livello 6
Partizione di livello 7
Partizione di livello 8
Partizione di livello 9
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Titolo partizione di livello
Citazione
Sottoscrizione
1
2
3
4
5
6
7
8
9
Tabella 1: Tag inseriti come commento.
Proprietà
LTID
Valori possibili
Stringa, possibili valori
attualmente previsti:
0_0_0, non classificato
0_0_1, rinvio informativo
dinamico
0_0_2, rinvio informativo
statico
0_1_0, deroga
0_2_0, sospensione
0_3_0, modificazione
interpretativa
0_4_0, proroga
0_5_0, sospensione
1_0_0, abrogazione totale
2_0_0, abrogazione atomica
3_0_0, abrogazione parziale
4_0_0, integrazione
5_0_0, sostituzione
6_0_0, integrazione atomica
7_0_0, sostituzione atomica
8_0_0, rifacimento
AA, atto in allegato
API, atto parte integrante
4_4_0, integrazione con
proroga
Descrizione
Tipo di riferimento
DID
VID
DT
GID
SID
DD
PID
VER
Numero
Numero
Numero
Numero
Numero
Data
Numero
True, False
ACTIVE
True, False
Identificativo Documento
Identificativo versione
Identificativo tipo di documento
Identificativo Generale del documento
Identificativo Specifico del documento
Data di emanazione
Identificativo partizione
Indica se e' stata verificata la presenza
del documento di arrivo del riferimento
Indica se il riferimento è da
considerarsi attivo o meno. Ad esempio
sono non attivi i riferimenti all'interno
delle menzioni.
Tabella 2: Proprietà del tag Link.
Indice Analitico
Nome
n_DID
n_VID
Valore
Numero
Numero
n_DTID
Numero
n_DD
n_PD
n_GID
n_SID
Data
Data
Numero
Numero
n_VD
n_KW
Data
Stringa
Descrizione
Identificativo del documento nel DB
Identificativo della versione del
documento nel DB
Identificativo del tipo di documento nel
DB
Data di emanazione del documento
Data di pubblicazione del documento
Identificativo generale del documento
Identificativo specifico del documento nel
DB
Data di inizio vigore del documento
Parole chiave del documento
Tabella 3: Proprietà del documento inserite con il tag meta.
3.2 ESEMPI DI DESCRIZIONE DI ATTI TRAMITE
NML
Nel seguente esempio è mostrato una delibera del Consiglio del Comune di
Bologna, nella quale sono stati inseriti marcatori secondo la grammatica NML al
fine aggiungere informazioni al documento. I marcatori sono stati evidenziati in
grassetto nel testo.
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=windows-1252">
<META NAME="Generator" CONTENT="Microsoft Word 97">
<TITLE>Deliberazione del Consiglio comunale 19 dicembre 1984, o</TITLE>
<META NAME="Doc_type_id" CONTENT="49">
<META NAME="n_Doc_type_id" CONTENT="49">
<META NAME="n_Start_Vig_Date" CONTENT="6 maggio 1985">
<META NAME="n_Deliver_Date" CONTENT="19 dicembre 1984">
<META NAME="n_ID1" CONTENT="577">
<META NAME="n_ID2" CONTENT="50088/84">
<META NAME="n_Title" CONTENT="Applicazione dell'art. 24 del DPR. 347/83, relativo al regolamento dei
concorsi">
<META NAME="n_Start_Eff_Date" CONTENT="6 maggio 1985">
<META NAME="n_Doc_Id" CONTENT="2">
<META NAME="n_Ver_Id" CONTENT="2">
<META NAME="Template" CONTENT="C:\programmi\microsoft office\modelli\Norma Pregresso\Delibera del
Consiglio.dot">
</HEAD>
<BODY>
<P ALIGN="JUSTIFY"><A NAME="Intestazione"> <!--n_Link LTID="AA" DTID="50" VID="3" DID="4" VER="YES" -->
<FONT SIZE=2>Deliberazione del Consiglio comunale <A NAME="Date_deliver">19 dicembre 1984</A>, o.d.g. <A
NAME="norma_id1">577</A>, p.g.<B> <A NAME="norma_id2"></B>50088/84</A>.</P>
<P ALIGN="JUSTIFY"> </P>
<B><P ALIGN="JUSTIFY">Oggetto: </P>
</B><P ALIGN="JUSTIFY"><A NAME="Doc_title"> <!--n_title--> Applicazione dell'art. 24 del DPR. 347/83,
relativo al regolamento dei concorsi <!--n_title--> </A></P>
<P ALIGN="JUSTIFY"></A> </P>
<P ALIGN="JUSTIFY"> </P>
<P ALIGN="JUSTIFY">La Giunta propone al Consiglio il seguente partito d&igrave; deliberazione</P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY"> <A NAME="AutorityFormal">IL CONSIGLIO</A></P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY"> <!--n_pre--> <A NAME="Preambolo">Premesso che con deliberazioni consiliari 25.5.84 n.
242 dell'O.d.G. e del 5.12.84 n. 468 dell'O.d.G., si &egrave; proceduto all'applicazione dell'art. 40 del
D.P.R. 347/83 relativo all'inquadramento;</P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY">che con successiva deliberazione consiliare P.G.N. 50052/84 si &egrave; dato luogo alla
modificazione della pianta organica degli uffici e dei servizi comunali, tenendo anche conto degli effetti
che il precisato inquadramento ha prodotto in relazione ai posti di pianta;</P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY">che di conseguenza, questa Amministrazione si trova oggi in condizione di dare
applicazione al disposto di cui all'art. 24 del D.P.R. 347/83, relativo alla determinazione delle norme di
accesso ai singoli profili professionali;</P>
Specifiche Software del Server
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY">dato atto che il presente provvedimento &egrave; stato portato a conoscenza delle
OO.SS. aziendali</A> <!--n_pre--> </P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY"> <A NAME="Emanazione">d e l i b e r a</A></P>
<P ALIGN="JUSTIFY"></P>
<P><A NAME="p_1_"> <!--n_Disp--> <!--nP1--> &nbsp;1) di approvare, in applicazione dell'art. 40 del D.P.R.
347/83, il regolamento dei concorsi nel testo allegato al presente ravvedimento di cui costituisce parte
integrante e sostanziale;</A> </P> <!--/nP1-->
<P><A NAME="p_2_"> <!--nP1--> &nbsp;2) di dare atto che detto regolamento dei concorsi &egrave; formato da
un articolato comprendente 46 articoli e dagli allegati A), B), C) e D);</A> <!--/nP1--> </P>
<P><A NAME="p_3_"> <!--nP1--> &nbsp;3) di dare infine atto che tale regolamento dei concorsi costituisce
altres&igrave; parte del Regolamento generale del personale degli uffici e dei servizi comunali e che
pertanto, sostituisce tutti gli articoli del Capo II del Titolo I (artt. dal 20 al 34) nonch&eacute; gli
artt. 14-15-16, gli artt. 35 e 36 e gli artt. 42,43,44 e 45 di detto Regolamento Generale.</A> <!--/nP1-->
</P>
<P ALIGN="JUSTIFY"></P>
<P ALIGN="JUSTIFY">&nbsp;</P>
<B><P ALIGN="CENTER">&nbsp;</P>
<P> <!--/n_Disp--> </P></B></FONT></BODY>
</HTML>
