Università degli studi di Modena

Capitolo 1

Clienti

Un’azienda è rappresentata dai suoi clienti e in questo capitolo verrà illustrato come WinLavori gestisce tutti i dati che caratterizzano un cliente.

Nella prima parte del capitolo verrà spiegato come è possibile attraverso una scheda inserire, modificare ed eliminare un cliente, gestire il suo contratto d’assistenza o i moduli relativi al gestionale acquistato.

Verrà illustrato come è possibile avere una lista dei clienti che hanno un determinato modulo di un gestionale o avere una lista dei clienti che non hanno quello stesso modulo, tutto avendo la possibilità di ordinare l’elenco per cliente o per modulo.

Attraverso una scheda sarà sempre chiara la situazione generale dei contratti di assistenza, quindi sapere quanti clienti sono in contratto per un determinato gestionale e quando questo scadrà o sapere quanti clienti sono fuori contratto o sono insoluti.

Infine in questo capitolo verrà descritta la gestione delle note, quindi la possibilità di inserire, modificare o eliminare una nota riferita ad un particolare modulo di un determinato gestionale.

1.1 Gestione Clienti

Come si può vedere dalla figura questa scheda è composta da: un Pannello sopra, da un Book sotto e dei Comandi tra i due.

Nel Pannello sono raccolti i dati principali del cliente, quindi il codice, la ragione sociale ed il gestionale acquistato; il codice permetterà al cliente di risultare unico all’interno di WinLavori, anche se dovesse esserci un altro cliente con ragione sociale uguale.

Attraverso i comandi saranno possibili tutte le operazioni all’interno della scheda, come spostarsi da un cliente ad un altro o modificarne i dati.

Nel Book sotto sono raccolti tutti i dati relativi al cliente: dati generali, moduli acquistati, situazione contratto, Pc aziendali, stampanti aziendali, Rapportini, dati programma, altre sedi aziendali e Commesse .

Come si può vedere attraverso questa scheda è possibile avere, in tempi ottimali, una fotografia molto chiara e completa della situazione del cliente.

Inserimento Cliente

Una delle operazioni sicuramente più importanti che l’utente potrà fare, è l’inserimento di un nuovo cliente; questa operazione sarà permessa attraverso il comando Aggiungi, indicato dalla freccia nella figura sopra.

Al click sul comando la scheda verrà inizializzata e commuterà dallo stato di consultazione allo stato di inserimento; l’utente avrà la possibilità di inserire tutti i dati compilando gli appositi campi, il cliente sarà reso univoco da un codice che il programma gli attribuisce al momento dell’inizializzazione.

Il codice cliente è l’unico dato non gestibile dall’utente, la sua integrità rappresenta un fatto fondamentale nella gestione dei dati.

Una particolare funzione legata ai campi delle schede permette di posizionarsi automaticamente sul campo successivo, una volta confermato il dato inserito attraverso il tasto invio.

Alla conferma dei dati, funzioni di controllo, vigileranno sulla loro correttezza; ad esempio non sarà possibile inserire un carattere in un campo numerico e viceversa.

Una volta inseriti e controllati i dati, l’utente ha la possibilità di annullare l’inserimento o di confermarlo.

La conferma avviene attraverso il comando Salva e l’annullamento al click del comando Abbandona.

Con il primo, il cliente sarà salvato in tabella e l’utente avrà la possibilità di consultarlo o modificarlo in un secondo tempo, mentre con il secondo l’operazione in corso verrà abbandonata e con lei anche il cliente che si stava inserendo.

Modifica Cliente

Una volta inserito un cliente sarà sempre possibile modificare o eliminare i suoi dati, tranne come detto il codice che rappresenta la garanzia di univocità del cliente.

L’ aggiornamento dei dati avviene attraverso il click su comando Modifica indicato dalla figura sopra, questo comando porta la scheda cliente in fase di modifica rendendo tutti i campi editabili.

Una volta modificati i dati, come in precedenza, sarà possibile confermare la modifica o annullarla attraverso i comandi Salva e Abbandona; confermando i dati si salverà la situazione attuale, quindi anche le modifiche apportate, mentre con abbandona si annulleranno le variazioni e si salveranno i dati precedenti alle modifiche.

Tutte queste operazioni saranno controllate da particolari funzioni che vigileranno sulla correttezza dei dati inseriti.

Eliminazione Cliente

L’eliminazione del cliente è sicuramente una delle operazioni più delicate, infatti una volta eliminati i dati saranno persi per sempre.

Prima di procedere è bene controllare bene se effettivamente si è posizionati sul cliente che si vuole rimuovere, quindi l’utente potrà eliminare il cliente con un click su comando Elimina indicato in figura contraddistinto da un cestino.

A questo punto comparirà un messaggio che chiederà una conferma, questa è l’ultima occasione per rinunciare all’operazione, in caso contrario il cliente e i dati a lui relativi saranno rimossi e non più recuperabili.

Ricerca Cliente

Questa scheda ha la possibilità di posizionarsi su un determinato cliente essenzialmente in due modi: sequenziale e diretto.

Il modo sequenziale permette all’utente di scorrere i clienti in base ad un ordine dato dal codice tramite il comando Navigate, mentre il modo diretto permette di arrivare al cliente voluto in modo immediato, quindi senza scorrerli tutti.

Se si è a conoscenza del codice è possibile attraverso l’apposito campo richiamare il cliente col tasto Invio, altrimenti sarà possibile richiamarlo grazie al comando Ricerca indicato dalla freccia in figura; la selezione del cliente è permessa solo in fase di consultazione della scheda.

