Desarrollo web Symfony2 y Sonata Project

De WikiSalud
Saltar a: navegación, buscar
Symfony Sonata05.jpg

Contenido

Symfony2 con Sonata Project

¿Qué es Sonata Project?

Sonata Project es un proyecto que contiene un conjunto de paquetes los cuales se han construido con Symfony2. Su codificacion este realizada en su mayoria por el trabajo de la comunidad a nivel mundial; utiliza algunos bundles ya conocidos como:

  • FriendsOfSymfony
  • KNPLabs
  • Symfony CMF
  • Entre otros.

El primer bundle realizado por la comunidad es el AdminBundle que tienen aproximadamente más de 300 mil descargas. En los últimos 3 años, el Equipo Sonata Project y los contribuyentes han ayudado a construir más de 20 bundles que son reutilizados por aquellos que lo necesiten. Cada bundle responde a una necesidad en especifico o a un problema y se han trabajado de forma independiente entre si. Algunos de estos bundles son los siguientes:

  • Core: SontaCoreBundle provee todos los elementos comunes requeridos para los demás bundles de Sonta.
  • Admin: Esta divido en 5 bundles del cual solo utilizaremos 2
    • SonataAdminBundle: contiene todas las librerías centrales y los servicios.
    • Doctrine2 ORM Admin: Integración del ORM Doctrine con el bundle anterior.
  • User: es la integracion del bundle de seguridad llamado FOS/UserBundle y el proyecto Sonata Admin. Este permite el manejo de usuarios y grupos, los perfiles del usuario, el menu según el perfil. Este bundle maneja dos tipos de usuarios: aquellos que pueden editar, son los que poseen el rol master; y los de solo lectura.
  • Block: se utiliza para el manejo de bloques en el Sonata Proyect
Nota: Sitio Oficial Sonata Project

FOS/UserBundle

FOSUserBunde agrega soporte para los usuarios del sistema desde la base de datos. Provee un framework flexible para el manejo de los usuarios. Incluye:

  • El registro
  • Cambio de contraseña
  • La autenticación.
Nota: Sitio Oficial FOSUserBundle

FOSJsRoutingBundle

Este bundle permite utilizar tus rutas desde el código JavaScript. Es posible generar tus URL con parámetros; si se requiere, tal como se realiza con el componente de Router de Symfony 2.

Nota: Sitio Oficial FOSJsRoutingBundle

Estructura General de Archivos del Proyecto

Estructura de Archivos de Symfony

De forma predeterminada, cada aplicación basada en Symfony tiene la misma estructura de archivos básica, de igual forma este será el estándar para la Estructura de Archivos del Sistema a desarrollar. La estructura básica se muestra en la siguiente imagen

Estructura básica de archivos de Symfony.

Directorio "app" : Contiene los archivos necesarios para configuración del Sitio Web, además contiene un directorio caché que permite que el acceso a la aplicación se realice de manera más rápida, un directorio logs en el que se registra los diferentes eventos que suceden dentro del sistema, y un directorio resources, que contiene los diferentes archivos (recursos) que pueden ser utilizados en todo el Sitio Web.

Directorio "src" : Contiene los diferentes Bundles, que se hayan creado dentro del sistema, cada Bundle contiene el conjunto de directorios y archivos que almacenan la lógica del sistema.

Directorio "vendor" : dentro de este directorio, se almacena las librerías a utilizar, que pertenecen a terceros.

Directorio "web" : Contiene archivos que necesitan ser accedidos de forma pública, como por ejemplo: imágenes, hojas de estilo y archivos JavaScript. También es el lugar donde reside cada Controlador Frontal (app/app_dev).


Estructura de Archivos de un Bundle con Sonata

