NicoGis - Sviluppare in ambiente ArcGIS...

Shapefile (il vecchio) e ArcGIS.com (il nuovo)

2012-01-15T19:40:00.005+01:00

Come avete potuto leggere o avete già provato, è possibile aggiungere feature alla nostra mappa in ArcGIS.com tramite file di testo con separatori, file GPS (.gpx) e shapefile (compresso in un file zip).
Il visualizzatore di mappa di ArcGIS.com aggiunge informazioni di localizzazione, visualizza feature sulla mappa per ogni dato nel file e memorizza l'informazione nella mappa web come un layer.
Un volta aggiunta la feature class dal file nella mappa, è possibile modificare le proprietà del layer che è stato creato. Ad esempio è possibile configurare la finestra di pop-up, modificare i simboli, impostare l'intervallo di visibilità, abilitare la modifica della feature class e rimuovere il pop-up. Per modificare le proprietà del layer cliccare su Details, poi su Contents e infine sulla freccia a destra del nome del layer.

Per aggiungere un file alla mappa, aprire il visualizzatore di mappa di ArcGIS.com e cliccare su Add, scegliere Add Layer from File, selezionare il file sul computer e cliccare su Import Layer. Aggiungendo uno shapefile, scegliere di generalizzare le feature per la visualizzazione sul web (è raccomandata) o prendere le feature originali. Il layer è memorizzato con la mappa. Per browser che supportano il drag and drop dell' HTML5, è possibile trascinare il file direttamente sulla mappa.

In questo caso, aggiungiamo lo shapefile delle principali autostrade degli Stati Uniti.
Il nostro caro vecchio shapefile - come sapete - è un formato vettoriale che memorizza posizione, geometria ed attributi delle feature geografiche. E' memorizzato fisicamente mediante un insieme di file che contengono una feature class. Gli shapefile spesso contengono molte geometrie con associati dati e storicamente sono stati utilizzati dalle applicazioni GIS Desktop come ArcGIS Desktop e ArcGIS Explorer. Però, se abbiamo pochi dati nello shapefile - generamente non più 1000 feature - è possibile renderlo disponibile ad altri facendolo visualizzare attraverso il web con un browser: aggiungendolo tramite un file zip contenente i file fisici che memorizzano lo shapefile (file .shp, .shx, .dbf e .prj) sulla mappa che si crea con il visualizzatore di mappa di ArcGIS.com. Quando aggiungiamo uno shapefile, il visualizzatore di mappa di ArcGIS.com lo serializza in formato json ESRI per essere letto velocemente e visualizzato dai web client. Chiaramente, così facendo, siamo in un'ottica file server e quindi una soluzione non scalabile rispetto ad un feature service. Per aiutare ulteriormente le prestazioni di visualizzazione, è possibile scegliere di generalizzare le feature dello shapefile. La generalizzazione riduce le dimensioni dello shapefile semplificando le feature ed è spesso adatto per dati da rappresentare a piccole scale. Sì può generalizzare utilizzando applicazioni desktop come ArcGIS Desktop che ArcGIS.com quando aggiungiamo il file alla mappa (vedi immagine precedente).
La generalizzazione di ArcGIS.com riduce la risoluzione del layer shapefile e "spunta" la precisione delle feature. Per maggiori dettagli vedere qui. La generalizzazione adottata dovrebbe essere un buon compromesso tra mantenere l'informazione e l'accuratezza di visualizzazione delle feature, mentre riduce soprattutto la dimensione dei dati e consente pertanto una veloce visualizzazione sulla mappa. La logica utilizzata da ArcGIS.com è calcolare al volo la dimensione in unità di mappa del pixel nella corrente visualizzazione e impostare questa misura come maxAllowableOffset, poichè il dettaglio è inutile al di sotto del pixel, rimuovendo quindi inutili vertici. Chiaramente se il feature layer è impostato come modificabile, la generalizzazione non verrà applicata perchè la gestione sarebbe un po' più complessa. Shapefile con più di 1000 feature o in alcuni casi anche con meno feature (visualizzazione di errori in fase di caricamento) non possono essere aggiunti nella mappa perchè non adatti ad una visualizzazione veloce su web. L'alternativa è creare un feature service con ArcGIS Server o in futuro con 10.1 sottoscrivendo una subscription ad ArcGIS Online per creare feature service.

Una volta caricato il layer possiamo rinominarlo con Rename utilizzando la finestra di pop-up:

Una volta caricato possiamo, come detto precedentemente, modificare i simboli. In questo esempio ho impostato ad Unique Values: in pratica si visualizza ogni feature utilizzando una particolare caratteristica che la identifica.

A questo punto, la nostra mappa è pronta per essere salvata. Correntemente quindi fa riferimento ad una basemap, ad uno shapefile (operational layer) che abbiamo caricato ed alle impostazioni fatte sul layer basato sullo shape (unique values, label ecc.). Per la mappa sono presenti comunque anche altre informazioni che possiamo memorizzare, ad esempio i bookmark.

Salviamo la mappa con il pulsante Save ed inseriamo Title, Tags, Summary e indichiamo in quale cartella salvare la definizione della mappa (le cartelle possono essere create in ArcGIS.com per poter suddividere le proprie mappe, applicazioni, layer ecc.). I tag permettono ad altri di cercare la tua mappa mediante le parole chiave che sono state inserite (separare più tag mediante una virgola) mentre il summary è una descrizione per tua mappa. Con Save As faremo invece una copia della definizione della mappa.

Una volta salvata la mappa, possiamo decidere se condividerla con altre persone.

Cliccando su Share possiamo condividere con tutti o uno o più gruppi ai quali ci siamo uniti. Per unirsi ad un gruppo vedi il seguente video:

Anche noi possiamo crearci il nostro gruppo ed invitare altri utenti ad unirsi:

Una volta salvata la mappa è possibile anche modificare le feature del layer.

Per chi è la prima volta che si collega ad ArcGIS.com ricordo che occorre avere un ESRI Global Account (cliccare su Create an Account) e successivamente bisogna registrare l'account in ArcGIS.com (cliccare su Register your ESRI Global Account) . Il link per la registrazione è: https://www.arcgis.com/home/signin.html.

In questo esempio che abbiamo visto tutte le informazioni sono memorizzate su ArcGIS.com (mappa e dati). Vediamo un po' più nel dettaglio come sono memorizzate.

Alla nostra mappa è associato un UUID (identificatore univoco universale). In questo caso per recuperare il nostro item passiamo l'UUID della mappa (cioè l'ID della mappa) creata: b4ad815cb1ec46dcac03ecd8a31c82ff
https://www.arcgis.com/home/item.html?id=b4ad815cb1ec46dcac03ecd8a31c82ff.
Se desideriamo visualizzare la mappa nel viewer messo a disposizione di ArcGIS.com possiamo semplicemente passare l'UUID al parametro webmap.

http://www.arcgis.com/home/webmap/viewer.html?webmap=b4ad815cb1ec46dcac03ecd8a31c82ff

Come parametri possiamo passare anche:
- center
- level
- extent
- baseUrl
- url
- displayslider
- displayscalebar
- displaylegend
- displaydetails
- displaysearch
ecc.
Per maggiori dettagli sui parametri che si possono passare vedere qui.

Per creare una web application possiamo direttamente da ArcGIS.com cliccare su Share.

Con Link to this map possiamo condividere il link alla mappa mediante un URL shortening ad esempio in Twitter e Facebook.

Oppure possiamo inglobarla nel nostro sito, blog, WCMS ecc. mediante il tag IFRAME.

Mentre cliccando su Make a Web Application possiamo creare, utilizzando uno dei tanti template, un'applicazione in javascript utilizzando le API ESRI javascript. Una volta selezionato il template, ArcGIS.com imposterà automaticamente i riferimenti della mappa nel codice javascript - se decidiamo di pubblicarla - salvandola su ArcGIS.com. Per identificare l'applicazione web ArcGIS.com crea un altro UUID: ced2d4e31f9b4afd9d644bb1770b8041.
http://studioat.maps.arcgis.com/apps/OnePane/chrome/index.html?appid=ced2d4e31f9b4afd9d644bb1770b8041&webmap=b4ad815cb1ec46dcac03ecd8a31c82ff

L'alternativa è pubblicarla sul nostro server scaricando il template e cliccando su Download. In questo caso configureremo manualmente l'id della mappa nel template.

Possiamo anche creare una webmap anche direttamente da un json senza passare da ArcGIS.com.
Qui possiamo vederne un esempio (utilizzo di esri.arcgis.utils.createWebMap).

