Mostrando entradas con la etiqueta Laravel. Mostrar todas las entradas
Mostrando entradas con la etiqueta Laravel. Mostrar todas las entradas

jueves, 26 de abril de 2018



Creacion de un Blog Personal Con Laravel 5.6

Guardar una publicación de blog

Ahora necesitamos un controlador más para nuestras publicaciones de blog. Entonces, crea un archivo en la carpeta app/http/controller/, que se llamara ArticuloContoller.php. El código final del controlador debe ser el siguiente:

(Puedes crear el contralador usando el comando php artisan make:controller ArticuloController)


<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use App\Articulo;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Redirect;
use View;
class ArticuloController extends Controller
{
//
public function getIndex(){
$articulos = Articulo::with('Autor')-> orderBy('id', 'DESC')->paginate(5);
return View::make('index')->with('articulos',$articulos);
}
public function getAdmin(){
return View::make('agregarArticulo');
}
public function crearArticulo(){
Articulo::create(array(
'titulo' => Input::get('titulo'),
'contenido' => Input::get('contenido'),
'idAutor' => Auth::user()->id
));
return Redirect::route('index');
}
}

Asignando publicaciones de blog a los usuarios

La función crearArticulo() procesa la nueva solicitud de creación de publicación de blog en la base de datos. Como puede ver, podemos obtener la identificación del autor con un método mencionado anteriormente:

Auth::user()->id

Con este método, podemos asignar al usuario actual el articulo creado. Como verá, tenemos un nuevo método en la consulta:

Articulo::with('Autor')->

Si lo recuerda, hemos definido una función pública Autor() en nuestro modelo de Artículos:


public function Autor(){

        return $this->belongsTo('App\User','idAutor');

    }

El método belongsTo() es una función Eloquent para crear relaciones entre tablas. Básicamente, la función necesita una variable requerida y una variable opcional. La primera variable (requerida) define el Modelo objetivo. La segunda variable opcional es definir la columna fuente de la tabla del modelo actual. Si no define la variable opcional, la clase Eloquent busca en la columna thetargetModelName_id de nombre de destino. En la tabla de publicaciones, almacenamos los ID de los autores en la columna_id_original, no en la columna denominada ID_usuario. Debido a esto, necesitamos definir una segunda variable opcional en la función. Con este método, podemos pasar nuestras publicaciones de blog y toda la información de sus autores al archivo de plantilla. Puede pensar en el método como una especie de método de unión SQL.

Cuando queremos utilizar estas funciones de relación en consultas, podemos llamarlas fácilmente de la siguiente manera:

Libro::with('Categoria')->with('Autor')->get();

Es fácil administrar los archivos de plantilla blade con menos variables. Ahora solo tenemos una variable para pasar el archivo de plantilla, que se combina con todos los datos necesarios. Por lo tanto, necesitamos el segundo archivo de plantilla para enumerar nuestras publicaciones de blog. Esta plantilla funcionará en la interfaz de nuestro blog.

Listado de Articulos

Laravel pasa datos al archivo de plantilla como una matriz. Entonces, necesitamos usar el ciclo para analizar los datos en el archivo de la plantilla. También podemos usar un bucle foreach en los archivos de plantilla. Entonces crea un archivo index.blade.php en la capeta de vistas que se encuentra en la ruta ruta resourses/views el nombre del archivo sera  index.blade.php. El código debería verse de la siguiente manera.

resourses/views/index.blade.php
<!doctype html>
<html lang="es">
<head>
<meta charset="utf-8" />
<title>Blog CesarGI</title>
</head>
<body>
<div>
<header>
<h1>
<a href="/">Mi Blog Cesar GI</a>
</h1>
<p>Bienvenidos a mi primer Blog</p>
</header>
<nav>
<ul>
<li><a href="/">INICIO</a></h4></li>
<li><a href="/admin">ADMIN</a></h4></li>
<li><a href="/logout">CERRAR SESION</a></h4></li>
</ul>
</nav>
<section id="principal">
<section id="contenido">
@foreach($articulos as $articulo)
<article>
<h2>{{$articulo->titulo}}</h2>
<p>{{$articulo->contenido}}</p>
<p>
<small>Posted by
<b>{{$articulo->Autor->name}}</b> at
<b>{{$articulo->created_at}}</b>
</small>
</p>
</article>
@endforeach
</section>
{{$articulos->links()}}
</section>
<!--FOOOTER-->
<footer>
<section id="seccion-footer">
<section >
<aside>
<h4>DERECHOS RESERVADOS PARA "CESAR GI" AUTOR DE <br>
<a href="http://www.codigojavalibre.com/">WWWW.CODIGOJAVALIBRE.COM</a></h4>
</aside>
</section>
</section>
</footer>
<!--FIN FOOOTER-->
</div>
</body>
</html>

