Mostrando entradas con la etiqueta web. Mostrar todas las entradas
Mostrando entradas con la etiqueta web. Mostrar todas las entradas

viernes, 6 de febrero de 2015

Consumir un WebService JSON desde JavaScript con Ajax

En muchas ocasiones se nos hace necesario, desde una página HTML, realizar la llamada a un webservice para obtener una serie de resultados. Una buena forma de conseguir esto es utilizar Ajax. Existen múltiples formas de realizar la llamada, y en este post indicaremos simplemente una de ellas. Espero que os sea de utilidad.
<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Test consumir WebService</title>
  <script src="http://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>

  <script type="text/javascript">
    // Procesar resultados del webservice
    function webServiceResult(data)
    {
      $("#resultado_json").empty();    

      $("#resultado_json").append("Nombre: "+data.name+"<br>");
      $("#resultado_json").append("Pais: "+data.sys.country+"<br>");
      $("#resultado_json").append("Longitud: "+data.coord.lon+"<br>");
      $("#resultado_json").append("Latitud: "+data.coord.lat+"<br>");
      $("#resultado_json").append("Tiempo: "+data.weather[0].main+"<br>");
      $("#resultado_json").append("&nbsp;&nbsp;"+data.weather[0].description+"<br>");
      $("#resultado_json").append("Humedad: "+data.main.humidity+"<br>");
      var tmin = Math.round(10*(data.main.temp_min -273.15)) / 10;
      var tmax = Math.round(10*(data.main.temp_max -273.15)) / 10 ;
      $("#resultado_json").append("Temp. minima: "+tmin+"<br>");
      $("#resultado_json").append("Temp. maxima: "+tmax+"<br>");
    }
      
    // Llamada al webservice
    function callWebService()
    {
      try
      { 
        $.ajax({
          url: "http://api.openweathermap.org/data/2.5/weather",
          data:
          {
              q: "Cordoba,es",
          },
          type: "get",
          async: true,
          contentType: "text/json; charset=utf-8",
          dataType: "jsonp",        
          success: function(msg) { webServiceResult(msg) },
          error: function(jqXmlHttpRequest, textStatus, errorThrown) { alert("Error leyendo datos."); }
        });
      } 
      catch (err) 
      {
        alert(err);
      }
    }
  </script>
  
</head>

<body>

<button type="button" onclick="javascript:callWebService();">Llamar a WS</button>

<div id="resultado_json"></div>

</body>
</html>
Un ejemplo más elaborado, e incluso cargando los datos a consultar desde un fichero JSON, se puede consultar aqui.

Consumir un WebService XML desde .NET

En esta entrada publicamos una función que nos permite consumir un webservice XML y pasarlo a un DataTable, de forma que podamos trabajar con los datos de manera muy sencilla. La función es la siguiente:
Public Shared Function GetDataTable_WebServiceXML(opcion As String, listaParametros As String) As Data.DataTable
  Try
    Dim url As String = "http://url.com/WebService.asmx/GetOpcion"
    url += "?nombre=" + opcion + "&parametros=" + listaParametros

    Dim request As HttpWebRequest
    Dim response As HttpWebResponse = Nothing
    Dim ds As New Data.DataSet

    request = DirectCast(WebRequest.Create(url), HttpWebRequest)
    response = DirectCast(request.GetResponse(), HttpWebResponse)
    ds.ReadXml(response.GetResponseStream())

    If ds.Tables.Count > 0 Then
      Return ds.Tables(0)
    Else
      Return New Data.DataTable
    End If

  Catch ex As Exception
    Throw New Exception(ex.Message)
  End Try
End Function
Con el código de esta pequeña función, obtendremos un datatable con los resultados obtenidos. Si fuera necesario podríamos modificarla para devolver un DataSet o directamente el contenido del XML.

Registros de SQL hacia XML/JSON

Nuestra aplicación de gestión en la empresa está desarrollada en .NET y utilizando base de datos SQL Server. Se trata de una aplicación de escritorio, y debido a ciertas necesidades, hemos construido un WebService para hacer disponibles ciertos datos desde el exterior, para que sean consumidos por la web de eCliente y por varias apps.

