krsrk - Tumblr blog

krsrk · 8 years ago

Text

Integración Vue Js con Laravel 5.4 (1)

En esta publicación se verá la integración de Laravel con Vue Js. Vue Js es una librería de Js que se incluye en Laravel a partir de la versión 5.4. Esta versión su futuro será controlar la vista en Laravel. Pero además de que está integrado en Laravel esta librería une las características importantes de Angular y React.

Para ver cómo se integra con Laravel usaremos un caso escenario de un blog donde veremos en la vista principal las publicaciones hechas por el usuario y cuando se autentifique el usuario verá sus publicaciones propias. Así como también generamos un formulario para dar de alta una publicación, no abordaremos la totalidad del CRUD ya que simplemente esta publicación se trata de Vue Js y cómo vamos a procesar los datos en la vista.

Asumimos que el lector ya está relacionado con Laravel y no daremos detalles sobre código y comandos que se vean de Laravel. También asumimos que el lector ya está familiarizado con el entorno Homestead y como crear un dominio para este entorno.

Antes de Empezar

Tener instalado Node Js

Tener instalado Composer

Tener instalado el comando laravel en las globales del sistema

Tener instalado Homestead o un entorno MAMP o LAMP

Instalación del proyecto Laravel

Abrimos la terminal, nos logeamos a nuestro entorno Homestead via SSH, adentro del servidor navegamos a la carpeta Code o cualquiera que hayan puesto en default en la configuracion del Homestead, y simplemente ejecutamos el siguiente comando:

laravel new blog

Revisamos que nuestra aplicacion se creo realmente: http://blog.app. Si vemos la pantalla de bienvenida de Laravel ya tenemos nuestro proyecto creado.

Creación de Migraciones

En este paso crearemos nada más una migración que es la tabla de posts que ahí vamos almacenar las publicaciones hechas por el usuario. Para este paso usaremos otro comando para crear dichas migraciones. Tenemos que estar en el directorio del proyecto osea Code/blog :

php artisan make:migration create_table_feeds

Una vez ejecutado este comando nos creará un archivo en la ruta blog/database/migrations. Aquí crearemos código para nuestra estructura de la tabla. Antes que nada configuramos el .env con nuestra base de datos llamada blog.

<?php use Illuminate\Support\Facades\Schema; use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateTableFeeds extends Migration { protected $tableName = 'feeds'; /** * Run the migrations. * * @return void */ public function up() { Schema::create($this->tableName, function (Blueprint $table) { $table->increments('id'); $table->integer('user_id'); $table->string('title'); $table->string('content'); $table->timestamps(); $table->integer('status')->default(1)->comments('1=publicacion activa, 2=en borrador o no publicda, 3=borrada'); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists($this->tableName); } }

Creación de Modelos

Vamos a crear un modelo, para eso simplemente crearemos el modelo que nos falta ya que User ya esta por default cuando se crea el proyecto, ejecutamos:

php artisan make:model Feeds

Una vez que se ejecuta nos creará un archivo el cual reside en el directorio /app llamado Feeds.php. Abrimos el archivo y codificamos lo siguiente:

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Feeds extends Model { /** * The attributes that are mass assignable. * * @var array */ protected $fillable = [ 'user_id', 'title', 'content', 'status' ]; }

Para crear una relacion en el modelo, revisaremos la lógica de nuestra app, como es de blog o de publicaciones, la cardinalidad es de 1 usuario -> varias publicaciones, entonces tendremos que modificar el modelo User y hacer lo siguiente dentro del codigo de la clase y agregar este metodo:

public function feeds() { return $this->hasMany('App\Feeds'); }

Siguiente modificamos el modelo Feeds para establecer la relacion inversa:

public function user() { return $this->belongsTo('App\User'); }

Creación de Factories

Los Factories se encuentran en /database/factories modificaremos el archivo ModelFactory.php y pondremos esto:

$factory->define(App\Feeds::class, function (Faker\Generator $faker) { return [ 'title' => $faker->sentence(6), 'content' => $faker->text, ]; });

En el archivo ya existia el factory de Users. Este codigo marcara error si por ejemplo no se define las relaciones entre modelos. Usa la clase Faker para generar información aleatoria a la hora de crear los registros en la base de datos.

Creación de Seeds

Para crear los Seeds necesitaremos crear un Seed de Users con Feeds, para esto ejecutamos en la terminal:

php artisan make:seed UserTableSeeder

Una vez ejecutado este comando nos creará un archivo php UserTableSeeder en el directorio /database/seeds; abriremos el archivo y codificamos lo siguiente:

<?php use Illuminate\Database\Seeder; class UserTableSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { factory(\App\User::class, 6)->create()->each(function ($u) { $u->feeds()->saveMany(factory(\App\Feeds::class, 2)->create(['user_id' => $u->id])); }); } }

Abrimos el archivo DatabaseSeeder y codificamos lo siguiente:

<?php use Illuminate\Database\Seeder; class DatabaseSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { $this->call(UserTableSeeder::class); } }

Una vez teniendo listo nuestros archivos ejecutamos los siguientes comandos:

php artisan migrate

php artisan db:seed

Una vez hecho esto se deberá tener la tabla feeds y users con registros.

Creación de un sistema de autentificación

Para crear un sistema de autentificación en Laravel simplemente ejecutaremos:

php artisan make:auth

Probamos nuestros usuarios; nos dirigimos a http://blog.app/login y entramos la información de algun usuario, el password es secret. Si se puede logear ya está listo nuestro sistema de autentificación.

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Base de Datos: Models] (6)

Creación de Models

Los Models es otro componente o instancia de Laravel los cuales son una abstracción de la base de datos. Supongamos que si tenemos una tabla user tendríamos una clase User definida con propiedades(campos de la tabla). Esto hace que el acceso a la información y ejecución de consultas sea por así decirlo mas rápido. Aquí en estas clases podemos definir varias cosas entre ellas la conexión de base de datos definidas en el archivo database.php en la carpeta /config.

Para empezar a codificar un Model, tendremos que crear unos archivos en /app: Post.php, PostComment.php. Recordemos que el modelo User para la tabla users ya esta creado por default cuando se crea el proyecto. Una vez creado estos archivos codificaríamos lo siguiente:

<?php ///Archivo /app/Post.php namespace App; use Illuminate\Database\Eloquent\Model; /** * */ class Post extends Model { protected $table = 'post'; protected $fillable = [ 'title', 'abstract', 'content', 'created_at', 'status' ]; protected $guarded = [ 'id','updated_at' ]; public function comments() { return $this->hasMany('App\PostComment', 'post_id'); } public static function getFields() { return [ 'title' => '', 'abstract' => '', 'content' => '', ]; } }

<?php namespace App; use Illuminate\Database\Eloquent\Model; /** * */ class PostComment extends Model { protected $table = 'post_comment'; protected $fillable = [ 'comment', 'created_at', 'status' ]; protected $guarded = [ 'id','post_id','updated_at' ]; public function post() { return $this->belongsTo('App\Post', 'post_id'); } }

En estas clases ocurren varias cosas; estos modelos se definen propiedades y métodos para su configuración, la mayoría de estos están relacionados con la base de datos en especifico la tabla, aquí describo estas propiedades:

protected $table : string el cual contiene el nombre de la tabla en la base de datos.

protected $fillable : array con los campos a mostrar en nuestra aplicación.

protected $guarded: array con los campos guardados y que no se van a mostrar al menos públicamente en nuestra aplicación.