Qui possiamo vedere la definizione della mappa (l'url base è http://www.arcgis.com/sharing/content/items) :
http://www.arcgis.com/sharing/content/items/b4ad815cb1ec46dcac03ecd8a31c82ff?f=pjson

{
  "id": "b4ad815cb1ec46dcac03ecd8a31c82ff",
  "item": "usa_-_major_highways_1326046703296",
  "itemType": "text",
  "owner": "ciava.at",
  "uploaded": 1326046716000,
  "modified": 1326046717000,
  "guid": null,
  "name": null,
  "title": "USA - Major highways",
  "type": "Web Map",
  "typeKeywords": [
    "Web Map",
    "Explorer Web Map",
    "Map",
    "Online Map",
    "ArcGIS Online"
  ],
  "description": null,
  "tags": ["USA Major highways"],
  "snippet": "USA - Major highways",
  "thumbnail": "thumbnail/ago_downloaded.png",
  "documentation": null,
  "extent": [
    [
      -128.4263,
      23.7584
    ],
    [
      -65.4088,
      51.5041
    ]
  ],
  "lastModified": -1,
  "spatialReference": null,
  "accessInformation": null,
  "licenseInfo": null,
  "culture": "it",
  "url": null,
  "access": "public",
  "size": 806736,
  "numComments": 0,
  "numRatings": 0,
  "avgRating": 0,
  "numViews": 41
}

Che possiamo 'replicare' in javascript:

 var webmap = {};    
  webmap.item = {  "title":"USA - Major highways", 
    .....
  };

Analogamente possiamo fare con i dati della mappa:
Qui possiamo vedere la "serializzazione" del nostro shapefile in formato json ESRI:
http://www.arcgis.com/sharing/content/items/b4ad815cb1ec46dcac03ecd8a31c82ff/data?f=pjson

{
  "operationalLayers": [{
    "id": "usa_major_highways_9585",
    "title": "USA - Major highways",
    "featureCollection": {
      "showLegend": true,
      "layers": [{
        "layerDefinition": {
          "currentVersion": 10.1,
          "id": 0,
          "name": "usa_major_highways",
          "type": "Feature Layer",
          "displayField": "",
          "description": "",
          "copyrightText": "",
          "supportsRollbackOnFailure": true,
          "geometryType": "esriGeometryPolyline",
          "minScale": 0,
          "maxScale": 0,
          "extent": {
            "xmin": -1.75985065262543E7,
            "ymin": 2424999.05112109,
            "xmax": -7545366.07247812,
            "ymax": 8893656.17013185,
            "spatialReference": {"wkid": 102100}
          },
          "drawingInfo": {
            "renderer": {
              "type": "uniqueValue",
              "field1": "FULL_NAME",
              "defaultSymbol": {
                "color": [
                  0,
                  0,
                  0,
                  255
                ],
                "width": 2,
                "type": "esriSLS",
                "style": "esriSLSSolid"
              },
              "uniqueValueInfos": [
                {
                  "value": "I 10",
                  "symbol": {
....

Che possiamo impostare in javascript:

 webmap.itemData = {    
               "operationalLayers": [{      
                ...

Se invece desideriamo creare la mappa da id possiamo utilizzare:

var mapDeferred = esri.arcgis.utils.createMap("b4ad815cb1ec46dcac03ecd8a31c82ff", "map", {
              mapOptions: {
                slider: true,
                nav:false
              }
            });

Infine abbiamo la possibilità di modificare l'ArcGIS URL mediante arcgisUrl. Il default è http://arcgis.com/sharing/content/items

esri.arcgis.utils.arcgisUrl = http://arcgis.com/sharing/content/items;

E' possibile così impostare il proprio dominio dove è localizzata la nostra mappa (es. http://mydomain/sharing/content/items) ed utilizzare le api di ESRI. Nel 2012 sarà disponibile Portal for ArcGIS che permetterà alle organizzazioni di fare il proprio deployment con le caratteristiche di 'ArcGIS Online' nella propria intrastruttura.
Per connetterti con il tuo smartphone al tuo ArcGIS Server puoi seguire il seguente documento.

Analogamente in Silverlight API e Flex API abbiamo funzionalità per caricare e per gestire webmap.

Infine, volevo sottolineare che ho fatto una breve panoramica ma le funzionalità messe a disposizione da ArcGIS.com - soprattutto con la possibilità dalla 10.1 di poter (tramite subscription) creare servizi direttamente su ArcGIS.com (tiled map service e feature service per ora) - sono tantissime.

Fidarsi è bene ma con checksum è meglio!

2011-12-12T08:48:00.000+01:00

Con la versione 10 il software ESRI è distribuito tramite la CDN di Akamai. Sebbene sia ancora disponibile la possibilità di richiedere il software su supporto DVD, è innegabile il vantaggio di poter scaricare il software direttamente sul proprio computer. E' altrettanto vero che l'operazione di scaricamento potrebbe durare anche molte ore se non si ha a disposizione una connessione veloce; qui infatti ci viene incontro il Download Manager che ci permette di mettere in pausa o fermare il download e riprenderlo più tardi, scaricare più file simultaneamente e recuperare il download corrente su una perdita di connessione o da crash di sistema.
Se tuttavia non si vuole utilizzare il Download Manager (ad esempio non accettiamo di installarlo), è possibile scaricare direttamente l'immagine del software. Così facendo è consigliabile, una volta scaricato il file, controllarne la checksum.

La checksum, cioè somma di controllo, viene utilizzata per verificare l'integrità di un dato o di un messaggio che potrebbe subire alterazioni. Una somma di controllo potrebbe sommare tutti i bit del dato e verificare se la somma dei bit trasmessi corrisponda a quella calcolata prima del trasferimento. Se due o più input hanno la stessa somma, quindi la stessa checksum, si parla di collisione. Minore è la probabilità di collisione, migliore è la qualità dell'algoritmo di controllo per verificare l'integrità del dato in sicurezza. Pertanto è importante utilizzare algoritmi con strutture matematiche complesse per impedire a malintenzionati di calcolare checksum che determinino collisioni. Quando scarichiamo file da internet, è buona pratica verificare la checksum per poter assicurare che i dati scaricati siano corretti e per garantirne l'autenticità. In genere per la checksum (digest nel caso specifico) vengono utilizzati algoritmi di hash crittografati, come MD5 e SHA-1 che comunque non sono esenti da collisioni.
Qui possiamo vedere una panoramica sulle funzioni hash e degli attacchi ai quali potrebbero essere soggetti: collisione hash, attacco del compleanno, attacco preimmagine, tabella arcobaleno, attacco del canale laterale e attacco a forza bruta.

Con c# possiamo facilmente calcolare la checksum (MD5) di un file:

            using (FileStream file = new FileStream(txtFile.Text, FileMode.Open))
            {
                    byte[] retVal;    
                    using (MD5 md5 = new MD5CryptoServiceProvider()) 
                    {
                             retVal = md5.ComputeHash(file);
                             txtMD5.Text= BitConverter.ToString(retVal).Replace("-", ""); // hex string
                    }     
            }

Qui potete scaricare la soluzione.
Controllo di un file scaricato con verifica del checksum (MD5) dichiarato:

Esito positivo

Esito negativo:

Deserializzazione JSON: polimorfismo

2011-11-30T10:05:00.012+01:00

Quando si ha a che fare con il formato JSON, ad esempio quando richiamiamo i servizi rest SOE ESRI, .NET ci mette a disposizione DataContractJsonSerializer che ci consente di serializzare direttamente oggetti di tipo .NET in dati JSON e di deserializzare tali dati in istanze di tipi .NET. Tuttavia, uno dei problemi sorge quando il servizio REST ci restituisce istanze di oggetti diversi o derivati. Javascript è un linguaggio con tipizzazione debole e l'identità del tipo non rappresenta solitamente un problema. Il problema si presenta quando si utilizza JSON per le comunicazioni tra un sistema fortemente tipizzato (.NET) e uno con tipizzazione debole (Javascript): è utile allora mantenere l'identità del tipo.

Prendiamo questo esempio: i tipi con nomi di contratto dati "Envelope" e "Point" derivano da un tipo con nome di contratto dati "Geometry". Se "Point" viene inviato da .NET a Javascript e viene quindi restituito ad un metodo .NET che prevede "Geometry", è utile per .NET sapere che l'oggetto in questione è stato originariamente un "Point"; in caso contrario, tutte le informazioni specifiche del tipo derivato (ad esempio i membri dati "x" e "y" su "Point") potrebbero andare perdute.
Per mantenere l'identità del tipo, durante la serializzazione di tipi complessi in JSON, può essere aggiunto un suggerimento; il deserializzatore riconosce tale suggerimento e agisce di conseguenza. Il suggerimento relativo ai tipi è rappresentato da una coppia chiave/valore JSON dove il nome della chiave è "__type" (due caratteri di sottolineatura seguiti dalla parola "type"). Il valore è rappresentato invece da una stringa JSON con forma 'DataContractName:DataContractNamespace' (tutto il testo che precede i due punti rappresenta il nome).

Per ridurre le dimensioni dei messaggi JSON, il prefisso dello spazio dei nomi del contratto dati predefinito viene sostituito dal carattere "#". Per rendere reversibile questa sostituzione, viene utilizzata una regola di escape: se il primo carattere nello spazio dei nomi è "#" o "\", verrà aggiunto un carattere "\"). Pertanto, se "Point" è un tipo nello spazio dei nomi .NET "Studioat.Geometry", il relativo spazio dei nomi del contratto dati sarà: http://schemas.datacontract.org/2004/07/Studioat.Geometry. Le forme e la rappresentazione JSON appaiono nel modo seguente.

//prima forma
string a1 = "{\"__type\":\"Point:http:\\/\\/schemas.datacontract.org\\/2004\\/07\\/Studioat.Geometry\",\"X\":10.256,\"Y\":80.729}";
//seconda forma
string a2 = "{\"__type\":\"Point:#Studioat.Geometry\",\"X\":10.256,\"Y\":80.729}";

Sia i nomi troncati (#Studioat.Geometry) che quelli completi vengono riconosciuti durante la deserializzazione. Inoltre il suggerimento relativo ai tipi deve essere visualizzato all'inizio nella rappresentazione JSON. Questo è il solo caso in cui l'ordine delle coppie chiave/valore è importante nell'elaborazione di JSON.
Di seguito viene riportato un esempio di modalità non valida per specificare un suggerimento relativo ai tipi.

string a2 = "{\"X\":10.256,\"Y\":80.729,\"__type\":\"Point:#Studioat.Geometry\"}";

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
 
namespace Studioat.ScratchCode
{
 class Program
 {
  static void Main(string[] args)
  {
     string a1 = "{\"__type\":\"Point:http:\\/\\/schemas.datacontract.org\\/2004\\/07\\/Studioat.Geometry\",\"X\":10.256,\"Y\":80.729}";
     string a2 = "{\"__type\":\"Point:#Studioat.Geometry\",\"X\":10.256,\"Y\":80.729}";
 
     string b1 = "{\"__type\":\"Envelope:http:\\/\\/schemas.datacontract.org\\/2004\\/07\\/Studioat.Geometry\",\"XMin\":10.256,\"YMin\":80.729,\"XMax\":21.956,\"YMax\":34.712}";
     string b2 = "{\"__type\":\"Envelope:#Studioat.Geometry\",\"XMin\":10.256,\"YMin\":80.729,\"XMax\":21.956,\"YMax\":34.712}";
 
     byte[] rawstring = System.Text.Encoding.Unicode.GetBytes(a1);
     MemoryStream stream = new MemoryStream(rawstring);
 
     DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Geometry.Geometry), new Type[] { typeof(Geometry.Envelope), typeof(Geometry.Point) });
 
     Geometry.Geometry o = serializer.ReadObject(stream) as Geometry.Geometry;
     if (o is Geometry.Point)
     {
      Geometry.Point j = o as Geometry.Point;
      Console.WriteLine("Point x:{0} y:{1}", j.X, j.Y);
     }
     else if (o is Geometry.Envelope)
     {
      Geometry.Envelope j = o as Geometry.Envelope;
      Console.WriteLine("Envelope xmin:{0} ymin:{1} xmax:{2} ymax:{3}", j.XMin, j.YMin, j.XMax, j.YMax);
     }
     Console.Read();
  }
 }
}
 
namespace Studioat.Geometry
{
 [DataContract]
 public abstract class Geometry : ICloneable
 {
    
  protected Geometry()
  {
  }
 
  public abstract object Clone();
 }
 
 [DataContract]
 public class Point : Geometry
 {
 
  private double x;
  private double y;
 
 
  public Point()
  {
   this.x = double.NaN;
   this.y = double.NaN;
 
  }
 
  public Point(double x, double y)
  {
   this.x = x;
   this.y = y;
  }
 
  public override object Clone()
  {
   Studioat.Geometry.Point point = base.MemberwiseClone() as Studioat.Geometry.Point;
   return point;
  }
 
  [DataMember]
  public double X
  {
   get;
   set;
  }
 
  [DataMember]
  public double Y
  {
   get;
   set;
  }
 }
 
 [DataContract]
 public class Envelope : Geometry
 {
 
  private double maxx;
  private double maxy;
  private double minx;
  private double miny;
 
  public Envelope()
   : this(double.NaN, double.NaN, double.NaN, double.NaN)
  {
  }
 
  public Envelope(Point minPoint, Point maxPoint)
   : this(minPoint.X, minPoint.Y, maxPoint.X, maxPoint.Y)
  {   
  }
 
  public Envelope(double minx, double miny, double maxx, double maxy)
  {
   this.minx = minx;
   this.miny = miny;
   this.maxx = maxx;
   this.maxy = maxy;
  }
 
  public override object Clone()
  {
   Envelope envelope = base.MemberwiseClone() as Envelope;
   return envelope;
  }
 
  [DataMember]
  public double XMax
  {
   get;
   set;
  }
 
  [DataMember]
  public double XMin
  {
   get;
   set;
  }
 
  [DataMember]
  public double YMax
  {
   get;
   set;
  }
 
  [DataMember]
  public double YMin
  {
   get;
   set;
  }
 }
}

... a qualcuno piace versionato!

2011-10-29T12:47:00.001+02:00

Il versioning è il meccanismo che abilita più utenti all'editing contemporaneo in geodatabase ArcSDE.
Esso utilizza un modello di concorrenza ottimistica di lock dei dati che, in parole povere, significa che non sono applicati blocchi sulle feature e sulle row durante lunge transazioni.
Il versioning registra e gestisce gli stati delle singole feature e row così come sono modificate mentre preserva l'integrità nel database. Esso è la base per l'accesso multiutente e l'editing simultaneo nei geodatabase Enterprise e non crea copie di dati. Una versione si riferisce ad uno specifico stato del geodatabase. Esso contiene tutti i dataset nel geodatabase ed evolve nel tempo. Gli utenti accedono ai dati attraverso una versione. Dietro le quinte, vengono utilizzate delle query nell'RDBMS per visualizzare o lavorare con uno stato che si riferisce ad un specifico segmento di tempo o per vedere le attuali modifiche del singolo utente. Il versioning permette di gestire complessi workflow di editing che normalmente sono richiesti dai sistemi GIS di fascia Enterprise. Occorre però sottolineare che la maggior parte delle transazioni nei database avvengono nell'ordine dei secondi. Lo stato è l'unità dei cambiamenti (ad esempio una modifica) che è fatta sui dati di un geodatabase; se un cambio è stato fatto esso rappresenta uno snapshot del database.
E' importante però capire perchè le versioni sono importanti: nei geodatabase di tipo enterprise in molti casi molti utenti necessitano di modificare gli stessi dati contemporaneamente. La natura delle relazioni spaziali e della connettività che definisce i dati geografici richiede che le sessioni di editing per dati geospaziali sia dell'ordine delle ore, giorni o settimane. Queste sessioni possono richiedere lunghe transazioni nel DBMS. Inoltre l'utente richiede di poter anche annullare o rifare i cambi apportati, di sviluppare proposte senza intaccare i geodatabase pubblicati e i meccanismi per gestire i cambiamenti nel tempo come i dati e il geodatabase.

Tutti i geodatabase ArcSDE hanno una versione di default denominata DEFAULT che è di proprietà dell'amministratore ArcSDE. Questa versione esiste sempre e non può essere cancellata. Essa è la radice di tutte le versioni. Normalmente è la versione pubblicata del geodatabase che rappresenta la vista corrente per l'utente finale del geodatabase. La versione di DEFAULT è tipicamente mantenuta e aggiornata nel tempo incorporando in sè le modifiche dalle altre versioni. Come le altre versioni può essere modifica direttamente.
Un geodatabase ArcSDE può avere molte versioni. Una nuova versione (versione figlio) è creata da una versione esistente (versione padre). Quando una versione viene creata è identica alla versione padre. Comunque nel tempo padre e figlio possono divergere a causa delle modifiche effettuate in ogni versione.

Vediamo come creare due versioni figlio della versione di DEFAULT

Innanzitutto occorre versionare i dataset abilitati alle modifiche.

Quando registriamo il nostro dataset nel geodatabase ci viene chiesto se desideramo spostare le modifiche nella tabella base: questa possibilità ci permette di lavorare con l'editing versionato ma supporta anche alcune funzionalità dell'editing non versionato. Quest'ultimo abilita gli utenti ad effettuare modifiche direttamente nelle tabelle base dei geodatabase analogamente ai database classici. Se si seleziona questa funzionalità, essa funziona come l'editing versionato tranne quando si effettuano modifiche alla versione di DEFAULT. Quando si modifica la versione di DEFAULT le modifiche vengono apportate direttamente nella tabella base, anche quando le versioni sono riconciliate e postate (vedremo più avanti questi concetti) alla versione di DEFAULT. Chiaramente sia il modello versionato con spostamento delle modifiche nella tabella base che il modello non versionato presentano delle limitazioni rispetto al modello versionato: ad esempio non è supportata la replica o non tutti i tipi di oggetti possono essere modificati.

Quando modifichiamo il dataset versionato nell'ambiente di editing ogni versione ci sembra abbia una propria copia dei dati. Infatti quando visualizzamo i dati di una versione piuttosto che un'altra il dataset ci può apparire differente. Il dato invece è memorizzato una sola volta del DBMS e, come abbiamo detto precedentemente, dietro le quinte ArcGIS lascia il dataset nel suo originale stato durante l'editing. Le modifiche vengono memorizzate in tabelle associate al dataset dette 'delta table' o tabella A (aggiungi) e tabella D (cancella). Ogni dataset avrà associato una coppia di queste tabelle quando sono registrate come versionate in ArcCatalog.

Ogni versione ha un proprietario, una descrizione, una versione padre, associato uno stato del database e un livello di accesso. I livelli di accesso sono:

Private: solo il proprietario può vedere e effettuare modifiche;
Protected: tutti gli utenti possono vedere ma soltanto il proprietario può effettuare modifiche;
Public: tutti gli utenti possono vedere ed effetture modifiche.

Il livello di accesso predefinito per la versione di DEFAULT è public. Normalmente è raccomandato di impostare il livello a protected per assicurare che i dati nel geodatabase ArcSDE non siano accidentalmente persi o corrotti. Questo significa che solo l'amministratore ArcSDE può modificare o postare le modifiche alla versione DEFAULT.

Il versioning, come detto, si presta molto bene a gestire complessi workflow così come progetti GIS a fasi (ogni fase è rappresentata da una versione) e modelli a scenari what-if senza intaccare i dataset originali. Qui potete vedere degli esempi.
Fornisce un framework per gestire sicurezza e assicurare qualità nei dati in editing e supporta archiving e repliche.
Ogni organizzazione può adattare o personalizzare il proprio workflow, visti i moltissimi scenari che il versioning permette di fare.
Il più semplice workflow è avere utenti concorrenti direttamente nella versione di DEFAULT.
Un'altra opzione è creare una versione separata per ogni utente editor. Spesso per proteggere la versione di default si crea una versione di qualità del dato dalla versione di DEFAULT. Questa versione dovrebbe essere gestita da un utente che controlla i dati prima di propagarli alla versione di DEFAULT. Ogni workflow ha pro e contro, pertanto è importante che ognuno utilizzi la miglior strategia atta a soddisfare i propri requisiti nel workflow di business.

Nel nostro esempio creiamo un albero a due livelli (DEFAULT e due figli: VersioneA e VersioneB):

Dal Version Manager selezioniamo la versione padre (in questo caso la versione DEFAULT) e con il tasto destro creiamo la versione versioneA e la versione versioneB.

Visualizzazione del Version Manager dopo che abbiamo aggiunto le due versioni.

Per creare la versione lato programmazione utilizzare l'interfaccia IVersion2

Qui vediamo un esempio di creazione di due versioni figlio per la versione versioneQA.

public void CreateChildExample(IWorkspace workspace)

{

IVersionedWorkspace versionedWorkspace = (IVersionedWorkspace)workspace;

IVersion2 qaVersion = (IVersion2)versionedWorkspace.FindVersion("versioneQA");

IVersion2 editorAVersion = (IVersion2)qaVersion.CreateChild("VersioneB",qaVersion);

IVersion2 editorBVersion = (IVersion2)qaVersion.CreateChild("VersioneB", qaVersion);

}

Una versione come detto si riferisce ad uno specifico stato del database, un'unità di modifica che avviene nel database. Ogni operazione di modifica eseguita nel geodatabase crea un nuovo stato del database. Un'operazione di modifica è un qualsiasi task o insieme di task (aggiunte, eliminazioni o modifiche) sulle feature o sulle row. I valori di ID dello stato si applicano a qualsiasi modifica fatta nel geodatabase. Inizialmente la versione di DEFAULT punta allo stato 0. Con le modifiche al geodatabase l'ID dello stato inizierà ad incrementarsi. Normalmente l'ID dello stato si incrementa di un'unità per ogni operazione di editing. Comunque, ci sono delle eccezioni: dove l'ID dello stato si incrementa con un valore più grande dell'unità, così ad esempio durante un'operazione di riconcilia.

Facciamo ad esempio 4 modifiche a due feature class accedendo alla versione di default.

Prima delle modifiche:

Dopo le modifiche (eliminato un poligono, aggiunti due punti e modificato un attributo di un poligono):

Ora se andiamo a vedere la tabella degli stati:

Come possiamo notare lo state_id ora è 4 (avendo fatto 4 modifiche). I singoli stati dall'1 al 3 sono stati eliminati.

Nella tabella delta D (cancellazione) della feature poligonale possiamo notare due record perchè uno si riferisce all'eliminazione di una feature (con ObjectID 8) con riferimento allo stato Id 4 mentre il primo record è stato aggiunto perchè abbiamo fatto una modifica al poligono con ObjectID 3. La modifica aggiunge un record nella tabella delta A con i nuovi valori e contemporaneamente uno nella tabella D per eliminare il vecchio record.

Ora vediamo uno scenario a due livelli: creiamo due versioni (versioneA e versioneB) dalla versione di DEFAULT. In questo scenario l'ID dello stato crescerà con il numero delle modifiche effettuate nelle sessioni di editing nelle varie versioni. Inizialmente le versioni A e B partiranno con lo stesso ID di stato (stato 0) perchè sono state derivate dalla DEFAULT. Ora l'utente A che opera sulla versione A aggiunge una nuova feature e così l'ID di stato si incrementa di 1. Quando l'utente B inizia una sessione di editing, un nuovo ramo separato è creato dalla DEFAULT per registrare le modifiche. In questo scenario abbiamo ad esempio le seguenti operazioni:

Utente A aggiunge una feature;
utente B cancella una feature;
utente A fonde due feature in una singola;
utente B aggiunge una feature.

L'ordine di queste operazioni è registrato con il corrispondente ID di stato che rappresenta ogni cambio fatto al geodatabase.

Gli ID di stato nel geodatabase possono essere concepiti come una struttura ad albero. Questa struttura, chiamata diagramma ad albero degli stati, è una mappa logica degli stati in un geodatabase.
Man mano che si modifica nel tempo il geodatabase, una traccia (lineage) degli stati è mantenuta così da identificare tutte le modifiche apportate in una versione. Per determinare la lineage per una specifica versione, si seleziona il percorso più diretto nell'albero degli stati allo stato 0.

ID dello stato a 0 (dalla versione DEFAULT)

Sequenza di editing in multiutenza.

Utente A in versione A: aggiunta di un poligono

Utente B in versione B: cancellazione poligono

Utente A in versione A: fusione di 2 poligoni

Utente B in versione B: aggiunta di un poligono

Con il GDBT possiamo visualizzare l'albero degli stati per questa sequenza di editing

Qui vediamo le due lineage delle due versioni:

Le relazioni padre-figlio possono essere derivate dalle lineage dello stato. Entrambe le versioni A e B fanno riferimento al loro nuovo stato 3 e 4 a differenza della DEFAULT e la loro lineage contiene l'ID dello stato al quale riferisce la DEFAULT ovverosia lo stato 0. La lineage della versione A è 3,1,0 mentre quella della versione B è 4,2,0 mentre la DEFAULT punta all'ID dello stato 0.
Ciò significa che la DEFAULT è una versione antenata alle versioni A e B. Mentre la versione DEFAULT è la versione padre per le versioni A e B.

Tutte le versioni che esistono nel geodatabase ArcSDE possono essere viste nel Version Manager ad esclusione di quelle marcate private che sono solo visibili dai loro rispettivi proprietari.
In questa finestra di dialogo possono essere create e cancellate. Come precedentemente detto, è importate implementare la strategia di workflow che si adatti meglio al proprio business poichè la complessità della gestione delle versioni cresce in base al numero di versioni create.

Le modifiche apportate in una versione rimangono isolate in quella versione fino a quando il proprietario non decide di fonderle con un'altra versione. L'eccezione riguarda il cambio di schema di un dataset (ad esempio aggiunta di un campo in una tabella): questo cambio sarà applicato a tutte le versioni.

Il compito di fondere in modo appropriato le varie versioni si ottiene in ArcGIS grazie a due operazioni: il reconciling e il posting. Queste due operazioni in genere si eseguono l'una dopo l'altra (per esempio il reconciling seguito dal posting) per combinare le modifiche da una versione all'altra.

Reconcile
L'operazione di reconciling è il primo passo per fondere le modifiche tra due versioni. In questo processo le modifiche di una versione antenata (chiamata versione target) sono portate nella versione che è in modifica in una sessione di editing di ArcMap (chiamata versione edit). Una versione target può essere una qualsiasi versione nella lineage della versione che si sta modificando. Ritornando all'esempio precedente, sia la versione A che la versione B possono riconciliare con la DEFAULT perchè entrambe hanno nella loro lineage lo stato con ID 0 che è puntato dalla DEFAULT. Il processo di reconciling fonde le modifiche dalla versione target alla versione edit.

Per eseguire un'operazione di reconcile ci può essere solamente un utente a modificare la versione di edit. Dal momento che una versione mette tutti gli oggetti versionati nel geodatabase, qualsiasi feature modificata nella versione target verrà inserita nella versione di edit. Dal momento che la maggioranza di queste feature non si troverà in conflitto, si inseriranno senza problemi nella versione di edit. Ad esempio: se un poligono fosse aggiunto alla versione target dopo il processo di reconcile, il poligono apparirebbe anche nella versione di edit. L'utente potrebbe allora decidere se salvare o meno le modifiche nella versione di edit.
Ad un livello concettuale, un processo di reconcile comporta l'unione di modifiche relative ad un ramo dell'albero degli stati con un altro ramo.

Riprendiamo l'esempio precedente: dalla versione B eliminiamo un poligono.

Riconciliamo e postiamo con la versione antenata (DEFAULT):

Ora passiamo alla versione A: se riconciliamo con la versione DEFAULT scatta il conflitto perchè lo stesso poligono eliminato nella versione B e propagato alla versione DEFAULT esiste nella versione A.

Nella finestra di dialog Conflits possiamo gestire i conflitti alfanumeri e geografici.

Il processo di reconcile può essere implicito od esplicito.

Implicito: un'operazione di reconcile è implicita quando ci sono diversi utenti che modificano la stessa versione. Ogni utente mantiene il suo ramo per la durata della sessione di editing. Quando un utente cerca di salvare le modifiche della sua sessione avviene un'operazione di reconcile per mettere le modifiche al ramo dell'utente nel ramo al quale si riferisce la versione. Con più utenti in una versione, ogni volta che si salvano le modifiche viene eseguito il processo di reconcile. Non si può scegliere quando esso avviene: succede sempre quando si salvano le modifiche.

Esplicito: Quando si esegue un'operazione di reconcile tra diverse versioni, un utente sceglie quando eseguire il processo di reconcile. Questo è diverso dal processo implicito, che avviene quando si salvano le modifiche. Indipendentemente dal tipo di reconcile, il meccanismo è lo stesso.

La differenza tra processo implicito ed esplicito è quando avviene il processo di reconcile e come vengono specificate le opzioni di individuazione del conflitto.

Possibili conflitti durante il reconciling

In alcuni casi, una piccola percentuale di feature ed oggetti può essere in conflitto quando si confrontano la versione target e la versione edit. I conflitti possono scattare in due scenari di editing:

quando la stessa feature è aggiornata in entrambe le versioni (target e edit);
quando la stessa feature è aggiornata in una versiona e cancellata nell'altra.

In pratica, i conflitti non scatteranno frequentemente per la maggior parte dei processi di reconcile, perchè in molti workflow di business, le versioni tipicamente rappresentano differenti progetti con aree geografiche distinte. Pertanto la probabilità che avvengano dei conflitti è rara. I conflitti di solito sorgono quando gli utenti modificano feature in zone di confine.

Quando si eseguono operazioni di reconcile, ArcGIS trova i conflitti in due modi: per object ID o per attributo.
Conflitti per object ID significa che si individua una feature in conflitto quando qualsiasi parte di essa (geometria o attributi) è stata modificata sia nella versione di target che in quella di edit.
Conflitto per attributo significa che si individua una feature in conflitto solo quando lo stesso attributo è stato modificato sia nella versione di target che in quello di edit.

Le regole delle risoluzioni dei conflitti si possono impostare automaticamente sia a favore della versione di target che di edit. C'è anche l'opzione di far risolvere manualmente i conflitti individuati all'utente della versione di edit rivedendo ogni conflitto con la finestra di dialogo Conflicts Resolution in ArcMap.

Si può esaminare dettagliatamente ogni conflitto e l'utente decide se applicare la modifica della versione target, mantenere la modifica della versione di edit o riconvertire la feature a com'era all'inizio della sessione di edit. Dopo la risoluzione di tutti i conflitti (se ce ne sono), il processo di reconcile può considerarsi completato e l'utente può salvare le modifiche e continuare a modificare o procedere con un'operazione di post.

Post

Il post è il secondo passo quando si uniscono le modifiche di due versioni. Questo processo deve sempre seguire un'operazione di riconciliazione. Il processo di post sincronizza la corrente versione di edit con la versione di target. Tutte le modifiche fatte nella versione di edit sono salvate nella versione target facendo entrambe le versioni identiche.
A differenza del processo di reconcile, il posting non può essere annullato una volta che è stato eseguito perchè le modifiche sono applicate ad una versione al di fuori di una sessione di editing.
A questo punto, l'utente della versione di edit ha l'opzione di continuare a fare modifiche in una sessione di editing e poi eseguire un'altro processo di reconcile e di post per sincronizzare le due versioni o semplicemente salvare le modifiche e fermare la sessione di editing nella versione di edit.

Qui potete vedere come riconciliare, ascoltare gli eventi delle versioni, trovare le differenze tra versioni e risolvere i conflitti, tutto via codice tramite gli ArcObjects.

Compress
Nel tempo un'attività di editing in un geodatabase ArcSDE Enterprise accumula centinaia di migliaia di ID di stato (rappresentanti le modifiche memorizzate nella tabella delta). Questo può impattare negativamente nelle prestazioni. Periodicamente l'amministratore ArcSDE deve comprimere il geodatabase ArcSDE rimuovendo gli stati non più riferiti da una versione. Un'operazione di compress può ridurre la profondità dell'albero degli stati e aiuta nelle prestazioni del sistema.
La compressione non rimuove dati che sono accessibili attraverso la lineage della versione, ma solamente i dati non utilizzati. Un'operazione di compress è implementata come una serie di transazioni che rimuovono e rinominano gli stati, il tutto all'interno di una transazione nel database per assicurare che il DBMS possa ripristinare il geodatabase ad uno stato consistente.

Albero degli stati prima di un'operazione di compress.

Albero degli stati dopo un'operazione di compress.

Non ti scordar mai del result map service...

2011-09-20T22:02:00.002+02:00

I servizi di geoprocessing possono essere creati pubblicando due differenti risorse ArcGIS Desktop: un toolbox o un documento di ArcMap contenente layer di tool.

quando pubblichiamo un toolbox, tutti i tools nel toolbox diventano task di geoprocessing nel servizio di geoprocessing;
quando pubblichiamo un documento di mappa, tutti i layer di tool nel documento di mappa diventano task di geoprocessing del servizio di geoprocessing di ArcGIS Server. I layer di tool sono creati trascinando i tool nella tabella dei contenuti (TOC) di ArcMap;
quando pubblichiamo un documento di mappa contenente layer di tool, possiamo anche specificare se desideriamo che il documento di mappa diventi un servizio di mappa da utilizzare per generare l'output dei task. Un servizio di mappa che genera gli output dei task è chiamato result map service.

Ma vediamo nel dettaglio i result map service.

I servizi di geoprocessing possono avere un result map service per creare un'immagine della mappa come risultato dei task. Le immagini sono facili da gestire, trasferire e visualizzare su web.

Le immagini della mappa sono create dal servizio di mappa di ArcGIS Server e sono il risultato della pubblicazione del documento mappa (.mxd). Ma perchè creare un'immagine come risultato del task?

I motivi possono essere molteplici:

il risultato del task potrebbe essere potenzialmente un dataset di grosse dimensioni;
il tipo di dato restituito in output potrebbe non essere supportato dal client (esempio raster in ArcGIS Explorer). In questo caso utilizziamo il result map service per visualizzare l'output;
desideriamo proteggere i dati del dataset e consentiamo solo la visualizzazione dei risultati;
abbiamo una complessa cartografia da visualizzare ed il client non ha le capabilities per poterlo fare;
abbiamo la necessità di visualizzare immagini in report (ad esempio in report services);
per generare tematizzazioni lato server.

Quando utilizziamo i result map service è importante sottolineare che avremo due servizi: il servizio di geoprocessing e il result map service. Questi due servizi sono eseguiti indipendentemente l'uno dall'altro. Quando si invoca il task, ArcGIS Server esegue prima il task di geoprocessing e poi esegue il result map service per generare l'output del servizio di geoprocessing utilizzando la mappa del result map service. Questo significa che l'output dei task nel servizio di geoprocessing deve essere un dataset su disco e non un dataset in memoria perchè il result map service deve poter accedere al dato elaborato (GPRasterDataLayer o GPFeatureRecordSetLayer).

Uno degli errori più comuni è quello però di utilizzare il result map service come servizio di base della mappa dell'applicazione. L'utente clicca ad esempio su una particella, il nostro task ci restituisce la particella selezionata con un colore in funzione, ad esempio di un attributo. A questo punto, perchè non utilizzare il result map service come servizio di base della mappa? Lo abbiamo già a disposizione senza dover creare un altro servizio di mappa.

I motivi sono due:

quando un result map service è aggiunto ad una applicazione, tutti i layer del servizio sono disponibili alla visualizzazione. Questi layer includono i layer di tool di geoprocessing utilizzati per la generazione dell'output, layer che possono contenere dati sensibili o layer utilizzati dal servizio di geoprocessing ma che non ha senso visualizzare per l'utente (tipo i layer di tool);
le mappe di base sono multiscala e multirisoluzione (costruite per mostrare dettagli alle grandi scale e generalizzazioni alle piccole scale). Creare mappe di base multiscala e multirisoluzione che vengono generate velocemente è una caratteristica che il nostro result map service non necessita di avere poichè il suo lavoro è quello di generare un output.

Passiamo ora ad un esempio pratico.

Creiamo un modello che calcola le service area (utilizziamo i dati di questo esempio):

Come potete vedere, abbiamo come input i valori di break (impostiamo un default: 1 2 3) e la posizione, mentre come output la service area.

E' importante salvare l'output su disco poichè successivamente il servizio di mappa ArcGIS Server dovrà utilizzarlo per generare la mappa.

Quando il task del servizio di geoprocessing viene invocato, ArcGIS Server imposta al volo la variabile %scratchworkspace% al percorso fisico della cartella di nome 'scratch' contenuta all'interno della cartella univoca del job generato. Ogni volta che si esegue un task, una cartella univoca di job è creata all'interno della cartella del servizio contenuta all'interno della cartella 'jobs' di arcgis server. Qui sotto è illustrato lo schema delle cartelle e dei file gestiti da ArcGIS Server durante la creazione dei job.

Pertanto abbiamo la possibilità di memorizzare l'output in un file geodatabase già pronto creato dal sistema (scratch.gdb) o salvarlo nella cartella scratch come file (ad esempio come shapefile).

Nel primo caso il percorso di output sarà:

%scratchworkspace%\scratch.gdb\SAPolygon

Nel secondo caso sarà:

%scratchworkspace%\SAPolygon.shp

Optiamo per il primo caso e quindi nel modello impostiamo per l'ouput:

A questo punto creiamo la mappa che utilizzeremo come result map service. Trasciniamo nella TOC (tabella dei contenuti) di ArcMap il tool e carichiamo il network dataset utilizzato per il calcolo della service area. E' importante caricare in mappa il network dataset perchè utilizzare layer come sorgenti migliora le prestazioni del modello. Difatti, se si dovesse fare riferimento ad un network dataset su disco ogni volta che viene eseguito il task, il sistema dovrebbe leggere la struttura dei file; mentre, se è già caricato, vengono sfruttate la lettura iniziale e le proprietà del dataset in cache.

Ora, dal menu di Geoprocessing di ArcMap, occorre selezionare Enviroments ... ed impostare nella sezione Workspace il valore per la proprietà 'Scratch Workspace'. E' importante indicare una cartella dove l'utente SOC abbia i privilegi per leggere; poichè, una volta eseguito il modello per creare il layer di output, il documento di mappa verrà pubblicato ed i layer in esso contenuti dovranno essere accessibili.

In questo esempio ho creato nella cartella 'Progetti' (dove l'utente SOC può leggere) una cartella 'Test' con all'interno una cartella di nome 'Scratch' che a sua volta contiene un file geodatabase di nome 'scratch', così il modello potrà trovare il file geodatabase (visto come ho impostato l'output nel modello).

A questo punto eseguiamo il modello da ArcMap: selezioniamo il layer di tool dalla TOC e clicchiamo con il tasto destro del mouse, dal context menu visualizzato selezioniamo la voce Open.

Viene così aperta la maschera di input del modello che ci consente di selezionare un punto sulla mappa e generare la service area.

A questo punto selezioniamo il tool sulla mashera e clicchiamo un punto sulla mappa. Il modello verrà eseguito e verrà creata la feature class nel file geodatabase indicato in output (la variabile %scratchworkspace% viene risolta da quello che è stato impostato in Enviroments in ArcMap).

Una volta generate le service area, possiamo creare la nostra legenda direttamente in ArcMap o fare riferimento direttamente ad un layer, se nel modello abbiamo impostato il Layer Symbology dell'output.

Infine creiamo il servizio di mappa dall'mxd indicando nelle capabilities anche Geoprocessing. Verranno creati, come precedentemente detto, due servizi.

Se diamo un'occhiata alle proprietà del servizio di geoprocessing, noteremo che la proprietà Result Map Service punta al servizio di mappa DrivePolygon.

Ora vediamo come chiamare il task da client. In questo esempio utilizziamo le API Javascript ma potete utilizzare gli analoghi metodi per Flex e Silverlight.

Con il metodo getResultImageLayer ci facciamo restituire l'output del task come immagine che carichiamo come layer sulla mappa.

 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
  
 <html>
  
  <head>
  
   <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
  
   <meta http-equiv="X-UA-Compatible" content="IE=7,IE=9" />
  
   <!--The viewport meta tag is used to improve the presentation and behavior of the samples 
  
    on iOS devices-->
  
   <meta name="viewport" content="initial-scale=1, maximum-scale=1,user-scalable=no"/>
  
   <title>Service Area Task</title>
  
   <link rel="stylesheet" type="text/css" href="http://serverapi.arcgisonline.com/jsapi/arcgis/2.4/js/dojo/dijit/themes/claro/claro.css">
  
   <script type="text/javascript" src="http://serverapi.arcgisonline.com/jsapi/arcgis/?v=2.4"></script>
  
   <script type="text/javascript">
  
     dojo.require("esri.map");
  
     dojo.require("esri.tasks.gp");
  
     var map, gp;
  
     var driveTimes = "1 2 3";
  
     /*Initialize map, GP and image params*/
  
     function init() {
  
       var startExtent = new esri.geometry.Extent({ "xmin": -122.673387, "ymin": 37.635131, "xmax": -122.157408, "ymax": 37.918426, "spatialReference": { "wkid": 4326} });
  
       map = new esri.Map("mapDiv", { extent: startExtent });
  
       var imageParameters = new esri.layers.ImageParameters();
  
       imageParameters.format = "jpeg"; //set the image type to PNG24, note default is PNG8. 
  
       //Takes a URL to a non cached map service. 
  
       var dynamicMapServiceLayer = new esri.layers.ArcGISTiledMapServiceLayer("http://server.arcgisonline.com/ArcGIS/rest/services/ESRI_StreetMap_World_2D/MapServer", { "imageParameters": imageParameters });
  
       map.addLayer(dynamicMapServiceLayer);
  
       gp = new esri.tasks.Geoprocessor("http://localhost/ArcGIS/rest/services/DrivePolygon/GPServer/PolygonDriver");
  
       gp.setOutputSpatialReference({ wkid: 4326 });
  
       dojo.connect(map, "onClick", computeServiceArea);
  
     }
  
     function computeServiceArea(evt) {
  
       map.graphics.clear();
  
       var pointSymbol = new esri.symbol.SimpleMarkerSymbol();
  
       pointSymbol.setOutline = new esri.symbol.SimpleLineSymbol(esri.symbol.SimpleLineSymbol.STYLE_SOLID, new dojo.Color([255, 0, 0]), 1);
  
       pointSymbol.setSize(5);
  
       pointSymbol.setColor(new dojo.Color([0, 255, 0, 0.25]));
  
       var graphic = new esri.Graphic(evt.mapPoint, pointSymbol);
  
       map.graphics.add(graphic);
  
       var features = [];
  
       features.push(graphic);
  
       var featureSet = new esri.tasks.FeatureSet();
  
       featureSet.features = features;
  
       var params = { "Input_locations": featureSet, "Default_break_values": driveTimes };
  
       gp.submitJob(params, completeCallback, statusCallback);
  
     }
  
     function statusCallback(jobInfo) {
  
       console.log(jobInfo.jobStatus);
  
     }
  
     function completeCallback(jobInfo) {
  
       var imageParams = new esri.layers.ImageParameters();
  
       imageParams.imageSpatialReference = map.spatialReference;
  
       gp.getResultImageLayer(jobInfo.jobId, "SAPolygons", imageParams, function (gpLayer) {
  
         gpLayer.setOpacity(0.5);
  
         map.addLayer(gpLayer)
  
       });
  
     }
  
     dojo.addOnLoad(init);
  
   </script>
  
  </head>
  
  <body class="claro">
  
   <div id="mapDiv" style="width:800px; height:600px; border:1px solid #000;"></div>
  
   Zoom in to a US city and single click the map. A service area GP task will be executed synchronously and on
  
   completion the results will be drawn as graphic features to the map. The drive time polygons are 1, 2,
  
   and 3 minutes.
  
  </body>
  
 </html>

Come possiamo vedere da Fiddler alla riga 21 viene invocato il job, dalla 22 alla 26 viene controllato se il job ha terminato con successo ed infine alla riga 27 viene fatta la richiesta dell'immagine del job.

Come possiamo vedere nel dettaglio la richiesta REST dell'immagine è:

http://localhost/ArcGIS/rest/services/DrivePolygon/GPServer/PolygonDriver/jobs/ja354cae94d0e44fcb740484883d42d56/results/SAPolygons?dpi=96&transparent=true&format=png8&imageSR=4326&f=image&bbox=%7B%22xmin%22%3A-122.69005570312501%2C%22ymin%22%3A37.57078484765625%2C%22xmax%22%3A-122.14073929687501%2C%22ymax%22%3A37.98277215234375%2C%22spatialReference%22%3A%7B%22wkid%22%3A4326%7D%7D&bboxSR=4326&size=800%2C600

In sintesi, all'url del geoprocessing si appendono 'jobs', l'id del job, 'results' ed il nome del parametro di output e si concatenano i parametri di export map per l'immagine.

Archiving: questo sconosciuto ...

2011-08-18T21:54:00.000+02:00

Quante volte ti hanno chiesto di tenere traccia di tutte le modifiche apportate nel tempo al geodatabase? Spesso la gestione della history dei dati è un’operazione che non viene effettuata. Ma, così facendo, perdiamo moltissime informazioni. Ad esempio, a domande di questo tipo non potremmo rispondere:

- che valore aveva uno specifico attributo in un determinato periodo di tempo?

- come si è modificata nel tempo una specifica feature o row?

- come è cambiata nel tempo la geometria di un poligono?

Quante operazioni di analisi spaziale eseguiamo senza considerare le differenze temporali relative ai dati: capite che l’elaborazione potrebbe non dare risultati corretti. Il caso più evidente, per fare un esempio pratico, sono le particelle catastali che hanno una dinamicità nel tempo abbastanza elevata (frazionamenti, fusioni, cambi di proprietà ecc.) ma se ci pensate bene anche dati come i comuni o le province cambiano nel tempo (esempio: formazione della provincia di Monza e Brianza o - voci di questi giorni - l’eliminazione di provincie con meno di 300000 abitanti).

Archiving in ArcGIS, introdotto dalla versione 9.2, fornisce la funzionalità di registrare ed accedere ai cambiamenti apportati a tutti i dati o ad un sottoinsieme di essi di un geodatase versionato. Archiving è il meccanismo per catturare, gestire ed analizzare i dati che vengono modificati nel tempo.

Il geodatabase archiving mantiene i cambi dal momento in cui viene abilitato a farlo fino a quando l’archiving è disabilitato.

Precedentemente all’introduzione dell’archiving, una delle soluzioni alternative per catturare le modifiche nel tempo era quella di creare delle versioni, che fungevano da snapshots, per l’intero geodatabase. Comunque, una soluzione di questo tipo non era completamente soddisfacente perché, una volta che i dati venivano deversionati o la versione veniva eliminata, si perdeva la rappresentazione storica dei dati. L’archiving avviene parallelamente alle modiche dei dati non appesantendo il sistema e richiede meno consumo di risorse quando si utilizza rispetto all’equivalente classe versionata.

Il Geodatabase archiving introduce la versione historical in aggiunta a quella già esistente ovvero la versione transactional.

L’utente può connettersi o ad una versione transactional o ad una versione historical.

Una versione transactional consente ad un utente di modificare i dati. Una versione historical rappresenta i dati ad uno specifico momento nel tempo e fornisce una rappresentazione in sola lettura del geodatabase.

Un utente può connettersi ad una versione historical utilizzando un riferimento storico (historical marker) o specificando un momento ben preciso. In sostanza con il riferimento storico nominiamo un tempo (esempio: “incendio boschivo zona Spinelli” è il nostro riferimento storico per fare riferimento alla data 14:00 PM Giugno 2003).

Il modello archiving supporta completamente il modello dati del geodatabase: pertanto stand-alone feature classes, feature datasets, tables, relationship classes, networks, topologies, e terrains possono partecipare all’archiving.

L’archiving richiede che i dati siano registrati come versionati e con l’opzione “Register the selected objects with the option to move edits to base.” non selezionata.

Una volta che l’archiving è abilitato, tutti i cambi salvati o postati alla versione di DEFAULT sono registrati nella corrispondente classe archive. La classe archive è una completa copia della classe abilitata più tutte le modifiche che sono stata salvate o postate alla versione di DEFAULT.

Una cosa importate da capire è però come ArcGIS rappresenti il tempo quando i cambi vengono effettuati. La history può essere registrata o con un valido momento temporale o con un riferimento temporale transaction. La differenza tra i due è che il primo rappresenta il momento temporale in cui i cambi sono avvenuti nel mondo reale e normalmente vengono registrati dall’utente che applica le modifiche mentre il secondo è il momento in cui il dato è stato modificato nel database. I riferimenti temporali transaction sono generati automaticamente dal sistema e sono quelli utilizzati da ArcGIS. Pertanto occorre prestare molta attenzione per non avere ad esempio modifiche nel geodatabase nell’ordine non corretto rispetto al mondo reale.

Illustriamo ora come abilitare e gestire l’archiving. In questo caso utilizzo la licenza ArcEditor con installato un personal SDE geodatabase memorizzato in SQL Server Express 2008 R2 e copiamo la feature class Trees che trovate nel file geodatabase GDBTrees.gdb della cartella C:\Programmi\ArcGIS\ DeveloperKit10.0\Samples\data\Trees.

Da ArcCatalog seleziono la feature class che desidero abilitare all’archiving.

Come detto precedentemente, per poter abilitare la feature class all’archiving, devo in via preliminare versionarla con l’opzione “Register the selected objects with the option to move edits to base.” non abilitata.

Un dataset abilitato all’archiving abiliterà tutte le feature class contenute in esso.

Lato programmazione: se la proprietà moveEditsToBase è abilitata sulla nostra object class, occorre chiamare dall’interfaccia IVersionedObject3 il metodo UnRegisterAsVersioned3(false) per deregistrare la classe come versionata disabilitando il ‘moving of edits to the base table’ e poi chiamare sempre dalla IVersionedObject3 il metodo RegisterAsVersioned3(false) per registrare l’object come versionato con l’opzione moveEditsToBase a false.

A questo punto possiamo abilitare l’archiving:

Nel momento in cui si abilita l’archiving nel geodatabase viene creata una classe archiving che tiene traccia di tutte le modiche effettuare sull’ object class (in questo esempio la feature class Trees). Nel geodatabase la classe archiving è una tabella con il nome della feature class con l’aggiunta del suffisso ‘_H’

Oltre ai campi dell’object class (nel nostro esempio: ObjectID, Year_Planted e Shape) all’archiving class vengono aggiunti anche i campi: GDB_FROM_DATE, GDB_TO_DATE e GDB_ARCHIVE_OID.

L’GDB_ARCHIVE_OID funge da OBJECTID nella classe archiving (Trees_H).

E’ possibile modificare il nome della classe archiving ed i nomi dei campi aggiunti per l’archiving utilizzando la classe ArchiveRegistrationInfo.

namespace Studioat.Samples.Archiving

{

    using System;

    using System.Collections.Generic;

    using ESRI.ArcGIS.esriSystem;

    using ESRI.ArcGIS.Geodatabase;

 

    internal class Program

    {

        private static LicenseInitializer licenseInitializer = new LicenseInitializer();

    

        [STAThread]

        internal static void Main(string[] args)

        {

            ////ESRI License Initializer generated code.

            licenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeArcEditor }, new esriLicenseExtensionCode[] { });

 

            ////connessione ad una versione transactional

            IWorkspace workpace = Archive.GetPersonalOrWorkgroupArcSdeWorkspace("studioat40_sqlexpress", "sde:sqlserver:studioat40\\sqlexpress", "OSA", "History", Archive.TypeVersion.VERSION, "dbo.DEFAULT");

 

            IFeatureWorkspace fw = workpace as IFeatureWorkspace;

            IObjectClass oc = fw.OpenFeatureClass("Trees") as IObjectClass;

 

            ////facoltativo il passaggio di un set di ArchiveRegistrationInfo per indicare dei nomi diversi

            ////rispetto a quelli di default (impostati ad esempio in dbtune)

            ISet setArchiveInfo = new SetClass();

            setArchiveInfo.Add(new ArchiveRegistrationInfoClass() { ArchiveTableName = "TreesHistory", FromFieldName = "Da", ToFieldName = "A", OIDFieldName = "OIDHistory", DatasetName = "Trees" });

 

            ////imposto ad esempio un secondo ArchiveRegistrationInfo se è una classe relazionata a Trees (se utilizzo il 3° parametro true nell'abilitazione all'archiving)

            ////setArchiveInfo.Add(new ArchiveRegistrationInfoClass() { ArchiveTableName = "TreesMaintenanceHistory", FromFieldName = "Da", ToFieldName = "A", OIDFieldName = "OIDHistory", DatasetName = "TreesMaintenance" });

            

            ////ISet setArchiveInfo = null;

            

            oc.EnableArchiving(setArchiveInfo);

            

            ////determino il numero di differenze (inserimenti) tra l'historical name DEFAULT e l'historical name di nome 'Test'

            ////IFIDSet fids = FindHistoricalDifferences(workpace, "Test", "Trees", esriDifferenceType.esriDifferenceTypeInsert);

            ////Console.WriteLine("Insert:" + fids.Count().ToString());

 

            ////ESRI License Initializer generated code.

            ////Do not make any call to ArcObjects after ShutDownApplication()

            licenseInitializer.ShutdownApplication();

        } 

    }

 

    public static class Archive

    {

        public enum TypeVersion

        { 

             /// <summary>

             /// Version Transactional

             /// </summary>

             VERSION,

             /// <summary>

             /// Version Historical Name

             /// </summary>

             HISTORICAL_NAME,

             /// <summary>

             /// Version Historical Timestamp

             /// </summary>

             HISTORICAL_TIMESTAMP

        }

 

        public static IWorkspace GetPersonalOrWorkgroupArcSdeWorkspace(string server, string instance, string authenticationMode, string database, TypeVersion typeVersion, string version)

        {

            IPropertySet propertySet = new PropertySetClass();

            propertySet.SetProperty("SERVER", server);

            propertySet.SetProperty("INSTANCE", instance);

            propertySet.SetProperty("DATABASE", database);

            propertySet.SetProperty("AUTHENTICATION_MODE", authenticationMode);

            object o = version;

            if (typeVersion == TypeVersion.HISTORICAL_TIMESTAMP)

            {

                o = Convert.ToDateTime(version);

            }

            propertySet.SetProperty(Enum.GetName(typeof(TypeVersion), typeVersion), o);

 

            Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory");

            IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(factoryType);

            return workspaceFactory.Open(propertySet, 0);

        }

 

        public static ITable GetArchiveTable(this IObjectClass objectClass)

        {

            IArchivableClass archivableClass = objectClass as IArchivableClass;

            return archivableClass.Archive;

        }

 

        public static void EnableArchiving(this IObjectClass objectClass, ISet setArchiveInfo)

        {

            IArchivableObject archivableObjecting = objectClass as IArchivableObject;

            if (!archivableObjecting.IsArchiving)

            {

                ////time stamp inizializzato dal sistema (imposto null)

                ////se l'object class ha relationship è possibile impostare l'ultimo parametro a true per automaticamente

                ////abilitare l'archiving sulle object class relazionate

                archivableObjecting.EnableArchiving(setArchiveInfo, null, false);

            }

        }

 

        public static IWorkspace ConnectoToVersion(string server, string instance, string user, string password, string database, TypeVersion typeVersion, string version)

        {

            IPropertySet propertySet = new PropertySetClass();

            propertySet.SetProperty("SERVER", server);

            propertySet.SetProperty("INSTANCE", instance);

            propertySet.SetProperty("DATABASE", database);

            propertySet.SetProperty("USER", user);

            propertySet.SetProperty("PASSWORD", password);

            object o = version;

            if (typeVersion == TypeVersion.HISTORICAL_TIMESTAMP)

            {

                o = Convert.ToDateTime(version);

            }

            propertySet.SetProperty(Enum.GetName(typeof(TypeVersion), typeVersion), o);

 

            Type factoryType = Type.GetTypeFromProgID("esriDataSourcesGDB.SdeWorkspaceFactory");

            IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(factoryType);

            return workspaceFactory.Open(propertySet, 0);

        }

 

        public static IFIDSet FindHistoricalDifferences(IWorkspace workspace, string historicalMarkerName, string tableName, esriDifferenceType differenceType)

        {

            IHistoricalWorkspace historicalWorkspace = (IHistoricalWorkspace)workspace;

            IHistoricalVersion defaultVersion = historicalWorkspace.FindHistoricalVersionByName(historicalWorkspace.DefaultMarkerName);

            IHistoricalVersion historicalVersion = historicalWorkspace.FindHistoricalVersionByName(historicalMarkerName);

 

            IFeatureWorkspace defaultFWS = (IFeatureWorkspace)defaultVersion;

            IFeatureWorkspace historicalFWS = (IFeatureWorkspace)historicalVersion;

            ITable defaultTable = defaultFWS.OpenTable(tableName);

            ITable historicalTable = historicalFWS.OpenTable(tableName);

 

            IVersionedTable versionedTable = (IVersionedTable)defaultTable;

            IDifferenceCursor differenceCursor = versionedTable.Differences(historicalTable, differenceType, null);

 

            IFIDSet fidSet = new FIDSetClass();

            IRow differenceRow = null;

            int objectID = -1;

 

            differenceCursor.Next(out objectID, out differenceRow);

            while (objectID != -1)

            {

                fidSet.Add(objectID);

                differenceCursor.Next(out objectID, out differenceRow);

            }

 

            fidSet.Reset();

            return fidSet;

        }

 

        public static IList<IPair<string, object>> GetHistoricalMarkers(IWorkspace workspace)

        {

            IList<IPair<string, object>> list = new List<IPair<string, object>>();

            IHistoricalWorkspace historicalWorkspace = (IHistoricalWorkspace)workspace;

            IEnumHistoricalMarker enumHistoricalMarker = historicalWorkspace.HistoricalMarkers;

            enumHistoricalMarker.Reset();

 

            IHistoricalMarker historicalMarker = null;

            while ((historicalMarker = enumHistoricalMarker.Next()) != null)

            {

                list.Add(new Pair<string, object>() { First = historicalMarker.Name, Second = historicalMarker.TimeStamp }); 

            }

 

            return list;

        }

    }

 

    /// <summary>

    /// classe generica per gestire coppie di oggetti

    /// </summary>

    /// <typeparam name="T">tipo del primo oggetto</typeparam>

    /// <typeparam name="U">tipo del secondo oggetto</typeparam>

    public struct Pair<T, U> : IPair<T, U>

    {

        private T first;

        private U second;

 

        public T First

        {

            get

            {

                return this.first;

            }

 

            set

            {

                this.first = value;

            }

        }

 

        public U Second

        {

            get

            {

                return this.second;

            }

 

            set

            {

                this.second = value;

            }

        }

    }

 

    /// <summary>

    /// interfaccia per coppie di oggetti generici

    /// </summary>

    /// <typeparam name="T">tipo del primo oggetto</typeparam>

    /// <typeparam name="U">tipo del secondo oggetto</typeparam>

    public interface IPair<T, U>

    {

        T First

        {

            get;

            set;

        }

 

        U Second

        {

            get;

            set;

        }

    }

}

Una volta che si abilita l’archiving, la classe archiving si presenta con tutti i record dell’object class presenti nella versione di DEFAULT. Come si può notare, la data GDB_FROM_DATE è stata inizializzata nel momento in cui è stato abilitato l’archiving (13/7/2011 alle 20.59.19), mentre il GDB_FROM_TO è lasciato aperto (data impostata ad infinito) .

Facendo una connessione alla versione historical con una data precedente al 13/7/2011 alle 20.59.19 non vediamo nessuna feature perché prima di questa data non era ancora abilitato l’archiving:

Ma se effettuiamo una connessione indicando una data posteriore al 13/7/2011 alle 20.59.19 vedremo tutte le feature della feature class (nel nostro caso 5 trees).

Da notare che viene creato anche in automatico il riferimento temporale di abilitazione dell’archiving denominato DEFAULT.

Per ogni operazione di archive, il riferimento temporale DEFAULT è aggiornato con il valore dell’operazione di archive. Ciò consente che, quando si sceglie il riferimento temporale DEFAULT e si lavora con una versione historical, la corrente rappresentazione della classe archive è equivalente alla rappresentazione della classe versionata nella versione DEFAULT di tipo transactional.

Il riferimento temporale di abilitazione dell’archiving può anche essere visto nelle proprietà della feature class:

Ma ora vediamo cosa succede all’archiving class quando si aggiunge, modifica o cancella una feature nella feature class.

Lato programmazione: l’evento che cattura il momento dell’operazione di archive è OnArchiveUpdated dell’interfaccia IVersionEvents2.

Sull’aggiunta di una feature in ArcMap verrà compilato in automatico con la data di sistema il campo GDB_FROM_DATE mentre il campo GDB_TO_DATE verrà lasciato aperto (data impostata ad infinito). I valori nei campi che rappresentano la feature class (OBJECTID, YEAR_PLATED e SHAPE) sono uguali ai corrispondenti della feature class.

Ora modifichiamo la posizione spaziale da ArcMap della feature con OBJECID uguale ad 1.

Come possiamo notare la feature con OBJECTID uguale ad 1 e GDB_ARCHIVE_OID uguale ad 1 viene chiusa con la data della modifica della feature class (13/08/2011 alle 20:41.28) col campo GDB_TO_DATE e viene creato un nuovo record con i dati della feature modificati (in questo caso solo il campo shape mentre OBJECTID e YEAR_PLANTED rimangono invariati) e con il valore della data di modifica nel campo GDB_FROM_DATE mentre GDB_TO_DATE rimane aperto (data impostata ad infinito).

Infine vediamo la cancellazione di una feature con OBJECTID uguale ad 3. In questo caso viene solo compilato il campo GDB_TO_DATE con la data di cancellazione della feature.

Per la gestione della history in ArcMap abbiamo a disposizione la toolbar “Geodatabase History”

Il primo pulsante apre il “Geodatabase History Viewer” che permette di visualizzare i dati selezionando un riferimento temporale precedentemente creato (Historical marker) od uno specifico momento temporale senza modificare la connessione. Comodo è l’Auto Apply che, se abilitato, permette sulla modifica dei riferimenti temporali di visualizzare automaticamente i cambiamenti in mappa senza dover cliccare ulteriori pulsanti di conferma.

Il secondo pulsante consente di caricare in mappa la classe di archiving della feature class selezionata in TOC.

In questo modo l’utente potrà effettuare le proprie interrogazioni, ad esempio utilizzando il Select By Attributes.

Il terzo pulsante consente di creare i riferimenti temporali (Historical Marker). Una volta selezionata la connessione sulla TOC è possibile creare i riferimenti temporali per poi poterli successivamente utilizzare nella visualizzazione temporale dei dati.

E’ possibile disabilitare l’archiving di un object class. In questo caso tutte le modifiche salvate o postate alla versione di DEFAULT non verranno più registrate nella relativa classe di archivio.

Quando si disabilita l’archiving, viene presentato un messaggio che chiede se si vuole mantenere o cancellare la classe archive. Se si sceglie di non eliminare la classe archive associata possiamo preservarla come tabella temporale nel geodatabase.

Consigli sulla disabilitazione dell’archiving

L’archiving deve essere disabilitato su una classe prima che possa essere deversionata.
Eliminando un feature dataset od una classe con archiving abilitato preserviamo le classi archive.

Dalla versione 10 nel geodatabase replication è possibile utilizzare la classe archive per tenere traccia delle modifiche invece di utilizzare le tabelle delta delle versioni. Questa possibilità è disponibile solo per le repliche one-way. In tal modo i riconcilia, post e compress non sono influenzati rendendo la gestione delle versioni e delle repliche indipendenti. Ciò consente anche che la schedulazione della sincronizzazione sia più flessibile.

Infine illustriamo uno scenario in cui si potrebbe creare un salto temporale nella classe archive:

Un utente effettua modifiche direttamente nella versione di DEFAULT ed elimina una feature in una sessione di editing. Infine, l’utente salva le modifiche. L’attributo GDB_TO_DATE nella classe archive viene aggiornato con la data di sistema della cancellazione dell’oggetto.

Se lo stesso oggetto è aggiornato da una versione figlia e riconciliata con la versione di DEFAULT, scatta il conflitto.

Se durante il processo di risoluzione del conflitto l’utente sceglie di sostituire il conflitto con la rappresentazione modificata nella versione figlia, la riga verrà sostituita nella versione di DEFAULT quando la versione stessa verrà postata. L’operazione di archive inserisce una nuova riga nella classe archive e imposta l’attributo GDB_FROM_DATE alla data di sistema e l’attributo GDB_TO_DATE ad infinito (12/31/9999).

Pertanto, quando l’utente osserva il lineage dell’oggetto temporalmente, le date conterranno un salto tra il GDB_TO_DATE e il GDB_FROM_DATE per il tempo in cui l’oggetto non esiste nella versione di DEFAULT.

Add-in: come ti personalizzo ArcGIS Desktop

2011-07-30T22:07:00.049+02:00

ArcGIS 10 ha introdotto diverse novità per personalizzare ed estendere più facilmente le applicazioni Desktop ArcGIS, introducendo il nuovo modello add-in desktop. Il nuovo modello fornisce un framework, su base dichiarativa, per creare personalizzazioni pacchettizzate in un singolo file compresso. Una delle caratteristiche principali è che gli add-ins sono facilmente condivisibili tra utenti perché non richiedono installazione o registrazione di componenti COM. Gli add-ins sono aggiunti al sistema semplicemente copiandoli in una ben determinata cartella e rimossi cancellandoli dalla cartella stessa. Inoltre, indicando una cartella di rete, è possibile condividerli per una intera organizzazione centralizzando l’installazione.
Gli add-ins possono essere scritti utilizzando .NET o Java con XML. L’XML descrive la personalizzazione mentre le classi .NET o Java forniscono il comportamento personalizzato.
Installando l’SDK ArcObjects, vengono inclusi Wizard per la creazione di Add-Ins integrati direttamente nell’ambiente di sviluppo installato nel sistema (Microsoft Visual Studio - inclusa la versione libera Express - ed Eclipse), agevolando così lo sviluppo.

Come avrete già sentito, la personalizzazione che utilizza VBA, dalla versione 10, è stata deprecata anche se è ancora possibile usarla richiedendo un file di licenza per l’estensione VBA. Ma rimangono comunque, in funzione dello scopo o della specifica soluzione da costruire, altre opzioni che potrebbero essere ancora più indicate rispetto agli add-ins.

Python

Molte aree di applicazione in ArcGIS sono accessibili attraverso un semplificato utilizzo delle API Python facendo in modo che i più comuni task possano essere creati facilmente. Inoltre gli script di Python sono facilmente condivisibili e possono essere creati senza un ambiente di sviluppo esterno. Sebbene siano presenti moltissimi moduli di dominio pubblico, Python non è adatto per qualsiasi task di programmazione. Anche se si sta migliorando, non tutte le aree di applicazione in ArcGIS sono state ancora coperte. Inoltre gli ambienti di sviluppo per le modifiche ed il debugging non sono ancora così sofisticati e facili da usare come ambienti tipo Microsoft Visual Studio. Infine non è possibile ascoltare e rispondere ad eventi ArcGIS, implementare interfacce COM o comunicare con molti punti dell’estensibilità COM.

Dalla versione 10.1 sarà possibile creare Add-ins anche mediante Python.

Estensibilità COM classica

Il framework add-in non supporta ogni punto di estensibilità definita da ArcGIS. Ad esempio non è possibile creare un renderer, un workspace o una feature personalizzati come add-in.

Se la tua soluzione include tipi di componenti che non sono supportati dal framework add-in, dovrai utilizzare l’approccio di estensibilità COM classica.

Inoltre, dal momento che gli add-ins non necessitano di operazioni di registrazione, non utilizzare soluzioni basate su add-ins che si basano su dipendenze esterne tipo librerie, assembly o servizi che richiedono la registrazione od un intervento di un amministratore.

Tipi di Add-in

Le applicazioni ArcGIS desktop supportano un prefissato insieme di tipi di add-in, includendo i più popolari tipi utilizzati nel modello di estensibilità basato su COM introdotto nelle precedenti versioni. I seguenti tipi di add-in sono supportati dalla versione 10:

Button e tool
Combo box
Menu e context menu
Multi-items
Toolbars
Tool palette
Dockable windows
Application extension
Editor extension

Gestione degli add-ins

Gli add-ins possono essere distribuiti in diversi modi: da repository basati su web, e-mail o da file system o rete. Puoi installare un add-in semplicemente facendo un doppio click sul file di add-in da Esplora risorse. Quando si fa il doppio click, ESRI fornisce una Utility di installazione Add-In che valida l’add-in e lo copia nell’appropriata cartella ben definita. All’utente viene data la possibilità di vedere l’autore, la descrizione, la versione e informazioni sulla firma digitale dell’add-in prima di procedere all’installazione. Questa utility assicura che il file sia copiato nella cartella appropriata, gestione dei conflitti di nomi e garanzia che le versioni esistenti dei file add-in non siano sovrascritte da una versione precedente. Inoltre l’utility lavora direttamente con file allegati alle e-mail o da link da pagine web. Qui sotto possiamo vedere come si presenta l’add-in gestito dall’utility dopo il doppio click ma prima dell’installazione:

Per firmare l'Add-in utilizzare l'utility ESRISignAddIn.exe che trovate nella cartella C:\Programmi\File comuni\ArcGIS\bin.

Gli Add-ins possono anche essere installati utilizzando il pulsante Add from file della finestra di dialogo Customize disponibile in tutte le applicazioni ArcGIS Desktop.

E’ possibile accedere alla finestra di dialogo mediante il menu Customize. Gli add-ins installati, utilizzando le opzioni doppio click o ‘Add from file’, sono classificati come add-in locali. Gli add-in locali risiedono in una speciale e ben definita cartella per utente della macchina locale.

Nonostante i file add-in possano essere copiati manualmente nelle cartelle ben definite senza utilizzare l’utility ESRI Add-In, occorre prestare particolare attenzione per evitare conflitti di nomi, sovrascrivere versioni e così via. Questo approccio è tipicamente utilizzato quando si condividono add-in nella rete.

Come i componenti COM classici, tipi di add-in individuali sono accessibili mediante finestra di dialogo Customize. Ad esempio, un button definito in un add-in non si comporta differentemente da un command COM, entrambi sono elencati sotto la loro specifica categoria nella linguetta Commands. Da questa posizione, possono essere trascinati in una toolbar o in un menu.

Le applicazioni ArcGIS Desktop forniscono una finestra di dialogo per la gestione degli Add-In (Add-In Manager). Nella linguetta Add-Ins di questa finestra di dialogo vengono fornite informazioni di dettaglio per ogni add-in correntemente disponibile perché venga eseguito nell’applicazione corrente. Ad esempio, Add-in costruiti per ArcGlobe non appariranno in ArcMap. Ecco come si presenta la linguetta Add-Ins dell’Add-In Manager:

Mentre la linguetta Options lascia all’utente la possibilità di aggiungere cartelle personalizzate per gli add-in.

Il framework add-in in aggiunta cercherà gli add-ins in queste cartelle personalizzate ogni volta che l’applicazione è inizializzata. Questa opzione è particolarmente utile in scenari ove una posizione centralizzata della rete sia utilizzata per condividere add-ins in una organizzazione.

Gli Add-ins possono essere aggiunti, cancellati ed aggiornati in queste posizioni senza fare interventi sulle macchine client. Gli aggiornamenti saranno automaticamente trasmessi sui client quando le applicazioni sono reinizializzate. La linguetta Options può anche essere utilizzata per disabilitare tutte le funzionalità degli add-in.

Ecco come si presenta la linguetta Options:

Dall’Add-In Manager, gli utenti possono anche scegliere di disinstallare un particolare add-in. Disinstallando un add-in, il file add-in selezionato verrà spostato nel Cestino dove così si potrà ripristinare, se necessario, successivamente.

Il pulsante ‘Delete this Add-In’ è soltanto abilitato per add-ins locali. Per disinstallare un add-in da una cartella personalizzata, occorre semplicemente eliminarlo dalla condivisione o eliminare la cartella personalizzata utilizzando il pulsante ‘Remove Folder’ (in quest’ultimo caso non vedrò più tutti gli add-in contenuti in esso).

Anatomia del file Add-in

Un add-in è composto da numerose parti che includono metadati nella forma di file XML che descrive l’add-in stesso così come le sue personalizzazioni, le immagini e altri tipi di dati semplici ad uso delle personalizzazioni e codice compilato. Per mettere insieme tutti questi file relazionati, gli add-ins sono pacchettizzati come archivio compresso con l’estensione del file esriAddIn (ad esempio MyAddIn.esriAddIn).

Gli add-ins utilizzano tecniche di programmazione sia dichiarativa che imperativa. Il file XML accennato sopra è la porzione dichiarativa e descrive tutti gli aspetti statici dell’add-in, includendo caption, tooltips, help, immagini e dettagli del layout iniziale. La porzione imperativa, o attiva, è il classico modello di programmazione basato su istruzioni che può essere, come abbiamo già detto, un linguaggio .NET o Java.

Ad esempio, possiamo cambiare l’etichetta e l’immagine di un button senza ricompilare il codice; alcune personalizzazioni, come toolbars, tool palettes e menu sono completamente dichiarative; non sono porzioni attive.

La distinzione tra aspetti dichiarativi e di programmazione incrementa la flessibilità, riduce e semplifica lo sviluppo per gli sviluppatori, ed in generale rende più facili lo sviluppo e la manutenibilità della soluzione.

Il seguente esempio di XML mostra un add-in dove è dichiarata una toolbar con un button in essa:

<ESRI.Configuration

  xmlns="http://schemas.esri.com/Desktop/AddIns"

  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

  <Name>

    Acme Custom Mapping Extension

  </Name>

  <AddInID>{6fa0df73-57ab-491e-a73d-e58ce07af414}</AddInID>

  <Description>Custom mapping toolbar.</Description>

  <Version>1.0</Version>

  <Image>Images\Acme.png</Image>

  <Author>John Locke</Author>

  <Company>Acme</Company>

  <Date>5/28/2009</Date>

  <Targets>

    <Target name="Desktop" version="10.0"/>

  </Targets>

  <AddIn language="CLR" library="Acme.dll" namespace="Acme">

    <ArcMap>

      <Commands>

        <Button

          id="Acme_ToggleDockWinBtn"

          class="ToggleDockWinBtn"

          caption="OpenDockWin"

          category="Acme Tools"

          image="Images\ToggleDockWinBtn.png"

          tip="Toggle dockable window."

          message="Open dockable window.">

          <Help heading="Toggle">Turns the ACME dockable window on and off.</Help>

        </Button>

      </Commands>

      <Toolbars>

        <Toolbar id="Acme_Toolbar" caption="Acme Toolbar">

          <Items>

            <Button refID="Acme_ToggleDockWinBtn"/>

          </Items>

        </Toolbar>

      </Toolbars>

    </ArcMap>

  </AddIn>

</ESRI.Configuration>

Il seguente esempio di codice mostra la porzione attiva di un button. Tutti gli ArcObjects, così come la ricchezza dell’ambiente di programmazione, sono direttamente disponibili agli sviluppatori.

 public class ToggleDockWndBtn : Button

 {

        public ToggleDockWndBtn() { }

 

        protected override void OnClick()

        {

            //Get dockable window.

            UID dockWinID = new UIDClass();

            dockWinID.Value = @"ESRI_SelectionSample_SelCountDockWin";

            s_dockWindow = ArcMap.DockableWindowManager.GetDockableWindow(dockWinID);

        }

 }

Creare gli add-ins

Gli add-ins sono creati utilizzando un IDE come Visual Studio (incluso l’Express) per .NET e Eclipse per Java e semplici wizard e template sono forniti con l’SDK ArcObjects per generare automaticamente progetti add-in con incluso XML e file di classi.

In aggiunta, quando questi progetti sono creati, essi automaticamente generano un file add-in pronto per essere copiato in cartelle ben definite degli add-in. La maggior parte dell’XML è compilato tramite il wizard; comunque, se necessario, può essere direttamente modificato. Lo schema associato al file XML permette facili modifiche provvedendo all’IntelliSense e alla validazione al volo. Per maggiori dettagli su come creare gli add-in vedere qui.

Come esercizio ho creato un add-in per visualizzare le immagini di Street View di Google cliccando direttamente sulla mappa (dataframe attivo) in ArcMap. Qui potete scaricare la soluzione mentre qui potete vedere il video per come installarlo.

Da notare che in questo add-in è gestita anche la trasformazione di datum a WGS84 (input richiesto da Street View di Google) rispetto al sistema di coordinate che è impostato nel dataframe attivo. Pertanto per dataframe con sistemi di coordinate basati su datum WGS84 non occorre impostare nulla, mentre per sistemi di coordinate non basati su datum WGS84 (esempio Monte Mario) occorre impostare nel dataframe (linguetta Coordinate System - pulsante ‘Transformations…’) la trasformazione da utilizzare per passare a WGS84: l’add-in utilizzerà quella indicata in Transformations nelle proprietà del datafame.

Se il dataframe non ha impostato il sistema di coordinate, le coordinate della mappa verranno considerate come coordinate geografiche WGS84 (scelta fatta per evitare messaggi all’utente) .

Token: se lo conosci non lo eviti

2011-06-30T11:00:00.749+02:00

Parliamo delle connessioni internet e delle applicazioni web: si ricorda che, dalla versione 10.1, ArcGIS Server sarà un erogatore di servizi GIS (solo a 64bit) esclusivamente su protocollo http e le connessioni locali non saranno più possibili.
ArcGIS Server ti consente di abilitare la sicurezza per le tue applicazione web e i tuoi servizi web. Naturalmente, oltre a queste, possiamo applicare la sicurezza al nostro sistema ArcGIS Server con utenti utilizzati da ArcGIS Server per accedere ai dati, sicurezza con codice eseguito direttamente sul server e sicurezza mediante dispositivi hardware.
Per gestire la sicurezza per i servizi web e le applicazioni web i passi da seguire sono:

definire la gestione degli utenti e dei ruoli
scegliere un metodo di autenticazione
implementare Secure Sockets Layer (SSL)
impostare i permessi per i servizi e le applicazioni

La componente fondamentale di qualsiasi meccanismo di controllo degli accessi è la capacità di autenticare gli utenti. Tutti i meccanismi di autenticazione richiedono che le informazioni degli utenti e dei ruoli ai quali fanno riferimento risiedano centralmente da qualche parte del sistema. Le applicazioni ASP.NET consentono che queste informazioni siano memorizzzate e gestite o dal sistema operativo o da un provider membership ASP.NET. ArcGIS Server utilizza queste due opzioni fornite da ASP.NET.

La decisione di optare per una piuttosto che per l'altra dipende da contesto di utilizzo. Se, ad esempio, sviluppiamo applicazioni su una intranet, sicuramente vorremo utilizzare già gli utenti/ruoli definiti nel sistema operativo per garantire l'accesso alle applicazioni. Se stiamo sviluppando applicazioni su internet, invece, non vogliamo che gli utenti web siano utenti nella nostra active directory; in questo caso memorizziamo questi utenti nel provider membership ASP.NET.

ArcGIS Server consente di configurare facilmente il Membership provider di ASP.NET per SQL Server di Microsoft utilizzando ArcGIS Server Manager. Inoltre, essendo molto flessibile, il provider può essere personalizzato per poterlo utilizzare anche con altre fonti dati come altri database, file xml, ldap ecc. Qui potete vedere come implementare un provider personalizzato.

Quindi riepilogando abbiamo:

utenti e ruoli definiti a livello di sistema operativo
membership provider di ASP.NET
- Microsoft SQL Server (configurabile utilizzando ArcGIS Server Manager)
- Personalizzato (configurato dall'amministratore/sviluppatore e poi integrato in ArcGIS Server Manager)

L'autenticazione è il processo tramite il quale il sistema verifica l'identità dell'utente che intende accedere al sistema mediante user e password. Il metodo di autenticazione determina come il server valida l'identità dell'utente.

Per informazioni memorizzate a livello di sistema operativo l'autenticazione avviene con metodo IIS mentre, utilizzando il Membership Provider ASP.NET, l'autenticazione avviene con metodo ASP.NET.

I metodi di autenticazione variano anche in termini di livello di sicurezza fornita.
I metodi di autenticazione disponibili con ArcGIS server per Micorosoft .NET framework sono:

Autenticazione IIS:

Autenticazione integrata Windows (utilizzata generamente su intranet; utilizza solo utenti definiti a livello di sistema operativo e, quando si utilizza IE sulla rete locale, l'identità è passata in modo trasparente senza prompt di login. Stesso discorso per i client ARCGIS. Questo consente di connettersi ed utilizzare i servizi senza un esplicito accesso con login);
HTTP Basic e Digest (utilizzata su intranet e internet; utilizza solo utenti definiti a livello di sistema operativo, su browser si ha pop-up di login)

Autenticazione ASP.NET:

autenticazione basata su Forms (utilizzata per applicazioni web quando le informazioni utente sono memorizzate in un membership provider, su browser avremo una form di login su una pagina web)
autenticazione basata su token (implementata da ArcGIS Server, utilizzata solo per servizi web e non per le applicazioni, il client ottiene un token dal server passando user e password e poi il token è utilizzato per accedere al servizio, lavora con utenti memorizzati)

Importante: per poter supportare più metodi di autenticazione occorre creare istanze multiple di ArcGIS server. Ogni istanza di ArcGIS Server dovrebbe essere legata allo stesso GIS Server ma dovrebbe essere configurata con metodi differenti di autenticazione. Il classico caso è l'utilizzo degli utenti windows su una rete locale e quello degli utenti SQL Server per utenti esterni su internet. In questo caso occorre avere due istanze di ArcGIS Server. Per maggiori dettagli su come implementare più metodi di autenticazione vedete Multiple ArcGIS Server Web instances for security.

In base alle esigenze di memorizzazione delle informazioni dell'utente e del metodo di autenticazione, potresti avere la necessità di acquistare un certificato SSL per il tuo web server. SSL abilita l'utilizzo dell'HTTPS che cripta la comunicazione tra i client e il tuo web server. L'HTTPS è il risultato dell'applicazione di un protocollo di crittografia (SSL o TLS) al protocollo di trasferimento HTTP. Chiaramente, quando gli utenti si autenticano con i metodi di autenticazione HTTP basic, basato su token o basato su forms, SSL può aumentare la sicurezza delle credenziali perchè il passaggio delle informazioni avviene in modo criptato, aumentando il livello di sicurezza di attacchi del tipo man in the middle. Proprio MITM è utilizzato ad esempio da fiddler per decifrare il traffico HTTPS: in sostanza fiddler fa da proxy tra il browser ed il server web. Fiddler comunica con il server web mediante il certificato valido mentre con il browser comunica emettendo un suo certificato per poter decifrare il traffico. Ovviamente il browser ti avverte che il certificato di fiddler non è valido ma accettandolo possiamo eseguire la nostra analisi di traffico su https. Per non ricevere più warning possiamo installare il certificato di fiddler nel browser (raccomandato solo su macchine di test). Per maggiori dettagli sui certificati digitali seguite il link.

Per gli utenti che accedono ai servizi o alle applicazioni, devi aggiungere permessi nei servizi o nelle applicazioni per un ruolo nel quale l'utente è membro. I permessi di ArcGIS Server sono basati su ruoli. Pertanto, per aggiungere permessi per un servizio, per una cartella servizio o per l'applicazione nel manager occorre usare i ruoli piuttosto che i permessi dei singoli utenti.

Quando si applica la sicurezza ad un servizio, essa è applicata a tutte le forme di quel servizio: SOAP, REST e OGC (come ad esempio il WMS). Consentendo l'accesso ad esempio al ruolo Tecnici ad un servizio da manager, fai sì che gli utenti appartenenti a quel ruolo siano abilitati ad accedere attraverso i metodi SOAP, REST e OGC abilitati per il servizio. Analogamente, la services directory rispetta le impostazioni di sicurezza così, una volta che l'utente si è autenticato, potrà vedere solo i servizi per i quali ha l'accesso.

Vediamo ora più nel dettaglio l'autenticazione con il servizio di token fornito da ArcGIS Server. Come abbiamo visto, con l'autenticazione basata su token si utilizza l'autenticazione ASP.NET (SQL Server o un altro provider personalizzato per la memorizzazione di utenti e ruoli).
Un token si attua come una chiave di accesso ai servizi protetti ed è esclusivamente fornito agli utenti autenticati. Il token è una stringa che cripta delle informazioni che contengono nome dell'utente, periodo di scadenza ed altre informazioni. Il token è fornito all'utente autenticato attraverso i servizi web disponibili in -Istanza ArcGI Server-/Tokens.

Il token fornisce un certo livello di sicurezza per i tuoi servizi gis ma non è certamente più sicuro di altri metodi come un'autenticazione integrata windows. La protezione del tuo sistema con i token dipende dal controllo di accesso ai token. Questo in pratica si traduce nel fatto di far circolare le informazioni su un canale protetto, come precedentemente accennato, utilizzando l'HTTPS. Inoltre è possibile richiedere che tutte le richieste, oltre a quella richiesta per il token, circolino su canale protetto. In questo caso, tramite Manager o ArcCatalog, è possibile impostare Require Encryped Web Access nelle proprietà del folder dei servizi indicati.

Il servizio di token è un servizio web che è installato con la componente ARCGIS Web application durante l'installazione di ArcGIS server. Nella versione 10, il servizio di token è automaticamente abilitato quando necessario. E' abilitato se gli utenti sono memorizzati in un Membership provider. Non è abilitato o utilizzato quando specifichi utenti windows per l'autenticazione dei servizi GIS a meno che utilizzi Membership Provider per i ruoli e abiliti i token per l'autenticazione utente.

Quando il servizio di token è abilitato, puoi impostare un valore massimo consentito di time-out per i token, ovverosia il periodo di tempo oltre il quale il token non è più valido.
E' possibile anche impostare la chiave (Shared key) per criptare il token. Questa chiave è utilizzata per decriptare il token che arriva dal client e verifica l'identita del client. Questa chiave serve per verificare che il server abbia creato il token. Il token è criptato con una chiave utilizzando il metodo di criptazione AES. I 16 caratteri impostati (gli altri non vengono utilizzati) rappresentano i 128 bit utilizzati per la criptazione.

Quando i token sono richiesti per i servizi GIS, i client seguono il seguente approccio:

Il client fa una richiesta al servizio GIS
il server GIS risponde che un token è richiesto e fornisce l'url del servizio di token
il client richiede il token dal servizio di token fornendo user e password
il servizio di token valida la user e password con il Membership provider impostato e, se valido, restituisce un token al client
il client fa le richieste al servizio GIS ed include il token con la richiesta
il server GIS valida il token ed invia la risposta per il servizio richiesto dal client

Per consentire l'utilizzo dei servizi GIS senza fornire un token o una login occorre assegnare al servizio il ruolo di Everyone.

Quando il servizio token è abilitato e richiesto per accedere ai servizi, il client deve essere in grado di ottenere ed usare il token come visto nei passi descritti precedentemente. I client ESRI ottengono ed utilizzano il token automaticamente.

Per ArcGIS Desktop, ArcGIS Explorer e le applicazioni Web ADF, l'utente inserisce la user e la password nella finestra di dialogo della connessione per accedere al servizio. L'applicazione automaticamente si prende cura di comunicare con il servizio di token ed acquisire un valido token.

Le applicazioni basate su SOAP necessitano di acquisire ed utilizzare esplicitamente i token, verificandone la validità di volta in volta.

Le applicazioni basate su REST (javascript, Silverlight/WPF e Flex, SharePoint), poichè sono applicazioni che vengono eseguite lato client, possono essere analizzate da chiuque e pertanto non è opportuno memorizzare la user e la password per accedere al servizio nell'applicazione. Pertanto un token può essere ottenuto dal servizio di token. Il token poi è incluso nella richiesta al servizio.

Occorre ricordare che non vanno confuse le credenziali di accesso all'applicazione con quelle di accesso al token. L'applicazione utilizza il token poichè sono state memorizzate in essa la user e la password di un ruolo autorizzato ad utilizzare il/i servizio/i. L'applicazione inoltre può essere protetta mediante login basata su utenti che possono anche non avere diretto accesso ai servizi. Quando si utilizza l'autenticazione IIS (utenti memorizzati in Windows) le credenziali di accesso sono passata automaticamente dall'applicazione ai servizi GIS.

Nelle impostazioni di protezione nel Manager, possiamo impostare il time-out dei token. Come abbiamo accennato, il time-out del token è il periodo di tempo che il token rimane valido. Una volta che non è più valido, se viene utilizzato ugualmente, verrà visualizzato un errore.
Possiamo avere due tipi di scadenza di valida per il token:
Token a breve durata: forniscono una maggiore protezione poichè limitano l'utilizzo non autorizzato. Se ad esempio un hacker tiene monitorato la comunicazione tra l'utente ed il server, potrebbe visualizzare il token ed utilizzarlo però, se il tempo di validità è basso, l'utilizzo sarà limitato. Lo svantaggio dei token a breve durata è che lo sviluppatore dovrà richiedere un nuovo token prima che il token perda validità.
Token a lunga durata: questo time-out normalmente è utilizzato dalle applicazioni basate su REST. La validità del token è più duratura rispetto ai token di breve durata. Per ottenere un token di lunga durata, il client deve includere nella richiesta al servizio di token un client ID e un tempo di validità. Il client ID può essere o l'IP del client o il Referrer URL Web (cioè l'url dell'applicazione web che si sta utilizzando). Se non si specifica il periodo di validità, il token verrà considerato di breve durata.

Come si accennava precedentemente, un modo per minimizzare l'uso non autorizzato dei token è richiedere l'utilizzo dell'HTTPS (SSL) per tutte le comunicazioni con i servizi GIS.

Si pensi ad esempio ad un servizio GIS abilitato all'editing (Feature Service): se non fosse protetto, potrebbe essere utilizzato da chiunque per modificare i dati.

Per richiedere il token al server, occorre fare una richiesta URL.

La richiesta per farsi restituire il token dal server è la seguente:

https://myserver.example.com/arcgis/tokens?request=gettoken&username=myuser&password=secret1&clientid=ref.myserver.example.com&expiration=1440&f=json&callback=myfunction

request: il valore di questo parametro è gettoken (obbligatorio)
username: la username di un utente abilitato all'accesso di uno o più servizi (obbligatorio)
password: la password dell'utente (obbligatorio)
clientid: è un parametro opzionale. Si utilizza un "." per dividere il tipo dal valore passato

ip: indirizzo ip del client. Esempio clientid=ip.10.14.100.38
ref: la base dell'url dell'applicazione. Esempio clientid=ref.http://myserver/myApp
requestip: il token è generato per l'IP da dove la richiesta ha avuto origine. Esempio clientid=requestip

expiration: facoltativo. Specifica la durata di validita del token. Se non specificato, il token verrà considerato con impostazione di breve durata.
f: restituisce il risultato in formato json. Facoltativo ed aggiunto a partire dalla 10sp1
callback: facoltativo. Specifica la funzione di callback da utilizzare per farsi restituire il risultato. Se specificata, il formato di restituizione è sempre in json.

Dalla 10 sp1 è possibile utilizzare anche la seguente richiesta:

https://myserver.example.com/arcgis/tokens/generateToken?username=myuser&password=mypass&client=referer|ip|requestip&referer=referer&ip=ipaddress&expiration=expiration&f=json&callback=myfunction

Il servizio di token di default è impostato su connessione che utilizza https. Sebbene non consigliato è possibile, in fase di test, disabilitare l'https. Questo normalmente accade quando si è in fase di test con web server basato su file (Cassini in Visual Studio) che non supportano l'uso di https/ssl.

Per disabilitare l'https occorre aprire il web.config dell'applicazione di Tokens (-Web server root-\ArcGIS\Tokens\web.config) con notepad e andare nella sezione di appSettings

<appSettings>
<add key="RequireSSL" value="True" />
<add key="TokenServiceURL" value="https://myserver/..." />
<appSettings>

Impostare il parametro RequireSSL a false e cambia da https a http l'url in TokenServiceURL.
Per rendere il servizio di token accessibile su internet, occorre modificare i tre web.config in rest, services e token della tua istanza arcgis server. Occorre aprirli con notepad e cambiare l'url nel parametro TokenServiceURL al nome del dominio in sostituzione di quello della macchina.

Negli help dei web client ESRI potete vedere nel dettaglio come utilizzare i token:
javascript
silverlight
flex

Se le applicazioni sono protette con autenticazione basata su token, è possibile utilizzare una pagina di proxy che gestisce la comunicazione tra i servizi ArcGIS Server e la nostra applicazione. Questo permette di non trasmettere il token dal client. La pagina di proxy (codice server-side) riceve la richiesta dal client e la gira ai servizi gis utilizzando il token memorizzato in essa.
Qui potete scaricare e configurare la pagina proxy:
ASP.NET
Java/JSP
PHP

In questo link potete scaricare una versione modificata del proxy page ESRI per poter far chiamate dalla pagina di proxy e richiedere il token senza memorizzarlo nel file di configurazione.
proxyConTokenDinamico

In pratica, ho aggiunto la richiesta di token come visto precedentemente

https://myserver.example.com/arcgis/tokens?request=gettoken&username=myuser&password=secret1&clientid=ref.myserver.example.com&expiration=1440&f=json&callback=myfunction

public string GetToken(string uri)
        {
            foreach (ServerUrl su in serverUrls)
            {
                if (su.MatchAll && uri.StartsWith(su.Url, StringComparison.InvariantCultureIgnoreCase) && su.DynamicToken)
                {
                    // Code to dynamically get the token
                    string tokenService = string.Format("https://{0}/arcgis/tokens?request=getToken&username={1}&password={2}&expiration=30", su.Host, su.UserName, su.Password);
                    string token;
 
 
                    // This script is added to force the application to certify the SSL script (if for example you have a self certificate on server)
                    System.Net.ServicePointManager.ServerCertificateValidationCallback += delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate, System.Security.Cryptography.X509Certificates.X509Chain chain, System.Net.Security.SslPolicyErrors sslPolicyErrors)
                    {
                        return true;
                    };
 
 
 
                    System.Net.WebRequest tokenRequest = System.Net.WebRequest.Create(tokenService);
                    System.Net.WebResponse tokenResponse = tokenRequest.GetResponse();
                    System.IO.Stream responseStream = tokenResponse.GetResponseStream();
                    System.IO.StreamReader readStream = new System.IO.StreamReader(responseStream);
                    token = readStream.ReadToEnd();
 
                    return token;
                }
                else if (su.MatchAll && uri.StartsWith(su.Url, StringComparison.InvariantCultureIgnoreCase))
                {
                    return su.Token;
                }
                else
                {
                    if (String.Compare(uri, su.Url, StringComparison.InvariantCultureIgnoreCase) == 0)
                        return su.Token;
                }
            }
 
            if (mustMatch)
                throw new InvalidOperationException();
 
            return string.Empty;
        }

Per fare i propri controlli sul certificato ssl, è possibile utilizzare ServerCertificateValidationCallback, ad esempio per forzare la validità, come nel caso qui sopra, se ci troviamo con un certificato non scaduto ma non rilasciato da un ente riconosciuto (caso di autocertificati)

// This script is added to force the application to certify the SSL script (if for example you have a self certificate on server)
System.Net.ServicePointManager.ServerCertificateValidationCallback += delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate, System.Security.Cryptography.X509Certificates.X509Chain chain, System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
      return true;
};

Via SOAP possiamo utilizzare RequiresTokens del servizio Catalog:

Catalog myCatalog = new Catalog();
 
            myCatalog.Url = "http://localhost/arcgis/services";
            string myToken = null;
            if (myCatalog.RequiresTokens())
            {
 
                string tokenServiceUrl = myCatalog.GetTokenServiceURL();
 
                string url = tokenServiceUrl + "?request=getToken&username=myuser&password=secret";
 
                System.Net.WebRequest request = System.Net.WebRequest.Create(url);
 
                System.Net.WebResponse response = request.GetResponse();
 
                System.IO.Stream responseStream = response.GetResponseStream();
 
                System.IO.StreamReader readStream = new System.IO.StreamReader(responseStream);
 
                myToken = readStream.ReadToEnd();
 
            }
 
            MapService_MapServer mapservice = new MapService_MapServer();
 
            mapservice.Url = string.Format("http://localhost/arcgis/services/MapService/MapServer{0}",string.IsNullOrEmpty(myToken)?string.Empty, "?token=" + myToken);

Se il token è scaduto o invalido (codice 498) o richiesto (codice 499) nella gestiore errori si richiede un nuovo token:

try {
 
    mapimg = mapservice.ExportMapImage(mapdesc, imgdesc);
 
}
 
catch (System.Net.WebException webExc) {
 
    System.Net.HttpWebResponse webResp = webExc.Response as System.Net.HttpWebResponse;
 
    if (webResp != null) {
 
        int statusCode = (int)webResp.StatusCode;
 
        if (statusCode == 498 || statusCode == 499) {
 
            // call a method (not shown here) that obtains a new token
 
            string newToken = getToken();
 
        
 
            mapservice.Url = "http://MyWebServer/arcgis/services/MapService/MapServer?token=" + newToken;
 
            mapimg = mapservice.ExportMapImage(mapdesc, imgdesc);
 
        }
 
    }
 
}

Arcpy per tutti

2011-05-31T16:24:00.004+02:00

Arcpy, introdotto con la versione 10, è un site-package ovverosia un termine Python per indicare una libreria che aggiunge funzioni aggiuntive a Python.

Un modulo è un file di Python che normalmente include diverse funzioni e classi. Arcpy è supportato da diversi moduli tra i quali un modulo per il mapping (arcpy.mapping), uno per l'analisi spaziale (arcpy.sa) ed un altro per l'analisi geostatistica (arcpy.ga).

Qui potete trovare l'elenco delle classi e delle funzioni in arcpy.

ArcPy fornisce l'accesso agli strumenti di geoprocessing così come alle funzioni, classi e moduli che consentono di creare semplici e complessi flussi di lavoro velocemente e facilmente.

ArcPy sfrutta l'accesso a numerosi moduli di Python sviluppati da professionisti e programmatori GIS di differenti discipline. Inoltre il vantaggio di utilizzare ArcPy con Python è che quest'ultimo è un linguaggio di programmazione general purpose, facile da imparare ed utilizzare. Esso è interpretato anche se, al dir il vero, il compilatore Python trasforma il codice sorgente in un codice intermedio (bytecode), una sorta di "codice-macchina" per una macchina virtuale ottimizzata apposta per eseguire programmi Python; l'interprete Python vero e proprio é una implementazione in software di questa macchina virtuale: pertanto, se tecnicamente è un linguaggio interpretato, questo risulta molto veloce. Inoltre Python è a tipizzazione dinamica, che fornisce agevolmente la possibilità di creare prototipi velocemente e script di test in un ambiente interattivo, mentre è ancora abbastanza potente da supportare la creazione di applicazioni complesse .

ArcPy è organizzato in strumenti, funzioni, classi, e moduli.

Tecnicamente parlando, gli strumenti di geoprocessing sono funzioni disponibili da arcpy, e pertanto sono accessibili come le altre funzioni di Python. Occorre però, per evitare di fare confusione, fare una distinzione tra gli strumenti e le funzioni non-strumenti (come, ad esempio, una funzione di utility: ListFeatureClasses()).

Gli strumenti sono documentati in modo differente dalle funzioni. Ogni strumento ha la sua propria pagina di riferimento nell' help di sistema di ArcGIS Desktop. Le funzioni sono documentate nella documentazione di ArcPy.
Gli strumenti restituiscono un risultato object; le funzioni no.
Gli strumenti generano messaggi, accessibili attraverso diverse funzioni tipo GetMessages(). Le funzioni non generano messaggi.
Gli strumenti sono licenziati per livello di prodotto (ArcView, ArcEditor, e ArcInfo) e per livello di estensione (Network Analyst, Spatial Analyst, e così via). E' possibile trovare quale livello di licenza è richiesto nella pagina di riferimento degli strumenti. Le funzioni non sono licenziate ma installate con ArcPy.

Ma dove scriviamo il nostro codice Python?
In ArcGIS abbiamo la Python Window dove possiamo esercitarci ed eseguire le nostre istruzioni. Oppure possiamo utilizzare un IDE come ad esempio PythonWin (che potete trovare nel dvd di installazione e che non viene installato automaticamente da ArcGIS).
Tra gli IDE commerciali quello che vi consiglio è Wing IDE mentre tra quelli freeware PyScripter

In questo link potete scaricare un pdf e una serie di esercizi per imparare ad utilizzare Python in ArcGIS.

Per gli sviluppatori ArcGIS Server: in questo link potete vedere degli esempi di utilizzo di arcpy con servizi di geoprocessing. In questo caso possiamo utilizzare una più semplice e rapida alternativa alla creazione di SOE per ArcGIS Server.

Vediamo un semplice esempio di codice arcpy richiamato da c#. In questo caso creiamo un tool che verifica se un mxd è adatto ad essere publicato in ArcGIS Server

Creiamo una toolbox in ArcMap

Aggiungiamo lo script python che utilizza arcpy

Indichiamo nome e label al tool. Selezioniamo la voce 'Store relative path names' che ci permette di poter spostare la nostra toolbox senza avere problemi di percorsi.

In questo caso abbiamo un solo parametro, richiesto e di input. E' il map document da analizzare. Come data type possiamo indicare ArcMap Document così, se dovessimo utilizzarlo come tool direttamente in ArcGIS in automatico, avremmo un button che sfoglia file di tipo map document automaticamente.

In questa sezione è possibile scrivere codice python per poter fare validazioni sui controlli creati automaticamente nella maschera da ArcGIS quando si crea un tool.

Qui potete vedere l'help a riguardo.

Testiamo il tool in ArcMap

In questo caso abbiamo selezionato un documento di mappa con un layer non supportato per la pubblicazione. Vediamo il messaggio: Layer type is not supported Layer: streets

Questo è il nostro script python che utilizza il tool.

e questo è un esempio di come chiamare il tool in c#

namespace Studioat.Samples
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using ESRI.ArcGIS.esriSystem;
    using ESRI.ArcGIS.Geodatabase;
    using ESRI.ArcGIS.Geoprocessing;
    using ESRI.ArcGIS.Geoprocessor;
 
    class Program
    {
        private static LicenseInitializer m_AOLicenseInitializer = new LicenseInitializer();
    
        [STAThread()]
        static void Main(string[] args)
        {
            //ESRI License Initializer generated code.
            m_AOLicenseInitializer.InitializeApplication(new esriLicenseProductCode[] { esriLicenseProductCode.esriLicenseProductCodeArcEditor },
            new esriLicenseExtensionCode[] { });
 
 
            Geoprocessor gp = new Geoprocessor();
            gp.AddToolbox(@"J:\ArcpyTest\Tools\ToolAGS.tbx");
            IVariantArray parameters = new VarArrayClass();
            parameters.Add(@"J:\ArcpyTest\Test.mxd");
            string messageAnalyzeMSD;
            ExecuteTask(gp, parameters, "AnalyzeMSD", out messageAnalyzeMSD);
            m_AOLicenseInitializer.ShutdownApplication();
        }
 
        /// <summary>
        /// esecuzione task
        /// </summary>
        /// <param name="gp">oggetto geoprocessor</param>
        /// <param name="parameters">lista parametri</param>
        /// <param name="nameTask">nome task</param>
        /// <param name="message">eventuale messagio se il task fallisce</param>
        /// <returns>restituisce true se il task ha generato errori</returns>
        public static bool ExecuteTask(Geoprocessor gp, IVariantArray parameters, string nameTask, out string message)
        {
            bool result = false;
            message = null;
            try
            {
                IGeoProcessorResult2 geoProcessorResult2 = gp.Execute(nameTask, parameters, null) as IGeoProcessorResult2;
                IGPMessages msgs = geoProcessorResult2.GetResultMessages();
                IList<string> messageErrors = new List<string>();
                for (int i = 0; i < msgs.Count; i++)
                {
                    if ((msgs.GetMessage(i).IsInformational()) && (msgs.GetMessage(i).Description.StartsWith("Errore: ")))
                    {
                        messageErrors.Add(msgs.GetMessage(i).Description);
                    }
                }
 
                if (messageErrors.Count > 0)
                {
                    string errors = string.Join(Environment.NewLine, messageErrors.ToArray());
                    message = errors;
                    return result;
                }
 
                return true;
            }
            catch
            {
                message = string.Format("Operazione annullata: errore nell'esecuzione del task '{0}'!", nameTask);
                return result;
            }
        }
    }
}

LINQPad: Linq ma non solo ...

2011-04-30T21:14:00.226+02:00

LINQPad, per chi non lo conosce, è un utilissimo programma che permette di interrogare interattivamente i database mediante LINQ.

LINQPad supporta c# 4.0 ed il framework 4.0:
• LINQ to Objects
• LINQ to SQL e Entity Framework
• LINQ to XML
• Parallel LINQ

E' possibile inoltre interrogare
• OData / WCF Data Services
• SQL Azure, SQLite and MySQL Enterprise Server
• Microsoft StreamInsight
• Microsoft Dynamics CRM
• Mindscape LightSpeed ORM
• Persino il 'vecchio' SQL

LINQPad è fornito anche di moltissimi esempi per imparare LINQ.

Inoltre permette di eseguire istantaneamente espressioni, blocchi di codice o programmi con formattazione dell'output. Questo ti consente di evitare di crearti numerosi progetti di console application per testare le tue espressioni.

LINQPad è free e può anche essere eseguito senza essere installato. La funzione di autocompletamento è invece a pagamento, ma ad un costo molto contenuto.

Innanzitutto, l'interfaccia utente è il client che può interfacciarsi a più server. Per ogni query LINQPad crea un separato server; questa classe è eseguita in un suo proprio dominio di applicazione ed esegue la query in isolamento. Tale isolamento evita che interferisca con altre query e con la UI e consente a LINQPad di assicurare un annullamento della query (mediante un abort del thread) senza influenzare altri domini di applicazione.

LINPad compila le query utilizzando NET's CSharpCodeProvider o VBCodeProvider (in funzione del linguaggio che si utilizza).
Poichè c# e vb sono tipizzati staticamente, oggetti del database ai quali facciamo riferimento, necessitano di DataContext tipizzati. LINQPad, per un discorso di prestazioni, crea dataContext tipizzati al volo utilizzando Reflection.Emit piuttosto che generare e compilare il codice. E' usato LINQ to SQL rispetto a EF perchè il primo è di un ordine di grandezza nella creazione del metamodello quando è istanziato.

Vediamo qualche esempio:

dopo aver effettuato la connessione al nostro database, possiamo fare la nostra interrogazione e vedere immediatamente i risultati.

vedere la relativa forma lambda

vedere la relativa forma SQL

e l'IL

In questo caso vediamo un esempio di LINQ to Objects:

Qui vediamo un esempio utilizzando IronPython. Occorrerà far riferimento preventivamente agli assembly opportuni. Cliccando il tasto F4 si potranno aggiungere gli assembly e i namespace da utilizzare

Vediamo un esempio utilizzando la nuova classe ExpandoObject del framework 4.0

Ma LINQPad mette anche a disposizione alcune sue funzioni per, ad esempio, visualizzare immagini, visualizzare un testo html ecc.
In questo caso vediamo una chiamata alle api chart di google:
http://chart.apis.google.com/chart?cht=p3&chd=s:Uf9a&chs=350x140&chl=January|February|March|April"

Vediamo ora una interrogazione OData / WCF Data Services utilizzando stackoverflow. Nel caso di stackoverflow la chiamata è del tipo è http://data.stackexchange.com/%3Ccommunity%3E/atom
Clicchiamo su add connection

Infine vediamo l'utilizzo di una libreria ESRI. nel caso specifico la ESRI.ArcGIS.SOESupport.dll:

Qui potete vedere come interrogare twitter

Con la versione beta corrente di LinqPad è possibile aggiungere i propri visualizzatori personalizzati.
Per maggiori dettagli vedete qui.

Qui vediamo un semplice esempio che ho realizzato:

using System;
using System.Globalization;
using System.Text;
using LINQPad;
 
namespace StudioAT.LinqPad
{
    public class Point
    {
        private double x;
        private double y;
        
        private Point()
        {
 
        }
        public Point(double x, double y)
        {
            this.x = x;
            this.y = y;
        }
 
        public double X
        {
           get 
           {
              return this.x;
           }
        }
 
        public double Y
        {
            get
            {
                return this.y;
            }
        }
    }
 
    public static class Extensions
    {
        /// <summary>
        /// Map Mode of Map Control (Microsoft)
        /// </summary>
        public enum MapMode
        {
            /// <summary>
            /// map mode road
            /// </summary>
            Road,
 
            /// <summary>
            /// map mode aerial
            /// </summary>
            Aerial,
 
            /// <summary>
            /// map mode aerial with labels
            /// </summary>
            AerialWithLabels,
 
            /// <summary>
            /// Bird's eye
            /// </summary>
            Birdseye,
 
            /// <summary>
            /// Bird's eye with labels
            /// </summary>
            BirdseyeWithLabels
        }
 
        public static void DisplayBirdsEye(this Point point)
        {
            
            string url = string.Format("http://dev.virtualearth.net/embeddedMap/v1/ajax/{0}?", Enum.GetName(typeof(MapMode), MapMode.BirdseyeWithLabels));
            string pointXY = string.Format("{1}_{0}", point.X.ToString(Helper.CultureInfoUS), point.Y.ToString(Helper.CultureInfoUS));
            string currentCulture = CultureInfo.CurrentUICulture.Name;
            Helper.GetCultureMapControl(ref currentCulture);
 
            UriBuilder uriBuilder = new UriBuilder(new Uri(url));
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("zoomLevel={0}", 10);
            sb.Append('&');
            sb.AppendFormat("center={0}", pointXY);
            sb.Append('&');
            sb.AppendFormat("pushpins={0}", pointXY);
            sb.Append('&');
            ////The heading is represented in geometric degrees with 0 or 360 = North, 90 = East, 180 = South, and 270 = West.
            ////sb.AppendFormat("heading={0}", 0);
            ////sb.Append('&');
            sb.AppendFormat("culture={0}", currentCulture);
            uriBuilder.Query = sb.ToString();
 
            System.Windows.Forms.WebBrowser wb = new System.Windows.Forms.WebBrowser() { ScriptErrorsSuppressed = true };
            wb.Navigate(uriBuilder.Uri.ToString());
            PanelManager.DisplayControl(wb, "Bird's eye");
        }
 
        public static void DisplayStreetView(this Point point)
        {
            System.Windows.Forms.WebBrowser wb = new System.Windows.Forms.WebBrowser() { ScriptErrorsSuppressed = true };
            UriBuilder uriBuilder = new UriBuilder(new Uri("http://samples.sistemigis.it/StreetViewArcMap/panoAvailable.html"));
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("lat={0}", point.Y.ToString(Helper.CultureInfoUS));
            sb.Append('&');
            sb.AppendFormat("long={0}", point.X.ToString(Helper.CultureInfoUS));
            sb.Append('&');
            sb.AppendFormat("width={0}", 600);
            sb.Append('&');
            sb.AppendFormat("height={0}", 400);
            uriBuilder.Query = sb.ToString();
            wb.Navigate(uriBuilder.Uri.ToString());
            PanelManager.DisplayControl(wb, "Street View");
        }
 
    }
 
    /// <summary>
    /// class of helper
    /// </summary>
    public static class Helper
    {
        /// <summary>
        /// culture for lat-long
        /// </summary>
        public static readonly CultureInfo CultureInfoUS = new CultureInfo("en-US");
 
        /// <summary>
        /// culture supported from Map Control (Microsoft)
        /// </summary>
        private static readonly string[] culturesMapControl = new string[] { "nl-BE", "en-CA", "en-IN", "en-GB", "en-US", "fr-CA", "fr-FR", "de-DE", "it-IT", "ja-JP", "es-MX", "es-ES", "es-US" };
 
        /// <summary>
        /// set culture for map control (microsoft)
        /// if current culture isn't supported it's changed with default culture of map control 
        /// </summary>
        /// <param name="currentCulture">current culture</param>
        public static void GetCultureMapControl(ref string currentCulture)
        {
            int pos = Array.BinarySearch<string>(culturesMapControl, currentCulture);
            if (pos < 0)
            {
                currentCulture = CultureInfoUS.Name;
            }
        }
    }
}

Una volta eseguiti i due extension method, è possibile utilizzare i visualizer personalizzati, nel nostro caso Bird's eye e Street View.

Occorre creare un progetto di tipo Class Library ed aggiungere nei riferimenti l'exe di LinqPad evitando di fare un'inutile copia dell'exe durante la compilazione (Copy Local = false)

Per avere pronto il plugin all'uso è possibile impostare come percorso di compilazione la cartella dei plugin di LinqPad.

Per creare e/o impostare questa cartella in LinqPad selezionare la voce Preferences dal menu Edit (tab Folders)

Tutte le dll e gli exe in questa cartella vengono automaticamente riferiti in LinqPad.

SOE (Server Object Extension) Rest

2011-03-01T17:57:01.406+01:00

SOE consente di estendere le funzionalità base di ArcGIS Server. Le funzionalità sono sviluppate prevalentemente utilizzando gli ArcObjects, che sono i mattoncini con i quali è costruito ArcGIS e che consentono la massima flessibilità nello sviluppo di funzionalità.
Poichè lo sviluppo di una SOE richiede conoscenze di sviluppo relative a diversi ambienti, è importante valutare bene se è necessario svilupparla o trovare alternative ai propri scopi. Normalmente la si sviluppa quando non sono presenti funzionalità out-of-box esposte da ArcGIS Server o dal geoprocessing (funzionalità ad esempio di segmentazione dinamica o tracing su geometry network).
La SOE estende un tipo di servizio. Per ora SOE esposta via REST è solo disponibile con servizi di tipo MapServer.
Considerando poi che la 10.1 permetterà solo la pubblicazione di msd (Servizi di mappa ottimizzati) è importante sviluppare SOE Rest che supportino gli msd. Questo può creare qualche problema nell'utilizzo diretto dei fine-grained arcobjects dalla libreria Carto, ma è comunque possibile utilizzare nuove interfacce che abilitano il MapServer ad utilizzare gli object.
Per lo sviluppo occorre conoscere gli ArcObjects, .NET o Java e tecnologie di comunicazione web service come REST o SOAP. Inoltre, se occorre gestire delle proprietà della SOE, è possibile sviluppare in ArcCatalog nella pagina delle capabilites del servizio una windows form.
Per completezza è possibile esporre la SOE anche via SOAP.
Come abbiamo già detto, occorre valutare bene se sviluppare una SOE o se ad esempio creare un modello con il Model Builder e concatenare i singoli tool che ci interessano per eseguire i nostri task. Questi tool potranno essere personalizzati con Python (ora nella 10 potenziato con arcpy). Si potrà poi esporre questi geoprocessi come web service per essere utilizzati dalle nostre applicazioni. Inoltre è possibile creare strumenti di geoprocessing con .NET e incorporare arcobjects in tool utilizzabile nei tool o nei modelli. E' chiaro che utilizzando tool out-of-box e costruendo modelli evitiamo la scrittura di codice.
L'aspetto negativo di questa soluzione è che richiede più memoria e spesso è più lenta della SOE. E' chiaro che una soluzione di questo tipo si adatta bene se il servizio è chiamato solo poche volte al giorno. Se il servizio è chiamato molte volte e soprattutto da utenti concorrenti, optare per la SOE.
Infine, prima di iniziare lo sviluppo di una SOE, valutare anche se le funzionalità del geometry service con le funzionalità di interrogazione esposte da ArcGIS Server non coprono già le nostre esigenze.

Una SOE è un oggetto COM sviluppato in .NET o Java che implementa IServerObjectExtension più altre interfacce necessarie all'implementazione.

Questa interfaccia è utilizzata dal server object (servizio) per gestire il ciclo di vita della SOE. L'Init è chiamato una sola volta quando si crea l'istanza, mentre lo ShutDown informa la SOE che il context è in shut down cosicchè la SOE rilascia il suo riferimento sul server object helper.

La SOE può opzionalmente implementare l'interfaccia IObjectConstruct, se occorre recuperare proprietà di configurazione della SOE o occorre eseguire logiche di inizializzazione. Questa interfaccia ha un solo metodo che è chiamato una sola volta dopo l'Init.

Attenzione a non mettere logiche di inizializzazione nel costruttore della SOE o nell'Init, ma utilizzare IObjectConstruct.Construct(), che è chiamato dopo il ciclo di vita della SOE e così assicura che la SOE è creata e puoi così generare log sin dalla tua logica di inizializzazione.

IObjectActivate and ILogSupport sono due interfacce opzionali da non utilizzare poichè sono utilizzabili con SOE che usano connessioni ArcGIS Server Local. Poichè con la 10.1 non ci sarà supporto su DCOM è meglio evitare di utilizzarle e comunque non sono utilizzate con SOE Web Services.

Per il logging utilizzeremo l'oggetto ESRI.ArcGIS.SOESupport.ServerLogger.

Per le SOE Rest implementeremo l'interfaccia IRESTRequestHandler: il client invia richieste su http al web service che restituisce una risposta. L'interfaccia IRESTRequestHandler facilita questa comunicazione.

I passi da seguire per sviluppare una SOE sono:
1) Sviluppare la SOE. E' presente un template in Visual Studio che crea un primo scheletro con le interfacce da implementare.
2) Registrare la SOE su ogni macchina SOC
3) Registrare la SOE in ArcGIS Server SOM
4) Facoltativo: sviluppare una pagina di proprietà della SOE per ArcCatalog
5) Abilitare la SOE su un servizio
6) Utilizzare il servizio con abilitata la SOE da un client (per esempio da Silverlight, Flex, Javascript).

Per lavorare con i Web services REST SOE, una volta indicato l'url ed appeso alcuni parametri di input (coordinate, nomi di layer ecc.), il server elabora e restituisce la risposta, come ad esempio, dati o stream di byte (immagini), al browser. Normalmente questo scambio avviene attraverso JSON.

Esempio:

http://sampleserver3.arcgisonline.com/ArcGIS/rest/services/Earthquakes/EarthquakesFromLastSevenDays/MapServer/0/query?where=magnitude>6&f=pjson

Questo è l'url inviato al server. I parametri che passiamo sono dopo il ? e cioè where=magnitude>6&f=pjson

La risposta restituita dal server in JSON è
{
"displayFieldName" : "eqid",
"fieldAliases" : {
"eqid" : "Earthquake ID"
},
"geometryType" : "esriGeometryPoint",
"spatialReference" : {
"wkid" : 4326
},
"fields" : [
{
"name" : "eqid",
"type" : "esriFieldTypeString",
"alias" : "Earthquake ID",
"length" : 50
}
],
"features" : [
{
"attributes" : {
"eqid" : "c0000f0y"
},
"geometry" : {
"x" : 148.95690000000002,
"y" : -6.0207999999999515
}
}
]
}

Il client potrà poi leggere e "parsare" la risposta in JSON e fare qualcosa nell'applicazione: ad esempio visualizzare le geometrie nella propria mappa.

Il precedente esempio è una chiamata rest ad un servizio ArcGIS Server. In questo caso non è stata chiamata una SOE Rest.

Il seguente link richiede la quota ad una certa latitudine e longitudine. E' una SOE chiamata ElevationSOE
http://sampleserver4.arcgisonline.com/ArcGIS/rest/services/Elevation/ESRI_Elevation_World/MapServer/exts/ElevationsSOE/ElevationLayers/1/GetElevationAtLonLat?lon=-123&lat=47&f=pjson

Vediamo come è composto l'url:
- http://sampleserver4.arcgisonline.com/ArcGIS/rest/services : è l'URL dell'ArcGIS Server root per i servizi rest
- Elevation: nome della cartella in ArcGIS Server
- ESRI_Elevation_World: nome del servizio
- MapServer: tipo di servizio
- exts: url della root per tutte le SOE esposte da questo servizio
- ElevationsSOE: nome della SOE
- ElevationLayers: risorsa esposta dalla SOE rappresentante una lista di layer abilitati per restituire quote
- 1: indice del layer da utilizzare nella richiesta della risorsa ElevationLayers
- GetElevationAtLonLat: operazione sulla SOE che prende la quota data una lat/lon
- lon=-123: parametro logitudine per GetElevationAtLonLat
- lat=47: parametro latitudine per GetElevationAtLonLat
- f=pjson: formato per la risposta dell'operazione. In questo caso è stato indicato il pjson ovverosia il json formattato per essere facilmente leggibile.

Il server restituisce un oggetto Json (chiamato elevation).
{
"elevation" : 83.003478588350134
}

Il server in questo caso ha eseguito ArcObjects per restituire questo risultato, ma l'applicazione client non necessita di avere conoscenze ArcObjects. Il client deve solo conoscere l'url e gestirsi la risposta.

Prima di sviluppare una SOE Rest occorre introdurre la definizione di risorsa e di operazione.
Una volta stabilito quali sono le informazioni che vogliamo inviare e ricevere dal nostro servizio occorre pensare alla SOE Rest come risorse e operazioni.
Le risorse sono delle informazioni che richiediamo al server. Esempio: una lista di layer della mappa o un insieme di livelli di scala disponibili nella cache della mappa. Può essere vista come una proprietà di sola lettura.
Le operazioni sono richieste al server su una determinata risorsa. Dopo aver effettuato la richiesta possiamo farci restituire informazioni testuali, immagini od altro. Le operazioni possono essere viste come dei metodi.

E' importante progettare il diagramma delle risorse e delle operazioni (con input ed output) per poter creare lo schema poichè quest'ultimo deve essere creato da programmazioni e, se dovessimo creare risorse multiple con operazioni, potrebbe diventare ardua la gestione da codice senza un diagramma definito. Inoltre, poichè i dati in input ed output andranno serializzati o deserializzati (si passerà da Json ad ArcObjects e viceversa), conoscere nel dettaglio i parametri aiuta lo sviluppo di queste operazioni. La ESRI ha introdotto oggetti e metodi (nella libreria ESRI.ArcGIS.SOESupport) che aiutano i passaggi di serializzazione e deserializzazione.

Una volta che abbiamo installato SDK ArcGIS.NET, abbiamo a disposizione in Visual Studio 2008 e 2010 dei templates che ci aiutano a creare una SOE Rest. Il template è disponibile sono in C# con framework 3.5.

Una volta selezionato il template, ci verrà generata una classe che rappresenta la nostra SOE Rest.

Come abbiamo accennato precedentemente, una SOE è una classe COM che risiede sul nostro server. Il template ha già impostato per noi la GUID e la visibilità a COM.
Inoltre la classe implementa una serie di interfacce alcune delle quali sono nuove:

ServicedComponent: è richiesta come classe base dalla SOE che usa COM.
IServerObjectExtension: contiene i metodi Init() e Shutdown() che vengono eseguiti quando si avvia e si ferma la nostra SOE. Normalmente non vengono utilizzati a meno che occorra 'ripulire' qualcosa sullo shutdown. Utilizzare il metodo IObjectConstruct.Construct() per inizializzare qualcosa una volta che la SOE è abilitata - non il costruttore della classe o l'Init.
IObjectConstruct: contiene un metodo (Construct()) che viene eseguito una volta che la SOE è abilitata. Qui è il posto corretto dove mettere logiche business di inizializzazione che non necessitano di essere eseguite ad ogni richiesta. Ad esempio, potresti creare geodatabase temporanei che precalcolano dati che poi verranno utilizzati e dipendono dal servizio sottostante, oppure impostare variabili che verranno poi utilizzate perchè non cambiano più durante il ciclo di vita ecc.
IRESTRequestHandler: abilita richieste e risposte REST per il servizio. Questi metodi creano lo schema e manipolano le richieste. Normalmente possiamo lasciare il codice generato così com'è.

Nel costruttore possiamo notare la classe SoeRestImpl che implementa l'interfaccia IRESTRequestHandler.

reqHandler = new SoeRestImpl(soe_name, CreateRestSchema()) as IRESTRequestHandler;

La SoeRestImpl valida lo schema SOE, convalida il nome delle risorse e delle operazioni delle chiamate HandleRESTRequest, valida le capabilities della SOE, gestisce gli errori e registra le chiamate e le risposte del servizio.
La classe SOE normalmente contiene una sola istanza della classe SoeRestImpl.
Il resto del template contiene delle funzioni per mostrare che cosa la SOE Rest può fare e come ogni richiesta alla SOE può essere gestita. CreateRestSchema() definisce le risorse e le operazioni disponibili nella nostra SOE. Ognuna di queste risorse e operazioni ha associato una funzione che descrive che cosa deve fare la risorsa e l'operazione quando è chiamata. Il template contiene, a scopo dimostrativo, una funzione per la risorsa ( RootResHandler() ) ed una per una operazione ( SampleOperHandler() ).

private RestResource CreateRestSchema()
{
     RestResource rootRes = new RestResource(soe_name, false, RootResHandler);
     RestOperation sampleOper = new RestOperation("sampleOperation",
                                                      new string[] { "parm1", "parm2" },
                                                      new string[] { "json" },
                                                      SampleOperHandler);
 
     rootRes.operations.Add(sampleOper);
 
     return rootRes;
}

In questo caso possiamo vedere come lo schema del template è molto semplice, ovvero abbiamo una risorsa (risorsa di root) e una operazione che viene aggiunta alla risorsa di root ( rootRes.operations.Add(sampleOper)).
Come abbiamo detto precedentemente, poichè lo schema verrà creato via codice è importante definire bene le risorse e le operazioni che si vogliono supportare.

La funzione CreateRestSchema() è il cuore della nostra SOE Rest.
Qui è dove noi definiamo e creiamo lo schema del servizio dicendo quali risorse e operazioni intediamo supportare.

Per ogni risorsa che definiamo, utilizziamo RestResource, mentre per ogni operazione che definiamo utilizziamo RestOperation.
Una volta definite tutte le risorse e le operazioni, utilizziamo il metodo Add() sulla risorse per costruire lo schema.

Nel precedente schema, alla risorsa rootRes è stata aggiunta una operazione (sampleOper).

Quando creiamo una RestResource o una RestOperation, possiamo, opzionalmente, passare il nome di una capabilities come uno dei parametri del metodo e/o per le operation se si può chiamare esclusivamente via post (postOnly).

La risorsa può essere una collezione o meno. Il secondo parametro indica se la risorsa è una collezione.

Esempio di risorsa di tipo collection

RestResource customLayerResource = new RestResource("customLayers", true, CustomLayer, c_CapabilityGetInfo);

Ora, se una risorsa od una operazione è aggiunta in una risorsa di tipo collezione, quando chiameremo la nostra operazione/risorsa per recuperare il/i valore/i delle risorse di tipo collezione dei livelli superiori utilizzeremo la lista boundVariable contenente tutti valori di ogni risorsa di tipo collezione dei livelli superiori rispetto alla risorsa od operazione che si sta analizzando. Ogni valore è recuperato passando la chiave così composta "NomeRisorsa" + ID

//customLayers/{customLayersID}
        //returns json with simplified layerinfo (name, id, extent)
        private byte[] CustomLayer(NameValueCollection boundVariables, string outputFormat, string requestProperties, out string responseProperties)
        {
            responseProperties = null;
 
            //layerID
            int layerID = Convert.ToInt32(boundVariables["customLayersID"]);

RestOperation sampleOper = new RestOperation("sampleOperation",
                                                      new string[] { "parm1", "parm2" },
                                                      new string[] { "json" },
                                                      SampleOperHandler, "GetSampleOper");

In questo esempio abbiamo definito una capability per l'operazione sampleOper di nome, ad esempio, GetSampleOper.
Le capabilities sono gruppi di risorse o operazioni che l'amministratore del gis server può abilitare o disabilitare per esporre o meno un certo sottoinsieme di funzionalità.

Queste capabilities sono chiamate "Operations Allowed" e vengono visualizzate automaticamente in ArcCatalog.

Nel progetto di registrazione della SOE impostare le proprietà seguenti:

// Capabilities
serverObjectExtensionType.Info.SetProperty("DefaultWebCapabilities", string.Format("{0}", "GetSampleOper"));
serverObjectExtensionType.Info.SetProperty("AllWebCapabilities", string.Format("{0}", "GetSampleOper"));

Abbiamo precedentemente accennato che ogni risorsa ed ogni operazione che aggiungiamo al nostro schema necessita di una funzione. Essa contiene la logica da eseguire quando si chiama la risorsa o l'operazione.
Queste funzioni sono dove noi scriveremo la maggior parte del nostro codice ArcObjects.

Se abilitiamo il nostro servizio a questa extension possiamo notare nella sezione Supported Extensions la nostra SOE Rest extension.
Selezionandola vedremo la risposta del resource di root

Cliccando su rest vedremo la rappresentazione JSON della risorsa

{
  "hello" : "world"
}

Nell'esempio del template la risorsa ha una funzione chiamata RootResHandler(). L'esempio creato automaticamente dal template restituisce un semplice JSON hello : world.
La definizione della funzione che gestisce la risorsa è definita da un delegato .NET nella libreria ESRI SOESupport.
Questo significa che tutte le risorse hanno una firma uguale alla seguente:

public delegate byte[] ResourceHandler(NameValueCollection boundVariables, string outputFormat, string requestProperties, out string responseProperties);

Il REST SOE template contiene anche la funzione per una operazione (chiamata SampleOperHandler()). In questo semplice esempio la funzione deserializza due parametri stringa (parm1 e parm2) e restituisce gli stessi come output in formato JSON. Puoi copiare e modificare questa funzione per ospitare le operazioni del tuo schema.

Come per la risorsa, la firma della funzione per gestire un'operazione è definita da un delegato. Essa è simile a quella della risorsa eccetto il fatto di contenere un oggetto Json come input (operationInput). Questo oggetto Json ha dei parametri richiesti dall'operazione; per esempio, quando chiamiamo un'operazione di buffer, l'oggetto Json potrebbe contenere un punto e la distanza di buffer.

public delegate byte[] OperationHandler(NameValueCollection boundVariables, JsonObject operationInput, string outputFormat, string requestProperties, out string responseProperties);

Gli elementi principali sui quali occorre concentrarsi in una funzione che gestisce una operazione sono: la deserializzazione dell' input JSON, lavorare con gli ArcObiects o con le proprie librerie e serializzare l'output in JSON. Deserializzare e serializzare il JSON può essere la parte più delicata.

Come possiamo notare, nelle firme abbiamo la responseProperties. Questa potrebbe essere utilizzata quando vogliamo restituire qualcosa che non può essere rappresentato da JSON, come ad esempio una immagine. In questo caso dobbiamo impostare il Content-type header dell' HTTP nelle proprietà della risposta.

Innanzitutto, quando definiamo la nostra risorsa o operazione, impostiamo i formati supportati. In questo esempio definiamo un'operazione che restituisce un PNG. Nella RestOperation è il terzo parametro che riceve un array di stringhe con i formati supportati.

RestOperation pngOper = new RestOperation("generatePng", null, new string[]{"png"} , PngHandler);
soeResource.operations.Add(pngOper);

Nella funzione che gestisce l'operazione impostiamo come ultimo parametro (responseProperties) un JSON rappresentante il Content-Type header che desideriamo. Nel caso specifico image/png

private byte[] PngHandler(System.Collections.Specialized.NameValueCollection
                          boundVariables, ESRI.ArcGIS.SOESupport.JsonObject
                          operationInput, string outputFormat, string
                          requestProperties, out string responseProperties)
{
         responseProperties = "{\"Content-Type\" : \"image/png\"}";
         // Add code to generate and return a PNG.
}

altrimenti impostiamo a null se non dobbiamo impostare il Content-Type header.

Il JSON è un formato altamente strutturato per trasferire dati tra applicazioni e per i web services.
Gli ArcObjects però non capiscono il JSON, pertanto le nostre funzioni che gestiscono le risorse e le operazioni devono deserializzare l'input JSON; ovverosia, estrarre i valori che occorrono per la logica di business. Una volta eseguita la business logic, il codice avrà la necessità di creare un JSON con i risultati così da serializzare la risposta.

La libreria SOESupport è stata creata da ESRI per essere di supporto a queste operaioni, serializzare e deserializzare JSON. Quando un client fa una richiesta, JSON è portato nella funzione che gestisce la risorsa o l'operazione come istanza della classe SOESupport.JsonObject; inoltre, possiamo inviare i nostri risultati dalla funzione come istanza di JsonObject.

Ma entriamo nel dettaglio: vedendo il codice generato nel template possiamo notare il pattern utilizzato nella funzione di gestione di una operazione.

private byte[] SampleOperHandler(NameValueCollection boundVariables,
                                                  JsonObject operationInput,
                                                      string outputFormat,
                                                      string requestProperties,
                                                  out string responseProperties)
        {
            responseProperties = null;
 
            string parm1Value;
            bool found = operationInput.TryGetString("parm1", out parm1Value);
            if (!found || string.IsNullOrEmpty(parm1Value))
                throw new ArgumentNullException("parm1");

L'istanza della classe JsonObject è il parametro operationInput. Il nostro codice dovrà provare a prendere i valori utilizzando i metodi TryGet inclusi in JsonObject.
Abbiamo a disposizione:

TryGetArray
TryGetAsBooolean
TryGetAsData
TryGetAsDouble
TryGetAsLong
TryGetJsonObject (gestione di oggetti di oggetti nidificati)
TryGetObject
TryGetString

Questi metodi permettono di estrarre il valore dei parametri JSON ed assegnarli a variabili nel nostro progetto. Successivamente potremo utilizzare queste variabili per creare gli ArcObjects che ci occorrono.

Per deserializzare le geometrie possiamo utilizzare il metodo SOESupport.Conversion.ToGeometry() che prende un oggetto JSON o una stringa di input e restituisce una IGeometry. Abbiamo anche ToSpatialReference che, data una stringa, restituisce uno ISpatialReference e ToJson che serializza in stringa Json UTF8 come array di byte un IRecordSet o una IGeometry.

In questo esempio vediamo un extension method per convertire oggetti JsonObjects in IGeometry (nota: alla fine è stato posto un try/catch perchè con la cultura IT è possibili aver problemi con la funzione TryGetDouble per il separatore decimale. L'alternativa è impostare nel web.config dell'applicazione rest ESRI la cultura IT):

        /// <summary>
        /// restituisce la Geometry corrispondente
        /// </summary>
        /// <param name="jsonObjectGeometry">oggetto JsonObject</param>
        /// <returns>restituisce la IGeometry</returns>
        internal static IGeometry ConvertAnyJsonGeometry(this JsonObject jsonObjectGeometry)
        {
            object[] objArray;
            ////double? nullable;
            if (jsonObjectGeometry.TryGetArray("rings", out objArray))
            {
                return Conversion.ToGeometry(jsonObjectGeometry, esriGeometryType.esriGeometryPolygon);
            }
 
            if (jsonObjectGeometry.TryGetArray("paths", out objArray))
            {
                return Conversion.ToGeometry(jsonObjectGeometry, esriGeometryType.esriGeometryPolyline);
            }
 
            if (jsonObjectGeometry.TryGetArray("points", out objArray))
            {
                return Conversion.ToGeometry(jsonObjectGeometry, esriGeometryType.esriGeometryMultipoint);
            }
 
            try
            {
                return Conversion.ToGeometry(jsonObjectGeometry, esriGeometryType.esriGeometryPoint);
            }
            catch
            {
                try
                {
                    return Conversion.ToGeometry(jsonObjectGeometry, esriGeometryType.esriGeometryEnvelope);
                }
                catch
                {
                    return null;
                }
            }
        }

Chiaramente un controllo sull'oggetto è sempre essenziale per questi metodi. Se l'oggetto non contiene i dati necessari per costruire il punto, avremo un'eccezione.

Ma ora vediamo l'operazione inversa . Una volta completata la nostra business logic dobbiamo serializzare i nostri risultati in JSON o in stream indietro al client.
Vediamo come serializzare i risultati in JSON.

Per generare una risposta JSON possiamo creare un'istanza della classe JsonObject ed aggiungere dati utilizzando i metodi che ci mette a disposizione JsonObject.

JsonObject jsonPoint;
if (!operationInput.TryGetJsonObject("location", out jsonPoint))
                throw new ArgumentNullException("location");
IPoint location = Conversion.ToGeometry(jsonPoint,
                                                    esriGeometryType.esriGeometryPoint) as
                                                    IPoint;

Nell'esempio creaimo un oggetto JsonObject ed aggiungiamo una stringa con la proprietà parm1 e con il valore parm1Value. Se parm1Value ha il valore 'myFirstParameter' il risultato del JSON sarà:

JsonObject result = new JsonObject();
            result.AddString("parm1", parm1Value);

{
"parm1" : "myFirstParameter"
}

Come visto per i metodi di deserializzazione, abbiamo i seguenti metodi di serializzazione:

AddArray
AddBoolean
AddData
AddDouble
AddJsonObject (consente di aggiungere oggetti nidificati)
AddLong
AddObject
AddString

Alcune geometrie possono essere serializzate perchè contengono oggetti nidificati e array. Il modo più semplice è utilizzare SOESupport.Conversion.ToJsonObject() per serializzare le geometrie.
Passando un oggetto che implementa IGeometry prenderemo l'oggetto serializzato in Json.

In questo esempio serializziamo delle IGeometry e creiamo un oggetto Json con una proprietà geometries che contiene un array di oggetti Json (le nostre geometrie serializzate).

            // Creiamo una lista vouta di JsonObjects.
            List<JsonObject> jsonGeometries = new List<JsonObject>();
            
            JsonObject jsonResultsGeometry = Conversion.ToJsonObject(resultsGeometry);
            jsonGeometries.Add(jsonResultsGeometry);
            JsonObject resultJsonObject = new JsonObject();
            resultJsonObject.AddArray("geometries", jsonGeometries.ToArray());
            byte[] result = Encoding.UTF8.GetBytes(resultJsonObject.ToJson());
            return result;

Json prodotto:

"geometries" : [
    {
      "rings" : [
        [
          [
            537677.56250619888,
            4900994.4999926779
          ],
          [
            537952.21783445403,
            4900502.2883762196
          ],
          [
            537942.24243737175,
            4900503.3471435569
          ],
          etc. . .
        ]
      ]
    },
    {
      "rings" : [
        [
          [
            537952.21783445403,
            4900502.2883762196
          ],
          [
            537677.56250619888,
            4900994.4999926779
          ],
          [
            537826.87501833774,
            4901122.9999607969
          ],
          etc . . .
        ]
      ]
    }
]

Lato client: ad esempio, utilizzando le API ESRI Javascript, possiamo ciclare attraverso queste geometrie e creare un Polygon da visualizzare in mappa.

      var geometries = response.geometries;
      // Loop through all graphics in the JSON.
      for (var i = 0, il = geometries.length; i < il; i++) {
          // Make a new polygon.
          var polygon = new esri.geometry.Polygon(sr);
          // Loop through all rings in the JSON and add to polygon.
          for (var j = 0, jl = geometries[i].rings.length; j < jl; j++) {
              polygon.addRing(geometries[i].rings[j]);
          }
          // Create a graphic from the polygon and add it to the map.
          var currentGraphic = new esri.Graphic(polygon, symbol, attr, infoTemplate);
          map.graphics.add(currentGraphic);
      }

E' importante abilitare la nostra SOE a supportare l'utilizzo di servizi basati su MSD. Innanzitutto, perchè l'engine di drawing è più veloce rispetto ai servizi tradizionali basati su mxd, e poi perchè nella versione ArcGIS Server 10.1 i servizi MSD saranno i soli supportati.
Questo però, poichè l'engine di drawing è completamente differente, non supporta completamente tutti gli ArcObjects della libreria Carto e quindi, se il servizio si basa su un MSD, non possiamo utilizzare direttamente gli ArcObjects relativi al documento di mappa come IMap, ILayer, IFeatureLayer o IMapServerObjects.

A questo punto, il consiglio è utilizzare la classe MapServer e classi/interfaccie collegate, che rappresentano il servizio, nella libreria Carto per prendere informazioni sui layer o per capire come eseguire interrogazioni sul servizio.

In questo esempio vediamo come accedere ai datasource dei layer della mappa del servizio. Una volta che arriviamo ai datasource, possiamo utilizzare gli ArcObjects per lavorare con i cursori o per eseguire operazioni topologiche. Innazitutto, come abbiamo detto, utilizziamo la classe MapServer per prendere il layer e poi utilizziamo IMapServerDataAccess per prendere i dati sottostanti.

        /// <summary>
        /// restituisce la featureclass dal mapserver
        /// </summary>
        /// <param name="mapServer">oggetto map server</param>
        /// <param name="layerID">identificativo del layer</param>
        /// <returns>restituisce la feature classe del layer</returns>
        internal static IFeatureClass GetFeatureClass(this IMapServer3 mapServer, int layerID)
        {
            IMapServerDataAccess dataAccess = (IMapServerDataAccess)mapServer;
            return dataAccess.GetDataSource(mapServer.DefaultMapName, layerID) as IFeatureClass;
        }

L'interfaccia IMapServer3 ha metodi che restituiscono i dati serializzati in JSon utilizzando da IQueryResultOptions la proprietà Format

 // Summary:
    //     Query Result Format.
    [Guid("6B819851-6A36-4A6F-8759-58CEF9915B36")]
    public enum esriQueryResultFormat
    {
        // Summary:
        //     Indicates RecordSet.
        esriQueryResultRecordSetAsObject = 0,
        //
        // Summary:
        //     Indicates KML.
        esriQueryResultKMLAsMime = 1,
        //
        // Summary:
        //     Indicates KML.
        esriQueryResultKMLAsURL = 2,
        //
        // Summary:
        //     Indicates JSON.
        esriQueryResultJsonAsMime = 3,
        //
        // Summary:
        //     Indicates JSON.
        esriQueryResultJsonAsURL = 4,
        //
        // Summary:
        //     Indicates AMF.
        esriQueryResultAMFAsMime = 5,
        //
        // Summary:
        //     Indicates AMF.
        esriQueryResultAMFAsURL = 6,
    }

Qui vediamo un esempio di come serializzare il risultato di una query in formato json mediante un stream di byte come risposta della nostra operazione. C'è da sottolineare come possiamo anche contestalmente effettuare una trasformazione di datum mediante la proprietà GeoTransformation della classe QueryResultOptionsClass.

private byte[] FindNearFeatures(int layerID, IPoint location, double distance)
        {
            if (layerID < 0)
                throw new ArgumentOutOfRangeException("layerID");
 
            if (distance <= 0.0)
                throw new ArgumentOutOfRangeException("distance");
 
            IMapServer3 mapServer = serverObjectHelper.ServerObject as IMapServer3;
            if (mapServer == null)
                throw new Exception("Unable to access the map server.");
 
            IGeometry queryGeometry = ((ITopologicalOperator)location).Buffer(distance);
 
            ISpatialFilter filter = new SpatialFilterClass();
            filter.Geometry = queryGeometry;
            filter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
 
            IQueryResultOptions resultOptions = new QueryResultOptionsClass();
            resultOptions.Format = esriQueryResultFormat.esriQueryResultJsonAsMime;
            
            AutoTimer timer = new AutoTimer(); //starts the timer
 
            IMapTableDescription tableDesc = GetTableDesc(mapServer, layerID);
 
            logger.LogMessage(ServerLogger.msgType.infoDetailed, "FindNearFeatures", -1, timer.Elapsed, "Finding table description elapsed this much.");
 
            IQueryResult result = mapServer.QueryData(mapServer.DefaultMapName, tableDesc, filter, resultOptions);
 
            return result.MimeData;
        }

Per abilitare la nostra SOE a supportare un servizio msd occorre, quando si registra, impostare la proprietà SupportsMSD a true cosicchè, quando pubblichiamo, possiamo vedere il servizio nella lista di quelli disponibili.

            // Proprietà per definire il support msd
            serverObjectExtensionType.Info.SetProperty("SupportsMSD", "true");
            // Richiesto per abilitare l'esposizione della SOE con ArcGIS Server REST endpoint
            serverObjectExtensionType.Info.SetProperty("SupportsREST", "true");

Se il nostro servizio è protetto, le regole di autenticazione sono applicate a tutte le extension del servizio, comprese le custom. Qui potete vedere come recuperare l'utente via codice. (Disponibile dalla 10 sp2)

Debug della SOE
Le SOE sono componenti COM che sono in esecuzione all'interno di ArcGIS Server e quindi occorre una specifica tecnica per l'attività di debugging.
Innanzitutto, l'assembly della SOE deve essere registrato con l'opzione /codebase, la quale crea nel registro una voce di codebase che specifica il percorso della dll per un assembly che non è specificato nella GAC (cache globale degli assembly). Il file che specifichiamo con /codebase deve essere un assembly con nome forte. In Visual Studio questo può essere facilmente impostato andando nelle pagine delle proprietà del progetto in Signing

Per eseguire un'attività di debugging sul server object container (SOC), impostare il processo ArcSOC.exe ad un minimo ed un massimo numero di istanze per servizio che ospita la SOE pari ad 1.
Questo evita che più di un processo SOC ospiti la nostra SOE; inoltre si potrebbero fermare tutti gli altri servizi per ridurre il numero di SOC e quindi si potrebbe selezionare più agevolmente il processo quando si esegue il debug.

Ricordarsi che ArcGIS server ha comunque due processi ArcSOC.exe che utilizza per le proprie attività (cancellazione file in arcgisoutput, logging arcgis server ecc.) .
Se ci sono molti processi SOC in esecuzione e non vogliamo interromperli, agganciamo il debugger a tutti i processi ArcSOC gestiti per amministrarli.

Una volta che il servizio con abilitata la SOE è in esecuzione in ArcGIS Server, agganciamo da Visual Studio il debugger al processo della SOC relativo.

I passi da seguire sono:

1) Aprire da Visual Studio la soluzione e i progetti contenenti l'implementazione della SOE.

2) Selezionare il menu Debug e selezionare Attach to Process

3) Una volta selezionato Attach to Process ci comparirà una maschera con l'elenco dei processi disponibili.
Se i processi ArcSOC.exe non sono visualizzati, spuntare le checkbox Show processes from all users e Show processes in all sessions. Occorre trovare i processi ArcSOC.exe che hanno nella colonna Type la voce "Managed, x86". Se ce n'è più di 1 determinare qual è quello associato con il servizio che ospita la SOE.

4) Una volta selezionato il processo ArcSOC.exe, occorre cliccare su Attach. Un messaggio sui possibili pericoli di processi potenzialmente pericolosi vi avvertirà. Poichè siamo in un contesto di testing sicuro, confermiamo clicchiamo su Attach.

5) A questo punto inseriamo un breakpoint nel codice della SOE.

6) Dal cliente che utilizza la SOE eseguiamo una richiesta dove è coinvolto il nostro breakpoint aggiunto precedentemente.

7) A questo punto l'esecuzione si fermerà al nostro breakpoint consetendoci di proseguire in debug.

8) Una volta che il debug è terminato o fermato Visual Studio si 'stacca' da ArcSOC.exe.

9) Se abbiamo la necessità di modificare il codice ed abbiamo registrato la SOE con l'opzione codebase, fermiamo il servizio arcgis server che utilizza la SOE, modifichiamo il codice, ricompiliamo il progetto e facciamo ripartire il servizio. Non c'è la necessità di rieseguire un regasm per la registrazione della dll o riaggiungerla alla GAC.

Infine, per poter eseguire un'attività di debug sul metodo Costruct, occorre inserire un ritardo di n secondi. In questo caso abbiamo per esempio 20 secondi di tempo per agganciare il processo e andare in debug sul costruct della SOE.

#region IObjectConstruct Members
        /// <summary>
        /// Metodo che parte all'inizio quando si avvia la SOE
        /// </summary>
        /// <param name="props">proprietà della SOE</param>
        public void Construct(IPropertySet props)
        {
            ////ho 20 sec per attaccare il processo e debuggare il costruttore dopo aver avviato il servizi
            System.Threading.Thread.Sleep(20000);
 
            AutoTimer timer = new AutoTimer();
            this.logger.LogMessage(ServerLogger.msgType.infoSimple, "Construct", -1, this.soeName + ": il costruttore è stato avviato.");
 
            this.configProps = props;

Property Page per una server object extension

Se creiamo una SOE che deve essere utilizzata da più di un servizio è facile che abbiamo l'esigenza di impostare parametri in funzione del servizio utilizzato. Ad esempio, desideriamo impostare un determinato layer ad essere coinvolto nelle richieste della SOE ma non altri, oppure impostare parametri che siano indipendenti dalla richiesta fatta dal client - ad esempio il numero massimo di record restituiti per la nostra elaborazione (potrebbe essere nel caso specifico un override del parametro del servizio stesso).
In queste situazioni, possiamo costruire una property page che si posizionerà nella scheda delle capabilities della maschera di dialogo delle proprietà del servizio in ArcCatalog o in ArcGIS Server Manager
Chiaramente, se la SOE dipende da proprietà del property page, non possiamo utilizzare l'Add New Service Wizard poichè per poterla utilizzare dobbiamo impostare queste proprietà. Quindi in questo caso le alternative sono due: o impostiamo dei valori di default nelle proprietà che abbbiamo creato per la SOE, oppure pubblichiamo il servizio senza SOE abilitata e poi andiamo sui servizi, fermiamo il servizio, impostiamo le proprietà dalla property page e riavviamo il servizio.

Per sviluppare una property page creiamo una nuova Windows Form. Le proprietà della SOE possono essere impostate basandosi sugli eventi della form (per esempio cambio selezione di una combobox).

Dobbiamo implementare ESRI.ArcGIS.Framework.IComPropertyPage e ESRI.ArcGIS.CatalogUI.IAGSSOEParameterPage per la nostra page per inserirla in ArcCatalog.

La nostra page deve implementare per la IComPropertyPage i seguenti membri:

PageSite
Activate
Show
Hide

I membri Height e Deactivate non sono richiesti ma se necessari possiamo implementarli mentri i rimanenti non sono utilizzati.

L'Interfaccia IAGSSOEParameterPage definisce un insieme di proprietà per la SOE che devono essere esplicitamente implementate. Queste includono:

Tipo di servizio (ServerObjectType)
Proprietà non relazionate alla SOE (ServerObjectProperties)
Nome della SOE (ServerObjectExtensionType)
Proprietà che definiamo per la SOE (ExtensionProperties)

Ad esempio, qui possiamo vedere Come creare pagine property SOE : come usare il set della proprietà ServerObjectProperties per farsi restituire il percorso del documento di mappa ed eseguire proprie logiche per farsi restituire il layer ed i propri campi.

Quando una SOE è abilitata in ArcCatalog cliccando OK o Apply, le sue proprietà sono restituite dalla pagina della SOE property attraverso il get della proprietà ExtensionProperties. Queste proprietà restituite sono aggiunte al file di configurazione del servizio di mappa ( C:\Program Files\ArcGIS\Server10.0\server\user\cfg ). Quando vengono effettuate modifiche alle proprietà della SOE, queste si riflettono nella property page attraverso il set della proprietà ExtensionProperties.

Per semplificare il codice della property page, potremmo voler implementare le nostre interfacce richieste ( IComPropertyPage and IAGSSOEParameterPage ) in una classe astratta e poi raggruppare la logica che le implementa in una classe separata che eredita dalla classe astratta.

Negli esempi ESRI troverete la classe astratta in SOEPropertyPage.cs e la PropertyPage.cs che eredita da essa. Tutto il codice con i set e i get delle proprietà della SOE è implementato nella PropertyPage.cs.

La nostra property page deve contenere del codice che quando è registrato con il COM include la categoria del componente AGSSOEParameterPages. Le categorie del componente sono utilizzate dall'applicazione client per determinare in modo efficiente tutte le componenti di un particolare tipo che sono installate nel sistema. Se le categorie del componente non sono utilizzate, l'applicazione avrebbe dovuto istanziare ogni componente COM ed interrogarla per vedere se supporta la funzionalità richiesta - il che non è un approccio pratico.

ArcCatalog cerca soltanto le pagine property nella categoria del componente AGSSOEParameterPages. Nella classe in SOEPropertyPage.cs il seguente codice assicura che la pagina property è registrata nella categoria AGSSOEParameterPages.

Per verificarlo possiamo eseguire categories.exe in <ArcGIS Desktop install>\bin ed espandere la categoria ESRI AGS Extension Parameter Pages. Qui potremo vedere anche altre pagine sviluppate da ESRI (KML, WCS, WFS ecc) che sono SOE.

Una volta sviluppata la nostra property page, dobbiamo registrare il COM così che i tipi .NET e la windows form possano essere utilizzati in ArcCatalog

In <Program files>\Common Files\ArcGIS\bin abbiamo l'utility ESRIRegAsm.exe:

ESRIRegAsm.exe "<path to ArcCatalog property page dll>" /p:Desktop

Qui potete vedere un esempio: Print SOE Rest

Instructions:

Print SOE Rest
Author: Domenico Ciavarella
http://www.studioat.it/
February 13th 2011
Summary:
This solution (developed in c#) creates a SOE Rest in arcgis server to print template mxd from client.
For now you can print services arcgis server and format pdf.

Installation:
a) register unregister dll and soe
- register dll in SOC machine
1) %WinDir%\Microsoft.NET\Framework\v2.0.50727\regasm Studioat.ARCGIS.SOE.REST.dll /codebase

- register soe in ArcGIS server (SOM)
1) Studioat.ARCGIS.SOE.Register.exe -c Studioat.ARCGIS.SOE.REST.Print -n Print -l "Your title"

