Desarrollo PHP para todos

Diseñando una aplicación desde cero parte 2

2016-02-01T21:45:00.000-04:30

Buen día, en la entrada anterior obtuvimos un diagrama de clases según un requerimiento ahora comenzaremos a convertir este diagrama en una app funcional, para esto podemos utilizar cualquiera de los frameworks de la variedad que tenemos en php (symfony, laravel, yii, zend, etc.) o incluso php puro y duro (para mi usar un framework opción super recomendada), en esta entrada se trabajará con symfony2.8 destacando que no es un tutorial de como trabajar con symfony por lo que no se explicará estructura del framework ni nada por el estilo, el punto es ir haciendo la aplicación según el diseño, el mismo diseño debería de servir para cualquier otro y ya con las manos en el código se mostrará como ir aplicando Test Development driver TDD a nuestra aplicación, por supuesto usando PHPUnit como framework base paras las pruebas unitarias.

Lo primero es conocer un poco de TDD, en síntesis la teoría es la siguiente, escribe la test de la funcionalidad a aplicar, corre el test y estarás en rojo, realiza el código para que la test funcione y pasa a verde, el punto principal es que según el diseño que se pensó para la aplicación se vayan realizando las test y codeando la funcionalidad, no es hacer un millón de test y luego ir al código sino al contrario, escribe test, escribe el condigo necesario de la funcionalidad para que ella pase a verde y pasa a la siguiente test, repite hasta que termines la app (suena divertido :)). Aplica refactory si es necesario (no es el tema principal en este artículo pero es parte del ciclo de TDD), ahora sí manos al código.

Según el diagrama diseñado en la entrada anterior tenemos una entidad Album y una Artista por lo que lo primero que tenemos que hacer son comenzar las test de nuestra entidad, para ello en la carpeta de test escribimos lo siguiente

https://gist.github.com/carlosbelisario/71c1ba6b81ce22943a5b

Como podemos ver, la test es simple y se autocomenta (importante para las test ya que las mismas no sirven de doc muchas veces) y lo que probamos es que haya instancia de nuestra entity a testear. Una vez culminado el código de la test procedemos a correrlo lo cual nos dará como resultado

.PHP Fatal error: Class 'AppBundle\Entity\Album' not found ...

Es lo esperado según la técnica que estamos usando, el test esta en rojo ¿por que? obviamente no hemos aún creado nuestra entidad, en el caso de symfony podemos hacer uso de su consola para crearla o podemos hacerlo a pie (a gusto del consumidor) y obtendremos

https://gist.github.com/carlosbelisario/714a37a94c6c0258b64d

si volvemos a correr nuestra test ahora si tendremos el verde que deseamos y si ya finalizamos la primera test, simple cierto.

Seguimos revisando nuestro diseño y vemos que nuestra entidad tiene comportamiento que debemos testear, si tenemos un método para añadir los artistas a nuestro album y según la cardinalidad podemos agregar muchos artistas al mismo, doctrine nos provee de un tipo de datos llamado ArrayCollection que implementaremos en la entidad, pero vayamos a la test

https://gist.github.com/carlosbelisario/790574b289899627a5e7

Como se puede observar, la test cambio un poco añadimos un método setUp para inicializar en cada test nuestro objeto a testear Album en este caso, y se añadió la funcionalidad que se necesita si volvemos a correr la test encontraremos que estamos en rojo nuevamente y ¿que tenemos que hacer? realizar el código para pasar a verde, el cual para nuestro caso será el siguiente.

https://gist.github.com/carlosbelisario/283f67b5adeb06168937

Volvemos a correr la test y ya nuevamente todo en verde, en este punto podemos ver que tenemos setter y getter dentro de nuestra entidad (el comando de consola de doctrine es genial y nos creo todos los que necesitamos) la pregunta del millon

¿se deben hacer test de todos los getter y setter?

En mi opinión personal no, solo si tienen alguna lógica específica se deberían de hacer test, documentandome sobre el tema he leído personas que concuerdan con este punto, pero todo es cuestión de puntos de vistas y opiniones

Como podemos ver ya hemos implementado las test de la primera entidad (el comando de consola de doctrine nos apoyo con el segundo método que faltaba) el cual podemos ver su test aquí

https://gist.github.com/carlosbelisario/770c537ca6802cb6c80b

Antes de concluir es importante indicar que una test en rojo no significa que sea un error y una test en verde no significa que la test este 100% correcta siempre hay que tener en cuenta el concepto de refactory para nuestras test y nuestro código de manera que el software que tengamos sea software de calidad.

Espero que la entrada sea de agrado cualquier comentario o mejora será bien recibido y recordar hay que crear test verlas en rojo y luego pasar a verde. Saludos

Curso de introducción a java challenge2

2016-01-26T22:41:00.002-04:30

Buen día, en esta segunda entrada de los challenge que van saliendo del curso de lynda up and run java, ya con un poco más de contenido dado en el curso, ya indicaron la existencia de métodos, estructuras de control (bucles y condicionales), métodos y sobrecarga de métodos para jugar un poco más con lo que se puede hacer con lo dado y veamos que se puede hacer con el challenge al oopstyle

El reto en este caso no es más que llevar el costo de la estadía de los pacientes en un hospital, teniendo los siguientes datos

datos de estadía
hay que determinar si existen sobrecargos en la estadía
cargos por medicamentos
cargos por laboratorio

acá lo que se implemento del código

código challenge 2

cualquier comentario, sugerencia critica es aceptada, saludos

Challenge1 curso up and run java lynda

2016-01-25T12:10:00.003-04:30

Buen día, en esta entrada estaré compartiendo un repositorio que he creado para los challege del curso de java que estoy realizando en lynda.com, el punto principal es mostrar el código de estos challenge como los va brindando el instructor de lynda, cabe destacar que es un curso introductorio a java, el primer challenge como no se ha llegado a la separación en objetos la gente de lynda lo hizo a la manera estructurada todo en el método main, pero por ir un poco más allá cree un paquete donde separe en objetos e hice el mismo programa al estilo POO.

El challenge trata acerca de calcular el área de pintura de una casa, quitando las ventanas y las puertas de la misma, la formula fue dada en el mismo curso, sin mas preambulo les dejo el repositorio con el código

Repositorio del Challenge1

Cabe destacar que no soy un experto en java, si consiguen detalles o piensan que hay una mejor manera de aplicar al código pueden dejarla en los comentarios serán bien recibidos, saludos y espero sea de su agrado

Diseñando una aplicación desde un requerimiento (parte 1)

2016-01-23T17:15:00.001-04:30

Buen día esta es la primera de varias entradas donde se diseñará y construirá una app partiendo desde un requerimiento, el mismo será el siguiente:

Se necesita una aplicación que permitirá a los gestores de una discográfica mantener su histórico de producciones, con la lista de los artistas que han participado en cada una. En particular, los usuarios deben poder:
1. Crear, modificar, borrar y listar (con todos los campos relacionados) álbumes
2. Crear, modificar, borrar y listar artistas
3. Añadir y quitar artistas de un álbum existente.
Notas adicionales:
• Un álbum tiene un título y una fecha de publicación.
• De los artistas se conoce el nombre y el instrumento o rol.
• Los artistas se presentarán en el orden en que han sido añadidos al álbum.
• La aplicación se ejecutará en un servidor accesible solo desde la oficina del promotor, y por lo tanto no necesita ningún tipo de control de acceso.

La idea principal es utilizar aplicar y compartir diferentes técnicas que utilizamos para el diseño y desarrollo de una aplicación, sin más preámbulo comencemos con la primera fase (ya teniendo los requerimientos de la aplicación) la misma en nuestro caso será la identificación de entidades que participan dentro del sistema, viendo el requerimiento escrito buscaremos los sustantivos para hacer esta identificación, los cuales viendo el escrito muy simplemente se puede ver que estarán:

Una vez identificadas las entidades pasamos a ver los atributos de las mismas de manera que podamos ir modelando la aplicación de manera correcta, los atributos los identificaremos en nuestros requerimientos como las características que describen a nuestras entidades, por lo que actualizando el diagrama de clases quedaría de la siguiente manera

Luego de tener las entidades con atributos pasaremos a verificar cuales serán las operaciones o métodos de las mismas, los métodos los reconoceremos por medio de verbos o acciones que según los requerimientos ejecutan las entidades, por lo que nuevamente actualizaremos el diagrama de clases el cual quedaría:

Ya tenemos nuestra primera instancia del diagrama de clases según lo descrito en el documento, una vez teniendo esto hacemos una revisión para ver que todo este correcto y de no ser así realizaremos un reactory para que el diseño quede acorde a lo que se pide en el requerimiento, entonces manos al diagrama.

