Relazione Agic

682 views

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
682
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
5
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Relazione Agic

  1. 1. UNIVERSITÀ DEGLI STUDI DI TRIESTE FACOLTÀ DI INGEGNERIA Corso di Laurea in Ingegneria Informatica Sviluppo di un software per l’importazione e gestione di dati curricolari Laureanda: Relatore: Maja Agic Prof. Maurizio Fermeglia ANNO ACCADEMICO 2007 - 2008
  2. 2. INDICE 1. INTRODUZIONE 2 2. TECNOLOGIE UTILIZZATE ED ANALISI 4 2.1 Tecnologie utilizzate 4 2.1.1 SQL Server Management Studio 2005 4 2.1.2 Linguaggio SQL 5 2.1.3 Microsoft Visual Studio 2005 5 2.1.4 Linguaggio C# 6 2.1.5 Formato RIS 7 2.2 Analisi 8 2.2.1 Analisi del database 8 2.2.2 Analisi del programma applicativo 9 3. REALIZZAZIONE E TEST 11 3.1 Realizzazione 11 3.1.1 Implementazione 11 3.1.1.1 Implementazione database 11 3.1.1.2 Implementazione programma applicativo 20 3.1.2 Interfaccia 35 3.1.2.1 Installazione e configurazione 35 3.1.2.2 Esempio d’uso 39 3.2 Test 47 4. CONCLUSIONI 48 4.1 Obiettivi 48 4.2 Lavoro svolto 48 4.3 Stato attuale 48 4.4 Considerazioni personali 50 5. BIBLIOGRAFIA 51 1
  3. 3. 1 INTRODUZIONE Un software di gestione dei dati è uno strumento che ha lo scopo di semplificare l’interazione tra l’utente e le informazioni contenute all’interno di un database. Il modo in cui avviene la relativa gestione e le operazioni permesse sulla base dati dipendono dai requisiti espressi da parte del committente. In questo testo viene descritta un’applicazione che fornisce all’utente la possibilità di importare ed amministrare i riferimenti bibliografici legati alle pubblicazioni professionali del personale appartenente al Dipartimento di Ingegneria Chimica, dell'Ambiente e delle Materie Prime (DICAMP) dell’Università degli Studi di Trieste. Inoltre, sarà illustrato il database sottostante. Il sistema sviluppato (il database e l’applicazione) è stato creato per esigenze di raccolta sistematica dei riferimenti alle pubblicazioni appartenenti alle suddette persone ed alla loro raggiungibilità dal sito internet del DICAMP, più precisamente http://www.dicamp.units.it/Research/Publications/default.aspx . Questo sito dispone già di una raccolta dei riferimenti alle pubblicazioni, il che vuole dire che il sistema qui descritto andrà a sostituire la vecchia modalità di visualizzazione. La vecchia raccolta dei riferimenti permetteva solamente la visualizzazione dei dati relativi alle pubblicazioni che si trovano in un file statico HTML. Con il nuovo sistema i dati da visualizzare andranno prelevati dal database sottostante, ed inoltre ci sarà la possibilità di filtrare i riferimenti da visualizzare per autore, e i dati potranno essere importati nel database da file RIS. I dati sul sito saranno visualizzati in maniera simile a quella delle pubblicazioni sul sito http://www.mose.units.it/ . Tutto questo è stato realizzato utilizzando fondamentalmente due ambienti di sviluppo. “SQL Server 2005” per il database ed il “Microsoft Visual Studio 2005” (che incorpora il .NET Framework 2.0) per l’applicazione. Tutti i moduli che compongono l’applicazione sono stati scritti in linguaggio C#, uno dei linguaggi con il quale è possibile programmare in “MS Visual Studio 2005”. Lo sviluppo di questo sistema non sarebbe stato possibile senza uno studio preliminare sia sulle tecnologie utilizzate, sia sul formato dati da importare. Una volta completata la parte preliminare si è iniziato con l’analisi degli obiettivi del committente, la quale ha avuto come risultato la definizione degli requisiti che il sistema avrebbe dovuto soddisfare. Arrivati al punto dove gli requisiti sono ben inquadrati si è potuto procedere con la progettazione, seguita dalla fase di realizzazione. Quando la parte creativa del lavoro è stata terminata ha avuto l’inizio la fase di test. L’oggetto di questo testo sarà descrivere in dettaglio ognuna di queste fasi che hanno portato al risultato finale. Intanto segue una breve introduzione alle stesse. 2
  4. 4. Le tecnologie studiate: • SQL Server Management Studio 2005 • Linguaggio SQL • Microsoft Visual Studio 2005 • Linguaggio C# • Formato RIS Analisi: L’analisi dei bisogni ed obiettivi consisteva fondamentalmente nell’apprendere le esigenze che progetto da sviluppare dovrà soddisfare, dalle quali è stato possibile determinare quali dati dovrà contenere il database, le prime grezze idee sulla visualizzazione dei dati nell’applicazione, nonché le operazioni da permettere all’utente. Realizzazione: Questa fase si occupa della progettazione e sviluppo vero e proprio del database, e dei moduli del programma applicativo. La prima parte di realizzazione descritta, viene chiamata “implementazione”. Qui si è occupati del disegno logico delle singole tabelle del database, delle loro relazioni e vicoli. Fatto ciò, ci siamo occupati anche del descrivere il funzionamento dei vari “form” che saranno la parte interattiva del sistema. Questa parte contiene anche porzioni di codice dei metodi ritenuti più importanti. Infine abbiamo riportato un diagramma di flusso finale di tutto il programma applicativo. La seconda parte di realizzazione descrive l’interfacciamento dell’utente col programma. In questa sezione viene spiegata la modalità di installazione e configurazione del sistema, nonché riportato un esempio di utilizzo del sistema con le immagini delle schermate e le spiegazioni che le accompagnano. Test: I test funzionali sono stati eseguiti sia dopo la codifica di ogni modulo, per accertarsi che il modulo esegua correttamente la propria funzione, sia dopo l’unione dei moduli. 3
  5. 5. 2 TECNOLOGIE UTILIZZATE ED ANALISI 2.1 Tecnologie utilizzate 2.1.1 SQL Server Management Studio 2005 È un ambiente integrato per l’accesso, configurazione, gestione e sviluppo di tutti i componenti di SQL Server. Esso unisce un vasto gruppo di tool grafici ed una serie di rich script editor con lo scopo di fornire l’accesso a SQL Server agli sviluppatori ed amministratori di tutti i livelli di abilità. SQL Server Management Studio unisce le funzionalità di Enterprise Manager, Query Analyzer e Analysis Manager inclusi nelle precedenti versioni di SQL Server, in un unico ambiente. Inoltre, SQL Server Management Studio funziona con tutti i componenti di SQL Server come Reporting Services, Integration Services e SQL Server Compact 3,5 SP1. In questo modo gli sviluppatori possono approfittare delle esperienze familiari, e gli amministratori di database hanno a loro disposizione un utility unico e completo che unisce gli tools grafici di facile impiego con le capacità di rich scripting. 4
  6. 6. 2.1.2 Linguaggio SQL Il linguaggio SQL (Structured Query Language) è un linguaggio di tipo non procedurale che consente di operare sui dati di un database tramite frasi che non fanno uso di simboli matematici ed algebrici, ma solo di parole chiave prese dal linguaggio corrente. Questo, insieme alla sintassi che riprende forme usuali, fa sì che le frasi abbiano una struttura lineare ed espressiva. In particolare il termine Structured (strutturato) di SQL è riferito al fatto che si può inserire un'interrogazione all'interno di un'altra interrogazione; più in generale si parla di query innestate. SQL è il linguaggio per la definizione dei dati. Le tre istruzioni che permettono la definizione dei dati: CREATE, ALTER, DROP. Esso è pure un linguaggio per la manipolazione dei dati, la quale è possibile attraverso le quattro istruzioni: SELECT (segue esempio), INSERT, UPDATE, DELETE. Ed infine, è il linguaggio di controllo dei dati: GRANT, REVOKE. Esempio della istruzione select: L'istruzione SELECT serve per estrarre informazioni dal database. La sua sintassi è la seguente: SELECT [ ALL | DISTINCT ] lista_scelte FROM lista_tabelle [WHERE condizioni] [GROUP BY lista_attributi ] [HAVING condizioni ] [ ORDER BY lista_attributi ] 2.1.3 Microsoft Visual Studio 2005 È un ambiente di sviluppo integrato (Integrated Development Environment o IDE) sviluppato da Microsoft, che supporta diversi tipi di linguaggio, quali C++, C#, J#, Visual Basic .Net e ASP .Net, e che permette la realizzazione di applicazioni, siti web, applicazioni web e servizi web. È inoltre un RAD (Rapid Application Development), ovvero una applicazione atta ad aumentare la produttività aiutando il programmatore con mezzi come l'IntelliSense o un designer visuale dei form. Visual Studio .NET è inoltre multipiattaforma: con esso è possibile realizzare programmi per server, workstation, pocket PC, smartphone e, naturalmente, per i browser. 5
  7. 7. 2.1.4 Linguaggio C# Il C# è un linguaggio di programmazione orientato ad oggetti, sviluppato da Microsoft all'interno dell'iniziativa .NET, e successivamente approvato come standard ECMA. La sintassi del C# prende spunto da quella del Delphi (hanno il medesimo autore), del C++, da quella di Java ed a Visual Basic per gli strumenti di programmazione visuale e per la sua semplicità (meno simbolismo rispetto a C++, meno elementi decorativi rispetto a Java). Esempio 1 - stampa su schermo “Hello World” using System; class HelloWorldApp { public static void Main() { Console.WriteLine(quot;Hello Worldquot;); } } 6
  8. 8. Esempio 2 - definisce la classe Persona using System; namespace Program { class Persona { public string Nome { get { return mNome; } set { mNome = value; } } private string mNome; } } 2.1.5 Formato RIS Il formato RIS è un “tag format” standardizzato, sviluppato da “Research Information Systems, Incorporated” per permettere lo scambio di dati tra i programmi di citazioni. Il formato di file -- due lettere, due spazi ed il trattino -- è il formato “taggato” per esprimere i riferimenti bibliografici. È supportato da vari gestori di riferimenti. Tante biblioteche digitali, come IEEE Xplore, Scopus, ACM Portal, e SpringerLink sono in grado di esportare i propri riferimenti in questo formato. Le spiegazioni dei tag: TY - Type of reference (must be the first tag) J2 - Periodical name - User abbreviation 2 ID - Reference ID (not imported to reference VL - Volume number software) IS - Issue number T1 - Primary title T2 - Title secondary TI - Book title CY - City of Publication CT - Title of unpublished reference PB - Publisher A1 - Primary author U1 - User definable 1 A2 - Secondary author (each name on separate line) U5 - User definable 5 AU - Author (syntax. Last name, First name, Suffix) T3 - Title series Y1 - Primary date N2 - Abstract PY - Publication year (YYYY/MM/DD) SN - ISSN/ISBN (e.g. ISSN XXXX-XXXX) N1 - Notes AV - Availability KW - Keywords (each keyword must be on separate M1 - Misc. 1 line preceded KW -) M3 - Misc. 3 RP - Reprint status (IN FILE, NOT IN FILE, ON AD - Address REQUEST (MM/DD/YY)) UR - Web/URL SP - Start page number L1 - Link to PDF EP - Ending page number L2 - Link to Full-text JF - Periodical full name L3 - Related records JO - Periodical standard abbreviation L4 - Images JA - Periodical in which article was published ER - End of Reference (must be the last tag) J1 - Periodical name - User abbreviation 1 7
  9. 9. Esempio di come quot;Claude E. Shannon. A mathematical theory of communication. Bell System Technical Journal, 27:379–423, July 1948quot; sarebbe espresso in questo formato: TY - JOUR AU - Shannon, Claude E. PY - 1948/07// TI - A Mathematical Theory of Communication JO - Bell System Technical Journal SP - 379 EP - 423 VL - 27 ER - 2.2 Analisi L’analisi parte dai bisogni del committente. Questi dovranno essere soddisfatti dal sistema che andiamo a sviluppare. La parte di analisi si conclude con la definizione di requisiti. In questo paragrafo verrà illustrato il procedimento di analisi seguito, sia per il database, sia per quanto riguarda il programma applicativo che andrà ad utilizzare i dati contenuti nel database. 2.2.1 Analisi del database • Descrizione degli obiettivi Il database deve contenere le informazioni riguardanti il personale del DICAMP ed i riferimenti bibliografici degli ultimi. Per quanto riguarda il personale, a parte il nome e cognome di ogni membro, il database deve tenere traccia anche dello stato (attivo/non attivo) dei membri, username, appartenenza a qualche gruppo interno al dipartimento, ed inoltre deve fornire l’informazione se la determinata persona è un amministratore del database. L’unico dato tra questo che può mancare è il username. Prendendo in considerazione invece gli riferimenti bibliografici, ci interessa memorizzare il tipo di riferimento, il titolo, gli autori, l’anno di pubblicazione, il nome ed il volume della rivista dov’è uscita la pubblicazione, la pagina iniziale e finale. Inoltre, c’è bisogno di un campo che formatterà i seguenti dati nel seguente modo → volume:pagina iniziale - pagina finale (anno di pubblicazione). Ogni riferimento deve essere associato ad uno o più membri del personale. 8
  10. 10. Ogni persona deve appartenere ad un gruppo. Una persona non può appartenere a più di un gruppo. Esiste anche il gruppo chiamato “nessuno”, del quale fanno parte solo le persone che non appartengono a nessun altro gruppo. Il dato, “tipo di riferimento”, è un’abbreviazione che deve avere una spiegazione comprensibile per un utente non esperto di abbreviazioni bibliografiche del formato RIS. Ogni pubblicazione deve avere un tipo definito, e non ne può avere più di uno. • Glossario Per evitare possibili ambiguità sui termini viene creato il glossario. Esso spiega tutti i principali termini utilizzati nella descrizione degli obiettivi. RIFERIMENTO Una collezione di dati che descrivono una pubblicazione PERSONA Individuo appartenete al personale del DICAMP ed autore di almeno una pubblicazione, oppure l’amministratore GRUPPO Un insieme di persone. È dotato di un nome. AUTORI Tutti gli autori della pubblicazione, sia le persone del DICAMP, sia autori esterni. È una stringa concatenata con il simbolo “;” RIVISTA Il giornale nel quale è stato pubblicato l’articolo ANNO PUBBLICAZIONE L’anno dell’uscita della pubblicazione alla quale ci si riferisce PAGINA INIZIALE Il numero di pagina dove si trova l’inizio dell’articolo nella rivista PAGINA FINALE Il numero di pagina dove si trova la fine dell’articolo nella rivista 2.2.2 Analisi del programma applicativo • Descrizione degli obiettivi Il programma applicativo ha lo scopo di permettere all’utente di interfacciarsi col database in un modo semplice ed intuitivo. Il suo compito è: - la importazione dei riferimenti nel database a partire da un file in formato RIS - permettere all’utente di associare il riferimento alle persone 9
  11. 11. - permettere all’utente di modificare tutti i dati del riferimento, tranne il tipo di pubblicazione, prima del salvataggio dello stesso nel database - la visualizzazione di tutti i riferimenti associati ad una determinata persona, con la possibilità di: - cancellazione di ogni singolo riferimento - modifica del riferimento selezionato - associazione dissociazione delle persone ad da un determinato riferimento • Bozza del diagramma di flusso dell’applicazione Ora siamo in grado di costruire una prima bozza del diagramma di flusso che esprime in modo sintetico i requisiti che l’applicativo dovrà soddisfare. INIZIO AMMINISTRAZIONE IMPORTAZIONE VISUALIZZAZIONE DI TUTTI I RIFERIMENTI DELLA PERSONA MODIFICHE PRIMA DEL SALVATAGGIO MODIFICHE SINGOLO RIFERIMENTO FINE FINE 10
  12. 12. 3 REALIZZAZIONE E TEST 3.1 Realizzazione La parte di realizzazione è formata da due parti che saranno spiegate in seguito. La parte di implementazione e la parte di interfaccia. 3.1.1 Implementazione Questa parte spiega come è stato progettato il database e l’applicativo. Per progettare un database, partendo dai requisiti determinati al punto precedente si procede con la progettazione concettuale, la quale ha come risultato il diagramma delle entità e relazioni → Entity - Relationship(E-R) Diagram. L’implementazione dell’applicativo invece determina i contenuti dei singoli moduli che costituiscono il programma finale, e la modalità di funzionamento del tutto. 3.1.1.1 Implementazione database Le caratteristiche del database, determinate a partire dai requisiti, che servono al disegno del diagramma E-R: • Determinazione delle entità ENTITA’ Personale Gruppo Tipo Riferimento Riferimento 11
  13. 13. • Analisi delle entità → Elenco attributi PERSONALE GRUPPO RIFERIMENTO ID_Gruppo ID_Riferimento ID_Personale Nome Titolo Cognome Note Autori Nome Anno_Pubblicazione Attivo Pag_iniz Username Pag_fin Amministratore TIPO RIFERIMENTO Rivista Volume ID_TipoRif Riferimento_veloce RisTAG TipoPubblicazione → Descrizione degli attributi TIPO RIFERIMENTO ATTRIBUTO DESCRIZIONE Numero che identifica univocamente un tipo di riferimento ID_TipoRif Il tag utilizzato nel file RIS per identificare un tipo di riferimento RisTAG La spiegazione testuale del RisTAG TipoPubblicazione 12
  14. 14. GRUPPO ATTRIBUTO DESCRIZIONE Numero che identifica univocamente un gruppo ID_Gruppo Il nome del gruppo appartenente al DICAMP Nome Ulteriori informazioni Note RIFERIMENTO ATTRIBUTO DESCRIZIONE Numero che identifica univocamente il riferimento ID_Riferimento Il titolo del riferimento Titolo Tutti gli autori della pubblicazione, sia le persone del DICAMP, sia autori esterni Autori L’anno nel quale è uscita la pubblicazione alla quale il riferimento si riferisce Anno_Pubblicazione Il numero di pagina dove si trova l’inizio dell’articolo nella rivista Pag_iniz Il numero di pagina dove si trova la fine dell’articolo nella rivista Pag_fin Il nome del giornale nel quale è stato pubblicato l’articolo Rivista Il volume della rivista dove è stato pubblicato l’articolo Volume volume:pagina iniziale - pagina finale (anno di pubblicazione) Riferimento_veloce 13
  15. 15. PERSONALE ATTRIBUTO DESCRIZIONE Numero che identifica univocamente una persona ID_Personale Il cognome della persona Cognome Il nome della persona Nome Lo stato corrente della persona Attivo Il codice della persona Username La persona che amministra il database Amministratore → Vincoli sugli attributi TIPO RIFERIMENTO ATTRIBUTO CHIAVE TIPO VALORE NULL Chiave Primaria (PK) Integer Non permesso ID_TipoRif No String Permesso RisTAG No String Permesso TipoPubblicazione 14
  16. 16. GRUPPO ATTRIBUTO CHIAVE TIPO VALORE NULL Chiave Primaria (PK) Integer Non permesso ID_Gruppo No String Permesso Nome No String Permesso Note RIFERIMENTO ATTRIBUTO CHIAVE TIPO VALORE NULL Chiave Primaria (PK) Integer Non permesso ID_Riferimento Parte di una Chiave Unica (IX) String Permesso Titolo No String Permesso Autori No Integer Permesso Anno_Pubblicazione No Integer Permesso Pag_iniz No Integer Permesso Pag_fin Parte di una Chiave Unica (IX) String Permesso Rivista Parte di una Chiave Unica (IX) String Permesso Volume Parte di una Chiave Unica (IX) String Permesso Riferimento_veloce 15
  17. 17. PERSONALE ATTRIBUTO CHIAVE TIPO VALORE NULL Chiave Primaria (PK) Integer Non permesso ID_Personale No String Non permesso Cognome No String Non permesso Nome No Integer Non permesso Attivo No String Permesso Username No Bool Non permesso Amministratore • Determinazione delle relazioni RIFERIMENTO PERSONALE GRUPPO TIPO RIFERIMENTO 16
  18. 18. • Analisi delle relazioni → Cardinalità delle relazioni ENTITA’ ENTITA’ CARDINALITA’ Riferimento Personale Molti a Molti Personale Gruppo Uno a Molti Riferimento Tipo Riferimento Uno a Molti 17
  19. 19. • Diagramma E-R ID_Riferimento Attivo Username Rivista Pag_iniz Volume Pag_fin Cognome Nome PERSONALE 0-N 0-N RIFERIMENTO PERSONALE AUTORE Anno_Pubblicazione 0-1 1-1 Titolo Autori Riferimento_veloce ID_Personale Amministratore RAGGRUPPA- TIPIZZAZIONE MENTO ID_Gruppo ID_TipoRif TipoPubblicazione Nome 0-N 0-N TIPO GRUPPO RisTAG Note RIFERIMENTO 18
  20. 20. • Schema fisico Lo schema fisico viene creato traducendo il diagramma E-R. Le entità diventano tabelle del database fisico. Qui abbiamo una tabella in più, ed è quella che rappresenta la relazione “Personale Autore”, che lega la tabella “Riferimento” con la tabella “Personale”. È stata chiamata “tblRif_Pers”. Infine si aggiungono tutte le relazioni tra le tabelle, attraverso la definizione delle chiavi primarie e chiavi esterne. Lo schema fisico del nostro database viene illustrato in seguito. 19
  21. 21. 3.1.1.2 Implementazione programma applicativo Il programma applicativo è suddiviso in moduli. Ogni modulo rappresenta un form. Partendo dalla bozza del diagramma di flusso, determinato alla conclusione della parte di analisi, la si elabora ulteriormente, affinché tutti i moduli non sono completamente definiti. Qui verrà descritto il funzionamento interno dei moduli principali del programma ed il loro funzionamento intrinseco, mentre nella parte di interfaccia, che verrà in seguito, ci focalizzeremo sul funzionamento dal punto di vista dall’utente. I moduli principali sono: • PRINCIPALE • IMPORTAZIONE • RIFERIMENTI • DETTAGLI • AMMINISTRAZIONE • MODIFICA_PUBBLICAZIONE PRINCIPALE Il modulo chiamato “Principale” è il modulo radice. Contiene due bottoni, i quali sono collegati con i prossimi due moduli principali, che biforcano il flusso del programma. Sostanzialmente, premendo uno dei due bottoni, si crea l’oggetto della classe che definisce il form scelto e lo si visualizza su schermo. Esempio che mostra la porzione di codice del funzionamento di uno dei due bottoni: private void button3_Click(object sender, EventArgs e) // bottone ”Importa” { // cliccato Importazione imp = new Importazione(); imp.Show(); } 20
  22. 22. IMPORTAZIONE Questo modulo ci da la possibilità di cercare il file RIS nel PC, e di richiamare il prossimo modulo principale, quello di nome “Riferimenti”. Quindi ha il bottone di nome “Sfoglia”, che crea un oggetto della classe “System.Windows.Forms.OpenFileDialog”, setta l’estensione predefinita a “.ris”, ed il path iniziale diventa quello del Desktop del Localhost. Quindi i settings del file dialog sono: fd.DefaultExt = quot;risquot;; // fd è il riferimento all’oggetto della classe OpenFileDialog fd.FileName = quot;*.risquot;; fd.Filter = quot;quot;RisFiles|*.risquot;quot;; fd.InitialDirectory=System.Environment.GetFolderPath(Environment.SpecialFolder.Desktop); fd.Title = quot;Cercaquot;; fd.FileOk += new System.ComponentModel.CancelEventHandler(this.openFileDialog1_FileOk); Il nome del file RIS selezionato viene inserito nella textbox del form “Importazione”. Premendo il bottone “Apri”, viene aperto in lettura il file RIS del nome specificato nella textbox, e viene creato l’oggetto “Riferimenti” ed invocato il metodo “mostra_Riferimenti”, che mostra il form dove in automatico vengono inseriti tutti i riferimenti alle pubblicazioni che il file RIS contiene. Nel caso l’apertura del file non termina con successo, viene gestita l’eccezione visualizzando un form di errore su schermo che informa l’utente dell’apertura non avvenuta e gli suggerisce di ricontrollare il nome del file. RIFERIMENTI Nella listbox del form riferimenti vengono visualizzati tutti i riferimenti che contiene il file RIS dal quale siamo andati a leggere. Una riga per ogni riferimento. Non vengono visualizzati tutti i dati che lo riguardano, ma solamente il titolo, rivista ed autori. Questa visualizzazione viene ottenuta leggendo il file RIS. Visto che un file RIS di solito contiene più di un riferimento, ci si ferma su ogni tag TY, il quale identifica il tipo del riferimento, ed è sempre il primo tag della pubblicazione. Fermati qui, viene creata una stringa concatenata, man mano che si continua a leggere riga per riga il file, concatenando solamente il testo che segue i tag T1 o TI per il titolo, A1, A2, AU per gli autori, JF, JO, JA per il nome della rivista. Nel caso dell’esistenza di più tag per il medesimo concetto (ad es. esiste sia T1 che TI ), viene concatenato solamente il testo che segue il primo tag incontrato. 21
  23. 23. Segue il codice del metodo “mostra_Riferimenti”che effettua quanto appena detto: public void mostra_Riferimenti(Stream st, int x) { TextReader tr; try { tr = new StreamReader(st); // apre lo stream di lettura dal file string conc = quot; *quot;; string prima; int i = 0; int j = 0; int k = 0; prima = tr.ReadLine(); while (prima != null) // ciclo di concatenazione della stringa { // man mano che il file viene letto if (prima.StartsWith(quot;TYquot;)) { i = 0; j = 0; k = k + 1; if (k > 1 && k != (x + 2)) this.listBox_mia.Items.Add(conc); conc = quot; *quot;; } if (prima.StartsWith(quot;T1quot;) || prima.StartsWith(quot;TIquot;)) { i = i + 1; if (i == 1) conc = conc + prima.Substring(6) + quot;** quot;; } if (prima.StartsWith(quot;A1quot;) || prima.StartsWith(quot;A2quot;) || prima.StartsWith(quot;AUquot;)) conc = conc + prima.Substring(6) + quot; | quot;; if (prima.StartsWith(quot;JFquot;) || prima.StartsWith(quot;JOquot;) || prima.StartsWith(quot;JAquot;)) { j = j + 1; if (j == 1) conc = conc + quot;(quot; + prima.Substring(6) + quot;);quot;; } prima = tr.ReadLine(); } this.listBox_mia.Items.Add(conc); tr.Close(); this.Show(); } // continua sulla pagina successiva 22
  24. 24. catch (Exception e) { Errore_File ef = new Errore_File(); // mostra il messaggio d’errore ef.Show(); } } Facendo doppio click sul riferimento che si desidera importare, viene creato l’oggetto della classe “Dettagli” e viene invocato il metodo “trova_Record” della medesima classe. Questo metodo va a leggere nuovamente il file RIS in ricerca del riferimento desiderato e visualizza tutti i dati del riferimento. DETTAGLI Questo modulo crea il form dove vengono visualizzati tutti i dati che riguardano il riferimento desiderato. Essi sono mostrati in formato stringa nei rispettivi testbox, unicamente identificati da una label affianco. Tutti i textbox permettono la modifica diretta del dato(stringa), tranne quello con la label “Tipo Riferimento”, visto che si è ritenuto non opportuno dare la possibilità di modificare questo campo all’utente, in quanto non ce ne bisogno, e potrebbe portare solamente danni, causa errori umani. Il codice del metodo “trova_Record” che ha il compito di riempire le textbox a partire dal file RIS: public void trova_Record(int x, Stream st,int ind) { num_riga = ind; TextReader tr = new StreamReader(st); int count = 0; int i = 0; int j = 0; int k = 0; x = x + 1; string autori = quot;quot;; string line; while (count < x) // il ciclo che legge il file finché non incontra il record { // desiderato. Quando lo trova inserisce il Tipo di line = tr.ReadLine(); // riferimento nella textbox corrispondente // continua sulla pagina successiva 23
  25. 25. if (line.StartsWith(quot;TYquot;)) { count = count + 1; textBox1.Text = line.Substring(6); } } do // il ciclo che inserisce tutti i dati del riferimento, tranne il tipo di riferimento { // nelle textbox corrispondenti line = tr.ReadLine(); if (line == null) break; if (line.StartsWith(quot;T1quot;) || line.StartsWith(quot;TIquot;)) { i = i + 1; if (i == 1) textBox2.Text = line.Substring(6); } if (line.StartsWith(quot;A1quot;) || line.StartsWith(quot;A2quot;) || line.StartsWith(quot;AUquot;)) autori = autori + line.Substring(6) + quot;;quot;; if (line.StartsWith(quot;JFquot;) || line.StartsWith(quot;JOquot;) || line.StartsWith(quot;JAquot;)) { j = j + 1; if (j == 1) textBox4.Text = line.Substring(6); } if (line.StartsWith(quot;VLquot;)) textBox5.Text = line.Substring(6); if (line.StartsWith(quot;PYquot;) || line.StartsWith(quot;Y1quot;)) { k = k + 1; if (k == 1) { textBox6.Text = line.Substring(6, 4); } } if (line.StartsWith(quot;SPquot;)) textBox7.Text = line.Substring(6); if (line.StartsWith(quot;EPquot;)) textBox8.Text = line.Substring(6); } while (!line.StartsWith(quot;TYquot;)); textBox3.Text = autori; tr.Close(); this.Show(); } 24
  26. 26. In più, ci sono anche due listbox. Una dove all’apertura del form vengono visualizzati tutti i record della tabella “Persone” in ordine alfabetico, più precisamente, la stringa concatenata di cognome e nome della persona. L’altra listbox è inizialmente vuota. Selezionando la persona o le persone desiderate, dalla prima listbox, e premendo il bottone con la freccia che punta verso la listbox vuota, si fa in modo che le righe selezionate spariscono da una listbox ed appaiono nell’altra. Inoltre poi, è possibile fare l’identica operazione al contrario. Tutto questo ha lo scopo di permettere all’utente di associare il riferimento alle persone che sono gli autori della pubblicazione alla quale il riferimento si riferisce. Schiacciando il bottone “Importa”, viene aperta una connessione con il database del sistema, il quale si chiama “pubblicazioni”, e viene aggiunto un nuovo record alla tabella “tblRiferimento”, salvando nei rispettivi campi i valori delle textbox. Se mancano i dati che dovrebbero andare inseriti nei campi “Volume”, “Pag_iniz” e “Pag_fin”, al loro posto viene inserito il valore “1”. Inoltre viene calcolato ed inserito il valore per il campo “Riferimento_veloce”, con la seguente concatenazione di stringa: stringRiferimento_veloce= Volume + ”:” + pag_iniz + “ - “ + pag_fin + “(“ + Anno_Pubblicazione + “)”; Prima di chiudere le connessione col database, viene aggiunto un nuovo record nella tabella “tblRif_Pers” per ogni persona associata al riferimento nella listbox al punto precedente. Se tutto è andato a buon fine, viene chiuso il form “Dettagli” e creato l’oggetto della classe “Importazione_Riuscita”, attraverso il quale si visualizza il form che informa l’utente che l’importazione è terminata con successo. Nello stesso momento, viene cancellata la riga del riferimento appena importato dalla listbox del form “Riferimenti”, per evitare che l’utente importi più volte lo stesso riferimento per errore. Se qualcosa ha generato un’eccezione nello scaricamento dati nel database, viene visualizzato il form di errore informando l’utente che l’importazione non è riuscita, ed indicando i possibili motivi grazie ai quali non è stato possibile importare. Questo avviene creando l’oggetto della classe “Errore_Importazione” ed applicandogli il metodo “Show()”. In seguito è riportato il codice del funzionamento nel bottone “Importa” con il quale i dati vengono importati nel database: private void button3_Click(object sender, EventArgs e) { string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;; // file della stringa if (!File.Exists(s)) // di connessione { Errore_Apertura_File_Connessione ef = new Errore_Apertura_File_Connessione(); ef.Show(); } // continua sulla pagina successiva 25
  27. 27. else // per poter connettersi al DB bisogna includere la libreria System.Data.SqlClient { try { TextReader tr= new StreamReader(s); string source=tr.ReadLine(); // legge la stringa di connessione dal file SqlConnection conn= new SqlConnection(source); conn.Open(); // apre la connessione col DB string risTag= quot;SELECT ID_TipoRif FROM tblTipoRif WHERE RisTAG='quot; + this.textBox1.Text + quot;'quot;; SqlCommand cmd1 = new SqlCommand(risTag, conn); int tagRis = (int)cmd1.ExecuteScalar(); // esegue la query che torna il valore del ID_TipoRif string titolo = this.textBox2.Text; string autori = this.textBox3.Text; string rivista = this.textBox4.Text; string riferimento_veloce=quot;quot;; if (titolo.Contains(quot;'quot;)) titolo = titolo.Replace(quot;'quot;, quot; quot;); if (autori.Contains(quot;'quot;)) autori = autori.Replace(quot;'quot;, quot; quot;); if (rivista.Contains(quot;'quot;)) rivista = rivista.Replace(quot;'quot;, quot; quot;); string insert = quot;INSERT INTO tblRiferimento (ID_TipoRif, Titolo, Autori,Rivista,Volume,quot; + quot;Anno_Pubblicazione,Pag_iniz,Pag_fin,Riferimento_veloce) VALUES (quot; + tagRis + quot;,'quot; + titolo + quot;','quot; + autori + quot;','quot; + rivista + quot;'quot;; if (this.textBox5.Text != quot;quot;) { insert = insert + quot;,'quot; + this.textBox5.Text+quot;'quot;; riferimento_veloce = this.textBox5.Text+quot;:quot;; } else { insert = insert + quot;,'1'quot;; riferimento_veloce = quot;1:quot;; } if (this.textBox6.Text != quot;quot;) { insert = insert + quot;,quot; + this.textBox6.Text; } else { insert = insert + quot;,nullquot;; } if (this.textBox7.Text != quot;quot;) { insert = insert + quot;,quot; + this.textBox7.Text; riferimento_veloce = riferimento_veloce + this.textBox7.Text+quot;-quot;; } // continua sulla pagina successiva 26
  28. 28. else { insert = insert + quot;,1quot;; riferimento_veloce = riferimento_veloce + quot;1-quot;; } if (this.textBox8.Text != quot;quot;) { insert = insert + quot;,quot; + this.textBox8.Text; riferimento_veloce = riferimento_veloce + this.textBox8.Text; } else { insert = insert + quot;,1quot;; riferimento_veloce = riferimento_veloce + quot;1quot;; } riferimento_veloce = riferimento_veloce + quot;(quot;+this.textBox6.Text+quot;)quot;; insert = insert +quot;,'quot;+riferimento_veloce+ quot;')quot;; cmd1 = new SqlCommand(insert, conn); // inserisce un nuovo record nella tabella “tblRiferimento” cmd1.ExecuteNonQuery(); // con i dati delle textbox string id = quot;SELECT MAX(ID_Riferimento) FROM tblRiferimentoquot;; cmd1 = new SqlCommand(id, conn); int id_rifer = (int)cmd1.ExecuteScalar(); // esegue la query che torna ID del riferimento appena inserito int num_autori= this.listBox1.Items.Count; System.Windows.Forms.ListBox.ObjectCollection oc=this.listBox1.Items; int count = oc.Count; Object[] ob_c = new Object[count]; oc.CopyTo(ob_c,0); char[] spazio= new char[1]; spazio[0]=','; while (num_autori>0) // il ciclo che associa il riferimento alle persone desiderate { String[] str_cogn_nom =this.listBox1.GetItemText(ob_c[num_autori-1]).Split(spazio[0]); string id_auth= quot;SELECT ID_Personale FROM tblPersonale WHERE quot;+ quot;Cognome=' quot;+str_cogn_nom[0]+ quot; ' AND Nome='quot;+str_cogn_nom[1]+quot;'quot;; cmd1 = new SqlCommand(id_auth, conn); //esegue la query che torna ID della Persona da int id_pers = (int)cmd1.ExecuteScalar(); // associare string ins_auth= quot;INSERT INTO tblRif_Pers(ID_Rif,ID_Personale)quot; + quot;VALUES (quot;+id_rifer+quot;,quot;+id_pers+quot;)quot;; cmd1 = new SqlCommand(ins_auth, conn); cmd1.ExecuteNonQuery(); // inserisce la coppia ID_Riferimento, ID_Persona alla tblRif_Pers num_autori=num_autori-1; } conn.Close(); // chiude la connessione rif_interno.refresh(num_riga); // chiama il metodo refresh che toglie la riga del riferimento importato Importazione_Riuscita ir =new Importazione_Riuscita(det_esterno,rif_interno);//dal form “Riferimenti” ir.Show(); // mostra il form che informa l’utente della importazione terminata con successo } catch (Exception err) { Errore_Importazione eimp = new Errore_Importazione(); eimp.Show(); // mostra il form dell’errore nella importazione } } } 27
  29. 29. AMMINISTRAZIONE Come è possibile intuire dal nome stesso di questo modulo, esso ci permette di amministrare i riferimenti salvati nel database. Appena viene creato l’oggetto di questa classe, viene stabilita la connessione col database attraverso la quale viene riempita la combo box con i cognomi e nomi di tutti i record nella tabella “tblPersonale”. Scegliendo la persona desiderata, e successivamente schiacciando il bottone “Mostra”, viene visualizzato il gruppo di appartenenza della persona scelta in una textbox non soggetta a modifiche. Questo accade eseguendo la query sulla tabella “tblPersonale” che restituisce il valore del campo “ID_Gruppo”. Successivamente viene eseguita la seconda query che torna il valore del campo “Nome” della “tblGruppo”. A parte questo, la listbox contenuta nel form “Amministrazione” viene riempita nell’ordine alfabetico con i riferimenti associati alla persona in questione. Queste righe di riferimenti sono le stringhe concatenate dei seguenti campi: Titolo, Autori, Rivista, Riferimento_veloce. Da qui è possibile selezionare un riferimento nella listbox e cancellarlo premendo il bottone “Cancella pubblicazione”. Il riferimento viene dissociato dalla persona nel database e dalla listbox nel form corrente. Se si desidera invece modificare i dati del riferimento, si seleziona il riferimento desiderato e si schiaccia il bottone “Modifica pubblicazione”. Facendo così eseguiamo una query che prende i dati dei campi “Titolo”, “Autori”, “Rivista”, “Riferimento_veloce” separando opportunamente la stringa selezionata nella listbox, e ci restituisce il valore del campo “ID_Riferimento”. Questo è possibile per via della esistenza della chiave unica nella base dati che comprende i campi “Titolo”, “Rivista”, “Volume”, “Riferimento_veloce”. Non è stato possibile aggiungere il campo “Autori” alla chiave per via del limite di lunghezza massimo della chiave. Comunque si è ritenuto che non possono esistere due riferimenti con questi quattro campi identici. Successivamente viene creato un oggetto della classe “Modifica_Pubblicazione”, e viene invocato su di esso il metodo “carica_dati”, al quale viene passato come parametro il valore “ID_Riferimento” ottenuto con la query appena conclusa. Fatto ciò, viene visualizzato il rispettivo form. Tutte le eccezioni che possano venire sollevate sono gestite visualizzando i rispettivi form con i messaggi di errore. MODIFICA_PUBBLICAZIONE All’apertura di questo form vengono visualizzati i dati del riferimento per il quale è stata creata un’istanza di questa classe. I dati vengono visualizzati con il metodo “carica_dati” all’apertura del form. 28
  30. 30. Il codice del metodo “carica_dati”: public void carica_dati(int rif) { globale_IDrif = rif; string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;; if (!File.Exists(s)) { Errore_Apertura_File_Connessione ef = new Errore_Apertura_File_Connessione(); ef.Show(); } else // per poter connettersi al DB bisogna includere la libreria System.Data.SqlClient { TextReader tr= new StreamReader(s); string source=tr.ReadLine(); SqlConnection conn= new SqlConnection(source); conn.Open(); //apre la connessione SqlCommand cmd; string tipoRif; int numRif=0; try { string dati=quot;SELECT ID_TipoRif, Titolo, Autori, Rivista, Volume, Anno_Pubblicazione, quot; + quot;Pag_iniz, Pag_fin,quot;+ quot;Riferimento_veloce FROM tblRiferimento WHERE ID_Riferimento=quot;+rif; cmd = new SqlCommand(dati, conn); SqlDataReader dati_array = cmd.ExecuteReader(); while(dati_array.Read()) { numRif= (int)dati_array[0]; this.textBox10.Text=dati_array[1].ToString(); // caricamento delle textbox this.textBox9.Text = dati_array[2].ToString(); this.textBox8.Text = dati_array[3].ToString(); this.textBox4.Text = dati_array[4].ToString(); this.textBox7.Text = dati_array[5].ToString(); this.textBox2.Text = dati_array[6].ToString(); this.textBox5.Text = dati_array[7].ToString(); this.textBox3.Text = dati_array[8].ToString(); } dati_array.Close(); } catch (Exception load_e) { this.textBox10.Text = quot;ERRORE: Caricamento non riuscitoquot;; } try { tipoRif = quot;SELECT RisTAG FROM tblTipoRif WHERE ID_TipoRif=quot; + numRif; SqlCommand cmd1 = new SqlCommand(tipoRif, conn); string tipo= (string)cmd1.ExecuteScalar(); // continua sulla pagina successiva 29
  31. 31. this.textBox1.Text = tipo; int[] int_arr = new int[10000000]; int i = 0; string cognNom=quot;quot;; string autori_associati_ID = quot;SELECT ID_Personale FROM tblRif_Pers quot; + quot;WHERE ID_Rif=quot; + rif; cmd = new SqlCommand(autori_associati_ID, conn); SqlDataReader autorID_array = cmd.ExecuteReader(); while(autorID_array.Read()) { int_arr[i] = (int)autorID_array[0]; i++; } autorID_array.Close(); for (int j=0;j<i;j++) { string autori_associati = quot;SELECT Cognome, Nome FROM tblPersonale quot; + quot;WHERE ID_Personale=quot;+int_arr[j]; cmd = new SqlCommand(autori_associati, conn); SqlDataReader autor_array = cmd.ExecuteReader(); while(autor_array.Read()) { cognNom = autor_array[0].ToString() + quot;,quot; + autor_array[1].ToString(); } this.listBox1.Items.Add(cognNom); //caricamento listbox con persone autor_array.Close(); // associate }} catch (Exception load_e1) { this.listBox1.Items.Add(quot;ERRORE: Caricamentoquot;); this.listBox1.Items.Add(quot;non riuscitoquot;); } try { string cogn_Nom = quot;quot;; string autori_non_associati = quot;SELECT Cognome,Nome FROM tblPersonale quot; + quot;WHERE ID_Personale NOT IN (SELECT ID_Personale quot; + quot;FROM tblRif_Pers WHERE ID_Rif=quot; + rif + quot;)quot;; cmd = new SqlCommand(autori_non_associati, conn); SqlDataReader autor_non_array = cmd.ExecuteReader(); while (autor_non_array.Read()) { cogn_Nom = autor_non_array[0].ToString() + quot;,quot; + autor_non_array[1].ToString(); this.listBox2.Items.Add(cogn_Nom); //caricamento listbox con persone } // non associate autor_non_array.Close(); } catch (Exception load_e2) { this.listBox2.Items.Add(quot;ERRORE: Caricamentoquot;); this.listBox2.Items.Add(quot;non riuscitoquot;); } conn.Close(); }} 30
  32. 32. Il metodo “carica_dati”, il quale codice è riportato sopra, carica le textbox con tutti i dati del riferimento, inoltre riempie una listbox con le persone associate al medesimo riferimento, mentre ne riempie una analoga con le persone non associate. È possibile effettuare direttamente qualsiasi modifica sui dati delle textbox. Questo non è possibile solamente a quella affianco alla label “Tipo Riferimento” in quanto non ritenuto opportuno permettere tale modifica. È possibile associare o dissociare le persone dal riferimento in questione. Questa operazione viene eseguita spostando le persone tra le due listbox per mezzo di due bottoni con le frecce che indicano il verso dello spostamento della persona o persone selezionate nelle listbox. Infine, le modifiche vengono salvate nel database premendo il bottone “Salva Modifiche”. Alla sua pressione viene aperta la connessione col database e viene eseguita la query di update del record il quale campo “ID_Riferimento” corrisponde a quello passato al metodo “carica_dati”. Vengono aggiornati tutti i campi di questo record, tranne “ID_TipoRif”. Esso identifica il tipo di riferimento, e come detto sopra, la textbox corrispondente non era modificabile. Fatto questo, vengono associate/dissociate le persone al/dal riferimento. Infine, se tutto è andato a buon fine, viene visualizzata la finestra “Salvataggio_modifiche_OK” che informa l’utente che le modifiche sono state fatte. Allo stesso momento viene aggiornata la riga della listbox nella finestra “Amministrazione”. Persino la riga relativa viene cancellata se il riferimento è stato dissociato dalla persona corrente. Il codice che sta dietro il click sul bottone “Salva Modifiche” viene riportato qui: private void button3_Click(object sender, EventArgs e) { string s=Application.StartupPath+quot;SettingsstringaConnessione.txtquot;; if (!File.Exists(s)) { Errore_Apertura_File_Connessione ef = new Errore_Apertura_File_Connessione(); ef.Show(); } else // per poter connettersi al DB bisogna includere la libreria System.Data.SqlClient { try { TextReader tr= new StreamReader(s); string source=tr.ReadLine(); SqlConnection conn= new SqlConnection(source); conn.Open(); //apre la connessione SqlCommand cmd; // continua sulla pagina successiva 31
  33. 33. string stringa=quot;UPDATE tblRiferimento SET Titolo='quot;+this.textBox10.Text+ quot; ', Autori='quot;+this.textBox9.Text+quot;', Rivista='quot;+this.textBox8.Text+quot;' quot;; if (this.textBox4.Text!=quot;quot;) stringa = stringa + quot;, Volume='quot; + this.textBox4.Text + quot;'quot;; else stringa = stringa + quot;, Volume= nullquot;; if (this.textBox7.Text != quot;quot;) stringa = stringa + quot;, Anno_Pubblicazione=quot; + this.textBox7.Text; else stringa = stringa + quot;, Anno_Pubblicazione= nullquot;; if (this.textBox2.Text != quot;quot;) stringa = stringa + quot;, Pag_iniz=quot; + this.textBox2.Text; else stringa = stringa + quot;, Pag_iniz= nullquot;; if (this.textBox5.Text != quot;quot;) stringa = stringa + quot;, Pag_fin=quot; + this.textBox5.Text; else stringa = stringa + quot;, Pag_fin= nullquot;; if (this.textBox3.Text != quot;quot;) stringa = stringa + quot;, Riferimento_veloce='quot; + this.textBox3.Text + quot;'quot;; else stringa = stringa + quot;, Riferimento_veloce= nullquot;; stringa=stringa+quot; WHERE ID_Riferimento=quot; + globale_IDrif; cmd = new SqlCommand(stringa, conn); cmd.ExecuteNonQuery(); // esegue la query update del riferimento int num_elementi= this.listBox1.Items.Count; System.Windows.Forms.ListBox.ObjectCollection oc = this.listBox1.Items; int count = oc.Count; Object[] ob_c = new Object[count]; oc.CopyTo(ob_c, 0); for (int i=0;i<num_elementi;i++) { char[] spazio = new char[1]; ; spazio[0] = ','; String[] str_cogn_nom = this.listBox1.GetItemText(ob_c[i]).Split(spazio[0]); string aut_ID= quot;SELECT ID_Personale FROM tblPersonale WHERE Cognome = ' quot; + str_cogn_nom[0]+ quot; ' AND Nome=' quot;+str_cogn_nom[1]+quot; ' quot;; cmd = new SqlCommand(aut_ID, conn); int autore_ID = (int)cmd.ExecuteScalar(); try { string autori_ass=quot;INSERT INTO tblRif_Pers(ID_Rif, ID_Personale) VALUES(quot;+ globale_IDrif+quot;,quot;+autore_ID+quot;)quot;; cmd = new SqlCommand(autori_ass, conn); // cerca di associare tutte le cmd.ExecuteNonQuery(); //persone della listbox, anche quelle già associate } catch(SqlException prim_e) // acchiappa l’eccezione che viene sollevata quando cerca // { // di associare una persona già associata, e la gestisce non facendo niente, // il che corrisponde al passare alla prossima persona da associare } } int num_elementi1= this.listBox2.Items.Count; System.Windows.Forms.ListBox.ObjectCollection oc1 = this.listBox2.Items; int count1 = oc1.Count; Object[] ob_c1 = new Object[count1]; // continua sulla pagina successiva 32
  34. 34. oc1.CopyTo(ob_c1, 0); for (int i=0;i<num_elementi1;i++) { char[] spazio1 = new char[1]; ; spazio1[0] = ','; String[] str_cogn_nom1 = this.listBox2.GetItemText(ob_c1[i]).Split(spazio1[0]); string aut_ID1=quot;SELECT ID_Personale FROM tblPersonale WHERE Cognome = ' quot; + str_cogn_nom1[0]+ quot; ' AND Nome=' quot; + str_cogn_nom1[1] + quot; ' quot;; cmd = new SqlCommand(aut_ID1, conn); int autore_ID1 = (int)cmd.ExecuteScalar(); string canc_aut = quot;DELETE FROM tblRif_Pers WHERE ID_Rif=quot; + globale_IDrif + quot; AND ID_Personale=quot; + autore_ID1; cmd = new SqlCommand(canc_aut, conn); //cancella dalla tabella “tblRif_Pers” cmd.ExecuteNonQuery(); // il record che associa la determinata persona al riferimento } conn.Close(); this.Close(); Salvataggio_modifiche_OK sa_ok = new Salvataggio_modifiche_OK(); sa_ok.Show(); amm_interno.mostra_riferimenti_dell_autore(); //refresh della listbox nel } // form “Amministrazione” catch(Exception load_e4) { Errore_Amministrazione eam = new Errore_Amministrazione(); eam.Show(); } } } Finisce qui la parte che descrive l’implementazione dei singoli moduli. 33
  35. 35. DIAGRAMMA DI FLUSSO Diagramma di flusso finale: “Esci” FINE “Amministrazione” “Importazione” PRINCIPALE “Esci” “Annulla” ERRORE_FILE “Cancella pubblicazione” CANCELLAZIONE “Sfoglia” IMPORTAZIONE AMMINISTRAZIONE ERRORE_AMMINISTRAZIONE “Modifica pubblicazione” “Apri” CERCA ERRORE_CAN ERRORE_APERTURA_FILE_ “Chiudi” CELLAZIONE CONNESSIONE “Annulla” RIFERIMENTI ERRORE_FILE MODIFICA Doppio click listbox ERRORE_APERTURA_FILE_ CONNESSIONE “Annulla” “Salva Modifiche” ERRORE_APERTURA_FILE_ CONNESSIONE DETTAGLI ERRORE_ AMMINISTRAZIO NE ERRORE_IMPORTAZIONE “Importa” “OK” “OK” SALVATAGGIO_MODIFICHE_ IMPORTAZIONE_ OK RIUSCITA 34
  36. 36. 3.1.2 Interfaccia Per spiegare come l’utente si interfaccia col sistema, bisogna prima descrivere la installazione e configurazione necessaria del sistema sulla macchina dell’utente, e poi fare un esempio d’uso che dovrebbe togliere ogni dubbio sulla modalità d’utilizzo. 3.1.2.1 Installazione e configurazione INSTALLAZIONE • Per potere usufruire di questo sistema in modalità off-line bisogna avere sul proprio PC la banca dati (pubblicazioni.mdf e pubblicazioni_log.ldf), l’applicativo (Tesi_schermata1.exe) e la cartella di nome “Settings” che si deve trovare nello stesso directory dell’applicativo, e deve contenere al suo interno un file di nome “stringaConnessione.txt”, il quale contiene, appunto, la stringa di connessione al database. Sul contenuto di questo file parleremo di più nel paragrafo “Configurazione”. Inoltre bisogna avere installato il SQL Server ed il Microsoft .NET Framework. 35
  37. 37. Passi da compiere per collegare la banca dati al server locale: 1. Connettersi al server locale 2. Click col tasto destro sulla cartella “Databases” nella finestra “Object Explorer” e poi click su “Attach” 36
  38. 38. 3. Nella finestra che si apre cliccare il bottone “Add”, successivamente scegliere il file “pubblicazioni.mdf” dalla cartella dove è stato salvato, ed infine cliccare “OK”. Fatto ciò, il nostro database risulta collegato al server locale. 37
  39. 39. Possiamo accertarci di questo avvenimento vedendolo nella cartella “Databases” nella finestra “Object Explorer”. • Utilizzare il sistema invece nella modalità on-line, ovvero quando la banca dati si trova su un’altra macchina della rete, è il caso di utilizzo decisamente più probabile. Per fare ciò, bisogna avere sul proprio PC l’applicativo (Tesi_schermata1.exe) e la cartella di nome “Settings” che si deve trovare, anche in questo caso, nello stesso directory dell’applicativo, e deve contenere al suo interno un file di nome “stringaConnessione.txt”. Inoltre il PC deve essere dotato del Microsoft .NET Framework. In questa modalità non c’è, appunto, il bisogno di collegare il database al server locale. Però, in ogni caso, il database deve essere collegato al server locale della macchina sulla quale si trova. 38
  40. 40. CONFIGURAZIONE Il sistema per funzionare deve essere configurato opportunamente. La configurazione consiste nel modificare una parte della stringa di connessione, in modo che si riferisca al server sul quale si trova il database. Quindi andiamo ad aprire il file “stringaConnessione.txt”, che si trova nella cartella “Settings”, la quale si deve trovare nella cartella contenente l’eseguibile dell’ applicativo. • Se vogliamo utilizzare il sistema in modalità off-line, bisogna cambiare il valore del “Data Source”, inserendo il nome del server locale. Non c’è bisogno di modificare niente altro. Una volta modificato, il file viene ovviamente salvato. Esempio: Data Source=PC-MAJA; Initial Catalog=pubblicazioni; Integrated Security=True Inserire qui il nome del server locale • Se invece si desidera utilizzare il sistema in modalità on-line, anche in questo caso si deve cambiare la stringa di connessione. In questo caso al posto del server locale si deve inserire il nome del server remoto sul quale si trova il database. 3.1.2.2 Esempio d’uso Facendo partire il programma applicativo (Tesi_schermata1.exe), viene visualizzata questa finestra: 39
  41. 41. Se vogliamo importare dei riferimenti da un file RIS che abbiamo da qualsiasi parte nel nostro PC, schiacciamo il bottone “Importazione”. Questa operazione ci apre la seguente finestra: Qui abbiamo la possibilità di scrivere direttamente il nome del file (attenzione: con il path completo!), oppure aprire la finestra la quale ci permette di sfogliare le cartelle del PC e scegliere il file RIS desiderato. Non si ritiene necessario accompagnare questo procedimento con le immagini del programma. Una volta selezionato il file, il suo nome appare al posto della scritta “*.ris”. 40
  42. 42. Successivamente premendo il bottone apri viene visualizzata la finestra “Riferimenti”, la quale ci mostra i possibili riferimenti da importare. Per motivi di questo esempio abbiamo utilizzato un file RIS che ci ha portato alla seguente schermata: 41
  43. 43. Adesso scegliamo il riferimento che vorremmo importare, e facciamo il doppio click sopra. Questo ci fa aprire la prossima finestra, quella dove possiamo modificare i dati ed associare il riferimento alle persone: 42
  44. 44. Se adesso decidiamo di associare questo riferimento ad esempio a Fermeglia Maurizio e Ferrone Marco, dobbiamo selezionare i loro nomi e schiacciare il bottone con la freccia che punta verso sinistra. Nel caso cambiassimo idea dopo e non volgiamo più associarla a qualcuno dei due, selezioniamo la persona desiderata, e schiacciamo il bottone della freccia che punta verso destra. Esempio: 43
  45. 45. Quando abbiamo terminato con tutte le modifiche ed associazioni, e volgiamo importare il riferimento, clicchiamo il bottone “Importa”, il quale ci mostra la finestra che ci informa che l’importazione è andata a buon fine, ed inoltre ci toglie il riferimento appena importato dalla finestra “Riferimenti”. Nel caso di importazione non riuscita viene visualizzata la finestra di errore, e la modifica alla finestra “Riferimenti” non avviene. Supponiamo che l’importazione sia andata a buon fine. Vediamo quindi questa finestra: Adesso possiamo selezionare il prossimo riferimento da importare nella finestra “Riferimenti” e ripetere il medesimo procedimento finché non abbiamo importato tutti i riferimenti che volevamo. Quando abbiamo terminato, premiamo il bottone “Chiudi” della finestra “Riferimenti”. Questo ci riporta sul menù di partenza. 44
  46. 46. Se volgiamo amministrare i riferimenti che sono contenuti nel database, premiamo il bottone “Amministrazione” del menù di partenza, ovvero dalla finestra “Pubblicazioni”. Facendo così si apre la finestra “Amministrazione” dove possiamo scegliere dalla combo box la persona della quale vogliamo amministrare i riferimenti. Cliccando il bottone “Mostra” ci vengono visualizzati i riferimenti ed il gruppo di appartenenza della persona. Prendiamo come esempio Fermeglia Maurizio. Dopo aver cliccato “Mostra” vediamo la seguente schermata: 45
  47. 47. Ora se vogliamo cancellare un riferimento, lo selezioniamo e premiamo il bottone “Cancella pubblicazione”. Questo fa si che il riferimento viene cancellato dal database e pure da questa schermata. Non è possibile selezionare più riferimenti nello stesso momento. Tutte le operazioni si fanno su uno alla volta. Se vogliamo modificare un riferimento, lo selezioniamo e clicchiamo il bottone “Modifica pubblicazione”. Questo ci apre la seguente finestra, di nome “Modifica”: Qui possiamo modificare i dati della pubblicazione, ed associare oppure dissociare il riferimento dalla determinata persona, attraverso le due listbox e i due bottoni che sono auto esplicativi. Quando abbiamo terminato le modifiche, premendo il bottone “Salva Modifiche”, tutte le modifiche vengono salvate. Viene visualizzata la finestra che ci informa dell’avvenuto, e successivamente viene aggiornata la finestra “Amministrazione”. Se abbiamo finito con tutto, premiamo il bottone “Esci”, che ci chiude la finestra “Amministrazione” e ci lascia a quella “Pubblicazioni”. Se vogliamo terminare tutto il programma, premiamo il bottone “Esci”, ed anche l’ultima finestra viene chiusa e tutte le risorse che utilizzava rilasciate. 46
  48. 48. 3.2 Test Durante, ed al termine della realizzazione del sistema, sono stati eseguiti dei test funzionali sul programma e sui moduli per assicurarsi del loro corretto funzionamento. Questi test comprendevano sia i dati “a caso”, sia i dati “critici” dove mancavano informazioni, per poter gestire nel modo migliore le eccezioni. Questi test sono stati eseguiti sul PC che è stato utilizzato per lo sviluppo del sistema. Una volta accertati che tutto funziona bene ed assicurati che gli obiettivi iniziali sono stati raggiunti, il sistema è stato portato al committente per la validazione. Dopo la conferma del committente, il sistema è stato installato sul suo PC, ovvero, su uno dei ambienti finali, di nuovo accertandosi che il tutto funziona correttamente. 47
  49. 49. 4 CONCLUSIONI Questo capitolo porta alcune considerazioni finali sul lavoro svolto. Si valuterà se gli obbiettivi iniziali sono stati raggiunti. Si cercherà in qualche modo di quantificare il lavoro svolto. Si rappresenterà lo stato attuale del sistema, l’utilizzo corrente, e l’utilizzo che gli si prospetta in un futuro prossimo. Infine, il capitolo si concluderà esprimendo alcune considerazioni riguardanti il livello di soddisfazione personale dovuto al lavoro effettuato. 4.1 Obiettivi Girandosi indietro cercando di confrontare il lavoro ottenuto con il lavoro assegnato si può concludere che tutti gli obiettivi prestabiliti sono stati raggiunti. Il fatto che il sistema è stato portato al committente, il relatore di questa tesi, il quale è nello stesso tempo anche un utente finale, per la validazione dei requisiti, ed è stato giudicato valido, non fa altro che rafforzare la suddetta affermazione. 4.2 Lavoro svolto In questo paragrafo cercherò di quantificare il lavoro svolto attraverso il numero delle classi dell’applicativo, ed il numero di tabelle del database sviluppato. Numero delle classi del programma applicativo: 13 Numero di tabelle del database: 5 4.3 Stato attuale Attualmente il programma è, come già detto sopra stato consegnato al committente, nonché utente. Come già detto nella descrizione del progetto, esso è stato creato per una condivisione di dati in rete, e la loro visualizzazione in Internet, sul sito http://www.dicamp.units.it/Research/Publications/default.aspx . I dati verranno visualizzati in maniera analoga a quella della visualizzazione delle pubblicazioni sul sito http://www.mose.units.it/ . 48
  50. 50. 49
  51. 51. Non mi risulta che il sistema sia già operativo sul sito citato sopra, ma lo dovrebbe essere in un futuro prossimo. 4.4 Considerazioni personali Personalmente mi ritengo soddisfatta del lavoro svolto. È stata una bella esperienza. Ho imparato tante cose, quindi è stato utile. Le ore volavano tra gli alti e bassi, tra le arrabbiature e congratulazioni con me stessa. Devo ammettere che mi è dispiaciuto un po’ quando l’ho finito. Ma soprattutto sono rimasta parecchio sorpresa del modo in cui mi ha preso. Non me l’aspettavo. Come ultima cosa devo fare presente che senza il mio relatore questa esperienza sarebbe stata molto meno bella e motivante. 50
  52. 52. 5 BIBLIOGRAFIA • “C# - Guida per lo sviluppatore” - Robinson, Cornes, Glynn, Harvey, McQueen, Moemeka, Nagel, Skinner, Watson - Ulrico Hoepli Editori S.p.A. 2001 - Ristampa n. 4, anno 2005 • “Introduzione a Microsoft SQL Server 2005 per sviluppatori” - DeBetta - Mondadori Informatica - Edizione n. 1, anno 2005 • http://msdn.microsoft.com/it-it/library/kx37x362.aspx • http://msdn.microsoft.com/it-it/library/ms310242.aspx • http://www.vbsimple.net/index.htm?/database/db_08_06.htm 51

×