Vamos a repasar el código. Hemos utilizado un bucle foreach dentro del archivo de plantilla para analizar todos los datos de los  artículos del blog. Además, vemos el uso combinado de datos de autor en el ciclo foreach. Como puede recordar, obtenemos la información del autor con el método belongsTo () en el lado del modelo. El análisis completo de datos relacionales se realiza dentro de una matriz, que se denomina nombre de función de relación. Por ejemplo, si tuviéramos una segunda función de relación, que se llama Categorías(), la consulta sería algo así como en el lado del controlador:

$libros = Libro::with('Autor')-> with('Categoria')->orderBy('id', 'DESC')->get();

El ciclo foreach se vería de la siguiente manera:


@foreach($libros as $libro)

<article>
<h2>{{$libro->titulo}}</h2>
<p>Autor: <b>{{$libro->Autor->name}}</b></p>
<p>Categoria: <b>{{$libro->Categoria->name}}</b></p>
</article>

@endforeach


Paginar el contenido

El método get () de Eloquent, que hemos utilizado en el lado del controlador en la consulta Eloquent, recupera todos los datos de la base de datos con una condición dada. A menudo necesitamos paginar el contenido para una interfaz fácil de usar y tener menos cargas de páginas y optimizaciones. La clase Eloquent tiene un método útil para hacer esto rápidamente, que se llama paginate(). Este método obtiene los datos paginados y genera enlaces de paginación en la plantilla con solo una línea de código. Abra el archivo app/controllers/ArticuloController.php y cambie la consulta de la siguiente manera:


$articulos = Articulo::with('Autor')-> orderBy('id', 'DESC')->paginate(5);

El método paginate() pagina los datos con el valor numérico dado. Por lo tanto, en cada paginación apareceran 5 publicaciones de artículos. También tenemos que cambiar nuestra plantilla para mostrar enlaces de paginación. Abra app/views/index.blade.php y agregue el siguiente código después del bucle foreach:

{{$articulos->links()}}

La sección en la plantilla, que tiene el ID como "principal", debería verse de la siguiente manera:


<section id="principal">
<section id="contenido">
@foreach($articulos as $articulo)
<article>
<h2>{{$articulo->titulo}}</h2>
<p>{{$articulo->contenido}}</p>
<p>
<small>Posted by
<b>{{$articulo->Autor->name}}</b> at
<b>{{$articulo->created_at}}</b>
</small>
</p>
</article>
@endforeach
</section>
{{$articulos->links()}}
</section>

La función links () generará enlaces de paginación automáticamente, si hay suficientes datos para paginar. De lo contrario, la función no muestra nada.

Terminando


En este tutorial, hemos creado un blog simple con las funciones incorporadas de Laravel y el controlador de base de datos Eloquent. Hemos aprendido cómo paginar los datos y el mecanismo de relación de datos básicos de Eloquent. También hemos cubierto el mecanismo de autenticación integrado de Laravel. En los siguientes capítulos, aprenderemos cómo trabajar con tablas más complejas y datos relacionales.


Y listo tendría su blog básico, para iniciar sesión usamos el usuario que creamos en la migracion:
Emal: admin@gmail.com
Password: admin

Espero les guste y seguiré avanzando este blog hecho en Laravel.

Indice del mini curso



Category: articles


Crea Un Blog Personal Con Laravel 5.6

Creando un área solo para miembros

Como saben, nuestro sistema de blog está basado en miembros. Por eso, necesitamos que algunas áreas solo sean accesibles por miembros, para agregar nuevas publicaciones al blog. Tenemos dos métodos diferentes para hacer esto. El primero es el método de filtro de ruta, que elaboraremos en los próximos capítulos. El segundo es la verificación de autorización basada en plantilla. Este método es una forma más efectiva de entender el uso de la clase Auth con el sistema de plantillas Blade.

Con la clase Auth podemos verificar el estado de autorización de un visitante con solo una línea de código:

Auth::check();

La función check(), que se basa en la clase Auth, siempre devuelve verdadero o falso. Entonces, eso significa que podemos usar fácilmente la función en una declaración if/else en nuestro código. Como sabrá en capítulos anteriores, con el sistema de plantillas blade pudimos usar ese tipo de declaración PHP en los archivos de plantilla.