Lo primero viendo los atributos de la clase Artista se puede observar que tenemos el atributo rol de tipo string (no lo especificaron pero es lo primero que se ocurre por la descripción de especifican del mismo, muy obviamente se nota que rol es una asociación a un artista por lo que tendremos que sacar una entidad de este tipo, agregaremos también el método para añadir y eliminar el rol a la asociación, también realizaremos la asociación de Album hacia Artista ya que en el requerimiento se nos indica que al Album se le añaden los artistas asociados al mismo, lo siguiente es que las acciones "Crear, modificar, borrar y listar" son lo que normalmente llamamos CRUD y serán realizadas por medio de un ORM que utilicemos (en siguiente entrada indicaremos cual en específico se utilizará) por lo que las sacaré a una entidad aparte que llamaré ORM, la misma tendrá las operaciones del CRUD, entonces nuestro diagrama de clase va quedando de la siguiente manera.

Como podemos ver tenemos ya el diseño de lo que según el requerimiento de la aplicación necesitamos, si en algún momento se ve que se necesita algo más o hacer una modificación se realiza la refactorización del diagrama, aunque en general el mismo esta completo. Cualquier observación, sugerencia o modificación al diseño es bien recibida y/o debatida, saludos espero que la entrada sea de su interés y podamos debatir un poco sobre el proceso que se realizó

Zend y Symfomy el equipo perfecto

2012-12-03T22:27:00.000-04:30

Una diapositiva muy interesante que conseguí leyendo un poco los temas que se trataron en la ZendCon 2012 Espero que sirva un poco, para ver las cosas que se pueden hacer si se siguen bien los standares, saludos

Script de comparación entre rangos de fechas

2012-08-08T15:12:00.001-04:30

Este es un pequeño script que realice para dar una respuesta en foros del web, y me pareció que vale la pena compartirlo, ando un poco fiebruo con eso de los closures, por lo que me hice uno para hacer este script

date_default_timezone_set('UTC');

$rangeBettweenRange = function(array $range1, array $range2) {
    $from1 = new DateTime($range1[0]);
    $to1 = new DateTime($range1[1]);
    $from2 = new DateTime($range2[0]);
    $to2 = new DateTime($range2[1]);    

    $range1Diff = $from1->diff($to1);    

    for($i = 0; $i <= $range1Diff->days; $i++) {    
        if($from1 >= $from2 && $from1 <= $to2) {
            $return[$from1->format('d-m-Y')] =  "in the range 
";
        } else {
            $return[$from1->format('d-m-Y')] = "out the range
";
        }
        $from1->modify("+1 day");        
    }
    return $return;
};

El resultado es algo como esto

Array
(
    [01-01-2012] => out the range

    [02-01-2012] => out the range

    [03-01-2012] => out the range

    [04-01-2012] => out the range

    [05-01-2012] => out the range

    [06-01-2012] => out the range

    [07-01-2012] => out the range

    [08-01-2012] => out the range

    [09-01-2012] => out the range

    [10-01-2012] => out the range

    [11-01-2012] => out the range

    [12-01-2012] => out the range

    [13-01-2012] => out the range

    [14-01-2012] => out the range

    [15-01-2012] => in the range 

    [16-01-2012] => in the range 

    [17-01-2012] => in the range 

    [18-01-2012] => in the range 

    [19-01-2012] => in the range 

    [20-01-2012] => in the range 

    [21-01-2012] => in the range 

    [22-01-2012] => in the range 

    [23-01-2012] => in the range 

    [24-01-2012] => in the range 

    [25-01-2012] => in the range 

    [26-01-2012] => in the range 

    [27-01-2012] => in the range 

    [28-01-2012] => in the range 

    [29-01-2012] => in the range 

    [30-01-2012] => in the range 

    [31-01-2012] => in the range 

)

el que hacer con el resultado ya queda del desarrollador. Espero que el script sea de utilidad, saludos

Temas más vistos y con más respuestas de MyBB Forum con YiiFramework

2012-07-26T20:18:00.000-04:30

En esta entrada compartiré unos pequeños script que realice para la gente de yiiframework en español, esarriba, como hacerlo, luego en un proyecto creado con YiiFramework generamos el modelo Threads con la herramienta Gii de YiiFramework, también necesitaremos generar el modelo Posts, un simple script que nos permite por medio de YiiFramework conocer los temas más vistos y con más respuestas de un foro de MyBB.

Aclarando que ya tenemos que tener configurado el foro de MyBB, pueden ver en el enlace que se dejo

arriba como hacerlo, luego en un proyecto creado con YiiFramework generamos el modelo Threads con la herramienta Gii de YiiFramework, también necesitaremos generar el modelo Posts ambos extienden del Active Record de Yii, comenzamos a trabajar en nuestro código

Lo primero es hacer la relación entre ambos models/Threads.php

    /**
     * @return array relational rules.
     */
     public function relations()
     {
        // NOTE: you may need to adjust the relation name and the related
 // class name for the relations automatically generated below.
 return array(
     'posts' => array(self::HAS_MANY, 'posts', 'tid'),
 );
     }

models/Posts.php

    /**
     * @return array relational rules.
     */
     public function relations()
     {
        // NOTE: you may need to adjust the relation name and the related
 // class name for the relations automatically generated below.
 return array(
            'threads' => array(self::BELONGS_TO, 'Threads', 'tid'),     
 );
     }

De esta manera tenemos la relación, una vez establecemos esto, realizamos el método hotpost, que es el que nos da los datos que necesitamos

/**
* hotThread return the hot threads of the foro
* @param  string  $type   [description]
* @param  integer $length [description]
* @return [type]          [description]
*/
public function hotThread($type = 'views', $length = 5)
{
    if($type == 'views') { //shows the hotpost for views
        $criteria = new CDbCriteria();
 $criteria->select = 'tid, subject, views, dateline, username';
 $criteria->with = array(
     'posts'=>array(                     
         'joinType'=>'LEFT JOIN', 
         'order' => 'pid',                     
         ),
 );   
 $criteria->order = 'views DESC';
 $criteria->together = true;   
 $criteria->limit = $length;
        $dataProvider = new CActiveDataProvider($this, array(
            'criteria' => $criteria,                                    
            'pagination'=>array(
                'pageSize'=>20,
            ),
        ));            
    } elseif($type == 'answerd') { //show the hotpost by answerd
        $criteria = new CDbCriteria();
 $criteria->select = 'tid, COUNT(posts.tid) as length, subject, views, dateline, username';   
 $criteria->order = 'length DESC'; 
 $criteria->with = array(
     'posts'=>array(                    
         'joinType'=>'RIGHT JOIN',  
         'order' => 'pid',         
         ),
 );
 $criteria->together = true;   
 $criteria->group = 'posts.tid';
 $criteria->limit = $length;
        $dataProvider = new CActiveDataProvider($this, array(
            'criteria' => $criteria,                                                    
        ));
    }
    return $dataProvider;
}

Como vemos estamos obteniendo un nuevo atributo para la categoría por respuesta, entonces tenemos que agregar a nuestra clase Threads el atributo length

class Threads extends CActiveRecord
{
    public $length;
    /*...*/

Ya que obtuvimos los hotpost por su respectiva categoria (visitas y respuestas), ahora realizaremos el controller, controllers/SiteController.php

public function actionHotpost()
{        
    $threads = new Threads();  
    $dataProviderVisitPost = $threads->hotThread('views');
    $dataProviderMostAnswerdPost = $threads->hotThread('answerd');
    $this->render('index-test',array(
        'dataProviderVisitPost'=>$dataProviderVisitPost,
        'dataProviderMostAnswerdPost' => $dataProviderMostAnswerdPost)
    );                
}

Ahora, hacemos la vista, esta consta de un CListView,
views/site/index-test.php

pageTitle=Yii::app()->name; ?>

h1="">
titulo de la pagina
/h1>
h2="">
Temas más Visitados
widget('zii.widgets.CListView', array(
    'dataProvider'=>$dataProviderVisitPost,
    'itemView'=>'_hotpostitem', 
));?>

h2="">
Con mayor numero de respuesta /h2>
widget('zii.widgets.CListView', array(
    'dataProvider'=>$dataProviderMostAnswerdPost,
    'itemView'=>'_hotpostitemvisit',   
));?>

Disculpen los horrores en las etiquetas html, no le tengo instalado plugin para codigo al blog, por eso no esta el principio <.

Ahora solo nos queda realizar el código de
views/site/_hotpostitem.php

div class="view">     
   h2>subject); ?>/h2>
   span>Creado por: username);?> en la fecha dateline));?>/span>
   p>Visto: views); ?>/p>  
   p>posts[0]->message, 0, 350)); ?>/p>   
   a href="http://localhost/mybb/Upload/showthread.php?tid=tid)?>" alt="leer mas">Leer mas/a>
/div>

Y de views/site/_hotpostitemvisit.php

div class="view">     
   h2>subject); ?>/h2>
   span>Creado por: username);?> en la fecha dateline));?>/span>
   p>Cantidad de Respuestas: length - 1); ?>/p>  
   p>posts[0]->message, 0, 350)); ?>/p>   
   a href="http://localhost/mybb/Upload/showthread.php?tid=tid)?>" alt="leer mas">Leer mas/a>
/div>

Espero que este sirva de agrado a los que lo lean, el código pronto estará en github, en la cuenta de yienespanol y en la de mi persona, saludos

CrugeMailer una extensión para enviar correos electrónicos con YiiFramework

2012-07-14T20:44:00.001-04:30

Buenas esta entrada es para presentar la librería CrugeMailer, es una librería para enviar correos electrónicos con YiiFramework, simple de configurar, simple de usar implemeta la librería Swiftmailer para enviar correos electrónicos con php.

¿Como la usamos?

Clonamos la librería en la carpeta extensions de nuestra aplicación "pathapplication/protected/extensions"

cd /pathapp/protected/extensions/

git clone https://github.com/carlosbelisario/crugemailer

Necesitamos también la librería swiftmailer para esto realizamos los siguiente

git submodule init
git submodule update

Una vez tenemos la librería instalada la librería tenemos que hacer la configuración en el main

'import'=>array(
    'application.models.*',
    'application.components.*',
    'application.extensions.crugemailer.*',        
),

'component' => array(

/*...*/

    'crugemailer'=>array(

         'class' => 'application.extensions.crugemailer.CrugeSwiftMailer',

         'mailfrom' => 'christiansalazarh@gmail.com',

         'transport' => 'gmail' // gmail para usar el stmp de gmail (recomendado), no especificarlo trabajara la librería con la función mail de php

/**

         * obligatorios si el transporte es gmail

*/

         'gmailAcount' => 'carlos.belisario.gonzalez@gmail.com',

         'gmailPassword' => 'password de gmail',

         'subjectprefix' => 'Prefijo que deseas agregar, es opcional - ',

),

);

Luego de tenerla configurada simplemente cuando necesitemos mandar un mail lo que debemos hacer es lo siguiente

Yii::app()->crugemailer->sendEmail('el cuerpo de lo que va a ser enviado en el mensaje',
/*destinatario del mensaje*/array('carlos.belisario.gonzalez@gmail.com'),
array('contac@midominio.com'),/*opcional puede configurarse en
el application/config/main*/
'Asunto del Correo Electrónico'/*opcional*/);

Y ya estamos enviando correos electrónicos desde YiiFramework con la librería swiftmailer

Espero que la librería les sea útil, esta todavía en desarrollo para mas funcionalidades pero actualmente ya envia los correos, saludos

Configurando la Extensión YiiDoctrine2Orm

2012-06-30T17:33:00.002-04:30

Buenas en esta entrada indicaré cada uno de los pasos a seguir para configurar la extensión YiiDoctrine2Orm y tener disponible el popular ORM Doctrine2 en una aplicación creada con YiiFramework, esta entrada me surge de el pequeño trabajo que me dio configurarla (ya que en la web oficial no tienen un tutorial paso a paso de la configuración) aunque abriendo los archivos de la extensión es muy intuitiva e incluso te traen el main.php y console.php de ejemplo para que puedas tener esta librería a disposición.

Lo primero que tenemos que hacer claro esta es bajar los archivos de la extensión desde la página del proyecto, también tenemos que tener instalado también Doctrine 2 en nuestro equipo personalmente tengo el ORM en un repositorio separado a la de los proyectos y tengo un link a las carpetas del proyecto para poder hacer las actualizaciones al mismo y que este cambie en todos los proyectos que uso (en desarrollo cuando pasa a producción si es en un servidor externo hay que copiar las librerías).

Una vez tenemos el ORM y la extensión de YiiFRamework, descomprimimos la carpeta d2ormext-1.0.1.zip, en la carpeta "/applicationpath/protected/extensions/", una vez descomprimida ingresaremos a la carpeta "/applicationpath/protected/extensions/Wildkat/YiiExt/DoctrineOrm/vendor/Doctrine/" y hacemos lo siguiente

ln -s /ruta/hacia/doctrine2/lib/vendor/doctrine-common Common

ln -s /ruta/hacia/doctrine2/lib/vendor/doctrine-dbal DBAL

ln -s /ruta/hacia/doctrine2/lib/vendor/doctrine-build-common build-common

ln -s /ruta/hacia/doctrine2/lib/Doctrine/ORM ORM

Ahora nos posicionamos en la carpeta "/applicationpath/protected/extensions/Wildkat/YiiExt/DoctrineOrm/vendor/Symfony" y hacemos el siguiente enlace

ln -s /ruta/hacia/doctrine2/lib/vendor/Symfony/Component Component

Una vez tenemos estos archivos debemos hacer lo siguiente en nuestro archivo applicationpath/protected/config/main.php y applicationpath/protected/config/console.php

agregamos la siguiente linea antes del arreglo

Yii::setPathOfAlias('Wildkat', realpath(dirname(__FILE__) . '/../extensions/Wildkat'));

luego en el indice componente del arreglo agregamos lo siguiente