Il posizionamento diretto è possibile attraverso una ricerca alfabetica o una ricerca libera.

La ricerca alfabetica avviene tramite il comando rappresentato da una lente di ingrandimento o attraverso il tasto tastiera F2, mentre la ricerca libera verrà eseguita dal comando rappresentato da una torcia o dal tasto F3.

Con la prima viene azionata la scheda per la ricerca alfabetica (Figura sotto).

Inserendo il testo nel campo di ricerca, verranno caricati in griglia tutti i clienti che hanno la descrizione che inizia col testo digitato; la ricerca può essere fatta per descrizione, codice, località, cap o partita iva.

Nell’esempio sotto, è stata fatta una ricerca alfabetica per ragione sociale, dei clienti che iniziano per CER; a questo punto se il cliente cercato è quello selezionato in griglia, col comando Ok sarà caricato nella scheda dalla quale è partita la ricerca.

La ricerca libera è molto simile a quella alfabetica, con l’eccezione che la ricerca del testo inserito non avviene solo sulla parte iniziale della ragione sociale, ma sull’intero testo che compone la descrizione del cliente.

A questo punto se si lanciasse una ricerca libera con il testo “CER”, in lista saranno caricati tutti i clienti trovati attraverso la ricerca alfabetica, più quelli che contengono all’interno della propria ragione sociale la stringa “CER”.

Stampa Cliente

Attraverso il click sul comando Stampa, contraddistinto da un’ icona stampante, viene attivata una piccola scheda menù per le stampe del cliente.

La scheda prevede diverse stampe a secondo delle reali esigenze dell’utente: Scheda Cliente, Scheda Moduli, Scheda Pc, Scheda Stampanti.

La scheda cliente è in sostanza la fotografia della situazione attuale del cliente, quindi tutto quello che compare nella scheda.

La scheda moduli, scheda Pc e scheda stampanti sono rispettivamente la stampa dei moduli acquistati, dei pc e delle stampanti del cliente.

Attraverso una CheckBox è possibile attivare la scelta multipla, quindi selezionando più schede, col tasto Ctrl, si potrà eseguire in serie più stampe; col comando Ok verranno lanciate le stampe selezionate, mentre con Annulla si abbandonerà l’operazione e si ritornerà alla scheda clienti.

1.2 Liste moduli Presenti/Assenti

La scheda Moduli Presenti/Assenti seleziona in una griglia o in una stampa, la situazione generale di uno o più moduli, quindi selezionando un modulo, è possibile sapere da chi è stato acquistato o da chi no.

Nell’esempio sopra è stata fatta la selezione per vedere i clienti che hanno acquistato il modulo A_CONTRATTO, quindi è risultato che i clienti che rispondono ai codici 5,172, 204 e 362 hanno attualmente in uso questo modulo.

Nel pannello in alto sono raccolti i dati di selezione: programma, codice cliente, moduli presenti, moduli assenti e ordine.

La selezione è possibile farla su un solo gestionale alla volta, visto che ogni modulo appartiene ad un unico gestionale, ma su uno o più clienti; in lista si potranno visualizzare i moduli presenti, i moduli assenti o tutti e due, sempre ordinati in base al criterio scelto.

In questa scheda i comandi sotto il pannello, come si vede dalla figura sopra, sono : Navigate, Stampa, Esegui ed Esci. Navigate permette all’utente si muoversi all’interno della griglia, stampa esegue la riproduzione su carta dei dati in griglia, esegui lancia la selezione e con esci si chiude la scheda.

1.3 Liste Contratti Assistenza

La scheda Liste contratti d’assistenza permette di visualizzare in griglia la situazione dei contratti di assistenza in base alle esigenze dell’utente.

Nell’esempio sopra l’utente ha elaborato una lista che considera i contratti di assistenza di tutti i clienti, di tutti i programmi, senza considerare la data di scadenza, quindi in griglia abbiamo tutti i contratti inseriti in WinLavori.

Nel Pannello, in alto, sono raggruppati i dati per la selezione: cliente, data fine contratto, in contratto, insoluti, programma.

Il campo contratto permette di filtrare solo i clienti in contratto o non, come anche il campo insoluti, mentre il campo programma seleziona solo i contratti relativi al gestionale considerato.

I comandi sono gli stessi visti nel paragrafo precedente: navigate, stampa, esegui e esci. Navigate permette all’utente si muoversi all’interno della griglia, Stampa esegue la riproduzione su carta dei dati in griglia, Esegui lancia la selezione e con Esci si chiude la scheda.

1.4 Gestione Note

Gestione note è una scheda di inserimento, attraverso la quale è possibile inserire, modificare ed eliminare una nota.

Una nota è un’appunto su un modulo, quindi una breve descrizione di quello che fa e di quello che comporta, ogni nota è identificata da un numero che la rende unica.

Oltre all’inserimento è possibile anche una consultazione delle note, grazie alla griglia in basso alla scheda, i dati per la selezione sono come sempre in alto all’interno del pannello; è possibile filtrare le note in base al programma, al numero, alla data ed al cliente, la lista sarà sempre ordinata secondo i criteri prescelti.

I comandi oltre ai consueti Navigate, Stampa, Esegui ed Esci comprendono anche aggiungi, modifica, salva, abbandona ed elimina per le normali operazioni di aggiornamento.

Dalla griglia si osserva il campo Numero che identifica la nota, il campo Tipo che indica il programma a cui fa riferimento, la data di inserimento e la descrizione.

Capitolo 2

Chiamate

