Manipolare gli eventi con Vue.js

In questo articolo parleremo di come manipolare gli eventi con Vue.js, da quelli nativi del framework, passando per quelli personalizzabili e infine parlando del bus degli eventi.
Ecco, in dettaglio, i contenuti che tratteremo:

  • Manipolare eventi con Vue
  • Tipi di eventi che si possono manipolare
  • Metodi per la gestione degli eventi
  • Oggetti Evento
  • Modificatori Eventi
  • Eventi personalizzati
  • Bus Eventi

Quando vuoi creare un sito web dinamico probabilmente vuoi che sia in grado di rispondere agli eventi. Esistono molti tipi di eventi in un sito, sia appartenenti al framework che personalizzabili a seconda degli obbiettivi. Un sito senza eventi non è altro un insieme di dati e scritte con cui l'utente non può interagire.

Ad esempio, se un utente fa un click su un pulsante, invia un modulo o sposta semplicemente il mouse, il sito dinamico che utilizza Vue dovrà rispondere in qualche maniera, facendo apparire un messaggio o inviando una richiesta a qualche componente.

Vediamo come si possono gestire questi eventi con Vue.js, il framework open-source di Javascript per la creazione dell'interfaccia utente e delle Single Page Applications.

Manipolare eventi con Vue

Possiamo catturare un evento soltanto aggiungendo la direttiva v-on al relativo elemento DOM con cui vogliamo interagire, seguito dall'evento che vogliamo catturare.
Supponiamo di voler gestire il click dell'utente su un pulsante: possiamo aggiungere la direttiva all'elemento e il nostro modello Vue diventerebbe:

<button v-on:click="clickHandler"></button>

Notiamo, quindi, che aggiungendo una direttiva all'argomento v-on, questo sarà il nome dell'evento che vogliamo gestire (nel nostro caso il click).

Associamo, ora, un'espressione alla direttiva, che sarà il nome del metodo che si desidera utilizzare per gestire l'evento. Come possiamo vedere sopra è stato chiamato "ClickHandler".

Suggerimento: la direttiva v-on ha una comoda scorciatoia "@" che può essere utilizzata al posto di v-on nel seguente modo:

<button @click = "clickHandler"></button>

Sono a tutti gli effetti dei "sinonimi" quindi potete usare quello che stilisticamente vi aggrada di più.

Tipi di eventi che si possono manipolare

Oltre al semplice click, quali altri eventi appartenenti al DOM possono essere gestiti con questo framework? Vue.js, facendo parte di Javascript, può gestire qualsiasi tipo di evento nativo Web o Mobile (nonchè eventi personalizzati di cui si parlerà più avanti) tra cui troviamo:

  • Submit,
  • Keyup,
  • Drag,
  • Scroll,
  • Reset,
  • Abort.

E molti altri. Qui potete trovare una lista completa degli eventi più comuni DOM. Una volta quindi identificato l'evento che ci serve e il componente che emetterà lo stesso, con v-on o @ possiamo collegarli in maniera molto sepmplice ed efficace.
Vediamo ora che metodi abbiamo a disposizione per la gestione degli eventi.

Metodi per la gestione degli eventi

Nella gestione degli eventi possiamo associare un metodo al nostro evento, creando così un codice personalizzato a seconda degli scopi del nostro sito.
Manteniamo semplice il nostro esempio per capire il funzionamento generale e registriamo un messaggio sulla console. Ovviamente potremmo fare qualcosa di più interessante come mostrare/nascondere un altro elemento, incrementare il contatore ecc ecc.

<div id="app">
  <button v-on:click="clickHanlder"></button>
</div>

new Vue({
  el: "#app",
  methods: {
    clickHandler () {
      console.log("You clicked the button!");
    }
  }
})

Come possiamo vedere una volta raccolto il segnale dell'evento avvenuto, il metodo all'interno del nostro elemento Vue farà apparire nella console la scritta "You clicked the button!".
Una altra cosa da notare è che mentre nell'elemento <button> clickHandler è il nome dell'evento, nell'elemento Vue è una funzione, e quindi viene rappresentato come clickHandler().

Oggetti evento

Possiamo anche passare alla funzione un'oggetto chiamato event. La funzione che abbiamo creato diventerà un'eventHandler, e ciò apre molte più possibilità su come rispondere allo stesso.
Questo oggetto contiene molte proprietà e metodi utili tra cui un riferimento all'elemento da cui ha avuto origine (event.target), l'ora in cui si è verificato (event.timeStamp) e altro.
Tutte queste proprietà possono essere viste nella console e sono davvero moltissime. Vediamo come si trasforma la nostra funzione.

clickHandler (event) {
  console.log(`The button was clicked at ${event.timeStamp}.`);
}

Notiamo che questo oggetto è fornito dall'API nativa, non da Vue, quindi è lo stesso oggetto che potremmo trovare in Javascript puro. Ecco il riferimento dell'interfaccia dell'evento per comodità.

Modificatori eventi

