1 - Registramos y configuramos SwiftmailerServiceProvider en el archivo app.php

1
2
3
4
5
6
7
8
9
10
11
12
13

 
$app->register(new Silex\Provider\SwiftmailerServiceProvider());
 
 
$app->register(new SwiftmailerServiceProvider(), array(
    'swiftmailer.options' => array(
        'host'          => 'smtp.gmail.com',
        'port'          => '465',
        'username'      => 'tu dirección de gmail',
        'password'      => 'contraseña de gmail'
    )
 
));

en caso de que no tengas instalado swiftmailer, el proceso es tan sencillo como agregar la siguiente línea a tu composer.json:

1
2
3

"require": {
    "swiftmailer/swiftmailer": ">=4.1.2,<4.2-dev"
}

Abrimos una consola y ejecutamos:

$ php composer.phar install

2 - Ahora creamos la ruta con el controlador

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

 $app->match('/contacto', function (Application $app, Request $request) {
   //creamos los campos del formulario   
        $form = $app['form.factory']->createBuilder('form')
                ->add('nombre','text')
                ->add('email','email')
                ->add('mensaje', 'textarea')
                ->getForm();
 
            if('POST' == $request->getMethod()){
 
                $form->bind($request);
 
                    if($form->isValid()){
                        //Obtenemos los datos del formulario
                        $datos = $form->getData();
 
                        $contenido_email = sprintf('Email: %s \n\n Remitente: %s \n\n Mensaje: $s ',
                        $datos['email'],
                        $datos['nombre'],
                        htmlspecialchars($datos['mensaje']));
 
                        $message = \Swift_Message::newInstance()
                                  ->setSubject('Contacto')
                                  ->setFrom(array($datos['email']))
                                  ->setTo(array('tu@email.com'))
                                  ->setBody($datos['mensaje']);
 
                              $app['mailer']->send($message);  
 
                           return $app->redirect($app['url_generator']->generate('contacto'));
 
                        }           
            }
 
       return $app['twig']->render('contacto.html.twig', array(
           'form' => $form->createView()
        )); 
 
});

Si tu aplicación es muy pequeña puedes hacerlo de esta forma pero si tu aplicación va a ser mas grande, es mejor que definas todos los controladores en clases, si quieres saber más lee la documentación o también puedes utilizar los controladores como servicios.

3 – Ahora creamos la plantilla contacto.html.twig para imprimir el formulario de contacto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

 
<h2>Contacto</h2>
 
<form action="{{ path('contacto') }}" method="post" {{ form_enctype(form) }}>
 
{{ form_errors(form) }}
 
        {{ form_label(form.nombre) }}  
        {{ form_errors(form.nombre) }}
        {{ form_widget(form.nombre) }}
 
 
        {{ form_label(form.email) }}   
        {{ form_errors(form.email) }}
        {{ form_widget(form.email) }}
 
        {{ form_label(form.mensaje) }}   
        {{ form_errors(form.mensaje) }}
        {{ form_widget(form.mensaje) }}
 
{{ form_rest(form) }}
        <br/>
        <input  type="submit" value="Enviar" />
    </form>

Enlace: Silex Framework

Características

• Compatible con iPhone, iPad y Android
• Soporta deslizamiento con el pulgar
• Establecer un intervalo( en milisegundos) para realizar la transición 
• Ajustar tamaño (radio) de la barra
• Fácil personalizable
• Ligero con sólo 130 líneas de código. minified  de 4 kb

Enlace: Demo

Utilizarlo es muy sencillo:

1 - Añadimos el siguiente código a nuestro composer.json e instalarlo:

{
    "require": {
        "silex/silex": "1.0.*",
        "taluu/doctrine-orm-provider": "1.0.*"
    },
    "minimum-stability": "dev"
}

composer update

2 – Lo registramos en Silex en app.php:

use \Doctrine\Common\Cache\ApcCache;
use \Doctrine\Common\Cache\ArrayCache;
 
 
$app->register(new Silex\Provider\DoctrineServiceProvider(), array(
    // Doctrine DBAL settings goes here
));
 
 
$app->register(new Nutwerk\Provider\DoctrineORMServiceProvider(), array(
    'db.orm.proxies_dir'           => __DIR__ . '/cache/doctrine/proxy',
    'db.orm.proxies_namespace'     => 'DoctrineProxy',
    'db.orm.cache'                 => 
        !$app['debug'] && extension_loaded('apc') ? new ApcCache() : new ArrayCache(),
    'db.orm.auto_generate_proxies' => true,
    'db.orm.entities'              => array(array(
        'type'      => 'annotation',       // tipo de definición de entidades
        'path'      => __DIR__ . '/src',   // ruta a tus clases
        'namespace' => 'MiWeb\Entity', // el namespace de tus clases
    )),
));

Para llamar al entity manager en Silex:

$app['db.orm.em']

El funcionamiento es practicamente igual que en Symfony2 pero si quieres saber más, revisa este post(Ingles)

Enlace: Doctrine 2 ORM for Silex

Hoy vamos a ver como loguearse con un usuario usando el SecurityServiceProvider que incorpora el framework para añadir los firewalls necesarios a la aplicación.

Antes de nada tenemos que registrar el proveedor de doctrine y

1) Antes de nada tenemos que registrar el proveedor de doctrine y configurar la conexión con nuestra base de datos en nuestro app.php:

1
2
3
4
5
6
7
8
9

$app->register(new Silex\Provider\DoctrineServiceProvider(), array(
    'db.options' => array(
        'driver' => 'pdo_mysql',
        'dbhost' => 'localhost',
        'dbname' => 'dbname',
        'user' => 'root',
        'password' => 'contraseña',
    ),
));

2) También es necesario el SessionServiceProvider para manejar las sesiones de la aplicación:

$app->register(new Silex\Provider\SessionServiceProvider());

3)Ahora añadimos las dependencias del SecurityServiceProvider a nuestro archivo composer.json y lo instalamos:

1
2
3

"require": {
    "symfony/security": "~2.1"
}

$ php composer.phar update

4) Registramos el SecurityServiceProvider  y configuramos los firewalls de la aplicación:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

register(new Silex\Provider\SecurityServiceProvider(), array(
    'security.firewalls' => array(
        'anonimo' => array('pattern' => '^/anonimo'), 
        'segura' => array(
            'pattern' => '^.*$',
            'anonymous' => true, //Es necesario si el login path está dentro de una zona segura                          
            'form' => array('login_path' => '/', 'check_path' => 'login_check'),
            'logout' => array('logout_path' => '/logout'), // para cerrar sesión
            'users' => $app->share(function() use ($app) {
                //El proveedor de usuarios:
                return new App\User\UserProvider($app['db']);
            }),
        ),
    ),
    'security.access_rules' => array(
        // Puede ser el rol que tu quieras 
        array('^/.+$', 'ROLE_USER'),
    )
));

5)Ahora creamos la clase UserProvider:

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

// app/src/User/UserProvider.php o donde tu quieras
namespace App\User;
 
use Symfony\Component\Security\Core\User\UserProviderInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Core\User\User;
use Symfony\Component\Security\Core\Exception\UsernameNotFoundException;
use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
use Doctrine\DBAL\Connection;
 
class UserProvider implements UserProviderInterface
{
    private $conn;
 
    public function __construct(Connection $conn)
    {
        $this->conn = $conn;
    }
 
    public function loadUserByUsername($username)
    {
        $stmt = $this->conn->executeQuery('SELECT * FROM users WHERE username = ?', array(strtolower($username)));
        if (!$user = $stmt->fetch()) {
            throw new UsernameNotFoundException(sprintf('Username "%s" does not exist.', $username));
        }
 
        return new User($user['username'], $user['password'], explode(',', $user['roles']), true, true, true, true);
    }
 
    public function refreshUser(UserInterface $user)
    {
        if (!$user instanceof User) {
            throw new UnsupportedUserException(sprintf('Instances of "%s" are not supported.', get_class($user)));
        }
 
        return $this->loadUserByUsername($user->getUsername());
    }
 
    public function supportsClass($class)
    {
        return $class === 'Symfony\Component\Security\Core\User\User';
    }
}

6)Tabla de la base de datos

1
2
3
4
5
6
7
8