'components'=>array(

    // los componentes que ya tengamos configurados

    'doctrine' => array(
     'class' => 'Wildkat\YiiExt\DoctrineOrm\DoctrineContainer',
     'dbal' => array(
         'default' => array(
             'driver' => 'pdo_mysql',
             'host' => 'localhost',
             'dbname' => 'dbname',
             'user' => 'userdb',
             'password' => 'passworddb',
         ),
     ),
     'cache' => array(
         'default' => array(
             'driver' => 'ArrayCache',
             'namespace' => '__app',
         ),
     ),
     'entityManager' => array(
         'default' => array(
             'connection' => 'default',
             'metadataCache' => 'default',
             'queryCache' => 'default',
             'entityPath' => 'application.models.entities',
             'mappingDriver' => 'YamlDriver',
             'mappingPaths' => array(
                 'application.models.entities'
             ),
             'proxyDir' => 'application.data',
             'proxyNamespace' => 'Proxy',
         ),
     ),
 ),

persomalmente cambie la carpeta donde que hace el mapping a la misma donde creo las entidades "application.models.entities", sin embargo cada quien puede configurarla donde desee.

Una vez tenemos esta configuración ahora tenemos que copiar el archivo applicationpath/protected/extensions/Wildkat/YiiExt/DoctrineOrm/commands/DoctrineOrmCommand.php a la carpeta applicationpath/protected/commands para tener disponible en yiic las ordenes para trabajar con doctrine.

Como se indico la extensión es muy intuitiva para configurar, ahora lo que nos queda es usar el ORM en nuestras aplicaciones de YiiFramework si no deseamos trabajar con el Active Record por defecto que trae el mismo, saludos espero que sea de ayuda este post

Comparación simple entre algunas extensiones para el control de acceso de YiiFramework

2012-06-24T15:01:00.002-04:30

Como lo prometido es deuda, estuve jugando un poco con las extensiones para control de acceso que me recomendaban en la Página de facebook de YiiFramework en Español, a partir de esto realice una pequeña comparación entre las que me comentaban, espero que pueda servir de ayuda al momento de la elección, aunque la comparación no esta muy detallada ya que no ligue ninguna con un gestor de usuarios como tal, sin más preámbulos vamos a la comparación

AuthManager

Es el componente que trae el framework por defecto, simplemente lo importamos, y hacemos una configuración tan simple como crear una base de datos o incluso un archivo llamado auth.php como lo indican acá en este post http://www.yiiframework.com/wiki/65/how-to-setup-rbac-with-a-php-file/, simplemente sencillo de trabajar, fácil de configurar por lo tanto es la elección de muchos que les gusta hacer su propia gestión de control de acceso, como bien me recomendaba una persona en la conversación que tuvimos en la Página de facebook de YiiFramework en Español

Actualmente es el que tengo en un proyecto ya que hasta ahora estaba buscando cual extensión se me hacía mejor para este tema del control de acceso.

SRBAC

En las pruebas realizadas a esta extensión, pude notar facilidad para configurarlo, tan simple como seguir los pasos de la documentación que colocan en la web de la extensión, aunque en la línea de la clase de configuración para el login

'class'=>'modules.srbac.components.SDbAuthManager'

” falto colocar al principio el application al principio para que pudiera el autoload cargarlo, sin embargo una vez configurado correctamente

'class'=>'application.modules.srbac.components.SDbAuthManager'

, es algo intuitivo para cualquier usuario que trabaje con el framework se da cuenta de que falta ese detalle para que logre iniciarse el modulo, una vez establecido la interfaz aunque me habían comentado que deja que desear, me pareció fácil de manejar y muy simple para el momento de manejar los roles, tareas y operaciones de los usuarios, ya esta internacionalizado para nuestro lenguaje, solo vi un pero corrijan si estoy errado o si hubo una mala configuración de mi parte (ando comenzando con el framework así que puede pasar), me dejo ingresar al módulo de srbac sin pedirme ningún login (a mi manera de ver un fail ya que le estoy dando a cualquier visitante la oportunidad de tener el control de mis listas de acceso), aunque en mi investigación según vi en algunos foros, se resuelve con un condicional (aunque sigo pensando la extensión debería de tenerlo en cuenta porque es la seguridad), sin embargo muy intuitivo y para los que están acostumbrados a utilizar authManager seguro se les hará simple ya que esta basada en esta.

YiiRights

El más recomendado en la Página de facebook de YiiFramework en Español, y cuando lo instalamos podemos ver el porque, simple, una interfaz mas limpia en cuanto a la estructura del html se refiere, fácil de instalar y configurar, la documentación super detallada, tiene la traducción a nuestro lenguaje, en fin una excelente herramienta para trabajar el control de acceso, no le encontré ningún pero, ya veo el porque es tan recomendada, me hablaron de integrarla con yiiUser, pero como estaba tocando el tema solo de control de acceso no quise darle ventajas a ninguna extensión. Aunque tiene una ventaja en lo personal esta en github https://github.com/schmunk42/yii-rights solo un git clone y ya tenemos nuestra extensión en la carpeta de la aplicación

YUM

Es mas que un simple control de acceso es un sistema completo de usuario que gestiona varios componentes, es decir te monta la gestión de usuarios con tan solo una configuración simple, es mucho mas complejo que los mencionados anteriormente ya que esta basado en diferentes módulos, para los que necesitan la gestión de usuarios ya montada YUM es la elección, ya que tiene todo lo relacionado a registros asignación de permisos creación de permisos, en lo personal para proyectos a grandes rasgos creo que es la elección, pueden ver acá todo lo que esta ofrece http://code.google.com/p/yii-user-management/ y por supuesto descargar y probar esta excelente extensión

Una vez probadas todas las extensiones claro que YUM esta por encima de las otras motivado a que esta tiene toda la gestión de usuarios, sin embargo como indique en el grupo la veo muy compleja para proyectos a pequeños rasgos (aunque siempre pueden crecer), la segunda opción de las estudiadas sería como podemos ver Rights debido a la facilidad y simplicidad que esta ofrece de hecho se tendría que unir con yiiUser como me recomendaron para poder hacer una comparación entre YUM y esta completamente, seguiría por supuesto SRBAC que le encontré en mis pruebas el detalle de la falta de solicitud de autenticación para poder gestionar los roles de usuario y por última el authManager y explico porque, como se observo cuando se estaba haciendo las pruebas con las extensiones tanto rights como srbac están basadas en esta, de hecho ya nos proveen una interfaz gráfica para el manejo de los roles y estaríamos sacando a mi parecer más provecho de esta extensión si utilizamos alguna que ya nos tenga un poco de trabajo ya realizado.

Espero que este post sea informativo y aclaratorio para todos los que lo lean por supuesto si hay comentarios o correcciones en cuanto a cada una de las extensiones que se mencionaron no duden en indicarlos, el tema por supuesto va al grupo del facebook ya que de ahí fue de donde salio, saludos

Lo nuevo que nos traerá YiiFramework 2

2012-06-17T18:39:00.000-04:30

Como ya había comentado en el post anterior actualmente me estoy nutriendo mucho con YiiFramework, hoy leyendo en http://www.linkedin.com/ en el grupo de Yii, me encontré con esta presentación que nos dice todo lo que traerá este framework para su siguiente versión.
Dejo la presentación:

YiiConf 2012 - Alexander Makarov - Yii2, what's new

View more presentations from Alexander Makarov

Como pueden ver el camino por el que va es a mejores prácticas de programación, implementación de los namespace, mejoras en el Active Record, aplicación del estandar PSR-0 para los autoload, en fin la presentación ya lo dice todo.

Si ven el caminó hacia el que va es simplemente muy parecido al que ya tomo symfony2 y para el que va Zend Framework también en su versión 2, cada uno aplicando por supuesto su forma de desarrollar.

Saludos espero que les sea de utilidad esta presentación

Introduciendonos en el mundo de los Frameworks PHP

2012-06-12T18:05:00.000-04:30

En esta entrada se tocará un tema un tanto polémico, y aunque la intención no es caer en batallas de mi framework contra el de los demás, si es dar una idea a todos los desarrolladores PHP que no se han adentrado en el mundo de los frameworks.

Lo primero que debemos tener claro es que es un framework PHP, mi definición sería es una herramienta para desarrollar aplicaciones web con el lenguaje. Un conjunto de librerías que una vez aprendida a utilizar nos facilitan el trabajo, ya que nos brindan una cantidad de códigos que nos evitan el reescribir una y otra vez los mismos script.

¿Porque un framework?

Esta es una pregunta que muchos cuando comenzamos a adentrarnos mas en el lenguaje nos hacemos, porque un framework si yo ya he hecho mis propios sistemas que funcionan, ya que hacen lo que se quería. Mi respuesta muy directa y viene de la mano con la definición es que estos nos brindan una serie de librerías y evitamos el reescribir nuevamente una y otra vez el mismo código, además de que estos framework tienen un soporte de la comunidad y están realizados bajo buenas prácticas de programación.

¿Puedo hacer mi propio framework?

Esta es la pregunta del millón, siempre que me la hacen mi respuesta es la siguiente "Claro que pudieras hacer tu propio framework con buenas prácticas de programación", pero no es mejor trabajar con alguno de los que ya existen que son bastantes y participar en esa comunidad, de manera que los esfuerzos y conocimientos que se tienen ayuden a una comunidad entera, que ya tiene cierta cantidad de tiempo trabajando por mantener el framework listo. A esta pregunta también hay muchos que son menos tolerantes que yo (suele pasar :-)) que dicen para que reinventar la rueda si ya existen muchos frameworks realizados con las mejores prácticas de programación.

¿Que busco en un framework php?

Lo principal que se busca es que tengan buenas prácticas de programación, actualmente los frameworks vienen desarrollados bajo una serie de patrones de diseños como lo son Modelo Vista Controlador ( El famoso MVC), Active Record, DAO o DataMapper para el trabajo del ORM que brinde el framewokr, entre otros patrones que estos brindan.

Sistema de plantillas fácil de manejar.

Soporte por parte de la comunidad (es decir que no este en el olvido).

Componentes o librerías que nos brinda el framework.

Facilidad para integrar con librerías externas a lo que son el framework ejemplo (FPDF, Doctrine, etc).

¿Es un framework un CMS?

Esta es una de las preguntas mas comunes que solemos hacernos los desarrolladores (yo no soy muy amante de los CMS aunque lo admito he usado Wordpress XD). Pero un framework y un CMS no son lo mismo, un framework es una herramienta para programadores, que nos brinda una serie de librerías, un CMS es un gestor de contenido ya hecho que con solo montarlo ya tenemos una página, solo hay que acomodarla a nuestro gusto o crear un theme y ya tenemos una web, cualquier diseñador es capaz de montar una web con ellos.

¿Top tres de frameworks (opinión personal)?

Este es la pregunta mas polémica de este post, ya que es la que normalmente crea guerras santas entre cual es el mejor framework para desarrollar con php, aunque solo he probado por encima o testeado con algunos yo pudiera dar estos tres en mi lista:

Symfony 2: Este framework aplica excelentes prácticas de programación, su sistema de plantillas twig es muy sencillo de utilizar, aunque también puede usarse php como motor de plantillas, el sistema de ruteo es simple, tiene como ORM a doctrine 2, su configuración es fácil de realizar, el sistema de bundles que tiene es maravilloso ya que hay muchos realizados lo que hay es que adaptarlos a nuestra situación. Pudiera seguir dando más detalles de este, pero mejor vayan a su web oficial y vean que mas hay.

ZendFramework: Muchos dicen que es el framework ofical de php ya que lo creo y da soporte la comunidad de los que desarrollan el php "Zend", tiene excelentes prácticas de programación aunque dicen que la curva de aprendizaje del mismo es difícil vale la pena aprenderlo. Lo desacoplado de este framework, la cantidad de librería que este brinda y la utilización de las mismas sin necesidad de usar el framework nos dice lo bueno que es el framework.

YiiFramewor: Es un framework super sencillo de utilizar, ademas que aplica excelentes prácticas de programación, trae una serie de librerías que nos permiten crear código de manera fácil y siendo precisos, tiene un componente para crear los CRUD de manera simple permitiendo que el desarrollador se concentre en la lógica específica de su desarrollo.

Personalmente utilizo yiiFramework actualmente, aunque cualquiera de los tres que acabo de nombrar los usaría con gusto.

Espero que este post ayude a los que están comenzando en el trabajo con php a decidirse por utilizar un buen framework con buen soporte, pueden dar su top tres también de framework y el porque sin insultar ningún otro ya que no es el punto llegar a batallas sino informar, saludos

Manejo de errores y excepciones PHP

2012-05-13T12:51:00.002-04:30

Buenas en esta entrada intentaré explicar un poco el manejo de errores y excepciones con PHP, comenzaremos definiendo un poco que es un error a nivel de programación.
Un error es un problema que pasa en cierta línea de programación a medida que nuestro código es interpretado, un ejemplo muy simple pero bastante recurrente, el no colocar el ";" a final de cada línea de instrucción.

Una excepción es un problema o algo inesperado que ocurre al intentar interpretar nuestro código. Si vemos los conceptos en teoría son parecidos más no son lo mismo, es importante hacer la aclaración porque habemos quienes la primera vez que vemos el tema creemos que es lo mismo. Llevemos esto a un ejemplo simple