Una buona pratica comune nelle app Javascript è gestire manualmente l'invio di un modulo anzichè utilizzare la funzione nativa. Per fare ciò, è necessario utilizzare il metodo nativo preventDefault() dell'evento di invio prima di eseguire il codice di gestione dei moduli, altrimenti la pagina verrà reindirizzata prima che possa essere completata.
preventDefault() è un metodo dell'interfaccia event presentata prima, in sostanza dice che se l'evento non viene esplicitamente gestito, la sua azione predefinita non deve essere presa come "normale".

formHandler (event) {
  event.preventDefault();
  // form handling logic
}

Invece di farlo manualmente nel handler, Vue offre un modificatore di eventi per farlo direttamente dal modello.
La sintassi quindi prevede il richiamo all'evento (con v-on o @) e il modificatore successivamente. Si noti che il modificatore viene aggiunto dopo il " . " nella directory corrente:

<form @submit.prevent="formHandler"></form>

Vue offre diversi modifcatori di eventi utili negli scenari comuni di gestione degli stessi:

  • .stop
  • .prevent
  • .capture
  • .self
  • .once
  • .passive

Ora che conosciamo gli eventi e come possiamo gestirli utilizzando il paramentro nativo event e i modificatori, vediamo come poter creare degli eventi personalizzati.

Eventi personalizzati

Finora abbiamo parlato della gestione di eventi nativi. Ma Vue è un framework basato su componenti, quindi possiamo fare in modo che un componente emetta il proprio evento?

Ovviamente la risposta è sì, e questo può essere molto utile nell'ottica di un sito con funzioni particolari. Supponiamo che un componente figlio (child) invii i dati a un componente genitore (parent). Non possiamo usare oggetti props in questo caso, poichè i dati di questi oggetti vanno solo da genitore a figlio e non viceversa.
Come sappiamo i props sono delle speciali keyword che sono usate per passare dati da un componente all'altro, l'unico intoppo sta nel fatto che sono unidirezionali e readonly quindi per il nostro caso non vanno bene.

ParentComponent
|
| (data travels down via props, never up)
v
ChildComponent

La soluzione è avere un figlio che emette un event e allo stesso tempo avere un genitore che lo ascolta.
Facciamo un esempio per chiarire ogni dubbio. Abbiamo un componente genitore chiamato MainPage, e un componente figlio chiamato DialogComponent.
Quando il figlio viene chiuso, questo emetterà un evento ascoltato dal padre.
Per fare questo chiamiamo this.$emit("my-event") dal componente figlio quando vogliamo che l'evento venga emesso.

DialogComponent

export default {
  methods: {
    onClose() {
      this.$emit("dialog-closed");
    }
  }
};

Il componente genitore può poi gestire l'evento personalizzato esattamente nella stessa maniera con cui avrebbe gestito un evento nativo del linguaggio.

MainPage

<div>
  <dialog-component @dialog-closed="eventHandler" />
</div>

Possiamo anche inviare dati dell'oggetto event al nostro evento personalizzato, il quale può essere ricevuto nel metodo di handling.

DialogComponent

onClose() {
  this.$emit("dialog-closed", { time: Date.now() });
}

MainPage

eventHandler (event, { time }) {
  console.log(`Dialog was closed at ${time}`);
}

Suggerimento: usa i kebab-case per i nomi del tuo evento personalizzato! I kebab-case è una pratica di scrivere gli identificatori separando le parole che lo compongono con dei trattini. HTML non fa distinzione fra maiuscole e minuscole, quindi un nome evento di tipo camel-case, ad esempio myEvent, sarà confuso col myevent nell'esempio.
Come possiamo intuire, il camel-case è invece la pratica di scrivere gli identificatori distinguendoli l'uno dall'altro trammite lettera maiuscola. E' meglio, quindi, usare kebab-case ad esempio "my-event" ed evitare confuzione nella generazione del codice.

Bus eventi

Come abbiamo visto sopra, un componente figlio può inviare un evento ad un componente padre. Ma cosa succede se si desidera che un componente invii un evento a qualsiasi altro componente nella gerarchia? Ad esempio ad un fratello, ad un nonno e cosi via.

Per raggiungere questo obbiettivo possiamo usare un modello chiamato "bus degli eventi". Creiamo un'istanza separata di Vue per trasportare un evento a qualsiasi componente che lo importa.

Prima di tutto, creiamo ed esportiamo un'istanza di Vue in un nuovo file del modulo:

eventBus.js

import Vue from "vue";
export default new Vue();

Poi, importiamo il bus nel componente dove vorremmo emettere il nostro evento. Possiamo usare l'$emit metodo dell'istanza Vue che abbiamo già visto in precedenza e tra parentesi mettiamo il nome dell'evento emesso.

import eventBus from "./eventBus";export default {
  ...
  methods: {
    myMethod () {
      eventBus.$emit("my-event")
    }
  }
}

Infine, importiamo il bus di un componente in cui desideriamo ascoltare l'evento. Dovremmo, però, impostare un ascoltatore da qualche parte nel nostro codice. Utilizziamo, quindi, un hook del ciclo di vita come created, in quanto possiamo accedere all'istanza del componente in quel punto del codice.