La estructura de directorios de un Bundle es simple y flexible. Por defecto, el sistema de Bundles sigue un conjunto de convenciones que ayudan a mantener el código consistente entre todos los Bundles de Symfony2, y para el desarrollo de cualquier sistema se seguirá dicho estándar. La siguiente figura presenta la estructura básica del Bundle de un proyecto que implementa Sonata.

  • Admin: Contiene las clases Admins, perteneciente a los “services” (objetos creados con un propósito específico) que extienden del Framework SonataAdmin.
  • Controller: Contiene los controladores del Bundle.
  • DepenencyInjection: Contiene los archivos que permiten estandarizar y centralizar la construcción de objetos dentro de la aplicación.
  • Dql: Directorio que contiene los archivos de clases que de las funciones personalizadas que permitirán agregar mayor funcionalidad a Doctrine.
  • Entity: En este directorio se almacenaran todas aquellas Clases que son el resultado del mapeo objeto-relacional, mediante Doctrine y que ayudan a realizar la persistencia con la base de datos.
  • EventListener: Contiene los archivos de clases que permiten verificar si un evento ha ocurrido dentro del sistema, y realizar determinadas acciones en base a ello.
  • Form: Contienen las clases que permiten la creación de los formularios en la aplicación.
  • Repository: Directorio que contiene los archivos de clases que permiten realizar consultas personalizadas a la base de datos.
  • Resource: Contiene diferentes recursos que brindan funcionalidad a la aplicación.
  • config: Se encuentran los archivos de configuraciones, incluyendo la configuración de enrutamiento.
  • doc: Directorio que contiene archivos de ayuda (documentación) del sistema.
  • public: En este directorio se encuentran elementos web (imágenes, hojas de estilo, etc.), los cuales pueden ser accedidos públicamente.
  • translation: Contiene los archivos necesarios para la traducción de los mensajes, al idioma Español.
  • views: Contiene plantillas para las vistas, organizadas por el nombre del controlador.
  • Service: Contiene las clases tipo “services” personalizadas.
Estructura básica de un proyecto que implementa Sonata

Instalación e Integración de los Bundles de Sonata

Instalación de Symfony.

Para poder realizar la integración de los diferentes bundles de sonata es necesario haber instalado Symfony. Los pasos de instalación y configuración de Symfony se describe en el siguiente enlace Desarrollo Web Symfony2.

Una vez instalado y configurado Symfony se procederá a la instalación y configuración de los diferentes Bundles de Sonata.

Nota: Se debe de crear una base de datos y usuario, los cuales deben configurarse en el archivo parameters.yml, 
si el archivo no existe se debe de crearlo, tal y como se describe en los pasos del enlace anterior.

Instalación de Sonata

Configuracion del composer.json

El archivo composer.json es el archivo en el cual se declaran todos los bundles a utilizar dentro del proyecto, y el cual permite a través de él descargar y mantener actualizado dichos bundles o paquetes.

 Nota:  Documentacion Oficial

El archivo composer.json, se encuentra dentro del directorio principal del proyecto. Abrir el archivo y deberá quedar de la siguiente manera:

{
    "name": "symfony/framework-standard-edition",
    "license": "MIT",
    "type": "project",
    "description": "The \"Symfony Standard Edition\" distribution",
    "autoload": {
        "psr-0": { "": "src/", "SymfonyStandard": "app/" }
    },
    "require": {
        "php": ">=5.3.3",
        "symfony/symfony": "2.5.*",
        "doctrine/orm": "~2.2,>=2.2.3",
        "doctrine/doctrine-bundle": "~1.2",
        "twig/extensions": "~1.0",
        "symfony/assetic-bundle": "~2.3",
        "symfony/swiftmailer-bundle": "~2.3",
        "symfony/monolog-bundle": "~2.4",
        "sensio/distribution-bundle": "~3.0",
        "sensio/framework-extra-bundle": "~3.0",
        "incenteev/composer-parameter-handler": "~2.0",
        "friendsofsymfony/user-bundle": "~1.3@dev",
        "knplabs/knp-menu-bundle": "1.1.*@dev",
        "sonata-project/core-bundle": "~2.2@dev",
        "sonata-project/intl-bundle": "~2.2",
        "sonata-project/cache-bundle": "~2.2@dev",
        "sonata-project/easy-extends-bundle": "~2.1",
        "sonata-project/admin-bundle": "~2.3@dev",
        "sonata-project/doctrine-orm-admin-bundle": "~2.3@dev",
        "sonata-project/block-bundle": "~2.2",
        "sonata-project/jquery-bundle": "~1.10",
        "sonata-project/exporter": "1.*",
        "sonata-project/user-bundle": "~2.3@dev",
        "sonata-project/formatter-bundle": "~2.3",
        "sonata-project/datagrid-bundle": "~2.2@dev",
        "sonata-project/media-bundle": "~2.3@dev",
        "jms/serializer-bundle": "~0.11",
        "jms/security-extra-bundle": "~1.5@dev",
        "jms/di-extra-bundle": "~1.4@dev",
        "friendsofsymfony/jsrouting-bundle": "~1.1"
 
    },
    "require-dev": {
        "sensio/generator-bundle": "~2.3"
    },
    "scripts": {
        "post-root-package-install": [
            "SymfonyStandard\\Composer::hookRootPackageInstall"
        ],
        "post-install-cmd": [
            "Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
             "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::removeSymfonyStandardFiles"
        ],
        "post-update-cmd": [
            "Incenteev\\ParameterHandler\\ScriptHandler::buildParameters",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::buildBootstrap",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::clearCache",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installAssets",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::installRequirementsFile",
            "Sensio\\Bundle\\DistributionBundle\\Composer\\ScriptHandler::removeSymfonyStandardFiles"
        ]
    },
    "config": {
        "bin-dir": "bin"
    },
    "extra": {
        "symfony-app-dir": "app",
        "symfony-web-dir": "web",
        "incenteev-parameters": {
            "file": "app/config/parameters.yml"
        },
        "branch-alias": {
            "dev-master": "2.5-dev"
        },
        "symfony-assets-install": "symlink"
    }
}

Instalación y configuración de los bundles

Una vez configurado el composer.json, es necesario proceder con la instalación de los bundles, dicha instalación se realizará dentro del directorio vendors. Para poder realizar la instalación es necesario ingresar al directorio principal del proyecto, tener instalado composer.phar y digitar el siguiente comando:

php composer.phar install

Una vez descargados lo bundles es necesario habilitarlos para que puedan ser utilizados dentro del sistema, esto se logra editando el archivo AppKernel.php que se encuentra dentro del directorio app , y agregarle las siguientes líneas:

<?php
......
// app/AppKernel.php
 
class AppKernel {
    public function registerbundles()
    {
        return array(
            // Application Bundles
            // ...
            new Sonata\CoreBundle\SonataCoreBundle(),
            new Sonata\BlockBundle\SonataBlockBundle(),
            new Sonata\jQueryBundle\SonatajQueryBundle(),
            new Knp\Bundle\MenuBundle\KnpMenuBundle(),
            new Sonata\DoctrineORMAdminBundle\SonataDoctrineORMAdminBundle(),
            new Sonata\AdminBundle\SonataAdminBundle(),
            new FOS\UserBundle\FOSUserBundle(),
            new Sonata\UserBundle\SonataUserBundle('FOSUserBundle'),
            new Sonata\EasyExtendsBundle\SonataEasyExtendsBundle(),
            new Sonata\CacheBundle\SonataCacheBundle(),
            new Sonata\IntlBundle\SonataIntlBundle(),
            new Sonata\MarkItUpBundle\SonataMarkItUpBundle(),
            new Knp\Bundle\MarkdownBundle\KnpMarkdownBundle(),
            new Ivory\CKEditorBundle\IvoryCKEditorBundle(),
            new Sonata\FormatterBundle\SonataFormatterBundle(),
            new JMS\SerializerBundle\JMSSerializerBundle(),
            new JMS\AopBundle\JMSAopBundle(),
            new JMS\DiExtraBundle\JMSDiExtraBundle($this),
            new JMS\SecurityExtraBundle\JMSSecurityExtraBundle(),
            new FOS\JsRoutingBundle\FOSJsRoutingBundle(),
            // ...
 
        )
    }
......
......
}