Le Chiamate rappresentano le richieste di intervento fatte dal cliente o da un dipendente, in questo capitolo verrà illustrata come avviene la loro gestione da parte di WinLavori.

Le chiamate sono molto utili ai tecnici che essendo spesso fuori sede non possono essere al corrente delle richieste fatte, a loro, nella giornata; quindi al rientro avranno una situazione reale ed immediata, dei loro prossimi impegni.

Attraverso le chiamate ogni dipendente potrà impostare il proprio piano di lavoro dei giorni seguenti; quindi le chiamate saranno caratterizzate dal cliente, dal motivo, dall’operatore che l’ ha inserita e dal dipendente a cui è riferita.

Nella prima parte del capitolo verrà descritta la scheda di inserimento, con la quale è possibile anche la consultazione e la modifica di una chiamata.

Nella seconda parte ci si occupa della scheda di consultazione, dove è possibile, attraverso una scheda di selezione, filtrare solo le chiamate desiderate; una volta filtrate possono anche essere modificate o eliminate.

La scheda di consultazione permette anche l’inserimento di una chiamata nei rapportini o nel planning, infatti spesso i rapportini sono ore di lavoro fatte per evadere una chiamata o una voce di planning sono ore che verranno fatte per evadere una chiamata.

2.1 Gestione Chiamate

Questa scheda consente la consultazione, l’inserimento e la modifica.

I comandi nella parte alta della scheda rappresentano le varie funzioni legate alla scheda chiamate.

Il comando Navigate permette di spostarsi tra una chiamata ed un’altra e quindi la consultazione dei dati, come il numero che la identifica, la data di inserimento, il cliente e tutti quelli che si possono osservare nella figura sopra.

Attraverso il comando Aggiungi, contraddistinto da un più, è possibile l’inserimento; dal programma viene assegnato un numero alla chiamata che la identificherà, mentre il resto dei campi vengono inizializzati.

Naturalmente sulla correttezza dei dati inseriti vigileranno delle funzioni di controllo che impediranno all’utente di inserire dei dati non coerenti.

Con il comando Richiama, rappresentato da una freccia, si potrà richiamare una chiamata inserita in precedenza ed aggiornarne i dati.

L’operazione di inserimento e modifica verranno salvate attraverso il comando Conferma, in basso alla scheda; se i dati inseriti sono corretti comparirà, come si vede anche dalla figura, una finestra di messaggio che convaliderà l’inserimento.

2.2 Selezione Chiamate

Il problema più frequente che nasce una volta inserita una chiamata, è ritrovarla all’interno delle migliaia inserite precedentemente; questa scheda consente attraverso una selezione dettagliata, di filtrare le chiamate in base: alla data, al cliente, al comune del cliente, al destinatario, al tipo di chiamata, alla priorità, al numero, alla commessa, all’evasione e alla situazione contratto cliente.

La selezione più usata è sicuramente il destinatario e l’evasione, attraverso questa l’utente è in grado di verificare velocemente le chiamate già evase e quelle ancora da evadere, quindi controllare se gli impegni previsti sono stati tutti assolti o se invece per qualche motivo sono ancora da adempiere.

Il comando Esegui, in fondo alla scheda, lancerà la selezione in base ai dati inseriti dall’utente; verrà visualizzata a questo punto, la scheda di Consultazione che verrà trattata nel paragrafo successivo.

2.3 Consultazione Chiamate

Questa è la scheda risultato di una selezione fatta nella scheda Selezione; in questo caso sono state considerate le chiamate inevase, degli ultimi mesi, del destinatario CR.

Attraverso il comando Navigate, è possibile spostarsi all’interno della lista, quindi selezionare una determinata chiamata e consultarne i dati nei campi a destra e la descrizione nell’ Editor sotto.

Una volta selezionata la chiamata, si può evadere velocemente con il comando Evadi, contraddistinto da un segno di spunta blu; questo comando caricherà nel campo Data di evasione la data odierna e la chiamata risulterà evasa, alle successive selezioni.

Il comando Modifica, caratterizzato da una mano che scrive, lancerà la scheda di Inserimento, vista precedentemente, in modalità modifica; a questo punto sarà possibile variare tutti i dati, tranne naturalmente il numero chiamata rigorosamente gestito dal programma.

I comandi col segno più, rappresentano i collegamenti con Planning e Rapportini.

Attraverso il primo, foglio bianco, è possibile usare una chiamata per creare una riga di Planning, questa operazione sarà segnalata dal campo della griglia Plann, in questo modo all’utente è sempre chiaro se la chiamata è già stata inserita nel piano di lavoro o no.

Il comando Rapportini, foglio a righe, crea un rapportino partendo dai dati in comune con la chiamata, quindi il destinatario, il cliente, la commessa e la descrizione; naturalmente una volta caricati i dati sono sempre aggiornabili dall’utente.

I comandi Elimina,Stampa ed Esci completano le funzionalità possibili all’interno di questa scheda.

Il primo elimina una chiamata, essendo questa un’operazione molto delicata sarà condizionata da una conferma finale.

Il secondo lancia una stampa della chiamata o della lista in griglia, il terzo è il comando attraverso il quale si chiude la scheda.

Capitolo 6

Documentazione del SoftWare

In questo capitolo verrà illustrata la parte software del progetto, quindi gli strumenti attraverso i quali è stato possibile sviluppare il progetto.

La prima parte del capitolo descrive l’ambiente di sviluppo, quindi lo strumento attraverso il quale è stato sviluppato il codice che caratterizza il progetto; per codice si intende l’insieme di istruzioni che compongono il gestionale.