Questo viene fatto con il metodo $on del bus che accetta due argomenti: il nome dell'evento che si desidera ascoltare e una funzione di callback (che nel nostro caso è una arrow-function).
Nel nostro esempio, come visto in precedenza, facciamo una semplice operazione di stampa nella console, ma voi potete sbizzarrirvi nella gestione di questi eventi facendo cose più interessanti.

import eventBus from "./eventBus";
export default {
  ...
  created () {
    eventBus.$on("my-event", () => {
      console.log("my-event called on global event bus");
    });
  }
}

Ed il gioco è fatto: un modo di condividere i dati tra tutti i componenti della tua app!

Per riassumere quindi:

  • se vogliamo inviare un evento dal padre al figlio possiamo utilizzare i props
  • se vogliamo inviare dal figlio al padre dobbiamo usare l'oggetto event e creare una connessione tra l'emit e l'ascoltatore (componente parent)
  • se vogliamo inviare il segnale in qualsiasi punto della gerarchia possiamo utilizzare il bus degli eventi e modificarlo a nostro piacimento.

Una soluzione più scalabile per il passaggio di dati in un'app consiste nell'utilizzare Vuex.

FONTE: Medium Anthony Gore


Guida a Spring Expression con Spring Boot

Una guida per imparare ad utilizzare il linguaggio di programmazione Spring Expression con annotazione @value.

Il simbolo di Spring

Il linguaggio Spring Expression (conosciuto anche come SpEL) è un potente linguaggio di “espressioni”, che può essere utilizzato per eseguire query e manipolare un grafo di oggetti in fase di esecuzione. SpEL è disponibile tramite XML o annotazione, viene valutato durante il tempo di creazione.

In questo articolo vedremo alcuni esempi di base dell’utilizzo di SpEL in Spring Boot, un linguaggio che rende semplice e rapida la creazione di progetti basati sui Framework Spring.

Una breve introduzione

Spring Boot supporta la maggior parte degli operatori aritmetici e logici, utilissimi per interrogare e manipolare un gruppo di oggetti. Per capire quali sono gli operatori più utilizzati guardiamo questa lista:

  • Condizionali, ? :
  • Aritmetica, +, -, *, /,%, ^, div, mod
  • Logica, and, or, not, &&, ||, !

Come vedremo nelle prossime sezioni, la creazione e la manipolazione di file XML è molto semplice, veloce e risulta facile l'iniezione di valori al suo interno.
Questo linguaggio permette anche l'analisi di espressioni al di fuori del contesto di configurazione, attraverso un tool chiamato SpELExpressionParser. Questo tool permette l'analisi di stringhe, l'impostazione di valori e la configurazione di un parser.
Vediamo più nello specifico come si comporta e come interagisce col mondo Spring Framework.

Impostazione dell’applicazione Spring Boot

In questa sezione creeremo una semplice applicazione Spring Boot con un file chiamato emplyee.properties, che salveremo nella directory delle risorse del nostro computer.
Guardiamo il codice:

employee.names=Petey Cruiser,Anna Sthesia,Paul Molive,Buck Kinnear
employee.type=contract,fulltime,external
employee.age={one:'26', two : '34', three : '32', four: '25'}

Come vediamo le proprietà del tipo che stiamo modellando sono tre:
- Nome,
- Tipo di Contratto e
- Età.
Ora che abbiamo definito le caratteristiche di un employee generale definiamo una classe che configura le varie proprietà.
Creeremo, quindi, una classe EmployeeConfig come segue:

package com.techshard.spel;
import 
org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@PropertySource (name = "employeeProperties", value = "employee.properties")
@ConfigurationProperties
public class EmployeeConfig {
}

Lettura della configurazione tramite SpEL e annotazione @Value

Creati questi due file siamo pronti per la lettura della classe Employee.Config trammite Spring Boot.
Aggiungeremo alcuni campi per leggere la configurazione direttamente da emplyee.properties usando l’annotazione @Value.
L’annotazione @Value può essere utilizzata per iniettare valori nei campi "bean" gestiti da Spring e può essere applicata a tre diversi livelli:
- campo,
- costruttore,
- parametro del metodo.

Nel prossimo esempio presentiamo l'annotazione SpEL per le espressioni: iniziano tutte con il simbolo "#" e sono racchiuse tra parentesi graffe. L'espressione tipica è:
#{expression}.
E' possibile, come mostrato successivamente, fare riferimento alle proprietà in modo simile, iniziando l'interrogazione con il simbolo "$", sempre racchiuse tra parentesi graffe:
${property.name}.

Il metodo "split", originario di Java, viene utilizzato per dividere le stringhe che vengono create, dividendole una dall'altra con una virgola ",".

@Value ("#{'${employee.names}'.split(',')}")
private List<String> employeeNames;

Stiamo, quindi, usando il linguaggio Spring Expression per ottenere un elenco di nomi di dipendenti (employee). Ora siamo in grado di manipolare le proprietà per ottenere l’elenco dei valori.
Il campo employee.names fornirà un elenco di questo tipo: [Peter Cruiser, Anna Sthesia, Paul Molive, Buck Kinnear].