Hemos configurado el webservice para que devuelva los datos en el formato deseado, XML o JSON, así quien lo consuma podrá elegir cómo quiere los datos. En eCliente utilizamos .NET, por lo que se hace más sencillo obtener los resultados en un XML (directamente creamos un DataSet a partir de él se hace mucho más fácil su gestión), y en las apps lo consumimos con JSON.

En ambos casos nos hemos encontrado con un problema: tenemos registros que tienen caracteres que, bien hacen que se rompan el XML, o bien el HTML, debido a que contienen caracteres no permitidos para estos formatos.

Para evitar este problema, hemos creado una función escalar en SQL Server que nos reemplaza los caracteres no deseados para que el XML/JSON sea correcto. La función es la siguiente:
USE [BaseDatos]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE FUNCTION [dbo].[CampoToHTML] (@texto varchar(256)) returns varchar(max)
begin
   declare @resul varchar(max)
   set @resul = @texto
   set @resul = REPLACE(@resul, char(34), char(39))
   set @resul = REPLACE(@resul, 'ñ' COLLATE Latin1_General_CS_AS,'n')
   set @resul = REPLACE(@resul, 'á' COLLATE Latin1_General_CS_AS,'a')
   set @resul = REPLACE(@resul, 'é' COLLATE Latin1_General_CS_AS,'e')
   set @resul = REPLACE(@resul, 'í' COLLATE Latin1_General_CS_AS,'i')
   set @resul = REPLACE(@resul, 'ó' COLLATE Latin1_General_CS_AS,'o' )
   set @resul = REPLACE(@resul, 'ú' COLLATE Latin1_General_CS_AS,'u')
   set @resul = REPLACE(@resul, 'Ñ' COLLATE Latin1_General_CS_AS,'N')
   set @resul = REPLACE(@resul, 'Á' COLLATE Latin1_General_CS_AS,'A')
   set @resul = REPLACE(@resul, 'É' COLLATE Latin1_General_CS_AS,'E')
   set @resul = REPLACE(@resul, 'Í' COLLATE Latin1_General_CS_AS,'I')
   set @resul = REPLACE(@resul, 'Ó' COLLATE Latin1_General_CS_AS,'O')
   set @resul = REPLACE(@resul, 'Ú' COLLATE Latin1_General_CS_AS,'U')
   set @resul = REPLACE(@resul, '&' COLLATE Latin1_General_CS_AS,'y')
   return @resul
END
De esta forma, la consulta SQL la haríamos de la siguiente forma:
SELECT id,dbo.CampoToHTML(apellidos) FROM Clientes
Esto es todo.

Consumir un webservice desde PHP (XML/JSON)

Cuando trabajamos con PHP, es muy habitual encontrarnos con la necesidad de realizar la llamada a un webservice para obtener una serie de resultados para después trabajar con ellos. Existen múltiples formas de conseguir esto, y en este post vamos a mostrar dos posibilidades muy sencillas para conseguirlo. Mostraremos dos ejemplos, uno que recibe los resultados en formato XML y otro en formato JSON. Una vez recibidos los resultados, recorremos la información obtenida para mostrarla por pantalla.

Si el webservice devuelve resultados en XML
<?php
  // Llamada al WebService
  $client = new SoapClient("http://www.webservicex.net/country.asmx?WSDL");
  $result = $client->GetCountries();
  $xml = $result->GetCountriesResult;

  // procesar xml
  $xml = simplexml_load_string($xml);
  foreach($xml->Table as $table) 
  {
    $output .= "<p>$table->Name</p>";
  }
  print_r($output);
?>

Si el webservice devuelve resultados en JSON
<?php
// Función para llamar al webservice y devolver el resultado en un array
function callWebService($method)
{
  $url ='http://api.geonames.org/citiesJSON?north=44.1&south=-9.9&east=-22.4&west=55.2&lang=de&username=demo';
  $json = file_get_contents($url);
  $array = json_decode($json,true);
  return $array;
}
Esa misma función puede optimizarse en una sóla línea:
function callWebService($method)
{
  return json_decode(file_get_contents('http://api.geonames.org/citiesJSON?north=44.1&south=-9.9&east=-22.4&west=55.2&lang=de&username=demo'),true);;
}
La llamada podría se la siguiente:
$resul = callWebService();
foreach($resul['geonames'] as $city)
{
    $cities .= '<p>'.$city['name'].'</p>';    
}
print_r ($cities);