/**
*
* conexion con el servidor
*/
$dns = 'mysql:host=localhost;db=test';
$user = 'user';
$password = 'password';
// si vemos esta línea el interprete de php encuentra un error al no encontrar el final de línea ";"
$connect = new PDO($dns, $user, $password)

ahora si tenemos el mismo código completo pero no están bien los parámetros de la conexión con mysql esto nos lanzará una excepción

/**
*
* conexion con el servidor
*/
$dns = 'mysql:host=localhost;db=test';
$user = 'user';
$password = 'password';
// si vemos esta línea el interprete de php encuentra un error al no encontrar el final de línea ";"
$connect = new PDO($dns, $user, $password);

Ahora como manejarlas?? PHP desde la versión 4 pero mejorada en la versión 5 tiene un soporte para programación orientada a objetos, por lo que podemos explotar estos beneficios. Para manejar las excepciones php tiene varias palabras reservadas las cuales indicaremos a continuación.

Lo primero que tenemos que conocer es la clase Exception esta nos brinda la posibilidad de manejar todas las excepciones que lance el lenguaje.

Ahora hablaremos un poco de throw: como bien es traducido a nuestro idioma es lanza, lo usamos para indicarle al interprete que debe lanzar una excepción en caso de que algo no sea lo que necesitamos, un ejemplo simple

function test($a) {
    if(!$a) {
        throw new Exception('Error al comparar a');
    } else  {
       echo $a;
    }
}

En esté código lo que le decimos al interprete de php, es si es falso $a lanza una excepción porque necesitas que esté tenga un valor verdadero.

try/catch Estas dos palabras son importantes e interesantes al momento de trabajar con excepciones, como vemos en su traducción a nuestro lenguaje try es trata, intenta ejecutar el código que esta en este bloque, si existe algún problema o algo inesperado catch o captura la excepción, entonces si continuamos la implementación del código anterior que ya nos lanza una excepción entonces realizaríamos lo siguiente

try {
   test(0);
} catch(Exception $e) {
   $e->getMessage(); 
}

Entonces si pasamos 0 el interprete de php lo toma como falso y este automáticamente lanzara la excepción, como vemos el catch pide como parámetro un objeto del tipo Exception, y cuando captura esta excepción muestra el mensaje.

Hasta ahora todo ha sido fácil y sencillo verdad?? Ahora lo vamos a ver un poco más fácil vamos a trabajar como se debe a partir de PHP5 con objetos, para el manejar las excepciones con objetos no cambia mucho, lo que cambia es que podemos utilizar las ventajas como la herencia para extender de la clase Exception y crear nuestro propio objeto para manejar las excepciones.

Para el caso de los objetos trabajaremos con una sencilla clase

/**
*
* class manager of exception
*/
class TestException extends Exception {}

/**
*
* class for testing this article
*/
class Test 
{
    /**
    *
    * @param Int $number
    */
    public function testInteger($number)
    {   
        if(!is_numeric($number)) {
            throw new TestException('Debe de indicar un numero');
        }
        if(is_int($number)) {
            return true;
        } else {
            return false;
        }
    }
}

Entonces cuando nos toque utilizar este objeto deberíamos realizar lo siguiente

try {
    $test = new Test();
    $test->testInteger(1);
    $test->testInteger('hola');
} catch(TestException $e) {
    echo $e->__toString();
}

si ejecutamos el código nos dara como resultado algo como esto

exception 'TestException' with message 'Debe de indicar un numero' in /var/www/loqueras/Test.php:22 Stack trace: #0 /var/www/loqueras/Test.php(35): Test->testInteger('hola') #1 {main}

Con esto ya sabemos donde y que es lo que esta pasando en nuestro código, como ven no hay error de sintaxis, sino más bien de algo que esperaba la clase.

Tocando un poco otro tema en cuanto al manejo de errores hay un tema importantes al momento de trabajar los mensajes de errores, warning, hay muchos códigos o programadores que utilizan el símbolo "@" o operador de control de error para que el interprete de php no muestre en pantalla el error, esto simplemente es una mala práctica al momento de programar, porque?? porque simplemente ocultar un error no lo corrige, solo lo oculta, es como que te barra la casa y te esconda la tierra bajo la sombra y luego pregunten porque me enferme. Buenos por ahora es todo espero que les sirva este post y ayude a entender un poco mas el manejo de errores y excepciones saludos.

Presentación de mi mini Librería FileManager

2012-03-03T18:25:00.000-04:30

Esta entrada es para presentar la primera versión de la librería que estoy creando para el manejo de archivos txt, csv, es 100% programación orientada a objetos, aunque todavía esta en beta, ya estoy trabajando en una segunda versión que agregara mas utilidad y manejo sobre estos archivos, por ahora estoy conforme con lo que hace, pueden probarla si lo desean y me indican si encuentran algún bugs.

La librería esta bajo la licencia GPL por lo tanto se puede copiar, modificar y distribuir con todos los términos que esta licencia indica Todavía no le tengo una documentación por lo tanto mostrare como utilizarla aunque es muy intuitiva, en mi repositorio publico de github encontramos la libreria y la utilizamos de la siguiente manera:
archivo.csv
campo1;campo2;campo3
valor11;valor12;valor13
valor21;valor22;valor23
valor31;valor32;valor33

instanciamos la clase y le indicamos el archivo

    require_once 'filemanager/libs/FileManager.php';

    $file = new file('archivo.csv');
    $fileManager = new FileManager();
    $fileManager->setFile($file);

obtenemos el contenido del archivo en un arreglo

    $contenido = $fileManager->read();
    foreach($contenido as $linea => $contenido) {
        echo "$linea.- $contenido";
    }

podemos mostrarlo o realizar cualquier trabajo que deseemos con el. escribir nuevo contenido al archivo

    $nuevoContenido = "a;b;c\nd;e;f\n";
    $fileManager->changeMode('w');
    $fileManager->write($nuevoContenido);

este metodo borra el contenido anterior del archivo por lo que debemos de ser muy cuidadosos con el, para agregar una nueva linea al archivo necesitamos utilizar el metodo addNewLine

    $nuevoContenido = "a;b;c;";
    $fileManager->changeMode('a');
    $fileManager->addNewLine($nuevoContenido);

como su nombre lo indica agrega una nueva linea. Actualización del archivo

    //el contenido
    $nuevoContenido = "a;b;c;";
    //la linea a actualizar
    $line = 1;
    $fileManager->changeMode('w');
    $fileManager->update($line, $nuevoContenido);

de esa manera se actualiza esa línea sin cambiar nada más dentro del archivo el método save, este método es lo suficientemente inteligente como para escribir todo de nuevo o actualizar el archivo según sea el caso

    //el contenido
    $nuevoContenido = "a;b;c;";
    //la linea a actualizar
    $line = 1;
    $fileManager->changeMode('w');
    //hace lo mismo que write,
    $fileManager->save($nuevoContenido);
    //el metodo verifica que no este vacío, si lo esta hace lo mismo que write, sino lo esta hace el update
    $fileManager->save($nuevoContenido, 1);

El método delete(), este método borra un archivo, cabe destacar que para poder hacerlo el archivo tiene que tener los permisos, sino dará una excepción.

    
    $fileManager->delete();

Método changeMode, a menudo es necesario cambiar el modo para poder hacer los cambios en los archivos ya que por defecto cuando pasamos el archivo a la clase esta abierto como lectura 'r', este método nos permite cambiar el modo para poder agregar información al documento como lo hemos visto en cada uno de los métodos anteriores

    
    $fileManager->changeMode('w');

mas información sobre los modos de apertura de un archivo aca. espero que la librería les sea de utilidad, saludos cualquier comentario es bien aceptado

Rutas en PHP

2012-02-24T22:17:00.000-04:30

Esta es una entrada un tanto informativa, que tenía algo pendiente y al ver algunos detalles en unos códigos en la web me decidí a compartir. Al hablar de las rutas en PHP podemos decir que tenemos dos maneras de implementarlas 1.- Rutas Absolutas: son aquellas en la que colocamos toda la url del archivo que queremos incluir, mencionar, etc, un ejemplo: archivo http://tusitio.com/archivos/incluir.php esta es la ruta de un archivo alojado en tusitio.com en la carpeta archivos el archivo incluir.php

$hola = "Hola Mundo!!";

index.php

require_once('http://tusitio.com/archivos/incluir.php');
echo $hola;

el resultado sería hola mundo en nuestro navegador, ya que incluimos el archivo por medio de una ruta absoluta, fácil verdad?? 2.- Rutas Relativas: Las rutas relativas son un poco mas complejas de explicar, pero sin embargo una vez que entendemos es sencillo saber como llegar desde donde estamos hasta el archivo que queremos llegar, veamos con un ejemplo para ser más específico estructura del sitio htdocs/ ...images/ ......image.png ......logo.jpg ......mygif.gif ...css/ ......style.css ...js ......myJs.js ...index.php ...procesos/ ......miProceso.php ...class/ ......myClass.php supongamos que en el index queremos incluir a miProceso.php, tendriamos que hacer lo siguiente

require_once('procesos/miProceso.php');

lo que indicamos con esta ruta es que desde index.php vaya a la carpeta proceso e incluya el archivo miProceso.php fácil verdad?? Pero que pasa cuando el archivo no esta en una carpeta del mismo nivel, sino que tenemos que salir de nuestra carpeta para llegar al sitio?? debemos utilizar '../' para subir un nivel fuera de nuestra carpeta, es decir, si quicieramos incluir a myClass.php dentro de miProceso.php tendríamos que realizar lo siguiente

require_once('../class/myClass.php');

que hicimos?? al hacer "../" subimos un nivel, es decir subimos desde la carpeta procesos a la carpeta htdocs, una vez en la carpeta htdocs entramos a la carpeta class ("class/") e incluimos el archivo myClass.php dentro de el archivo miProceso.php podemos dentro de las rutas relativas subir niveles e ingresar en carpetas tantas veces como sea necesarío, ver algo como esto ../../carpeta1/carpeta2/archivo.php es una ruta correcta en esta subimos dos niveles y entramos en la carpeta2 que a su vez esta en la carpeta1 espero que sea de ayuda esta entrada, saludos

Clase para gestión de Usuario

2012-01-22T13:37:00.002-04:30

En una Discusión que se formo en un aporte que hizo un compañero de forosdelweb, donde di algunas sugerencias al usuario que lo inicio, quede de hacer una pequeña clase para también aportar al tema en cuestión, y hasta ahora la clase es la siguiente


error_reporting(E_ALL);
/**
 * 
 * clase para gestionar Usuarios
 * @author Carlos Belisario 
 * @version 1.0
 * 
 */
class Usuarios
{
    /**
     * 
     * @var String $usuario
     */
    private $usuario;
    
    /**
     * 
     * @var String $password
     */
    private $password;
    
    /**
     * 
     * @var String $rol
     */
    private $rol;
    
    /**
     * 
     * @var String $estatus
     */
    private $estatus;
    
    /**
     * 
     * @var String $securitySalt
     */
    private $securitySalt;
    
    /**
     *
     * @var PDO 
     */
    private $db;
    
    /**
     *
     * @var String $error
     */
    private $error;


    /**
     *
     * @param PDO $db 
     */
    
    public function __construct(PDO $db) 
    {
        $this->db = $db;
    }

        /**
     * 
     * Getter and Setter
     */
    public function getUsuario() 
    {
        return $this->usuario;
    }
    
    public function setUsuario($usuario)
    {
        $this->usuario = $usuario;
    }
    
    public function getPassword()
    {
        return $this->password;
    }
    
    public function setPassword($password, $salt = true)
    {
        if($salt)
            $this->password = md5($this->getUsuario().$password.$this->getSecuritySalt());
        else
            $this->password = md5($this->getUsuario().$password);
    }
    
    public function getSecuritySalt()
    {
        return $this->securitySalt;
    }
    
