Symfony_Fixtures

Creación de Exámenes Prueba a través de fixtures

Los fixtures son extensiones de archivos que se requieren para llenar con datos de prueba una tabla con la arquitectura de datos que se da por las entidades de symfony… Regularme y en otros frameworks se genera SQL con el fin de rellenar los datos, pero no es tan fácil compartirlos con otros desarrolladores y no queda registro entero sobre el código del sistema. Sigue leyendo

violin-516023_960_720

Hola Mundo !! en Symfony 2

violin-516023_960_720

Realizó: Omar Leonardo Zambrano. Miembro Activo GLUD. Documento distribuido bajo licencia GNU Free Documentation License 1.3

Hola.

A continuación podrás encontrar un primer mini tutorial del uso de symfony, con un ejemplo básico y clásico como el ¡Hola Mundo!.

Objetivo. Acercarse al manejo del framework de PHP symfony

Symfony_Logo

Nota: Este tutorial no entrara en detalles de cada uno de las herramientas utilizadas y su significado. Ya que se quiere mostrar a traves de un ejemplo, uno de los mecanismos de routing o enrutamiento de paginas en symfony 2.

  • Creación del proyecto ¡hola mundo!

El primer paso a llevar a cabo es construir nuestro proyecto, el cual lo podemos hacer a través de la construcción de un bundle, para lo cual ejecutaremos en la consola de nuestro equipo la siguiente instrucción:

$ php app/console generate:bundle –namespace=Acme/HelloBundle –format=yml

Con la cual se crea un directorio dentro de nuestra carpeta principal de symfony:

/src/Acme/HelloBundle

Direct

El cual contiene todos los archivos de nuestro proyecto, adicionalmente , de forma automática se ha registrado nuestro proyecto en el núcleo del proyecto principal, esto es en el archivo /app/Appkernel.php

AppKernel

  • Creando la ruta:

El proyecto principal gestiona sus rutas de enrutamiento a través del archivo /app/config/routing.yml.Sin embargo este archivo se actualiza a través de la importación de la información de cada subproyecto desde los gestores de rutas de cada proyecto, tal gestor se encuentra en la dirección: /scr/Acme/HelloBundle/Resources/Config/routing.yml. 

Este archivo tiene la siguiente estructura:

Routing

En el cual se puede el nombre del proyecto corresponde a la primera linea del archivo, la segunda corresponde a la direccion URL del proyecto; la tercera linea corresponde a un array llamado defaults que especifica el controlador a ejecutar. Cabe resaltar que en la definicion de path se agredo {name} el cual cumple la función de comodin, que se entiende como que cualquier valor dado redirigirá a la misma ubicación de proyecto.

  • El controlador

En este momento hemos terminado el proceso de routing de nuestro proyecto sin embargo no tal enrutamiento no gestiona el consumo de ningun controlador por lo cual no sera posible visualizar el efecto del trabajo desarrollado. Por lo cual procedemos a realizar un controlador que ejecute alguna tarea para que se pueda ver el funcionamiento:

Procedemos a realizar un controlador, el cual lo ubicaremos: /scr/Acme/HelloBundle/Controller:

Controller

El cual es la estructura básica de un controlador en PHP que da como resultado un objecto tipo respuesta para Sympony, se puede ver en la imagen anterior que la función indexAction retorno un objeto tipo html donde se muestra en pantalla la frase “Hello” mas el valor de la variable name.  Ya por ultimo es necesario indicar en el método de enrutamineto cual es el controlador que va hacer utilizado, por lo cual es necesario modificar el archivo routing.yml de la siguiente manera:

RoutingF

En donde podemos observar que se le indica el nombre del proyecto, el nombre del controlador y la función a ejecutar cada vez que se direccione a tal URL, y a continuación el resultado final:

Resultado

Referencias:

http://gitnacho.github.io/symfony-docs-es/book/page_creation.html

https://librosweb.es/libro/symfony_2_x/capitulo_4/antes_de_empezar_crea_el_bundle.html

Symfony_Install

Tutorial para instalación y configuración de Symfony

Licencia Creative Commons
Tutorial para instalación y configuración de Symfony por el Grupo GNU Linux de la Universidad Distrital FJC se distribuye bajo una Licencia Creative Commons Atribución 4.0 Internacional.

PRIMER CAFÉ

Utilizaremos una herramienta en línea de comandos para la transferencia de archivos llamada curl, si no la has instalado en tu vida, abre la consola de comandos y ejecutemos lo siguiente:

$ sudo apt-get install curl
$ sudo apt-get install php5-curl 

