\begin{it}
	\usepackage[italian]{babel}
\end{it}
\begin{en}
	\usepackage[english]{babel}
\end{en}

\usepackage{blindtext}
\usepackage[T1]{fontenc}
\usepackage[utf8]{inputenc}
\usepackage[pdftex]{graphicx}
\usepackage{scrlayer-scrpage}
\usepackage{float}
\usepackage{hyperref}
\usepackage{tikz}
\usepackage[backend=biber]{biblatex}
\usepackage{pgfgantt}
\usepackage{pgffor}
\usepackage{listings}
\usepackage{lmodern}

\bibliography{bibliography}

% page margins
\usepackage[margin=3cm,head=15pt]{geometry}

% document metadata
\begin{it}
	\def\mdtitle{Alternanza scuola-lavoro estesa presso \textit{Agomir S.p.A.}}
	\def\mdsubtitle{Sviluppo di applicazioni multipiattaforma per dispositivi mobili}
\end{it}
\begin{en}
	\def\mdtitle{Extended school internship at \textit{Agomir S.p.A.}}
	\def\mdsubtitle{Multiplatform mobile application development}
\end{en}
\def\mdauthor{Claudio Maggioni}
\def\mddate{\today}
\def\mdrevision{6}

% header and footer style
\clearscrheadfoot
\pagestyle{scrheadings}
\makeatletter
\ohead[]{\mdauthor}
\ihead[]{\mdtitle}
\cfoot[\pagemark]{\pagemark}

% listings configuration
\begin{it}
	\renewcommand{\lstlistingname}{Listato}
	\renewcommand{\lstlistlistingname}{Elenco dei listati}
\end{it}
\lstset{
	basicstyle=\small\ttfamily,
	frame=shadowbox,
	rulesepcolor=\color{black},
	columns=fullflexible,
	commentstyle=\color{gray},
	keywordstyle=\bfseries,
	escapeinside={\%*}{*)},
  aboveskip=2em,
  captionpos=b,
  abovecaptionskip=1em,
  belowcaptionskip=1em
}

\begin{document}

% first page
\begin{titlepage}
	\pagenumbering{gobble}
	\centering
	\includegraphics[width=0.15\textwidth]{images/logo.jpg}\par\vspace{1cm}
	{\scshape\LARGE Istituto di Istruzione Superiore \mbox{``A. Badoni''}\par}
	\vspace{1cm}
	{\scshape\Large Tesi di maturità\par}
	\vspace{1.5cm}
	{\huge\bfseries\mdtitle\par}
	\vspace{0.75cm}
	{\Large\bfseries\mdsubtitle\par}
	\vspace{2cm}
	{\Large\itshape\mdauthor\par}
	\vfill	
	% Bottom of the page
	{\large\mddate\par}
	\begin{it}
		\vspace{0.5cm}
		{\large\textsc{Traduzione in italiano}\par}
	\end{it}
	\vspace{0.5cm}
	{\large\color{red}\textsc{Revisione \mdrevision}\par}
\end{titlepage}

\newpage

\pagenumbering{Roman}
\tableofcontents

\newpage