    public function setSecuritySalt($securitySalt = 'heyntonwgrnkmoamju33mdowm')
    {
        $this->securitySalt = $securitySalt;
    }
    
    public function getRol()
    {
        return $this->rol;
    }
    
    public function setRol($rol)
    {
        $this->rol = $rol;
    }
    
    public function getEstatus()
    {
        return $this->estatus;
    }
    
    public function setEstatus($estatus)
    {
        $this->estatus = $estatus;        
    }
    
    public function getError()
    {
        return $this->error;
    }

    public function setError($k, $error)
    {
        $this->error[$k] = $error;
    }
    /**
     * 
     * @method login
     * metodo para autnetificar al usuario
     * 
     */
    public function login()
    {
        // aca verificamos que el usuario haya escrito en un formato que comience con letras y pueda estar seguido de un punto, guion bajo o guion 
        if(preg_match("/(^[a-z]{1,20})(?!\s)([\w-\.]{0,20}$)/i",  $this->getUsuario())){
            $sql = "SELECT * FROM usuarios WHERE usuario = :usuario AND password = :password";
            try {
                // hacemos la consulta
                $query = $this->db->prepare($sql);            
                $query->bindParam(':usuario', $this->getUsuario());
                $query->bindParam(':password', $this->getPassword());
                $query->execute();
                $row = $query->fetchObject();
                //verificamos que el usuario exista en la base de datos y la password sea correcta
                if(!empty($row)) {                                                                                  
                    $this->setRol($row->rol);
                    /*podemos pasar el estatus para que se haga la verificacion
                    * e ingrese a una pagina para usuarios deshabilitados, 
                    * para darle motivos e incluso donde comunicarse, 
                    *                            
                    */                        
                    $this->setEstatus($row->estatus);
                        
                    /* o podemos incluirlo en los errores, de manera que no haga login
                    if($row->estatus == "habilitado") {
                        $this->setRol($row->rol);                                                                 
                    } else {
                        $this->setError ('userEstatus', 'El Usuario no esta habilitado');
                    }*/                          
                    
                } else {
                    $this->setError('errorLogin', 'El Usuario o la Contraseña no es Correcta');
                }    
            
             } catch( PDOException $e) {
                 $e->getMessage();
             }                     
        } else {
            $this->setError('erroFormato', 'Formato de usuario no permitido');
        }   
    }
}

/**
* como usar
*/
try {
//establecemos la conexion con PDO
    $db = new PDO('mysql:host=localhost; dbname=prueba', 'root', '123');   
} catch(PDOException $e) {
   echo $e->getMessage();
}
//instanciamos la clase y probamos el login
$class = new Usuarios($db);
//los parámetros estan siendo pasado un login por defecto se puede obtener desde un formulario con $_POST O $_GET
$class->setUsuario('carlos');
$class->setPassword('123456');
//indicamos que realice el login
$class->login();
//sino existe algn error 
if(count($class->getError()) == 0) {
    //realizamos los procesos con las variables de session o incluso si se desea se puede crear un componente de session y le pasamos nuestro objeto usuario con el login correcto
} else {
// gestionamos los mensajes de errores para los usuarios
    echo "";
    print_r($class->getError());
    echo "";
}

hasta ahora llevo realizado esto, sin la gestión de lo que es el CRUD de la gestión de usuarios, sin embargo cuando vaya teniendo tiempo lo iré actualizando, el proyecto lo pueden descargar desde https://github.com/carlosbelisario/juegos_con_clases/ espero que sea de utilidad

Comenzando con PHP - Operadores

2011-06-09T17:20:00.001-04:30

En esta entrada, continuando con la serie de artículos introductorios al PHP, estaremos hablando de los operadores en PHP y lo que podemos ir logrando con ellos, también hablaremos un poco de la concatenación de string, variables profundizando un poco más en el lenguaje en si, aunque todavía no hemos hecho ninguna aplicación :-).

Los operadores no son mas que los carácteres que nos permiten realizar ciertas operaciones, en PHP podemos realizar desde operaciones básicas(suma, resta, etc) hasta algunas un poco más complejas, para no extendernos tanto en el tema comencemos a conocer los operadores básicos en PHP.

Operadores Aritméticos

Como su mismo nombre lo indica son los operadores que nos permiten realizar operaciones aritméticas en nuestros programas, estos son sencillos, ya que son los que diariamente nos encontramos, entre ellos tenemos:

+ (Suma): El signo de mas(+) es el operador que utilizamos para realizar la suma en nuestras operaciones, un ejemplo:
```
$resultado = 1 + 1;
echo $resultado;
```
Sencillo, nada que no hallamos conocido hasta ahora :-).
- (resta): El signo - como es de imaginar lo utilizamos para restar, también nos brinda la sencilles de operaciones que ya hemos realizado.
```
$resultado = 3 - 1;
echo $resultado;
```
* (multiplicación): Para los que no han tenido ninguna relación con un lenguaje de programación normalmente el simbolo del asterisco (*) es el que se utiliza para hacer referencia a la multiplicación, PHP no es la excepción.
```
$resultado = 3 * 5;
echo $resultado;
```
/ (división): Si como lo podemos ver tenemos el slash(/) como signo para identificar la división, ejemplo
```
$resultado = 4 / 2;
echo $resultado;
```
% (modulo): En este momento es cuando los que estamos comenzando empezamos a conocer operadores, para los que no lo conocen el módulo es el residuo que queda de una división, este es muy utilizado al momento de saber si un numero es par o impar, pongamos un ejemplo:
```
$modulo = 10 % 2;
if($modulo == 0){
   echo "el numero es par y su residuo es $modulo";
}
$modulo1 = 9 % 2;
if($modulo1 == 0){
   echo "el numero es par";
}
else{
    echo "el numero es impar y su residuo es $modulo1";
}
echo $resultado;
```
Que es lo que hace el modulo?? divide el numero de la izquierda entre el numero después del símbolo del porcentaje, y retorna como resultado el residuo que quede de esta división, en el primer caso retornaria "el numero es par y su residuo es 0", en el segundo caso "el numero es impar y su residuo es 1", para probarlo hagan una división a mano y vean el residuo y entenderan un poco mas (a practicar matemáticas jaja XD).

Operador de Concatenación de String.

Para concatenar dos string e incluso una variable utilizamos el punto (.) seguido del string que deseemos concatenar un ejemplo.

$variable = "hola";
echo 'yo deseo que se imprima lo que dice la variable y esto es ' . $variable;

El resultado seria "yo deseo que se imprima lo que dice la variable y esto es hola", esta es una simple concatenación para irnos familiarizando, esto lo utilizaremos bastante eso lo aseguro :-).

Operador de Asignación

El operador de asignación en PHP es el signo igual "=", lo utilizamos para asignar valores a las variables, aunque se ve bastante sencillo PHP nos permite varias formas de asignar valores a nuestras variables, veamos algunas de ellas.

= (Igual): Asigna el valor a la variable, ejemplo:
```
$variable = "hola";
```
.= ( punto seguido del signo igual): Asigna un valor a la variable, si la variable ya contiene un valor, el resultado seria el valor actual de la variable concatenado con el valor que deseamos agregar a esta, un ejemplo:
```
$variable = "hola ";
$variable .= "Como estas";
echo $variable;
```
El resultado seria "hola Como estas", fácil verdad??
+= (símbolo de mas seguido del igual): Al igual que con el punto lo que hacemos es sumar al valor que ya contiene la variable (lo que es igual a un acumulador), si hacemos algo como esto
```
$i = 0;
$i += 5;
$i += 10;
echo $i;
```
Si como ya deben de saber el resultado seria 15.

Para no extendernos con este tipo de asignación podemos realizar la misma forma de asignar con cada uno de los operadores aritméticos ya indicados y estos harán la respectiva operación con el valor y luego la asignación.

Operadores de Comparación

Los operadores de comparación como bien su nombre lo indica se utilizan para hacer comparaciones, estos retornan un valor booleano true / false, mayormente lo utilizamos en los condicionales (ya hablaremos de estos), veamos cuales operadores podemos utilizar:

== Doble Igual (Igual que): Colocando el == Indicamos al interprete de PHP que estamos haciendo una comparación de que el valor de la izquierda es igual al valor de la derecha, ejemplo.
```
var_dump(2 == 2);
//retorna true
var_dump(2 == 1);
//retorna false
```
Si copiamos este código y lo vemos en el navegador obtendriamos algo como esto

bool(true) bool(false)
Si es el retorno de nuestras comparaciones.
! (cierre exclamación): Con este operador indicamos al navedador que debe negar una operacion si hacemos algo como esto
```
var_dump(! 2 == 2);
```
Obtendremos bool(false) ya que estamos negando el valor que nos da ese resultado.
!= cierre exclamación igual (diferente): Si como imaginan estamos negando el igual, así que este operador lo utilizamos para indicar que un valor sea diferente, si tomamos el ejemplo inicial
```
var_dump(2 != 2);
//retorna false
var_dump(2 != 1);
//retorna true
```
Ahora obtendriamos el resultado inverso al que colocábamos en la comparación inicial.
<> (diferente): Si es equivalente al operador anterior por lo que podemos utilizar el que deseemos.

<, <=, >, >= estos signos creo que todos en algún momento los hemos visto, pondré un ejemplo del uso de cada uno.

var_dump(2 < 5);
//retorna true
var_dump(5 < 2);
//retorna false
var_dump(2 > 5);
//retorna false
var_dump(5 > 2);
//retorna true
var_dump(5 <= 2);
//retorna false
var_dump(2 <= 5);
//retorna true
var_dump(2 <= 2);
//retorna true
var_dump(5 >= 2);
//retorna true
var_dump(2 >= 5);
//retorna false
var_dump(2 >= 2);
//retorna true

Fácil verdad??.

=== (identico): este operador es muy similar al igual cuando estamos comparando, la gran diferencia es que este evalúa que sean del mismo tipo y el mismo caracter, veamos un ejemplo básico
```
var_dump("1" == 1);
//retorna true
var_dump("1" === 1);
//retorna false
```
pero porque?? si es el mismo numero??
Como se dijo anteriormente las cadenas de carácteres siempre estan entre comillas (así sean números) y los caracteres numéricos no, entonces al preguntar si es igual evalúa que es el mismo caracter, pero si evaluamos si son idénticos al no ser del mismo tipo retorna false.
!== (no identico): al igual que en el anterior este evalúa el tipo de dato que estamos evaluando, en sí este evalúa si no son iguales y que no sean del mismo tipo, ejemplo:
```
var_dump("1" !== 1);
//retorna true
var_dump(1 !== 1);
//retorna false
```
como podemos observar es todo lo contrario al anterior.

Operadores de Incremento:

En PHP podemos incrementar el numero de una variable muy fácilmente, utilizando este tipo de operador, hay cuatro de este tipo y los presentamos a continuación

Pre-incremento ++$i: Cuando hacemos el pre-incremento primero hacemos el incremento en uno a la variable y luego la retornamos ejemplo:
```
$i = 0;
echo ++$i;
echo " 

" . $i;
```
esto me retornara

1
1
Post-Incremento $i++: Este operador hace lo inverso al anterior, retorna el valor y luego incrementa en uno a la variable veamos un ejemplo:
```
$i = 0;
echo $i++;
echo " 

" . $i;
```
0
1
En lo personal mayormente cuando trabajajo con bucles utilizo este operador, aunque cada uno tiene el caso en el cual puede ser usado.
Pre-decremento --$i: Cuando hacemos el pre-incremento primero hacemos un decremento en uno a la variable y luego la retornamos ejemplo:
```
$i = 10;
echo --$i;
echo " 

" . $i;
```
esto me retornara

9
9
Post-Incremento $i--: Igualmente este operador hace lo inverso al descrito anteriormente, retorna el valor y luego decrementa en uno a la variable veamos un ejemplo:
```
$i = 10;
echo $i--;
echo " 

" . $i;
```
10
9