Sempre nel primo paragrafo viene anche affrontata la gestione dei dati, quindi l’interfaccia con il programma e il formato degli archivi.

Successivamente verrà presentata la programmazione Object-Oriented, sulla quale si basa l’ambiente di sviluppo usato per la progettazione di WinLavori.

Nella terza parte vengono illustrati gli Oggetti e i Comandi principali utilizzati all’interno di WinLavori, quindi quei componenti messi a disposizione dall’ambiente di sviluppo o progettati appositamente per il progetto che svolgono determinate funzioni base, come l’inserimento o l’eliminazione di una riga in una griglia.

Infine vengono riportate parti del codice più significativo che caratterizzano gli Oggetti, i Comandi e di conseguenza l’intero gestionale.

6.1.1. Ambiente di Sviluppo

Il progetto è stato sviluppato attraverso DB2k un’ evoluzione di Visual Dbase della Borland, un ambiente orientato agli Oggetti e ai Database.

DB2k è un ambiente di sviluppo (RAD) per la creazione di potenti applicazioni database client/server.

Le funzioni più importanti sono un insieme di strumenti interattivi estremamente flessibili per l’amministrazione del database e un modello evoluto di programmazione orientato agli oggetti.

Questo ambiente include il motore di database Borland Database Engine (BDE), che consente di connettersi in modo semplice alle tabelle Dbase e fornisce il supporto nativo per Paradox, Access, FoxPro ed in generale, il supporto per qualsiasi sorgente dati supportata da ODBC.

La particolarità più interessante di questo ambiente, come per tutti gli ambienti ad oggetti, è la semplicità e la rapidità con la quale è possibile sviluppare gestionali anche complessi, senza sacrificare l’affidabilità e le prestazioni del progetto; questo è permesso dalla possibilità di sfruttare Oggetti o Classi limitando al massimo le righe di codice.

La figura sopra rappresenta il book del centro di controllo di Dbase, attraverso questo il programmatore può controllare progetti, schede, report, programmi, tabelle, sql, moduli, immagini e tutto quello che è legato all’ambiente di sviluppo.

Nell’esempio vediamo la pagina schede; in questa pagina sono raccolte tutte le schede che sono state descritte nei capitoli precedenti.

Col doppio Click su SenzaNome viene creata una scheda che il programmatore andrà a sviluppare secondo le proprie esigenze.

Come visto in precedenza le schede sono molto simili tra di loro, si può notare che spesso hanno molti comandi in comune come i Aggiungi, Modifica, Navigate; Dbase permette di progettare delle Classi, quindi delle schede basi, che raccolgono tutte le funzioni in comune a schede di un certo tipo.

A questo punto quando si crea una nuova scheda, invece di partire da una scheda vuota, è possibile partire da una Classe e quindi evitare di sviluppare tutto quello che è già stato fatto in precedenza per un’altra scheda dello stesso tipo.

In questo modo spesso, invece di sviluppare interamente una scheda, basta personalizzarla secondo le proprie esigenze, quindi risparmiare tutto il tempo impiegato precedentemente nella progettazione della Classe; in teoria è possibile creare delle schede senza scrivere una riga di codice.

Una Classe può essere una scheda, come visto sopra, ma può essere anche un qualsiasi altro Oggetto o Comando; in sostanza una Classe non è altro che un componente, caratterizzato da proprietà, metodi ed eventi, che svolge delle funzioni base e quindi riutilizzabile spesso all’interno di un progetto.

Una Classe può essere confusa con un programma o una procedura; una classe non è codice eseguibile, ma un modello di un determinato componente.

Come si può capire, lo studio e la corretta progettazione delle Classi è fondamentale, lavorare bene in questa fase, vuol dire ottenere il massimo dall’ambiente di sviluppo in termini di tempi e prestazioni; per intenderci, una sbagliata progettazione delle Classi sarebbe come costruire una casa usando mattoni difettosi o inadeguati.

Le Classi e gli Oggetti sono alla base della programmazione Object-Oriented che verrà illustrata nel paragrafo successivo.

6.1.2. Programmazione Object-Oriented

Muoversi nella programmazione Object-Oriented, é spesso difficile anche per programmatori esperti.

Prima di OO, imparare un nuovo linguaggio, consisteva soltanto nell'impadronirsi della nuova sintassi; OO richiede molto più, un maggiore sforzo nel modo di immaginare i programmi ed il relativo codice.

Il processo di apprendimento non é dei più semplici, ma i benefici sono talmente enormi, da compensare il tempo impiegato ad imparare questa nuova metodologia di programmazione.

Visual dBase ha una delle più semplici, ed allo stesso tempo più eleganti implementazioni, di OO; è la piattaforma giusta, per il primo progetto Object-Oriented.

Che cosa è Object-Oriented

OO è una metodologia di programmazione, che fa uso di Oggetti. Gli oggetti si possono definire come delle entità, che sono caratterizzati da determinati attributi (proprietà) e determinati comportamenti (metodi).

Quali differenze con le architetture di programmazione precedenti ?

Le architetture precedenti usavano metodi procedurali, i programmi cominciavano dal punto "A", andavano al punto "B" e ritornavano al punto "A".

L'interfaccia utente, era basata, su una struttura a menu gerarchico; l'utente utilizzava il programma, tramite menu innestati e tornava indietro, utilizzando il tasto <ESC> o qualche altro tasto, predefinito dal programma.

In OO, gli oggetti, sono eseguiti, creati, attivati ed il controllo e nelle mani dell'utente finale, non esiste un modo obbligato per muoversi nel programma.

Ciascun oggetto, ha la propria vita indipendente da tutti gli altri oggetti.

