UNIVERSITÀ DEGLI STU DI DI TRIESTE DIPARTIMENTO DI ARCH ITETTURA E INGEGNERIA

C ORSO DI L AUREA MA GISTRAL E IN IN GEGN ERIA INFOR MA TICA

PROGETTAZIONE E SVILUPPO DI UN PLUGIN PER LA GESTIONE DELLE CAMPAGNE

PUBBLICITARIE BASATO SULLA TECNOLOGIA DI GOOGLE ADWORDS

LAUREANDA

NASI Mariela

RELATORE

Rettore dell’Università degli Studi di Trieste

Chiar.mo Prof. FERMEGLIA Maurizio

CORRELATORI

Ing. SARDON Diego

Senior Developer MORETTO Carlo

Anno Accademico 2015 – 2016

2

A Kozeta,

…alla guerriera.

3

RINGRAZIAMENTI

...c’è sempre poco spazio per riportare tutto e tutti in una pagina di ringraziamenti, mancano sempre

delle parole per esprimere pienamente la gratitudine. Prima di tutti, vorrei ringraziare il mio relatore, il

professore Maurizio Fermeglia, rettore dell’Università degli Studi di Trieste. Devo tanto a lui, tanta

sicurezza acquisita, tante opportunità, tante esperienze nuove e soprattutto tanta fiducia. Nella vita

bisogna saper motivare ed essere motivati. E lui è stata una delle persone che ha saputo motivarmi

sempre. Se dovessi unire in un’unica parola rispetto, motivazione, innovazione, “se pol”, direi

decisamente Fermeglia.

Ringrazio il mio correlatore Diego Sardon per avermi dato l’opportunità di lavorare con lui e per

contagiarmi la sua voglia di innovazione, il mio caro amico/correlatore Carlo per essere stato un bravo

capo, per insegnarmi tante cose e segreti del mestiere e per condividere insieme a me una grande

passione chiamata “sushi”.

Ringrazio mia mamma Helena, la mia guerriera, la persona che non ha mai smesso di dirmi “mi fido di

te”, “tu sempre puoi”, parole che hanno fatto crescere in me una fiducia infinita che mi ha aiutata a non

mollare mai. Ringrazio il mio fratellino Dodi, che anche se non fratelli di sangue, lui è “i bukur i Miçit”

(bello di Miçi), il miglior complice di sempre, Katerina, la mia bella piccola sorellina che ha una purezza

d’anima infinita, Zisi, il mio fratello del cuore, il mio orgoglio. Ringrazio mia nonna Kozeta, la guerriera

delle guerriere, quella che ci sarà sempre anche se non più fisicamente. Ringrazio mio nonno Andon,

un uomo ideale, per insegnarmi l’importanza del silenzio e per la sua saggezza che non ha prezzo.

Ringrazio mia zia, Alma, per essermi stata sempre vicina e per prendersi cura dei miei dentini.

Ringrazio mio zio Edi per farmi sentire protetta e per volermi bene come ad una figlia. Ringrazio mia

bisnonna Marjeta che mi protegge dal cielo e che so che è sempre orgogliosa di me. Ringrazio Ornela,

la mia sorella per scelta e amica del cuore, per esserci sempre e per aiutarmi a diventare una persona

migliorare. Ringrazio la mia prof. Mirela per avermi insegnato che nessuna sfida per quanto grande sia

non ti deve mai spaventare. Ringrazio il compagno di mia mamma Artur, per essere una persona così

bella e speciale, per insegnarmi tante cose, e per rendere felice mia mamma. Ringrazio Keli e Selim, i

miei nonni per scelta, per avermi riempita di amore, attenzioni e per essersi presi cura di me sempre.

Ringrazio Elvira, Aljon e Viktor per farmi sentire come parte della famiglia, per tutte le deliziose cene e

per essere delle bellissime persone a cui voglio tanto bene.

Ringrazio Ale, la mia amica, collega, complice, per insegnarmi tante cose, ma soprattutto che la vera

amicizia va protetta sempre e per avermi sempre appoggiata nonostante tutto e tutti, Marsi per portare

sempre allegria nelle mie giornate e per essere un’amica vera, Marina per essere una scutarina bella e

dolce e per le belle trecce. Ringrazio Endra, Enrico, Stefano, Sergiu, Regi, Evgenia per aver condiviso

con me momenti importanti in questo percorso.

Ringrazio Desi, Iteng, Anjeza per avermi insegnato che la distanza e il tempo non contano nelle vere

amicizie. Ringrazio Nik, Fede, Erni, Ele, Bidi, Luca, Desi, Sonja, Enrico F., Virgo, Verz per tutte le

bellissime esperienze in EESTEC che ci hanno fatto crescere e per aver imparato assieme che quello

che conta in un team è il suo spirito. Ringrazio Natalia per tutti gli indimenticabili viaggi che abbiamo

fatto e che faremo. Ringrazio i miei colleghi del corso per aver condiviso con me tanti momenti

importanti in questi anni di “fatica”. Grazie a Tom, Eli, Elena per sopportarmi e supportarmi e per essere

i migliori coinquilini di sempre.

4

Inoltre, ringrazio tutti i miei cari colleghi di battaglia Adri, Ema, Raf, Max, Gabri, Andrea, Fred, Gio,

Alessio, Sara e tanti altri per avermi supportata sempre e comunque e per insegnarmi tante cose ogni

giorno. Grazie ad Aggeliki e a Maria Fernanda per essere delle bellissime amiche e per il fantastico trio

che abbiamo creato, grazie al mio sych Vale, ad Andrea C. per essere la sua “amica pigra”, a Ivan e

Marghe per il bellissimo weekend e le feste indimenticabili.

Non vorrei assolutamente dimenticare nessuno. Ognuno di loro ha lasciato un segno di sé e ha preso

qualcosa da me. Nella vita siamo ciò che siamo grazie alle nostre scelte, ma anche grazie alle persone

che incontriamo. Sono orgogliosa delle mie scelte e assolutamente orgogliosa di aver incontrato così

tante belle persone che hanno fatto sì che la mia esperienza a Trieste mi facesse diventare ancora più

ricca.

M.

5

INDICE

1. INTRODUZIONE ........................................................................................................... 8

2. PANORAMICA GENERALE ....................................................................................... 10

2.1 CMS Agenzie ....................................................................................................... 10

2.2 Plugin Google Adwords ........................................................................................ 11

3. ANALISI DEL PROGETTO ........................................................................................ 12

3.1 Analisi degli obiettivi ............................................................................................ 12

3.2 Perché questo plugin? ......................................................................................... 12

3.3 Perché Google Adwords? .................................................................................... 13

4. STRUMENTI UTILIZZATI PER IL PROGETTO ......................................................... 13

4.1 Strumenti Hardware .............................................................................................. 14

4.1.1 PC Notebook Sony Vaio ................................................................................ 14

4.1.2 Server Aziendali ............................................................................................ 15

4.2 Strumenti Software .............................................................................................. 15

4.2.1 Django Framework ........................................................................................ 15

4.2.2 MySQL Workbench ....................................................................................... 16

4.2.3 Git e GitLab ................................................................................................... 16

5. PREPARAZIONE DELL’AMBIENTE DI LAVORO .................................................... 18

5.1 Configurazione dell’ambiente virtuale .................................................................. 18

5.2 Inizializzazione del progetto Django .................................................................... 19

5.3 Configurazione delle impostazioni globali ............................................................ 20

5.4 Configurazione di MySQL .................................................................................... 21

6. SVILUPPO DEL PLUGIN ......................................................................................... 23

6.1 Interfaccia principale ............................................................................................. 23

6.2 Creazione del modello .......................................................................................... 23

6.3 Creazione di forms, views, templates .................................................................. 26

6

7. GOOGLE ADWORDS ................................................................................................. 36

7.1 Richiesta di accesso alle Adwords API ................................................................ 36

7.2 Impostazione delle credenziali ............................................................................. 38

7.3 Accessi alle Adwords API ..................................................................................... 38

8. PANNELLO DI AMMINISTRAZIONE ......................................................................... 41

8.1 Creazione del pannello ........................................................................................ 41

8.2 Creazione di commandi aggiuntivi ....................................................................... 42

9. INTERFACCIA GRAFICA .......................................................................................... 44

10. CONSIGLI E PROCEDURE UTILI ............................................................................. 45

11. CONCLUSIONI .......................................................................................................... 51

12. SITOGRAFIA ............................................................................................................. 52

7

INDICE DELLE FIGURE

FIGURA 4.1 – Sony VAIO VGN-NW21MF ........................................................................ 14

FIGURA 5.1 – Creazione del progetto Django .................................................................. 19

FIGURA 5.2 – Struttura del progetto Django .................................................................... 20

FIGURA 5.3 – Modifiche al file settings.py ........................................................................ 21

FIGURA 5.4 – Modifiche al file urls.py .............................................................................. 21

FIGURA 5.5 – Impostazioni MySQL Workbench .............................................................. 21

FIGURA 5.6 – File settings_local.py ................................................................................. 22

FIGURA 6.1 – Interfaccia principale .................................................................................. 23

FIGURA 6.2 – Modello del database ................................................................................. 24

FIGURA 6.3 – Pannello di MySQL Workbench .................................................................. 26

FIGURA 6.4 – Creazione campagna (1 di 4) .................................................................... 27

FIGURA 6.5 – Creazione campagna (2 di 4) .................................................................... 28

FIGURA 6.6 – File settings_adv.py ................................................................................... 28

FIGURA 6.7 – Creazione campagna (3 di 4) .................................................................... 29

FIGURA 6.8 – Creazione campagna (4 di 4) .................................................................... 30

FIGURA 6.9 – Riepilogo dei dati inseriti ............................................................................ 31

FIGURA 6.10 – Creazione campagna (3 di 4) per annunci multimediali ........................... 32

FIGURA 6.11 – Elenco delle campagne ........................................................................... 33

FIGURA 6.12 – Popup di avviso eliminazione campagna ................................................ 33

