mi lado nerd: febrero 2018

symfony3 crear entity por consola - crear CRUD

php bin/console doctrine:generate:entity --entity AppBundle:Producto -n

-n : sin interaccion

el comando anterior crea:

AppBundle/Entity/Producto.php (con el atributo id)
AppBundle/Repository/ProductoRepository.php (al que hace referencia la entity Producto)

antes debemos crear un formulario asociado a la entity Producto

php bin/console generate:doctrine:form AppBundle:Producto

(de lo contrario doctrine:crud crea uno pero vacio...y hay que completarlo manualmente)

luego, para crear un CRUD de esa entidad

php bin/console generate:doctrine:crud

(la forma interactiva)
la no interactiva php bin/console generate:doctrine:crud AppBundle:Producto -n --format=annotation --with-write
no estaria andando)

AppBundle:Producto

recordar de darle yes en la opcion: with-write , esto creara los actions correspondientes a new/create/edit/update y delete

te crea el controller, el formulario (vacio..mejor crearlo antes) y las vistas( simples, sin ningun estilo).

symfony3 bundle migrations

para la version 3.0.3

descargarlo asi:

composer require doctrine/doctrine-migrations-bundle "^1.0"

shotdown el server built-in antes de descargar el bundle de lo contrario nos dara error VirtualAlloc

php.ini saber el memory_limit actual

php -r "echo ini_get('memory_limit').PHP_EOL;"

symfony3 formularios - validaciones personalizadas

Se puede crear nuestras propias constraints
siguiendo el esquema de las que existen:
por ejemplo para la constraint NotBlank (clase annotation) existe una clase NotBlankValidator que implementa la validacion.
Ambas clases se encuentran en la misma carpeta vendor/Symfony/Validator/Contraints

entonces,
para crear una constraint que permita alfanumericos con espacios, creamos la carpeta

src/AppBundle/Validator/Constraints

y ahi creamos la clase llamada por ejemplo ContainsAlphanumericWithSpaces y ContainsAlphanumericWithSpacesValidator

donde
/**
* @Annotation
*/
class ContainsAlphanumericWithSpace extends Constraint{
public $message = 'The string "%string%" contains an illegal character: it can only contain letters, numbers or spaces.';

}