Supponiamo, ora, di voler ottenere solo la prima voce dal nostro elenco dei dipendenti.
Useremo la stessa interrogazione spiegata prima, ma questa volta ci riferiremo ad una lista di oggetti in cui ci interessa il primo.
SpEL è un linguaggio che parte dal numero 0, quindi il nostro ""primo" elemento sarà [0].

Possiamo scrivere l’espressione come segue:

@Value ("#{'${employee.names}'.split(',')[0]}")
private String firstEmployeeName;

Questo ci farà ottenere il primo nome della lista: Peter Cruiser.
Ora vediamo come utilizzare @Value con la funzione di maps. Abbiamo definito la seguente proprietà, riguardante l'età degli employee:

employee.age={one:'26', two : '34', three : '32', four: '25'}

Come sappiamo la funzione map, mappa diversi valori "legandoli" insieme.
Utiliziando sempre il modo spiegato in precedenza per fare riferimento alla proprietà desiderato.
Possiamo iniettare, quindi, il valore della proprietà nella map come segue:

@Value ("#{${employee.age}}")
private Map<String, Integer> employeeAge

Supponiamo, ora, di ottenere il valore desiderato utilizzando una determinata chiave.
Come abbiamo fatto con i nomi, ci possiamo riferire ad un particolare elemento "definando" in che posizione trovarlo.
Possiamo ottenere il valore come segue:

@Value ("#{${employee.age}.two}")
private String employeeAgeTwo;

Se non siamo, però, sicuri che esista una determinata chiave e desideriamo ottenere un valore prefinito, a prescindere dalla sua esistenza o meno, possiamo scrivere la seguente espressione:

@Value ("#{${employee.age}['five'] ?: 30}")
private Integer ageWithDefaultValue;

In questo modo diamo come valore 30, se la chiave ‘five’ non esiste. Come possiamo notare è stato utilizzato l'operatore condizionale che ha definito l'esistenza o meno del valore "five".
In queste circostanze, in cui non sappiamo se un determinato valore o una determinata chiave esiste, gli operatori messi a disposizione da SpEL sono molto utili per creare delle query funzionali.

Leggere le proprietà del sistema mediante l’annotazione @Value

Possiamo inserire proprietà di sistema usando SpEL. Ad esempio, la Home di Java può essere iniettata ed aggiunta alle proprietà del sistema come segue:

@Value ("#{systemProperties['java.home']}")
private String javaHome;

Allo stesso modo la directory dell’utente può essere inserita come segue:

@Value ("#{systemProperties['user.dir']}")
private String userDir;

Conclusioni

In questo articolo abbiamo esaminato varie possibilità di utilizzare SpEL con annotazione @Value. Se desideri saperne di più sul linguaggio Spring Expression leggi la documentazione Spring qui.
SpEL è un linguaggio rivolto alle espressioni molto potente e ben supportato che può essere utilizzato in tutti i prodotti del Framework Spring.
Può configurare delle applicazioni Spring o anche scrivere parser per eseguire attività più generali.
Buona programmazione a tutti!

FONTE: Medium - Swathi Prasad


Vicino@TE screenshot

Questo è il racconto super-sintetico di come un’azienda di sviluppo software Agile, che non ha mai lavorato da remoto, riesce a consegnare un prodotto in tempo record grazie ad un utilizzo (reale) del metodo Agile, nonostante l’emergenza che obbliga tutti gli stakeholder a lavorare da casa.

È mercoledì, 11 marzo 2020. 

Da oggi e per tutta la durata dell’emergenza, Zupit lavora in smart working. Ufficio deserto. Per noi è una situazione abbastanza anomala, perché non abbiamo mai lavorato da remoto.

Abbiamo sempre preferito lavorare tutti nello stesso luogo, perché crediamo molto nel valore del rapporto umano che si crea nelle pieghe della giornata lavorativa, ed è indubbiamente agevolato dalla presenza di persona.

Il primo contatto

Il venerdì seguente (13 marzo), mentre stiamo ancora oliando i meccanismi della collaborazione a distanza, veniamo contattati dall’Azienda Provinciale per i Servizi Sanitari (APSS), rappresentata dal Servizio Politiche di Amministrazione Digitale.

L’APSS ha raccolto una richiesta di aiuto da parte della terapia intensiva dell’ospedale di Rovereto.

Hanno assolutamente bisogno di realizzare un servizio che permetta a medici e infermieri di comunicare con i parenti delle persone ricoverate in terapia intensiva, che a causa dell’isolamento sono impossibilitati a recarsi in reparto per vedere il loro caro o confrontarsi con gli operatori sanitari.

Normale amministrazione per Zupit, visto che ci occupiamo di realizzare software.

C’è però un dettaglio che va considerato: serve per ieri.