Espero os sea de utilidad. Si deseas obtener más información, puedes consultar la documentación de php.

domingo, 1 de febrero de 2015

Plugins para Sublime Text

Si trabajos con SublimeText, éste puede extenderse con plugins para hacernos la vida más fácil. En este post hablaremos de dos plugins muy interesantes.

Para poder instalar estos plugins, haremos uso de "Package control". Tenemos las instrucciones de instalación en esta página. Básicamente abrimos la consola de SublimeText (View-Show console) y pegamos el texto que se nos indica en la página de instalación. Reiniciamos SublimeText y ya tenemos instalado este plugin.

SublimeCodeIntel (intellisense)
Este plugin sirve para que cuando vamos escribiendo (según el lenguaje en el que estemos programando), SublimeText nos vaya mostrando las distintas posibilidades existentes (digamos que es un auto-completar para nuestro código fuente, al estilo de VisualStudio). Por ejemplo, si estamos editando un CSS, y dentro de body escribimos b, se nos sugiere una lista de posibles valores que empiezan por la letra b (background,bottom, border,...). Conforme vayamos escribiendo, se nos irá filtrando la lista a las posibilidades que tenemos. De esta manera, además de ahorrar tiempo, evitaremos errores de escritura y nos evita tener que aprender de memoria todas las posibilidades.


El plugin se llama SublimeCodeIntel,y su instalación es muy sencilla:
  • Abrir SublimeText y ejecutar la paleta de comandos (Ctrl+Mayus+P).
  • Seleccionar "Package control: Install Package"
  • En la lista resultante, seleccionar SublimeCodeIntel. Esperamos a que se instale y reiniciamos SublimeText.
La ventaja de este método es que siempre obtendremos la última versión del plugin. Más información sobre este plugin se puede encontrar en su página oficial.

Emmet
Emmet es un plugin para crear estructuras html con muy pocas pulsaciones de teclado. Para ello se siguen una serie de reglas que se pueden consultar en la página oficial.

Su instalación se consigue, una vez instalado Package Control como se indica más arriba, mediante los siguientes sencillos pasos:
  • Abrir SublimeText y ejecutar la paleta de comandos (Ctrl+Mayus+P).
  • Seleccionar "Package control: Install Package"
  • En la lista resultante, seleccionar Emmet. Esperamos a que se instale y reiniciamos SublimeText.
Esto es todo.

sábado, 31 de enero de 2015

Página web que se ve pequeña en movil

Cuando hacemos una web, y esta se ve muy pequeña en un teléfono móvil, se debe que los navegadores de los móviles entienden por defecto que la página está realizada para verse en monitores más grandes, por lo que escalan su contenido. Esto obliga a tener que hacer zoom para poder ver correctamente la página.

Para evitar este efecto, HTML5 dispone de la etiqueta viewport. Para que la web se vea correctamente en un dispositivo más pequeño que un monitor, se debe de incluir dentro del head de la página la siguiente etiqueta:
<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
Los valores posibles del atributo content, son los siguientes:

width: Ancho en píxeles o device-width para coger el ancho de la pantalla.
height: Alto en píxeles o device-height para coger el alto de la pantalla.
user-scalable: (yes o no) Si el usuario puede o no hacer zoom.
initial-scale: (0.0 a 10.0) Escala a usar la primera vez que se cargue la página web. Para no usar escalado: 1.0.
minimum-scale: (0.0 a 10.0) Escala mínima a la que el usuario puede llegar al hacer zoom.
maximum-scale: (0.0 a 10.0) Escala máxima a la que el usuario puede llegar al hacer zoom.

Se puede encontrar más información en la siguiente página.

miércoles, 28 de enero de 2015

Formulario de contacto en Blogger en página independiente

Para añadir un formulario de contacto a una página creada en Blogger que no sea la principal, hay que seguir los siguientes pasos.

Ir a Diseño, y en cualquier lugar, seleccionar Añadir un gadget

Seleccionar el gadget Formulario de contacto. Si no se encuentra, pulsar en la segunda opción, Más gadgets.

Una vez añadido, ir a Plantilla - Editar HTML.