Perchè Object-Oriented

Il beneficio principale, che OO offre al programmatore, è la possibilità di riutilizzare gli oggetti.

Se ben progettati, gli oggetti possono essere riutilizzati, in qualsiasi programma senza adattamenti; gli oggetti non richiedono dichiarazione di variabili, chiamate a procedure, ecc.

Teoricamente, si potrebbe scrivere interi programmi, con poco o addirittura nessun codice; basterebbe combinare gli oggetti insieme a poche proprietà e avere già una applicazione eseguibile.

All’Utente, i programmi sviluppati con OOP, danno diverse possibilità.

Ciascun utente, può personalizzare il programma per adattarlo al proprio ambiente di lavoro, tramite la selezione degli oggetti, in funzione del proprio compito e delle proprie abitudini, e non secondo uno schema rigido condizionato da un menu gerarchico.

Concetti Object-Oriented

La programmazione OO, è basata su una manciata di concetti chiave, indispensabili per arrivare ad una corretta progettazione di classi ed oggetti effettivamente riutilizzabili.

Incapsulare

Non si può intervenire sul controllo degli oggetti da parte dell’ utente. Non è possibile sapere quanti oggetti, di quale genere, l’ utente visualizzerà sullo schermo in un dato momento.

Il migliore modo per assicurare che tutto lavorerà insieme, malgrado le scelte dell'utente, è garantire che ogni oggetto sarà indipendente; ciascun oggetto, deve contenere tutti i suoi dati e le sue procedure, ed essere completamente isolato da ogni altro oggetto.

Un oggetto non si deve sovrapporre ad un altro sia fisicamente che contettualmente, spesso, infatti, gli oggetti usano dati che possono confondersi dando vita a dei malfunzionamenti.

Può succedere, ad esempio, che una procedura di un oggetto vada in esecuzione con i dati di un altro oggetto.

Quando si parla di dati non ci si riferisce al database, ma ai dati memorizzati nelle proprietà dell’oggetto; è importante isolare questi dati.

L’incapsulamento non è altro che la procedura di isolamento che permette all’oggetto di essere indipendente.

Ereditarietà

Gli oggetti, hanno la capacità di ereditare attributi (proprietà) e comportamenti (metodi), da altri oggetti.

Questo è un aspetto delicato, dal punto di vista del riutilizzo; per riutilizzo si intende, la capacità di modificare un oggetto in una specifica applicazione, senza doverlo riscrivere.

Si supponga, per esempio, di creare un oggetto Automobile; esso possiede alcune proprietà (come i pneumatici, il motore ecc) ed alcuni comportamenti (partenza,frena, fai il pieno ecc) che possono essere ereditabili.

Infatti, usando OO, è possibile creare un nuovo oggetto, chiamato Elicottero derivato da Automobile. Il nuovo oggetto Elicottero, possiede tutte le proprietà ed i comportamenti di Automobile, con in più alcune proprietà (rotore) ed alcuni comportamenti (decolla) specifici, ovviamente ad un elicottero.

Si dice che Elicottero ha ereditato le proprietà (pneumatici, motore) ed i comportamenti (parti,arresta) da Automobile.

Tramite l'eredità, la produttività viene enormemente migliorata; usando OO, non è necessario reinventare la ruota.

Polimorfismo

Gli oggetti, possono modificare i comportamenti e le proprietà che hanno ereditato.

L'oggetto figlio, può ridefinire i comportamenti Parti e Arresta di Automobile, più opportunamente per Elicottero, cambiando questi comportamenti in Decolla e Atterra.

Il Polimorfismo che letteralmente significa, forme multiple, migliora il riutilizzo degli oggetti.

Non si deve scartare a priori, che l'oggetto Automobile possa essere genitore per l'oggetto Elicottero, solo perché le proprietà Parti e Arresta di Automobile non descrivono accuratamente il comportamento di Elicottero.

6.1.2. Gestione Dati

La gestione dei dati è sicuramente il fondamento della progettazione di un software gestionale.

Assieme a Dbase viene distribuito il motore di database Borland Database Engine (BDE), che consente di connettersi in modo molto semplice alle tabelle Dbase e fornisce il supporto nativo per Paradox, Access, FoxPro e supporta i formati di Server Database più diffusi come Oracle, Sql Server, Interbase ed in generale qualsiasi sorgente dati supportata da ODBC.

Per la memorizzazione dei dati del progetto sono state utilizzate le tabelle standard di Dbase (.DBF), quindi il motore BDE non si connetterà ad un vero Database, ma ad una directory che conterrà tutte le tabelle DBF.

Queste tabelle non permettono di sfruttare tecniche come Transazioni, Trigger o Stored Procedures, ma garantiscono comunque una buona affidabilità e buone prestazioni; inoltre non comportano ulteriori spese, per l’acquisto di licenze, da parte del cliente.

L’ interazione coi dati non è implementata interamente in un DBMS (DataBase Management Systems), quindi le prestazioni di un buon gestionale Client/Server saranno vincolate a caratteristiche hardware, come una attenta manutenzione della rete, alle dimensioni delle tabelle e al numero di utenti.

6.2. Oggetti e Comandi

Oggetto Scheda

Oggetto che viene utilizzato per contenere altri oggetti utili, in genere, alla gestione di una particolare voce di menù; in sostanza è l’oggetto base su cui verranno progettate tutte le schede.

Oggetto Pannello

Questo Oggetto viene usato per accorpare campi utili ad un’unica funzione.

Oggetto Book

Oggetto utilizzato spesso all’interno di schede per visualizzare dati, ha la caratteristica di poter disporre di diverse pagine per separare i dati in base alle varie funzionalità.