Tras cualquier cambio en PHP o MySQL es necesario reiniciar el servidor ejecutando:

$ sudo service apache2 restart 

De esta manera, estaríamos listos para transferir los archivos del instalador de symfony a nuestra maquina ejecutando los siguientes comandos en terminal:

$ sudo curl -LsS https://symfony.com/installer -o /usr/local/bin/symfony

Asignamos permisos de escritura al siguiente fichero:

$ sudo chmod a+x /usr/local/bin/symfony

Creamos nuestro proyecto:

$ sudo symfony new miProyectoDemo

Con el comando anterior, el instalador entenderá que desarrollaremos con la ultima versión disponible de Symfony. Ya si lo que se desea es una versión en especifico, debes añadir la versión como parámetro al comando, estos son algunos ejemplos:

# Usa una versión estable
$ symfony new my_project_name 2.8
$ symfony new my_project_name 3.0

# Usa una versión especifica
$ symfony new my_project_name 2.7.3
$ symfony new my_project_name 2.8.1

# Usa una versión Beta
$ symfony new my_project 3.0.0-BETA1

installSymfony

Al finalizar instalación, nos aparece un mensaje donde se sugiere enviar el paquete del nuevo proyecto, al fichero que por defecto está conectado a nuestro localhost, en mi caso ejecute la instalación directamente en /var/www/html/ pero en dado caso que no, podrias probar moviendo tu proyecto con:

$ sudo mv miProyectoDemo /var/www/html -Rf

Procedemos a crear la base de datos para nuestro proyecto con la siguiente linea de codigo:

$ sudo php app/console doctrine:database:create

Podrías verificar que la base de datos symfony fue creada, ingresando a mysql desde terminal:

$ mysql -uroot -p
         mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| symfony            |
+--------------------+

mysql> exit
Bye

Procedemos a configurar nuestra aplicación editando el archivo parameters.yml ubicado en el fichero app/config/ para lo cual podrias usar el editor de texto que deseen, en mi caso, usaré VIM, para añadir el puerto por defecto de las BD en mysql, el nombre de la BD, su usuario y la clave.

$ vim app/config/parameters.yml

# This file is auto-generated during the composer install
parameters:
 database_host: 127.0.0.1
 database_port: 3306
 database_name: symfony
 database_user: root
 database_password: 11223344
 mailer_transport: smtp
 mailer_host: 127.0.0.1
 mailer_user: null
 mailer_password: null
 secret: 95d8d17bccea019bc3e6a33b2405c543bf7a2198

Ahora, desde el fichero raiz de nuestro proyecto ejecutaremos el siguiente comando para la levantar la consola de Symfony en nuestro localhost:

$ cd miProyectoDemo/

Para versiones de symfony 3
$ php bin/console server:run

Para versiones de symfony 2
$ php app/console server:run

Nos dirigimos a nuestro navegador y escribimos en el browser localhost:8000 arrojando la vista por default del framework

symfony28

Symfony aprovecha el servidor web interno proporcionado por PHP para ejecutar aplicaciones. Por lo tanto, ejecutar una aplicación de Symfony es cuestión de navegar por el directorio del proyecto.

Para comprobar esto, crearemos nuestro primer Bundle con la siguiente linea de comando

 $ php app/console generate:bundle 

Cuando las cosas se pongan interesantes, tendremos que crear varios Bundle’s asignandoles un nombre de la siguiente manera por ejemplo

$ php app/console generate:bundle --bundle-name=EVA_Bunlde

En Consola nos aparecerán algunas preguntas como ¿Está pensando en compartir este paquete a través de múltiples aplicaciones?, asigna un nombre al bundle, elija el fichero donde se creará el Bundle y que formato desea emplear para la configuración.

En otro post, dejaremos todo bien detallado, solo sigue los hilos del grupo de trabajo GNU Linux de la Universidad Distrital, exitos en la busqueda de nuevos conocimientos…

eva

 

Symfony_Form

Formularios en Symfony

Genere una nueva entidad dentro del bundle, se crea el directorio Entity y luego el archivo Task.php dentro de este.

O de manera más fácil, genere la entidad automáticamente con:

$ php app/console generate:doctrine:entity

Esta opción debe contar con la conexión a base de datos.

The Entity shortcut name: AppBundle:Formulario


New field name (press <return> to stop adding fields): task
Field type [string]: text
Is nullable [false]: 
Unique [false]: 

New field name (press <return> to stop adding fields): dueDate
Field type [string]: date
Is nullable [false]: 
Unique [false]:

Agregue una nueva acción a la clase del bundle donde desee el formulario:

//Importante el use
use AppBundle\Entity\Formulario;
//Tal vez necesites el request.

   /**
     * @Route("/glud", name="glud")
     */
    public function newAction(Request $request)
    {
        // crea una task y le asigna algunos datos ficticios para este ejemplo
        $formulario = new Formulario();
        $formulario->setTask('Write a blog post');
        $formulario->setDueDate(new \DateTime('tomorrow'));

        $form = $this->createFormBuilder($formulario)
            ->add('task', 'text')
            ->add('dueDate', 'date')
            ->add('save', 'submit')
            ->getForm();

        return $this->render('default/new.html.twig', array(
            'form' => $form->createView(),
        ));
    }

Crear una plantilla que visualice el formulario. Se puede crear en la ubicación app/Resources/views/default/new.html.twig y dentro de esta poner:

{{ form(form) }}

Se puede iniciar el servidor con symfony con el comando:

$ php app/console server:run 0.0.0.0:8000

Al realizar esto se puede acceder a la ruta:

http://localhost:8000/glud

Y con esto se puede observar el formuario.

Screenshot at 2016-05-19 15:11:29

Muchas gracias, espero que a alguien le sirva.

Grupo GNU/Linux Universidad Distrital FJC

doctrine

DOCTRINE: Mis primeros pasos

En este post aprenderemos a realizar configuraciones básicas de nuestras bases de datos utilizando DOCTRINE, pero…. ¿Que es Doctrine?

DOCTRINE es el hogar de varias bibliotecas de PHP las cuales se centraron principalmente en el almacenamiento de base de datos,pero… ¿porque utilizar DOCTRINE? 

Sabemos que uno de los problemas mas comunes en el desarrollo web es la comunicación de este con una base de datos, ya que se tiene que escribir y leer datos de forma continua, el objetivo de DOCTRINE es ofrecer herramientas poderosas para poder realizar este fin y lograr el manejo de bases de datos de forma fácil.

Lo primero que se debe hacer es la creación de un proyecto en symfony, todos los pasos para realizar el proyecto esta en este post Instalación Symfony.

Doctrine utiliza unos parámetros básicos, los cuales están en el archivo parameters.yml el cual se encuentra en app/config/parameters.yml en este se encuentran los parámetros con los cuales se genera la conexión con la base de datos, así que debemos verificar que el archivo contenga la información correcta y de no ser así modificar su contenido.

$nano app/config/parameters.yml

# This file is auto-generated during the composer install
parameters:
    database_host: 127.0.0.1     
    database_port: 3306            #Puerto genérico de la base de datos
    database_name: ejemploDT       #Nombre de la base de datos
    database_user: root            #Usuario de mysql
    database_password: admin       #Contraseña de mysql
    mailer_transport: smtp
    mailer_host: 127.0.0.1
    mailer_user: null
    mailer_password: null
    secret: ThisTokenIsNotSoSecretChangeIt

Para saber el puerto de nuestra base de datos podemos buscarla en el archivo de configuración de mysql el cual se encuentra en /etc/mysql/my.cnf

 Esta es la salida de el archivo en cuestión, debemos verificar el contenido de este para que DOCTRINE funcione correctamente.

Luego de esto podemos iniciar a utilizar DOCTRINE, para crear una base de datos simplemente utilizamos el siguiente comando:

$ php app/console doctrine:database:create

Y se creara la base de datos con los parámetros establecidos en el archivo anteriormente mencionado.  Para verificar esto podemos mirar que bases de datos tenemos, esto lo hacemos entrando a mysql:

$ mysql -h localhost -u root -p

luego  nos pedirá nuestra contraseña de mysql, se debe tener en cuenta que el usuario de mysql puede variar, esto depende de si el usuario dejo o no el nombre por defecto, de tener otro nombre cambiamos “root” por el nombre de usuario que corresponda.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| drupal8            |
| ejemploDT          |
| symfony            |
+--------------------+

Como podemos ver se creo nuestra base de datos llamada “ejemploDT

Para evitar errores futuros agregamos algunas lineas al archivo de configuración de mysql para modificar la base de datos para que sea UTF8

 $ sudo nano /etc/mysql/my.cnf

Y agregamos las siguientes lineas:

[mysqld]
# Version 5.5.3 introduced "utf8mb4", which is recommended
collation-server     = utf8mb4_general_ci # Replaces utf8_general_ci
character-set-server = utf8mb4            # Replaces utf8

Para iniciar el trabajo en nuestra base de datos creamos una entidad, DOCTRINE nos simplifica esto con el siguiente comando:

 $ php app/console doctrine:generate:entity