Estos son algunos de los operadores en PHP, los más básicos con los que podemos empezar a hacer nuestros programas, más adelante iremos dando y viendo la utilidad que tienen estos, un saludo y hasta una próxima entrada.

Comenzando con PHP - Variables y Constantes

2011-06-07T21:00:00.000-04:30

En el artículo anterior hicimos nuestro primer código PHP, este fue el popular hola mundo, en el día de hoy vamos a profundizar un poco más en el lenguaje, tocaremos el tema de "Las Variables y las Constantes en PHP".

Lo primero que hay que tener claro es:

¿Que es una variable?

Una variable no es mas que una posición en memoria que guardara un dato específico dentro de nuestro código, en PHP las variables son declaradas con el signo dollar "$" seguido de una palabra que haga referencia al valor que deseamos que esta contenga, un ejemplo de esto seria.

$nombre = "Carlos";
$apellido = "Belisario";

Fácil no??

Como vemos en PHP no hace falta la declaración del tipo de variable que se debe hacer normalmente en lenguajes como JAVA o Lenguaje C, el interprete de PHP entiende el tipo de dato al que pertenece la variable por medio del valor que este contiene.

Tipos de Datos que puede contener una variable

String o Cadenas de Carácteres: Como su nombre lo indica son variables cuyo valor contiene una cadena de carácteres, para definir las cadenas como se dijo en el artículo anterior deben de estar entre comillas Dobles " " o comillas simples ' ', ejemplo:
```
$string = "Esto es una cadena o string";
```
Números Enteros: Son variables que como su nombre lo indican contienen un número entero (sin decimal) dentro de ellas, para declarar estas variables solo hace falta asignar el número a la variable sin comillas, ejemplo
```
$entero = 10;
```
Numeros Reales o Punto flotante: Son variables que contienen un numero real o con decimal dentro de ellos, al igual que los enteros se declaran asignando el valor numérico a la variable sin necesidad de que este entre comillas, el separador entre la parte entera y la parte decimal es el punto "."
```
$real = 15.5;
```
Bool: Los variables con datos de tipo bool almacenan los valores de verdadero (true) o falso (false), son mayormente utilizadas para hacer condicionales (tema del que hablaremos en una próxima entrada).
Array o Arreglos: En PHP como en algunos otros lenguajes tenemos este tipo de variable, útil al momento de guardar múltiples resultados de un solo tipo, este tipo de variable crea un vector con los datos almacenados, los cuales pueden ser de diferentes tipos sin que esto sea considerado como un error, para crear un arreglo podemos hacerlo de diferentes formas veamos los casos:
caso 1:
```
$arreglo = array("dato del primer indice","dato del segundo indice",15);
```
En este caso asignamos al arreglo los valores, indicando la palabra array seguido de los valores dentro de paréntesis, para acceder a un valor de un array debemos hacerlo por medio de los índices del mismo, cuando se crean de esta manera los índices son numéricos y comienzan desde el indice 0 (cero), hasta la cantidad de elementos que tenga el array, en este ejemplo seria
0 => "Dato del primer indice",
1 => "Dato del segundo indice",
2 => 15
La forma de acceder a un valor de un array es por medio de su índice, esto lo hacemos indicando la variable seguida de el índice que deseamos mostrar, entonces si deseamos mostrar el valor del segundo índice tendríamos que hacer algo como esto
```
$arreglo = array("dato del primer indice","dato del segundo indice",15);
echo $arreglo[1]; 
```
lo que daría como resultado una salida en el navegador diciendo "dato del segundo indice"
Fácil verdad

Caso 2:
Asignación dinámica del array
```
$arreglo[] = "Datos del primer índice";
$arreglo[] = "Datos del segundo índice";
$arreglo[] = 15;
```
Como vemos aca asignamos los datos de una manera dinámica, sin necesidad de indicar la palabra array, solo debemos abrir y cerrar corchete (sin índice en el medio) y este automáticamente tomara el indice que deseemos.
Nota: Si deseamos podemos indicar el índice que queremos que tenga el valor en el array, aunque cuando se están creando de manera dinámica esto no es necesario.

Caso 3:
Arreglos asociativos:
```
$arreglo['nombre'] = "Carlos";
$arreglo['apellido'] = "Belisario";
$arreglo['edad'] = 24;
```
Los arreglos asociativos son una de las mas maravillosas formas de crear un arreglo, ya que mediante este podemos indicar el índice con el nombre asociado al valor que estamos almacenando, en el caso que acabamos de mostrar, se veria de esta manera

'nombre' => "Carlos",
'apellido' => "Belisario",
'edad' => 23

Pero como accedemos a sus valores?? Igualmente con el índice, la única diferencia es que este sera un valor asociativo (string), si quiero saber el nombre como lo haríamos??
```
echo $arreglo['nombre']
```
Los arreglos son una de las partes fundamentales del lenguaje ya que con este tipo de datos es que mayormente se obtienen los resultados de consultas a las base de datos (ya llegaremos alla :-))
Objetos: Los objetos son un tipo de dato más complejo, para los que están comenzando en el mundo de la programación decirle que es un objeto y hablarles de métodos, atributos sería correrlos (un poco de humor :-)), pero para los que gusten en un artículo anterior se toco ese tema.

Ahí tenemos alguno de los tipos de datos que podemos tener en una variable, una vez que entendemos el funcionamiento de las variables, ahora veamos lo que son las constantes.

Una constante como su nombre lo indica es un valor que siempre sera el mismo dentro de un sistema, en PHP las definimos por medio de la funcion define(), son un poco menos utilizadas que las variables, pero si tienen su funcionalidad :-), veamos la definición de estas.

define('constante',"Valor de la Constante");
echo constante;

Como podemos ver las constantes se definen fácilmente, tenemos que tener claro que una constante solo es definida una vez, su valor luego no puede ser modificado.

Fácil o no??

Hay que destacar que hay que cosas que tenemos que tener en cuenta al momento de declarar una constante, colocaremos algunas a continuación

Las Constantes solo pueden ser definidas una vez, si en algún momento necesitáramos variar su valor entonces ya no tendría razón crear una constante sino crear una variable, hacer algo como esto
```
define('constante',"Valor de la Constante");
define('constante',"Otro valor");
echo constante;
```
Sería un esfuerzo perdido para no decir error ya que el interprete de PHP no mostraría ninguno, pero el resultado siempre sera "Valor de la Constante" porque son constantes :-).
Las constantes solo contienen valores escalares, que quiere decir esto?? que no contendrán array ni objetos dentro de ellas.

Una vez tenemos un poco más claro lo que son las variables y constantes hagamos un pequeño programita, sencillo pero donde implementemos lo hablado hoy.
calculo del área de un circulo

Indique el Radio:

Como vemos es un pequeño programa donde calculamos el área de un circulo, fácil verdad.

Un poco fuera del tema principal como se puede notar PHP no trabaja solo ya que es un lenguaje de servidor, la parte visual que ve el cliente la hacemos con el HTML, en el programa que acabamos de hacer embebimos el PHP dentro de las etiquetas HTML.

En conclusión hablamos de lo que son las variables y constantes en PHP, espero que se entienda lo que se quiso transmitir en este tercer artículo para los que se inician con el PHP

Comenzando con PHP - MI Primer Código

2011-06-06T20:53:00.000-04:30

En esta entrada comenzaremos a escribir código PHP, para los que no lo conocen PHP es un lenguaje de tipo Scripter(Interpretado) que se ejecuta del lado del servidor, desarrollado para realizar aplicaciones web dinámicas, combinándolo con el lenguaje de etiquetas HTML y un servidor de base de datos como MySQL que es del que estaremos hablando a medida que vayamos creando artículos relacionados(un poco de teoría nunca puede faltar :-)).

Como podemos escribir código PHP??

Para empezar a escribir código PHP hay una serie de programas que hacen falta, de los cuales hablamos en el artículo anterior, una vez instalados todos estos artículos solo nos queda comenzar a escribir nuestro código.

Para que nuestro navegador interprete el código que vayamos escribiendo es necesario encerrar entes entre la etiqueta de apertura y cierre de PHP, las cuales presentamos a continuación:

<?php Etiqueta natural del Lenguaje: Es la etiqueta de apertura (opent_tags) del lenguaje, es la más recomendada de todas las formas que existen para indicar que utilizaremos código PHP.
<? Etiqueta corta: Con esta etiqueta igual que la anterior indicamos a nuestro navegador que debe intrepertar el código como código PHP, esta etiqueta esta desaconsejada debido a que hay muchos web-hosting que traen deshabilitado el short_open_tags lo cual puede traer problemas al momento de implementar nuestro archivo un poco mas de información sobre este tema aca, además de que esta forma trae problemas con la apertura del documento XML ejemplo <?xml version="1.0" encoding="UTF8">
<?= "string" ?> Con esta etiqueta indicamos al navegador que imprima lo que se encuentra después del signo igual lo que nos mostraría en el navegador "string", como es parte del short_open_tag esta desaconsejado totalmente.
?> etiqueta de cierre de PHP, si tal y como lo imaginas con esta etiqueta cerramos el código PHP que hallamos generado.

Como podemos ver existen varias maneras para que nuestro navegador interprete que el código es de PHP, como se indico la manera más recomendable y la que utilizaremos sera <?php ?>.

Una vez establecido el como indicamos que estamos trabajando con PHP, llega el momento mas esperado, el momento de poner manos a la obra.

Lo primero que vamos a hacer es crear un sitio que hará referencia a nuestro código PHP que generemos, esto lo haremos creando una carpeta en la carpeta /VAR/WWW/ si estamos en linux y seguimos el tutorial anterior o en la carpeta HTDOCS si estamos en windows e instalamos el XAMPP para windows como se indico en el artículo anterior. Entonces en la carpeta que sea su caso creemos una caperta llamada comenzando, dentro de esta carpeta van a ir todos los archivos HTML,PHP que vayamos generando, entonces dentro de nuestra carpeta comenzando creemos un archivo llamado index.php, este archivo contendrá nuestro primer programa, este sera el clásico Hello World o Hola mundo, y escribiremos el siguiente código
index.php

Si en nuestro navegador colocamos

http:/localhost/comenzando

obtendremos en el la palabra Hola Mundo!.

Nota: En este caso no se indico el archivo .php porque todo archivo index es considerado el archivo inicial a ejecutar, si hubieramos llamado al archivo comenzando.php tendríamos que haber indicado la dirección al navegador de esta manera

http:/localhost/comenzando/comenzando.php

Fácil no??

Pero familiaricémonos con la sintaxis de PHP, la primera línea como vemos tenemos la etiqueta de apertura <?php, en la segunda linea tenemos la funcion echo, esta función lo que haces es enviar una salida al navegador, en este caso la palabra Hola Mundo, como es una cadena de carácteres o string esta cadena va entre comillas, bien sean simples ' ', o dobles " " y el final de la línea tenemos el ;, que indica que finalizo la línea de instrucción de nuestro código de PHP, fácil verdad??

Como vemos la sintaxis de PHP es bastante sencilla, pero claro no vamos a utilizar PHP solo para hacer un programa con el Hola Mundo, más adelante iremos adentrándonos un poco más en este maravilloso lenguaje, un saludo y hasta la próxima entrada.

Comenzando con PHP - que debemos tener para empezar

2011-06-05T15:08:00.001-04:30

En esta entrada vamos a hablar sobre lo que tenemos que tener para comenzar a trabajar con PHP, de tal manera que no tengamos problemas al momento de comenzar a desarrollar nuestros proyctos.

Lo primero que tenemos que tener es un servidor Apache, IIS entre algunos otros, siendo en mi opinión personal trabajando con el PHP el más utilizado el Apache y este el que vamos a indicar como instalar, en este artículo, además de este debemos instalar también el PHP5 con su la librería para apache2, también un servidor y un cliente de base de datos en este caso trabajaremos con MySQL, sin más preámbulo pongamos manos a la obra:

En los sistemas linux lo hacemos de la siguiente manera:
Lo primero que debemos de hacer es colocarnos como usuario root para tener permisos para instalar en programas en nuestro equipo esto lo hacemos con las siguientes lineas