FIGURA 6.13 – Pannello dell’annuncio.............................................................................. 33

FIGURA 6.14 – Pulsante Report ....................................................................................... 34

FIGURA 6.15 – Report del CPC ....................................................................................... 34

FIGURA 6.16 – Report delle parole chiave ....................................................................... 34

FIGURA 6.17 – Form di modifica di una campagna .......................................................... 35

FIGURA 7.1 – File urls.py .................................................................................................. 40

FIGURA 8.1 – File admin.py .............................................................................................. 41

FIGURA 8.2 – Login al pannello di amministrazione ......................................................... 41

FIGURA 8.3 – Le tabelle nel pannello di amministrazione ................................................. 42

FIGURA 8.4 – La tabella delle campagne.......................................................................... 42

FIGURA 8.5 – Commandi aggiuntivi .................................................................................. 43

8

1. INTRODUZIONE

La seguente tesi è stata realizzata in collaborazione con l’azienda Prodigys Technology S.r.l. presso la

loro filiale di Trieste. Essa presenta lo sviluppo di un plugin 1 per la gestione delle campagne

pubblicitarie di una serie di Agenzie (per motivi di privacy non viene riportato il nome del cliente, e per

questo utilizzeremo sempre il termine Agenzie).

Il plugin è un’implementazione aggiuntiva al CMS delle Agenzie già esistente. È stato sviluppato con la

piattaforma Django ed è basato sulle tecnologie di Google Adwords, un servizio online di advertising

che permette di inserire spazi pubblicitari all’interno delle pagine di ricerca di Google. Questi annunci

verranno visualizzati in alto, a destra e sotto i risultati di ricerca e verranno selezionati da un algoritmo

che, tra le tante variabili, tiene conto delle parole chiave, le cosiddette keyword, ricercate dall’utente. Il

sistema si basa sul costo per click (CPC), ovvero sulla formula che richiede un esborso da parte di chi

pubblica annunci, solo se l’annuncio viene effettivamente cliccato da un utente.

L’idea per il suo sviluppo è nata dopo aver notato la necessità di uno strumento che potesse

contemporaneamente gestire le campagne pubblicitarie ed attirare più visitatori ai siti delle agenzie. In

questo modo verranno mostrati annunci pertinenti agli scopi dell’utente e correlati ai prodotti in vendita.

Per la realizzazione del plugin è stato necessario attraversare una serie di passaggi:

Studio del linguaggio Python e successivamente della piattaforma Django;

Analisi dettagliata della piattaforma di Google Adwords e del pannello di amministrazione;

Analisi del flusso di creazione delle campagne e semplificazione dei passaggi per rendere il

plugin user-friendly2;

Raccolta dei requisiti del cliente;

Progettazione del plugin, dei passaggi di creazione delle campagne e dell’interfaccia grafica;

Realizzazione del plugin;

Test.

In mercato esistono già plugin basati sulla tecnologia di Google Adwords, però essi si occupano

principalmente di Remarketing3, invece il risultato di questa tesi è interamente basato sulla metodologia

di costo per click.

Nel capitolo 2 si presenta una panoramica generale del CMS Agenzie già esistente e del plugin

realizzato. Nel capitolo 3 si riporta l’analisi degli obiettivi e delle motivazioni della scelta di Google

Adwords come strumento di creazione delle campagne pubblicitarie. Nel capitolo 4 si presentano tutti

gli strumenti hardware e software utilizzati. Il capitolo 5 dà spazio alla preparazione dell’ambiente di

lavoro, alle configurazioni effettuate e all’inizializzazione del progetto. Nel capitolo 6 si presenta la

creazione di tutti gli elementi necessari, quali views, forms, templates, per costruire una prima base del

1 Il plugin è un programma non autonomo che interagisce con un altro programma per ampliarne o estenderne le funzionalità originarie. 2 Tipo di software di facile usabilità. 3 Il remarketing aiuta a raggiungere gli utenti che hanno visitato il sito web. I visitatori precedenti o gli utenti possono vedere gli annunci mentre navigano nei siti web inclusi nella Rete Display di Google o mentre cercano termini correlati ai prodotti o ai servizi su Google.

9

plugin. Il capitolo 7 riporta tutte le configurazioni necessarie per la creazione degli account Google

Adwords e per l’accesso alle Adwords API. Inoltre, questo capitolo presenta anche dei metodi realizzati

per eseguire tutte le operazioni richieste dal plugin. Nel capitolo 8 si fa una presentazione del pannello

di amministrazione di Django e della sua utilità. Nel capitolo 9 si riportano tutti i concetti riguardanti

l’aspetto grafico del plugin. Nel capitolo 10 si presentano una serie di procedure e consigli utili per la

realizzazione di progetti simili. Si è pensato di aggiungere questo capitolo con lo scopo di supportare

tutti gli studenti che utilizzeranno tecnologie e strumenti simili e i quali attraverseranno le stesse

difficoltà e problematiche che sono state riscontrate durante la realizzazione di questo plugin. Il capitolo

11 presenta le conclusioni del lavoro svolto per questa tesi e il capitolo 12 la bibliografia e sitografia

utilizzate come riferimento per lo studio e l’approfondimento di diversi argomenti.

10

2. PANORAMICA GENERALE

2.1. CMS Agenzie

Prima di presentare il plugin sviluppato basandosi sulla tecnologia di Google Adwords, introduciamo il

CMS esistente sul quale, successivamente, viene implementato questo plugin.

Il CMS è stato sviluppato utilizzando la piattaforma Django, un web framework4 open source5 per lo

sviluppo di applicazioni web, scritto in linguaggio Python, seguendo il design pattern6 Model-View-

Controller. Vedremo ulteriori dettagli nel capitolo 3.

Il CMS in produzione permette alle Agenzie, tramite la scelta di template, la costruzione di un sito per

ogni Agenzia monomandataria.

Per l’autenticazione sono state prodotte delle utenze generata ad hoc: per ogni agenzia è stata

generata una utenza singola. L’utenza permette alla singola agenzia di caricare i contenuti

personalizzati e quindi di vedere solo la parte di CMS dedicata al proprio sito.

Si definisce che il sito delle singole agenzie si compone di una struttura standard di pagine secondo la

seguente alberatura:

Home page (qui l’agenzia può selezionare, da una lista predefinita, i prodotti da mettere in

home page. Il link al prodotto rimanda alla corrispondente pagina sul sito principale)

Pagina Chi siamo, con la storia dell’agenzia, i nominativi e le foto degli agenti da contattare.

Pagina Dove siamo (integrazione con il Geolocator e campo note in cui si esplicitano eventuali

indicazioni stradali e riferimenti per raggiungere l’agenzia, orari e giorni di apertura)

Pagina Convenzioni (contiene la lista con le convenzioni locali e nazionali)

Altre sedi contiene le informazioni di posizione e contatto delle sub-agenzie. Nel caso la sub-

agenzia abbia una certa rilevanza, è possibile anche avere una pagina di dettaglio della sub-

agenzia, con anche le informazioni relative al personale e il form di contatto

Form di contatto. In questa funzionalità si dettaglia:

Ogni compilazione del form genera una mail ad un solo indirizzo e-mail che è stato

indicato in fase di costruzione del sito

Il soggetto della mail riporta il motivo di contatto fleggato nel form

La compilazione del form genera due mail: una al cliente come conferma della

compilazione del form e una all'agenzia

Il sito non ha un database di storage dei form compilati

4 È un'architettura logica di supporto su cui un software può essere progettato e realizzato. 5 In informatica, è un software non protetto da copyright e liberamente modificabile dagli utenti. 6 Si tratta di uno schema di progettazione, è un concetto che può essere definito come "una soluzione progettuale generale ad un problema ricorrente"

11

Il CMS comprende anche le seguenti funzionalità:

Sito multilingua

Sezione news

Versione mobile

Manutenzione (qualsiasi modifica o aggiornamento del sito post rilascio online)

Eventuali skin o template diversi da quelli già censiti

2.2. Plugin Google Adwords

Il plugin basato su Google Adwords dà la possibilità alle singole agenzie di creare delle campagne

pubblicitarie tramite una procedura guidata. Ogni campagna può avere uno o più annunci relativi ai vari

prodotti o servizi offerti dalle agenzie. Le campagne hanno una data di inizio, una data di fine, un

budget e una serie di specifiche che vedremo in dettaglio nel capitolo 5.

Gli annunci possono essere di tipo testuale oppure multimediale. Gli annunci testuali hanno un titolo,

due righe di descrizione e il link all’agenzia. Gli annunci multimediali invece hanno un titolo e

un’immagine.

Ad ogni annuncio vengono associate delle parole chiave, tramite le quali i prodotti o servizi pubblicizzati

potranno essere molto più facilmente reperibili nell’ambiente web. Ogni parola chiave ha un costo per

click (nel capitolo 5 vedremo cosa riferisce).

Il plugin riporta una pagina contenente l’elenco delle campagne, organizzata in tre menu principali:

campagne in corso, campagne future, campagne terminate. Per ogni campagna vengono riportate le

specifiche e tutti gli annunci ad essa associati. Per ogni annuncio vengono riportate le specifiche e tutte

le parole chiave con i rispettivi costi per click.

Il plugin ti permette di modificare o eliminare le campagne pubblicitarie esistenti.

Tramite la voce Report è possibile visualizzare i risultati della campagna negli ultimi 7 giorni. La voce

riporta due sotto elementi, Report CPC e Report Keyword che rappresentano rispettivamente i grafici di

efficienza dei cost per click e impressioni, e delle parole chiave.

12

3. ANALISI DEL PROGETTO

3.1. Analisi degli obiettivi

Gli obiettivi principali di questo plugin sono:

A. Raggiungere un maggior numero di clienti: attirare nuovi

visitatori sul portale dell’agenzia, incrementare le vendite online,

ricevere più telefonate oppure fidelizzare i propri clienti.