for unregister
1) Studioat.ARCGIS.SOE.Register.exe -n Print -u
2) %WinDir%\Microsoft.NET\Framework\v2.0.50727\regasm Studioat.ARCGIS.SOE.REST.dll /codebase /u

b) create a service map and enable in capabilities the extension. The msd used for the service that is published isn't important because it is not used.
c) in the same directory where the msd is we must create a folder called 'Applications'. Here we create as many folder as our printing applications are and in each of them we put the mxds which will be used for printing.
   ---yourmsdpublish.msd
   ---Applications (folder)
              MyAppWorld (folder)
                  templateWorld.mxd
                  other mxds
              MyApplicationsRiver (folder)
                 River1.mxd
                 TemplateRivers.mxd
              and so on...
d) from service directory yuo can see all your applications
http://localhost/ArcGIS/rest/services/%3Cyourservice%3E/MapServer/exts/Print
e) see all template of application with id=0
http://localhost/ArcGIS/rest/services/%3Cyourservice%3E/MapServer/exts/Print/applications/0

f) see parameter for print template with id=0 and application with id=0
http://localhost/ArcGIS/rest/services/%3Cyourservice%3E/MapServer/exts/Print/applications/0/templates/0/printtemplate

Parameters:
1) extent: Geometry Envelope (see rest api esri)
example:
{"xmin":-8582617.03619766,"ymin":4896408.449978509,"xmax":-8535608.26380234,"ymax":4915441.270021492,"spatialReference":{"wkid":102113}}
2) scale: number (optional)
3) services: array objects (name, serverConnection, transparency(optional), layers (optional))
[{"name":"World_Street_Map", "serverConnection":"http://server.arcgisonline.com/ArcGIS/services"}, { "name":"ArcPyMapping/Birds", "serverConnection":"http://ec2-50-17-53-73.compute-1.amazonaws.com/ArcGIS/services", "transparency":50}]
name: name of service
serverConnection: connection to server
transparency: effect transparency of layer
layers: (visibility layers of service: see parameter layers in export map of rest api esri)
4) properties: (optional).  Object (texts (optional), graphics(optional))
{"texts":[{"text":"texttitle","value":"Map title"},{"text":"textscala","value":""}],"graphics":[{"geometry":{"x":-8556360.916981738,"y":4907186.070966704,"spatialReference":{"wkid":102113}},"symbol":{"color":[0,255,0,64],"size":7.5,"angle":0,"xoffset":0,"yoffset":0,"type":"esriSMS","style":"esriSMSSquare","outline":{"color":[255,0,0,255],"width":0.75,"type":"esriSLS","style":"esriSLSSolid"}}},{"geometry":{"x":-8557583.909434298,"y":4904778.3045757245,"spatialReference":{"wkid":102113}},"symbol":{"color":[0,255,0,64],"size":7.5,"angle":0,"xoffset":0,"yoffset":0,"type":"esriSMS","style":"esriSMSSquare","outline":{"color":[255,0,0,255],"width":0.75,"type":"esriSLS","style":"esriSLSSolid"}}}]}
texts: array of objects (text, value)
if in template in pagelayout you have added graphic texts with name %My name% you return list from (example application=0 and template=0)
http://localhost/ArcGIS/rest/services/<my service>/MapServer/exts/Print/applications/0/templates/0?f=pjson
{
"name" : "TemplateA4_3",
"id" : 0,
"texts" : [
    "textscala",
    "texttitle"
]
}
graphics: array of graphics (from esri api javascript: yourgraphic.toJson())
5) resolution: number (optional) range from 150 to 600. If you want to change this range you must change in code (there are two constants)
6) options: array properties for pdf (optional)
{"embedFonts": true, "imageCompression":"esriExportImageCompressionDeflate" ...}

I have added in file zip an example in api esri javascript to see how to use.