Ayuda Laravel

json

Novedades en Laravel 5.3

por 2 comentarios

Framework Laravel 5.3
Coincidiendo con la conferencia Laracon en Europa, ha sido publicada la versión de Laravel 5.3 y trae con ella muchas novedades tanto a nivel de código, como en forma de paquetes adicionales para añadir funcionalidad específica.

A continuación vamos a dar un rápido vistazo a las novedades, aunque algunas de ellas las trataremos más en profundidad en futuros posts.

[Leer más…] acerca de Novedades en Laravel 5.3

Crear una aplicación con Lumen – parte 2

por Deja un comentario

Una vez realizada la configuración inicial, pasamos a añadir la funcionalidad de nuestra aplicación.

Primero debemos definir la ruta a la que debemos llamar para obtener nuestro resultado en nuestro caso la ruta será:

PHP
1
http://localhost:8000/weather

Editamos el archivo app/Http/routes.php y añadimos la ruta:

PHP
1
2
$app->get('/weather', 'WeatherController@getWeather');
 

Aquí estamos definiendo la url /weather y ejecutará la función getWeather de controlador WeatherController.

Ahora que ya tenemos la ruta definida, pasamos a crear el controlador WeatherController.

Creamos el archivo app/Http/Controllers/WeatherController.php con el contenido.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
<?php
 
namespace App\Http\Controllers;
 
class WeatherController extends Controller
{
    public function getWeather()
    {
        return "get Weather";
    }
}
 

Definimos WeatherController con la función getWeather, hacemos que extienda de Controller.

Para seguir, debemos pensar qué tipo de respuesta queremos obtener. En nuestro caso queremos un json con los datos de temperatura, probabilidad de lluvia, estado del cielo, un modelo sería:

PHP
1
2
3
4
5
6
7
8
{
  "weather": {
    "temperature": 0,
    "skyState": 0,
    "rainfall": 0
  }
}
 

Por ahora vamos a modificar nuestra función para que devuelva un json fijo, y cuando creemos nuestro Service Provider modificaremos la función.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
public function getWeather()
{
    $weatherResponse = [
        "weather" => [
            "temperature" => 0,
            "skyState" => 0,
            "rainfall" => 0
        ]
    ];
 
    return response()->json($weatherResponse);
}
 

A continuación crearemos nuestro service provider que obtendrá el XML de Aemet y lo parseará.

Como esto conectará a un servicio externo, y podría pasar que más adelante quisiéramos cambiar de servicio, o añadir otro servicio de meteorología, lo mejor será crear un interface para asegurarnos que si algún día añadimos otro proveedor, este servicio cumpla el mismo protocolo, y no tengamos que modificar nuestro controlador para adecuarse al nuevo proveedor.
Primero definiremos nuestro interface, que en caso de Laravel 5 ha pasado a llamarse Contracts así que creamos el archivo app/Contracts/Weather.php.

PHP
1
2
3
4
5
6
7
8
9
10
<?php
 
namespace App\Contracts;
 
interface Weather
{
    public function url($url);
    public function get($query);
}
 

Aquí hemos definido nuestro “Contrato” con dos funciones, una para establecer la url para obtener el xml, y otra para obtener los datos que nos interesan.

Ahora ya podemos crear nuestra implementación particular, para Aemet que implemente nuestro interface. Así que creamos el archivo app\Services\AemetWeather.php y le añadimos las dos funciones del interface que debemos implementar.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php
 
namespace App\Services;
 
use App\Contracts\Weather;
 
class AemetWeather implements Weather
{
    public function url($url)
    {    
    }
 
    public function get($query)
    {    
    }
}
 

Ahora nos queda asignar que cuando se necesite una instancia de Weather, esta se resuelva a AemetWeather. Para hacer esto podemos crear un Service Provider para Weather, o como en este caso sólo utilizaremos uno, podemos declararlo en app\Providers\AppServiceProvider.php.

En la función register añadimos:

PHP
1
2
3
4
$this->app->singleton(Weather::class, function($app) {
    return new AemetWeather();
});
 

Aquí estamos diciendo a Lumen que cuando se necesite una instancia de Weather, cree y devuelva una instancia de AemetWeather.