Oggetto Griglia

Oggetto attraverso il quale vengono visualizzate delle liste di dati.

Comando Aggiungi

In genere il comando Aggiungi viene utilizzato per inserire nuove righe in griglia e quindi in tabella, porta la scheda dallo stato di consultazione allo stato di inserimento.

Comando Navigate

Navigate permette di scorrere la selezione della riga in griglia o comunque di scorrere i dati all’interno della lista.

Comando Modifica

Questo comando porta la scheda dallo stato di consultazione a quello di Modifica, quindi permette la variazione dei dati già inseriti in precedenza.

Comando Salva

Attraverso questo comando vengono salvati i dati inseriti e la scheda viene riportata allo stato di consultazione.

Comando Abbandona

Abbandona riporta la scheda allo stato di consultazione, annullando tutte le modifiche fatte ai dati.

Comando Elimina

Tramite Elimina è possibile eliminare dati, nel caso di una scheda con griglia verrà eliminata la riga attualmente selezionata; questa operazione è possibile farla solo in fase di consultazione.

Comando Copia

Copia porta la scheda in stato di modifica e crea una copia della riga attualmente selezionata in griglia.

Comando Stampa

Attraverso questo comando è possibile stampare i dati opportunamente selezionati, questa operazione è possibile farla solo in stato di consultazione.

Comando Esegui

Esegui è il comando che in ogni scheda lancia il filtro dei dati e carica la griglia, in genere esegue sempre una funzione caratteristica della scheda.

Comando Esci

Tramite questo comando è possibile uscire dalla scheda, l’uscita è consentita solo in fase di consultazione; quindi prima di uscire è necessario abbandonare o salvare i dati.

6.3. Codice Sviluppato più significativo

Il codice è sviluppato all’interno di ogni scheda, questo è strutturato in funzioni associate ad eventi, come può essere l’apertura di una scheda o il click su un comando.

Queste funzioni possono essere di uso interno alla scheda o di uso generale.

Se di uso interno sono visibili e quindi utilizzabili solo all’interno della scheda, mentre quelle di uso generale sono contenute in una classe S2Funzio.CC e quindi utilizzabili da qualsiasi scheda del progetto; di seguito verranno riportate alcune delle principali funzioni utilizzate nel progetto.

La funzione Cod2dati

Questa funzione è usata per ottenere dei dati da una tabella, passando come parametri nome e indice tabella, questa provvederà a restituire il dato richiesto; è una funzione ad uso generale, quindi contenuta in S2Funzio.CC

*------------------------------------------------------------------------------

FUNCTION COD2DATI (cFile,cIndex,xChiave,bVar,lFound,cFilter)

*------------------------------------------------------------------------------

* se trova xChiave in cFile tramite cIndex (se c'è) valuta bVar e restituisce .T.

* altrimenti non valuta bVar (o lo valuta se lfound=true) e restituisce .F.

* è possibile applicare un filtro (cfilter)

*------------------------------------------------------------------------------

LOCAL qArchivio,rArchivio,nI,lRet,lTrovato

lRet = false

PRIVATE cTemp

// controllo che apertura vada a buon fine altrimenti restituisco false

try

d = new S2DB()

d.active := true

qArchivio = new Query()

qArchivio.sql = "select * from " + cFile + ".dbf"

qArchivio.database = d

qArchivio.active = true

rArchivio = qArchivio.rowset

cTemp = cFilter

IF TYPE("cTemp") = "C"

rArchivio.filter = cFilter

ENDIF

cTemp = cIndex

IF TYPE("cTemp") = "C"

rArchivio.indexname = cIndex

lTrovato = rArchivio.FindKey(xChiave)

ELSE

lTrovato = rArchivio.ApplyLocate(xChiave)

ENDIF

catch (Exception e)

MsgBox( cFile + chr(10) + e.message,"Attenzione!",16 )

return false

endtry

IF lTrovato

lRet = true

ENDIF

cTemp = bVar

IF TYPE("cTemp") = "CB"

IF lFound .OR. lTrovato

for nI=1 to rArchivio.Fields.size

cTemp = rArchivio.Fields[nI].fieldname

&cTemp = rArchivio.Fields[nI].value

if not ltrovato

do case

case rArchivio.Fields[nI].type = "C"

&cTemp = space(rArchivio.Fields[nI].length)

case rArchivio.Fields[nI].type = "N"

&cTemp = 0

case rArchivio.Fields[nI].type = "D"

&cTemp = ctod("")

endcase

endif

release cTemp

bVar()

ENDIF

// chiudo e rilascio la query temporanea...

rArchivio.abandon(); qArchivio.active = false;rele obje qArchivio

RETURN lRet

La funzione Controllo

Questa è una funzione ad uso interno, quindi è contenuta all’interno della scheda ;

attraverso Controllo è verificata la correttezza dei dati inseriti.

*------------------------------------------------------------------------------

FUNCTION CONTROLLO

*------------------------------------------------------------------------------

local cdesc,ccli,cdest,ccomm,cmotivo1,cmotivo2,cmotivo3,cmotivo4,cmotivo5,cmotivo6,cmotivo7

cdesc=""

do case

CASE this.name = "FLD_OPERATORE"

if not empty(this.value)

if not cod2dati("OPERATOR","OPERATOR",LEFT(_app.kazi,2)+transform(this.value,"!!"),{; cDesc = nome})

this.validerrormsg = "L'operatore inserito non esiste !!!"

return false

else

form.fld_descoper.value = cdesc

endif

else

form.fld_descoper.value=""

endif

CASE this.name = "FLD_CLIENTE"

if not empty(this.value)

if not cod2dati("ANACLI","ANACLI",LEFT(_app.kazi,2)+"C"+str(this.value,5),{; cDesc = RAGSOC})

this.validerrormsg = "Il cliente inserito non esiste !!!"

return false

else

form.fld_desccli.value=cdesc

endif

else

form.fld_desccli.value=""

endif

CASE this.name = "FLD_TIPORAPP"

if not empty(this.value)

if not cod2dati("OPERAZIO","OPERAZIO",LEFT(_app.kazi,2)+transform(this.value,"!!"),{; cDesc = nome})

this.validerrormsg = "Il Tipo di Rapportino inserito non esiste !!!"

return false

else

form.fld_destipo.value = cdesc

endif

else

form.fld_destipo.value=""

endif

CASE this.name = "FLD_DACOMM"

if not empty(this.value)

if not cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(this.value,5),{; cDesc = note})

