Estrapolazione dati

[luisa227]

Ciao Luisa,
per fare quello che vuoi tu, visto che ricevi i dati via json, devi chiamare direttamente la fonte dei dati, non la pagina stessa.
In questo caso (il primo link) se fai un controllo con fiddler ti accorgerai che al click sulla ricerca (o chiamando il link alla pagina con i parametri) i dati vengono caricati da "http://www.albonazionalegestoriambientali.it/Services/GetRicerche.asmx/GetImpresePerSezioneProvincia", con una chiamata POST. Quindi puoi tranquillamente utilizzare una HttpWebRequest per fare altrettanto. Ad esempio :

public class JSONDataReader
    {
        public class Result
        {
            public Content d { get; set; }
        }
        public class Content
        {
            public int NumeroRecordTotali { get; set; }
            public List<Imprese> ListaImprese { get; set; }
        }
        public class Imprese
        {
            public string Cap { get; set; }
            public string Categorie { get; set; }
            public string CodiceFiscale { get; set; }
            public string Comune { get; set; }
            public string Denominazione { get; set; }
            public string IdImpresa { get; set; }
            public string NumeroIscrizione { get; set; }
            public string Progressivo  { get; set; }
            public string ProvinciaIscrizione{ get; set; }
            public string Sezione{ get; set; }
            public string SiglaProvincia{ get; set; }
            public string Via{ get; set; }
        }
       
        public JSONDataReader(string url,string parameters,string fileName)
        {
            SendRequest<Result>((Result, err) =>
            {
                if (err != null)
                    return;
                var imprese = Result.d.ListaImprese;
                //imprese contiene i dati estrappolati.


                Type type = typeof(Imprese);
                var properties = type.GetProperties();
                var names = properties.Select(s => s.Name);
                var header = string.Join(";", names);
                var sb = new StringBuilder(header);
                sb.Append(Environment.NewLine);
                foreach (var impresa in imprese)
                {
                    foreach (var name in names)
                    {
                        var pi = properties.Single(s => s.Name == name);
                        sb.Append(pi.GetValue(impresa));
                        sb.Append(";");
                    }
                    sb.Append(Environment.NewLine);
                }
                File.WriteAllText(fileName, sb.ToString());
            },
            url,
            parameters);
        }


        public static void SendRequest<T>(Action<T, Exception> action, string url, string objJson)
        {
            string responseString = string.Empty;
            byte[] byteArray = Encoding.UTF8.GetBytes(objJson);
            var request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/json";
            request.BeginGetRequestStream(new AsyncCallback((asynchronousResult) =>
            {
                HttpWebRequest req1 = (HttpWebRequest)asynchronousResult.AsyncState;
                Stream postStream = req1.EndGetRequestStream(asynchronousResult);
                postStream.Write(byteArray, 0, objJson.Length);
                postStream.Dispose();
                req1.BeginGetResponse(new AsyncCallback((asynchronousResult1) =>
                {
                    try
                    {
                        HttpWebRequest req2 = (HttpWebRequest)asynchronousResult1.AsyncState;
                        HttpWebResponse response = (HttpWebResponse)req2.EndGetResponse(asynchronousResult1);
                        Stream streamResponse = response.GetResponseStream();
                        StreamReader streamRead = new StreamReader(streamResponse);
                        responseString = streamRead.ReadToEnd();
                        T result = (T)Newtonsoft.Json.JsonConvert.DeserializeObject(responseString, typeof(T));
                        action(result, null);
                        streamResponse.Dispose();
                        streamRead.Dispose();
                        response.Dispose();
                    }
                    catch (WebException e)
                    {
                        action(default(T), e);
                    }


                }), request);
            }), request);
        }
    }

Questa classe recupera i dati delle imprese e crea un csv contenente i dati incolonnati. E la usi così:

new JSONDataReader(
                "http://www.albonazionalegestoriambientali.it/Services/GetRicerche.asmx/GetImpresePerSezioneProvincia",
                "{\"lang\":\"it\",\"siglaProvincia\":\"SS\",\"idRegione\":\"20\",\"includiCP\":\"false\",\"paginaCorrente\":\"1\",\"risultatiPerPagina\":\"50\"}",
                "test.csv");

Ciao U235, grazie davvero per la risposta molto professionale. Scusa l'ignoranza ma non conosco bene json. La classe da te postata la posso mettere direttamente in una pagina PHP (uso questo linguaggio)? grazie ancora

[U235]

Ciao U235, grazie davvero per la risposta molto professionale. Scusa l'ignoranza ma non conosco bene json. La classe da te postata la posso mettere direttamente in una pagina PHP (uso questo linguaggio)? grazie ancora

Buongiorno,
figurati...
purtroppo non avevo letto che non lo vuoi in asp.net, ed io non ti posso aiutare con il PHP. Infatti il codice che ho scritto funziona in asp.net.
Se poi tu hai uno spazio misto (win+linux o anche da qualche altra parte un win), potesti comunque mettere questo e chiamare con ajax le tue webapi da javascript (come nella pagina postata sotto (.html)), anche se usi php.

@djciko
a dire il vero hai ragione... il mio codice era un esempio, ma in effetti per farlo girare in asp.net andrebbe ritoccato.
Sperando di fare cosa gradita, anche se un po lunghetto, butto giù una bozza.

Il lavoro sarebbe: tuaPagina->chiamata ajax tuo server (webapi)->chiamata server remoto->elaborazione sul server->risultato alla tuaPagina

WebApi:

public class JSonReaderController : ApiController
    {
        string url = "http://www.albonazionalegestoriambientali.it/Services/GetRicerche.asmx/{0}";
        string parameters = "{\"lang\":\"it\",\"siglaProvincia\":\"SS\",\"idRegione\":\"20\",\"includiCP\":\"false\",\"paginaCorrente\":\"1\",\"risultatiPerPagina\":\"50\"}";


        [HttpGet]//restituisce un file .csv contenente le imprese (download, Imprese.csv) [/api/jsonreader/csv]
        public HttpResponseMessage CSV()
        {
            //imposto il tipo radice (RootImpresa) ricavato dal json (vedi in basso), l'url (formato da indirizzo + metodo che restitiusce il tipo specificato),
            //e i parametri necessari all'interrogazione (in base al metodo del sito remoto)
            //i parametri necessari si possono scoprire con fiddler, così come il metodo corretto da chiamare per avere i dati desiderati
            var res = Task.Run(() => JSonReader<RootImpresa>.GetItems(string.Format(url,"GetImpresePerSezioneProvincia"), parameters)).Result.d.ListaImprese;
            var properties = typeof(Impresa).GetProperties();
            var names = properties.Select(s => s.Name);
            var header = string.Join(";", names);
            var sb = new StringBuilder(header);
            sb.Append(Environment.NewLine);
            foreach (var impresa in res)
            {
                foreach (var property in properties)
                {
                    sb.Append(property.GetValue(impresa));
                    sb.Append(";");
                }
                sb.Append(Environment.NewLine);
            }
            var csv = sb.ToString();
            HttpResponseMessage result = new HttpResponseMessage(HttpStatusCode.OK);
            result.Content = new StringContent(csv);
            result.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
            result.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
            result.Content.Headers.ContentDisposition.FileName = "Imprese.csv";
            return result;
        }


        [HttpGet]//restituisce un json contenente le imprese [/api/jsonreader/Imprese]
        public IEnumerable<Impresa> Imprese()
        {
            //imposto il tipo radice (RootImpresa) ricavato dal json (vedi in basso), l'url (formato da indirizzo + metodo che restitiusce il tipo specificato),
            //e i parametri necessari all'interrogazione (in base al metodo del sito remoto)
            //i parametri necessari si possono scoprire con fiddler, così come il metodo corretto da chiamare per avere i dati desiderati
            return Task.Run(() => JSonReader<RootImpresa>.GetItems(string.Format(url, "GetImpresePerSezioneProvincia"), parameters)).Result.d.ListaImprese;
        }


        [HttpGet]//restituisce un json contenente le imprese [/api/jsonreader/Imprese]
        public IEnumerable<Categorielista> DettaglioImpresa(int id)
        {
            //imposto il tipo radice (RootDettaglio) ricavato dal json (vedi in basso), l'url (formato da indirizzo + metodo che restitiusce il tipo specificato),
            //e i parametri necessari all'interrogazione (in base al metodo del sito remoto). In questo caso varia l'id dell'impresa della quale 
            //si vuole visualizzare i dettagli
            //i parametri necessari si possono scoprire con fiddler, così come il metodo corretto da chiamare per avere i dati desiderati
            return Task.Run(() => JSonReader<RootDettaglio>.GetItems(string.Format(url, "GetImpresaDettaglioConsorzio"),
                "{\"lang\":\"it\",\"idImpresa\":\"" + id + "\"}")).Result.d.CategorieLista;
        }
    }
    public class JSonReader<T>
    {
        public async static Task<T> GetItems(string url, string parameters)
        {
            return await AsyncSendRequest(url, parameters);
        }
        public static async Task<T> AsyncSendRequest(string url, string parameters)
        {
            byte[] byteArray = Encoding.UTF8.GetBytes(parameters);
            var request = WebRequest.CreateHttp(url);
            request.Method = "POST";
            request.ContentType = "application/json";
            Stream postStream = request.GetRequestStream();
            postStream.Write(byteArray, 0, parameters.Length);
            postStream.Dispose();
            object state = null; 
            var task = Task<WebResponse>.Factory.FromAsync(
                request.BeginGetResponse,
                request.EndGetResponse,
                state);
            using (var response = (HttpWebResponse)(await task))
            {
                Stream streamResponse = response.GetResponseStream();
                StreamReader streamRead = new StreamReader(streamResponse);
                var responseString = streamRead.ReadToEnd();
                T result = (T)Newtonsoft.Json.JsonConvert.DeserializeObject(responseString, typeof(T));
                return result;
            }
        }
    }


    /******************************************************************************************************/
    //queste classi in basso sono generate automaticamente a partire dal json restituito dalle due chiamate:
    //http://www.albonazionalegestoriambientali.it/Services/GetRicerche.asmx/GetImpresePerSezioneProvincia
    //e
    //http://www.albonazionalegestoriambientali.it/Services/GetRicerche.asmx/GetImpresaDettaglioConsorzio/id 
    //da visual studio copiare il json e poi: menu modifica->incolla speciale->incolla json come classi
    public class RootImpresa
    {
        public ContainerImpresa d { get; set; }
    }


    public class ContainerImpresa
    {
        public string __type { get; set; }
        public int NumeroRecordTotali { get; set; }
        public Impresa[] ListaImprese { get; set; }
        public string NumeroRecordTotaliLabel { get; set; }
    }
    public class Impresa
    {
        public int Progressivo { get; set; }
        public int IdImpresa { get; set; }
        public string SiglaProvincia { get; set; }
        public string Comune { get; set; }
        public string Via { get; set; }
        public string Cap { get; set; }
        public string CodiceFiscale { get; set; }
        public string Denominazione { get; set; }
        public string Sezione { get; set; }
        public string Categorie { get; set; }
        public string ProvinciaIscrizione { get; set; }
        public string NumeroIscrizione { get; set; }
    }


    public class RootDettaglio
    {
        public D d { get; set; }
    }
    public class D
    {
        public string __type { get; set; }
        public object[] ListaImpreseConsorzio { get; set; }
        public string Cer { get; set; }
        public string Tipologie { get; set; }
        public string CerCP { get; set; }
        public bool HasCer { get; set; }
        public bool HasTipologie { get; set; }
        public bool HasCerCP { get; set; }
        public Categorielista[] CategorieLista { get; set; }
        public int IdImpresa { get; set; }
        public string SiglaProvincia { get; set; }
        public string Comune { get; set; }
        public string Via { get; set; }
        public string Cap { get; set; }
        public string CodiceFiscale { get; set; }
        public string Denominazione { get; set; }
        public string Sezione { get; set; }
        public string Categorie { get; set; }
        public string ProvinciaIscrizione { get; set; }
        public string NumeroIscrizione { get; set; }
    }
    public class Categorielista
    {
        public string SiglaCategoria { get; set; }
        public string TipoIscrizione { get; set; }
        public string Classe { get; set; }
        public string DataIscrizione { get; set; }
        public string DataScadenza { get; set; }
        public string Stato { get; set; }
        public string SospensioneCausale { get; set; }
        public string SospensioneDal { get; set; }
        public string SospensioneAl { get; set; }
        public string SottoCategoria { get; set; }
    }