Ahora en nuestro controlador podemos inyectar nuestra clase Weather, y modificar la función para que establezca la url, y haga las llamadas correspondientes.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace App\Http\Controllers;
 
use App\Contracts\Weather;
 
class WeatherController extends Controller
{
    public function getWeather(Weather $weather)
    {
        $weather->url('http://www.aemet.es/xml/municipios/localidad_08019.xml');
 
        $weatherResponse = [
            "weather" => [
                "temperature" => $weather->get('temperature'),
                "skyState" => $weather->get('skyState'),
                "rainfall" => $weather->get('rainfall')
            ]
        ];
 
        return response()->json($weatherResponse);
    }
}
 

Por último nos queda la llamada y parseo del xml. Editamos el archivo app\Services\AemetWeather.php

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
<?php
 
namespace App\Services;
 
use App\Contracts\Weather;
 
class AemetWeather implements Weather
{
    protected $contentXML;
 
    /**
     * Establecemos la url de consulta
     * @param  string $url URL del webservice
     * @return App\Services\AemetWeather
     */
    public function url($url)
    {
        $this->contentXML = simplexml_load_file($url);
 
        return $this;
    }
 
    public function get($query)
    {
        switch ($query) {
            case 'rainfall':
                return $this->getRainfall();
                break;
            case 'skyState':
                return $this->getSkyState();
                break;
            case 'temperature':
                return $this->getTemperature();
                break;
        }
        return false;  
    }
 
    /**
     * Obtenemos la probabilidad de precipitación
     * @return int
     */
    protected function getRainfall()
    {
        return intval($this->contentXML->prediccion->dia[0]->prob_precipitacion[0]);
    }
 
    /**
     * Obtenemos el estado del cielo
     * @return string
     */
    protected function getSkyState()
    {
        $cielo = $this->contentXML->prediccion->dia[0]->estado_cielo[0];
        $sig = 0;
        while ($cielo == "") {
            $sig=$sig+1;
            $cielo = $this->contentXML->prediccion->dia[0]->estado_cielo[$sig];
        }
        return (string)$cielo;
    }
 
    /**
     * Obtenemos la temperatura
     * @return int
     */
    protected function getTemperature()
    {
        // Horario de verano
        $daylight_in_seconds = timezone_offset_get( timezone_open( "Europe/Madrid" ),
                                                    new \DateTime() );
        // Diferencia horaria
        $offset = $daylight_in_seconds/3600;
        // Hora actual
        $hour = date("H")+$offset;
 
        // Periodo segun la hora
        $p = 0;
        if (($hour > 6) && ($hour <= 12)) $p = 1;
        if (($hour > 12) && ($hour <= 18)) $p = 2;
        if ($hour > 18) $p = 3;
 
        return intval($this->contentXML->prediccion->dia[0]->temperatura->dato[$p]);
    }
}
 

Con esto ya obtenemos el json que hemos definido anteriormente después de parsear el XML que obtenemos desde Aemet.

PHP
1
2
3
4
5
6
7
8
{
  "weather": {
    "temperature": 24,
    "skyState": "11",
    "rainfall": 5
  }
}
 

Si además queremos cachear el contenido del webservice para no hacer las consultas constantemente, podemos modificar la función url de AemetWeather para que Cachee el XML por 10 minutos.

PHP
1
2
3
4
5
6
7
8
9
10
11
12
13
use Illuminate\Support\Facades\Cache;
 
public function url($url)
{
    $content = Cache::remember('AemetContent', 10, function() use ($url) {
        return file_get_contents($url);
    });
 
    $this->contentXML = simplexml_load_string($content);
 
    return $this;
}
 

Esto nos dará un error, porque debemos habilitar el uso de Facades en Lumen, que por defecto viene desactivado. Editamos el archivo bootstrap/app.php y descomentamos la línea:

PHP
1
2
$app->withFacades();
 

En el archivo .env modificamos los claves CACHE_DRIVER, SESSION_DRIVER para que utilice el driver file en vez de memcached.

Con eso ya tenemos la aplicación Lumen lista para subir a producción. Hay cosas que se pueden mejorar o hacer de otra manera, pero este es una pincelada de cómo podemos utilizar Lumen para hacer pequeñas aplicaciones.

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información.plugin cookies

ACEPTAR
Aviso de cookies