public function postComment(): define la relación a otra tabla, las relaciones pueden ser hasOne(1:1), hasMany(1:N), belongsToMany(N:N). Cuando se define una relación de 1:N en la tabla detalle en este caso PostComment se debe definir la relación inversa o que pertenece a Post con el metodo post() y dentro de esta belongsTo() el cual el primer parámetro es la clase padre(Post) y como segundo parámetro la foreign key o llave foranea que va relacionar ambas tablas. Par ver mas sobre la relaciones consultar la documentación de Laravel.

Una vez teniendo nuestros Factories, Models y Seeds nos vamos a la terminal o linea de comando y tendremos que ejecutar el siguiente comando:

php artisan db:seed

Si todo sale bien tendremos populada nuestra base de datos.

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Base de Datos: Factories y Seeds] (5)

Creación de Factories

Factories es un componente de Laravel el cual su función es popular la base de datos con información, obviamente esta información es de prueba o no verídica; se usa principalmente para pruebas o para iniciar una base de datos con datos.

Para empezar a codificar un factory debemos ir al directorio “database/factories”, una vez en ese directorio abriremos el archivo “ ModelFactory.php” y pondremos lo siguiente:

<?php use App\User; use Faker\Generator as FakerGen; /* |-------------------------------------------------------------------------- | Model Factories |-------------------------------------------------------------------------- | | Here you may define all of your model factories. Model factories give | you a convenient way to create models for testing and seeding your | database. Just tell the factory how a default model should look. | */ $factory->define(User::class, function (FakerGen $faker) { $fields = [ 'name' => $faker->name, 'email' => $faker->email, 'password' => bcrypt('secret'),]; return $fields; }); ///Factory para la tabla post $factory->define(App\Post::class, function (Faker\Generator $faker) { return [ 'title' => $faker->sentence(5), 'abstract' => $faker->sentence(15), 'content' => $faker->text(), ]; }); ///Factory para la tabla post_comment $factory->define(App\PostComment::class, function (Faker\Generator $faker) { return [ 'comment' => $faker->sentence(15), ]; });

Se va generar información en la base de datos por cada tabla que tengamos en este caso tenemos 3 tablas user, post, post_comment.Factories usa una clase que se llama FakerGen la cual es encargada de generar la información aleatoria.

Al método “define” le pasaremos las clases de los modelos(esto lo definiremos mas adelante) y un callback con el parametro del FakerGen; adentro de este callback las opciones del FakerGen.

Creación de Seeds

En esta instancia de Laravel ejecutaremos nuestro Factories para que se genere la información, estos archivos generados se encuentran en “database/seeds” y cuentan con el metodo run() el cual aquí haremos nuestras llamadas a los factories, una vez localizado el seed lo abriremos y escribiremos lo siguiente en el metodo run(), abriremos primero PostTableSeeder.php:

<?php use Illuminate\Database\Seeder; class PostTableSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { factory(\App\Post::class, 10)->create()->each(function($p) { $p->comments()->saveMany(factory(\App\PostComment::class, 5)->make()); }); } }

En este código en el método run() le indicaremos cuantos registros queremos esto lo definimos en primer parámetro de factory; después por cada uno de estos registros va generar 5 comentarios definidos en el parámetro del método saveMany(). Con esto tendremos 10 publicaciones o post y 5 comentarios por cada una de estas publicaciones. Esto seria el código de la tabla de User:

<?php use Illuminate\Database\Seeder; class UserTableSeeder extends Seeder { /** * Run the database seeds. * * @return void */ public function run() { factory('App\User', 5)->create(); } }

Con esto ya tenemos codificado nuestros Seeds y Factories, el próximo capitulo codificaremos nuestros Modelos para ejecutar todo este proceso.

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Base de Datos: Migraciones] (4)

Las Migraciones o “Migrations” en Laravel es un componente por asi decirlo para tener un control a nivel código sobre la base de datos; este componente puede definir desde creaciones de tablas hasta modificación de las mismas. Estos componentes se traducen en clase y se van guardando en la base de datos de MySQL que tengas configurada.

Las ventajas son enormes cuando se trabajan en equipo de trabajo por asi decirlo grandes ya que como es a nivel código y combinado con un sistema de subversión de código, todos los miembros de tu equipo tendrán actualizada la base de datos por si alguien hace cambios.

Creación de Migrations

En estos pasos crearemos las migraciones para nuestro proyecto de “Blog”. Para hacer esto navegaremos en la linea de comandos hasta el directorio de nuestro proyecto y ejecutaremos:

php artisan make:migration create_table_post

Una vez ejecutado este comando nos creara un archivo la ruta /database/migrations, y el nombre del archivo llevara como prefijo la fecha en que se creo y el nombre de la migración. En la tabla de migrations de nuestra base de datos se creara un registro para llevar el control de lo que se migra en la base de datos.

Para crear la tabla de los comentarios de la publicación del blog ejecutaremos:

php artisan make:migration create_table_post_comment

Con esto ya tendríamos nuestros archivos creados para programarlos. En nuestro IDE abrimos la carpeta de las migraciones, ahí deberíamos de encontrar los archivos de nuestras migraciones abrimos el archivo 20160101 create_table_post.php y lo editamos :

<?php use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateTablePost extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('post', function (Blueprint $table) { $table->increments('id'); $table->string('title'); $table->string('abstract'); $table->string('content'); $table->timestamps(); $table->integer('status')->default(1)->comment("Estatus del comentario 1= activo, 2=borrador, 0= borrado"); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::drop('post'); } }

Esta clase tiene dos métodos up() y down(). En up() se define las instrucciones de Laravel para crear la estructura de la tabla en la base de datos. En down() hace un rollback a la transacción y deshace los cambios hechos en la base de datos; en este caso elimina la tabla “post” de la base de datos.

Una vez hecho esto editaremos el segundo archivo 20160101create_table_post_comment.php(el nombre puede variar dependiendo en que fecha se creo) :