\pagenumbering{arabic}
\begin{it}
	\section{Informazioni generali sul lavoro svolto}

	A partire dal giorno 19/10/2017, collaboro con l'azienda \textit{Agomir
    S.p.A}\cite{agomir:website} (produttrice di software, sistemi e servizi per
	piccole e medie imprese) svolgendo un'attività di alternanza scuola-lavoro
  estesa con cadenza settimanale (giovedì e venerdì pomeriggio). Mi occupo di
  sviluppo software di tipo gestionale, nello specifico di applicazioni per
  smartphone multipiattaforma (cioè compatibili sia con Android che con iOS)
  utilizzando strumenti come \textit{Ionic Framework}\cite{ionic:website} e
  \textit{Apache Cordova}\cite{cordova:website}.

	Tale approccio al mondo \textit{mobile} facilita lo sviluppo, perché al
  posto di usare API e meccanismi legati alla piattaforma \`e possibile
  utilizzare tecnologie note e standard come HTML e Javascript. Naturalmente
  tali applicazioni richiedono pi\`u risorse e tendono ad essere meno fluide,
  ma questo aspetto è meno rilevante in contesti gestionali come quelli
  affrontati da Agomir, non legati ad esempio al mondo dei videogiochi o
  all'elaborazione real-time.
\end{it}
\begin{en}
	\section{General information about the work done}
	
	\blindtext
\end{en}

\begin{it}
	\section{Gestione dei progetti}

	Non ho diretto controllo manageriale su ciò che sviluppo in azienda,
  in quanto ho un ruolo simile a quello di un dipendente. L'incarico di gestire
  l'andamento dei progetti spetta a Mario Goretti, A.D. dell'azienda e capo
  del settore di sviluppo software gestionale (\textsc{SWG}), e ai suoi collaboratori. 
	
	In generale sviluppo i progetti da solo. Collaboro con il collega Daniele
  Crippa per l'interfacciamento con i software aziendali esistenti e per
  l'organizzazione di nuovi progetti, nonché consigli e dritte varie.
	
	Nonostante non abbia controllo totale \`e comunque mia responsabilità fare
  stime orarie sul lavoro da svolgere nonché definire passi e \textit{milestone}
  per i vari progetti.
	
	Per aumentare la forza lavoro per lo sviluppo di applicazioni \textit{mobile}
  ho coordinato momenti di formazione ad alcuni dipendenti nei quali ho mostrato
  il principale funzionamento delle tecnologie che uso.
\end{it}
\begin{en}
	\section{Projects management}
	
	\blindtext
\end{en}

\begin{it}
	\section{Il progetto principale: \textit{InteGRa Mobile}}
	
	Questa applicazione, una volta completata, dovrebbe permettere ad utenti in
  mobilità di interfacciarsi con alcune funzioni del prodotto ERP di punta di
  Agomir: il gestionale \textit{InteGRa}\footnote{Sito internet di InteGRa ERP:
    \url{https://integra.agomir.com/}}. Nel dettaglio, sarà possibile accedere
  alle seguenti sezioni:
	
	\begin{description}
	  \item[Ordini cliente] per registrare ordini di prodotti a clienti;
	  \item[Soggetti] per consultare informazioni anagrafiche di clienti e fornitori;
	  \item[Agenda] per consultare e aggiungere eventi nel calendario presente
      nell'ERP, il quale si pu\`o integrare con \textit{Outlook};
	  \item[Magazzini] gestire e inventariare scorte in magazzino.
	\end{description}
	
	In aggiunta, sarà possibile anche registrare le ore per interventi in
  trasferta, funzione gi\`a implementata nell'applicazione
  \textit{InteGRa.Service}, sviluppata nei periodi di alternanza precedenti.
  Tale lavoro non \`e direttamente implementabile in \textit{InteGRa Mobile} a
  causa di differenze consistenti nelle architetture dei due prodotti.
	
	Inoltre, l'applicazione sarà in grado di funzionare in modo limitato anche
  senza connessione diretta ad \textit{InteGRa}, permettendo la sincronizzazione
  dei dati modificati con il gestionale in un momento futuro.
\end{it}
\begin{en}
	\section{The main project: \textit{InteGRa Mobile}}
	
	\blindtext
\end{en}

\begin{it}
	\subsection{Architettura software}
\end{it}
\begin{en}
	\subsection{Software architecture}
\end{en}

\begin{figure}[H]
	\centering
	\resizebox{\ifdim\width>\linewidth\linewidth\else\width\fi}{!}{\input{diagrams/itgmobile}}
	\begin{it}
		\caption{L'architettura di \textit{InteGRa Mobile} raffigurata con un diagramma}
	\end{it}
	\begin{en}
		\caption{The architecture of \textit{InteGRa Mobile} as a diagram}
	\end{en}
	\label{fig:itgmobliearch}
\end{figure}

\begin{it}
	Nella figura \ref{fig:itgmobliearch} si può notare come l'insieme dei
  componenti software all'interno del progetto siano organizzati e comunichino
  tra loro. Tale architettura è stata realizzata da me, basandosi
  sull'esperienza acquisita con il progetto \textit{InteGRa.Service}. Segue
  una spiegazione sintetica (organizzata in punti) del diagramma. 

  \begin{itemize}

  \item L'applicazione non comunica direttamente con il gestionale, ma tramite
    una serie di chiamate \textsc{REST}\cite{wiki:rest} ad un endpoint lato
    server (chiamato \textit{InteGRaREST}) che svolge il ruolo di intermediario.

  \item Tale componente è una Java WebApplication che utilizza una libreria
    sviluppata internamente (chiamata \textit{restaurant}) per offrire le rotte
    accessibili al client e per interagire con il database di
    \textit{InteGRa}, una normale istanza di \textit{PostgreSQL}.

  \item Nella fase di comunicazione tramite HTTP, i dati in input vengono
    trasmessi come \texttt{application/x-www-form-urlencoded} mentre
	  i dati in output vengono trasmessi come \textsc{JSON}\cite{wiki:json}, e le
    sessioni vengono identificate con un token presente come parametro nella
    query string di ciascuna richiesta;

  \item \textit{InteGRaREST} effettua autonomamente query \textsc{SQL} al
    database per recuperare velocemente informazioni aventi
    struttura dati e logiche di memorizzazione semplici;

  \item Nel caso sia necessario interagire con record complessi,
    \textit{InteGRaREST} comunica con \textit{InteGRa} attraverso
    chiamate \textsc{SOAP}\cite{wiki:soap};

 \item \textit{InteGRa Mobile}, l'applicazione per dispositivi mobili, comunica
   con \textit{InteGRaREST} grazie a una versione client di \textit{restaurant},
   in grado di gestire (in modo limitato) operazioni eseguite in mancanza di
   connessione alla rete. 

 \end{itemize} 
\end{it}
\begin{en}
	\blindtext
\end{en}

\begin{it}
  \subsubsection{\textit{restaurant} -- lato server}
  La libreria \textit{restaurant}\footnote{Il nome \textit{restaurant} è un
    gioco di parole sull'acronimo REST.} viene importata
  come una normale dipendenza Maven\cite{maven:website}. Essa dipende da:
  \begin{description}
    \item[Hibernate ORM\cite{hibernate:website}] un famoso Object/Relation
      Mapper\cite{wiki:orm} per Java, utile ad interrogare il database
      \textit{PostgreSQL} con facilità;
    \item[GSON\cite{gson:website}] una libreria di Google per serializzare
      e deserializzare oggetti Java in JSON;
    \item[Jersey\cite{jersey:website}] un'implementazione dell'API JAX-RS
      per realizzare gli endpoint REST. Ciò avviene senza servlet ma tramite
      semplici metodi contenuti in classi senza ``padre'' dette \textit{controller},
      opportunamente decorati con le annotazioni nel package
      \texttt{javax.ws.rs}.
  \end{description}

  Le operazioni richieste per interrogare la base di dati sono ulteriormente
  semplificate dal codice contenuto in \textit{restaurant} su due livelli:
  \begin{itemize}
    \item È possibile eseguire normali operazioni di CRUD\cite{wiki:crud}
      nonchè costruire manualmente query tramite i metodi statici della classe
      \textit{CRUDUtils}, che lavorano in input e in output con istanze delle
      classi ``entità'';
    \item Inoltre, è possibile creare nuovi \textit{controller} con facilità
      ereditando dalle classi astratte \textit{JsonProducer} (per
      implementare funzioni al di fuori di CRUD),
      \textit{ReadableRESTController} (per implementare operazioni in sola
      lettura, equivalenti alla ``Read'' in CRUD) e \textit{CRUDRESTController}
      (per implementare CRUD completi), che offono
      metodi in grado di generare autonomamente risposte in JSON, sia in caso
      di successo che in errore.
  \end{itemize}

  Seguono le interfacce delle classi \textit{CRUDUtils}, \textit{JsonProducer},
  \textit{ReadableRESTController} e \textit{CRUDRESTController}, complete di
  Javadoc (in inglese, come presente nei sorgenti originali).
\end{it}

\begin{lstlisting}[caption=Interfaccia della classe \textit{JsonProducer}, label={lst:jsonprd-java}, language=Java]
/**
 * Something that generates JSON responses
 */
public abstract class JsonProducer {
  
    protected static final Logger log = %*\ldots*);
  
    protected static final Gson GSON = %*\ldots*);
  
    /**
     * Generates a json response with status 200 containing an object
     *
     * @param o the contents of the response
     * @return JSON response
     */
    protected Response jsonResponse(Object o) { %*\ldots*) }
    
    /**
     * Generates a json response with custom status containing an object
     *
     * @param o      the contents of the response
     * @param status status of the response
     * @return JSON response
     */
    protected Response jsonResponse(Object o, int status) { %*\ldots*) }
  
    /**
     * Generates a json response containing a library standard error
     *
     * @param error the error
     * @return JSON error response
     */
    protected Response jsonErrResponse(Error error) { %*\ldots*) }
  
    /**
     * Generates a json response containing a custom error
     *
     * @param error the error
     * @return JSON error response
     */
    protected Response jsonErrResponse(ErrorDetails error) { %*\ldots*) }
    
    /**
     * Generates an error response if the parameter given as argument 
     * is null or an empty string
     *
     * @param s        parameter
     * @param propName parameter name, used in the error description
     * @return JSON error response or null if the parameter is valid
     */
    protected Response require(Object s, String propName) { %*\ldots*) }
}
\end{lstlisting}
\begin{it}
  Per una migliore lettura del listato \ref{lst:jsonprd-java}, si precisa che la
  classe \textit{Error} è una enumerazione Java contenente messaggi di errore
  standard. La classe \textit{ErrorDetails}, invece, permette al codice esterno
  di realizzare messaggi di errore personalizzati. Inoltre, l'oggetto statico
  \texttt{GSON} di classe \textit{Gson} è il serializzatore a JSON offerto dalla
  libreria omonima.
\end{it}

\begin{lstlisting}[caption=Interfaccia della classe \textit{ReadableRESTController}, label={lst:rdbrest-java}, language=Java]
/**
 * A REST Controller only readable
 * @param <T> The readable entity class
 */
public abstract class ReadableRESTController<T extends Readable,
    U extends PrimaryKey<T>> extends JsonProducer {
	
    /**
     * Interface used to carry a function capable of filtering a list 
     * of entities after it has been retrieved from the database
     *
     * @param <T> The readable entity class
     */
    public interface ListFilter<T extends Readable> {
        List<T> filter(List<T> toFilter);
    }
    
    /**
     * Returns the class of the readable entity. Used as parameter for
     * CRUDUtils
     *
     * @return the class of the readable entity
     */
    protected abstract Class<T> getBeanClass();

    protected final Logger log = %*\ldots*);
	
    /**
     * Returns a response with a standard unfiltered, unpaginated list
     * of entities
     *
     * @return JSON response, success or not
     */
    protected Response list() { %*\ldots*) }
    
    /**
     * Returns a list of entities, customizable in many ways
     *
     * @param filter map of names of fields and their values which must
     *               be equal in the fetched entities (null accepted if 
     *               not used)
     * @param otherFilter list of additional filters (Hibernate Criterion
     *                    objects, null accepted if not used)
     * @param order order of the entities (Hibernate Order, null accepted
     *              if not used)
     * @param afterDb implementation of interface containing a function
     *                capable of filtering a list of entities (null accepted
     *                if not used)
     * @param page the page number to fetch (starts at 1, null accepted
     *             if not used)
     * @return JSON response, success or not
     */
    protected Response list(Map<String, Object> filter,
        List<Criterion> otherFilter, Order order,
        ListFilter<T> afterDb, Integer page) { %*\ldots*) }

    /**
     * Returns a response with a single entity given its primary key
     *
     * @param filterOne map of names of columns and their values containing
     *                  the primary key
     * @return JSON response, success or not
     */
    protected Response get(Map<String, Object> filterOne) { %*\ldots*) }

    /**
     * Returns a response with a single entity given its primary key
     *
     * @param pk the primary key
     * @return JSON response, success or not
     */
    protected Response get(PrimaryKey<T> pk) { %*\ldots*) }

    /**
     * Returns the existing primary keys given a set of primary keys sent
     * as a JSON array
     *
     * @param requestBody the request body with JSON data
     * @return JSON array of the existing primary keys or error response
     */
    protected Response existing(InputStream requestBody) { %*\ldots*) }	
}
\end{lstlisting}
\begin{it}
  Anche il listato \ref{lst:rdbrest-java} necessita di una breve spiegazione.
  La classe astratta \textit{Readable}, vincolo sul primo parametro generico della classe,
  è il padre di ogni classe ``entità'', mentre \textit{PrimaryKey<T>} è il padre
  della classe contenente la chiave primaria di \textit{T}. Un'istanza della
  classe figlia di \textit{PrimaryKey<T>} è contenuta come attributo nella
  classe ``entità'' \textit{T}, che a sua volta estende \textit{Readable}. 
\end{it}

\begin{lstlisting}[caption=Interfaccia della classe \textit{CRUDRESTController}, label={crudrest-java}, language=Java]
/**
 * A REST Controller readable and writable
 * @param <T> The readable and writable entity class
 */
public abstract class CRUDRESTController<T extends CRUDable, U extends 
    PrimaryKey<T>> extends ReadableRESTController<T, U> {

    /**
     * A standard edit route body. Edits an entity and returns a JSON 
     * response, both on success and on error.
     *
     * @param filterOne map containing columns and relative values of the
     *                  primary key of the entity to edit
     * @param form request data containing the fields to edit
     * @return JSON response, positive or negative
     */
    protected Response edit(Map<String, Object> filterOne,
                            MultivaluedMap<String, String> form) { %*\ldots*) }

    /**
     * A standard edit route body. Edits an entity and returns a JSON
     * response, both on success and on error.
     *
     * @param pKey the entity primary key
     * @param form request data containing the fields to edit
     * @return JSON response, positive or negative
     */
    protected Response edit(PrimaryKey<T> pKey, 
        MultivaluedMap<String, String> form) { %*\ldots*) }

    /**
     * A standard delete route body. Deletes an entity and returns a JSON 
     * response, both on success and on error.
     *
     * @param pKey the entity primary key
     * @return JSON response, positive or negative
     */
    protected Response delete(PrimaryKey<T> pKey) { %*\ldots*) }

    /**
     * A standard delete route body. Deletes an entity and returns a JSON
     * response, both on success and on error.
     *
     * @param filterOne map containing columns and relative values of the
     *                  primary key of the entity to delete
     * @return JSON response, positive or negative
     */
    protected Response delete(Map<String, Object> filterOne) { %*\ldots*) }

    /**
     * A standard create route body. Creates an entity and returns a JSON
     * response, both on success and on error.
     *
     * @param form request data containing the entity column values
     * @return JSON response, positive or negative
     */
    protected Response create(MultivaluedMap<String, String> form) { %*\ldots*) }

    %*\ldots*)
}
\end{lstlisting}

\begin{it}
  Si precisa che la classe \textit{CRUDable} è un estensione della classe
  \textit{Readable} che contiene metodi per l'inizializzazione dell'oggetto
  sulla base di dati in input, contenuti in \textit{MultivaluedMap<String,
    String>}. Di conseguenza, le classi ``entità'' che estendono CRUDable
  possono essere usate per operazioni di scrittura, come quelle implementate
  da \textit{CRUDRESTController}.
\end{it}

\begin{lstlisting}[caption=Interfaccia della classe \textit{CRUDUtils}, label={lst:crudutils-java}, language=Java]

/**
 * Database access class. Access statically
 */
public abstract class CRUDUtils {

    /**
     * Interface containing a function able to generate an Hibernate Query
     * object and execute it by getting a generic response given the 
     * session
     *
     * @param <T> the response type
     */
    public interface HBMInteraction<T> {
        T execute(Session s);
    }

    /**
     * Interface containing a function able to generate an Hibernate Query
     * object and execute it by getting a list of rows given the session
     */
    public interface HBMQuery extends HBMInteraction<List<Object[]>> {
        List<Object[]> execute(Session s);
    }

    /**
     * Number of items on a single page. Used when pagination is requested
     */
    public static final int ITEMSPERPAGE = %*\ldots*);

    %*\ldots*) 

    private static final Logger log = %*\ldots*);

    /**
     * Save a writable entity on the database
     *
     * @param o the entity to save
     * @param <T> type of the entity. Must be readable and writable
     * @return boolean true = success, false = error
     */
    public static <T extends CRUDable> boolean persist(final T o) { %*\ldots*) }

    /**
     * Delete a writable entity on the database
     *
     * @param toDelete the entity to delete
     * @param <T> type of the entity. Must be readable and writable
     * @return boolean true = success, false = error
     */
    public static <T extends CRUDable> boolean delete(final T toDelete)
        { %*\ldots*) }

    %*\ldots*)

    /**
     * Execute a query which returns data of a generic type
     *
     * @param query HBMInteraction implementation
     * @param <T> The returning type
     * @return the data
     */
    public static <T> T executeHBMInteraction(HBMInteraction<T> query)
        { %*\ldots*) }

    /**
     * Get a list of entities
     *
     * @param tClass class of the entities
     * @param restrictions map of names of fields and their values which
     *                     must be equal in the fetched entities
     *                     (null accepted if not used)
     * @param criteria list of additional filters (Hibernate Criterion
     *                 objects, null accepted if not used)
     * @param <T> entity type. Must be readable
     * @param o order of the entities (Hibernate Order, null accepted if
     *          not used)
     * @param page the page number to fetch (starts at 1, null accepted if
     *             not used)
     * @return the list of entities
     */
    public static <T extends Readable> List<T> get(Class<T> tClass,
        Map<String, Object> restrictions, List<Criterion> criteria,
        Order[] o, Integer page) { %*\ldots*) }
    
    /**
     * Get a list of entities
     *
     * @param tClass class of the entities
     * @param <T> entity type. Must be readable
     * @return the list of entities
     */ 
    public static <T extends Readable> List<T> get(Class<T> tClass) { %*\ldots*) }


    /**
     * Get a single entity
     *
     * @param tClass class of the entities
     * @param restrictions map of names of fields and their values which
     *                     must be equal in the fetched entities
     *                     (null accepted if not used)
     * @param <T> entity type. Must be readable
     * @return the list of entities
     */
    public static <T extends Readable> T getOne(Class<T> tClass,
        Map<String, Object> restrictions) { %*\ldots*) }

    /**
     * Get a single entity
     *
     * @param tClass class of the entities
     * @param pk the primary key object of the entity
     * @param <T> entity type. Must be readable and contain a primary key
     *            object
     * @return the list of entities
     */
    public static <T extends Readable> T getOne(Class<T> tClass,
        PrimaryKey<T> pk) { %*\ldots*) }
}
\end{lstlisting}

\begin{it}
  Oltre a quanto mostrato, \textit{restaurant} contiene vari metodi utilità per
  la gestione di file \texttt{.properties}, per la validazione dei dati in
  input, per la registrazione della \textit{timestamp} di creazione o modifica
  di un record, e altro ancora.
\end{it}

\begin{it}
  \subsubsection{\textit{restaurant} -- lato client}
\end{it}
\begin{lstlisting}[caption=Interfaccia della classe \textit{RESTService}, label={lst:restservice-ts}, language=Java]
export class RESTService {

  ...

  /**
   * Read all the pages of an entity in order to save them for offline
   * readings.
   *
   * @param {{ new(): T }} - class of the table to read
   * @param {any} - key data for the search. Must not contain filters
   *                or a field with key '_page'
   * @return {Promise<boolean>} boolean promise that resolves when the
   *                            reading has been done, true if succesful,
   *                            false if not
   */
  public bulkRead<T extends Table>(type: TableStatic, restrictions?: any):
    Promise<boolean> { ... }

  /**
   * Retrieves a list of entities. When online and requested without
   * filters, the list is saved in the offline storage. When offline,
   * the data from the offline storage is read and filtered accordingly.
   *
   * Request criteria regarding directly properties of the entity MUST
   * have the following format:
   *
   * 'attr-' + name_of_property[.nested] [+ '||' + other_property] +
   * ('-like' | '-eq' | '-flag' | '-gt' | '-lt' | '-gte' | '-lte')
   *
   * Multiple field names separed by '||' state that the search must be
   * done on multiple fields with a logic OR.
   *
   * The different suffixes denote different logical criteria. Look up
   * the documentation of meetsCriteriaFilter*(...) methods in
   * order to get detailed info on each one.
   *
   * @param {{ new(): T }} type - type of the table to read
   * @param {number} page - number of the page starting at 1 (in offline
   *                        mode, a 20 entities slice; in online mode,
   *                        as defined by the server). -1 is for no
   *                        pagination
   * @param {any} restrictions - restrictions required by the server,
   *                             and filters.
   * @param {boolean} offline - whether to fetch (true) or not (false)
   *                            offline entities to sync. Defaults to true
   * @return {Promise<T[]>} - promise of the expanded list, unsuccesful
   *                          when the storage readings are unsuccesful
   */
  public read<T extends Table>(type: TableStatic, page: number,
    restrictions?: any, addOffline?: boolean): Promise<T[]> { ... }

  /**
   * Asks to the server which entity instances of the ones
   * saved in the offline storage exist and deletes the
   * ones that do not exist on the server.
   *
   * @param {TableStatic} type - the entity type
   * @return {Promise<void>} promise rejecting only if an error occurs
   */
  private async existing(type: TableStatic): Promise<void> { ... }

  /**
   * Reads a single entity, even in the offline storage if offline.
   *
   * @param {{ new(): T }} type - class of the entity to read
   * @param {any} keyData - the primary key fields and their values
   *                        in a JS Object, plus the 'id' field of
   *                        type string used in the end bit of the
   *                        request path.
   * @return {Promise<T>} - promise of the element, unsuccesful if
   *                        not found.
   */
  public readOne<T extends Table>(type: TableStatic | string,
    keyData: any): Promise<T> { ... }

  /**
   * Updates an entity on the server or, if offline, saves it in the
   * offline sync queue.
   *
   * @param {{ new(): T }} type - class of the entity to be saved
   * @param {T} value - the entity to save
   * @param {any} keyData - the primary key fields and their values
   *                        in a JS Object, plus the 'id' field of
   *                        type string used in the end bit of the
   *                        request path.
   * @return {Promise<T>} - promise of the saved element.
   */
  public update<T extends Table>(type: TableStatic | string, value: T,
    keyData: any): Promise<T> { ... }
  
  /**
   * Creates an entity on the server or, if offline, saves it in the
   * offline sync queue.
   *
   * @param {{ new(): T }} type - class of the entity to be deleted
   * @param {string} id - string used in the end bit of the request path.
   * @param {any} keyData - the primary key fields and their values in
   *                        a JS Object
   * @return {Promise<T>} - promise of the element deleted
   */
  public create<T extends Table>(type: TableStatic | string, value: T):
    Promise<T> { ... }
    
  /**
   * Deletes an entity on the server or, if offline, marks it for
   * deletion in the offline sync queue.
   *
   * @param {{ new(): T }} type - class of the entity to be saved
   * @return {Promise<T>} - promise of the element created.
   */
  public delete<T extends Table>(type: TableStatic | string, keyData: any):
    Promise<T> { ... }
}
\end{lstlisting}

\begin{it}
	\subsection{Stato del progetto}
\end{it}
\begin{en}
	\subsection{Project status}
\end{en}

\begin{figure}[H]
	\centering
	\resizebox{\ifdim\width>\linewidth\linewidth\else\width\fi}{!}{
		\begin{ganttchart}{1}{49}
			\gantttitle{2017}{28}
			\gantttitle{2018}{21} \\
			\gantttitle{6}{2}
			\gantttitle{7}{4}
			\gantttitle{8}{5}
			\gantttitle{9}{4}
			\gantttitle{10}{4}
			\gantttitle{11}{5}
			\gantttitle{12}{4}
			\gantttitle{1}{5}
			\gantttitle{2}{4}
			\gantttitle{3}{4}
			\gantttitle{4}{4}
			\gantttitle{5}{4} \\
			\gantttitlelist{25,...,52}{1}
			\gantttitlelist{1,...,21}{1} \\
			\ganttbar[name=prg]{Progettazione}{1}{1} \\
			\ganttlinkedbar[name=ir]{Impl. \textit{restaurant}}{2}{37} \\
			\ganttgroup[name=funz]{Impl. sezioni}{2}{13} \\
			\ganttbar{Inv. di magazzino}{2}{4} \\
			\ganttbar{Agenda}{5}{6} \\
			\ganttbar{Soggetti}{7}{8} \\
			\ganttbar{Ordini cliente}{11}{13} \\
			\ganttbar[name=tf]{Test per sezioni}{14}{16} \\
			\ganttlinkedgroup[name=tr]{Rifinim. \textit{restaurant}}{19}{46} \\
			\ganttbar{Adattam. architettura}{19}{37} \\
			\ganttbar[name=str]{Test}{38}{46} \\
			\ganttbar[name=ril]{Finalizzazione}{47}{49}
			\ganttlink{funz}{tf}
			\ganttlink{prg}{funz}
			\ganttlink{ir}{str}
			\ganttlink{tr}{ril}
		\end{ganttchart}
	}
	\begin{it}
		\caption{Il diagramma di Gantt del progetto
			\textit{InteGRa Mobile}}
	\end{it}
	\begin{en}
		\caption{\textit{InteGRa Mobile} Gantt diagram} 
	\end{en}
	\label{fig:ganttitgmob}
\end{figure}

\begin{it}
	Nella lettura del diagramma di Gantt in figura \ref{fig:ganttitgmob} \`e necessario tenere a mente che il completamento dell'intera applicazione non \`e certo per
	la fine di maggio. Ci\`o che dovr\`a essere necessariamente completato \`e la parte pi\`u importante del progetto:
	\textit{restaurant}, il motore di sincronizzazione online/offline e libreria generica che permette di implementare
	velocemente nuove sezioni dell'applicazione.
\end{it}
\begin{en}
	\blindtext
\end{en}
\begin{it}
	\subsection{Fasi del progetto}
	
	Le fasi del progetto, di cui date di inizio e fine sono state specificate nel diagramma in figura \ref{fig:ganttitgmob}, sono:
	
	\begin{description}

	\item[Progettazione] delineazione delle funzionalità da implementare
    nell'applicazione e prime bozze dell'interfaccia utente;
    
	\item[Implementazione \textit{restaurant}] implementazione della libreria, su
    cui si basano tutte le sezioni del programma. Vista l'importanza di questo
    componente, gli sviluppi vengono continuati in parallelo con
    l'implementazione delle sezioni;
    
	\item[Implementazione sezioni] creazione di interfaccia e logica per le
    funzionalit\'a previste, cio\'e:
	\begin{itemize}
	\item Magazzini;
	\item Agenda;
	\item Soggetti;
	\item Ordini cliente;
	\end{itemize}
  
  \item[Test per le sezioni] messa alla prova degli algoritmi e della UI per
    efficacia ed efficienza, nonch\'e eventuali correzioni;
  
	\item[Rifinimento \textit{restaurant}] messa alla prova delle scelte
    architetturali e algoritmi usati nella libreria e rifinimento di essi;
    Fase divisa in:
	\begin{description}
	\item[Miglioramento architettura] analisi del protocollo per individuare
    punti di debolezza e possibili ottimizzazioni;
	\item[Test per \textit{restaurant}] messa alla prova dei cambiamenti fatti;
	\end{description}
  
\item[Finalizzazione] task finali del progetto, tra cui branding, operazioni
  pre-rilascio, e gestione di eventuali personalizzazioni richieste dai clienti.

\end{description}
\end{it}
\begin{en}
	\subsection{Project phases}
	
	\blindtext
\end{en}

\section{Il progetto secondario: \textit{Guac Remote}}
Questo progetto \`e destinato ad un'importante azienda del territorio, produttrice di macchine equilibratrici. Tale applicazione dovrebbe fungere da client di
desktop remoto (come \textit{TeamViewer}\footnote{TeamViewer: \url{https://www.teamviewer.com/it/}}) per il PC presente nel loro prodotto di punta, un sistema di calibrazione delle
ruote di autoveicoli funzionante mediante telecamere. Il programma dovrebbe permettere all'operatore di tale prodotto di interagire con il software presente nel macchinario, senza scendere dal veicolo.

A causa di urgenza del committente, lo sviluppo di questo progetto ha interrotto e attualmente interrompe gli sviluppi
per \textit{InteGRa Mobile}.

\subsection{Architettura software}

\begin{figure}[H]
	\centering
	\resizebox{\ifdim\width>\linewidth\linewidth\else\width\fi}{!}{\input{diagrams/guacremote}}
	\caption{L'architettura di \textit{Guac Remote}}
	\label{fig:argosarch}
\end{figure}

\textit{Guac Remote} è basata su un'applicativo e libreria per la connessione a computer remoto chiamato \textit{Apache Guacamole}\cite{guacamole:website}.
Tale software è costituito da due parti: \cite{guacdoc:arch}
\begin{description}
	\item[\textit{guacamole-server} (o \textit{guacd})] un servizio scritto in C che funge da adattatore tra il protocollo \textit{guacamole} e i protocolli VNC, RDP o SSH, utilizzando questi ultimi per stabilire connessioni con gli host remoti;
	\item[\textit{guacamole-client}] una WebApplication scritta tramite \textit{Java servlet} che fornisce un'interfaccia web per interagire con \textit{guacamole-server} e connettersi ai PC remoti.
\end{description} 
Data la natura open-source del progetto, sia \textit{guacamole-server} che \textit{guacamole-client} possono essere usati come libreria per la realizzazione di software derivati. In particolare, \textit{guacamole-client} può essere scomposto nelle librerie \textit{guacamole-common-js}, che contiene il codice Javascript per il client, e \textit{guacamole-common}, che fornisce classi Java per la connessione con \textit{guacamole-server}. \cite{guacdoc:api}

In \textit{Guac Remote}, \textit{Apache Guacamole} è usato per fornire accesso remoto al PC presente nel macchinario, che contiene l'applicativo per la calibrazione, all'applicazione installata sul tablet. Nel dettaglio, \textit{guacamole-common-js} è usato nell'applicazione \textit{mobile} fornire un'interfaccia touchscreen per interagire con l'host remoto, mentre \textit{guacamole-common}, tramite una piccola WebApplication, assieme a \textit{guacamole-server} sono installati sul PC.

In aggiunta, tablet e PC possono comunicare informazioni aggiuntive tramite una WebSocket creata al momento della connessione, necessaria per alcune estensioni al protocollo richieste dal cliente.

\subsection{Stato del progetto}

\begin{figure}[H]
	\centering
	\resizebox{\ifdim\width>\linewidth\linewidth\else\width\fi}{!}{
		\begin{ganttchart}{1}{22}
			\gantttitle{2018}{22} \\
			\gantttitle{2}{6}
			\gantttitle{3}{8}
			\gantttitle{4}{8} \\
			\gantttitlelist{7,...,17}{2} \\
			\foreach \n in {7,...,17}{
				\gantttitle{G}{1}
				\gantttitle{V}{1}	
			} \\
			\ganttbar[name=prg]{Incontro con il cliente}{1}{1} \\
			\ganttlinkedbar{Realizzazione primo prototipo}{2}{4} \\
			\ganttlinkedbar{Prima demo al cliente}{5}{5} \\
			\ganttlinkedbar{Stime orarie per sviluppi futuri}{6}{6} \\
			\ganttlinkedgroup[name=impl]{Implementazione richieste \ldots}{8}{12} \\
			\ganttbar{Apertura tastiera e zoom \ldots}{8}{9} \\
			\ganttbar{Input tramite tastiera nativa \ldots}{10}{10} \\
			\ganttbar{Scroll a due dita}{11}{11} \\
			\ganttbar{Interfaccia di configurazione}{12}{12} \\
			\ganttbar[name=demodef]{Demo al cliente}{13}{13} \\
			\ganttlinkedbar{Implementazione richieste agg\ldots}{14}{20} \\
			\ganttlinkedbar{Consegna}{21}{22}
			\ganttlink{impl}{demodef}
		\end{ganttchart}
	}
	\caption{Il diagramma di Gantt del progetto \textit{Guac Remote}}
	\label{fig:ganttargos}
\end{figure}

% TODO: cambiare quando diventa tesina vera e propria
Questo progetto, al giorno 06/04, non ha ritardi. L'applicazione \'e stata mostrata in demo il giorno 29/03, ed il cliente si ritiene soddisfatto del lavoro fatto fino ad ora.

\subsection{Fasi del progetto}

Le fasi del progetto, di cui le date di inizio e di fine sono indicate nel diagramma della figura \ref{fig:ganttargos}, sono:

\begin{description}
\item[Incontro con il cliente] primo scambio di informazioni per capire gli obiettivi del progetto;
\item[Realizzazione primo prototipo] dimostrazione dell'efficacia del protocollo \textit{guacamole} tramite un prototipo del prodotto;
\item[Prima demo al cliente] demo del prototipo al cliente;
\item[Stime orarie per sviluppi futuri] delineazione della tabella di marcia per gli sviluppi futuri;
\item[Implementazione richieste del cliente] sviluppo delle estensioni al protocollo richieste. Nel dettaglio, esse sono:
\begin{description}
\item[Apertura tastiera e zoom al ``focus'' di un input] alla pressione di un campo di testo, l'applicazione \textit{mobile} deve automaticamente ingrandire l'area selezionata e mostrare una tastiera;
\item[Input tramite tastiera nativa Android o iOS] sostituzione della tastiera su schermo di \textit{guacamole-common-js} con quella nativa;
\item[Scroll a due dita] supporto della gesture di scroll verticale a due dita;
\item[Interfaccia di configurazione] creazione di una piccola finestra di configurazione, in cui inserire IP e porta del PC;
\end{description}
\item[Demo al cliente] dimostrazione degli sviluppi fatti al cliente e eventuale definizione di richieste aggiuntive;
\item[Implementazione delle richieste aggiuntive del cliente]
\item[Consegna] operazioni finali del progetto, tra cui branding e compilazione per rilascio.
\end{description}

\newpage

\pagenumbering{gobble}

\listoffigures
\lstlistoflistings
\printbibliography

\end{document}