B. Raggiungere il pubblico giusto al momento giusto: Gli utenti

trovano l’attività commerciale proprio mentre cercano su Google i prodotti o i servizi che l’agenzia

offre.

C. Fare pubblicità a livello locale o globale: raggiungere i clienti di determinati paesi, aree geografiche

o città, oppure quelli che si trovano nelle vicinanze dell’agenzia.

In linee più generali, chi decide di creare una campagna online, avrebbe come obiettivo quello di:

OTTENERE UNA CONVERSIONE: avere come obiettivo una conversione significa che l’utente,

dopo aver visto l’annuncio, deve eseguire un’operazione perché la pubblicità possa dirsi riuscita,

come per esempio deve registrarsi alla newsletter, richiedere un preventivo o effettuare un

acquisto.

FARE BRANDING: attraverso gli annunci sul web si vuole che aumenti la notorietà del business

e la sua visibilità.

3.2. Perché questo plugin?

La domanda nasce spontanea: perché utilizzare questo plugin anziché il pannello di Google Adwords?

Ecco alcuni motivi importanti:

Praticità di utilizzo: basta accedere al portale della propria Agenzia per effettuare una qualsiasi

operazione sulle campagne pubblicitarie.

Con pochi click si possono creare, modificare o eliminare campagne.

Nel form guidato per la creazione di una campagna, tanti campi sono precompilati in base ai

prodotti e alle categorie di clienti ad essi associati.

L’Interfaccia è molto intuitiva e user-friendly.

13

3.3. Perché Google Adwords?

L'API (Application Programming Interface, interfaccia di programmazione di un'applicazione) di Google

AdWords è progettata per essere utilizzata da sviluppatori che gestiscono grandi volumi di operazioni.

L'API di Google AdWords consente di creare applicazioni che interagiscono direttamente con il server

Google AdWords. Con tali applicazioni, gli inserzionisti e le terze parti possono gestire le campagne

pubblicitarie e gli account AdWords.

Con le Adwords API è possibile:

Generare automaticamente parole chiave, testi degli annunci, pagine di destinazione e rapporti

personalizzati.

Integrare i dati AdWords con il sistema degli spazi pubblicitari per gestire le campagne in base

alle scorte.

Sviluppare altri strumenti e applicazioni per facilitare la gestione degli account.

L'interfaccia SOAP7 dell'API di AdWords è supportata da tanti linguaggi di programmazione

importanti. Nel caso specifico è stata utilizzata la libreria Python di Google Adwords.

7 SOAP (Simple Object Access Protocol) è un protocollo leggero per lo scambio di messaggi tra componenti software, tipicamente nella forma di componentistica software. La parola object manifesta che l'uso del protocollo dovrebbe effettuarsi secondo il paradigma della programmazione orientata agli oggetti.

14

4. STRUMENTI UTILIZZATI PER IL PROGETTO

Per la realizzazione di questo progetto sono stati utilizzati i seguenti strumenti hardware e software:

4.1. Strumenti Hardware

4.1.1. PC Notebook Sony VAIO

L’unico strumento hardware utilizzato per la realizzazione del progetto è un Personal Computer Notebook Sony Vaio di serie VGN-NW21MFW. Questo PC possiede le seguenti caratteristiche:

Figura 4.1 – Sony VAIO VGN-NW21MF

Sistema Operativo: Windows 8 Consumer Preview; Nome processore: Duo Intel Core™2 T6600; Velocità processore: 2,2 GHz;

Tipo memoria: SDRAM DDR2;

Dimensioni memoria: 4 GB;

Velocità memoria: 800 MHz di velocità;

Nome scheda grafica: ATI Mobility Radeon™ HD 4570;

Memoria grafica totale: circa 2280 MB di memoria grafica totale disponibile con 512 MB di

memoria video GDDR3 dedicata;

Capacità unità disco rigido: 500 GB;

Velocità unità disco rigido: 5400 G/MIN.

15

4.1.2. Server Aziendali

Per lo sviluppo del plugin sono stati utilizzati i server aziendali dev.prodigys.it con sistema operativo

Debian e 4Gb di RAM.

4.2. Strumenti Software

4.2.1. Django Framework

Django è un web framework open source per lo sviluppo di applicazioni web,

scritto in linguaggio Python, seguendo il design pattern Model-View-Controller.

L'orientamento che ha Django nella gestione dei siti è evidente dal suo design, poiché fornisce un certo

numero di funzionalità che facilitano lo sviluppo di applicazioni per la gestione di contenuti Web. Per

esempio, invece che richiedere la realizzazione di controller e view per aree di amministrazione di un

sito, Django fornisce una soluzione integrata di amministrazione dei contenuti che può essere inclusa

come parte di ogni sito basato su Django e che può gestire molti siti Django da un'unica installazione.

L'applicazione per l'amministrazione permette di creare, aggiornare e eliminare contenuti rappresentati

da oggetti tenendo traccia di tutte le operazioni effettuate e fornisce un'interfaccia per la gestione di

utenti e gruppi di utenti (inclusa la gestione dei permessi).

In Django è facile effettuare delle modifiche in una parte dell’applicazione senza che esso abbia

un’influenza sulle altre parti. È importante separare la logica di business dalla logica di presentazione

utilizzando un sistema di template.

Queste tre parti insieme – accesso logico ai dati – logica di business– logica di presentazione portano

ad un concetto chiamato Model-View-Controller (MVC) pattern di architettura software. In questo

pattern, “Model” riferisce il livello di accesso ai dati, “View” riferisce quella parte del sistema che decide

cosa visualizzare e come visualizzarlo e il “Controller” riferisce quella parte del sistema che decide

quale view utilizzare a seconda del input dell’utente, accedendo al modello quando necessario.

Django segue questo pattern MVC nel seguente modo:

M, la parte di accesso ai dati, è gestito dal livello di database di Django

V, la parte che seleziona quali dati visualizzare e come visualizzarli, è gestita da views e

templates.

C, la parte che decide quale view utilizzare in base all’input dell’utente è gestita dallo stesso

framework seguendo l’URLconf e chiamando la funzione Python appropriata per quell’URL.

Per questo motivo, Django viene chiamato un MTV framework.

M riferisce “Model,” il livello di accesso ai dati. Questo livello contiene tutto quello che riguarda i

dati: come accedere ad essi, come convalidarli, che comportamento devono avere e la

relazione tra di essi.

T riferisce “Template,” il livello di presentazione. Questo livello contiene le decisioni che

riguardano la presentazione: come qualcosa deve essere visualizzato in una pagina web o un

altro tipo di documento.

16

V riferisce “View,” il livello di logica di business. Questo livello contiene la logica che accede al

modello e lo rinvia al template appropriato. Lo si potrebbe pensare come un ponte tra i modelli e

i templates.

Alcune funzionalità interessanti di Django sono:

Astrazione del database relazionale ad oggetti.

Possibilità di installare funzionalità attraverso plugin.

Robusta API per la gestione del database.

Sistema di "view generiche" che evitano la stesura di codice ripetitivo per determinati casi

comuni.

Sistema di template basato su tag con ereditarietà dei template.

Gestore di URL basate su espressioni regolari.

Sistema middleware 8 per lo sviluppo di funzionalità aggiuntive; ad esempio, componenti

middleware che forniscono caching, compressione dell'output, normalizzazione dell'output,

protezione CSRF9 e supporto per la sessione sono inclusi nella distribuzione principale di

Django.

Supporto per localizzazione, incluse traduzioni dell'interfaccia amministrativa, in molte lingue.

Sistema di gestione degli utenti e loro autenticazione nell'applicazione Web.

Sistema per la creazione e la validazione di form HTML.

4.2.2. MySQL Workbench

MySQL Workbench è uno strumento visuale di progettazione per database, che integra

sviluppo SQL, gestione, modellazione dati, creazione e manutenzione di database MySQL all'interno di

un unico ambiente sinergico.

4.2.3. Git e GitLab

Git è un sistema software di controllo di versione. Git è stato pensato inizialmente

solamente come motore a basso livello che altri potevano usare per scrivere un front-

end. In seguito diventato un sistema di controllo versione, direttamente utilizzabile da

riga di comando.

Git ha le seguenti importanti caratteristiche:

Forte supporto allo sviluppo non lineare. Git supporta diramazione e fusione (branching and

merging), e comprende strumenti specifici per visualizzare e navigare una cronologia di

sviluppo non lineare.

Sviluppo distribuito. Git dà a ogni sviluppatore una copia locale dell'intera cronologia di

sviluppo, e le modifiche vengono copiate da un tale repository a un altro. Queste modifiche

8 Si tratta di un insieme di programmi informatici che fungono da intermediari tra diverse applicazioni e componenti software. 9 CSRF (Cross-site request forgery) è una vulnerabilità a cui sono esposti i siti web dinamici quando sono

progettati per ricevere richieste da un client senza meccanismi per controllare se la richiesta sia stata inviata

intenzionalmente oppure no.

17

vengono importate come diramazioni aggiuntive di sviluppo, e possono essere fuse allo stesso

modo di una diramazione sviluppata localmente.

I repository possono essere pubblicati facilmente tramite HTTP, FTP, ssh, rsync, o uno speciale

protocollo git.

Autenticazione crittografica della cronologia. La cronologia di Git viene memorizzata in modo

tale che il nome di una revisione particolare (secondo la terminologia Git, una "commit")

dipende dalla completa cronologia di sviluppo che conduce a tale commit. Una volta che è stata

pubblicata, non è più possibile cambiare le vecchie versioni senza che ciò venga notato.

La spazzatura si accumula fino a quando viene raccolta. Quando si abortisce un comando o si

scartano delle modifiche si lasciano degli oggetti inutilizzabili nel database.

GitLab consente di trasformare un qualsiasi cloud server intelligente in una piattaforma basata sul web

di collaborazione on code, creando progetti, repository, revisioni e tutto il necessario. Per la

realizzazione del plugin è stato utilizzato il profilo azienda di GitLab.

18