Una habilitados los bundles a utilizar, es necesario proceder con su configuración; para lo cual se creará la carpeta bundles dentro del directorio app/config con la siguiente instrucción:

mkdir app/config/bundles

En la carpeta anteriormente creada se almacenarán las configuraciones necesarias para el funcionamiento de cada bundle, para lo cual se creará un archivo de configuración por bundle, tal y como se muestra a continuación:

  • fos_user.yml
fos_user:
    db_driver:      orm # can be orm or odm
    firewall_name:  main
    user_class:     Sonata\UserBundle\Entity\BaseUser
 
    group:
        group_class:   Sonata\UserBundle\Entity\BaseGroup
        group_manager: sonata.user.orm.group_manager
 
    service:
        user_manager: sonata.user.orm.user_manager
 
    profile:
        # Authentication Form
        form:
            type:               fos_user_profile
            handler:            fos_user.profile.form.handler.default
            name:               fos_user_profile_form
            validation_groups:  [Authentication]
  • sonata_admin.yml
sonata_admin:
    security:
        handler: sonata.admin.security.handler.role
    title:       Sistema X
    title_logo:  /bundles/applicationcore/images/escudo.png
    templates:
        # default global templates
        layout:  SonataAdminBundle::standard_layout.html.twig
        ajax:    SonataAdminBundle::ajax_layout.html.twig
 
        # default actions templates, should extend a global templates
        list:    SonataAdminBundle:CRUD:list.html.twig
        show:    SonataAdminBundle:CRUD:show.html.twig
        edit:    SonataAdminBundle:CRUD:edit.html.twig
 
        dashboard: SonataAdminBundle:Core:dashboard.html.twig
 
    dashboard:
        blocks:
            # display a dashboard block
            - { position: left, type: sonata.admin.block.admin_list }
  • sonata_block.yml
sonata_block:
    default_contexts: [cms]
    blocks:
        # Enable the SonataAdminBundle block
        sonata.admin.block.admin_list:
            contexts:   [admin]
 
        #sonata.admin_doctrine_orm.block.audit:
        #    contexts:   [admin]
        sonata.user.block.menu:    # used to display the menu in profile pages
        sonata.user.block.account: # used to display menu option (login option)
        sonata.block.service.text:
        sonata.block.service.rss:
  • sonata_cache.yml
sonata_cache:
    caches:
        apc:
            token:  s3cur3   # token used to clear the related cache
            prefix: test     # prefix to ensure there is no clash between instances
            servers:
                - { domain: kooqit.local, ip: 127.0.0.1, port: 80 }
  • sonata_core.yml
sonata_core: ~
  • sonata_formatter.yml
sonata_formatter:
    formatters:
        markdown:
            service: sonata.formatter.text.markdown
            extensions:
                - sonata.formatter.twig.control_flow
                - sonata.formatter.twig.gist
                #- sonata.media.formatter.twig

        text:
            service: sonata.formatter.text.text
            extensions:
                - sonata.formatter.twig.control_flow
                - sonata.formatter.twig.gist
                #- sonata.media.formatter.twig

        rawhtml:
            service: sonata.formatter.text.raw
            extensions:
                - sonata.formatter.twig.control_flow
                - sonata.formatter.twig.gist
                #- sonata.media.formatter.twig

        richhtml:
            service: sonata.formatter.text.raw
            extensions:
                - sonata.formatter.twig.control_flow
                - sonata.formatter.twig.gist
                #- sonata.media.formatter.twig

        twig:
            service: sonata.formatter.text.twigengine
            extensions: [] # Twig formatter cannot have extensions
  • sonata_user.yml
sonata_user:
    security_acl:     false
    class:
        user:         Application\Sonata\UserBundle\Entity\User
        group:        Application\Sonata\UserBundle\Entity\Group
 
    profile:  # Profile Form (firstname, lastname, etc ...)
        form:
            type:               sonata_user_profile
            handler:            sonata.user.profile.form.handler.default
            name:               sonata_user_profile_form
            validation_groups:  [Profile]