Chi è del settore sa bene che “per ieri” è un requisito piuttosto comune :) in questo caso, tuttavia, è davvero necessario per due motivi:

  1. si spera che l’emergenza rientri, quindi qualsiasi soluzione consegnata fra 2 mesi sarebbe inutile (o molto meno utile);
  2. gli operatori sono completamente oberati di lavoro e necessitano subito uno strumento che li scarichi dall’onere delle comunicazioni sincrone con i parenti.

Non ce lo siamo fatti ripetere due volte.

Obbiettivo: MVP in meno di una settimana.

Il team

Un giro di telefonate e verso le 22.00 abbiamo messo assieme un team fatto di 7 persone.

Anche questo è uno strappo alle nostre regole: Zupit lavora a team, per noi il team è “sacro”. Attualmente abbiamo 4 team full-stack, composti da 3 a 6 persone l’uno. Tutti i nostri progetti stanno dentro ad un team.

Le ragioni sono varie: gestione, pianificazione, condivisione del know-how, backup, … .

Per questo progetto, però, abbiamo dovuto creare un team misto. In questo modo chiediamo a tutta Zupit di fare uno sforzo condiviso. Per un team solo sarebbe stato impossibile aggiungere questo progetto alle altre scadenze.

Nonostante il team misto e lo sforzo comune, c’è bisogno di più.

Le persone che fanno parte del team Vicino@TE (questo è il nome del progetto) si rendono disponibili a lavorare anche nel week-end e tutti i pomeriggi.

Si parte!

È sabato (14 marzo) e parte la fase di lift-off. Dapprima con il Cliente, e poi con tutto il team, viene fatto il primo meeting per raccontare a tutti il progetto, i requisiti e l’idea di MVP.

Se non hai familiarità con “MVP”
MVP è il “minimo prodotto utilizzabile”, ossia la primissima versione del software che contiene il minimo indispensabile per erogare valore agli utenti.

Il lift-off termina con una sessione di poker planning per stimare le prime user stories da sviluppare.

La scelta di Kanban

Zupit ha deciso di lavorare abitualmente utilizzando Scrum con sprint di 1 settimana (è il modello che si adatta meglio ai nostri progetti).

Conoscere gli strumenti che utilizziamo ci permette però di capire che in alcuni casi non vanno bene.

Ecco perché abbiamo scelto di utilizzare Kanban per questo progetto: rilasci costanti, nuove richieste ogni giorno, cambiamento di priorità, time-frame non compatibile con sprint di 1 settimana.

Si è rivelata l’unica scelta sensata: ancora oggi siamo felici di aver adottato Kanban per questo progetto.

Primo rilascio, si parte con le iterazioni

Sono passati 4 giorni dal lift-off, 18 marzo 2020, e l’MVP è in produzione.

Merita una nota anche la grandissima collaborazione di tutti i servizi dell’APSS che hanno collaborato in tempo record per configurare l’ambiente di produzione.

Abbiamo perso il conto del numero di iterazioni fatte: non avendo un time-span definito ci è capitato di fare più di una sessione di poker planning a settimana. Ecco cosa abbiamo fatto ad ogni iterazione:

  •  raccolta di feedback dagli utenti;
  • scrittura di nuove User Stories;
  • poker planning;
  • sviluppo;
  • rilascio;
  • retrospettiva.

Sì, abbiamo fatto le retrospettive (una a settimana).

L’urgenza non è un buon motivo per saltare la cerimonia più importante del metodo, e non è un buon motivo per pensare “non c’è tempo per migliorare”.

Ecco un elenco di alcune delle cose che abbiamo introdotto grazie alle prime retrospettive:

  • code review e merge requests su GitLab;
  • pipelines di Continuous Integration e Continuo Deployment (CI/CD) su GitLab;
  • 4 ambienti di lavoro: development, testing, staging, production.

Sono pratiche che utilizziamo normalmente in tutti i progetti e - guarda caso - anche in questo si sono rivelate fondamentali.

Oggi

Oggi è l'8 aprile, abbiamo fatto svariati rilasci in produzione.

Gli utenti utilizzano il software a pieno ritmo e riceviamo costantemente richieste di ottimizzazione, miglioramento, aggiunta di nuove caratteristiche.

Nel tempo si aggiungono nuovi reparti, di altri ospedali, e da ogni reparto arrivano nuovi feedback che danno vita a nuove stories nel nostro backlog. Assieme agli stakeholder, riordiniamo le priorità e proseguiamo con nuovi rilasci.

Solo adesso ci stiamo preoccupando di problematiche nuove: altre aziende sanitarie, il deploy su ambienti diversi, differenza di configurazione tra diverse aziende, ... . Pensarci prima avrebbe ritardato inevitabilmente il rilascio delle funzionalità che servono davvero agli utenti.

Domani

Il futuro? Chi lo sa… è alla base dei principi Agili :)

Il prodotto realizzato servirà molto probabilmente anche dopo l’emergenza COVID-19, in tutte le occasioni in cui il parente può essere in difficoltà nel recarsi di persona in reparto.