this.validerrormsg = "La commessa inserita non esiste !!!"

return false

else

form.fld_desdacom.value = cdesc

endif

else

form.fld_desdacom.value=""

endif

CASE this.name = "FLD_ACOMMESSA"

if not empty(this.value)

if not cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(this.value,5),{; cDesc = note})

this.validerrormsg = "La commessa inserita non esiste !!!"

return false

else

form.fld_descom.value = cdesc

endif

else

form.fld_descom.value=""

endif

CASE this.name = "FLD_CLI"

if not empty(this.value)

if not cod2dati("ANACLI","ANACLI",LEFT(_app.kazi,2)+"C"+str(this.value,5),{; cDesc = RAGSOC})

this.validerrormsg = "Il cliente inserito non esiste !!!"

return false

else

form.book1.fld_desclidet.value=cdesc

endif

else

form.book1.fld_desclidet.value=""

endif

CASE this.name = "FLD_COMMESSA"

if not empty(this.value)

if not cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(this.value,5),{; cDesc = note})

this.validerrormsg = "La commessa inserita non esiste !!!"

return false

else

form.book1.fld_descomdet.value = cdesc

endif

else

form.book1.fld_descomdet.value=""

endif

CASE this.name = "FLD_OPER"

if not empty(this.value)

if not cod2dati("OPERATOR","OPERATOR",LEFT(_app.kazi,2)+transform(this.value,"!!"),{; cDesc = nome})

this.validerrormsg = "L'operatore inserito non esiste !!!"

return false

else

form.book1.fld_desoperdet.value = cdesc

endif

else

form.book1.fld_desoperdet.value=""

endif

CASE this.name = "FLD_DATA"

form.ultimadata=this.value

CASE this.name = "FLD_NCHIAM"

if not empty(this.value)

cmotivo1=""

cmotivo2=""

cmotivo3=""

cmotivo4=""

cmotivo5=""

cmotivo6=""

cmotivo7=""

ccli=0

cdest=0

ccomm=0

if not cod2dati("CHIAMATE","CHIAMNUM",str(this.value,5),{; cmotivo1 = motivo1; cmotivo2 = motivo2; cmotivo3 = motivo3; cmotivo4 = motivo4; cmotivo5 = motivo5; cmotivo6 = motivo6; cmotivo7 = motivo7; ccli=codcli; cdest=coddest1; ccomm=commessa})

this.validerrormsg = "La chiamata non esiste !!!"

return false

else

if (form.rowset.state=2) or (form.rowset.state=3)

if not empty(cdest)

form.book1.fld_oper.value=cdest

cdesc=""

cod2dati("OPERATOR","OPERATOR",LEFT(_app.kazi,2)+form.book1.fld_oper.value,{; cDesc = nome})

form.BOOK1.fld_desoperdet.value=cdesc

endif

if not empty(ccli)

form.book1.fld_cli.value=ccli

cdesc=""

cod2dati("ANACLI","ANACLI",LEFT(_app.kazi,2)+"C"+str(form.book1.fld_cli.value,5),{; cDesc = RAGSOC})

form.BOOK1.fld_desclidet.value=cdesc

endif

if not empty(ccomm)

form.book1.fld_commessa.value=ccomm

cdesc=""

cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(form.book1.fld_commessa.value,5),{; cDesc = note})

form.book1.fld_descomdet.value=cdesc

endif

form.book1.s2custeditor1.value = cmotivo1+cmotivo2+cmotivo3+cmotivo4+cmotivo5+cmotivo6+cmotivo7

endif

form.book1.edit_chiam.value = cmotivo1+cmotivo2+cmotivo3+cmotivo4+cmotivo5+cmotivo6+cmotivo7

endif

else

form.book1.edit_chiam.value=""

endif

endcase

return true

La funzione Ricerca

Ricerca è una funzione ad uso interno, quindi è contenuta all’interno della scheda; tramite questa funzione è possibile eseguire tutte le ricerche, alfabetiche e libere, all’interno della scheda.

*------------------------------------------------------------------------------

FUNCTION RICERCA ( cTipoRicerca )

*------------------------------------------------------------------------------

local cdesc

local l

private form; form = _app.oForm

private cCod_Ritorno // privata per il Type()

local cCampo

cCampo = form.cCampoAttivo

if cCampo $ "FLD_CLIENTE-BOOK1.FLD_CLI"

if cTipoRicerca = "A"

l = new CliforRaForm()

elseif cTipoRicerca = "L"

l = new CliforRlForm()

else

return

endif

l.cClifor = "C"

elseif cCampo $ "FLD_OPERATORE-BOOK1.FLD_OPER"