Luego de esto solo debemos agregarle un nombre y los campos que deseemos.

El nombre debe ser de la forma: AppBundle:Ejemplo

Por simple curiosidad podemos mirar los archivos generado por DOCTRINE, los cuales se encuentran en la carpeta de nuestro proyecto /src/AppBundle/Entity

$ nano src/AppBundle/Entity/Ejemplo.php

En este archivo podemos encontrar todas los campos que agregamos con DOCTRINE; Ahora debemos crear los captadores y definidores [getName(), setName()] los cuales nos permiten interactuar con las propiedades de nuestra entidad.

$ php app/console doctrine:generate:entities AppBundle/Entity/Ejemplo

Ahora tenemos una clase Ejemplo utilizable ya que con los pasos anteriores DOCTRINE sabe exactamente trabajar con ella.

En nuestra base de datos aún no tenemos la tabla correspondiente a Ejemplo para generarla procedemos a generarla utilizando el siguiente comando:

$ php app/console doctrine:schema:update --force

Este comando nos da como arroja las siguientes lineas:

Updating database schema…
Database schema updated successfully! “3” queries were executed

A simple vista se ve que DOCTRINE realizo los cambios correspondientes en nuestra base de datos agregando los campos que le dimos a nuestra entidad, en este caso realizo 3 columnas.

Para mirar como se va modificando nuestra base de datos entramos a mysql como se explico anteriormente y luego nos enfocamos en la que estamos trabajando:

mysql> use ehemploDT;

Ahora miramos sus tablas:

mysql> show tables;
+---------------------+
| Tables_in_ejemploDT |
+---------------------+
| ejemplo             |
+---------------------+
3 rows in set (0.00 sec)

Y procedemos a mirar su contenido:

mysql> describe ejemplo; 
+---------+--------------+------+-----+---------+----------------+
| Field   | Type         | Null | Key | Default | Extra          |
+---------+--------------+------+-----+---------+----------------+
| id      | int(11)      | NO   | PRI | NULL    | auto_increment |
| Nombre  | varchar(255) | NO   |     | NULL    |                |
| Estado  | varchar(255) | NO   |     | NULL    |                |
| Carrera | varchar(255) | NO   |     | NULL    |                |
+---------+--------------+------+-----+---------+----------------+
4 rows in set (0.00 sec)

Con eso se da por terminado nuestro primer contacto con DOCTRINE, Para mas información puedes visitarnos o ponerte en contacto con nosotros por todas nuestras redes, recuerda que el conocimiento te hace libre.

Symfony_Controller

Controladores en Symfony

¿Qué es con Controlador?

En Symfony un controlador(Controller) es una función PHP, capas de obtener información de una petición HTTP(Request) y devuelve una respuesta HTTP(Reponse). Esta respuesta puede ser una página HTML, un documento XML, un array JSON, una imagen, una re-dirección, un error 404, o casi cualquier cosa que se pueda imaginar.

El objetivo del controlador siempre va a ser el mismo, devolver una respuesta, del objeto tipo Response en Symfony. El controlador puede obtener información de la petición, cargar un recurso de la base de datos, enviar un email, u obtener información de la sesión de usuario.

¿Cómo funciona?

Los controladores deben ir en el directorio /src/AppBundle/Controller/ así cuando los creemos, los guardamos en este lugar. Ademas su nombre debe tener el sufijo Controller, por ejemplo HelloController, BlogController, etc.

Cuando creamos un proyecto en Symfony  se crea un controlador en nuesra carpeta donde estan contenidos, su nombre es DefaultController.php, vamos a examinarlo.

<?php

namespace AppBundle\Controller;

use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
 use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 use Symfony\Component\HttpFoundation\Request;

class DefaultController extends Controller
 {
 /**
 * @Route("/", name="homepage")
 */
 public function indexAction(Request $request)
 {
 // replace this example code with whatever you need
 return $this->render('default/index.html.twig', array(
 'base_dir' => realpath($this->container->getParameter('kernel.root_dir').'/..'),
 ));
 }
 }

Linea 1: Nos indica que el el código es un documento PHP.

Linea 2: Indica el espacio de trabajo, se utiliza en todos los controladores, esto es una funcionalidad de PHP.

Lineas 3, 4 y 5: Symfony una vez mas utiliza funcionalidades de  PHP en este caso la palabra clave use indica que se importan las clases que van a ser utilizadas, en este caso la clase Route nos permite decidir como va a ser la ruta que va a accionar el controlador, la clase base Controller la cual incluye varios métodos y contenedores de servicios, de los cuales se explicaran algunos mas adelante; y la clase Request permite gestionar datos recibidos desde la petición.