Una vez creada las configuraciones de los bundles a utilizar, es necesario que estas sean importadas en el archivo principal de configuración, para lo cual es necesario editar el archivo config.yml que se encuentra dentro del directorio app/config, y agregarle las siguientes líneas al inicio del archivo:

imports:
    # code...
    # - { resource: services.xml }
    - { resource: bundles/fos_user.yml }
    - { resource: bundles/sonata_admin.yml }
    - { resource: bundles/sonata_block.yml }
    - { resource: bundles/sonata_cache.yml }
    - { resource: bundles/sonata_core.yml }
    - { resource: bundles/sonata_formatter.yml }
    # - { resource: bundles/sonata_user.yml }

# code...

# Twig Configuration
twig:
    # code...
    form:
        resources:
            - 'SonataFormatterBundle:Form:formatter.html.twig'
 
# code...

# Doctrine Configuration
doctrine:
    dbal:
        # code...
        types:
            json: Sonata\Doctrine\Types\JsonType
# code...

# Knp MenuBundle
knp_menu:
    twig:  # use "twig: false" to disable the Twig extension and the TwigRenderer
        template: knp_menu.html.twig
    templating: false # if true, enables the helper for PHP templates
    default_renderer: twig # The renderer to use, list is also available by defaul

Una vez finalizada la configuración es necesario habilitar las rutas de cada uno de los bundles para que estas funcionen correctamente, para lo cual es necesario editar el archivo routing.yml que se encuentra dentro del directorio app/config, y agregarle las siguientes líneas:

root:
    pattern: /
    defaults:
        _controller: FrameworkBundle:Redirect:urlRedirect
        path:  /admin/login
        permanent: true
 
# Sonata AdminBundle
admin:
    resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
    prefix: /admin
 
_sonata_admin:
    resource: .
    type: sonata_admin
    prefix: /admin
 
# Sonata CacheBundle
sonata_cache_cache:
    resource: '@SonataCacheBundle/Resources/config/routing/cache.xml'
    prefix: /
 
# Sonata UserBundle
sonata_user_security:
    resource: "@SonataUserBundle/Resources/config/routing/sonata_security_1.xml"
 
sonata_user_resetting:
    resource: "@SonataUserBundle/Resources/config/routing/sonata_resetting_1.xml"
    prefix: /resetting
 
sonata_user_profile:
    resource: "@SonataUserBundle/Resources/config/routing/sonata_profile_1.xml"
    prefix: /profile
 
sonata_user_register:
    resource: "@SonataUserBundle/Resources/config/routing/sonata_registration_1.xml"
    prefix: /register
 
sonata_user_change_password:
    resource: "@SonataUserBundle/Resources/config/routing/sonata_change_password_1.xml"
    prefix: /profile
 
sonata_user:
    resource: '@SonataUserBundle/Resources/config/routing/admin_security.xml'
    prefix: /admin
 
fos_js_routing:
    resource: "@FOSJsRoutingBundle/Resources/config/routing/routing.xml"

Una vez realizado lo anterior, es necesario habilitar la seguridad, la cual se realizará a través de roles y grupos, con la ayuda del Bundle SonataUserBundle, para lo cual es necesario sobreescribir todo el archivo de seguridad de symfony security.yml que se encuentra del directorio app/config, de la siguiente manera:

security:
    encoders:
        FOS\UserBundle\Model\UserInterface: sha512
 
    role_hierarchy:
        ROLE_ADMIN:       [ROLE_USER, ROLE_SONATA_ADMIN]
        ROLE_SUPER_ADMIN: [ROLE_ADMIN, ROLE_ALLOWED_TO_SWITCH]
        SONATA:
            - ROLE_SONATA_PAGE_ADMIN_PAGE_EDIT  # if you are using acl then this line must be commented

    providers:
        fos_userbundle:
            id: fos_user.user_manager
 
    firewalls:
        # Disabling the security for the web debug toolbar, the profiler and Assetic.
        dev:
            pattern:  ^/(_(profiler|wdt)|css|images|js)/
            security: false
 
        # -> custom firewall for the admin area of the URL
        admin:
            pattern:            /admin(.*)
            context:            user
            form_login:
                provider:       fos_userbundle
                login_path:     /admin/login
                use_forward:    false
                check_path:     /admin/login_check
                failure_path:   null
                use_referer:    true
                default_target_path:  /admin/dashboard
            logout:
                path:           /admin/logout
                target:         /admin/login
                invalidate_session: false
            anonymous:          true
 
        # -> end custom configuration

        # default login area for standard users

        # This firewall is used to handle the public login area
        # This part is handled by the FOS User Bundle
        main:
            pattern:             .*
            context:             user
            form_login:
                provider:       fos_userbundle
                login_path:     /admin/login
                use_forward:    false
                check_path:     /admin/login_check
                failure_path:   null
                use_referer:    true
                default_target_path:  /admin/dashboard
            logout:
                path:           /admin/logout
                target:         /admin/login
                invalidate_session: false
            anonymous:          true
 
    access_control:
        # URL of FOSUserBundle which need to be available to anonymous users
        - { path: ^/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/register, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/resetting, role: IS_AUTHENTICATED_ANONYMOUSLY }
 
        # Admin login page needs to be access without credential
        - { path: ^/admin/login$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/logout$, role: IS_AUTHENTICATED_ANONYMOUSLY }
        - { path: ^/admin/login_check$, role: IS_AUTHENTICATED_ANONYMOUSLY }
 
        # Secured part of the site
        # This config requires being logged for the whole site and having the admin role for the admin part.
        # Change these rules to adapt them to your needs
        - { path: ^/admin/, role: [ROLE_ADMIN, ROLE_SONATA_ADMIN] }
        - { path: ^/.*, role: IS_AUTHENTICATED_ANONYMOUSLY }

A este punto el bundle es funcional, pero no esta listo aun, para que este funcione es necesario extender el bundle para generar las entidades correctas dentro del sistema, para ello es necesario ejecutar la siguiente sentencia en la consola, dentro del directorio raíz del proyecto:

php app/console sonata:easy-extends:generate SonataUserBundle -d src

Lo anterior generará un directorio llamado Application dentro del directorio src, en el que se almacenará y extenderá el bundle de SonataUserBundle.

Una vez extendido el bundle es necesario habilitarlo dentro del archivo AppKernel.php y posteriormente habilitar las configuraciones de sonata_user dentro del archivo config.yml.

  • AppKernel.php
<?php
 
// AppKernel.php
 
class AppKernel {
    public function registerbundles()
    {
        return array(
            // Application Bundles
            // ...
            new Application\Sonata\UserBundle\ApplicationSonataUserBundle(),
            // ...
 
        )
    }
}

Descomentar la línea que importa la configuración de sonata_user, quedando de la siguiente manera.

  • config.yml
imports:
    # code...
    - { resource: bundles/sonata_user.yml }
 
# code...

Modificar el archivo de configuración del fos_user.yml para configurar las nuevas entidades extendidas de Usuario y Grupo, dicho archivo se encuentra dentro del directorio app/config/bundles, quedando de la siguiente manera:

  • fos_user.yml original
fos_user:
    # code...
    user_class:     Sonata\UserBundle\Entity\BaseUser
 
    group:
        group_class:   Sonata\UserBundle\Entity\BaseGroup
 
# code...
  • fos_user.yml modificado
fos_user:
    # code...
    user_class:     Application\Sonata\UserBundle\Entity\User
 
    group:
        group_class:   Application\Sonata\UserBundle\Entity\Group
 
# code...

Configuración de la Entidad de Grupo y Usuario

Una vez realizado el apartado anterior, la configuración del proyecto con Sonata casi finaliza; como paso final es necesario realizar las configuraciones de las Entidades de Grupo y Usuario, así como la actualización del esquema a partir de las entidades del proyecto (Ingeniería inversa).