l = new NewTabForm()

l.text = "Tabella Operatori"

l.TabSql = 'select CODICE,NOME,CODICE from "OPERATOR" '+;

'where codazi="'+left(_app.kazi,2)+'" '

l.TabInd = 'OPERATOR'

l.NomeForm = "Operat"

elseif cCampo $ "FLD_TIPORAPP-BOOK1.FLD_TIPO"

l = new NewTabForm()

l.text = "Tabella Tipo Rapportini"

l.TabSql = 'select CODICE,NOME,CODICE from "OPERAZIO" '+;

'where codazi="'+left(_app.kazi,2)+'" '

l.TabInd = 'OPERAZIO'

l.NomeForm = "OPERAZ"

elseif cCampo $ "FLD_DACOMM-FLD_ACOMM-BOOK1.FLD_COMMESSA-FLD_ACOMMESSA"

l = new NewTabForm()

l.text = "Tabella Tipo Commesse"

l.TabSql = 'select NRCOM,NOTE,NRCOM from "COMMES" '+;

'where codazi="'+left(_app.kazi,2)+'" '

l.TabInd = 'COMMES'

l.NomeForm = ""

else

return

endif

l.mdi = false

l.menufile = ''

l.cCod_Ritorno = null

l.readmodal()

cCod_Ritorno = l.cCod_Ritorno

if not empty(l)

l.release(); l = null

endif

// passo a una variabile privata per macro

cTemp = cCampo

cstringa = "form."+cTemp+".setfocus()"

&cstringa

cdesc=""

if cCod_Ritorno # null

If cCampo == "FLD_OPERATORE"

form.FLD_OPERATORE.value = cCod_Ritorno

//class::Descrizione(form.FLD_OPERATORE,form.fld_descoper)

form.FLD_OPERATORE.keyboard( chr(13) )

elseif ccampo="BOOK1.FLD_OPER"

form.book1.FLD_OPER.value = cCod_Ritorno

cod2dati("OPERATOR","OPERATOR",LEFT(_app.kazi,2)+cCod_Ritorno,{; cDesc = nome})

form.book1.fld_desoperdet.value = cdesc

//class::Descrizione(form.BOOK1.FLD_OPER,form.book1.fld_desoperdet)

form.book1.FLD_OPER.keyboard( chr(13) )

elseif cCampo == "FLD_TIPORAPP"

form.FLD_TIPORAPP.value = cCod_Ritorno

//class::Descrizione(form.fld_TIPORAPP,form.FLD_DESTIPO)

form.FLD_TIPORAPP.keyboard( chr(13) )

elseif ccampo="BOOK1.FLD_TIPO"

form.book1.FLD_tipo.value = cCod_Ritorno

cod2dati("OPERAZIO","OPERAZIO",LEFT(_app.kazi,2)+cCod_Ritorno,{; cDesc = nome})

form.book1.fld_destipdet.value = cdesc

//class::Descrizione(form.book1.fld_TIPO,form.book1.FLD_DESTIPdet)

form.book1.FLD_tipo.keyboard( chr(13) )

elseif cCampo == "FLD_DACOMM"

form.FLD_DACOMM.value = cCod_Ritorno

form.FLD_DACOMM.keyboard( chr(13) )

elseif cCampo = "FLD_ACOMMESSA"

form.FLD_ACOMMESSA.value = cCod_Ritorno

cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(cCod_Ritorno,5),{; cDesc = note})

form.fld_descom.value = cdesc

form.FLD_ACOMMESSA.keyboard( chr(13) )

elseif ccampo = "BOOK1.FLD_COMMESSA"

form.book1.FLD_COMMESSA.value = cCod_Ritorno

cod2dati("COMMES","COMMES",LEFT(_app.kazi,2)+str(cCod_Ritorno,5),{; cDesc = note})

form.book1.fld_descomdet.value = cdesc

form.book1.FLD_commessa.keyboard( chr(13) )

elseif ccampo= "BOOK1.FLD_CLI"

form.book1.FLD_cli.value = val(substr(cCod_Ritorno,4,5))

cod2dati("ANACLI","ANACLI",cCod_Ritorno,{; cDesc = RAGSOC})

form.book1.fld_desclidet.value=cdesc

form.book1.FLD_cli.keyboard( chr(13) )

elseIF CCAMPO=="FLD_CLIENTE"

form.FLD_CLIENTE.value =val(substr(cCod_Ritorno,4,5))

form.FLD_CLIENTE.keyboard( chr(13) )

endif

return

INDICE

Capitolo 1 Clienti 6

1.1. Gestione Clienti

Capitolo 2 Chiamate 16

Capitolo 3 Rapportini 21

Capitolo 4 Commesse 25

Capitolo 5 Planning 29

Capitolo 6 Documentazione del SoftWare 34

Conclusioni

Introduzione

Clienti

Eliminazione Cliente

Ricerca Cliente

Questa scheda ha la possibilità di posizionarsi su un determinato cliente essenzialmente in due modi: sequenziale e diretto.

Il modo sequenziale permette all’utente di scorrere i clienti in base ad un ordine dato dal codice tramite il comando Navigate, mentre il modo diretto permette di arrivare al cliente voluto in modo immediato, quindi senza scorrerli tutti.

Se si è a conoscenza del codice è possibile attraverso l’apposito campo richiamare il cliente col tasto Invio, altrimenti sarà possibile richiamarlo grazie al comando Ricerca indicato dalla freccia in figura; la selezione del cliente è permessa solo in fase di consultazione della scheda.

Chiamate

Conclusioni