come scritto nei commenti, le classi le ricavo semplicemente scaricando il json (anche dal browser), copiandolo e incollandolo come descritto da dentro visual studio.

A questo punto abbiamo le nostre webapi che rendono trasparenti le fonti dei dati sottostanti, e possiamo richiamarle come se i dati risiedessero sul server:

<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <title></title>
    <meta charset="utf-8" />
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
</head>
<body>
    <ul>
        <li><a href="/api/JSonReader/imprese">Lista imprese json</a></li>
        <li><a href="/api/JSonReader/CSV">download csv</a></li>
    </ul>
    <button onclick="Load()">Carica Imprese qui</button>
    <div id="list"></div>
    <script type="text/javascript">
       function Load()
       {
           var div = document.getElementById('list');
           div.innerHTML = "<br>Sto caricando";
           $.ajax({
               contentType: "application/json; charset=utf-8",
               url: '/api/JSonReader/imprese',
               type: 'GET',
               dataType: 'json',
               success: function (data, textStatus, xhr) {
                   div.innerHTML = "";
                   $.each(data, function (index, item) {
                       var button = document.createElement('button');
                       var ul = document.createElement('ul');                       
                       $.each(item, function (i, subItem) {
                           var li = document.createElement('li');                           
                           li.innerHTML = subItem;
                           ul.appendChild(li);
                       });
                       button.innerHTML = "Dettaglio";
                       button.addEventListener("click", function () { LoadDetails(item.IdImpresa) });
                       ul.appendChild(button);
                       div.appendChild(ul);
                   });
               },
               error: function (error, textStatus, errorThrown) {
                   alert(textStatus);
               }
           });
       }
       function LoadDetails(id) {
           var div = document.getElementById('list');
           div.innerHTML = "<br>Sto caricando";
           $.ajax({
               contentType: "application/json; charset=utf-8",
               url: '/api/JSonReader/DettaglioImpresa/'+id,
               type: 'GET',
               dataType: 'json',
               success: function (data, textStatus, xhr) {
                   div.innerHTML = "";
                   $.each(data, function (index, item) {
                       var ul = document.createElement('ul');
                       $.each(item, function (i, subItem) {
                           var li = document.createElement('li');
                           li.innerHTML = subItem;
                           ul.appendChild(li);
                       });
                       div.appendChild(ul);
                   });
               },
               error: function (error, textStatus, errorThrown) {
                   alert(textStatus);
               }
           });
       }
    </script>
</body>
</html>

in pratica possiamo trattare i dati come meglio vogliamo, la fonte interna si trova al di sotto delle nostre webapi. Possiamo creare e scaricare un file tramite il suo url (anche direttamente dal browser), impaginare ecc.

Spero sia utile a qualcuno che legge o leggerà questo post, anche se non risponde all'esigenza di luisa.