CREATE TABLE `users` (
  `id` INT(11) UNSIGNED NOT NULL AUTO_INCREMENT,
  `username` VARCHAR(100) NOT NULL,
  `password` VARCHAR(255) NOT NULL,
  `roles` VARCHAR(255) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `unique_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

7) Usuario de prueba(contraseña = password)

INSERT INTO `users` (`username`, `password`, `roles`) VALUES ('usuario', 'BFEQkknI/c+Nd7BaG7AaiyTfUFby/pkMHy3UsYqKqDcmvHoPRX/ame9TnVuOV2GrBH0JK9g4koW+CgTYI9mK+w==', 'ROLE_USER');

8)Ejemplo de uso:

1
2
3
4
5
6
7
8

use Symfony\Component\HttpFoundation\Request;
 
$app->get('/', function(Request $request) use ($app) {
    return $app['twig']->render('index.twig', array(
        'error' => $app['security.last_error']($request),
        'last_username' => $app['session']->get('_security.last_username'),
    ));
});

 9)Formulario usando Twig:

1
2
3
4

<form action="{{ path('login_check') }}" method="post">
        <p><label for="username">Username: </label><input id="username" type="text" name="_username" value="{{ last_username }}"></p>
        <p><label for="password">Password: </label><input id="password" type="password" name="_password"></p>
        <p><input type="submit" value="Log in"></p>

Este tutorial está basado en este Bubbleco.de creado por Johann Reinke y en la documentación de Silex.

• Java SDK: para que nuestro servidor pueda compilar las aplicaciones Java.
• Servidor web: Apache
• Contenedor de servlets: utilizaremos Apache Tomcat
• Sistema Gestor de Bases de Datos: Mysql
• Paquete de instalación de OpenCMS

Pasos previos

Voy a realizar el tutorial en una maquina con Windows 7 y para facilitar el proceso usare XAMPP. Si no tienes XAMPP instalado puedes descargarlo de aquí, aunque también puedes utilizar WAMP Server o cualquier otra aplicación parecida.

Una vez tengas descargado e instalado XAMPP tienes que descargar e instalar el SDK de Java, y una vez lo tengas instalado hay que agregarlo al PATH de Windows(Equipo->Propiedades del sistema->Opciones Avanzadas->Variables de entorno) igual que se ve en la imagen. Ese es el directorio por defecto, si lo has instalado en otro directorio cambia la ruta.

Cuando hayas hecho lo anterior, descarga Apache Tomcat de su web oficial e instálalo tal que así:

1 - Cuando llegues a este paso asegúrate de que los puertos indicados no están e uso y establece un usuario y contraseña para administrar Tomcat.

2 - Otro paso importante de la instalación es indicar la ruta del JRE(Java Runtime Enviroment)

3 - La ruta de instalación de Tomcat:

Una vez finalizada la instalación Tomcat intentará arrancar el servicio automáticamente.

Instalación de OpenCMS

Ahora que instalamos todos los componentes necesarios para el funcionamiento de OpenCMS, procederemos a la instalación.

1 – Descarga OpenCMS y descomprímelo

2 - Ahora copia el fichero opencms.war a la carpeta webapps de Tomcat. Después reinicia Tomcat y el servidor se encargará de descomprimir y desplegar los ficheros de instalación contenidos en opencms.war.

3 – Abre un navegador y accede a la dirección http://localhost:8080/opencms/setup para comenzar el proceso de instalación, en la primera pantalla aceptamos el contrato de licencia.

4 - En la siguiente pantalla se mostrarán los test realizados automáticamente sobre los componentes necesarios. En mi caso da una advertencia para Tomcat pues es una versión muy reciente y no la reconoce.

5 - Ahora le toca el turno a la conexión con la base de datos, tendrás que introducir tu usuario y contraseña de MySQL.

6 - La base de datos se creó satisfactoriamente.

7 - Ahora escogemos los módulos que queremos instalar:

• OpenCMS Workplace: es necesario, incluye las interfaces de acceso a OpenCMS.
• OpenCMS Release Notes: documentación de la versión.
• OpenCMS TemplateTwo: plantilla de demostración sobre la que hacer pruebas.
• OpenCMS Demo Content for TemplateTwo: contenido adicional de la plantilla de demostración.
• OpenCMS Documentation from Alkacon: documentación de desarrollo para OpenCMS.
• OpenCMS TemplateOne and Demo Content: plantilla de pruebas de las versiones anteriores de OpenCMS.

8 - En la siguiente vista podemos configurar características propias del servidor:

• Dirección Mac: para evitar ataques por MAC Spoofing.
• URL de Acceso: ruta de acceso interno a nuestro servidor.
• Nombre del servidor: nombre de acceso(sin espacios) que irá a continuación de la ruta anterior para dar acceso al servidor.

Comienza la importación de módulos:

8 - Finaliza la instalación con una página de información sobre como configurar el navegador en caso de encontrar problemas:

9 - La última ventana muestra que la instalación se ha completado satisfactoriamente y que deberíamos borrar la carpeta /setup

10 - Ahora si accedes a la dirección http://localhost:8080/opencms/opencms/index.jsp deberías ver la página de bienvenida de OpenCMS.

Instalar Moodle en Linux es muy sencillo, pero antes de nada, tenemos que instalar un servidor LAMP para que pueda funcionar:

- Abrimos una terminal e instalamos el servidor Apache:

$ sudo apt-get install apache2

- Acto seguido instalamos un servidor MySQL:

$ sudo apt-get install mysql-server

Comenzará el proceso de instalación y nos pedirá que indiquemos un nombre de usuario(por defecto root – administrador) y contraseña.

- Instalamos un cliente MySQL para facilitar la administración del servidor.

$ sudo apt-get install mysql-client

- Instalamos PHP mediante el siguiente comando:

$ sudo apt-get install php5

- Para completar la instalación tenemos que instalar unos módulos adicionales de PHP  que requiere Moodle para su funcionamiento:

$ sudo apt-get install php5-gd php5-mysql php5-curl php5-xmlrpc php5-intl php5-cli

- Una vez acabe de instalar reiniciamos el servidor apache con la siguiente orden:

$ sudo /etc/init.d/apache2 restart

- Creamos un directorio para los datos de Moodle:

$ sudo mkdir /var/moodledata

- Modificamos los permisos de acceso:

$ sudo chmod 777 /var/moodledata

- Ahora accedemos a phpMyAdmin(http://localhost/phpmyadmin) y creamos la base de datos para Moodle y un usuario para la misma:

• Si no tienes phpmyadmin instalado sigue este tutorial.
• Para evitar problemas durante la instalación con el idioma, lo ideal es elegir cotejamiento utf8_spanish-ci.

Creamos un usuario nuevo para la base de datos:

Editamos los privilegios del usuario:

Una vez tenemos la base de datos creada y su usuario procedemos a instalar Moodle. Lo primero es descargarlo desde el sitio oficial de Moodle y lo descomprimimos dentro de la carpeta /var/www de Apache:

$ sudo tar xzvf moodle-version.tgz -C /var/www

Cuando acabe de descomprimir tenemos que otorgar permiso de escritura al servidor en el directorio creado:

$ sudo chown www-data /var/www/moodle

Ahora reiniciamos el servidor Apache:

$ sudo /etc/init.d/apache2 restart

Instalación de Moodle

Como Moodle es una aplicación web se instala desde el navegador accediendo a nuestro servidor local(http://localhost/moodle)

1 - Al acceder a la dirección anterior se nos mostrará una página para escoger el idioma tanto para la instalación como para el propio Moodle:

2 - A continuación se indican las rutas de acceso de Moodle vía web, los ficheros de la aplicación de Moodle y el directorio de contenidos:

3 - A continuación elegimos el controlador de la base de datos. Como usamos MySQL viene por defecto mysqli:

4 - Ahora configuramos el acceso a la base de datos, indicamos la ubicación del servidor (en este caso localhost pues estamos utilizando un servidor local), el nombre de la base de datos( el nombre de la base de datos que creamos en phpmyadmin), el usuario de la base de datos( el que creamos para la base de datos), la contraseña, el prefijo de las tablas de la base de datos(opcional).

5 - Aceptamos el contrato de licencia:

6 - En el siguiente paso vemos el estado de las extensiones, módulos y servidores auxiliares:

• El rojo indica que la instalación no puede continuar hasta que se resuelva el problema.
• El amarillo indica que la instalación puede continuar pero recomienda resolverlo antes de continuar.
• El verde indica que todo está correcto.

7 - Acto seguido comienza el proceso de instalación de todos los módulos que componen Moodle:

8 - Ahora hay que introducir los datos del administrador de Moodle, nombre de usuario, contraseña, nombre etc:

9 - Ahora definimos las características básicas de Moodle:

• Nombre completo del sitio: El que se mostrará en la barra del título del navegador.
• Nombre corto para el sitio: comunicaciones y configuración interna.
• Descripción de la página: orientado al indexado de contenido, como bots etc.
• Registrarse a sí mismo: habilita el módulo registerauth que obliga a los usuarios a registrarse para poder acceder al sitio.

10 - Página principal de Moodle:

La instalación no tiene ninguna complicación pero son bastantes pasos si no tienes ya montado un servidor LAMP. Ahora ya solo te queda  crear cursos e ir probando su funcionamiento pues es muy completo y tiene cientos de módulos para aumentar sus funcionalidades.

Silex

Silex es un microframework PHP creado por los mismos desarrolladores de Symfony2 y está basado en el mismo pues comparte buena parte de sus componentes. Podriamos decir que Silex es la versión ligera de Symfony2, pues ocupa 5 MB frente a los 8 MB de Symfony2. La gran diferencia con Symfony2 es su facilidad de uso pues en poco tiempo podrás dominarlo, eso si no es apto para proyectos web demasiado grandes pero tiene mucho potencial.

La documentación de Silex está totalmente en inglés y puede que a muchos les eche para atrás, pero por suerte Nacho Pacheco ha traducido toda la documentación al español y puedes consultarla online.

1 – El primer paso es descargar el archivo de instalación de Webmin a nuestro ordenador.

2 – Después nos situamos en el directorio donde descargamos el archivo y ejecutamos el siguiente comando en la terminal:

sudo dpkg -i webmin_1.610_all.deb

3 – A continuación abrimos un explorador y escribimos la dirección( si el nombre de tu equipo no es ubuntu cambialo por el que tienes):

https://ubuntu:10000

Tendremos que aceptar el certificado y acto seguido se mostrará una pantalla de login con la que acceder a la aplicación. El usuario y la contraseña son los mismos que los de tu usuario de Ubuntu.

1 -El primer paso es abrir el SDK de Android y encender el teléfono. Si no lo has hecho ya, hay que agregar una tarjeta SD al dispositivo virtual. Para ello solo tienes que acceder a tu dispositivo y pulsar “Edit” para editar su configuración y en “SD Card” establece el espacio que consideres oportuno. Después arranca el dispositivo.

2 - Hecho lo anterior, abrimos el explorador y accedemos a http://www.whatsapp.com/android/ y descargamos el archivo .apk

3 – Ejecutamos el archivo apk descargado y se iniciará la instalación

3 – A partir de aquí tienes que introducir un número de teléfono y agregar los contactos que quieras, al igual que en tu teléfono móvil

1 – El primer paso es descargar la última versión del SDK en su web oficial.

adt-bundle-linux-x86_64.zip

Puede ser tanto la versión de 32 bits como de 64 bits en mi caso seleccione la versión de 64 bits

2 – El siguiente paso es descomprimir el archivo

3 – Abrimos una terminal y nos situamos en la carpeta adt-bundle-linux-x86_64/sdk. Ejemplo:

cd adt-bundle-linux-x86_64/sdk

4 – Ejecutamos lo siguiente en la terminal:

sudo  tools/android

5 – Se abrirá una pantalla gráfica donde seleccionamos los archivos que queremos instalar y marcamos todo.

6 – Una vez esté todo instalado, tenemos que crear un dispositivo virtual, para lo cual accedemos igual que antes con el comando tools/android y en el menú seleccionamos Tools -> Manage AVDs -> New y escribimos un nombre para el nuevo dispositivo virtual, en mi caso AvdPortalbit, un dispositivo(el que tenga las características que mas te interesen) y la versión de Android:

7 – El siguiente paso es seleccionar el dispositivo virtual y arrancarlo(start):

8 – Nos dará la opción de seleccionar un tamaño para mostrar la pantalla de la aplicación, establece el que mas te interese:

9 – Arrancará el dispositivo y nos mostrará la pantalla de un smartphone con la versión de Android que hayamos seleccionado(hay que pulsar el botón de encendido):