Proviamo quindi a fare qualche previsione, almeno per quanto riguarda il lavoro di Zupit:

  • ci aspettiamo che il prodotto diventerà più maturo e si passerà quindi ad una fase di consolidamento e pianificazione a medio termine, quindi probabilmente torneremo ad utilizzare Scrum per questo progetto;
  • diminuirà anche l’urgenza, si spera, quindi potremo ridurre il team e riportare il progetto dentro uno dei nostri 4 team Agili.

Conclusioni

Perché stiamo condividendo tutto questo? Perché abbiamo sperimentato sulla nostra pelle una cosa importantissima: quando c’è una fase di emergenza, spesso si abbandona qualsiasi regola in favore dell’efficienza. Si ha la sensazione che seguire un metodo sia tempo perso, che il metodo funzioni solo “quando c’è tempo”.

Niente di più sbagliato.

Seguendo il metodo (oserei dire “anche più del solito”), siamo riusciti a:

  •  erogare un MVP in 4 giorni dal primo contatto con il cliente;
  • organizzare il lavoro di quasi 14 FTE (se consideriamo il ritmo di lavoro);
  • rilasciare N versioni del software in meno di un mese;
  • far collaborare 7 persone contemporaneamente sullo stesso codice;
  • mettere in piedi almeno 10 azioni di miglioramento continuo che hanno dato risultato già dell’iterazione successiva.

Quindi, per concludere, voglio dire “complimenti a Zupit, complimenti all’Azienda Provinciale per i Servizi Sanitari, e complimento alla Metodologia Agile”. Speriamo che questo racconto possa essere di stimolo all’adozione del metodo Agile, da parte dei nostri colleghi e dei nostri clienti.

Non possiamo non farlo

Nessuno di noi lo ha fatto con lo scopo di raccontarlo in giro, ma non posso non citare un’altra storia nella storia. Una cosa bella che merita di essere raccontata. 

In tutto il racconto non vi abbiamo parlato del budget. Il budget c’è, ci mancherebbe.

Le persone che hanno lavorato al progetto, tuttavia, hanno scelto di donare parte del loro lavoro (straordinario). Zupit raddoppierà questo valore, erogando tutta la somma come donazione all’Azienda Provinciale per i Servizi Sanitari.

Siamo orgogliosi di aver collaborato ad una causa più grande di qualsiasi discussione sullo sviluppo software.

--

Per saperne di più sul progetto in questione:
Comunicato stampa della Provincia Autonoma di Trento

Utilizzo di LINQ per eseguire Query su documenti Cosmos DB dinamici

Il 9 luglio 2019 è stata annunciata una nuova serie di librerie per lavorare con i servizi Azure. Questi SDK (Software Development Kit, in italiano “pacchetto di sviluppo per applicazioni”), sono destinati a più linguaggi tra cui Python, Java, JavaScript e .NET. Alcuni servizi popolari sono coperti, tra cui anche Azure Cosmos DB.
Abbiamo deciso di provarli e di creare qualcosa di utile per un progetto di url shortner. Avere una dashboard è utile, ma l'aggiornamento dei dati è spesso oneroso. E se potessimo scrivere qualcosa di semplice e veloce per darci un’istantanea in tempo reale?

Per semplicità abbiamo iniziato da una app console, ma come ci siamo arrivati? Facciamo un passo indietro e ricominciamo insieme.

L’app console

Abbiamo deciso di scrivere in .NET Core multipiattaforma. Con già installato .NET Core SDK, abbiamo solo bisogno di creare una directory e iniziare una nuova applicazione console.

dotnet new console

Sconsigliano di mettere le credenziali nel codice sorgente, quindi le memorizziamo localmente su un file appSetting.json che non viene preso in considerazione dal tool di versionamento del codice grazie al file .gitIgnore. Ciò significa aggiungere il pacchetto di configurazione in modo che possiamo leggere le impostazioni:

dotnet add package
Microsoft.Extensions.Configuration.Json

Infine abbiamo aggiunto il nuovo Azure SDK per Cosmos DB.

dotnet add package Microsoft.Azure.Cosmos –version 3.0.0.19 -preview

Dopo di chè lanciamo Visual Studio Code e iniziamo!

code .

Connettersi

I nuovi SDK contengono molti esempi per iniziare, quindi abbiamo “preso in prestito” il codice principale da qui:


Azure Cosmos GitHub

Questo codice imposta un servizio di configurazione e inserisce le impostazioni:

IConfigurationRoot configuration = new ConfigurationBuilder()
    .AddJsonFile("appSettings.json")
    .Build();
string endpoint = configuration["EndPointUrl"];
if (string.IsNullOrEmpty(endpoint))
{
    throw new ArgumentNullException("Please specify a valid endpoint in the appSettings.json");
}

Ovviamente dobbiamo create il file appSettings.json e riempirlo:

{
    "EndPointUrl": "https://don't you wish.documents.azure.com:443",
    "AuthorizationKey": "DoodleDoodleDeeWubbaWubbaWubba=="
}

Per garantire che le impostazioni siano pubblicate localmente, abbiamo aggiunto alla configurazione .csproj:

<ItemGroup>
    <None Include="appSettings.json">
        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
</ItemGroup>

Il codice per creare il client è molto breve. Ciò crea un’istanza per il client e lo elimina al termine.

using (CosmosClient client = new CosmosClient(endpoint, authKey))
{
    await Program.RunQueryAsync(client);
}

L’abbiamo runnato a questo punto e non sono state lanciate eccezioni, quindi ovviamente sappiamo che era tempo di mandare in produzione. Err…

Apriamo il contenitore

Azure Cosmos DB organizza i dati in database account che contengono informazioni su aree, failover, tipo API da usare e altre proprietà. All’interno di un database è quindi possibile avere più contenitori partizionati e sottoposti ad approvvigionamento in modo diverso. Abbiamo un database chiamato url-tracking con un contenitore chiamato url-stats.

Abbiamo impostato questi nomi nel codice:

private static readonly string CosmosDatabaseId = "url-tracking";
private static readonly string containerId = "url-stats";

Suggerimento: Usiamo static readonly invece di const solo per abitudine. Potremmo voler spostare i valori in un file di configurazione in un secondo momento e con un static readonly possiamo inizializzare i valori all’avvio del processo rispetto a const che deve essere disponibile  al momento della compilazione.

Il database e il contenitore esistono già (questi sono i nostri dati di produzione, non una demo con dati di esempio) quindi per arrivare al contenitore il percorso è simile al seguente:

var cosmosDatabase = client.GetDatabase(CosmosDatabaseId);
var container = cosmosDatabase.GetContainer(containerId);
Console.WriteLine("Connected. Parsing entries now...");

Ora è il momento di estrarre i dati!

La forma dei dati
Ci sono alcune cose interessanti da sapere sui metadati del nostro contenitore. In quella che potrebbe essere stata una scelta di design scadente , anche se al momento sembra soddisfacente, abbiamo deciso di sfruttare il fatto che non abbiamo bisogno di uno schema fisso con NoSQL. Tracciamo un supporto che ci dice dove sono pubblicati i collegamenti (ad esempio, Twitter, Facebook o persino all’interno di una presentazione PowerPoint). Una esempio per Twitter potrebbe essere la seguente:

{
    "id": "unique guid goes here",
    "page": "azure.microsoft.com/blog/previewing-azure-sdks-following-new-azure-sdk-api-standards",
    "shortUrl": "F61",
    "campaign": "link",
    "referrerUrl": "t.co/4EXayhRpzF",
    "referrerHost": "t.co",
    "agent": "Mozilla/5.0 etc...",
    "browser": "Chrome",
    "browserVersion": "77",
    "browserWithVersion": "Chrome 77",
    "desktop": 1,
    "platform": "Windows",
    "platformVersion": "10",
    "platformWithVersion": "Windows 10",
    "count": 1,
    "timestamp": "2019-07-10T20:20:54",
    "host": "azure.microsoft.com",
    "twitter": 1
}

Se vogliamo fare la stessa cosa con LinkedIn, il codice sarebbe simile al seguente:

{
    "id": "unique guid goes here",
    "unimportant-stuff": "removed",
    "count": 1,
    "timestamp": "2019-07-10T20:20:54",
    "host": "azure.microsoft.com",
    "linkedin": 1
}

Notiamo che la proprietà è diversa in base al supporto. Tutto ciò rappresenta una sfida non da poco per l’analisi dei dati. I linguaggi dinamici come JavaScript lo gestiscono bene, ma che dire per linguaggi fortemente tipizzato come C#? Guardando a ritroso avremmo potuto semplificare l’intuitività della proprietà “jolly” facendo questo (notiamo la proprietà media aggiunta):

{
    "id": "unique guid goes here",
    "unimportant-stuff": "removed",
    "count": 1,
    "timestamp": "2019-07-10T20:20:54",
    "host": "azure.microsoft.com",
    "medium": "linkedin",
    "linkedin": 1
}

…o anche:

{
    "id": "unique guid goes here",
    "unimportant-stuff": "removed",
    "count": 1,
    "timestamp": "2019-07-10T20:20:54",
    "host": "azure.microsoft.com",
    "medium": {
        "linkedin": 1
    }
}

Ma non l’abbiamo fatto, quindi per ora la cosa migliore che potevamo inventare era guardare l’host. Ne parleremo a breve. Potremmo tornare indietro e scrivere un’utility per aggiornare la struttura dei dati in un secondo momento, ma per ora funziona bene.

La Query

Un vantaggio dell’API SQL di Azure Cosmos DB è il fatto che sia possibile usare la sintassi SQL per interrogare il documento. Questa è una query perfettamente valida:

SELECT * FROM c WHERE <filter> ORDER BY c.timestamp DESC

Tuttavia è preferibile usare LINQ perché non dobbiamo manipolare le stringhe e possiamo adottare un approccio più fluido.

Aspetta, di cosa parliamo quando c’è il nome LINQ? Se non conoscete C# e/o .NET, non temete. LINQ sta per Language Integrated Query. E’ un modo per scrivere query utilizzando i metodi C# senza ricorrere alla manipolazione delle stringhe. L’esempio di sopra diventa:

query.Select(c=>c).Where(c=>
{//filter}).OrderByDescending(c=>c.timestamp)

L’obbiettivo è semplice: prendere tutte le voci delle ultime 24 ore e aggregarle sulla pagina e sul supporto. Ordinarle per elencare prima la pagina più popolare con un conteggio totale di clic, quindi all’interno della pagina ordinare i medium più popolari e mostrare il punteggio. Per conservare i dati, creiamo questo:

var documents = new Dictionary<string,IDictionary<string,int>>();

Il dizionario degli indici viene ordinato per pagina, quindi all’interno della pagina è presente un dizionario nidificato indicizzato per mezzo e conteggio dei clic.
Successivamente, abbiamo creato la nostra query. Ecco la parte interessante del progetto: i nuovi SDK supportano completamente LINQ e non hanno problemi con dati dinamici! Invece di proiettare su un tipo dinamico, abbiamo usato un IDictionary <string, object> per emulare un “sacchetto delle proprietà” (le stringhe sono nomi di proprietà, gli oggetti i loro rispettivi valori). Il codice seguente imposta la query e crea un iteratore in modo da poter recuperare i risultati in modo asincrono. Si noti che è perfettamente corretto trasmettere il valore di un elemento nel dizionario su una proprietà DateTime.

var queryable = container
    .GetItemLinqQueryable<IDictionary<string, object>>();
var oneDay = DateTime.UtcNow.AddDays(-1);
var query = queryable
    .OrderByDescending(s => s["timestamp"])
    .Where(s => (DateTime)s["timestamp"] > oneDay);
var iterator = query.ToFeedIterator();

Ecco una LINQ query per voi.

Anche se il valore del dizionario è un tipo di oggetto, non dobbiamo bloccare uno schema specifico, l’SDK è abbastanza intelligente da serializzare i valori sui tipi .NET appropriati, in questo caso per il timestamp di un DateTime.

La strategia generica per scorrere i risultati è semplice e, per quanto ne sappiamo, gestisce automaticamente le richieste di limitazione in modo appropriato.

int entries = 0;
int pages = 0;
while (iterator.HasMoreResults)
{
    foreach(var document in await iterator.ReadNextAsync())
    {
        entries += 1;
        var page = document["page"].ToString();
        if (!documents.ContainsKey(page)) 
        {
            documents.Add(page, new Dictionary<string,int>());
            pages += 1;
        }
        // logica medium va qua
    }
}

Come potete vedere, chiediamo semplicemente se ci sono più risultati e quindi eseguiamo l’iterazione asincrona del feed. La logica per tenere traccia dei conteggi per medium non ha nulla a che fare con SDK, quindi vediamo il seguente esempio:

var pageData = documents[page];
bool medium = false;
foreach(var key in document.Keys)
{
    if (medium) {
        if (pageData.ContainsKey(key))
        {
            pageData[key] += 1;
        }
        else 
        {
            pageData[key] = 1;
        }
        break;
    }
    else {
        if (key == "host") {
            medium = true;
        }
    }
}

Stiamo trovando la proprietà dopo l’host e la stiamo usando per sommare i dati. Sì, questo richiede fiducia nell’ordinamento delle colonne ed è per questo che lo abbiamo spiegato in precedenza. Fortunatamente, se per qualche motivo la proprietà “jolly” non esiste, il loop uscirà dopo l’host.

Generare il rapporto

Ora che i dati sono stati raccolti, generare il rapporto finale è semplice, soprattutto con l’aiuto di LINQ.  Mostriamo i totali, poi ordiniamo le pagine per clic e al loro interno per il medium più cliccato:

onsole.WriteLine($"Parsed {pages} pages across {entries} entries.");
foreach (var page in documents
    .OrderByDescending(kv => kv.Value.Values.Sum())) 
{
    Console.WriteLine(
        $"Page: {page.Key}\n\t{page.Value.Values.Sum()}");
    foreach (var medium in page.Value
        .OrderByDescending(kv => kv.Value))
    {
        Console.WriteLine($"\t{medium.Key}:\t{medium.Value}");
    }
}

Facile no? Ci sono voluti circa 30 minuti per scrivere il codice e molto più tempo per scrivere il post sul blog. Facciamo runnare il nostro codice:

dotnet run

… e controlliamo come stanno procedendo le cose.

Considerazioni finali

I nuovi SDK sono arrivati e finora sembrano molto utili. Sono rapidi da mettere in funzione, l’API è sembrata intuitiva e gli esempi ci hanno aiutato a capire come risolvere il nostro problema. Non vediamo l’ora di vederli sviluppare a seconda dei feedback degli utenti e vedere più servizi usati nelle versioni future. Spero che abbiate trovato utile questo esempio come applicazione delle nuove SDK.
Buona giornata e buona programmazione a tutti!

FONTE: https://blog.jeremylikness.com/blog/using-linq-to-query-dynamic-schemaless-cosmosdb-documents/