viernes, 26 de diciembre de 2014

Trabajando con bases de datos

Es muy seguro que en nuestros trabajos necesitemos conectarnos a una base de datos. En ésta sección veremos como:

  • Configurar una conexión a base de datos
  • Definir una clase Active Record (Registro Activo)
  • Realizar consultas usando la clase Active Record
  • Desplegar datos en una página a través de una vista

Preparando la base de datos

Yii nos permite trabajar con diferentes base de datos como SQLite, MySQL, PostgreSQL, MSSQL u Oracle.

Para nuestro ejemplo utilizaremos MySQL en el que crearemos una base de datos yii2basic y una tabla pais con algunos registros.

CREATE TABLE IF NOT EXISTS `pais` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nombre` varchar(50) NOT NULL,
  `codigo` varchar(3) NOT NULL,
  `poblacion` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Colombia','CO', 47846160);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Venezuela','VE', 31648930);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Argentina','AR', 42192500);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Ecuador','EC', 16013143);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Uruguay','UY', 3286314);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Paraguay','PY', 6672633);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Bolivia','BO', 10027254);
INSERT INTO `pais`(`nombre`, `codigo`, `poblacion`) VALUES ('Chile','CL', 17819054);



Configurar una conexión a base de datos

Por una lado, debemos habilitar las extensiones correspondientes a nuestra base de datos en la configuración de PHP. Para nuestro caso es php_mysqlphp_pdo_mysql.

Por otro lado, abrimos el archivo \config\db.php y cambiamos los parámetros de acuerdo a nuestra base de datos. En nuestro caso:

return [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=localhost;dbname=yii2basic',
    'username' => 'root',
    'password' => '',
    'charset' => 'utf8',
];

Para acceder a esta configuración en el código de nuestra aplicación lo podemos hacer con la expresión Yii::$app->db.

Creando el Active Record (Registro Activo)

Para representar y extraer los datos de la tabla pais, creamos una clase pais derivada de Active Record. El archivo en el cual guardamos es \models\Pais.php con el siguiente contenido:

<?php

namespace app\models;

use yii\db\ActiveRecord;

class Pais extends ActiveRecord
{
}

Este es todo el código que debemos escribir. No es necesario especificar el nombre de la tabla, ya que el nombre de la clase se asocia al nombre de la tabla.

Es posible sobreescribir el método yii\db\ActiveRecord::tableName()  para especificar de manera explícita el nombre de la tabla. El código sería algo similar a:

class Pais extends ActiveRecord
{
    public static function tableName()
    {
        return 'tbl_paises';
    }
}

Creando la Acción

Crearemos un controlador propio para nuestra tabla, y la acción index como la acción por defecto o que se ejecutará si no se especifica de manera explícitamente en la url. Creamos el archivo \controllers\PaisController.php con el siguiente contenido:

<?php

namespace app\controllers;

use yii\web\Controller;
use yii\data\Pagination;
use app\models\Pais;

class PaisController extends Controller
{
    public function actionIndex()
    {
        $query = Pais::find();

        $pagination = new Pagination([
            'defaultPageSize' => 5,
            'totalCount' => $query->count(),
        ]);

        $paises = $query->orderBy('nombre')
            ->offset($pagination->offset)
            ->limit($pagination->limit)
            ->all();

        return $this->render('index', [
            'paises' => $paises,
            'pagination' => $pagination,
        ]);
    }
}

Analicemos un poco el código.

Tenemos la llamada a Country::find() la cual recupera todos los datos de nuestra tabla. El límite de datos recuperados se realiza con ayuda del objeto yii\data\Pagination. El objeto Pagination tiene dos propósitos:
  1. Ajustar las cláusulas offset y limit de la consulta sql y recuperar un conjunto específico de datos. En nuestro ejemplo, páginas de 5 registros cada una.
  2. Desplegar de manera consistente los botones de paginación en nuestra vista.
Al final, se retorna la vista index con los datos de los países y la información de la paginación.

Creando la vista

Bajo el directorio views, crearemos un subdirectorio de nombre pais. En este subdirectorio se guardarán todas las vistas utilizadas en nuestro controlador. Creamos el archivo \views\pais\index.php con el siguiente código:

<?php
use yii\helpers\Html;
use yii\widgets\LinkPager;
?>
<h1>Países</h1>
<ul>
<?php foreach ($paises as $pais): ?>
    <li>
        <?= Html::encode("{$pais->nombre} ({$pais->codigo})") ?>:
        <?= $pais->poblacion ?>
    </li>
<?php endforeach; ?>
</ul>

<?= LinkPager::widget(['pagination' => $pagination]) ?>

La vista tiene dos secciones. La primera, que toma los datos de los países y los presenta como una lista HTML con viñetas (unordered); y la segunda, el widget yii\widgets\LinkPager para mostrar los botones de paginación.

Probando

Para probar el resultado de nuestro trabajo podemos en nuestro navegador web escribir la url:
http://hostname/index.php?r=pais/index

El resultado será similar al siguiente:



Sugerencias


  • Al crear nuestra base de datos, es bueno definir una conexión (cotejamiento) del tipo utf8.
  • Nuestros archivos deben ser grabados como UTF-8 sin BOM.



También te puede interesar:
DAO - Database Access Objects (Objetos de acceso a base de datos)
Generador de Consultas (Query Builder)
Active Record (Registro Activo)

jueves, 25 de diciembre de 2014

Configurando el lenguaje

Si hemos revisado la entrada Formularios en Yii 2, habremos notado que los mensajes se presentan en inglés. Algo lógico puesto que el lenguaje por defecto es el inglés.

En una aplicación Yii se definen dos lenguajes: el lenguaje fuente y el lenguaje objetivo.

El lenguaje fuente es el lenguaje original de la aplicación; los mensajes son directamente escritos como:

echo \Yii::t('app', 'Soy un mensaje cualquiera!');

El lenguaje objetivo es el lenguaje que debería ser usado para desplegar una determinada página, como por ejemplo el lenguaje al que deben traducirse los mensajes originales. El lenguaje objetivo se configura en el archivo

\basic\config\web.php

especificando el lenguaje en el que queremos mostrar los mensajes

$config = [
    'id' => 'basic',
    'basePath' => dirname(__DIR__),
    'language' => 'es',
    'bootstrap' => ['log'],
    'components' => [
...

El lenguaje también puede ser especificado en tiempo de ejecución. Se lo debe realizar antes de generar cualquier salida para que tenga el efecto deseado. Para lograrlo, basta con cambiar la propiedad de la aplicación al valor deseado de la siguiente manera:

\Yii::$app->language = 'es';

El formato del lenguaje/lugar es ll-cc donde:

  • ll es un código de 2 o 3 letras de acuerdo a ISO-639
  • cc es el código del país de acuerdo a ISO-3166

Como podemos notar en nuestro ejemplo, podemos indicar únicamente el lenguaje.

Los mensaje de validación de nuestro formulario visto en la entrada anterior, configurando la aplicación al español, se verán como en la siguiente imagen:




También te puede interesar:
Formularios en Yii 2

domingo, 7 de diciembre de 2014

Formularios en Yii 2

Crearemos un formulario sencillo mediante el cual podemos recolectar información de los usuarios. El objetivo es aprender a crear las vistas, una acción, y  por supuesto un modelo.

Para nuestro ejemplo, crearemos un formulario en el que usuario deba ingresar su nombre y correo, ambos de manera obligatoria. Y nos basaremos en nuestra aplicación basic.

Creando un modelo 

Nuestro modelo se llamará IngresoFormulario y crearemos el archivo de nombre /models/IngresoFormulario.php con el siguiente código:

<?php

namespace app\models;

use yii\base\Model;

class IngresoFormulario extends Model
{
    public $nombre;
    public $correo;

    public function rules()
    {
        return [
            [['nombre', 'correo'], 'required'],
            ['correo', 'email'],
        ];
    }
}

?> 

Analicemos un poco el código...

La clase IngresoFormulario se extiende de yii\base\Model, la cual es provista por Yii y se utiliza comúnmente para representar datos de un formulario.

  • yii\base\Model se utiliza para modelos que no están asociados con tablas de bases de datos.
  • yii\db\ActiveRecord es la clase normalmente utilizada cuando se trata de una correspondencia con un tabla de base de datos.

Nuestra clase tiene dos variables públicas, nombre y correo que se utilizarán para almacenar los datos ingresados por el usuario. También tenemos un método llamado rules(), el cual tiene las reglas de validación. Para nuestro caso las reglas son:

  • nombre y  correo son datos necesarios u obligatorios.
  • correo debe ser una dirección de correo válida, por eso se lo valida como del tipo email.


Creando la Acción

En nuestro controlador /controllers/SiteController.php crearemos una acción de nombre Ingreso. El código nos queda de la siguiente manera:

public function actionIngreso()
{
$model = new IngresoFormulario;

if ($model->load(Yii::$app->request->post()) && $model->validate()) {
// Valida los datos recibidos en $model

// Se puede manipular los datos de $model

return $this->render('confirmar-ingreso', ['model' => $model]);
} else {
// Se despliega la pagina inicial o si hay un error de validacion
return $this->render('ingreso', ['model' => $model]);
}
}

Analicemos un poco el código...

En primer lugar, se crea un objeto llamado IngresoFormulario. Se proceden a poblar el modelo con los datos provenientes de $_POST. Si el modelo se pobla exitosamente, se llama a validate() para asegurar que los datos son válidos.

La expresión Yii::$app representa la instancia de la aplicación, la cual es globalmente accessible. También provee componentes como request, response, db entre otros. En nuestro código se utiliza request para acceder a los datos $_POST.

Si todo es correcto, se devuelve la vista confirmar-ingreso. Si no se han recibido datos o se produjo un error, la vista ingreso es la devuelta junto con cualquier mensaje de error que pudo haberse producido.

En nuestro controlador Site es muy importante especificar que se va a utilizar el modelo IngresoFormulario. Para ello añadimos:

<?php

namespace app\controllers;

use Yii;
use yii\filters\AccessControl;
use yii\web\Controller;
use yii\filters\VerbFilter;
use app\models\LoginForm;
use app\models\ContactForm;
use app\models\IngresoFormulario;

class SiteController extends Controller
{

Creando las Vistas

Como habremos notado, nuestro controlador utiliza dos vistas. Una para recibir los datos, y otra para confirmar la recepción.

Para nuestro formulario, creamos un archivo /views/site/ingreso.php con el siguiente código:

<?php
use yii\helpers\Html;
use yii\widgets\ActiveForm;
?>
<?php $form = ActiveForm::begin(); ?>

    <?= $form->field($model, 'nombre') ?>

    <?= $form->field($model, 'correo') ?>

    <div class="form-group">
        <?= Html::submitButton('Enviar', ['class' => 'btn btn-primary']) ?>
    </div>

<?php ActiveForm::end(); ?>

Analicemos un poco el código...

Se utiliza un widget llamado ActiveForm para construir el formulario HTML. Los métodos begin() y end() generan los tags de apertura y cierre del formulario. Entre estos métodos, se utiliza el método field() para generar los campos del formulario. Por último, el helper  Html::submitButton nos permite generar el botón submit.

La otra vista es más sencilla. Creamos el archivo /views/site/confirmar-ingreso.php con el siguiente código:

<?php
use yii\helpers\Html;
?>
<p>Usted ha ingresado la siguiente informacion:</p>

<ul>
    <li><label>Nombre</label>: <?= Html::encode($model->nombre) ?></li>
    <li><label>Correo</label>: <?= Html::encode($model->correo) ?></li>
</ul>

En ésta segunda vista, sencillamente presentamos la información que fue ingresada a través del formulario.

Probando

Para revisar nuestro trabajo, accedemos a través de nuestro navegador web utilizando la URL
http://127.0.0.1/projects/basic/web/index.php?r=site/ingreso

Veremos una página como la siguiente.



Si ingresamos los datos del formulario correctamente y presionamos el botón Enviar, veremos algo similar a:



Si llenamos de manera incorrecta el formulario, se realizarán las validaciones correspondientes (por ahora se mostrarán los mensajes en inglés)



Explicación

Si realizamos diferentes pruebas con nuestro formulario, podemos notar su comportamiento. Por un lado, si hacemos clic en el un campo, y luego en el otro, veremos automáticamente el mensaje de que el campo no puede quedar en blanco. Esto se debe a que se realizan validaciones desde el lado del cliente mediante JavaScript. Si enviamos nuestro formulario, se realiza una segunda validación, pero esta vez en el lado del servidor. Obviamente, si deshabilitamos JavaScript en nuestro navegador web, las validaciones siempre se harán únicamente del lado del servidor.

Por otro lado,podemos notar que las etiquetas se generan automáticamente. El nombre del campo se utiliza como etiqueta del mismo, por lo que es una buena sugerencia utilizar nombres descriptivos y claros para nuestros campos. Claro está que si queremos nuestras propias etiquetas podemos utilizar un código similar al siguiente:

<?= $form->field($model, 'nombre')->label('Nombres y Apellidos') ?>
<?= $form->field($model, 'correo')->label('Correo electrónico') ?>


También te puede interesar:
Instalando Yii 2
Hola mundo!




sábado, 29 de noviembre de 2014

Hola mundo!

En muchas ocasiones, cuando empezados a realizar nuestra primera aplicación en algún lenguaje de programación, nos enseñan a mostrar un texto muy básico... El mítico Hola Mundo!

En este caso, en nuestra aplicación vamos a crear una nueva página llamada "hola", por lo que tendremos que crear una vista y un controlador que realicen:
  • la aplicación despachará la página solicitada a la acción
  • y la acción devolverá la vista con el mensaje "Hola mundo!"

Creando la Acción

Crearemos una acción llamada decir que recibirá un parámetro de nombre mensaje. El mensaje recibido en el parámetro será el que se muestre. Si no se recibe ningún valor, se desplegará por defecto Hola Mundo! 

Si hemos trabajado antes con Yii en su versión 1, recordaremos que los controladores agrupan a las acciones. Por ahora, utilizaremos unos de los controladores ya existentes, el SiteController.

Localizamos el archivo
basic/controllers/SiteController.php
y añadimos el siguiente código:

    public function actionDecir($mensaje 'Hola Mundo!')
    {
        return $this->render('decir', ['mensaje' => $mensaje]);
    }

Dentro de nuestra clase de controlador SiteController hemos añadido la acción decir como un método de nombre actionDecir. Al igual que en la versión 1, Yii utiliza el prefijo action para cada identificador de las acciones.

El código en si mismo no es difícil de comprenderlo. Recibimos el parámetro mensaje cuyo valor por defecto es Hola Mundo!

El método render() devuelve la vista decir, a la cual le pasa el parámetro mensaje para que pueda ser utilizado por la misma.

Cuando demos nombre a nuestras acciones, debemos entender cómo trata Yii a los identificadores de las acciones. Un identificador de acción siempre es referenciado en minúsculas. Si se requiere de múltiples palabras, se debe separar con guiones (por ejemplo, crear-comentario). Los nombres de los métodos de las acciones son mapeados removiendo todos los guiones, colocando en mayúscula la primera letra de cada palabra y añadiendo el prefijo action. Por ejemplo, la acción crear-comentario se corresponde con el método actionCrearComentario.

Creando la Vista

Las vistas son escritas para generar el contenido de respuesta.

Continuando con nuestro ejercicio, crearemos el archivo
views/site/decir.php
con el siguiente contenido:

<?phpuse yii\helpers\Html;?>
<?= Html::encode($mensaje?>

Hay que notar que utilizamos Html::encode antes de mostrar el mensaje. Esto es necesario porque el parámetro proviene de un usuario final, y se puede sufrir de un ataque cross-site scripting (XSS) al recibir código malicioso JavaScript en el parámetro.

Obviamente podemos añadir código adicional a nuestra vista, como texto plano, código PHP, tags HTML.

Probando

Escribiendo la url http://hostname/index.php?r=site/decir obtenemos un resultado como el siguiente:




En este caso no hemos pasado el parámetro mensaje y se ha mostrado el texto por defecto. Pero si escribimos algo como http://hostname/index.php?r=site/decir&mensaje=Mi+propio+mensaje se presenta algo similar a ésta imagen:



Hasta aquí hemos dado un vistazo a lo que es MVC, aunque en éste ejemplo no hemos utilizado un modelo. Conforme avancemos iremos profundizando en todos estos temas.


También te puede interesar:
Instalando Yii 2
Funcionamiento y Arquitectura de Yii 2
Trabajando con bases de datos

Funcionamiento y Arquitectura de Yii 2

Como hemos visto, luego de instalar Yii accedemos a nuestra aplicación a través de la url http://hostname/basic/web/index.php o http://hostname/index.php, dependiendo de la configuración de nuestro servidor. Recordemos que en este caso, basic es el nombre de nuestra aplicación.

Funcionalidad

Al instalar Yii 2, nuestra aplicación básica tiene cuatro páginas:
  1. La página de inicio
  2. La página "About" (Acerca de)
  3. La página "Contact" (Contacto) que despliga un formulario de contacto.
  4. La página "Login" (Ingreso) que permite ingresar nuestro nombre de usuario y clave.
Éstas paginas comparten una cabecera y un pie de página. La cabecera contiene un menú principal que permite navegar entre las diferentes páginas.

Hasta aquí, se parece mucho a la versión 1.

En ésta nueva versión, en la parte inferior del navegador tenemos una barra de herramientas con información útil que nos permite depurar nuestra aplicación. Podemos ver mensajes, estatus, consultas a la base en ejecución, y más.

Estructura de la aplicación

Como habíamos mencionado, basic es el nombre de nuestra aplicación. Partiendo de éste directorio, nuestra estructura de directorios y archivos sería:

basic/                  directorio principal de la aplicación
    composer.json       usado por Composer, información del paquete
    config/             contiene configuraciones
        console.php     configuración de la consola de aplicaciones
        web.php         configuración de la aplicación web
    commands/           contiene clases de la consola de comandos
    controllers/        contiene los controladores
    models/             contiene los modelos
    runtime/            contiene archivos generados por Yii durante                           el tiempo de ejecución, como archivos logs                            y de caché
    vendor/             contiene paquetes instalados por Composer,                            incluyendo el framework Yii en sí mismo
    views/              contiene las vistas
    web/                raíz de la nuestra aplicación Web,                                    contiene los archivos accesibles
        assets/         contiene archivos publicados por Yii                                  (javascript y css)
        index.php       script de entrada a la aplicación (bootstrap)
    yii                 script de ejecución de la                                             consola de comandos  Yii

En general, los archivos pueden ser divididos en dos tipos:  los que están bajo el directorio basic/web y los que están en otro directorios. A los primeros se puede acceder vía HTTP (un navegador web), mientras que los segundos no pueden y no deberían ser accesibles.

Al igual que en la versión 1, Yii implementa el patrón de diseño Modelo-Vista-Controlador (MVC). El siguiente diagrama muestra la estructura estática de una aplicación.



Cada aplicación tiene un script de entrada web/index.php que debe ser el único accesible. El script de entrada toma la petición de entrada y crea una instancia de la aplicación. La aplicación resuelve la petición con ayuda de sus componentes, y despacha la petición a los elementos MVC. Los widgest son utilizados en las vistas para ayudar a construir interfaces de usuario más complejas y dinámicas.

Ciclo de vida de una petición

Al realizar una petición se siguen los siguientes pasos:

  1. Un usuario realiza una petición a través del script de entrada web/index.php
  2. El script de entrada llama a la configuración de la aplicación y crea una instancia de la aplicación que maneje la petición.
  3. La aplicación resuelve la petición con ayuda de sus componentes.
  4. La aplicación crea una instancia de controlador para manejar la petición.
  5. La aplicación crea una instancia de acción y ejecuta los filtros para la acción.
  6. Si cualquier filtro falla, la acción es cancelada.
  7. Si todos los filtros pasan, la acción es ejecutada.
  8. La acción llama a un modelo, posiblemente de base de datos.
  9. La acción devuelve (renderiza) una vista, junto con el modelo de datos.
  10. El resultado proveído (renderizado) se devuelve al componente de aplicación de respuesta.
  11. El componente de respuesta envía el resultado proveído (renderizado) al navegador del usuario.

La siguiente imagen describe gráficamente éstos pasos.



También te puede interesar:
Instalando Yii 2
Configurando el servidor web
Yii Framework 2

Configurando el servidor web

Después de instalar Yii, podemos acceder a través de la url http://hostname/basic/web/index.php pero seguramente queremos que la url de acceso sea similar a http://hostname/index.php. Para ello, debemos realizar la configuración de manera que el documento raíz apunte al directorio basic/web. Recordemos que basic es el nombre de nuestro proyecto. También podemos necesitar ocultar el archivo index.php

Al configurar la ruta basic/web como la raíz, también prevenimos que los usuarios finales accedan al código privado de nuestra aplicación y archivos sensibles. El negar el acceso a éste directorio es una mejora de seguridad.

Si estamos ejecutando nuestra aplicación en un ambiente de hosting compartido y no tenemos permiso para modificar la configuración del servidor web, debemos considerar ajustar la estructura de nuestra aplicación para tener una mejor seguridad. En la entrada Ambiente de hosting compartido tendremos más detalles. (próximamente).

Configuración Apache recomendada

Modificando el archivo httpd.conf de Apache podemos cambiar la manera de acceder a nuestra aplicación.

En este archivo, debemos buscar  DocumentRoot (que no esté comentado con #) y actualizar el path al nuestro apuntando a basic/web.

En mi caso, localmente utilizo EasyPHP 14.1. Modifiqué
DocumentRoot "${path}/data/localweb"
por
DocumentRoot "${path}/data/localweb/projects/basic/web"

También hay un añadir un tag <Directory> con el siguiente contenido:
<Directory "${path}/data/localweb/projects/basic/web">
    # use mod_rewrite for pretty URL support
    RewriteEngine on
    # If a directory or a file exists, use the request directly
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteCond %{REQUEST_FILENAME} !-d
    # Otherwise forward the request to index.php
    RewriteRule . index.php
</Directory>

Es posible que tengamos que modificar VirtualHost que también tiene DocumentRoot y Directory. Solo hay que actualizarlos con el path apuntando a nuestro directorio basic/web.
Nos queda algo similar a lo siguiente:
<VirtualHost 127.0.0.1>
DocumentRoot "${path}/data/localweb/projects/basic/web"
ServerName 127.0.0.1
<Directory "${path}/data/localweb/projects/basic/web">
Options FollowSymLinks Indexes
AllowOverride All
Order deny,allow
Allow from 127.0.0.1
Deny from all
Require all granted
</Directory>
</VirtualHost>



También te puede interesar:
Instalando Yii 2
Funcionamiento y Arquitectura de Yii 2
Yii Framework 2

domingo, 23 de noviembre de 2014

Instalando Yii 2

Se puede instalar Yii 2, de dos maneras diferentes. Utilizando Composer o por descarga. La primera es la preferida, ya que permite instalar extensiones o actualizaciones con un simple comando.

Instalación usando Composer

Desde el siguiente link se puede descargar tanto para Linux, Mac OS X o Windows: descargar composer.
En dicha página constan los comandos y opciones para Linux. O el enlace de descarga para el ejecutable en el caso de Windows. También hay los correspondientes manuales.

En Windows, descargamos el archivo Composer-Setup.exe y ejecutamos el instalador siguiendo las instrucciones.



Uno de los problemas que tuve, es que Composer valida que la extensión OpenSSL de PHP esté habilitada. Si tienen el mismo error se les presentará un mensaje de error que dice:
Some settings on your machine make Composer unable to work properly.
Make sure that you fix the issues listed below and run this script again:
The openssl extension is missing, which means that secure HTTPS transfers are impossible.
If possible you should enable it or recompile php with --with-openssl

No es difícil corregirlo. Solo hay que retroceder un paso, activar la extensión php_openssl.dll en el archivo de configuración de PHP (php.ini) y volver a intentar la instalación. Esta vez no habrá problemas.

Por otro lado, necesitamos una cuenta en GitHub. Es gratuito.

Luego debemos abrirnos una ventana de consola (cmd), e ir al directorio en el cual queremos instalar nuestra aplicación Yii, el cual debe ser accesible desde nuestro servidor web.

Ejecutamos el comando:
composer global require "fxp/composer-asset-plugin:1.0.0-beta3"



Este comando lo hay que ejecutar una sola vez, el cual instala el plugin que permite administrar las dependencias a través de Composer.

Luego, ejecutamos el siguiente comando:
composer create-project --prefer-dist yiisoft/yii2-app-basic basic
Este comando lo utilizamos para instalar Yii en un directorio llamado basic. Si queremos otro directorio, debemos escribir el adecuado a nuestras necesidades.


Cuando nos solicite el username y el password debemos utilizar los de nuestra cuenta de GitHub.

También es posible tener la última versión de desarrollo de Yii. Recordemos que la versión de desarrollo no debe ser utilizada en producción, o nuestros ambientes definitivos. Solo debe ser utilizada para pruebas. El comando que debemos seguir es el siguiente:
composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic

Verificando la instalación

Después de haber realizado estos pasos, podemos ir a nuestro navegador web para probar. Escribimos la dirección similar a la siguiente:

http://127.0.0.1/projects/basic/web/

donde:
127.0.0.1 es mi servidor web, que en este caso estoy trabajando de forma local en mi computadora.
projects es el directorio en el cual se alojan mis proyectos y depende del servidor web que utilicemos. En otros casos suele ser www. O en otros casos no requiere.
basic es el directorio en el cual está nuestra aplicación y es el que especificamos anteriormente como basic
web es el subdirectorio de yii desde el cual se inicia la aplicación.

Si todo es correcto, veremos una pantalla como la de la imagen:


Posibles errores en la instalación de Yii 2

A pesar de haber realizado los pasos tal cual se describen aquí, es posible que obtengamos algún error como el siguiente:

Warning: require(D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web/../vendor/autoload.php): failed to open stream: No such file or directory in D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web\index.php on line 7

Fatal error: require(): Failed opening required 'D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web/../vendor/autoload.php' (include_path='.;C:\php\pear') in D:\Archivos de programa\EasyPHP-DevServer-14.1VC9\data\localweb\projects\yii2\basic\web\index.php on line 7

En este caso hay que revisar que tengamos el archivo autoload.php; y es muy probable que no le tengamos. Simplemente hay que borrar todos los archivos y el directorio en el cual íbamos a instalar yii y repetir nuestro segundo comando (el primero ya no es necesario), es decir:
composer create-project --prefer-dist --stability=dev yiisoft/yii2-app-basic basic

Durante la instalación debemos ver que descarga varios paquetes al 100%.



Luego podemos volver a probar a través de nuestro navegador web.

Instalando desde un archivo

También se puede instalar Yii 2 desde un archivo y para ello hay que seguir estos pasos:

  1. Descargar el archivo desde el sitio web de Yii Framework.
  2. Descomprimir el archivo descargado en una directorio web accesible.
  3. Modificar el archivo config/web.php ingresando una clave secreta para la configuración de cookieValidationKey (Utilizando Composer, esto es automático)

// !!! insert a secret key in the following (if it is empty) - this is required by cookie validation'cookieValidationKey' => 'enter your secret key here',
Nuestra clave secreta la debemos escribir en lugar de enter your secret key here


Otras opciones de instalación

Las formas de instalación vistas nos ayudan a tener un esqueleto de nuestra aplicación web, útil para aprender Yii 2 o proyectos pequeños. Otras opciones disponibles que se pueden considerar son:

  • Si se requiere instalar el framework completo (el core o núcleo) y construir una aplicación completa desde cero, se pueden seguir las instrucciones de la entrada La construcción de aplicaciones desde cero (próximamente).
  • Si se necesita iniciar con una aplicación más sofisticada, más adecuada a equipos en ambientes de desarrollo, se puede revisar la entrada Plantilla de aplicación avanzada (próximamente).


Revisando requerimientos

Si durante la verificación de la instalación no se presenta la página de "Congratulations" se debe revisar que se cumplen con los requisitos mínimos para el funcionamiento de Yii.

Se puede acceder a la URL http://127.0.0.1/projects/basic/requirements.php en la cual se nos presentará una pantalla con todos los detalles. Los requisitos que se cumplen y los que fallan; así como la conclusión.



Otra manera es ejecutar el comando:

cd basic
php requirements.php


Lo más importante es que por lo menos sea la versión de PHP 5.4 la que utilizamos. Y habilitar la extensión PDO y el correspondiente driver de la base de datos que vayamos a utilizar (si vamos a utilizar una).

Instalando Yii 2 en producción

Como habremos notado, hay un subdirectorio llamado web que debemos añadir en nuestra dirección url si queremos acceder a nuestro archivo index.php y toda nuestra aplicación. Seguramente, en nuestro ambiente de producción ya no queremos que aparezca este subdirectorio, incluso tal vez sea nuestra intención ocultar el archivo index.php. El cómo instalar Yii 2 en producción lo podemos revisar en Configurando el servidor web



También te puede interesar:
Yii Framework 2
Configurando el servidor web

martes, 18 de noviembre de 2014

Actualizando Yii desde la versión 1 (Parte II)

Como habíamos mencionado anteriormente, las diferencias entre las versiones 1 y 2 son algunas, ya que la versión 2 ha sido totalmente reescrita. Así que actualizar desde la versión 1 no es algo trivial. Continuando con las diferencias tenemos:

Aplicaciones de Consola

Las aplicaciones de consola ahora están organizadas como controladores, como una aplicación web. Los controladores de consola se extienden  yii\console\Controller, similar a CConsoleCommand de la versión 1.

Para ejecutar un comando de consola se utiliza yii <route>, where <route> es la ruta de un controlador (ejemplo: sitemap/index)

 I18N

Yii 2 deja de lado todo el formato de fechas y números incorporados en favor del paquete  PECL intl PHP.

La traducción de mensajes ahora se realiza a través del componente i18n. Este componente administra un conjunto de mensajes fuente, que permite usar diferentes mensajes distribuidos en categorías.

Filtros de Acción  

Los filtros de acción (los filtros que definíamos en el controlador), ahora se implementan a través de los comportamientos (behaviors). Para definir uno nuevo, se extiende de yii\base\ActionFilter. Por ejemplo, para utilizar el filtro yii\filters\AccessControl se debe escribir el siguiente código en un controlador.

public function behaviors()
{
    return [
        'access' => [
            'class' => 'yii\filters\AccessControl',
            'rules' => [
                ['allow' => true'actions' => ['admin'], 'roles' => ['@']],
            ],
        ],
    ];
}

Assets

Yii 2 introduce un nuevo concepto llamado asset bundle que reemplaza el concepto de paquetes de script de la versión 1.

Un asset bundle es un conjunto de archivos (por ejemplo: archivos JavaScript, hojas de estilo CSS, imágenes) dentro de un directorio. Cada asset bundle se representa como una clase que se extiende de yii\web\AssetBundle. Se registra vía yii\web\AssetBundle::register().

Helpers

Yii 2 introduce algunas de las clases helper (asistentes) comúnmente utilizadas, incluyendo:

  • yii\helpers\Html
  • yii\helpers\ArrayHelper
  • yii\helpers\StringHelper
  • yii\helpers\FileHelper
  • yii\helpers\Json


Formularios

Yii 2 introduce el concepto de field (campo) para construir un formulario utilizando yii\widgets\ActiveForm. Un field es un contenedor compuesto de una etiqueta, una entrada, un mensaje de error y/o un texto de indicio (hint). Un formulario se puede construir más limpiamente, algo similar a:

<?php $form yii\widgets\ActiveForm::begin(); ?>
    <?= $form->field($model'username'?>
    <?= $form->field($model'password')->passwordInput() ?>
    <div class="form-group">
        <?= Html::submitButton('Login'?>
    </div>
<?php yii\widgets\ActiveForm::end(); ?>


Query Builder (Constructor de Consultas)

En la versión 1 utilizábamos una serie de clases para construir nuestras sentencias, que incluía el uso de  CDbCommand, CDbCriteria, y CDbCommandBuilder. Yii 2 representa una consulta en términos de un objeto Query. Por ejemplo:

$query = new \yii\db\Query();
$query->select('id, name')
      ->from('user')
      ->limit(10);
$command $query->createCommand();
$sql $command->sql;
$rows $command->queryAll();

Active Record (Registro Activo)

Yii 2 introduce muchos cambios a nivel del Registro Activo. Los más obvios es el Query Builder y el manejo de consultas relacionadas. En la versión 1 la clase utilizada era CDbCriteria. En ésta nueva versión se utiliza yii\db\ActiveQuery la cual es una extensión de yii\db\Query. Una consulta sería:

$customers Customer::find()
    ->where(['status' => $active])
    ->orderBy('id')
    ->all();

Para declarar una relación, se define un método que retorne un objeto tipo ActiveQuery . Por ejemplo:

class Customer extends \yii\db\ActiveRecord{
    public function getOrders()
    {
        return $this->hasMany('Order', ['customer_id' => 'id']);
    }
}

De esta manera se puede utilizar  $customer->orders para acceder a las órdenes de compra de un cliente. También se puede usar el siguiente código para realizar una consulta relacionada condicionada:

$orders $customer->getOrders()->andWhere('status=1')->all();

En general, la manera de ejecutar las consultas no es muy diferente, aunque en Yii 2 se optimiza la manera de obtener los resultados con el fin de reducir significativamente el tiempo de CPU y la memoria, especialmente con una gran cantidad de registros, como por ejemplo al ejecutar:

$customers Customer::find()->asArray()->all();

Otro cambio es que no se puede definir un valor por defecto de los atributos a través de las propiedades públicas. Para poder realizar ésto, se lo debe hacer en el método init.

public function init()
{
    parent::init();
    $this->status self::STATUS_NEW;
}

Algunos problemas de la versión 1 al sobreescribir el constructor ya no se encuentran en la versión 2. Otros cambios y mejoras se las verá en entradas posteriores.

Active Record Behaviors (Comportamiento del Registro Activo)

La clase CActiveRecordBehavior ha sido eliminada en la versión 2. Para crear un Active Record Behavior, hay que extenderlo directamente de yii\base\Behavior. Si el behavior necesita responder a un evento en particular, hay que sobreescribir el método events(). Por ejemplo:

namespace app\components;

use yii\db\ActiveRecord;
use yii\base\Behavior;

class MyBehavior extends Behavior{
    // ...

    public function events()
    {
        return [
            ActiveRecord::EVENT_BEFORE_VALIDATE => 'beforeValidate',
        ];
    }

    public function beforeValidate($event)
    {
        // ...
    } 
}

Usuarios e Interfaces de Identidad

La clase CWebUser utilizada en la versión 1, es reemplazada por yii\web\User, y ya no hay la clase CUserIdentity. Ahora se debe implementar yii\web\IdentityInterface que es mucho más sencillo de usar. Las plantillas proveen un ejemplo, aunque conforme avancemos en la revisión de ésta versión, en las entradas se irá viendo acerca de Autentificación, Autorización y Técnicas de Aplicaciones Avanzadas.

Administración de URL

El administrador de URLs de la versión 2 es similar al de la versión 1. Una mejora es que ahora soporta parámetros. Por ejemplo, se puede tener una regla que hace coincidir post/popular con post/1/popular. En la versión 1 se requiere de dos reglas para este objetivo, mientras que en la nueva versión quedaría algo como lo siguiente:

[
    'pattern' => 'post/<page:\d+>/<tag>',
    'route' => 'post/index',
    'defaults' => ['page' => 1],
]


También te puede interesar:
Actualizando Yii desde la versión 1 (Parte I)