Antes de crear los archivos de plantilla, necesitamos escribir nuestras rutas. Necesitamos cuatro rutas para nuestra aplicación. Estos son:

  • Una ruta de inicio de sesión para procesar las solicitudes de inicio de sesión.
  • Una nueva ruta de publicación para procesar nuevas solicitudes de publicaciones
  • Una ruta de administrador para mostrar un nuevo formulario de publicación y un formulario de inicio de sesión
  • Una ruta de índice para publicar publicaciones.
El enrutamiento con nombre es otra característica sorprendente del marco de Laravel para un desarrollo rápido. Las rutas con nombre permiten hacer referencia a las rutas al generar redirecciones o URL de manera más cómoda. Puede especificar un nombre para una ruta de la siguiente manera:


Route::get('todos/articulos', function () {
    //
})->name('articulos');


También puede especificar nombres de ruta para los controladores:


Route::get('todos/articulos', 'ArticulosController@showArticulos')->name('todosarticulos');


Gracias a las rutas nombradas, podemos crear fácilmente URLs para nuestra aplicación:


<?php

//URLS DE NUESTRA APLICACION
Route::get('/', 'ArticuloController@getIndex')->name('index');
Route::get('/admin', 'ArticuloController@getAdmin')->name('area_admin');
Route::post('/add', 'ArticuloController@crearArticulo')->name('crear_nuevo_articulo');
Route::post('/login', 'UserController@postLogin')->name('login');
Route::get('/logout', 'UserController@getLogout')->name('logout');


Ahora necesitamos escribir el código para el controlador y las plantillas de nuestra aplicación. Primero, podemos comenzar a codificar desde nuestra área de administración. Vamos a crear un archivo en resources/views/ con el nombre agregarArticulo.blade.php. Nuestra plantilla de administrador debe ser similar a la siguiente:

agregarUnaVista-laravel



<html>

<head>
    <title>Mi Primer Blog</title>
    <link rel="stylesheet" type="text/css" href="/assets/css/style.css">
    
</head>

<body>
    @if(Auth::check())
    <section>
        <div >
            <h1>Bienvenidos al area de Administracion, {{Auth::user()->name}} 
            </h1>
            <form name="crearArticulo" method="POST" action="{{URL::route('crear_nuevo_articulo')}}">
                {{ csrf_field() }}
                <p>
                    <input type="text" name="titulo" placeholder="Titulo del articulo" value="" />
                </p>
                <p>
                    <textarea name="contenido" placeholder="Contenido del articulo"></textarea>
                </p>
                <p>
                    <input type="submit" name="submit" />
                </p>
            </form>
        </div>
    </section>
    @else
    <section>
        <div class="login">
            <h1>Login</h1>
            <form name="login" method="POST" action="{{URL::route('login')}}">
                {{ csrf_field() }}
                <p>
                    <input type="text" name="email" value="" placeholder="Email">
                </p>
                <p>
                    <input type="password" name="password" value="" placeholder="Password">
                </p>
                <p class="submit">
                    <input type="submit" name="commit" value="Login">
                </p>
            </form>
        </div>
    </section>
    @endif
</body>

</html>



Como puede ver en el código, usamos if/else  para verificar las credenciales de inicio de sesión de un usuario. Sabemos desde el comienzo de esta sección que usamos la función Auth::check() para verificar el estado de inicio de sesión de un usuario. Además, hemos utilizado un nuevo método para obtener el nombre del usuario que ha iniciado sesión actualmente:

Auth::user()->name;

Podemos obtener cualquier información sobre el usuario actual con el método user:

Auth::user()->id; 
Auth::user()->email;

El código de la plantilla primero verifica el estado de inicio de sesión del visitante. Si el visitante se ha conectado, la plantilla muestra un nuevo formulario de publicación; de lo contrario, muestra un formulario de inicio de sesión.

Ahora tenemos que codificar el lado del controlador de nuestra aplicación de blog. Comencemos desde nuestro controlador de usuario. Crea un archivo en la carpeta app/controller/, que se nombre UserContoller.php (Podemos usar artisan para crear el controlador, como la imagen siguiente). El código final del controlador debe ser el siguiente:

crear controlador usuario para el blog laravel


<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Input;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Redirect;
use App\User;
class UserController extends Controller
{
//
public function postLogin()
{
Auth::attempt(array('email' => Input::get('email'),'password' => Input::get('password')));
return redirect()->route('area_admin');
}
public function getLogout()
{
Auth::logout();
return Redirect::route('index');
}
}