5. PREPARAZIONE DELL’AMBIENTE DI

LAVORO

5.1. Configurazione dell’ambiente virtuale

Prima di tutto, iniziamo creando un’ambiente virtuale in modo da poter mantenere le varie dipendenze

richieste da diversi progetti in luoghi distinti. In questo modo possiamo mantenere la directory del

nostro progetto pulita e ben gestibile. E’ stata utilizzata la combinazione Python-virtualenv.

virtualenv è uno strumento per creare ambienti Python isolati. virtualenv crea una cartella che

contiene tutti gli eseguibili necessari per utilizzare i pacchetti che il nostro progetto Django richiede.

Installiamo virtualenv tramite pip:

$ pip install virtualenv

$ cd C:\Users\marielanasi\Desktop\Tesi di laurea\it-agenzie-cms

$ virtualenv virtualenv_agenzie_cms

virtualenv virtualenv_agenzie_cms crea una cartella nella directory attuale che contiene i file

eseguibili Python e una copia della libreria pip, la quale può essere utilizzata per installare altri

pacchetti.

Per iniziare ad utilizzare l’ambiente virtuale, è necessario attivarlo:

$ source virtualenv_agenzie_cms /bin/activate

Il nome dell’ambiente virtuale attuale appare ora sulla sinistra del prompt (es.(

virtualenv_agenzie_cms)Your-Computer:your_project UserName$) per segnalare che è

stata attivata. Da ora in poi, ogni pacchetto che viene installato usando pip verrà posizionato nella

cartella virtualenv_agenzie_cms, isolata dall’installazione Python globale.

I pacchetti possono essere installati in questo modo, p.e.:

$ pip install requests

Una volta finito di lavorare sull’ambiente virtuale, si può disattivare:

$ deactivate

Per eliminare un’ambiente virtuale basta eliminare la sua cartella. In questo caso sarebbe:

$ rm -rf virtualenv_agenzie_cms

19

Per mantenere la consistenza dell’ambiente virtuale, è una buona idea “congelare” lo stato attuale dei

pacchetti dell’ambiente. Per fare ciò, è necessario eseguire:

$ pip freeze > requirements.txt

Questo crea un file requirements.txt, il quale contiene una semplice lista di tutti i pacchetti dell’ambiente

attuale e le loro rispettive versioni. Questo facilita il lavoro di uno sviluppatore successivo per installare

gli stessi pacchetti usando la stessa versione:

$ pip install -r requirements.txt

Per ultimo, non dimenticare di escludere la cartella dell’ambiente virtuale dal controllo del codice

sorgente, inserendola nella ignore list.

5.2. Inizializzazione del progetto Django

Per la realizzazione del plugin è stato utilizzato:

PyCharm Professional Edition 4.52

Python Interpreter 2.7

Django 1.5.0

Creazione del progetto

Premere File → New Project e scegliere Django come tipologia di progetto. Specificare il nome e la

posizione del progetto, l’interprete Python da utilizzare e il nome dell’applicazione Python. La cartella it-

agenzie-cms\agenzie è quella dove risiede il CMS delle agenzie. Premere Create.

Figura 5.1 – Creazione del progetto Django

20

Struttura del progetto

Nella seguente schermata possiamo osservare la struttura del progetto Django:

Figura 5.2 – Struttura del progetto Django

agenzie è la container directory per il nostro progetto (dove risiede l’intero CMS).

manage.py (non si vede nella schermata): è una utility della linea di commando che ti permette

di interagire con il progetto Django.

La sotto directory agenzie è il pacchetto Python del nostro progetto.

agenzie/_init_.py: è un file vuoto che dice a Python che questa directory deve essere

considerata come un pacchetto Python.

agenzie/settings.py: è un file che contiene tutte le configurazioni del CMS

agenzie/urls.py: è un file che contiene la dichiarazione degli URL

agenzie/wsgi.py: è un file che definisce un punto di ingresso per web server WSGI10 compatibili

Infine, la sotto directory az_ads contiene tutti i file richiesti per lo sviluppo del nostro plugin. Nei

prossimi capitoli vedremo man mano tutti i dettagli dei file e delle sottocartelle di questa

sottodirectory.

5.3. Configurazione delle impostazioni globali

Una volta creato il progetto Django, si procede con le varie configurazioni. Per poter eseguire il nostro

plugin all’interno del progetto CMS Agenzie già esistente, dovremo inserire la nostra applicazione

all’interno dei file di configurazione globali. A tale scopo, sono state apportate delle modifiche nel file

settings.py e urls.py.

10 Il Web Server Gateway Interface (WSGI) è un protocollo di trasmissione che stabilisce e descrive

comunicazioni ed interazioni tra server ed applicazioni web scritte nel linguaggio Python.

21

Figura 5.3 – Modifiche al file settings.py Figura 5.4 – Modifiche al file urls.py

5.4. Configurazione di MySQL

Per la realizzazione di questo progetto è stato utilizzato:

MySQL Workbench 6.3

MySQL

Le impostazioni sono le seguenti:

Figura 5.5 – Impostazioni MySQL Workbench

22

PyCharm

È stato creato il file agenzie/settings_local.py ed è stato inserito all’intero il seguente codice:

Figura 5.6 – File settings_local.py

Questo file viene successivamente importato nel file globale settings.py. In questo modo è stata

completata la configurazione del database attuale del CMS. Nel capitolo 5 vedremo come procedere

per il nuovo modello che verrà creato.

23

6. SVILUPPO DEL PLUGIN

6.1. Interfaccia principale

Nell’interfaccia principale del plugin è possibile: creare una nuova campagna, per annunci testuali o

multimediali e visualizzare l’elenco di tutte le campagne esistenti. Nel prossimo paragrafo vedremo più

in dettaglio come si crea una campagna.

Figura 6.1 – Interfaccia principale

6.2. Creazione del modello

Come è stato già accennato in precedenza, Django è una piattaforma che si basa sul modello MTV

(analogo a MVC), model-template-view. Nei prossimi paragrafi di questo capitolo vedremo in dettaglio

come è stata realizzata ciascuna parte. Iniziamo con il modello.

Nel seguente schema logico è stato riportato il modello del database utilizzato per la realizzazione del

plugin. Le entità del nostro modello sono: Campagna, Annuncio, Report. Agenzia è una tabella esterna.

Vediamo le tabelle in dettaglio:

Campagna

campaign_status: indica lo stato della campagna che può essere attivo, in pausa oppure

rimosso.

campaign_channel_type: indica la tipologia di canale di ricerca; di predefinito viene utilizzata la

tipologia “rete di ricerca con selezione display”, il che vuol dire che verranno gestiti gli annunci

24

di testo con targetting per parole chiave pubblicati sulla rete di ricerca di Google e sulla rete

Display di Google.

campaign_delivery_method: indica il metodo di pubblicazione degli annunci (la frequenza); di

predefinito viene utilizzata la tipologia “standard”, il che vuol dire che il budget viene ottimizzato

distribuendo la spesa lungo l'arco dell'intera giornata.

Figura 6.2 – Modello del database

campaign_name: indica il nome della campagna.

campaign_location: indica il paese dove verrà lanciata la campagna.

campaign_language: indica la lingua della campagna.

campaign_max_cpc: indica un'offerta che si imposta per indicare l'importo massimo che si è

disposti a pagare per un clic sul annuncio. Si ha la possibilità di scegliere tra l’offerta manuale