sudo su

este comando nos pedirá la contraseña de administrador

[sudo] password for tuusuario:

una vez que estamos como root en nuestra terminal empezamos la descarga del software por medio del comando apt-get de la siguiente manera.

#con esta línea instalamos el servidor apache en nuestro equipo
apt-get install apache2
#con esta línea instalamos el el PHP a nuestro equipo
apt-get install php5
#Ahora instalamos el modulo de apache para PHP5
apt-get install libapache2-mod-php5
#instalamos el modulo de PHP para trabajar con MySQL
apt-get install php5-mysql
#Ahora instalamos el soporte para la librería GD de PHP
apt-get install php5-gd
#Instalamos la librería DOM de PHP
apt-get install php5-dom

Ya teniendo instalado el Apache y el PHP, para probar debemos de colocar en nuestro navegador
http://localhost y en este nos debe de salir la frase

It works!

Ya con esto podemos empezar a crear nuestros sitios con PHP, para esto debemos de crear las carpetas de nuestros sitios dentro de la carpeta /var/www y llamarla por el navegador, ejemplo
suponiendo que tenemos un este árbol de carpeta /var/www/misitio/, la dirección dentro del navegador sería
http://localhost/misitio
esto llamaría al archivo index creado dentro de la carpeta misitio en /var/www.
Ahora nos queda instalar el Servidor de Base de datos MySQL.

#procedemos a instalar el servidor mysql
apt-get install mysql-server
#aunque el MySQL trae un cliente para el terminal, instalaremos el PHPMYADMIN un cliente que se trabaja por el navegador
apt-get install phpmyadmin

Una vez instalado el PHPMYADMIN para que pueda ser llamado por el navegador debemos de colocar un enlace simbólico a este, de la siguiente manera

ln -s /usr/share/phpmyadmin /var/www/

lo que hace este comando es crear un enlace simbolico desde /usr/share/phpmyadmin que es donde queda instalado el PHPMYADMIN a /var/www de tal manera que cree un sitio con el nombre PHPMYADMIN.

Luego de estos pasos ya tenemos listo nuestro equipo para realizar aplicaciones con PHP y MySQL

Pero los usuarios de Windows que??

Para hacer la instalación del Apache, PHP y MySQL en windows es un poco mas sencillo ya que existen programas como xampp, wampserver, appserver que traen un paquete con cada uno de estos programas instalados, incluso trae por defecto el PHPMYADMIN, en lo personal me gusta mas trabajar con el XAMPP, por lo cual es el que indicare en este artículo:
Paso 1:
Descargar desde la web oficial: Apache Friends
Paso 2:
Instalar Xampp, este programa te pedirá una ruta a instalar, personalmente lo trabajo en la raíz por lo que crearía una carpeta de esta forma en C:\xampp.
Paso 3: Una vez instalados los paquetes este te mostrara un panel de control donde puedes iniciar o detener cada uno de los servidores instalados.

Luego de tener instalado el xampp y funcionando correctamente solo nos queda crear nuestros sitios en la carpeta HTDOCS ubicada dentro de la carpeta c:\xampp\, quedando por ejemplo
c:\xampp\htdocs\misitio

cuando queramos ver estos sencillamente debemos colocar en el navegador
http://localhost/misitio
y esto nos direccionara a la página index creada en la carpeta misitio.

Luego de esto solo nos queda instalar un IDE con soporte para PHP, personalmente trabajo con eclipse y su plugin para PHP, pero tambien existe Aptana, netbeans para PHP, entre algunos otros
Espero que halla podido explicar bien esto ya que lo más importante para comenzar a trabajar con una aplicación es tener correctamente instalado los programas que vamos a utilizar.

Conociendo las clases POO setter y getter

2011-05-19T20:47:00.002-04:30

En el día de hoy vamos a hablar un poco de un tema que aunque básico es importante al momento de crear nuestras clases y estos son los "setter y los geter".

Para dar una pequeña introducción al tema vamos a explicar que son cada uno de ellos, comenzando por el setter. Un setter es un método de una clase que sirve para asignarle un valor a un atributo de una clase.

Un poco de repaso de POO, un atributo son las características de un objeto, estos por buena práctica deben de ser de acceso privado, de tal manera que solo puedan ser modificados por la misma clase de la que son características y no por otra.

Continuando con lo que se refiere al metodo setter, cuando creamos este tipo de método estamos dando acceso a otros objetos o lugar de nuestra aplicación a indicar el valor de un atributo de nuestra clase, un ejemplo de este.

class MiClase
{
    private $atrbibutoClase;
    private $otroAtributo;
    public function setAtributoClase($atrbibutoClase)
    {
        $this->atrbibutoClase = $atrbibutoClase;
    }   
    public function setOtroAtributo($otroAtributo)
    {
        $this->otroAtributo = $otroAtributo;
    }   
}

Como posemos ver son metodos que asignan valor a cada atributo de nuestra clase
MiClase, de tal manera que podamos trabajar con los datos de esta.

Hasta aca esta sencillo nuestro trabajo con los setter, pero que con los tipos de datos que estos pueden recibir??

En Java por ejemplo este tipo de métodos se les indica el tipo de valor que reciben en el parámetro ya que java es exigente en cuanto a los tipos de datos que se le asignan a las variables y atributos, pero que con nuestro amado PHP.

Hasta el día de hoy nunca había tomado en cuenta la validación de tipo de dato que se da a los setter ya que tengo una clase con la que valido los datos al momento de estar trabajand, pero en el día de hoy foreando un poco en este tema en específico entendí que se puede o mejor dicho debe hacer la validación en nuestros métodos setter. Entonces como quedarian nuestros setter con validaciones??

Suponiendo que uno de los datos sea de tipo numerico quedaria de la siguiente manera.

<?php 
class MiClase
{
    private $atrbibutoClase;
    private $otroAtributo;
    public function setAtributoClase($atrbibutoClase)
    {
        if(is_numeric($atrbibutoClase)){
           $this->atrbibutoClase = $atrbibutoClase;
        }
        else{
             throw new Exception("EL dato debe de ser numerico");
        }
    }       
}
$class = new MiClase();
$class->setAtributoClase("hola");
?>

como vemos hacemos una validacion y sino lanzamos una excepcion indicando que el tipo de dato no es el correcto para este atributo de nuestra clase.

Como vemos aunque son métodos sencillos los setter en PHP tienen que tener un poco de lógica para hacer la validación de tipo de datos del mismo.

Ahora hablemos un poco de los getter, los getter son los métodos que retornan o muestran el valor de un atributo de nuestra clase. Entonces como quedaria nuestro getter??

public function getAtrbibutoClase()
{
    return $this->atrbibutoClase;
}

De esta manera al momento de tener una instancia de nuestro objeto MiClase solo con llamar a este método obtendriamos el valor de el atributo especificado.

Estos métodos de los que hablamos hoy son valiosamente útiles al momento de declarar nuestras clases ya que nos dan acceso a los atríbutos de la misma.

Espero que esta entrada sea de su agrado y que halla explicado bien la misma, cualquier sugerencia o corrección me la hacen saber, saludos.

Entendiendo el MVC II

2011-04-01T23:02:00.000-04:30

Siguiendo un poco el consejo del amigo mr_robb me dispuse a llevar un poco lo que hicimos a POO en PHP, para ir mostrando como trabajar los modelos y controladores con esta forma de programar, naturalmente cambia todo lo que es nuestro código anterior ya que ahora trabajaremos clases para nuestros modelos y controladores, aunque en lo que es el trabajo deberian de llevar a lo mismo un pequeño login.

Como lo que se quiere es mostrar como trabajar con los controladores y modelos y no hemos creado una clase base para estos ni para la vista incluiremos e instanciaremos los mismos en el momento que sea el caso pertinente, bueno acontinuación el nuevo código de nuestros modelos

usuario.php

/**
*
*Clase Modelo para gestionar los Usuarios
*/
/*Traemos la clase para trabajar las conexiones con la base de datos*/
require_once("db.php");
class Usuario 
{
 /**
 *
 *Definicion de atributos
 */
 private $_connection;
 /**
 *
 * Metodo Constructor para inicializar la conexion con la DB
 */
 public function __construct()
 {  
  $this->_connection = new db();
 }
 /**
 *
 *Metodo que gestiona el login de la aplicacion
 */
 public function login($user,$password)
 {
  $login = $this->_connection->selectAll('users',array('user'=>$user,'password'=>$password));
  if(count($login > 0)){
   if($login[0]['estatus'] === 'habilitado'){
    return true;
   }
   else{
    return "deshabilitado";
   }
  }
  else{
   return false;
  }
 }
 /**
 *
 * Metodo para agregar los usuarios 
 */
 public function agregarUsuario($datos = array())
 {
  if(!is_array($datos)){
   return false;
  }
  $insert = $this->_connection->insert('users',$datos);  
  if($insert){
   return true;
  }
  else{
   return "fallo";
  }  
 } 
 /**
 *
 *Metodo para deshabilitar los usuarios
 */
 public function deshabilitarUsuario($user)
 {
  $update = $this->_connection->update('users',array('estatus'=>'deshabilitado'),array('user'=>$user));  
  if($insert){
   return true;
  }
  else{
   return "fallo";
  }  
 }
}

Como podemos observar es una clase donde hacemos toda la lógica que tiene que ver con la gestión de usuarios, dentro de la misma se instancia la clase DB para trabajar con la base de datos (la clase DB es la implementada en este artículo).

UsuariosController.php