El controlador tiene dos funciones: la primera es la función postLogin(). Esta función básicamente verifica los datos del formulario publicado para el inicio de sesión del usuario y luego redirige al visitante a la ruta crear_nuevo_articulo para mostrar el nuevo formulario de publicación. La segunda función procesa la solicitud de desconexión y redirige a la ruta index.


Indice del mini curso



Category: articles


Creación de un Blog Personal Con Laravel 5.6

Para definir nuestras columnas y especificaciones de tabla, necesitamos editar este archivo. Después de editar el archivo de migración, debería verse así:








<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateArticulosTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('articulos', function (Blueprint $table) {
            $table->increments('id');
            $table->string('titulo');
            $table->text('contenido');
            $table->integer('idAutor');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('articulos');
    }
}

Después de guardar el archivo, necesitamos usar un comando artisan simple para ejecutar migraciones:

php artisan migrate

Si no ocurre ningún error, verifique la  base de datos blog y la tabla artículos.

Modelo Articulo

Como usted sabe, para cualquier cosa relacionada con las operaciones de bases de datos en Laravel, el uso de modelos es la mejor práctica. Nos beneficiaremos del ORM Eloquent.

Abra nuestro archivo app/Articulos.php y agregue el siguiente código.


<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Articulo extends Model
{
    protected $table = 'articulos';

    protected $fillable = [
        'titulo',
        'contenido',
        'idAutor'
    ];

    public $timestamps = true;

    public function Autor(){

        return $this->belongsTo('App\User','idAutor');
    }



}

Hemos establecido el nombre de la tabla de la base de datos con la variable protegida $table. También hemos establecido columnas editables con la variable $fillable y las marcas de tiempo con la variable $timestamps , como ya hemos visto y utilizado en los capítulos anteriores. Las variables que se definen en el modelo son suficientes para usar el ORM elocuente de Laravel. Cubriremos la función pública Autor()  y explicaremos la utilidad de esta función en los siguientes capitulos.

Nuestro modelo de publicaciones está listo. Ahora necesitamos un modelo de autores y una base de datos para asignar publicaciones de blog a los autores. Investiguemos el mecanismo de autenticación incorporado de Laravel.

Agregar un usuario

Ahora necesitamos crear un nuevo archivo de migración para agregar algunos autores a la base de datos. Podemos hacerlo ejecutando el siguiente comando:

php artisan make:migration crear_algunos_users

Abra el archivo de migración y edite la función  up() de la siguiente manera:


<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;
use App\User;

class CrearAlgunosUsers extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        //
        User::create(array(
            'email' => 'admin@gmail.com',
            'password' => Hash::make('admin'),
            'name' => 'Cesar GI'
        ));
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        //
    }
}


Usamos una nueva clase en la función up(), que lleva el nombre Hash. Laravel tiene una clase de comprobador/fabricante de hash, que se basa en seguro Bcrypt. Bcrypt es un método de hashing aceptado y seguro para datos importantes como contraseñas.

Para ejecutar la migración y crear el usuario ejecute el comando artisan.

php artisan migrate

Ahora, revisa la tabla users para ver el registro. En la columna password peras el cifrado.

Es muy importante almacenar de forma segura las contraseñas de sus usuarios y sus datos críticos.



Indice del mini curso



Category: articles


Creación de un Blog Personal Con Laravel 5.6

1. Crear y migrar la base de datos de publicaciones

Suponemos que ya ha definido las credenciales de la base de datos en el archivo app/config/database.php . Para esta aplicación, necesitamos una base de datos. Simplemente puede crear y ejecutar el siguiente comando SQL o, básicamente, puede usar la interfaz de administración de la base de datos, algo así como phpMyAdmin:

Yo he usado una base de datos MySQL con el nombre de blog, como en la siguiente imagen:


Crear y migrar la base de datos de publicaciones

Una vez creada la base de datos, vamos a configurar el archivo .env donde indicaremos la conexion, el nombre de la base de datos, el user y el password como en la siguiente imagen. (En mi caso no tengo contraseña así que la dejo en blanco).

Crear un blog personal con Laravel


Después de crear con éxito la base de datos para la aplicación, primero debemos crear una tabla de publicaciones e instalarla en la base de datos. Para hacer esto, abra su terminal, navegue la raiz de su proyecto y ejecute este comando artisan:

php artisan make:model Articulo -m

Este comando generará un archivo modelo app/Articulo.php y otro archivo de migración en la carpeta app/database/migrations que servirá para crear la tabla posts en nuestra base de datos llamada blog.