(si scelgono gli importi delle offerte) e quella automatica (si imposta un budget giornaliero di

destinazione e il sistema AdWords aggiusta automaticamente le offerte CPC max, con

l'obiettivo di ottenere il numero massimo di clic nei limiti di tale budget). Di predefinito viene

utilizzata l’offerta manuale.

campaign_daily_budget: indica il budget giornaliero per ogni campagna in base agli obiettivi

pubblicitari e all'importo che si è disposto a spendere giornalmente.

ad_group_status: indica lo stato del gruppo di annunci che può essere attivo, in pausa oppure

rimosso.

budget_frequency: indica la frequenza con cui verrà speso il budget; di predefinito verrà

utilizzata la tipologia “giornaliero”.

publish_date: indica la data di pubblicazione della campagna.

end_date: indica la data di conclusione della campagna.

25

campaign_agency: indica la chiave esterna che collega la tabella delle Campagne con quella

delle Agenzie.

adwords_group_id: indica l’id del gruppo di annuncio sul pannello di Google Adwords.

adwords_budget_id: indica l’id del budget sul pannello di Google Adwords.

adwords_campaign_id: indica l’id della campagna sul pannello di Google Adwords.

Annuncio

ad_type: indica la tipologia dell’annuncio che può essere testuale oppure multimediale.

ad_headline: indica la riga di intestazione dell’annuncio.

ad_description1: indica la prima riga di descrizione dell’annuncio.

ad_description2: indica la seconda riga di descrizione dell’annuncio.

keywords: indica la stringa di parole chiave dell’annuncio. Le parole chiave sono frasi che

vengono scelte per determinare dove e quando può apparire l’annuncio. Sono abbinate a

termini che le persone ricercano o a contenuti che le persone visualizzano. Selezionare parole

chiave strettamente correlate agli annunci può consentire di raggiungere clienti che sono alla

ricerca di quello che offre la propria attività commerciale.

keyword_status: indica lo stato delle parole chiave che può essere attivo oppure in pausa.

displayUrl: indica l’URL di visualizzazione che è l’indirizzo della pagina web visualizzato

nell’annuncio, generalmente in verde.

finalUrls: indica l’URL finale della pagina web, quello che i clienti visualizzano quando arrivano

sulla pagina.

ad_status: indica lo stato dell’annuncio che può essere attivo oppure in pausa.

product: indica la chiave esterna che collega la tabella degli Annunci con quella dei Prodotti da

pubblicizzare.

campaign: indica la chiave esterna che collega la tabella degli Annunci con quella delle

Campagne.

adwords_ad_id: indica l’id dell’annuncio sul pannello di Google Adwords.

image: indica l’URL dell’immagine da utilizzare per la creazione di un annuncio multimediale.

Report

name: indica il nome del report; di predefinito si utilizza il nome “Report degli ultimi 7 giorni”.

date: indica la data in cui viene richiesto il report.

impressions: indica la frequenza di pubblicazione dell'annuncio. Viene conteggiata

un'impressione ogni volta che l'annuncio viene pubblicato su una pagina dei risultati di ricerca o

un sito della Rete Google.

clicks: indica il numero di click effettuati; AdWords registra un clic quando un utente fa clic

sull’annuncio, ad esempio sul titolo blu di un annuncio di testo.

ctr: indica la frequenza con cui le persone che vedono il tuo annuncio fanno clic su di esso, cioè

è il numero di clic ricevuti dall'annuncio diviso il numero di volte in cui l'annuncio è stato

visualizzato espresso sotto forma di percentuale (clic ÷ impressioni = CTR). Il CTR può essere

utilizzato per misurare il rendimento delle tue parole chiave e dei tuoi annunci.

cost: indica il costo di ogni click sull’annuncio.

campaign: indica la chiave esterna che collega la tabella dei Report con quella delle

Campagne.

keyword_id: indica l’id della parola chiave.

keyword: indica la parola chiave.

26

quality: indica il punteggio di qualità da 1 a 10 riportato per ciascuna parola chiave dell'account,

che è una stima della qualità degli annunci e delle pagine di destinazione attivate da quella

parola chiave.

Le classi Campaign, Ad e Report vengono salvate nel file models.py. Una volta creato il modello, si

applicano le modifiche al database esistente aggiungendo le tabelle per questa nuova applicazione:

$ python manage.py syncdb

Accedendo al pannello sinistro di MySQL Workbench vedremo le nuove tabella appena create:

Figura 6.3 – Pannello di MySQL Workbench

6.3. Creazione di forms, views, templates

In questo paragrafo vediamo in dettaglio la realizzazione dei forms, views e templates. Per la

realizzazione del flusso di form per richiedere i dati all’utente è stato utilizzato lo strumento Form

wizard. Si tratta di un’applicazione che permette di creare form suddivisi su più pagine. L’applicazione

si occupa di mantenere lo stato dei dati inseriti nei form fra una pagina e l’altra. Vediamo il

funzionamento:

1. L’utente visualizza la prima pagina dello wizard, compila i dati e li inoltra.

2. Il server convalida i dati. Se non sono validi, il form viene visualizzato di nuovo con un

messaggio d’errore. In caso contrario, il server salva lo stato attuale dello wizard in back-end e

reindirizza l’utente allo step successivo.

3. Gli step 1 e 2 si ripetono per ogni form dello wizard.

4. Una volta inoltrato i dati di tutti i form e convalidati, lo wizard processa i dati, e li salva nel

database

27

Sono state realizzate due WizardForm: CampaignWizard e CampaignWizard2. Il primo gestisce il

flusso di creazione di una campagna per annunci testuali e il secondo gestisce il flusso di creazione di

una campagna per annunci multimediali. Vediamo i dettagli:

CampaignWizard1

A livello tecnico sono stati seguiti i seguenti passaggi:

1. Definizione di una serie di classi Form – una per ogni pagina dello wizard: CampaignForm,

ProductsForm, DetailsForm, BudgetForm. Queste classi vengono salvate nel file

forms.py.

2. Creazione di una sottoclasse CampaignWizard che specifica cosa si dovrebbe fare una volta

che tutti i form sono stati inoltrati e convalidati. Questa sottoclasse viene salvata nel file

views.py.

3. Creazione dei template che eseguono il rendering dei forms. Si potrebbe definire un template

unico generico per tutti i form oppure si potrebbe definire un template specifico per ogni step.

Nel nostro caso, è stato definito un template unico per tutti i form, eccetto il ProductForm, al

quale è stato associato un template specifico. Questi file html vengono posizionati nella cartella

templates.

4. Inserimento di un’URL della view nel file urls.py.

STEP 1: vediamo in dettaglio la realizzazione dei forms.

CampaignForm: viene chiesto all’utente di inserire il titolo della Campagna. Ecco il codice:

campaign_name = forms.CharField(label='Scegli il titolo della nuova

campagna:', max_length=100)

model = Campaign()

def clean_campaign_name(self):

campaign_name = self.cleaned_data['campaign_name']

length = len(campaign_name)

if length > 30:

raise forms.ValidationError("Il titolo della campagna supera il

limite dei caratteri.")

return campaign_name

Risultato:

Figura 6.4 – Creazione campagna (1 di 4)

28

ProductForm: viene chiesto all’utente di scegliere il prodotto da utilizzare (per motivi di privacy, nella

schermata sono stati inseriti nomi di prodotti diversi da quelli reali). Ecco il codice:

class ProductsForm(forms.Form):

product = forms.ModelChoiceField(label='Scegli il prodotto da

pubblicizzare:', queryset=Product.objects.filter(adv=True).order_by('name'),

widget=RadioSelect(), required=True)

model = Ad()

Risultato:

Figura 6.5 – Creazione campagna (2 di 4)

DetailsForm: in questo step, i dati sono precompilati richiamando il file settings_adv.py. L’utente

potrebbe comunque cambiare i valori dei campi. Il settings_adv.py file contiene i valori degli

attributi di un annuncio: titolo dell’annuncio, prima riga di descrizione, seconda riga di descrizione,

parole chiave, massimo valore di costo per click (CPC), immagine degli annunci multimediali.

Questo file è stato compilato dopo una lunga analisi da parte degli esperti SEO (Search Engine

Optimization)11. Questa analisi non rientra però nello scopo di questa tesi. Ecco un esempio:

Figura 6.6 – File

settings_adv.py

11 Search Engine Optimization, in acronimo SEO, si intendono tutte quelle attività volte ad ottenere la migliore rilevazione, analisi e lettura del sito web da parte dei motori di ricerca al fine di migliorare (o mantenere un elevato) posizionamento nelle pagine di risposta alle interrogazioni degli utenti del web.

29

Ecco il codice:

ad_headline = forms.CharField(label="Scegli il titolo dell'annuncio:",

max_length=255)

ad_description1 = forms.CharField(label='Scegli la prima riga di

descrizione:', max_length=255)

ad_description2 = forms.CharField(label='Scegli la seconda riga di

descrizione:', max_length=255)

keywords = forms.CharField(label='Scegli le parole chiave (separa le parole

con un ";"):', max_length=255)

model = Ad()

Risultato:

Figura 6.7 – Creazione campagna (3 di 4)

BudgetForm: questo step ha due campi precompilati e senza possibilità di cambiarli: il paese e la

lingua. Inoltre, viene chiesto all’utente di inserire il budget giornaliero della campagna, il massimo costo

per click (CPC), la data di inizio e di fine della campagna. La data di inizio ha come valore predefinito la

data attuale e la data di fine ha come valore predefinito la data attuale + 30 giorni. L’utente potrebbe

comunque cambiare i valori di questi campi. Ecco il codice:

campaign_location = forms.ChoiceField(widget=forms.RadioSelect,

initial=DEFAULT_LOCATION, choices=Campaign.CAMPAIGN_LOCATION, label='Paese

della campagna')

campaign_language = forms.ChoiceField(widget=forms.RadioSelect,

initial=DEFAULT_LANGUAGE, choices=Campaign.CAMPAIGN_LANGUAGE, label='Lingua

della campagna',)

campaign_daily_budget = forms.IntegerField(label='Inserisci il budget

giornaliero della campagna', initial=10)

campaign_max_cpc = forms.ChoiceField(choices=Campaign.CAMPAIGN_MAX_CPC,

label='Inserire il valore max di CPC (Costo per click)', initial=0.5)

publish_date =

forms.DateField(widget=forms.TextInput(attrs={'class':'datepicker'}),label='

30

Inserisci la data di inizio della campagna', initial=datetime.date.today())

end_date =

forms.DateField(widget=forms.TextInput(attrs={'class':'datepicker'}),

label='Inserisci la data di fine della campagna',

initial=(datetime.date.today() + datetime.timedelta(days=30)))

model = Campaign()

Risultato:

Figura 6.8 – Creazione campagna (4 di 4)

31

Conferma del form: la pagina di conferma è il risultato del template done.html che esegue il

rendering dell’intero wizard form.

Figura 6.9 – Riepilogo dei dati inseriti

STEP 2: in questo step viene creata la sottoclasse formwizard.views.SessionWizardView. Vediamo in

dettaglio la realizzazione della view:

Questa classe contiene la definizione di vari metodi che regolano il comportamento della wizard form.

done(): questo metodo specifica cosa dovrebbe succedere una volta che i dati di tutti i form

sono stati inoltrati e convalidati.

get(): questo metodo effettua il get dei dati.

post(): questo metodo richiama il metodo done() ed effettua il post dei dati.

get_context_data(): ritorna il contesto di un template per un determinato step. Questo metodo si

potrebbe sovvrascrivere per aggiungere ulteriori dati per tutti o alcuni step.

get_form_initial(): ritorna un dizionario il quale verrà passato ai form per ogni step come dato

iniziale.

get_template_names: questo metodo richiama i template da associare ad ogni step dello wizard

form.

STEP 3: in questo step sono stati realizzati i template che eseguono il rendering dei forms: campaign-

wizard-txt.html, campaign-wizard-txt-step2.html.

STEP 4: in questo step vengono specificati i forms che verranno utilizzati per lo wizard e viene inserito

l’URL nel file urls.py. Il metodo dello wizard as_view() riceve come argomento una lista di classi form

url(r'^wizard/(?P<agency_id>[^/]+)/$', CampaignWizard.as_view([CampaignForm,

ProductsForm, DetailsForm, BudgetForm]), name='wizard')

CampaignWizard2

32

Per la realizzazione di CampaignWizard2 sono stati seguiti gli stessi step come per CampaignWizard1.

L’unica differenza è il terzo form, al posto di DetailsForm è stato realizzato ImageDetailsForm, visto che

questo wizard gestisce il flusso di creazione di una campagna per annunci multimediali. Questo form

contiene, oltre al titolo e alle parole chiave, un’url di immagine che verrà utilizzato per l’annuncio. L’url è

un campo predefinito nel file settings_adv.py. Alla classe CampaignWizard2 sono stati associati i

template: campaign-wizard-img.html, campaign-wizard-img-step2.html.

Figura 6.10 – Creazione campagna (3 di 4) per annunci multimediali

Oltre alle wizard, sono state realizzate queste due classi: ListCampaign, EditCampaign. Queste classi

vengono salvate su views.py.

ListCampaign

Questa classe controlla la visualizzazione dell’elenco delle campagne create e definisce il solo metodo

get() che richiama tutti i dati dei form salvati nel database. A questa classe è stato associato il

template campaign_list.html.

Le campagne sono suddivise così: campagne in corso, campagne future, campagne terminate. La

suddivisione viene effettuata in base ad una Query sulle date di inizio e di fine di una campagna.

Per ogni campagna viene riportato: titolo, periodo, stato, budget, CPC, paese e lingua. Sul pannello di

ogni campagna ci sono tre pulsanti: Report, Modifica ed Elimina. Il pulsante Report visualizza i report

della campagna riguardo il CPC e le parole chiave, il pulsante Modifica permette di modificare il budget

oppure la data di fine di una campagna e il pulsante Elimina permette di eliminare una campagna.

Quando si preme il pulsante Elimina, un popup di avviso chiede all’utente se si è sicuri di voler

eliminare la campagna. In questo modo l’utente ha la possibilità di annullare l’operazione.

33

Figura 6.11 –

Elenco delle

campagne

Figura 6.12 – Popup di avviso

eliminazione campagna

Premendo su Annuncio: Prodotto 7 si apre un secondo pannello che contiene gli annunci della

campagna. Questo pannello riporta tutti i dati degli annunci e una tabella con le parole chiave con lo

stato e il max CPC per ciascuna.

Figura 6.13 – Pannello dell’annuncio

Il pulsante Report contiene due sotto elementi, Report CPC e Report Keyword.

34

Figura 6.14 – Pulsante Report

Il report CPC riporta i risultati del costo per click e delle impressioni12 della campagna:

Figura 6.15 – Report del CPC

Il Report Keyword riporta i risultati delle parole chiave della campagna:

Figura 6.16 – Report delle parole chiave

12 Impressioni riferisce il concetto di efficienza di una campagna.

35

EditCampaign

Questa classe controlla la pagina di modifica di una campagna e definisce i metodi get() e post(), il

primo richiama tutti i dati dei form, mentre il secondo salva le modifiche nel database. Gli unici campi

che si possono modificare in una campagna sono: budget e data di fine di una campagn. Per la

visualizzazione della pagina di modifica è stato creato il form CampaignEditForm salvato nel file

forms.py:

class CampaignEditForm(forms.ModelForm):

class Meta:

model = Campaign

fields = ['campaign_daily_budget', 'publish_date', 'end_date']

widgets = {

'publish_date': forms.DateInput(attrs={'class':'datepicker'}),

'end_date': forms.DateInput(attrs={'class':'datepicker'}),

}

def __init__(self, *args, **kwargs):

super(CampaignEditForm, self).__init__(*args, **kwargs)

A questa classe è stato associato il template campaign_edit.html.

Figura 6.17 – Form di modifica di una campagna

Una volta salvate le modifiche, un popup avvisa l’utente dell’operazione avvenuta con successo.

Oppure, nel caso di un’eliminazione, il popup è il seguente:

36

7. GOOGLE ADWORDS

7.1. Richiesta di accesso alle Adwords API

Per effettuare l’accesso alle Google Adwords API, in linee generali, bisogna seguire i seguenti

passaggi:

STEP 1

Creare un account di gestore clienti di produzione, detto manager account (MCC), ed associare ad

esso un profilo Adwords di test.

Un gestore clienti è un account AdWords che ti consente di visualizzare e gestire con facilità più

account AdWords (compresi altri gestori clienti) da un'unica posizione. Il gestore clienti è un account

AdWords cumulativo contenente più account AdWords individuali ad esso collegati. Come sempre, i

proprietari degli account AdWords individuali potranno accedere ai rispettivi account AdWords

mantenendo l'accesso alle proprie informazioni.

Per creare un gestore clienti, si procede nel seguente modo:

1. Visitare la pagina https://www.google.com/adwords/myclientcenter/ e fare clic su Iscriviti

subito nell'angolo in alto.

2. Inserire l'indirizzo email da utilizzare per questo account. L'indirizzo email non deve essere già

utilizzato per accedere ad altri account AdWords.

3. Specifica un nome per il gestore clienti. Questo nome verrà visualizzato dai clienti nel proprio

account gestito.

4. Scegliere come si intende utilizzare l'account: per gestire gli account AdWords o per gestire gli

account di altre persone. In questo caso, per gestire gli account Adwords.

5. Selezionare il Paese e il fuso orario. Questo fuso orario verrà utilizzato per i rapporti e la

fatturazione del account e non può essere modificato.

6. Selezionare una valuta permanente per l’account. Questa selezione associa il gestore clienti a

una valuta appropriata per eventuali esigenze di fatturazione specifiche del account.

7. Selezionare la casella per accettare le norme di utilizzo e fare clic su Salva e continua.

8. Una volta verificato l’indirizzo email inserito, il nuovo gestore clienti è attivo.

STEP 2

Una volta effettuato l’accesso al gestore clienti, bisogna richiedere l’accesso alle Adwords API:

1. Andare su Impostazioni – Adwords API Center

2. Seguire le istruzioni per l’accesso alle Adwords API

3. Successivamente, viene ricevuta un’email da adwordsapi-tokens@google.com con un modulo

da compilare. Compilare il modulo e seguire le istruzioni.

4. Una volta approvata la richiesta di accesso alle Adwords API, viene assegnato un developer

token, accessibile al Adwords API Center nelle Impostazioni del gestore clienti.

37

STEP 3

Creare un account di test, detto Test MCC account,

(https://developers.google.com/adwords/api/docs/test-accounts) ed associarlo al gestore clienti creato

nello step 1.

Un profilo AdWords di test permette di eseguire le richieste alle API di Adwords tramite l’ambiente di

sviluppo per motivi di test. I profili di test non hanno nessun effetto sulle campagne reali create e si può

testare la logica della gestione delle campagne senza modifiche i dati reali.

Per collegare l’account di test al gestore clienti bisogna:

1. Recuperare l'ID cliente AdWords (visualizzato nell'angolo in alto dell'account AdWords).

2. Accedere al gestore clienti alla pagina https://adwords.google.it.

3. Fare clic sulla scheda Account – Rendimento - + Account.

4. Scegliere "Collega account esistenti".

5. Dopo avere letto i termini per il collegamento degli account, inserire l'ID cliente dell'account

AdWords nel campo Account cliente.

6. Fare clic su Continua e poi su Invia.

7. Quando si fa clic su Invia, l'account AdWords riceve una notifica dell'account e un'email che invita il

relativo proprietario a eseguire il collegamento all’account. Gli utenti con accesso amministrativo

all'account invitato possono accettare l'invito facendo clic sull'icona a forma di ingranaggio e

selezionando Impostazioni account dal menu a discesa.

STEP 4

Utilizzare il developer token del gestore clienti di produzione per fare richieste tramite l’account

MCC di test

Accedere con l’account MCC di test quando si richiede un OAuth 2.0 refresh token.

STEP 5

Creare un nuovo progetto nel Google Developers Console (https://console.developers.google.com).

Premere Create a project ed inserire tutti i dati richiesti.

Premere APIs & Auth → Consent screen nel pannello sinistro di navigazione.

Creare un’OAuth2 clientId premendo APIs & auth → Credentials e dopo Create new Client ID,

scegliendo la configurazione per Web Application.

Una volta creato il client ID, il client id e client secret sono disponibili su APIs & auth →

Credentials.

38

7.2. Impostazione delle credenziali

Una volta creati gli accounts e ricevuto il developer token, si procede allo scaricamento della libreria

Python per Google Adwords:

https://developers.google.com/adwords/api/docs/clientlibraries

Nella cartella googleads-python-lib-master, aprire il file googleads.yaml e inserire i seguenti

dati:

developer_token: quello ricevuto nello step 2

user_agent: quello specificato nel momento di creazione

client_id: l’id dell’account MCC di test

client_secret: quello creato nello step 5

refresh_token: per ottenere il refresh token bisogna eseguire lo script

generate_refresh_token.py che si trova nella cartella googleads-python-lib-

master\examples\adwords\authentication.

7.3. Accessi alle Adwords API

Una volta definite tutte le impostazioni iniziali, si procede con le richieste da effettuare alle Google

Adwords API per eseguire le operazioni necessarie per il plugin.

E’ possibile recuperare un AdWordsClient completamente inizializzato chiamando il metodo

LoadFromStorage, il quale prende tutte le credenziali salvate in googlead.yaml.

from googleads.adwords import AdWordsClient

client =

AdWordsClient.LoadFromStorage(os.path.join(os.path.dirname(os.path.realpa

th(__file__)), '..\googleads.yaml'))

I seguenti metodi sono stati salvati nel file utils.py.

Creazione campagna

Per la creazione della campagna sono stati definiti i seguenti metodi:

create_campaign: instaura una connessione con il CampaignService e crea una campagna con

i dati inseriti dall’utente.

create_shared_budget: instaura una connessione con il BudgetService e crea un budget

condiviso per una campagna. Un budget condiviso è un budget che una stessa campagna può

utilizzare per più annunci contemporaneamente.

create_target: instaura una connessione con il CampaignCriterionService e crea dei target per

la campagna: lingua e paese predefinito, ricerca di prodotti/servizi entro 25km di distanza dalla

posizione dell’utente.

create_bidding_strategy: instaura una connessione con il BiddingStrategyService e definisce la

strategia da seguire per il consumo del budget e il valore del max CPC (nel caso si sia scelta

l’opzione automatica).

create_group: instaura una connessione con l’AdGroupService e crea un gruppo di annunci con

dati predefiniti.

39

create_ad: instaura una connessione con l’AdGroupAdService e crea un’annuncio testuale con

i dati inseriti dall’utente.

create_image_ad: instaura una connessione con l’AdGroupAdService e crea un’annuncio

multimediale con i dati inseriti dall’utente.

create_keyword: instaura una connessione con l’AdGroupCriterionService e crea le parole

chiave inserite dall’utente.

Modifica campagna

Per la modifica della campagna sono stati definiti i seguenti metodi:

Per i primi tre metodi si instaura una connessione con CampaignService, per l’ultimo invece con il

BudgetService.

change_campaign_status: modifica lo stato della campagna.

remove_campaign: rimuove la campagna dall’elenco delle campagne.

change_campaign_date: modifica la data di fine di una campagna.

change_campaign_budget: modifica il budget di una campagna.

Report campagna

Per la reportistica della campagna sono stati definiti i seguenti metodi:

download_report: scarica il report della campagna per gli ultimi 7 giorni in formato .csv

download_report_string: scarica i dati del report e li salva nella tabella Report.

È stato creato lo script get_cpc_report_data.py per scaricare giornalmente i dati dei report dal

pannello di Google Adwords. Questo file è stato posizionato nella cartella

az_ads\management\commands.

Pubblicazione campagna

Per la pubblicazione della campagna con tutti i dati riguardanti annuncio, budget, parole chiave ecc. è

stato definito il seguente metodo:

make_published: questo metodo richiama tutti i metodi: create_campaign,

create_shared_budget, create_target, create_bidding_strategy, create_group, create_ad

(oppure create_ad_image nel caso di un annuncio multimediale), create_keyword.

Nel file views.py sono state definite tutte le views necessarie per eseguire le operazioni appena

descritte:

PublishCampaign: una view che richiama il metodo make_published().

ChangeStatus: una view che richiama il metodo change_campaign_status().

RemoveCampaign: una view che richiama il metodo remove_campaign().

ChangeDate: una view che richiama il metodo change_campaign_date().

ChangeBudget: una view che richiama il metodo change_campaign_budget().

DownloadReport: una view che richiama il metodo download_report().

ReportCampaign: una view che controlla la visualizzazione dei grafici riguardo il CPC e le

impressioni.

KeywordCampaign: una view che controlla la visualizzazione dei grafici riguardo le parole

chiave.

40

Tutte le views vengono specificate nel file urls.py:

Figura 7.1 – File urls.py

41

8. PANNELLO DI AMMINISTRAZIONE

8.1. Creazione del pannello

Django permette di costruire automaticamente l’amministrazione dell’applicazione, ovvero una

applicazione che permette ad utenti autorizzati di gestire i contenuti del sito. Perché l’interfaccia di

amministrazione sia generata automaticamente, dobbiamo configurare opportunamente Django. Per

questo bisogna fare alcune modifiche:

Nel file agenzie/settings.py è stata aggiunta la riga django.contrib.admin alla

variabile INSTALLED_APPS in modo da abilitare l’applicazione admin.

Nel file agenzie/urls.py è stato aggiunto il seguente pezzo di codice:

from django.contrib import admin

admin.autodiscover()

urlpatterns = patterns('',

...

url(r'^admin/', include(admin.site.urls)),

Ora dobbiamo indicare a Django quali oggetti della nostra applicazione vogliamo gestire

nell’interfaccia di amministrazione. Creiamo allora il file admin.py nella directory della nostra

applicazione:

Figura 8.1 – File admin.py

Figura 8.2 – Login al pannello di

amministrazione

42

puntare il browser all’indirizzo http://127.0.0.1:8000/admin/, e si ottiene la pagina di

autenticazione di admin. Accediamo utilizzando username e password del super user creato

durante la fase di installazione (oppure durante la prima sincronizzazione del database).

Dovremmo vedere la pagina seguente:

Figura 8.3 – Le tabelle nel pannello di amministrazione

La sezione di amministrazione permette di aggiungere, modificare e cancellare gli oggetti della nostra

applicazione. Possiamo inoltre modificare secondo le nostre esigenze l’insieme degli attributi

visualizzati da Django per ogni oggetto della nostra applicazione. Per fare ciò, basta specificare gli

attributi in list_display. Inoltre, si possono aggiungere comandi aggiuntivi nel pannello di

amministrazione. Vedremo questo aspetto nel paragrafo 8.2. Creazione di comandi aggiuntivi.

Figura 8.4 – La tabella delle campagne

8.2. Creazione di comandi aggiuntivi

Come abbiamo accennato nel paragrafo 7.1, è possibile aggiungere dei comandi aggiuntivi al pannello

di amministrazione in base alle esigenze.

43

Per la pubblicazione delle campagne sul pannello di Google Adwords è stata aggiunta l’azione “Make

published action”. Questa azione richiama il metodo make_published() definito nel file utils.py.

Inoltre, è stata aggiunta anche l’azione “Change status action” che richiama il metodo

change_campaign_status().

Figura 8.5 – Comandi aggiuntivi

44

9. INTERFACCIA GRAFICA

Per l’interfaccia grafica del plugin si è basati su quella già esistente nel CMS attuale. Per fare ciò, sono

stati effettuati degli import di blocchi di codice all’interno dei file .html dei templates del plugin.

Prendiamo come esempio il file campaign-wizard-txt.html:

Questo pezzo di codice permette di estendere il file base.html del CMS attuale. Questo file realizza la

barra con il logo e nome dell’Azienda e le info di chi ha effettuato l’accesso.

Il seguente pezzo di codice effettua un import del file ad_style.css. Questo file è stato realizzato

appositamente per il plugin e controlla l’aspetto grafico dell’elenco delle campagne.

Questo pezzo di codice, invece, realizza il cosiddetto Cruscotto del plugin, nel quale viene riportato il

nome della pagina web e la fase in cui l’utente si trova (nel caso si tratti di una creazione di campagna).

Così come per il resto del CMS, anche per il plugin è stato utilizzato Bootstrap13 per la realizzazione di

pulsanti, messaggi di avviso, messaggi di errore, blocchi espandibili, calendari ecc. Lo si può notare

anche nel blocco di codice extrahead (bootstrap-datepicker.css e bootstrap-

datepicker.js per la realizzazione del calendario).

13 Bootstrap è una raccolta di strumenti liberi per la creazione di siti e applicazioni per il Web. Essa contiene modelli di progettazione basati su HTML e CSS, sia per la tipografia, che per le varie componenti dell'interfaccia, come moduli, bottoni e navigazione, e altri componenti dell'interfaccia, così come alcune estensioni opzionali di JavaScript.

45

10. CONSIGLI E PROCEDURE UTILI

In questo capitolo vediamo alcuni consigli e procedure utili per la risoluzione di una serie di

problematiche che potrebbero presentarsi durante la realizzazione di un plugin simile. Un consiglio

molto importante è quello di leggere attentamente tutte le documentazioni, visto che tanti problemi

sorgono da una lettura poco attenta di esse.

Procedure in Google Adwords

Come creare uno script aggiuntivo per recuperare dei dati da Google Adwords giornalmente?

Per aggiungere una funzionalità aggiuntiva all’applicazione, bisogna seguire la seguente procedura:

Creare una directory management/commands nell’applicazione;

All’interno della cartella commands, creare un file Python (nel nostro caso

get_cpc_report_data.py) e definire all’interno la classe Command che estende

BaseCommand.

Come creare dei grafici tramite le Google API?

Per la creazione di un grafico tramite le Google API bisogna scrivere uno script che effettua l’accesso

alle API e definisce tutte le impostazioni per il caricamento dei dati da visualizzare e per l’aspetto

grafico.

46

Come impostare la data nel formato richiesto da Google Adwords?

I formati definiti per Google Adwords sono poco tolleranti anche alle piccole modifiche. Per questo

motivo, bisogna stare molto attenti alla definizione di essi. Per quanto riguardo il formato della data,

sono state inserite queste righe di codice all’interno dello script che realizza la creazione di una

campagna:

'startDate': campaign.publish_date.strftime('%Y%m%d'),

'endDate': campaign.end_date.strftime('%Y%m%d'),

Essendo, publish_date = models.DateField(default=(datetime.datetime.now() +

datetime.timedelta(0)).strftime('%Y-%m-%d'))

end_date = models.DateField(default=(datetime.datetime.now() +

datetime.timedelta(30)).strftime('%Y-%m-%d'))

Come realizzare la Django View per scaricare un report in formato .csv da Google Adwords?

All’interno della libreria Python per Google Adwords esiste un file nella cartella reporting chiamato downloadcriteriareportasstrem.py. Per scaricare i dati necessari bisogna modificare questo script esistente, aggiungendo queste righe di codice per la lettura del file: …

myfile = StringIO.StringIO()

myfile.write(report.getvalue())

myfile.flush()

myfile.seek(0)

response = HttpResponse(FileWrapper(myfile), content_type='text/plain')

response['Content-Disposition'] = 'attachment; filename=report_campagne.csv'

report.close()

47

Come realizzare la Django View per scaricare un report in formato String da Google Adwords?

All’interno della libreria Python per Google Adwords esiste un file nella cartella reporting chiamato downloadcriteriareport.py. Per scaricare i dati necessari in formato String bisogna modificare questo script esistente creando un modello per i dati che andranno a popolare la tabella del Report:

Procedure nella piattaforma Django

Come aggiungere altri comandi rapidi su Django Admin?

Per definire nuove azioni all’interno del pannello di amministrazione, bisogna definirle all’interno del

ModelAdmin nel file admin.py. Prendiamo in considerazione l’esempio dell’azione

make_published() definita per la pubblicazione automatica delle campagne sul pannello di Google

Adwords.

48

Come convalidare il campo di un Django Form?

All’interno del file forms.py vengono definite tutte le convalidazioni dei campi. Per esempio,

consideriamo il campo delle parole chiave. Vorremmo che questo campo non accettasse meno di

quattro parole chiave. Per fare ciò vengono inserite le seguenti righe di codice all’interno del

DetailsForm, dove le parole chiave sono definite.

def clean_keywords(self):

keywords = self.cleaned_data['keywords']

num_words = len(keywords.split('; '))

if num_words < 4:

raise forms.ValidationError("Numero delle parole chiave non

sufficiente!")

return keywords

Allo stesso modo si procede anche per altri tipi di convalidazione, come lunghezza caratteri, non

accettazione di caratteri speciali ecc.

Come visualizzare solo alcuni dei campi di un Django Form?

Per la visualizzazione di solo alcuni campi di un form si definisce la classe Meta all’interno della classe

Form in questo modo:

class CampaignEditForm(forms.ModelForm):

class Meta:

model = Campaign

fields = ['campaign_daily_budget', 'publish_date', 'end_date']

widgets = {

'publish_date': forms.DateInput(attrs={'class':'datepicker'}),

'end_date': forms.DateInput(attrs={'class':'datepicker'}),

}

49

Come nascondere un campo di un Django Form?

Il campo di un Django Form si nasconde con la seguente riga di codice:

image = forms.CharField(label='Immagine annuncio',

widget=forms.HiddenInput())

Come inserire una data preimpostata a 30 giorni dalla creazione della campagna?

Per impostare precedentemente una data di fine campagna a 30 giorni dalla creazione, si definisce il

campo end_date in questo modo:

end_date = models.DateField(default=(datetime.datetime.now() +

datetime.timedelta(30)).strftime('%Y-%m-%d'))

Come creare URL dinamici in Django?

Se si vuole creare un URL in modo dinamico, appendendo alla fine un id, si inserisce la seguente riga

di codice nel file urls.py.

url(r'^listcampaign/(?P<agency_id>\d+)/$', ListCampaign.as_view(),

name='listcampaign')

Questa riga indica che l’URL della pagina web con la lista delle campagne create verrà visualizzata con

l’id dell’Agenzia appeso alla fine dell’URL.

Come leggere un file .jpeg salvato in locale?

Per leggere un file .jpeg vanno utilizzate le seguenti righe di codice:

with open(str(ad.image), "rb") as f:

encoded_string = base64.b64encode(f.read())

ad.image è un attributo del modello Ad e indica l’URL dell’immagine.

Come creare diverse menu in base alla data di inizio e fine di una campagna?

Per la creazione della pagina web che visualizza l’elenco delle campagne sono state realizzate delle

Query sulla data di inizio e di fine delle campagne.

if period == '1': #current

campaigns =

Campaign.objects.filter(campaign_agency__id=agency_id).filter(Q(publish_date

__lte=datetime.now()) &

Q(end_date__gte=datetime.now())).order_by('campaign_status')

elif period == '2': #past

campaigns =

Campaign.objects.filter(campaign_agency__id=agency_id).filter(Q(publish_date

__gt=datetime.now())).order_by('campaign_status')

elif period == '3': #future

campaigns =

50

Campaign.objects.filter(campaign_agency__id=agency_id).filter(Q(end_date__lt

=datetime.now())).order_by('campaign_status')

Come realizzare la view per la modifica in locale di una campagna esistente?

Per realizzare una pagina di modifica dei campi di un form, bisogna:

Definire un CampaignEditForm nel file forms.py, con i campi che si desidera modificare (vedi

procedura Come visualizzare solo alcuni dei campi di un Django Form).

Creare un template campaign_edit.html.

Definire il metodo get() in questo modo:

def get(self, request, *args, **kwargs):

campaign_id = kwargs['campaign_id']

campaign = Campaign.objects.get(pk=campaign_id)

agency = Agency.objects.get(pk=campaign.campaign_agency_id)

form = CampaignEditForm(instance=campaign)

return render(request, 'campaign_edit.html',{'form': form, 'agency':

agency })

Come realizzare la view per precompilare i dati di un Django Form?

Per la precompilazione dei dati di un Django Form, all’interno della Form Wizard, definire il metodo

get_form_initial() in questo modo:

current_step = self.storage.current_step

if step == '2':

step2_data = self.get_cleaned_data_for_step('1')

if step2_data:

product_name = str(step2_data['product'].pk)

ad_headline =

settings_adv.DEFAULT_PRODUCT_DATA[str(product_name)]['ad_headline']

keywords =

settings_adv.DEFAULT_PRODUCT_DATA[str(product_name)]['keywords']

image =

settings_adv.DEFAULT_PRODUCT_DATA[str(product_name)]['image']

return self.initial_dict.get(step, {'ad_headline': ad_headline,

'keywords': keywords, 'image': image})

dove DEFAULT_PRODUCT_DATA definisce la stringa dei dati predefiniti.

51

11. CONCLUSIONI

Il lavoro svolto in cinque mesi per la realizzazione di questa tesi ha pienamente soddisfatto le esigenze

dell’azienda Prodigys Technology S.r.l. I feedback ricevuti sono stati positivi e incoraggianti per

intraprendere ulteriori sfide simili. La comunicazione sia con i datori di lavoro che con i colleghi è stata

ottima e ha avuto riflessioni positive nello svolgimento del progetto.

L’obiettivo iniziale che si era posto è stato quello di realizzare un plugin che riuscisse a soddisfare

totalmente le richieste del cliente e cioè creare una piattaforma veloce di creazione di campagne

pubblicitarie basate sulla ricerca di parole chiave. Questo obiettivo è stato raggiunto. Il plugin è

funzionante e cioè fa quello per il quale è stato progettato: crea nuove campagne, crea nuovi annunci,

modifica campagne ed annunci esistenti, visualizza i risultati delle campagne sotto forma di grafici,

permette di scaricare i dati. Tutto questo viene realizzato tramite chiamate continue alle Google

Adwords API.

Il plugin è user-friendly, esegue tutte le operazioni in pochi click ed era proprio questo lo scopo iniziale:

la realizzazione di uno strumento che velocizzasse il processo di creazione delle campagne.

Il plugin è completo nelle sue funzionalità basilari, però verrà sottoposto ad ulteriori processi di sviluppo

per implementare nuove funzionalità a seconda delle esigenze del cliente e a seconda della tipologia

dei nuovi clienti.

Il processo di test, lato cliente, è stato realizzato alla fine della prima fase di sviluppo. Dopo lo sviluppo

delle fasi successive, il plugin avrà un utilizzo immediato da parte del cliente interessato.

Prima di iniziare la collaborazione con Prodigys, avevo gli stessi dubbi che ha ogni studente che non

ha mai affrontato un ambiente lavorativo vero e proprio. Non sapevo se sarei stata in grado di

realizzare un progetto per un vero cliente aziendale, soddisfacendo le sue esigenze e realizzando un

plugin funzionante in tutte le sue parti. Però, dall’altra parte, sapevo che se l’impegno e la volontà di

imparare non mancano, sempre si riescono a raggiungere gli obiettivi posti. E ce l’ho fatta. Anzi, ce

l’abbiamo fatta. Questo non solo grazie al mio impegno, ma anche grazie al supporto e ai consigli e

feedback ricevuti dai colleghi e dal mio relatore e correlatori.

È molto importante scegliere bene l’ambiente in cui si realizza un progetto di tesi, che sia esso

un’azienda, un ente pubblico, un laboratorio. È importante perché sono i primi passi verso un mondo

di lavoro che aspetta ogni neolaureato. E far bene i primi passi è sempre un ottimo inizio.

La dinamica del lavoro di gruppo, la gestione delle problematiche, la capacità di agire rapidamente

quando necessario, la comunicazione con il cliente ecc., sono tutti elementi molto importanti da tener

presente, oltre al aspetto tecnico di un progetto. Sono i cosiddetti soft skills, capacità che si imparano

interagendo con un gruppo di lavoro ben costruito.

In conclusione, direi che il lavoro svolto per questa tesi mi ha fatto crescere tanto, sia

professionalmente che personalmente, dandomi i primi input veri di un mondo lavorativo pieno di sfide

ed esperienze nuove da intraprendere.

52

12. SITOGRAFIA

Django Software Foundation, Django documentation, https://docs.djangoproject.com/en/1.8/

Django Software Foundation, “How-to” guides, https://docs.djangoproject.com/en/1.8/howto/

Stephan Jaekel, django-formwizard Documentation,

https://django-formwizard.readthedocs.io/en/latest/index.html

Django Software Foundation, Django’s bug tracker and wiki, https://code.djangoproject.com/wiki

A.Kenneth Reitz, The Hitchhiker’s Guide to Python, Virtual Environments,

http://docs.python-guide.org/en/latest/dev/virtualenvs/

JetBrains s.r.o, Meet PyCharm, https://www.jetbrains.com/help/pycharm/2016.3/meet-pycharm.html

HTML.it periodico telematico, Creare l’amministrazione di un sito,

http://www.html.it/pag/17924/creare-lamministrazione-di-un-sito/

Google Inc, Guida di Google Adwords, https://support.google.com/adwords

Google Inc, Google Adwords API, https://developers.google.com/adwords/api/docs/guides/start

Google Inc, Google Adwords Scripts, https://developers.google.com/adwords/scripts/docs/solutions/

Google Inc, Norme Adwords, https://support.google.com/adwordspolicy

Google Inc, Google Charts, https://developers.google.com/chart/

Julian Toledo (developer for Google Adwords), Online Training Video,

https://www.youtube.com/watch?v=avFIBgYq63E

SearchCode, https://searchcode.com/

Alex Hayes, Django-google-adwords, https://bitbucket.org/alexhayes/django-google-adwords

Stack Exchange Inc, Stock Overflow Community, http://stackoverflow.com/