session_start();
require_once("model/usuario.php");
class UsuariosController
{
 private $model = new Usuario(); 
 public function login($user,$pass)
 {
  if($_SERVER['REQUEST_METHOD'] == "POST"){ 
   $login = $this->model->login($user,$pass);
   if($login){
    $_SESSION['login'] = "si";
    header("location: index.php");
    exit;
   }
   elseif($login === "deshabilitado"){
    unset($_SESSION['login']);
    $_SESSION['messaje'] = "Usuario Deshabilitado";
    header("location:index.php");
    exit;
   }
   else{
    unset($_SESSION['login']);
    $_SESSION['messaje'] = "Usuario o Contraseña incorrecto";
    header("location:index.php");
    exit;
  }
  else{
   header("location:login.php");
   exit;
  }
 } 
}

En el caso del controlador podemos visualizar que es una clase que instancia el modelo y llama a sus métodos de la lógica segun una acción, en este caso solo indicamos la del login para no extendernos tanto, lo importante es que se vea que el controlador no tiene ninguna lógica del negocio como plantean algunas personas, sino que en este se llama a la lógica del mismo según la acción indicada y según el caso este llamara a la vista correspondiente.

También es importante destacar que por cada acción (método) del controlador que realicemos debemos de crear una vista (código html) de tal manera que este tenga a donde redirigir y mandar los mensajes al usuario si esto es pertinente.

Como podemos ver el MVC es más útil cuando se trabaja de manera orientada a objetos, aunque esta es solo una aplicación sencilla de un login, podemos ver algo mas avanzado sobre este patrón en este artículo MVC avanzado donde el autor nos muestra como crear las clases para gestionar controladores y vistas de una gran manera, espero que esta pequeña introducción a este patrón de diseño les sirva como base en lo referente a este patrón, saludos

Entendiendo el MVC

2011-03-28T23:18:00.000-04:30

En esta entrada vamos a hablar un poco del MVC, con la intención de hacerlo entendible a personas que se estén iniciando con este patrón de diseño lo llevaremos desde un punto de vista sencillo y entendible para cualquiera que tenga nociones de programación.

Pondremos manos a la obra haciendo una pequeña definición de este patrón de diseño.

El Patrón MVC sus siglas en ingles significan Model View Controller que significa Modelo Vista Controlador, es una arquitectura de Software que define la separación de los datos que conforman la vista de la lógica de una aplicación.

Esto se hace con la finalidad de que cada una de las partes de una aplicación solo realice lo que está en su responsabilidad, además de que le da mayor entendimiento a nuestros desarrollos y los hace más fácil de mantener, ya que la parte del diseño solo tiene la cantidad de código de programación que necesita al igual que en la parte que conforma nuestro código del negocio solo se va a encontrar lógica de programación en el lenguaje que estemos trabajando (PHP en nuestro caso) y no como algunos estamos acostumbrados muchos a hacer cosas como estas:


Insertar un registro
Campo:

Como vemos tenemos el código de nuestro negocio que es la inserción del registro y la vista en un mismo archivo cosa que no es de lo mas recomendable y es lo que este patrón desea evitar.

Ya sabemos que es lo que no quiere el MVC pero veamos en si lo que está detrás de sus siglas.

V (View o Vista): Aunque la primera letra del patrón es la M decidí mejor hablar primero de la vista ya que es lo más sencillo de explicar al momento de trabajar con este patrón.

La vista como su nombre lo indica es la parte visual, lo que el usuario final visualizara en su aplicación.
La vista podemos establecerla como la primera fase de este patrón ya que la vista es la que comunica al usuario lo que quiere ver, esta tiene acceso directo al modelo como podemos observar en la imagen que tenemos en la parte superior y es esta la que transmite los datos a la aplicación para hacer el proceso que necesitemos
M (Model o Modelo):El modelo es lugar donde se encuentra la lógica del negocio de nuestro desarrollo, es ahí donde se procesan todos los datos provenientes de la vista.
C (Controller o Controlador): Es el encargado de hacer la conexión entre la parte visual y la lógica del negocio de nuestro desarrollo (MODELO), este se encarga de pasar los datos de la vista hacia el modelo y según la respuesta que este le entregue selecciona la vista a cargar pasando los datos provenientes del modelo.

Bien hasta ahora hemos visto la teoría de este patrón pero como se construye una aplicación con él??

Vamos a trabajar de la manera más básica posible, para ello vamos a trabajar un poco el PHP de manera estructurada aunque mayor provecho a este patrón se saca trabajando OOP; Planteemos un ejemplo que todo sistema debe de tener una gestión de usuarios, entonces normalmente cuando trabajábamos sin el patrón hacíamos algo como esto

Como podemos observar es un login básico que hace todo el proceso en la misma página, si llegara un usuario y se logueara correctamente lo haría, pero como vemos tenemos lo que yo llamo un arroz con mango en nuestro código, pasemos este pequeño login al patrón MVC.

Comencemos con la vista

login.php

Como podemos observar la vista de nuestro pequeño sistema de login es todo lo que corresponde al HTML dejando todo el proceso ya que este corresponde a la lógica de nuestro negocio la cual estará en el modelo.

Ahora nuestro modelo.
usuario.php

Como vemos en nuestro modelo hicimos una función ya que el modelo del usuario debería tener toda la lógica que corresponde a la gestión de estos, como registrar, modificar y eliminar usuarios, para el ejemplo fuera lo más sencillo posible trabaje con el login ya que es algo que normalmente se hace en cualquier tipo de sistema.

Pero el controlador donde queda??

Como vemos ya tenemos la parte visual de nuestro login y tenemos la parte del negocio de nuestra aplicación pero para que el controlador y donde queda?? Como ya definimos el controlador comunica los datos de la vista al modelo entonces como debe de ser este?? Algo como esto

usuariosController.php

Con este pequeño controlador podemos observar cual es la función de este, sencillamente pasar datos de la vista al modelo y según la respuesta cargar la vista que se necesite según los datos obtenidos del modelo, sencillo no??

Espero que esta entrada ayude a los que están comenzando a conocer este patrón de diseño a entenderlo un poco mejor lo hice lo más sencillo posible según mi criterio :-), saludos hasta una próxima entrada.

Hablando de Clases y Objetos POO

2011-03-25T22:32:00.001-04:30

En un artículo anterior habíamos tocado el tema de las clases y los objetos desde el punto de vista del PHP aunque muy generalizado, en el día de hoy vamos a tocarlo un poco mas general de tal manera que podamos tener claro que son.

Cuando hablamos de un Objeto la teoría nos indica que es la instancia de una clase, en PHP mayormente asignado a una variable de esta manera

$objeto = new Clase();
var_dump($objeto)

el resultado seria

object(Clase)#1 (1) { ["var":"Clase":private]=> NULL }

Como vemos la variable $objeto se convirtió justamente en eso en un Objeto o una instancia de la clase Clase donde por medio de esta instancia podemos acceder a sus métodos y atributos públicos por cierto.

Ok el concepto de objeto sencillo la instancia de una clase, pero entonces que es una clase, es ahí donde muchos autores nos complican la vida literalmente diciéndonos que es una abstracción de datos, donde el concepto de abstracción de datos es algo muy complicado por lo que muchos o huimos del concepto o sencillamente nos quedamos con dudas sobre este concepto.

En lo personal tenía algunas dudas con lo que era el concepto de una clase y abstracciones de datos pero esta semana creo que se me aclaro mucho por lo que decidí hacer este post, entonces comencemos con los conceptos que tanto nos cuesta a algunos.

Una clase: es simplemente una entidad compleja llevada a lo resumido pero como es esto?? Un ejemplo pudiera ser cuando necesitamos trabajar con animales, todos conocemos que existen muchas clasificaciones de los animales, ejemplo por lo que comen (herbívoros, carnívoros....) o por la forma que nacen (ovíparos, mamíferos...) pero todo esta complejidad la resumimos en una sola palabra es decir Animales. Que fácil no??, también podríamos decir que una clase es un tipo de datos creados por el desarrollador, pero como así?? Explico un poco mi experiencia y la de algunos profesores que he tenido, no sé si en algún momento alguien ha visto algo como esto

public function miMetodo(Animales $animal){
/*grupo de sentencias del metodo miMetodo*/
}

Como podemos observar el parámetro del método miMetodo es de tipo Animales pero donde está definido este tipo de datos??? En una clase que creamos llamada Animales, entonces también podríamos definir a una clase como la declaración de un tipo de dato creada por el desarrollador, un ejemplo de esto es en JAVA los desarrolladores de este lenguaje notaron que no había un buen soporte para el trabajo con las variables de tipo carácter, por esto crearon una clase llamada String que define este tipo de datos ejemplo

String var;

y así indicamos al lenguaje que trabajaremos la variable var como de tipo String una clase creada por JAVA y podemos acceder a todos sus métodos y atributos de esta.

Aunque la explicación de que es una clase fue algo larga creo que lleva lo complicado a lo simple tal cual como lo hace una clase, pero entonces en donde esta lo abstracto de las clases o mejor dicho que es una abstracción?? El concepto de abstracción va ligado al de la clase, como es esto?? Sencillamente lleva lo complejo a lo sencillo ya que se enfoca en el que hace y no en como lo hace con todo lo complejo que esto pueda ser.

Bueno espero que esta entrada sea del agrado de todos, es sencillamente un artículo que intenta llevar lo complicado del concepto de una clase a ser entendido de manera fácil tal cual y como lo hace una clase.

clase validación de datos

2011-03-14T22:05:00.003-04:30

Buenas un poco abandonado el blog el día de hoy compartire una clase que realice para hacer validaciones, esta clase surge de un tema que planteaba en forosdelweb por una duda correspondiente al patrón MVC, según tenía entendido por un poco de experiencia con el framework cakePHP, la lógica de nuestros sistemas se encuentra en el controlador según entendia yo :-), resulta que esto era un error de concepto que tenia y los amigos del foro me ayudaron a entender y ver este error, luego de entender este concepto me genero otra duda donde realizar las validaciones?? en el controlador?? en el modelo?? según mi criterio si en el patrón MVC toda la lógica y el trabajo con los datos se hace con el modelo entonces las validaciones de los datos deve de ser en el modelo, entonces me dispuse a crear una clase para hacer las validaciones es una primera versión que hace la validación de manera correcta lo unico que se debe es llamar al método de la clase e indicar los parámetros para realizar la validacion

/**
/**
* Clase para realizar validaciones en el modelo
* Es utilizada para realizar validaciones en el modelo de nuestras clases.
*
* @author Carlos Belisario
*/
class Validacion
{
 protected $_atributos;
 protected $_error;
 public $mensaje;
 
 /**
 * Metodo para indicar la regla de validacion
 * El método retorna un valor verdadero si la validación es correcta, de lo contrario retorna el objeto 
 * actual, permitiendo acceder al atributo Validacion::$mensaje ya que es publico
 */
 public function rules($rule = array(),$data)
 {
  
  if(!is_array($rule)){
   $this->mensaje = "las reglas deben de estar en formato de arreglo";
   return $this;
  }  
  foreach($rule as $key => $rules){
   $reglas = explode(',',$rules['regla']);
   if(array_key_exists($rules['name'],$data)){
    foreach($data as $indice => $valor){     
     if($indice === $rules['name']){
      foreach($reglas as $clave => $valores){ 
       $validator = $this->_getInflectedName($valores);        
       if(!is_callable(array($this, $validator))){
          throw new BadMethodCallException("No se encontro el metodo actual");
       }
       $respuesta = $this->$validator($rules['name'], $valor);        
      }
      break;
     }
    }
   }
   else{
    $this->mensaje[$rules['name']] = "el campo $value no esta dentro de la regla de validación o en el formulario";    
   }
  }  
  if(!$respuesta){
   return $this;
  }
  else{
   return true;
  }
 } 
 
 /**
 * Metodo inflector de la clase 
 * por medio de este metodo llamamos a las reglas de validacion que se generen
 */
 private function _getInflectedName($text)
 {
  $_validator = preg_replace('/[^A-Za-z0-9]+/',' ',$text);
  $arrayValidator = explode(' ',$_validator);    
  if(count($arrayValidator) > 1){
   foreach($arrayValidator as $key => $value){     
    if($key == 0){
     $validator .= "_".$value; 
    }
    else{     
     $validator .= ucwords($value);
    }
   }
  }
  else{
   $validator = "_".$_validator;
  }    
  return $validator;
 }
  
 /**
 * Metodo de verificacion de que el dato no este vacio o NULL
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _noEmpty($campo,$valor)
 {   
  if(isset($valor) && !empty($valor)){   
   return true;   
  }
  else{   
   $this->mensaje[$campo][] = "el campo $campo debe de estar lleno";
   return false;
  }
 }
 /**
 * Metodo de verificacion de tipo numerico
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _numeric($campo,$valor)
 {   
  if(is_numeric($valor)){
   return true;
  }  
  else{
   $this->mensaje[$campo][] = "el campo $campo debe de ser numerico";
   return false;
  }
 }
 
 /**
 * Metodo de verificacion de tipo email
 * El metodo retorna un valor verdadero si la validacion es correcta de lo contrario retorna un valor falso
 * y llena el atributo validacion::$mensaje con un arreglo indicando el campo que mostrara el mensaje y el 
 * mensaje que visualizara el usuario
 */
 protected function _email($campo,$valor)
 {
  if(preg_match("/^[a-z]+([\.]?[a-z0-9_-]+)*@[a-z]+([\.-]+[a-z0-9]+)*\.[a-z]{2,}$/",$valor)){     
   return true;
  } 
  else{
   $this->mensaje[$campo][] = "el campo $campo de estar en el formato de email usuario@servidor.com";
   return false;
  }
 }
}

el uso de la clase es muy sencillo aca dejo las pruebas que realice a la clase

$_POST['campo1'] = 1;
$_POST['campo2'] = "usuario@hotmail.com";
$datos = $_POST;
$validacion =  new Validacion();
$regla = array(
   array('name'=>'campo1','regla'=>'no-empty,numeric'),
   array('name'=>'campo2','regla'=>'no-empty,email')
  );
$validaciones = $validacion->rules($regla,$datos);
print_r($validaciones);

por ahora solo tengo tres reglas de validación son muy básicas y sencillas, espero que sea de su agrado si tienen alguna corrección o critica que hacer a la clase no hay ningun problema, saludos