Indice del mini curso



Category: articles

jueves, 27 de julio de 2017

El archivo .env de Laravel está incluido en el uso, por lo que es fácil tener una configuración diferente basada en el entorno en el que se ejecuta la aplicación. Esto le da la flexibilidad de tener diferentes variables para locales, la puesta en escena, la producción, e incluso diferentes máquinas de los desarrolladores.


Uso de variables en su archivo .env


Normalmente, estos archivos son pequeños y manejables, pero hay momentos en los que se encuentra con situaciones en las que se duplican los mismos datos dentro del archivo. Aquí hay un ejemplo:


MAIL_USERNAME=cesar@codigojavalibre.com
MAIL_FROM_ADDRESS=cesar@codigojavalibredos.com

El paquete dotenv en el que Laravel se basa puede utilizar variables con otras variables definidas en este mismo archivo. Por ejemplo:


MAIL_USERNAME=cesar@codigojavalibredos.com
MAIL_FROM_ADDRESS=${MAIL_USERNAME}

Este truco simple le permite no repetir y puede ser útil cuando usted tiene servicios múltiples que requieren la misma pieza de datos.

Espero que les sirva :)

Category: articles

jueves, 20 de julio de 2017


A veces, necesitará procesar miles y miles de registros. Usted sabe que esas operaciones son muy pesadas para su RAM, pero Eloquent tiene un método útil para fragmentar los resultados de la consulta en bloques para optimizar su carga.





Apphouse::chunk(200, function($bloque)
  {
      foreach ($bloques as $bloque)
      {
          // Operaciones pesadas por bloques aquí...
      }
  });



El primer parámetro define el tamaño del bloque que desea utilizar. En este caso, vamos a cargar 200 resultados, procesarlos, descargarlos, y repetir lo mismo con los próximos 200.

El segundo parámetro es un cierre que define qué hacer con ese fragmento: el parámetro bloque de cierre es la colección devuelta de los registros.
Category: articles

martes, 18 de julio de 2017


En este articulo, les enseñare cómo comprobar si un archivo existe o no en el directorio dado y si existe un archivo, elimine el archivo del directorio.

Cuando va a trabajar en el sistema de archivos y necesita actualizar los datos, incluidos los archivos, entonces tendrá que eliminar los archivos existentes y luego subir el nuevo.

Así que antes de ir a eliminar los archivos existentes, tendrá que asegurarse de que los archivos existen; utilizando el file_exists() sabremos si el archivo existe, de lo contrario puede obtener el siguiente error:

php - Warning: unlink(Image): No such file or directory 
(Php - Advertencia: unlink (Image): Ningún archivo o directorio)

En PHP, se utiliza el método file_exists() para comprobar si el archivo existe o no y si el archivo existe entonces se utiliza la función unlink() para eliminar archivos.



Ejemplo 1 para borrar un archivo en Laravel 



if(file_exists(public_path('images/mi-archivo.jpeg'))){
  unlink(public_path('images/mi-archivo.jpeg'));
}else{
  dd('El archivo no existe.');
}

Ejemplo 2 para eliminar un archivo en Laravel

Ahora borraremos un archivo utilizando el método de  Laravel File::delete().


<?php

if(\File::exists(public_path('images/mi-archivo.jpeg'))){
  \File::delete(public_path('images/mi-archivo.jpeg'));
}else{
  dd('El archivo no existe.');
}

Puede eliminar los archivos múltiples de la siguiente manera:


<?php

\File::delete($file1,$file2);


Y eso seria todo espero que les guste :)

Category: articles

viernes, 14 de julio de 2017


En este tutorial, le haré saber cómo escribir subquery dentro de la instrucción select en Laravel 5. Laravel permite a los usuarios escribir una consulta sin usar el DB::raw() método.

Caso de uso de una sub consulta en Laravel

En algún momento necesitamos desarrollar la aplicación donde necesitamos obtener detalles de usuario con sus seguidores como la aplicación "Instagram".

Laravel 5.4

En la aplicación Instagram al visitar el perfil de usuario, verá el número total de publicaciones, sus seguidores y la cuenta siguiente.

En este escenario, podemos escribir una función mysql o usar subconsulta en la instrucción select.

Para este ejemplo, tendré dos tablas users y user_followers .

Supongamos que la tabla de users tiene campos id, name, email y la tabla user_followers tiene id, user_id, follower_id.

Primero utilizaré la consulta en bruto de MySQL para obtener detalles de la siguiente manera:


SELECT 
 users.*, 
 (SELECT count(*) FROM user_followers
   WHERE user_followers.user_id = users.id
  ) as total_followers
FROM `users``

Laravel Query Builder (Generador de consultas)

Ahora escribiré la consulta en Laravel para lograr la misma funcionalidad.


  $datos = \DB::table("users")
          ->select("users.*",
                  \DB::raw("(SELECT count(*) FROM user_followers
                          WHERE user_followers.user_id = users.id
                        ) as total_followers"))
          ->get();
  dd($datos);    

Puede escribir la subconsulta con instrucción join.



Category: articles

jueves, 13 de julio de 2017



Almacenamiento de relaciones en variables

Trate de reducir las llamadas de relación tanto como sea posible.

Supongamos que $ user-> posts; Se llama cinco veces en el código. Esto resultará en un número masivo de llamadas innecesarias a la base de datos y, en consecuencia, ralentizará la aplicación. La forma correcta de tratar con ella es almacenar el resultado de esta llamada en una variable como $ posts = $ user-> posts; Y luego usar $ posts en el código.

Mejores practicas en laravel ¡Optimice el desarrollo!

Mantenga su ruta limpia

Asegúrese siempre de no sobrecargar su archivo route.php . Evite escribir cierres en el archivo route.php . En su lugar, cree un controlador independiente para ello.

Elija la base de datos correcta

Eloquent soporta múltiples bases de datos, y por lo tanto no hay necesidad de limitarse a MySQL solamente. Utilice MongoDB para registros que tengan atributos altamente variables. Utilice ElasticSearch para buscar e indexar datos de gran volumen. Utilice Neo4J para aplicaciones que requieran una relación compleja entre modelos. Elegir la base de datos correcta es una práctica recomendada muy importante para sus aplicaciones.

Configuración

La mejor práctica es asegurarse de que su clave de aplicación está establecida. Esta es la variable APP_KEY en su archivo .env. Puede usar el siguiente comando:

php artisan key:generate

Siempre dé a su aplicación un nombre. Es decir, en lugar de usar el espacio de nombres de la raíz de la aplicación predeterminada dado por la instalación de Laravel, establézcalo en el contenido de la aplicación. Esto se puede configurar mediante el siguiente comando:

php artisan app:name ElNombreDeLaAplicacion

Esto hace que sus controladores, modelos, etc., se renombren  en ElNombreDeLaAplicacion\ Controllers y ElNombreDeLaAplicacion\ Models.


Category: articles

miércoles, 12 de julio de 2017

Ver la primera parte de Mejores practicas en Laravel

Mejores practicas en laravel

Eloquent ORM

El ORM de Eloquent es una característica de Laravel que proporciona una implementación ActiveRecord elegante para trabajar con su base de datos. La mejor práctica para trabajar correctamente con el ORM de Eloquent es cuidar la convención de nomenclatura de su modelo.

En el ORM Eloquente, cada tabla de base de datos tiene un modelo. Estos modelos se utilizan para interactuar con la base de datos y realizar diversas operaciones.

Ejemplo:

Considere un modelo con el nombre Productos.php


<?php
namespace App;
use Illuminate\Database\Eloquent\Model;

class Productos extends Model
{
       protected $table = 'productos';
       protected $connection = 'connection-name';
       protected timestamps = false;
}

El Modelo Eloquent usa el nombre plural de la clase como el nombre de la tabla. Por lo tanto, el nombre de la tabla será los productos. Eloquent también espera que la columna created_at y updated_at exista en la tabla. Si desea manejarlo por su cuenta, defina la propiedad $ timestamps como false.

Uso de carga automática:

En Laravel, puedes usar cualquier clase o incluso código PHP, siempre y cuando se pueda cargar automáticamente. Esto mejora el rendimiento de los scripts, evitando que PHP verifique si el archivo ya se ha cargado o no. Además, no necesita incluir el archivo cada vez que lo necesite en su código. PHP le informará si es necesario cuando se necesita.

Uso de las migraciones

Laravel Migrations es una característica maravillosa que proporciona control de versión para su base de datos. Permite a su equipo modificar y compartir fácilmente el esquema de la base de datos de la aplicación. Las migraciones suelen ser emparejadas con el constructor de esquema de Laravel para crear fácilmente el esquema de la base de datos de su aplicación.

Siempre use Laravel Migrations para crear base de datos en lugar de hacerlo manualmente. Esto reducirá considerablemente su carga de trabajo.

Evitar Accesores, Mutadores y Query Scopes

El rendimiento de cualquier aplicación de Laravel depende más del código que el motor. Es importante evitar la naturaleza dinámica del código cuando sea posible para optimizar el rendimiento del compilador.


<?php
function agregar($numero)

{

$x = 3;

$y = $x + 27;

return $y + $numero;

}

agregar($z);

agregar(28);

agregar(“Hola”);

Los accesores, los mutadores y los Query Scopes hacen un montón de cosas dinámicas que pueden engañar al compilador e impedir que se optimicen. Cuanto más dinámico es el código, más lento se ejecutará.




Category: articles

martes, 11 de julio de 2017

Laravel es un moderno framework de desarrollo de PHP que proporciona toda una serie de características y soluciones de terceros requeridas para la creación de aplicaciones web modernas, sostenibles y en tiempo real distribuidas. Dado todo esto, Laravel se está convirtiendo mas popular después del lanzamiento de PHP7 debido a los benchmarks de alto rendimiento.

Mejores practicas en laravel


Este artículo pretendo mostrar algunas buenas prácticas para el desarrollo en Laravel que son esenciales para racionalizar el proceso de desarrollo y garantizar la alta calidad del producto final.

Usar la última versión estable

Aunque la versión de Laravel 5.5 está a la vuelta de la esquina, la mejor práctica recomendada es utilizar siempre la última versión estable para el desarrollo de su aplicación. Por el momento, Laravel 5.4 es la última versión estable disponible.

Siga las normas

Cada marco tiene sus propios estándares internos de desarrollo de código. Lo bueno es que Laravel no te restringe a estas normas, siempre y cuando tus variables sean compatibles con el compositor. Sin embargo, los expertos recomiendan que usted debe seguir los estándares de codificación PSR-2 y PSR-4 .

Interfaz de línea de comandos Artisan

Laravel tiene su propia interfaz de línea de comandos conocida como Artisan. Utiliza el componente Symfony Console como base. Proporciona varios comandos útiles para acelerar el proceso de desarrollo de aplicaciones. Aquí la mejor práctica es utilizar siempre Artisan CLI ya que aumenta la productividad del proceso de desarrollo.

Los comandos Artisan también son útiles en la tarea de planificación de tareas y activan acciones en la ocurrencia de un evento. Por ejemplo, puede disparar un comando Artisan desde una ruta HTTP usando la fachada de Artisan:


Route::get('/foo', function()
{
   $exitCode = Artisan::call('command:name', ['--option' => 'foo']);
 
   //
});

A continuación se presentan varios comandos artesanos que aceleran el proceso de desarrollo de aplicaciones de Laravel:

php artisan config:cache

Este comando almacena en caché la configuración de la fase de carga bootstrap. Ayuda a limitar la petición de IO. Debe volver a ejecutar cada vez que cambie o agregue algo en el directorio de configuración. Este comando suele ser útil si tiene muchos archivos de configuración o paquetes.

php artisan route:cache

Este comando hace lo mismo pero para las rutas. Ayuda a reducir el tiempo requerido para el cálculo de rutas. Este comando debe volver a ejecutarse después de cambiar las rutas. Además, tenga en cuenta que no puede utilizar este comando si tiene rutas de cierre.

php artisan optimize

Este comando optimiza el autoloader y compila todas sus vistas

Depuración

Laravel viene con su propio componente de depuración. Sin embargo, es una buena práctica utilizar paquetes de depuración como Laravel Debugbar, ya que le proporcionan toneladas de buena información para optimizar su aplicación mediante la inclusión de un ServiceProvider para registrar la debugbar y adjuntarla a la salida.

También puede utilizar la herramienta de pruebas y depuración como Laravel Dusk , una herramienta de prueba de automatización de explorador perfecta para aplicaciones de pruebas de navegador y API. Utiliza ChromeDriver de forma predeterminada pero puede utilizar cualquier controlador compatible con Selenium.

Gestión de la Dependencia

Laravel se basa en los diversos paquetes de frameworks y bibliotecas. Por defecto. Estos paquetes están disponibles en las bibliotecas de Composer. La mejor práctica, en este caso, es crear su propia biblioteca Composer para cada conjunto específico de clases de aplicación, siguiendo los pasos siguientes:


  1. Pon tu biblioteca en GitHub.
  2. Dé a su biblioteca un archivo composer.json
  3. Registro con Packagist

Usted puede agregar fácilmente bibliotecas personalizadas en el paquete que será útil para optimizar su aplicación.



Category: articles

viernes, 9 de junio de 2017



Crear un scroll infinito en Laravel

En este tutorial, te voy a enseñar cómo auto cargar más datos en la página con el desplazamiento utilizando jQuery y PHP Laravel.

No es necesario hacer clic en ningún lugar para cargar mas datos; porque los datos se están cargando en la página automáticamente al ir bajando.

Hay tantos sitios web que utilizan la misma lógica para cargar datos en la página de desplazamiento, esto es muy útil para varios casos.

Comprueba si la longitud de los datos es igual a 0 y luego muestra el mensaje "No más registros!" Y si la longitud de los datos es más de 0 entonces agrega los datos del html a la lista.

Aquí está un paso simple para dejarle saber sobre la carga de datos automáticamente en la página de desplazamiento de arriba a abajo con jQuery y PHP.



Creamos nuestro modelo Producto:

ruta: app/Producto.php

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Producto extends Model
{
    public $fillable=['nombre','descripcion'];
}


Agregamos la siguiente ruta:

routes/web.php

Route::get('cargar-mas-datos',[
    'as'=>'cargar-mas-datos','uses'=>'ProductoController@cargarMasDatos'
]);


En este paso, crearemos un controlador ProductoController con un método cargarMasDatos.

app/Http/Controllers/ProductoController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use App\Producto;

class ProductoController extends Controller
{
    


    public function cargarMasDatos(Request $request){
        $productos=Producto::paginate(5);
        $html='';
        foreach ($productos as $model) {
            $html.='<li>'.$model->id.' <h2>'.$model->nombre.'</h2> : '.$model->descripcion.'</li>';
        }
        if ($request->ajax()) {
            return $html;
        }
        return view('productos',compact('productos'));
    }
}

Creamos nuestra vista productos.blade.php:

resources/views/productos.blade.php

<!DOCTYPE html>
<html>
<head>
    <title>Creacion de scroll infinito con Laravel y jquery</title>
    <link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
</head>
<head>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Auto cargar datos</title>

    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" type="text/css" media="all"
    />
    <style>
        .wrapper>ul#results li {
            margin-bottom: 2px;
            background: #f9f9f9;
            padding: 40px;
            list-style: none;
        }

        .cargar-mas-datos {
            text-align: center;
        }
    </style>

</head>

<body>


    <div>
        <br/>
        <br/>

        <div class="text-center">
            <h1 class="post-title">Auto cargar datos a lo que bajas en Laravel - scroll infinito </h1>
        </div>
        <hr>


        <div class="container">


            <div class="row">

                <div class="col-md-8 col-md-offset-2">
                    <div class="wrapper">
                        <ul id="results">
                            <!-- los resultados aparecen aquí -->
                        </ul>
                        <div class="cargar-mas-datos"><img src="{{asset('img/loading.gif')}}" /></div>
                    </div>
                </div>
            </div>
        </div>



    </div>

    <hr/>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
    <script type="text/javascript" src="http://www.expertphp.in/js/bootstrap.js "></script>
    <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js"></script>


    <script>
        var page = 1; //Pista usuario desplazarse como número de página, ahora el número de página es 1
        cargamosMasDatos(page); // carga de contenido inicial

        $(window).scroll(function () { // detecta desplazamiento de página
            if ($(window).scrollTop() + $(window).height() >= $(document).height()) { // si el usuario se desplazó hasta la parte inferior de la página
                page++; //Incremento del número de página
                cargamosMasDatos(page); //carga contenido  
            }
        });

        function cargamosMasDatos(page) {
            $.ajax(
                {
                    url: '?page=' + page,
                    type: "get",
                    datatype: "html",
                    beforeSend: function () {
                        $('.cargar-mas-datos').show();
                    }
                })
                .done(function (data) {
                    if (data.length == 0) {
                        console.log(data.length);

                        // notificar al usuario que ya no hay nada mas que cargar
                        $('.cargar-mas-datos').html("¡No hay más registros!");
                        return;
                    }

                    $('.cargar-mas-datos').hide(); // ocultar la carga de la animación una vez que se reciben los datos
                    $("#results").append(data); // agrega datos al elemento #results


                })
                .fail(function (jqXHR, ajaxOptions, thrownError) {
                    alert('No hay respuesta del servidor');
                });
        }
    </script>
</body>

</html>




Inicia a largar los datos

Carga los datos
Cargando mas datos al desplazarme hacia abajo
Cuando no haya mas datos que mostrar





Y eso seria todo :) estero que les guste.
Category: articles