<?php use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateTablePostComment extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('post_comment', function (Blueprint $table) { $table->increments('id'); //Llave primaria auto incrementabla tipo INT $table->integer('post_id'); // llave foranea: id del post, relacion 1->N $table->string('comment'); //comentatrio de la publicacion $table->timestamps(); //Fechas de creacion y actualizacion $table->integer('status')->default(1)->comment("Estatus del comentario 1= activo, 0= borrado"); // }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::drop('post_comment'); } }

Pasa lo mismo que el archivo anterior. Este al igual que el otro tiene los metodos up() y down().

Ya una vez editadas las migraciones volvemos a la consola o linea de comandos y ejecutamos:

php artisan migrate

Este comando lo que hace es que ejecuta las migraciones y crea las tablas en la base de datos. Para ver mas información sobre las instrucciones de las migraciones de Laravel dirigirse a este link: https://laravel.com/docs/5.3/migrations

Probamos en el phpMyAdmin que funcionaron las migraciones:

Hasta el momento ya tenemos nuestra base de datos configurada y con su estructura aplicada, en el siguiente capitulo vamos a introducirle información aleatoria con otro componente de Laravel que se llama Factories, para tener nuestra bases de datos populada y poder hacer el CRUD de nuestra app con facilidad.

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Configuración del proyect] (3)

En el capitulo anterior vimos como crear un proyecto con la linea de comando de “laravel”. Ahora nos dispondremos a configurarlo, como mencione anteriormente no nos meteremos en detalle sobre la estructura de archivos y directorios de Laravel, pero lo pueden revisar en este link: https://laravel.com/docs/5.3/structure.

Antes de iniciar con la configuracion tendremos que instalar las dependencias Node de nuestro proyecto el cual configuraremos dos archivos que se encuentran en / de nuestro proyecto: package.json y gulpfile.js

Archivo package.json

Este archivo ya viene cuando se crea el proyecto y en el se encuentra la configuracion para instalar las dependencias de Node. Si no se encuentra simplemente creen el archivo en la raiz del proyecto como “package.json” y dentro le ponen lo siguiente:

{ "private": true, "scripts": { "prod": "gulp --production", "dev": "gulp watch" }, "devDependencies": { "bootstrap-sass": "^3.3.7", "gulp": "^3.9.1", "jquery": "^3.1.0", "laravel-elixir": "^6.0.0-9", "laravel-elixir-vue-2": "^0.2.0", "laravel-elixir-webpack-official": "^1.0.2", "lodash": "^4.16.2", "vue": "^2.0.1", "vue-resource": "^1.0.3" }, "dependencies": { "vue-materials": "^1.0.7-rc.6", "vue-typeahead": "^2.3.0" } }

Una vez hecho esto ejecutamos el comando para instalar las dependencias Node:

npm install

Una vez ejecutado este comando nos creara las dependecias Node en el directorio “/node_modules” donde se podran usar las librerias antes mencioandas en el archivo y necesarias para el proyecto.

Recordemos que para hacer esto tenemos que estar en la carpeta de nuestros proyecto en la consola o terminal. Por lo general en esta ruta: “/MAMP/htdocs/blog”

Archivo gulpfile.js

Este archivo es necesario para ejecutar tareas para compilacion de Javascript y archivos Sass; necesitaremos que este creado este archivo en raiz, si no lo crearemos como “gulpfile.js”, y le pondremos lo siguiente:

const elixir = require('laravel-elixir'); require('laravel-elixir-vue-2'); /* |-------------------------------------------------------------------------- | Elixir Asset Management |-------------------------------------------------------------------------- | | Elixir provides a clean, fluent API for defining some basic Gulp tasks | for your Laravel application. By default, we are compiling the Sass | file for our application, as well as publishing vendor resources. | */ elixir(mix => { mix.sass('app.scss') .webpack('app.js'); });

En general este archivo ejecuta las tareas de compilación de los estilos Sass y el webpack de javascript “app.js” que lo utilizaremos mas adelante cuando usemos Vue JS. Para la compilacion de estos archivos se encuentran en la carpeta “resources/assets/js” y “resources/assets/sass”. Aquí es donde vamos a programar estos archivos y Gulp se va encargar de la compilación automática, cuando se compilan los guarda en “public/css” y “public/js”.

Mas adelante veremos como ejecutar el comando “gulp” cuando usemos javascript, sass y vue js en la vista.

Archivo .env

Este archivo es donde reside la configuracion o parametros de configuracion de Laravel. Aqui se podra configurar los datos de la base de datos y credenciales del servidor de correo principalmente, tiene mas opciones de parametros de configuracion, por el momento usaremos los de la base de datos. Practicamente asi se debe de ver nuestro archivo .env:

APP_ENV=local APP_KEY=base64:PQW8Ry4mz0X+VkqqGJz9azNmND+8VSX0LYD5vlgLSjY= APP_DEBUG=true APP_LOG_LEVEL=debug APP_URL=http://localhost DB_CONNECTION=mysql #Nombre de nuestra conexion DB_HOST=127.0.0.1 #IP o DNS de nuestro servidor de base de datos DB_PORT=3306 #El puerto del servidor DB_DATABASE=blog #Nombre de la base de datos DB_USERNAME=root #Usuario de la base de datos DB_PASSWORD= #Passwor de la base de datos BROADCAST_DRIVER=log CACHE_DRIVER=file SESSION_DRIVER=file QUEUE_DRIVER=sync REDIS_HOST=127.0.0.1 REDIS_PASSWORD=null REDIS_PORT=6379 MAIL_DRIVER=smtp MAIL_HOST=mailtrap.io MAIL_PORT=2525 MAIL_USERNAME=null MAIL_PASSWORD=null MAIL_ENCRYPTION=null

Como podrán ver para configurar la base de datos viene con el prefijo “DB_” en donde pondremos toda la información relacionada a nuestra base de datos, esta información puede variar dependiendo de su configuración de MySQL.

Archivo /config/database.php

Después de configurar el archivo “.env” debemos configurar este archivo ya que aqui es donde le decimos que conexión de base de datos debemos usar. La flexibilidad de Laravel hace que podamos usar diferentes manejadores de base de datos(MySQL, Oracle, PosgreSQL, etc ...) y diferentes base de datos en nuestro proyecto. La estructura de este archivo debe quedar como sigue:

<?php return [ /* |-------------------------------------------------------------------------- | PDO Fetch Style |-------------------------------------------------------------------------- | | By default, database results will be returned as instances of the PHP | stdClass object; however, you may desire to retrieve records in an | array format for simplicity. Here you can tweak the fetch style. | */ 'fetch' => PDO::FETCH_OBJ, /* |-------------------------------------------------------------------------- | Default Database Connection Name |-------------------------------------------------------------------------- | | Here you may specify which of the database connections below you wish | to use as your default connection for all database work. Of course | you may use many connections at once using the Database library. | */ 'default' => env('DB_CONNECTION', 'mysql'), /* |-------------------------------------------------------------------------- | Database Connections |-------------------------------------------------------------------------- | | Here are each of the database connections setup for your application. | Of course, examples of configuring each database platform that is | supported by Laravel is shown below to make development simple. | | | All database work in Laravel is done through the PHP PDO facilities | so make sure you have the driver for your particular database of | choice installed on your machine before you begin development. | */ 'connections' => [ 'sqlite' => [ 'driver' => 'sqlite', 'database' => env('DB_DATABASE', database_path('database.sqlite')), 'prefix' => '', ], 'mysql' => [ 'driver' => 'mysql', 'host' => env('DB_HOST', 'localhost'), 'port' => env('DB_PORT', '3306'), 'database' => env('DB_DATABASE', 'forge'), 'username' => env('DB_USERNAME', 'forge'), 'password' => env('DB_PASSWORD', ''), 'charset' => 'utf8', 'collation' => 'utf8_unicode_ci', 'prefix' => '', 'strict' => true, 'engine' => null, ], 'pgsql' => [ 'driver' => 'pgsql', 'host' => env('DB_HOST', 'localhost'), 'port' => env('DB_PORT', '5432'), 'database' => env('DB_DATABASE', 'forge'), 'username' => env('DB_USERNAME', 'forge'), 'password' => env('DB_PASSWORD', ''), 'charset' => 'utf8', 'prefix' => '', 'schema' => 'public', 'sslmode' => 'prefer', ], ], /* |-------------------------------------------------------------------------- | Migration Repository Table |-------------------------------------------------------------------------- | | This table keeps track of all the migrations that have already run for | your application. Using this information, we can determine which of | the migrations on disk haven't actually been run in the database. | */ 'migrations' => 'migrations', /* |-------------------------------------------------------------------------- | Redis Databases |-------------------------------------------------------------------------- | | Redis is an open source, fast, and advanced key-value store that also | provides a richer set of commands than a typical key-value systems | such as APC or Memcached. Laravel makes it easy to dig right in. | */ 'redis' => [ 'cluster' => false, 'default' => [ 'host' => env('REDIS_HOST', 'localhost'), 'password' => env('REDIS_PASSWORD', null), 'port' => env('REDIS_PORT', 6379), 'database' => 0, ], ], ];

Si observamos bien toda la información se obtiene del archivo “.env” por medio de la funcion “env()”. La conexión por default se define con el apartado “'default' => env('DB_CONNECTION', 'mysql'),”, en donde se le pasa como valor el nombre de la conexion definida en el archivo “.env”. En general es un array asociativo de PHP que se usa como configuración para Laravel.

El array “connections” se puede configurar en los modelos para poder usar ese tipo de manejador de base de datos y su base de datos, aqui es donde viene la flexibilidad de Laravel; por el momento solo usaremos el Driver de MySQL.

Archivo config/app.php

Este archivo se configura las opciones generales de nuestra aplicación como por ejemplo: paquetes de Laravel, librerías, métodos de encriptación, idiomas, usos horarios etc ..

Aqui nada mas modificaremos nuestro timezone que viene en el apartado del array “'timezone' => 'UTC',”, este lo modificaremos a nuestro gusto dependiendo de que zona horaria manejaremos. La estructura del archivo es la siguiente:

<?php return [ /* |-------------------------------------------------------------------------- | Application Name |-------------------------------------------------------------------------- | | This value is the name of your application. This value is used when the | framework needs to place the application's name in a notification or | any other location as required by the application or its packages. */ 'name' => 'Laravel', /* |-------------------------------------------------------------------------- | Application Environment |-------------------------------------------------------------------------- | | This value determines the "environment" your application is currently | running in. This may determine how you prefer to configure various | services your application utilizes. Set this in your ".env" file. | */ 'env' => env('APP_ENV', 'production'), /* |-------------------------------------------------------------------------- | Application Debug Mode |-------------------------------------------------------------------------- | | When your application is in debug mode, detailed error messages with | stack traces will be shown on every error that occurs within your | application. If disabled, a simple generic error page is shown. | */ 'debug' => env('APP_DEBUG', false), /* |-------------------------------------------------------------------------- | Application URL |-------------------------------------------------------------------------- | | This URL is used by the console to properly generate URLs when using | the Artisan command line tool. You should set this to the root of | your application so that it is used when running Artisan tasks. | */ 'url' => env('APP_URL', 'http://localhost'), /* |-------------------------------------------------------------------------- | Application Timezone |-------------------------------------------------------------------------- | | Here you may specify the default timezone for your application, which | will be used by the PHP date and date-time functions. We have gone | ahead and set this to a sensible default for you out of the box. | */ 'timezone' => 'UTC', /* |-------------------------------------------------------------------------- | Application Locale Configuration |-------------------------------------------------------------------------- | | The application locale determines the default locale that will be used | by the translation service provider. You are free to set this value | to any of the locales which will be supported by the application. | */ 'locale' => 'en', /* |-------------------------------------------------------------------------- | Application Fallback Locale |-------------------------------------------------------------------------- | | The fallback locale determines the locale to use when the current one | is not available. You may change the value to correspond to any of | the language folders that are provided through your application. | */ 'fallback_locale' => 'en', /* |-------------------------------------------------------------------------- | Encryption Key |-------------------------------------------------------------------------- | | This key is used by the Illuminate encrypter service and should be set | to a random, 32 character string, otherwise these encrypted strings | will not be safe. Please do this before deploying an application! | */ 'key' => env('APP_KEY'), 'cipher' => 'AES-256-CBC', /* |-------------------------------------------------------------------------- | Logging Configuration |-------------------------------------------------------------------------- | | Here you may configure the log settings for your application. Out of | the box, Laravel uses the Monolog PHP logging library. This gives | you a variety of powerful log handlers / formatters to utilize. | | Available Settings: "single", "daily", "syslog", "errorlog" | */ 'log' => env('APP_LOG', 'single'), 'log_level' => env('APP_LOG_LEVEL', 'debug'), /* |-------------------------------------------------------------------------- | Autoloaded Service Providers |-------------------------------------------------------------------------- | | The service providers listed here will be automatically loaded on the | request to your application. Feel free to add your own services to | this array to grant expanded functionality to your applications. | */ 'providers' => [ /* * Laravel Framework Service Providers... */ Illuminate\Auth\AuthServiceProvider::class, Illuminate\Broadcasting\BroadcastServiceProvider::class, Illuminate\Bus\BusServiceProvider::class, Illuminate\Cache\CacheServiceProvider::class, Illuminate\Foundation\Providers\ConsoleSupportServiceProvider::class, Illuminate\Cookie\CookieServiceProvider::class, Illuminate\Database\DatabaseServiceProvider::class, Illuminate\Encryption\EncryptionServiceProvider::class, Illuminate\Filesystem\FilesystemServiceProvider::class, Illuminate\Foundation\Providers\FoundationServiceProvider::class, Illuminate\Hashing\HashServiceProvider::class, Illuminate\Mail\MailServiceProvider::class, Illuminate\Notifications\NotificationServiceProvider::class, Illuminate\Pagination\PaginationServiceProvider::class, Illuminate\Pipeline\PipelineServiceProvider::class, Illuminate\Queue\QueueServiceProvider::class, Illuminate\Redis\RedisServiceProvider::class, Illuminate\Auth\Passwords\PasswordResetServiceProvider::class, Illuminate\Session\SessionServiceProvider::class, Illuminate\Translation\TranslationServiceProvider::class, Illuminate\Validation\ValidationServiceProvider::class, Illuminate\View\ViewServiceProvider::class, /* * Package Service Providers... */ // /* * Application Service Providers... */ App\Providers\AppServiceProvider::class, App\Providers\AuthServiceProvider::class, // App\Providers\BroadcastServiceProvider::class, App\Providers\EventServiceProvider::class, App\Providers\RouteServiceProvider::class, /** * Laravel Scout Providers */ Laravel\Scout\ScoutServiceProvider::class, TeamTNT\Scout\TNTSearchScoutServiceProvider::class, ], /* |-------------------------------------------------------------------------- | Class Aliases |-------------------------------------------------------------------------- | | This array of class aliases will be registered when this application | is started. However, feel free to register as many as you wish as | the aliases are "lazy" loaded so they don't hinder performance. | */ 'aliases' => [ 'App' => Illuminate\Support\Facades\App::class, 'Artisan' => Illuminate\Support\Facades\Artisan::class, 'Auth' => Illuminate\Support\Facades\Auth::class, 'Blade' => Illuminate\Support\Facades\Blade::class, 'Bus' => Illuminate\Support\Facades\Bus::class, 'Cache' => Illuminate\Support\Facades\Cache::class, 'Config' => Illuminate\Support\Facades\Config::class, 'Cookie' => Illuminate\Support\Facades\Cookie::class, 'Crypt' => Illuminate\Support\Facades\Crypt::class, 'DB' => Illuminate\Support\Facades\DB::class, 'Eloquent' => Illuminate\Database\Eloquent\Model::class, 'Event' => Illuminate\Support\Facades\Event::class, 'File' => Illuminate\Support\Facades\File::class, 'Gate' => Illuminate\Support\Facades\Gate::class, 'Hash' => Illuminate\Support\Facades\Hash::class, 'Lang' => Illuminate\Support\Facades\Lang::class, 'Log' => Illuminate\Support\Facades\Log::class, 'Mail' => Illuminate\Support\Facades\Mail::class, 'Notification' => Illuminate\Support\Facades\Notification::class, 'Password' => Illuminate\Support\Facades\Password::class, 'Queue' => Illuminate\Support\Facades\Queue::class, 'Redirect' => Illuminate\Support\Facades\Redirect::class, 'Redis' => Illuminate\Support\Facades\Redis::class, 'Request' => Illuminate\Support\Facades\Request::class, 'Response' => Illuminate\Support\Facades\Response::class, 'Route' => Illuminate\Support\Facades\Route::class, 'Schema' => Illuminate\Support\Facades\Schema::class, 'Session' => Illuminate\Support\Facades\Session::class, 'Storage' => Illuminate\Support\Facades\Storage::class, 'URL' => Illuminate\Support\Facades\URL::class, 'Validator' => Illuminate\Support\Facades\Validator::class, 'View' => Illuminate\Support\Facades\View::class, ], ];

Creación de la base de datos

Para crear nuestra base de datos abriremos la herramienta “phpMyAdmin” que viene en cualquier stack de XAMP y que por lo general tiene esta url “localhost/phpMyAdmin”(esto ya depende de como se configuro el ambiente de desarrollo).

Una vez abierto el phpMyAdmin nos dirigimos al menú de la parte superior y en la seccion Base de Datos o Databases damos click.

En donde dice Crear Base de Datos ponemos nuestro nombre de la base de datos en este caso “blog”, cotejamiento “utf8_general_ci”, le damos click en el botón “Crear” o “Create”.

Y con eso tenemos ya lista nuestra base de datos en nuestro servidor de desarrollo. En el siguiente capitulo veremos como hacer migraciones, factories y modelos que son componentes de Laravel para la capa de datos.

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Instalación del Proyecto] (2)

En el articulo anterior vimos como instalar el entorno de desarrollo para Laravel. Ahora veremos como instalar un proyecto, no entraremos en detalle sobre la estructura de directorios de Laravel, si quieren saber mas sobre Laravel deben consultar su documentación oficial: https://laravel.com/docs/5.3

El primer paso es instalar la global del comando Laravel para poder ejecutarla en la linea de comando. A esta instancia ya se debe tener Composer instalado de manera global; abrimos la linea de comandos o la terminal y ejecutamos:

composer global require "laravel/installer"

Una vez terminado el proceso del comando anterior, navegamos hasta donde queramos el proyecto en la linea de comandos(usualmente es htdocs o www dependiendo el servidor web que se use) y ejecutamos:

laravel new blog

Este comando ejecuta un nuevo proyecto llamado blog, crea la carpeta con las librerias que necesita Laravel, bajara la ultima version que es la 5.3.

Para probar nuestra instalación rapidamente ejecutamos el siguiente comando:

php artisan serve

Este comando ejecuta el servidor de desarrollo que trae Laravel, una vez ejecutado abrimos nuestro explorador de internet y escribimos la direccion del servidor web: http://localhost:8000.

Si se guardo el proyecto en la carpeta web del servidor web de Apache, se puede ejecutar en el explorador de internet de la siguiente forma: http://localhost/blog/public.

Si todo sale bien veremos la pagina de bienvenida de Laravel. Ya con esto el siguiente articulo veremos la configuración del proyecto.

Nota: si no se puede ejecutar el comando “laravel new” se puede instalar el proyecto con el siguiente comando:

composer create-project --prefer-dist laravel/laravel blog

0 notes

krsrk · 8 years ago

Text

Creación de una web app con Laravel 5.3 [Introducción y Entorno de Desarrollo] (1)

Introducción

En este articulo cubriremos la creación de un Blog para representar los pasos a seguir y problemáticas al usar este framework en la creación de web apps.

En este artículo veremos el paso a paso de como crear una web app en Laravel 5.3. Como sabemos Laravel se ha convertido por su simplicidad y flexibilidad en el framework favorito de los desarrolladores web, ya que nos proporciona herramientas donde podemos crear web apps fácilmente sin siquiera algún esfuerzo, obvio se tiene que tener experiencia en lenguaje de programación PHP.

Entorno de Desarrollo

Asumiremos que ya tenemos el entorno XAMP(Any OS, Apache, MySQL, PHP) instalado en nuestras computadoras; el sistema operativo es indiferente ya que se ha probado la misma aplicación en diferentes sistemas y funciona igual, obvio la problemática de los browsers en diferentes sistemas operativos continua pero eso es externo a Laravel.

Aparte de este entorno asumiremos también que se tiene instalado el Composer que es el que se usa para instalar las dependencias de Laravel y para crear la global Laravel en la linea de comandos.

Usaremos las siguientes herramientas:

Apache(versión que viene con el bundle):

Windows: se recomienda WAMP. Se puede usar XAMPP o MAMP.

Mac: XAMPP o MAMP

MySQL(versión mas actual o la que viene con el bundle):

Nota: el bundle XAMPP en la versión actual no tiene instalado MySQL sino MariaDB. Se tiene que instalar MySQL por separado.

PHP 5.6 >=(viene instalado con el bundle)

Nota: se recomienda la versión 7>=

Composer:

Nota: En Mac se tiene que correr con el archivo .phar o configurarlo global; el proceso de configuracion global es un poco complicado. Tanto en Windows como Mac se tiene que tener activada la extension PHP de openssl, en Windows tiene problemas cuando esta extension no esta activada y se tendria que deshabilitar el uso de esta extension(no recomendable) en el Composer.

Node JS:

Nota: Se debe instalar de forma global para ejecutarlo en la linea de comandos.NPM viene incluido en Node JS.

Gulp:

Nota: Se debe instalar de forma global para ejecutarlo en la linea de comandos.

Vue Js:

Nota: Se instala practicamente con el framework en la herramienta elixir de Laravel y el Node, ya que la versión 5.3 de Laravel lo trae incluido.

Materialize CSS(versión mas actual)

Links

Apache:

WAMP: http://www.wampserver.com/en/

XAMPP: https://www.apachefriends.org/es/index.html

MAMP: https://www.mamp.info/en/

MySQL: https://www.mysql.com/downloads/

PHP: http://php.net/manual/es/intro-whatis.php

Composer: https://getcomposer.org/

Node JS: https://nodejs.org/es/

GULP: http://gulpjs.com/

Vue JS: https://vuejs.org/

Materialize CSS: http://materializecss.com/

Una vez instalado nuestras herramientas procederemos a crear el proyecto de Laravel.

Nota: Sobre la compatibilidad de sistemas operativos

En este articulo no vamos a cubrir a fondo las peculiaridades al desarrollar en diferentes sistemas operativos; sin embargo hay ciertos casos que se deben de tomar en cuenta cuando el proyecto se suba a producción. Es recomendable, que se estandarice el entorno de desarrollo con la herramienta Homestead de Laravel y sea estos mismo requisitos de servidor web y sistema operativo lo que estén en producción. Mientras tanto muestro un caso que me paso al trabajar con entorno Windows y Linux:

Tipo de datos:

Linux: Si hacemos comparación de datos de un query de Eloquent Laravel con INT. Puede suceder que la condición falle dependiendo de cual sea, ya que en Linux toma literal el tipo de datos del query que en este caso es String; En Windows hace lo opuesto ya que el String cuando hace la comparación con un Int, este hace el cast automático; tanto puede ser versión de Sistema Operativo como de PHP en el sistema operativo:

Ejemplo:

if ($user->id !== 0) { ///$user->id == “1”

echo “Si tiene ID”;

} else { ///En linux toma el cast literal, $user->id es String

echo “No tiene ID”;

}

Solución:

if ((int)$user->id !== 0) { ///$user->id = 1 (Es Int)

echo “Si tiene ID”;

} else {

echo “No tiene ID”;

}

#php #laravel #mysql #vuejs

0 notes

krsrk · 9 years ago

Text

Primeros pasos Laravel y MS SQL Server - 2da Parte

En la entrega anterior nos quedamos en la instalacion de Laravel; ahora en esta entrega nos dedicaremos a configurar el MS SQL Server para que funcione con Laravel.

Les recuerdo que asumo que ya tienen instalado el SQL Server(2008), Windows Server 2008 o Windows 7; al menos en estas distros de Windows ha sido probado el Laravel con SQL Server.

Tambien les recuerdo que necesitamos acceder a los archivos de configuracion del Apache y del PHP; les recomiendo que instalen el MAMP ya que es un stack LAMP multiplataforma; y por medio de este es facil acceder y editar los archivos de configuracion.

Configuracion del entorno.

Tendremos que configurar el SQL Server para que se comunique con el PHP y tambien que el PHP tenga los drivers disponibles de este manejador de base de datos. Asi que tendremos que bajar primero el ODBC Driver, lo bajan de aca

https://www.microsoft.com/es-mx/download/details.aspx?id=36434

Ya despues de instalarlo tenemos que conseguir los DLLS de la extencion del PHP para que funcione con el SQL Server. Esos los descargan de aca:

https://msdn.microsoft.com/es-es/library/mt683517.aspx

En los DLLS tenemos que elegir que version tenemos de PHP por obvias razones se instalo un entorno de Laravel 5.2 con PHP 5.6; aunque la version ultima de Laravel funciona con PHP 7; en los DLLS no existe hasta el momento una version. Asi que tendremos que usar para PHP 5.6. Reitero dependiendo de su version es lo que tienen que bajar o usar.

Una vez instalado el ODBC Driver, proseguiremos a instalar los DLLS del PDO de PHP, asi que nos dirigiremos a esta ruta en su entorno Apache o servidor web:

C:\MAMP\conf\php5.6.21

Este ejemplo tomo como entorno el MAMP aqui lo que se hace es dirigirse al php.ini de PHP.

Una vez localizado el php.ini nos pondremos a editarlo; basicamente habilitaremos la extension dll para el sql server en las siguientes lineas:

; Windows Extensions ; Note that ODBC support is built in, so no dll is needed for it. ; Note that many DLL files are located in the extensions/ (PHP 4) ext/ (PHP 5) ; extension folders as well as the separate PECL DLL download (PHP 5). ; Be sure to appropriately set the extension_dir directive.

extension=php_bz2.dll extension=php_gd2.dll extension=php_gettext.dll extension=php_mbstring.dll extension=php_exif.dll extension=php_mysql.dll extension=php_mysqli.dll extension=php_pdo_sqlite.dll extension=php_sqlite3.dll extension=php_pdo_sqlsrv_56_ts.dll ;descomentaremos o pondremos esta linea extension=php_curl.dll

Aqui habilitaremos la extension del SQL Server para que pueda trabajar con el PHP, una vez insertada la linea o descomentada. Guardaremos los cambios y copiaremos los archivos dll que bajamos.

En la carpeta donde se bajaron los DLLS escogeremos el dll para nuestra version de PHP en este caso yo escogi este: php_pdo_sqlsrv_56_ts.dll. Lo copiaremos y nos iremos a la siguiente ruta:

C:\MAMP\bin\php\php5.6.21\ext

En esta ruta se encuentran las extensiones dinamicas de Windows de PHP, asi que pegaremos el dll y reiniciaremos nuestros servicio de Apache.

Les recuerdo que el nombre del archivo DLL debe ser igual al de la extension del php.ini, si no es asi, les causara error o simplemente no cargara la extension.

Ya que tenemos nuestro php.ini listo y los dll’s, volveremos a la ruta:

C:\MAMP\conf\php5.6.21

Copiaremos el php.ini y lo pegaremos en :

C:\MAMP\bin\php\php5.6.21

Esto sirve para que el PHP tome esa configuracion en la linea de comandos, que la vamos a utilizar mucho para hacer migraciones con Laravel, si nos e hace esto, a la hora de hacer migraciones nos marcara error.

De nuevo reiniciamos Apache. Y ya estara listo para empezar a usar el SQL Server en Laravel. La proxima entrega haremos migraciones y un pequeño CRUD con Laravel.

#laravel #sql server #php #windows

0 notes

krsrk · 9 years ago

Text

Primeros pasos Laravel y MS SQL Server - 1ra Parte

Laravel ha sido uno de los mas famosos frameworks de PHP, por su robustez y rapidez y aparte por su liavanez es uno de los mas usados para hacer RESTFul APIS(lo que esta de moda hoy). En esta publicación haremos una configuracion de Laravel desde 0; configurando tambien Eloquent(ORM de Laravel) con SQL Server. Todas las pruebas se hicieron con Windows 7 de manera local y Windows 2008 Server. Asumire que ya se tiene instalado el PDO SQL Driver de Microsoft y el SQL Server(Standar). Por lo regular Laravel se usa con MySQL en un entorno LAMP pero por “Urgencias Profesionales y Laborales” se tuvo que investigar como conectarlo con MS SQL Server.

1.- Instalacion de Laravel

Para esta instalacion se tendra que instalar Composer que es un sistema de dependencias para nuestras apps y lo usa Laravel, uan vez instalado usaremos la linea de comandos en modo administrador y ejecutaremos:

composer create-project --prefer-dist laravel/laravel myapp

Donde “myapp” es el nombre de nuestro proyecto o aplicacion y “laravel/laravel” es la ruta donde se va crear nuestro proyecto. Una vez ejecutado este comando Se generara la estructura de directorios y archivos de Laravel. Con esto ya tenemos listo los archivos de nuestro proyecto.

2.- Configuración

Para configurar nuestro proyecto debemos tener nuestro archivo .env listo para generar nuestra API KEY la cual es utilizada por Laravel para su configuracion. Sin mas, habra que buscar en el directorio raiz del proyecto un archivo que se llama .env.example, se tendra que copiar y cambiar el nombre por .env, una vez hecho esto abra que abrir el archivo y veremos lo siguiente:

APP_ENV=local APP_DEBUG=true APP_KEY=b809vCwvtawRbsG0BmP1tWgnlXQypSKf APP_URL=http://localhost

DB_HOST=127.0.0.1 DB_DATABASE=homestead DB_USERNAME=root DB_PASSWORD=root

CACHE_DRIVER=file SESSION_DRIVER=file QUEUE_DRIVER=sync

REDIS_HOST=127.0.0.1 REDIS_PASSWORD=null REDIS_PORT=6379

MAIL_DRIVER=smtp MAIL_HOST=mailtrap.io MAIL_PORT=2525 MAIL_USERNAME=null MAIL_PASSWORD=null MAIL_ENCRYPTION=null

Donde lo mas importante de este archivo sera el prefijo “DB_” ya que sera nuestra configuracion de la base de datos.

Una vez configurado el archivo .env ejecutaremos lo siguiente en la linea de comando:

php artisan key:generate

Si no genero erro el comando con esto ya tendremos nuestro proyecto configurado ahora nada mas queda probar en la direccion local: http://localhost/miproyecto/public; y ver que realmente funciona.

Esto seria todo por esta entrega la proxima veremos Migraciones a la base de datos y la configuracion del SQL Server para poder comunicarnos a una base de datos.

Les recuerdo que los pre requisitos para instalar Laravel en esta publicacion son:

SQL Server 2008

PHP 5.6>=

Apache Server(version mas actual)

Windows 7

Requisitos de instalacion de Laravel: https://laravel.com/docs/5.2/installation

0 notes

krsrk · 11 years ago

Text

Estructura de Directorios ZF2

Con esta nueva version del framework la estructura de archivos cambio un poquito (sarcasmo), asi que haremos un recorrido por la estructura de directorios del ZF2. Este post es continuacion de la instalacion del proyecto, asumires que ya lo tienen instalado, de nuevo menciono que todo se hizo en Mac Osx Mavericks.

config: Archivos de configuración del proyecto, en la version 1 era el famosisimo application/config/application.ini. Aqui se van a precargar configuracione y recursos necesarios para nuestra aplicacion.

data: Se guardan archivos en cache de la aplicacion. Esta carpeta no era nativa de la version 1.

module: Con la nueva arquitectura modular, esta carpeta vino a sustituir a la carpeta application/ de la version 1. En ella se encuentran los modulos de la aplicacion. Dentro de ella se encuentran las vistas y los controladores de los modulos asi como tambien los modelos.

public: Esta carpeta quedo igual que en la version 1. Aqui se guardan los estilos, scripts etc ...

vendor: Sustituye la carpeta library de la version 1. Se encuentra las librerias del Zend asi como tambien librerias que usemos de terceros como Doctrine.

Como se puede observar en la imagen dentro de las carpetas de los modulos, se encuentran las carpeta src/ la cual almacena los controllers, views y models de cada modulo.

Los que esten familiarizados con la version 1 no tendran mucho problema en adaptarse a esta nueva version, salvo las configuracion de los modulos que se hacen manual, ya que todavia no existe una herramienta para hacer esto. Existe el Zend Tool pero para esta version todavia le falta desarrollo. Pero es un buen inicio para saber de donde salen las cosas en la version 2 de estre framework.

0 notes

krsrk · 11 years ago

Text

Instalacion de Zend Framework 2

Zend Framework 2 es la nueva version de este famoso framework de PHP, en esta actualizacion se usa Inyeccion de Dependencias o DI, su arquitectura nativa incluye modulos(en la version 1 se tenia que configurar), y en si su estructura de directorios cambio radicalmente sin perder la esencia del patron de diseño MVC(Model View Controller)

Instalaremos un proyecto manual usando Zend Tool y Composer en un Mac Osx Mavericks. Todos los comandos se ejecutaron con SUDO por aquello de los permisos de las carpetas.

Empecemos !!!!

1.- Instalacion de Composer(Si ya se cuenta instalado pasar al paso 2).

Se debe ejecutar el siguiente comando; la extencion cURL debe estar activada en la linea de comandos:

curl -sS https://getcomposer.org/installer | php

Se mueve a bin para ejecutar el composer en la linea de comandos

mv composer.phar /usr/local/bin/composer

Documentacion: https://getcomposer.org

2.- Instalacion de dependencias de Zend Framework 2 con Composer:

Se obtiene el Zend Skeleton

php composer.phar create-project -sdev --repository-url="https://packages.zendframework.com" zendframework/skeleton-application path/to/install php composer.phar update

Se creo la siguiente ruta: path/to/install.

3.- Instalacion de Zend Tool

Descargar el Zend Tool con Composer, se descargara en el directorio donde se ejecuta el comando:

composer require zendframework/zftool:dev-master

Se creara la carpetala carpeta vendor/zftol, copiar el archivo zf.php a path/to/install y ejecutar los comandos para crear el proyecto:

php zf.php <zend tool comando>

Probemos que en verdad funciona:

php zf.php --version

Se debe visualizar en la consola la version de Zend Tool y Zend Framework

4.- Creacion de proyectos:

Usamos el siguiente comando:

php zf.php create project Applications/XAMPP/xampfiles/htdocs/<carpeta de mi proyecto>

Documentacion: http://framework.zend.com/manual/2.2/en/modules/zendtool.introduction.html

5.- Instalar las dependencias del proyecto:

Ejecutar:

php composer.phar

El archivo composer.phar se encuentra en la carpeta del proyecto cuando se crea.

Si todo salio bien abrir el navegador de internet y poner la direccion del proyecto:

http://localhos/zf-tuto/public

Se debe visualizar la siguiente pantalla:

Y voila !!!!! ya tenemos nuestro primer proyecto en ZF2 instalado ...

#zend framework #zf2 #php #zend

0 notes

krsrk · 11 years ago

Link

Para que aprendan mas rapido el MVC

0 notes

krsrk · 11 years ago

Text

Primer comienzo con Zend 1.12 - Parte 2.1

Instalación del Framework.

En el capítulo anterior vimos un resumen rápido del patrón de diseño que maneja Zend, el MVC (Model-View-Controller), como sabremos este modelo divide la lógica del negocio en tres partes, teniendo más control y administración sobre nuestro proyecto.

En esta entrega veremos cómo instalar el Zend Framework, asumiré de que ya se tiene experiencia en el servidor web apache, exactamente en el stack de XAMPP, y este mismo ya se tiene instalado. Esto también lo haremos sobre un ambiente Windows 7. En próximas entregas haremos la instalación para cualquier distro en Linux y para Mac. También se requiere experiencia en el uso de Netbeans que va ser nuestro IDE o editor para codificar el proyecto.

Lo primero es bajarnos todos los elementos requeridos, que a continuación listo:

- Zend Framework 1.12 (bajar la versión full): http://framework.zend.com/downloads/latest#ZF1

- Netbeans 7.4 (se requiere tener el plugin JDK de Java para poderlo abrir): https://netbeans.org/downloads/

- XAMPP: http://www.apachefriends.org/es/download_success.html

Como mencionamos anteriormente ya se debe tener instalado el XAMPP que es un stack de aplicaciones, este te instala PHP, MySQL y Apache en un entorno Windows; y sobre este servidor web vamos a trabajar.

Ya teniendo instalado el XAMPP, nos dirigimos a la carpeta de la aplicación, por lo regular se pone en C:/xampp, si no en la carpeta que usaron para la instalación, en esta carpeta hay una que se llama "htdocs" en ella se ponen todos los proyectos y páginas web basadas en PHP, aunque no necesariamente tienen que tener este lenguaje para que funcionen en el Apache web server, puede ser puro HTML y las paginas van a correr igual.

Una vez posicionados en la carpeta "htdocs", creamos una carpeta que se va llamar test(o como ustedes le quieran nombrar, para este tutorial va ser "test"). Entonces ya tenemos la siguiente ruta: C:/xampp/htdocs/test. El paso siguiente es ver la estructura de directorios del Zend.

Estructura de directorios.

Zend maneja también un estándar de directorios para el proyecto, ya basados en el paradigma del MVC. Para esto vamos a necesitar saber dónde queda cada elemento del proyecto (código de programación) para que se nos haga más fácil el acceso a nuestro código. Por lo regular una estructura básica de un proyecto en Zend sería como la siguiente.

Como podremos ver en la imagen existen tres carpetas importantes: public, application y library. Estas carpetas son la base para un proyecto de Zend, a continuación las explico un poco más a fondo.

El directorio public

Este directorio se encuentran las carpetas de los recursos del proyecto, a que se refiere con esto, que ahí va contener los scripts de Js, y CSS, también se cuenta con un .htaccess y un index.php, estos dos archivos uno es para los parámetros de seguridad y enrutamiento de la página y el index.php hace las llamadas a las clases principales de Zend que se van a encargar de enrutar nuestra aplicación en sus diferentes páginas.

El directorio application

Este directorio es donde se guarda todo el código fuente de nuestra aplicación. Se puede observar que se divide en diferentes carpetas, estas son los componentes del Zend, los importantes son: controller, layout, forms, views, model. Aquí ya se ve un poco como se aplica el MVC en la estructura de los archivos. Cuenta con un archivo llamada Bootstrap.php que también hace llamados a clases del Zend que pongamos en este archivo antes que se mande a llamar el controlador.

El directorio library

Aquí se encontrar las librerías que va usar el Zend para desarrollar el proyecto. Las clases principales son Zend_Controller y Zend_View que son las que hacen la separación de la lógica del negocio del MVC. El Model se va registrar aparte y serian todas las librerías externas(que no son nativas del Zend) que nosotros creemos y que se conviertan en código re usable.

Y las vistas???

Estas se encuentran en la siguiente ruta application/views/nombre-accion/index.phtml. Como se podrá ver las vistas guardadas en esta carpeta tienen que tomar el nombre del controlador y los archivos phtml el nombre de los action del controlador (este metodo es un dispatch de las vistas y lo veremos más adelante).

Una vez teniendo claro la estructura de directorios del Zend, procedemos a crear nuestro proyecto.

Usando Netbeans y Zend Tool

Para crear un proyecto con más facilidad usaremos dos herramientas una es Netbeans y la otra Zend Tool. Netbeans es un IDE para codificar los proyectos, pero tiene soporte para Zend lo cual hace más fácil crear un proyecto. Zend Tool es la herramienta encargada de hacer todo, se puede crear desde el mismo proyecto (te genera las estructuras de directorio), vistas, controladores, modelos, layouts, forms.

Primero tenemos que configurar el entorno de Netbeans para que puede usar el Zend Tool desde el mismo IDE. Antes de hacer este paso tenemos que descomprimir el Zend Framework (el que se bajó de la página) en la siguiente ruta: C:/zf (pueden crear la carpeta que quieran).

Nos vamos a Tools (Herramientas)->Options (Opciones)->PHP, veremos la siguiente pantalla

Le damos a la opción Browser (en la sección de Zend Script) y nos vamos a la siguiente ruta: C:\ZF\bin; una vez ahí escogemos el archivo .bat que está en esa carpeta.

Con esto ya le dijimos al Netbeans que use el Zend Tool por nosotros. Ahora a crear el proyecto de Zend.

Creando un proyecto con Zend Tool y Netbeans

Para esto hacemos lo siguiente; creamos un nuevo proyecto en Netbeans: File->New Project; o se le da clic al icono de nuevo proyecto ubicado en la barra de herramientas del Netbeans.

Le decimos que queremos un proyecto de PHP -> Php Application y le damos clic en el botón de siguiente.

Le decimos como se va llamar el proyecto y donde guardarlo; en este caso sería en C:/xampp/htdocs/test, y le damos clic en siguiente.

Le decimos la Url del servidor donde se va correr nuestra aplicación, y clic en siguiente.

En la siguiente pantalla nos pide que Php Framework vamos a usar, escogemos la opción de Zend Framework. Y le damos en finalizar o Finish.

Y Voila!!!! Ya tenemos nuestro proyecto de Zend creado.

Como este post se extendió por muchos detalles, próxima entrega ya nos pondremos a programar, ya en base con Netbeans y Zend Tool (crearemos lo demás que nos falta para nuestro proyecto), y crearemos un controlador con varias vistas.

0 notes

krsrk · 11 years ago

Text

Primer comienzo con Zend 1.12 - Parte 1

Zend es la empresa detras de los estandares y certificaciones de PHP, ellos desarrollaron un framework o un conjunto de librerias para el desarrollo de proyectos realizados en PHP.

Este framework se basa en un patron de diseño llamado “MVC – Model View Controller” o Modelo Vista Controlador, este patron de diseño divide la logica del negocio en estas tres partes. Tambien desarrolla el paradigma de POO o Programacion Orientada a Objetos, que lo que hace es una abstraccion de la realidad(Objetos) transformado a la programacion. Por lo tanto la programacion con este framework guarda la semantica y te ayuda con sus librerias a que tus proyectos tengan calidad de software y orden .

Veremos los primeros pasos para hacer una instalacion y una explicacion rapida a los elementos que conforman esta tecnología.

Introducción a la arquitectura del Zend. MVC(Model View Controller)

Que demonios es MVC ?

Como habíamos mencionado antes MVC es un patron de diseño orientado a objetos que divide la lógica del negocio en tres partes. Segun la teoria separa los datos y la lógica de negocio de una aplicación de la interfaz de usuario y el módulo encargado de gestionar los eventos y las comunicaciones. Para ello MVC propone la construcción de tres componentes distintos que son el modelo, la vista y el controlador, es decir, por un lado define componentes para la representación de la información, y por otro lado para la interacción del usuario.Este patrón de diseño se basa en las ideas de reutilización de código y la separación de conceptos, características que buscan facilitar la tarea de desarrollo de aplicaciones y su posterior mantenimiento.

Fuente: http://es.wikipedia.org/wiki/Modelo_Vista_Controlador

Diagrama Modelo Vista Controlador

En otras palabras tu aplicacion o proyecto te lo divide en tres: modelo, la vista y el controlador. Lo que hace que en cuestiones de mantenimiento se detecte mas rapido el error, en cuestiones de desarrollo sea mas rapido y en cuestiones de acceso a los datos sea mas flexible. A continuacion se explican cada una de estas partes del Modelo Vista Controlador

A que bella Vista …

La primera parte y seria las mas importante ya que en ella se desarrolla todo lo que el usuario haga o en otras palabras la interfaz de usuario y seria el producto final del desarrollo, seria la Vista (View). En ella se encuentra todo el HTML, Javascript y CSS que la interfaz pueda usar. Esto significa que en cuestiones de diseño esta parte es la que se afectaria. Haciendo llamadas a archivos de Javascript y CSS y haciendo renders del codigo HTML.

Un controlador para controlarlo todo …

La segunda parte seria el Controlador(Controller). Esto vendria siendo el motor de tu aplicacion ya que aqui se hace la programacion y las llamadas a los modelos o clases que tengas en tu sistema, el controlador puede tambien en el caso de Zend hacer el llamado a la Vista por medio de su metodos Action(esto se explicara mas adelante). En esta area es donde se definen llamadas al Modelo para procesar la informacion y mostrarla en la Vista.

Modelo a seguir …

La tercera parte es el Modelo(Model). Esta parte es el back-end de tu sistema, es donde se define los llamados a las librerias que desarrolles para el sistema y para el acceso a los datos(se acostumbra a usar un ORM para tener mas abstraccion a la hora de acceder a la base de datos).

Como podrían darse cuenta la arquitectura que maneja Zend simplifica mucho los procesos de un proyecto y le da mas ordenamiento al mismo, al dividir el proyecto en estas tres partes, los tiempos de respuesta a la hora de dar soporte o mantenimiento o actualizaciones sera mas rápido, inclusive también en las pruebas de la aplicación.

En el siguiente capitulo veremos mas a fondo el Zend Framework, desde la instalación, estructura de archivos, y crearemos un “Hola Mundo” como nuestra primera aplicación.

#zend #php

0 notes