Buscar el texto ContactForm. Pulsar sobre la flecha negra de la izquierda para desplegarlo, y se observará un código como el siguiente:
<b:widget id='ContactForm1' locked='false' title='Contacta' type='ContactForm'>
    <b:includable id='main'>
  <b:if cond='data:title != &quot;&quot;'>
    <h2 class='title'><data:title/></h2>
  </b:if>
  <div class='contact-form-widget'>
    <div class='form'>
      <form name='contact-form'>
        <p/>
        <data:contactFormNameMsg/>
        BLA, BLA, BLA
        <p/>
        <div style='text-align: center; max-width: 222px; width: 100%'>
          <p class='contact-form-error-message' expr:id='data:widget.instanceId + &quot;_contact-form-error-message&quot;'/>
          <p class='contact-form-success-message' expr:id='data:widget.instanceId + &quot;_contact-form-success-message&quot;'/>
        </div>
      </form>
    </div>
  </div>
  <b:include name='quickedit'/>
</b:includable>
</b:widget>
Del código anterior, se debe eliminar todo excepto las dos primeras y las dos últimas líneas.

Ahora, ir a la página donde se desea añadir el formulario de contacto, y en la edición HTML incluir esto:
<div class='widget ContactForm' id='ContactForm1'>
  <div class='contact-form-widget'>
    <div class='form'>
      <form name='contact-form'>
        <p>Nombre<p>
        <input class='contact-form-name' id='ContactForm1_contact-form-name' name='name' size='30' type='text' value=''/>
        <p>Correo electrónico *</p>
        <input class='contact-form-email' id='ContactForm1_contact-form-email' name='email' size='30' type='text' value=''/>
        <p>Mensaje *</p>
        <textarea class='contact-form-email-message' cols='25' id='ContactForm1_contact-form-email-message' name='email-message' rows='5'></textarea>
        <input class='contact-form-button contact-form-button-submit' id='ContactForm1_contact-form-submit' type='button' value='Enviar'/>
        <p class='contact-form-error-message' id='ContactForm1_contact-form-error-message'></p>
        <p class='contact-form-success-message' id='ContactForm1_contact-form-success-message'></p>
      </form>
    </div>
  </div>
</div>
Eso es todo.

Mostrar código fuente en Blogger

Para formatear el código fuente de una entrada se puede utilizar SyntaxHighlighter. El resultado es muy bueno, pero el rendimiento es bastante pobre. Otra forma para conseguir código con formato para tu blog, es usar google-code-prettify. Se instala muy fácilmente siguiendo esto pasos:
  • Entrar en el blog 
  • Ir a Diseño->Edición HTML
  • Buscar el cierre del head, </head> y justo arriba pegar el siguiente código:
  • <script src="
    https://google-code-prettify.googlecode.com/svn/loader/run_prettify.js">
    </script>
  • También puede descargarse el módulo completo desde aquí y usar esto:
    <link href="prettify.css" type="text/css" rel="stylesheet" />
    <script type="text/javascript" src="prettify.js"></script>
  • Guardar los cambios

Así, cuando se escriba una entrada nueva, en la edición HTML, debe encerrarse el código con estos tags:

<pre class="prettyprint">
  código fuente aquí
</pre>

Más información sobre el google-code-prettify puede encontrarse pulsando aquí.

miércoles, 6 de octubre de 2010

eCliente

Uno de los proyectos que debemos acometer en estos tiempos es la creación de una web de eCliente para la consulta de nuestros datos por parte de los clientes.

Inicialmente se acometió el desarrollo utilizando ASP.NET y una base de datos SQL Server online con la que sincronizábamos los datos deseados desde nuestra aplicación local. Un servicio subía todas las noches los datos que queríamos hacer públicos a la base de datos de Internet, que era la que utilizaba la aplicación web.

Con el paso del tiempo hicimos una mejora sustancial de la web, montando un servidor web y construyendo un webservice (.NET) en nuestras instalaciones. Este webservice conectaba con nuestra base de datos y devolvía los resultados, tanto en formato XML como JSON. Esto permitió modificar la web y hacerla mucho más simple. Ahora la web no accedía a datos, sino que hacía llamadas al webservice, teniendo la información en tiempo real. De paso nos ahorramos unos euros de SQL en el servidor Web y procesos de sincronización de información.


 

Copyright @ 2015 Tosblama