class ContainsAlphanumericWithSpaceValidator extends ConstraintValidator
{
public function validate($value, Constraint $constraint)
{
if (!preg_match('/^[a-zA-Z0-9\s]+$/', $value, $matches)) {
$this->context->buildViolation($constraint->message)
->setParameter('%string%', $value)
->addViolation();
}
}

symfony3 formularios - validaciones

las validaciones de formulario se hacen en la clase

use Symfony\Component\Validator\Constraints as Assert;

class Contacto {

/**
* @Assert\NotBlank(message = "El campo no debe ser vacío.")
* @Assert\Length(min=4, minMessage = "Debe contener al menos '{{ limit }}' caracteres.")
* @Assert\Type(
* type="alnum",message="el nombre debe contener caracteres alfanumericos"
* )
*/
private $nombre;

/**
* @Assert\NotBlank(message = "El campo no debe ser vacío.")
* @Assert\Email(
* message = "El campo '{{ value }}' debe ser una dirección de correo válida."
* )
*/
private $email;

symfony3 formularios

debemos tener:
una clase -> que representa los datos a mapear en el formulario
src/AppBundle/Model/Entity/Contacto.php
una clase formulario -> en donde se mapean los campos de la clase src/AppBundle/Form/ContactoType.php

Si tenemos en Contacto.php los campos nombre y email,

en ContactoType (extends AbstractType) deberiamos tener algo asi:

public function buildForm(FormBuilderInterface $builder, array $options) {
$builder
->add('nombre', TextType::class, array(
'required' => false
))
->add('email', EmailType::class, array(
'required' => false
))
->add('save', SubmitType::class, array('label' => 'Enviar'))
;
}
nota: al indicar que el campo email es del tipo EmailType le agregamos una validacion html5 al campo en tiempo real, antes de enviar los datos.

Para hacer uso de este formulario desde el controller:

class ContactoController extends Controller {

/**
* @Route("/contacto", name="contacto.index")
*/
public function indexAction() {
$contacto = new Contacto();

$form = $this->createForm(ContactoType::class, $contacto);

return $this->render('contacto/form.html.twig', [
'form' => $form->createView(),
]);
}

para mostrar el formulario en la vista:

{{ form_start(form, {'action': path('contacto.guardar')}) }}
<div class="form-group {% if not form.nombre.vars.valid %}has-error{% endif %}">
{{ form_label(form.nombre, null, {'label_attr': {'class': 'col-sm-2 control-label'}}) }}
<div class="col-sm-5">
{{ form_widget(form.nombre, {'attr': {'class': 'form-control'}}) }}
</div>
<div style="color: red">{{ form_errors(form.nombre) }}</div>
</div>
<div class="form-group">
<div class="col-sm-offset-2 col-sm-5">
{{ form_widget(form.save, {'attr': {'class': 'btn btn-primary', 'role': 'button'}}) }}
</div>
</div>
{{ form_end(form) }}

en el Controller para manipular los datos del formulario (para guardarlos por ejemplo o mostrarlos)

/**
* @Route("/contacto/guardar", name="contacto.guardar")
*/
public function guardarAction(Request $request) {
$contacto = new Contacto();
$form = $this->createForm(ContactoType::class, $contacto);

$form->handleRequest($request);

if ($form->isValid()) {
// success!
return $this->render('contacto/ok.html.twig', [
'form' => $form->createView(),
'contacto' => $contacto,
'titulo' => 'Sus datos enviado son los siguientes:',]);
} else {
// failure!
$this->addFlash('error', 'Hay errores en el formulario, favor revisar los datos!');
return $this->render('contacto/form.html.twig', [
'form' => $form->createView(),
'titulo' => 'Formulario con Errores',]);
}
}

nota: como los datos ya estan en 'contacto' si se quiere mostrar los datos enviados correctamente, se debe mandar como parametro este objeto:

<tr>

<td>{{ form_label(form.nombre) }}</td>

<td>{{ contacto.nombre }}</td>

</tr>

symfony server interno

symfony 3.0

la web se accedera en http://127.0.0.1:8000/ o en http://localhost:8000/

php bin/console server:start

symfony version

por consola:

php bin/console -version

y si queremos imprimirlo en pantalla, a traves de una pagina twig:

<h1><span>Welcome to</span> Symfony {{ constant('Symfony\\Component\\HttpKernel\\Kernel::VERSION') }}</h1>

laravel vue simple crud

crear el modelo, la migration y el controller resource

php artisan make:model Task -mr

ren ".env.example" ".env" (no olvidar renombrar este archivo)
php artisan key:generate (generar la key de la aplicacion)

setear los valores de la base de datos en .env

limpiar la cache del config:

php artisan config:cache

editar AppServiceProvider.php

use Illuminate\Support\Facades\Schema;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        //
         Schema::defaultStringLength(191);
    }

php artisan migrate

npm run watch

laravel mvc

fuente:

https://selftaughtcoders.com/from-idea-to-launch/lesson-17/laravel-5-mvc-application-in-10-minutes/

desde la carpeta de tu proyecto

crear el Modelo y su correspondiente archivo de migracion

php artisan make:model Car --migration

lo que crea el archivo app/Car.php (que se le conoce como un Resource)

editar el archivo de migration creado database/migrations/XXXXX_create_cars_table.php

Schema::create('cars', function (Blueprint $table) {
$table->increments('id');
$table->string('make');
$table->string('model');
$table->date('produced_on');
$table->timestamps();
});

ejecutar la migration

php artisan migrate

generar el controller de recourse

php artisan make:controller CarController --resource

lo que genera el archivo app/http/controllers/CarController.php

con 7 metodos de crud

asociar esos metodos con sus respectivas rutas.

ir a routes/web.php

agregar la siguiente linea

Route::resource('cars', 'CarController');

para verificar si las rutas se generaron

php artisan route:list

Request Type	Path	Action	Route Name
GET	`/cars`	`index`	cars.index
GET	`/cars/create`	`create`	cars.create
POST	`/cars`	`store`	cars.store
GET	`/cars/{car}`	`show`	cars.show
GET	`/cars/{car}/edit`	`edit`	cars.edit
PUT/PATCH	`/cars/{car}`	`update`	cars.update
DELETE	`/cars/{car}`	`destroy`	cars.destroy

en CarController.php

implementar el metodo show

public function show($id)
    {
      $car = Car::find($id);
      return view('cars.show', array('car' => $car));
    }

lalala

crear resources/views/cars/show.blade.php

<!DOCTYPE html>
<html>
  <head>
    <title>Car {{ $car->id }}</title>
  </head>
  <body>
    <h1>Car {{ $car->id }}</h1>
    <ul>
      <li>Make: {{ $car->make }}</li>
      <li>Model: {{ $car->model }}</li>
      <li>Produced on: {{ $car->produced_on }}</li>
    </ul>
  </body>
</html>

(para probar insertar a mano un registro en la tabla cars)

abrir la pagina asi:

http://localhost/mymvc/public/cars/1

laravel seteos iniciales para la creacion de una aplicacion

instalar laravel a nivel global composer global require "laravel/installer"
en htdocs crear nuestro proyecto laravel new mymvc
Directories within the storage and the bootstrap/cache directories should be writable by your web server or Laravel will not run.
generar el application key php artisan key:generate
renombrar el archivo .env.example por .env
en el archivo .env setear los valores de la conexion a BD

DB_CONNECTION=mysql

DB_HOST=127.0.0.1

DB_PORT=3306

DB_DATABASE=mymvcdatabase

DB_USERNAME=root

DB_PASSWORD=''

limpiar la cache de configuracion php artisan config:clear
para evitar el error Syntax error or access violation: 1071 Specified key was too long; max key length is 767 bytes ir al archivo AppServiceProvider.php y

editar la siguiente funcion:

public function boot() { Schema::defaultStringLength(191); }
agregar tambien use Illuminate\Support\Facades\Schema;

atom shortcuts

ctrl + p para buscar un archivo
ctrl + r para buscar un metodo dentro del archivo actual
ctrl + w cierra todas las pestañas
ctrl + shift + w cierra atom

firebase como deployar

notas:
- para que una app reciba notificaciones debe estar alojada en un servidor seguro https
- para pruebas Google acepta localhost como un servidor seguro
- desde un hosting seguro las llamadas a web services deben estar alojadas en hostings seguros

abrir una consola
logearte firebase login
ir a la carpeta de tu proyecto
firebase init
en la pregunta de What do you want to use as your public directory? colocar un punto . de ese modo toma todos los archivos de la carpeta en la que estamos.
firebase deploy

git readme comandos para formatear el texto

https://help.github.com/articles/basic-writing-and-formatting-syntax

mi lado nerd