A continuación se describen los pasos para la configuración de las entidades de Grupo y Usuario de SonataAdminBundle:

  1. Editar la Entidad de Usuario (User.php) y Grupo (Group.php) que se encuentran dentro del directorio src/Application/Sonata/UserBundle/Entity, para que queden de la siguiente manera:
  • User.php
<?php
namespace Application\Sonata\UserBundle\Entity;
 
use Sonata\UserBundle\Entity\BaseUser as BaseUser;
use Doctrine\ORM\Mapping as ORM;
 
/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user_user")
 */
class User extends BaseUser
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
 
    /**
     * Get id
     *
     * @return integer $id
     */
    public function getId()
    {
        return $this->id;
    }
}
  • Group.php
<?php
namespace Application\Sonata\UserBundle\Entity;
 
use Sonata\UserBundle\Entity\BaseGroup as BaseGroup;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Validator\Constraints as Assert;
/**
 * @ORM\Entity
 * @ORM\Table(name="fos_user_group")
 */
class Group extends BaseGroup
{
    /**
     * @ORM\Id
     * @ORM\Column(type="integer")
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
 
    /**
     * @var string
     * @Assert\Regex(pattern="/^[a-zA-ZaÑñáéíóúÁÉÍÓÚ ]+$/",match=true)
     * @ORM\Column(name="name")
     */
 
    /**
     * Get id
     *
     * @return integer $id
     */
    public function getId()
    {
        return $this->id;
    }
}

Una vez configurado las Entidades de Usuario y Grupo, se procederá a cargar el esquema de la base de datos a partir de las entidades del sistema, para lo cual es necesario ejecutar el siguiente comando en la consola, dentro del directorio raíz del proyecto:

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

Al crear el esquema solamente falta crear el usuario con el que se ingresará al sistema para ello se ejecuta el siguiente comando en el directorio raiz del proyecto:

php app/console fos:user:create --super-admin
 
# Salida de la consola
Please choose a username:klb
Please choose an email:calebruben@gmail.com
Please choose a password:klb
Created user klb

Al ejecutar el comando se pedirá el nombre de usuario, el correo y la contraseña del usuario a crear tal y como en la línea anterior.

Con lo anterior ya se ha finalizado la instalación y configuración de cada uno de los bundles de Sonata que se han de utilizar en el proyecto, y como ultimo paso es necesario realizar la actualización de las css, js y demás assets con la siguiente instrucción:

php app/console assets:install --symlink

Proceder a ingresar al sistema para verificar que todo se ha realizado de manera correcta, para lo cual es necesario ingresar al virtual host que se configuró para este proyecto, un ejemplo de la dirección es la siguiente: http://web.capacitacion.localhost/app_dev.php/admin/login Dando como resultado la siguiente pantalla:

Inicio de Sesión

Al ingresar con el usuario y contraseña creados en el paso anterior, se podra observar una pantalla similar a la siguiente:

Dashboard Sonata

Traducción

Para realizar la traducción se debe de modificar el archivo config.yml. Se debe buscar la #translator: { fallback: "%locale%" }' y se debe de quitar el # para descomentarla. Debe de quedar así:

framework:
    #esi:             ~
    translator:      { fallback: "%locale%" }
    secret:          "%secret%"

Ahora se debe de crear un directorio llamado translations en la ruta src/Application/Sonata/UserBundle/Resources/. Crearla con la siguiente instrucción:

mkdir src/Application/Sonata/UserBundle/Resources/translations

Dentro de este directorio se debe de guardar el siguiente archivo Archivo de traducción. Descargarlo dentro del directorio del proyecto y ejecutar la siguiente instrucción:

tar zxvf SonataUserBundle.tar.gz -C src/Application/Sonata/UserBundle/Resources/translations; rm SonataUserBundle.tar.gz

Este archivo contienen toda la traducción en español de las variables de SonataUserBundle.

Limpiar la cache de symfony con la siguiente instrucción:

php app/console cache:clear

Recargar la página de inicio de sesión y deberá aparecer como se muestra a continuación:

Traducción

parte 2

Herramientas personales
Espacios de nombres

Variantes
Acciones
Navegación
Herramientas