Linea 6: Acá se define la clase , se le coloca un nombre que por convención es el mismo nombre del archivo, en este caso DefaultController y decimos que extiende de la clase Controller, esto ultimo es opcional pero en la mayoría de casos se suele usar.

Lineas 7, 8 y 9: En esta anotación definimos la ruta en la cual va a ser ejecutado el controlador, en este caso ‘/’, podría ser ‘/hola’ o cualquier cosa que nos imaginemos; ademas es opcional agregarle un nombre, esto es para hacer referencia a esta ruta desde otro lugar.

Lineas de la 10 a la 16: Este es el método IndexAction el cual se ejecutara cuando sea llamada la ruta que definimos anteriormente, estos métodos son llamados con el sufijo Action, por ejemplo HelloAction. En este caso el método retorna una vista de una plantilla HTML ‘index.html.twig’ a través del método render() que muestra una plantilla y pone ese contenido en un objeto Response. Esta plantilla se encuentra  en el directorio app/Resources/views/default/.

Clase base Controller

Utilizar la clase base Controller es opcional, si extendemos de esta conseguiremos obtener acceso a un número de métodos de ayuda y a el contenedor de servicios,  con objetos útiles llamados servicios, y Symfony incluye un objeto de servicio que puede hacer plantillas Twig, otro que puede registrar los mensajes y muchos más.

Para utilizar la clase base Controller es necesario hacer su llamado,
y al declararla extendida de esta, con lel siguiente código:

namespace AppBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class DefaultController extends Controller
{...

A continuación se describen algunos de los metodos y servicios de la clase Controller.

Redirigir

Si queremos redirigir a una ruta de nuestro proyecto utilizamos el método redirectToRoute() y se le pasa como parámetro el nombre de la ruta:

public function indexAction()
{
    return $this->redirectToRoute('homepage');
}

Como parámetros adicionales se le pueden pasar otro valores como variable, arreglos, etc. Si queremos redirigir a una pagina externa usamos el método redirectToRoute() como se muestra a continuación:

public function indexAction()
{
    return $this->redirect('http://symfony.com/doc');
}

Rendering Templates

Si queremos renderizar una plantilla, utilizamos el método render() que la pone en un objeto Response, se muestra a continuación:

return $this->render('hello/index.html.twig', array('name' => $name));

Ademas se pueden pasar parámetros, en este caso un array que contiene una variable del nombre

Acceso a otros servicios

Symfony viene  con una gran cantidad de paquetes con objetos, con capacidad de hacer consultas en bases de datos, enviar emails y muchas cosas mas.  el)

llamado de estos servicios se hace mediante el comando get(), como se muestra a continuación:

$templating = $this->get('templating');


$router = $this->get('router');


$mailer = $this->get('mailer');

Referencias:

Symfony_Rest

Servicio REST en symfony

Primero creamos una ruta asegurémonos de que quede de primero en la el controlador del producto o lo que queramos mostrar:

   /**
     * Lists all Product entities in Rest Service.
     *
     * @Route("/rest", name="product_rest")
     * @Method("GET")
     */
    public function restAction()
    {

    }

Luego dentro de la función debemos asegurarnos de escribir:

$em = $this->getDoctrine()->getManager();
$products = $em->getRepository(‘AcmeStoreBundle:Product’)->findAll();
//Just convert array to JSON and return result
return new Response(json_encode(array(‘productos’ => $products)));

Con esto tenemos un servicio REST de consulta sencillo:

Captura de pantalla de 2016-04-28 00-02-50

Al tener más valores de productos se puede ver:

Captura de pantalla de 2016-04-28 00-14-25

El código refinado incluye referencias a los namespaces:

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\Encoder\XmlEncoder;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;

Y la función final quedó de la manera:

/**
     * Lists all Product entities in Rest Service.
     *
     * @Route("/rest", name="product_rest")
     * @Method("GET")
     */
    public function restAction()
    {
      $encoders = array(new XmlEncoder(), new JsonEncoder());
      $normalizers = array(new ObjectNormalizer());
      $serializer = new Serializer($normalizers, $encoders);
      $em = $this->getDoctrine()->getManager();
      $products = $em->getRepository('AcmeStoreBundle:Product')->findAll();
      $jsonContent = $serializer->serialize($products, 'json');
      //Just convert array to JSON and return result
      return new Response(json_encode(array('productos' => $jsonContent)));
    }