DEV Community: Lam Hoang

Regex Cheat Sheet

Lam Hoang — Mon, 13 Jul 2020 02:58:07 +0000

Full Regex Cheat Sheet

Basics

/ expression / flags, i.e /[A-Z]+/g basic format
/ hello\?*\/ escape special characters with backslashes
() group with parentheses
| logical OR

Character classes

\w word \d digit \s whitespace (tabs, line breaks)
\W NOT word \D NOT digit \S NOT whitespace
\t tabs, \n line breaks
. any character (except newline)

Brackets

[xyz] match any x, y, z
[J-Z] match any capital letters between J & Z.
[^xyz] NOT x, y, z

Quantification

bob|alice match bob or alice
z? zero or one occurrences
z* zero or multiple occurrences
z+ one or multiple occurrences
z{n} n occurrences
z{min,max} min/max occurrences

Anchors

hello world exact match
^hello start of the strings
world$ end of the string

Laravel Cheat Sheet

Lam Hoang — Tue, 09 Jun 2020 09:32:27 +0000

Full version Laravel Cheat Sheet

Setup Laravel Environment

Chose running the Bitnami WAMP stack instead of using Homestead

Download Bitnami 5.6 WAMP stack
uncomment C:\Bitnami\wampstack-5.6.30-1\apache2\conf\bitnami\bitnami-apps-prefix.conf and uncomment Include "C:/Bitnami/wampstack-5.6.30-1/frameworks/laravel/conf/httpd-prefix.conf"
Restart the servers
add C:\Bitnami\wampstack-5.6.30-1\frameworks\laravel to your windows path
Run the bitnami bash shell by executing 'use_wampstack.bat' from the bitnami application root folder.
test your laravel installation by typing php artisan serve [--port=8000] . Will serve by default on port 8000.

Add the following to your path so you can use the laravel.bat
C:\Users\motero\AppData\Roaming\Composer\vendor\bin

Get the laravel installer using composer

composer global require "laravel/installer"

Once installed you can use the
laravel new command to create a fresh laravel installation in the directory you specify.

Creating a new project

Create a project: composer create-project myprojectname

If you get any errors when running php artisan serve
or any artisan commands then run:

composer update --no-scripts

You may also need to regenerate the ciphers for the project:

php artisan key:generate

from your project folder.

Alternative is Laravel Homestead, which comes with Nginx, PHP 5.6, MySQL, Redis, Memcached, and Beanstalk.

https://laravel.com/docs/4.2/homestead

Routes are in /config/web.php

views are in resources/views/myview.blade.php

Working with Databases

Consider using MariaDB versus MySQL

mysql -uroot -p
create database databasename;
use databasename;

show tables;

Setup your database connection information in the .env file.

From command line (inside the project folder):

php artisan migrate

php artisan make: These are your file generators

Prepare the Migration

// creates the migration stub and the database table as well.
// Creates a migration stub under the /project/database/migrations folder

artisan make:model create_database_name --create=tasks

modify database columns
You do this by modifying the file at /database/migrations/create_database_name

Migrate the database

php artisan migrate

php artisan help make:model [Artisan Help Feature]

when you make a mistake, delete the item from the database stub file, and refresh your migration.

php artisan migrate:refresh // rolls back and reruns the migrations

Fetching database records ###

in web.php routes

$tasks = DB::table('tasks')->get(); //Laravel Query Builder

from the view get the content from the database:
{{ $task->body }}

dd($id) // die and dump [get more info on this

  $task = DB::table('tasks')->find($id);
Route::get('/tasks/{task}', function ($id) {

Hyperlinking to dynamic ids

<li><a href="/tasks/{{ $task->id}}">{{ $task->body }}</a></li>

If you ever return a database result from a view, Laravel returns it as JSON.

Creating a new database table

Make a new Comment model, and make migration

php artisan make:model Comment -m

Edit the migrations file to add any additional fields.

If one to many relatioship the many takes the id of the one.

$table->integer('post_id');

Migrate the database

php artisan migrate

Add many relationship to Post model

class Post extends Model
{
    public function comments()
    {
      return $this->hasMany(Comment::class);
    }
}

Eloquent

A model is a representation of something in your system. It could be a noun.
It is Laravel's active record implementation. simplifies your interaction.

This creates /app/task.php

Errors:

The only supported ciphers are AES-128-CBC and AES-256-CBC with the correct key lengths.

php artisan key:generate

error related to not having a .env file. Renamed .env.example to .env then run

php artisan key:generate

You may need to add the composer.bat / composer.phar files to your PATH. The location is here: C:\ProgramData\ComposerSetup\bin

php artisan make:model Task -m // make model and a migration file

composer dump-autoload // in case you get an error message when creating the model and migration.

Blade Templating Language

Blade is laravel's templating language.

php artisan make:model task

Create a model with singular noun. php artisan make:model MyModel

Tinker

php artisan tinker // boots up Laravel's Shell

It allows you to replace the php directive with @

Using Controllers

The middleman. Receive a request and will ask a task or post model to get the data and then passes it to the view.

Controller Deletgates.
Model fetches data
View HTML

Route::get('/tasks', 'TasksController@index' ); //@index is the index method

Controllers are stored in /app/Http/Controllers

use a make controller generator to generate your controllers

php artisan make:controller TasksController

Variables and wildcards in route controllers should match.

registering routes ###

Routes are registered in /routes/web.php

Route::get('/', 'PostsController@index');
Route::get('/posts/{post}', 'PostsController@show'); // Corresponds to /posts/show.blade.php

controller lives in /app/http/controllers In this case postscontroller.php

Layouts

in resources/views

create layout.blade.php

@yield('content')

Assets

found in /resources/assets

/sass folder

use a build tool called webpack using Laravel's Mix configuration tool. It grabs the file in the resources/assets folder and compiles it for use in the /public folder.

They are node dependencies. You need to have Node and npm installed on your machine.

from your application folder run:

npm install

Pulls in packages found in your package.json file.

You can run the files based on your package.json scripts section.

npm run dev

Order of Things

IMPORTANT

// controller => PostsController
// php artisan make:controller PostsController

// eloquent Model => Post
// php artisan make:model Post

// migration => create_posts_table
// php artisan make:migration create_posts_table --create=posts
// You an do them all indivdiually as above, or you can have Laravel
// create the model and the migration when you create the controller.

// php artisan make:model Post -mc

// after running the above command go into the migrations file in
// /database/migrations and add the columns you need

            $table->increments('id'); // default
            $table->string('title'); // added this one
            $table->timestamps(); // default

[ Add information on the types of columns that you can create and examples for them]

Migrate the database:

php artisan migrate

go to your controller and add the required methods to link it back to the view, or get data from the model, etc..

class PostsController extends Controller
{
    //add methods
    public function index()
    {
      return view('posts.index')
    } 

}

Create your view file.
/resources/views/posts/index.blade.php

View can then extend the layout file:

@extends('layout')

@section('content')
<p>This is my content section, this is only a test.</p>
@endsection

test your creation: php artisan serve

Folder Structure

created a /layouts folder

Have these partials in the folder
master.blade.php
nav.blade.php
sidebar.blade.php
footer.blade.php

/posts/
index.blade.php {this is where the posts live}

index extends the master layout with

@extends('layouts.master')
@section('content') // starts all of the content pieces.

master.blade.php

links to the partials via:
@include ('layouts.nav')
@yeld('content')
@include ('footer.nav')
@include ('layouts.footer')

CSS and JS files can go in the /public folder and are referenced like this: /css/styles.css.

Working with Forms

  <form method="POST" action="/posts">

  GET /posts - view all of the posts
  GET /posts/create - create a post
  GET /posts/{id}/edit - edit a specific post 
  GET /posts/{id} - displays a single post specified by the ID in the URL
  PATCH /posts - send to database
  DELETE /posts/{id}

// @store is the method in the PostController
  Route::post('/posts', 'PostsController@store');

//creates a resourceful controller, a boilerplate with all of the types of responses.
artisan make:controller TasksController -r

CSRF - Cross Site Request Forgery

Laravel automatically generates a CSRF token for each active user session managed by the application. This token is used to verify that the authenticated users is the one actually making teh requests to the application.

Anytime you define an HTML form, you should include a hidden CSRF token field in the form so that the CSRF protection middleware can validate the request.

  {{ csrf_field() }}

Begin you class paths with \ so that you are at the root, and not inside the namespace (applies to controller pages)

or set use App\Post; at the top, and then create new Post;

Example of store method in PostController


public function store()
    {
      // dd(request()->all());
      // create a new post using the request database
      $post = new \App\Post;

      $post->title=request('title');
      $post->body=request('body');

      // save it to the database
      $post->save();

      // and redirect to the home page
      return redirect('/');
    }

An alternative to the above is to simply use:

    Post::create(request(['title', 'body']));

and it creates the object, and saves the request items to the database.

Form Validation

At the minimum use HTML 5 form validation

<input type="text" required>

Setup server side validation in controller (PostController)

$this->validate(request(), [
        'title' => 'required',
        'body' => 'required'

      ]);

and in the view spit out the errors which are added to the $errors variable.
$errors is available globally to all views.


@if(count($errors))
<div class="form-group">
  <div class="alert alert-danger">
    <ul>
        @foreach($errors->all() as $error)
          <li>{{ $error }}
          </li>
        @endforeach

    </ul>

  </div>
</div>
@endif

Autentication

Using Laravel's Built in authentication using Scaffolding.

php artisan make:auth

This will create a number of things:

in /routes/web.php a new route:

Auth::routes();

Migration files, which need to be migrated.
Point to the database you want to use. If SQLite, change your .env file and create a database.sqlite file in the /databases folder.

NOTE: in windows you need to add the php/ext directory to your path.






```composer require doctrine/dbal```

 is a prerequisite to using SQLite.

You also have to uncomment this line in the php.ini file:


```extension=php_pdo_sqlite.dll```




## Artisan ##

## Blade ##
## Composer ##

## Eloquent ##

##Carbon##

## Github Primer ##
Assume that you have a GitHub account, and that you have created a new repo. 

1. Create local directory
2. Initialize Git

 ```git init```


3. Check status

 ```git status ```


4. Add files

 ```git add .```


5. Commit your files

 ```git commit -m "My commit message" ```


6. Add remote host

 ```git remote add origin https://github.com/username/myrepo.git```


7. Check remote host info

 ```git remote -v```


8. Push to remote repo

 ```git push origin master ```



NOTE: if you wish to override the remote changes with your local use


```git push --force ```



#### Pulling from remote repo ####

1.

 ```git pull origin master ```



## Linux Notes ##

View processes

 ```top```

 or

 ```ps aux```



Kill processes

 ```kill <pid>```



Start Apache

 ``` sudo apachectl [start | stop | restart]```





```apachectl configtest ```




```httpd -v ```



### Installing MySQL on Mac using Homebrew ###


```brew install mysql```



login to MySQL

 ```mysql -uroot```



configuration

 ```/usr/local/etc/opt/phpmyadin.config/inc.php```





```brew services start mysql```




```brew install phpmydmin```


NOTE: you may need to create a symbolic link for PHPMyAdmin

### Installing PHP with Homebrew ###


```brew install php71 | php56 ```


NOTE: you need to change the default PHP path in the Mac OS.


```export PATH=/usr/local/php5/bin:$PATH```



#### Making composer executable ####


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



### Changing PATH ###


``` export PATH=/usr/local/php5/bin:$PATH```




```php --version```



### ATOM Setup ###

c:\ProgramData\ComposerSetup\bin\composer.phar
C:\Bitnami\wampstack-5.6.30-1\php\php.exe

1. Create route
2. Create controller

php artisan make:controller ControllerName

add required method to controller class

HTML Cheat Sheet

Lam Hoang — Tue, 09 Jun 2020 09:21:06 +0000

HTML Cheat Sheet

A reminder of HTML elements. Full HTML Cheat Sheet

Minimal page

<!DOCTYPE html>
<html>
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <!-- content here -->
    </body>
</html>

Head

<head>
    <title>Title</title>
    <base href="base-url" />
    <link href="style.css" rel="stylesheet" type="text/css" />
    <style type="text/css">
        /* CSS code */
    </style>
    <script src="script.js"></script>
    <script>
        // Javascript code
    </script>
    <meta charset="UTF-8">
    <meta name="keywords" content="keywords">
    <meta name="description" content="description">
    <meta name="author" content="name">
    <meta http-equiv="refresh" content="10">
</head>

tag	element
title	page title
base	base url for all links
link	link to external source
style	CSS inside HTML page
script	Javascript code
meta	metadata
meta http-equiv="refresh" content="10"	auto-refresh page in 10s

Text content

Headings

<h1>Main heading</h1>
<!-- etc -->
<h6>Level-6 heading</h6>

tag	element
h1	main heading
h6	least important heading

Paragraphs

<p>Paragraph.<br/>
Other line.</p>
<p>Other paragraph.</p>
<hr/>
<p>See the line above.</p>

tag	element
p	paragraph
br	line break
hr	horizontal line

Formatting

<em>Formatting</em> is <strong>important</strong> !
(a+b)<sup>2</sup> = a<sup>2</sup> + b<sup>2</sup> + 2ab

tag	element
sub	subscript
sup	superscript
em	emphasize
strong	important
mark	highlighted
small	small
i	italic
b	bold

Quotes

<cite>This book</cite> was written by this author.
<q cite="url">quotation</q>
<blockquote cite="url">
Lorem ipsum<br/>
Lorem ipsum
</blockquote>

tag	element
cite	title of a work
q	inline quotation
blockquote	quotation

Content

Links

<a href="url">link</a>
<a href="url" target=_blank>open in a new window</a>

<a href="#comments">watch comments</a>
<h2 id="comments">comments</h2>

tag	element
a	hyperlink

Images

<img src="image.png" alt="description" width="300" height="200" />

tag	element
img	image

Blocks

<div>block</div>
<span>inline</span>

tag	element
div	block-level element
span	inline element

Lists

Unordered list

<ul>
    <li>item</li>
    <li>item</li>
    <li>item</li>
</ul>

tag	element
ul	unordered list
li	list item

Ordored list

<ol>
    <li>first</li>
    <li>second</li>
    <li>third</li>
</ol>

tag	element
ol	ordered list
li	list item

Definition list

<dl>
    <dt>term</dt><dd>definition</dd>
    <dt>term</dt><dd>definition</dd>
    <dt>term</dt><dd>definition</dd>
</dl>

tag	element
dl	definition list
dt	term
dd	definition

Tables

Basic table

<table>
<tr>
    <th>heading 1</th>
    <th>heading 2</th>
</tr>
<tr>
    <td>line 1, column 1</td>
    <td>line 1, column 2</td>
</tr>
<tr>
    <td>line 2, column 1</td>
    <td>line 2, column 2</td>
</tr>
</table>

tag	element
table	table
tr	table row
th	table heading
td	table cell

Advanced table

<table>
<caption>caption</caption>
<colgroup>
    <col span="2" style="..." />
    <col style="..." />
</colgroup>
<thead>
    <tr>
        <th>heading 1</th>
        <th>heading 2</th>
        <th>heading 3</th>
    </tr>
</thead>
<tfoot>
    <tr>
        <th>footer 1</th>
        <th>footer 2</th>
        <th>footer 3</th>
    </tr>
</tfoot>
<tbody>
    <tr>
        <td>line 1, column 1</td>
        <td>line 1, column 2</td>
        <td>line 1, column 3</td>
    </tr>
    <tr>
        <td>line 2, column 1</td>
        <td>line 2, column 2</td>
        <td>line 2, column 3</td>
    </tr>
</tbody>
</table>

tag	element
caption	caption
colgroup	defines groups of columns
col	defines column's properties
thead	groups headings together
tfoot	groups footers together
tbody	groups other rows

Forms

<form action="url" method="post">
    <fieldset>
        <legend>Who are you ?</legend>
        <label>Login :<input type="text" name="login" /></label><br/>
        <label for="pswd">Password :</label><input type="password" name="password" id="pswd" /><br/>
        <input type="radio" name="sex" value="male" />Male<br/>
        <input type="radio" name="sex" value="female" />Female<br/>
    </fieldset>

    <label>Your favorite color : <select name="color">
        <option>red</option>
        <option>green</option>
        <option>blue</option>
    </select></label>

    <input type="checkbox" name="available" value="monday" />Monday<br/>
    <input type="checkbox" name="available" value="tuesday" />Tuesday<br/>

    <textarea name="comments" rows="10" cols="30" placeholder="Write your comments here"><textarea/>

    <input type="submit" value="Button text">
</form>

tag	element
form	form
label	label for input
fieldset	group inputs together
legend	legend for fieldset
input type="text"	text input
input type="password"	password input
input type="radio"	radio button
input type="checkbox"	checkbox
input type="submit"	send form
select	drop-down list
option	drop-down list item
optgroup	group of drop-down list items
datalist	autocompletion list
textarea	large text input

HTML5 Semantic

Page layout

<header>My website</header>
<nav>
    <a href="page1">Page 1</a>
    <a href="page2">Page 2</a>
    <a href="page3">Page 3</a>
</nav>

<section>
    Hello everybody, Welcome to my website !
</section>

<article>
    <header>
        <h2>Title</h2>
    </header>
    <p>
        My article
    </p>
</article>

<aside>
    Writen by me
</aside>

<section id="comments">
    <article>Comment 1</article>
    <article>Comment 2</article>
</section>

<footer>
Copyright notice
</footer>

tag	element
header	header of document or section
footer	footer of document or section
section	section
article	article, forum post, blog post, comment
aside	aside content related to surrounding content
nav	navigation links

New elements

<figure>
    <img src="image.png" alt="figure 1" />
    <figcaption>Figure 1</figcaption>
</figure>

<details>
    <summary>Declaration of M. X on <time datetime="2013-12-25">Christmas day</time></summary>
    <p>M. X said...</p>
</details>

Downloading progress : <progress value="53" max="100"></progress>
Disk space : <meter value="62" min="10" max="350"></meter>

tag	element
figure	an illustration
figcaption	caption of a figure element
details	details that can be shown or hidden
summary	visible heading of a details element
progress	progress of a task
meter	display a gauge
time	machine-readable time indication

Django 2 Cheat Sheet

Lam Hoang — Tue, 09 Jun 2020 09:19:37 +0000

Django Cheat Sheet tries to provide a basic reference for beginner and advanced developers, lower the entry barrier for newcomers, and help veterans refresh the old tricks. Full Django Cheat Sheet

Creating a virtual environment

We need to create a virtual env for our app to run in: More Here
Run this command in whatever folder you want to create your venv folder

python -m venv ./venv

Activate the virtualenv

# Mac/Linux
source ./venv/bin/activate

# Windows
venv\Scripts\activate.bat - May need to add full path (c:\users\....venv\Scripts\activate.bat)

Escape from venv

deactivate

Check packages installed in that venv

pip freeze

Install Django

pip install django

Create your project

django-admin startproject PROJECTNAME

Run Server (http://127.0.0.1:8000) CTRL+C to stop

python manage.py runserver

Create an app

python manage.py startapp APPNAME

Create migrations

python manage.py makemigrations

Run migration

python manage.py migrate

Collect Static Files

python manage.py collectstatic

CSS Cheat Sheet

Lam Hoang — Tue, 09 Jun 2020 09:17:28 +0000

CSS Cheat Sheet

A quick go to guide for CSS goodness. Checkout the Full CSS Cheat Sheet.

Selectors

Universal Selector * {}

Type Selector h1, h2 ,h3 {}

Child Selector ul > li {}

Descendant Selector p a {}

Class Selector .class {}

ID Selector #id {}

Adjacent Sibling Selector h1 + p {}

General Sibling Selector h1 ~ p {}

Attribute Selector [attribute="SomeValue"] {}

Pseudo Selectors & Elements

Mouse Over Selector a:hover {}

Active Link Selector a:active {}

Focus Selector input:focus {}

Visited Links Selector a:visited {}

Link Selector .class:link {}

First Line Selector p::first-line {}

First Letter Selector p::first-letter {}

First Child Selector p:first-child {}

Last Child Selector p:last-child {}

Only Child Selector p:only-child {}

:nth-child Selector p:nth-child() {}

First Element of its Parent Selector p:first-of-type {}

Checked elements selector input:checked {}

Disabled elements selector input:disabled {}

Enabled elements selector input:enabled {}

Elements that have no Children Selector (including text nodes) p:empty {}

Not a Specified Element Selector :not(p) {}

Before Element .class::before {}

After Element .class::before {}

Text Styling

Font style font-style: normal | italic | oblique

Font Variant font-variant: normal | small-caps

Font Weight font-weight: normal | bold | bolder | lighter | 100 - 900

Font Size font-size: 12px | 0.8em | 80%

Text Transform text-transform: capitalise | lowercase | uppercase

Space Between Characters letter-spacing: normal | 4px

Line Height line-height: normal | 3em | 34%

Horizontal Alignment text-align: left | right | center | justify

Text Decoration text-decoration: none | underline | overline | line-through

Indent First Line text-indent: 25px

Font Family font-family: 'Open Sans', sans-serif

Text Overflow text-overflow: clip | ellipsis | string | initial | inherit

Text Shadow text-shadow: h-shadow v-shadow blur-radius color | none | initial | inherit

Position

Position position: static | relative | absolute | fixed | sticky

Position Properties top | right | bottom | left

Float Element float: left | right | none

Clear Floating Elements clear: none | left | right | both

Z Index z-index: 3 | auto | inherit

Background

Background Image background-image: url()

Background Color background-color: #2AA9E0

Background Position background-position: top | right | bottom | left | center

Background Attachment background-attachment: scroll | fixed | local | initial | inherit

Box properties

Box Sizing box-sizing: border-box | content-box

Margin margin: 2px 4px 6px 8px | 0 auto

Padding padding: 2px 4px 6px 8px

Border Color border-color: #2AA9E0

Border Width border-width: 10px

List Styling

List Type list-style-type: disc | circle | square | none

List Position list-style-position: inside | outside

List Image list-style-image: url()

Flexbox

Flex Direction flex-direction: row | row-reverse | column | column-reverse

Flex Wrap flex-wrap: nowrap | wrap | wrap-reverse

Align Items align-items: flex-start | flex-end | center | baseline | stretch

Order order: 0

Flex Grow flex-grow: 0

Flex Shrink flex-shrink: 1

Flex Basis flex-basis: 3px | auto

CSS Grid

Grid Template Columns grid-template-columns: 40px 50px auto 50px 40px

Grid Template Rows grid-template-rows: 25% 100px auto

Grid Template Areas grid-template-areas: "a b c" | none

Grid Template grid-template: "a a a" 20% "b b b" auto | 100px 1fr / 50px 1fr

Grid Column Gap grid-column-gap: 10px

Grid Row Gap grid-row-gap: 10px

Justify Items justify-items: start | end | center | stretch

Align Items align-items: start | end | center | stretch

Grid Auto Columns grid-auto-columns: 100px | max-content | min-content

Grid Auto Rows grid-auto-rows: 100px | max-content | min-content

Grid Auto Flow grid-auto-flow: row | column | row dense | column dense

Grid Column Start grid-column-start: 2 | areaname | span 2 | span areaname | auto

Grid Column End grid-column-end: 2 | areaname | span 2 | span areaname | auto

Grid Row Start grid-row-start: 2 | areaname | span 2 | span areaname | auto

Grid Row End grid-row-end: 2 | areaname | span 2 | span areaname | auto

Grid Column grid-column: 3 / span 2

Grid Row grid-row: 3 / span 2

Justify Self justify-self: start | end | center | stretch

Align Self align-self: start | end | center | stretch

Dynamic Content

CSS Variable --variable-name: value

Variable Usage var(--variable-name)

Counter Reset counter-reset: name-of-counter

Counter Increment counter-increment: name-of-counter

Counter Dynamic Value content: counter(name-of-counter)

Attribute Dynamic Value content: attr(name-of-attribute)

Laravel Cheat Sheet - Form

Lam Hoang — Sat, 16 May 2020 14:51:48 +0000

Forms

CSRF Protection

In Laravel 5.7 you create form by simple HTML

<form method="POST" action="{{ route('posts.store') }}">

</form>

CSRF protection is enabled by default, so you need to include a CSRF token with each form sent

Token can be included by adding a @csrf directive inside the <form> tag. It would generate an <input> of type hidden with the token as value

<form method="POST" action="{{ route('posts.store') }}">
    @csrf
</form>

The token is then verified inside Laravel using the VerifyCsrfToken middleware.

Middleware

Middleware is a mechanism that filter requests going through your application.

Simply put - each middleware is a chunk of code that runs BEFORE or AFTER the request is handled by Controller Action or a Closure.

Below is an example flow of the request going through your application:

An example AFTER middleware from Laravel Docs

namespace App\Http\Middleware;

use Closure;

class AfterMiddleware
{
    public function handle($request, Closure $next)
    {
        // Calling $next with $request parameter
        $response = $next($request);

        // Do something here after the request is handled by Controller/Closure

        return $response;
    }
}

An example BEFORE middleware

namespace App\Http\Middleware;

use Closure;

class BeforeMiddleware
{
    public function handle($request, Closure $next)
    {
        // Do something here before the request is handled by Controller/Closure...

        // Calling $next with $request parameter
        return $next($request);
    }
}

Middleware should call the passed Closure $next with the $request parameter to allow further processing, or throw an Exception or do a redirect to stop further processing of the Request.

Middleware examples:

Authentication (veryfying if user is authenticated)
CSRF protection
CORS middleware

Request

Obtaining data sent with request

class PostController extends Controller
{
    public function store(Request $request)
    {
        $title = $request->input('title');
    }
}

Reading all input as an array

$input = $request->all();

Reading an individual value with default provided

$name = $request->input('title', 'Draft post');

Retrieving all of the input values as an array

$input = $request->input();

The input() method can read data regardless of the HTTP verb used (works for GET query parameters or input fields sent through <form> with POST method)

Veryfing if input value is present

if ($request->has('title')) {
    // Do something with title
}

Redirects

Redirect to a URL

return redirect('/posts');

Redirect to a route with "flashed input"

return redirect('/posts/create')->withInput();

Redirect to last URL with "flashed input"

return back()->withInput();

Redirect to a named route

return redirect()->route('posts.index');

Redirect with flash message

return redirect()->route('posts')->with('status', 'New post created!');

Flashing input

Sometimes you need to repopulate the form with the old input, eg. when validation failed and you don't want the user to re-type all the fields.

You can do

$request->flash();

Or the above example (flash input and redirect)

return redirect('form')->withInput();

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Resource Controllers

Lam Hoang — Sat, 16 May 2020 14:50:47 +0000

Controllers

Import the Model class for easier usage

use App\BlogPost
// Now it can be used like this
BlogPost::all();
// Instead of 
\App\BlogPost::all();

Group code by responsibility, separate controllers for 2 simple static pages (HomeController), another for displaying blog posts (PostController).

Resource Controllers

Use (per) resource controllers

Route::resource('posts', 'PostController');

Instead of

Route::get('/posts', 'PostController@index')->name('blog.index');
Route::get('/posts/{id}', 'PostController@show')->name('blog.show');

Generating a new resource controller with all the resource methods

php artisan make:controller PostController --resource

Resource methods table

Verb	URI	Action	Route Name
GET	/posts	index	posts.index
GET	/posts/create	create	posts.create
POST	/posts	store	posts.store
GET	/posts/{photo}	show	posts.show
GET	/posts/{photo}/edit	edit	posts.edit
PUT/PATCH	/posts/{photo}	update	posts.update
DELETE	/posts/{photo}	destroy	posts.destroy

To enable only certain routes

Route::resource('posts', 'PostController')->only(['index', 'show']);

To disable specific routes

Route::resource('posts', 'PostController')->except(['create', 'store', 'edit', 'update', 'destroy]);

Both examples above will result in the same routes - posts.index and posts.show

Fetching a single model

Model can be fetched using BlogPost::find($id)

To display a 404 Not Found page when model cannot be found, use BlogPost::findOrFail($id)

Route Model Binding

Those 2 examples are equivalent

PostController extends Controller {
    public function show($post) {
        return view('post.show', ['post' => BlogPost::findOrFail($id)]);
    }
}

Above, we manually try to fetch the BlogPost model. findOrFail will show a 404 page if model is not found.

PostController extends Controller {
    public function show(BlogPost $post) {
        return view('post.show', ['post' => $post]);
    }
}

Above we use Route Model Binding. If the method parameter name matches the route segment, eg. route is /posts/{post} the variable name has to be $post. Then type hinting (specyfying the argument type) as the Eloquent model BlogPost, tells Laravel to try and fetch this object by id.

To customize the property by which the model is fetched, add the getRouteKeyName() method to the model.

public function getRouteKeyName()
{
    return 'slug';
}

With the example above, Laravel would try to find a BlogPost model by slug property.

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Models Eloquent

Lam Hoang — Sat, 16 May 2020 14:48:42 +0000

Laravel Tinker

Tinker is a console program that allows you to play around with Laravel models and execute arbitraty PHP command directly from your command line

Starting the console

php artisan tinker

Solving a problem with Tinker (for PHP 7.3 or newer) when it quits after every command

Modify the php.ini by adding this option

pcre.jit=0

On Mac php.ini can be usually found in /Applications/XAMPP/xamppfiles/etc/php.ini

To be sure where it is, run php -i | grep 'php.ini' in Terminal

On Windows it's in your XAMPP folder C:\xampp\php\php.ini or C:\xampp\etc\php.ini, depending on location of XAMPP itself

Eloquent Model

Generating a new model

php artisan make:model BlogPost

Generating a new model with migration

php artisan make:model BlogPost --migration
// or
php artisan make:model BlogPost -m

By convention, Laravel assumes the table name is "snake case" plural model name. For example:

Model name	Table name
BlogPost	`blog_posts`
Blogpost	`blogposts`
VeryLongTrain	`very_long_trains`

To define a custom name, add (override) the protected $table model property

class BlogPost extends Model
{
    protected $table = 'blogposts';
}

By default, all models are stored inside the App namespace, eg. App\BlogPost

Acessing and modifying properties

You can read and modify model properties (row columns) using properties

$post = App\BlogPost::find(1);
$title = $post->title;
$content = $post->content;

$post->title = 'New title';
$post->content = 'New content';
// Always call save() to create the record and UPDATE the existing one
$post->save();

Property name corresponds 1:1 to the column name of the table

Querying

Retrieving all models as collection

$posts = App\BlogPost::all();

Retrieving single model by primary key (usually, by id property/column)

// Fetch BlogPost with id 10
$post = App\BlogPost::find(10);

Fetching collection of models by id

$posts = App\BlogPost::find([1, 2, 3]);

Collections are iterable (eg. using foreach)

$posts = App\BlogPost::all();

foreach ($posts as $post) {
    echo $post->title;
}

Getting first element of the collection of models

$posts = App\BlogPost::all();
$post = $posts->first();

Creating and saving (creating a database row) a new model

$post = new App\BlogPost();
$post->title = 'Title';
$post->content = 'Content';
$post->save();

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Migrations

Lam Hoang — Sat, 16 May 2020 14:47:27 +0000

Migrations problems

The limit for keys is 767 bytes.

In the utf-8 encoding, the single character is 3 bytes, so key on VARCHAR(255) length won't exceed 767 (3 * 255 = 765).

In you are using utf8mb4, which we are, the single character is 4 bytes. Thus the maximum length for VARCHAR which has key on it (like UNIQUE) is 191.

When you encounter this:

Migration table created successfully.
Migrating: 2014_10_12_000000_create_users_table

Illuminate\Database\QueryException  : SQLSTATE[42000]: Syntax error or access violation: 1071 Specified key was too long; max key length is 767 bytes (SQL: alter table `users` add unique `users_email_unique`(`email`))

Change the email field length to 191.

Running migrations

To run the most recent, not executed yet migrations

php artisan migrate

To rollback the most recent migration

php artisan migrate:rollback

Setting the length of the field

$table->string('email', 191);

Writing migrations

Creating a new migration

php artisan make:migration create_blogposts_table

To prefill the migration with stub code that creates a new table

php artisan make:migration create_blogposts_table --create=blogposts

To prefill the migration with stub code that modifies an existing table

php artisan make:migration add_date_to_blogposts_table --table=blogposts

The migration file

Migration file containts a class with 2 methods, up() and down()

The up() methods creates new table, modifies the existing one. Generally, it specifies how your database schema should change from now on - this might include deleting fields or tables.

The down() method specifies how to revert changes made my migration.

up() method is called when you run php artisan migrate

down() method is called when you run php artisan migrate:rollback

Creating a new table

Schema::create('blogposts', function (Blueprint $table) {
    $table->increments('id');
});

Renaming an existing table

Schema::rename('blogposts', 'posts');

Creating columns

Schema::table('blogposts', function (Blueprint $table) {
    $table->string('title');
});

Available column types

Refer to this link https://laravel.com/docs/5.7/migrations#columns

Typical columns types

Command	Description
`$table->increments('id');`	Auto-incrementing UNSIGNED INTEGER
`$table->string('title', 100);`	VARCHAR with optional length
`$table->timestamps();`	Nullable TIMESTAMP `created_at` and `updated_at` columns
`$table->text('content');`	TEXT

Column modifiers

->default('value') - the default column value

->nullable() - column can be NULL

->unsigned() - integer is unsigned (no negative values)

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Database

Lam Hoang — Sat, 16 May 2020 14:44:55 +0000

Configuring database

The database connection parameters are stored inside .env file (on development environment).

On production environment store it in VirtualHost configuration or .htaccess file. To store variables in .htaccess file VirtualHost must contain the AllowOverride All directive.

Reading environment variable

$value = env('DB_HOST', '127.0.0.1');

Where first value is the name of the variable, and second is the default value (if env variable is not defined).

Connecting to the database server

Using phpMyAdmin

Visit http://localhost/phpmyadmin if you are using XAMPP

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Controllers

Lam Hoang — Sat, 16 May 2020 14:43:07 +0000

Controllers

Controllers are an alternative to Closures for defining the application logic

Generating a new Controller

php artisan make:controller ControllerNameController

Controllers are stored inside the app/Http/Controllers folder

An example controller class

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;

class HomeController extends Controller
{
    public function index()
    {
        return view('home');
    }

    public function contact()
    {
        return view('contact');
    }
}

Controllers do not have to extend the base App\Http\Controllers\Controller class, but it provides some convienience methods.

Route definition for the above controller (routes/web.php):

Route::get('/', 'HomeController@home');
Route::get('/contact', 'HomeController@contact');

We don't have to specify the full controller namespace in web.php. It's enough to specify everything after App\Http\Controllers.

RouteServiceProvider will is responsible for prepending the App\Http\Controllers namespace to controller names in routes.

Single Action Controllers

For controllers that handle just a single action:

<?php

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;

class HomeSingleController extends Controller
{
    public function __invoke()
    {
        return view('home');
    }
}

Route definition (routes/web.php)

Route::get('home', 'HomeSingleController');

Generating a single action controller

php artisan make:controller HomeSingleController --invokable

The __invoke is a magic PHP method that allows the object to be called like a function, eg.

$controller = new HomeSingleController();
$controller();

Routing

Route for controller action

$url = action('HomeController@home');

Source: Laravel Cheat Sheet

Laravel Cheat Sheet - Routes Views

Lam Hoang — Sat, 16 May 2020 14:41:52 +0000

Inside route definition file (routes/web.php)

Defining a route using closure

Route::get('/', function () {
    return view('welcome');
});

Defining a route that only renders a Blade template

Route::view('/home')
Route::view('/home', ['data' => 'value'])

Route with a required parameter

Route::get('/page/{id}', function ($id) {
    return view('page', ['page' => $id]);
});

Route with an optional parameter

Route::get('/hello/{name?}', function ($name = 'Guest') {
    return view('hello', ['name' => $name]);
});

Named route

Route::view('/home')->name('home');
Route::get('/blog-post/{id}', function ($id) { return view('blog-post', ['id' => $id]); });

Generating url to the named route

$url = route('home');
// Generates /home
$blogPostUrl = route('blog-post', ['id' => 1]);
// Generates /blog-post/1

Inside Blade template

Defining a section

@section('content')
    <h1>Header</h1>
@endsection

Rendering a section

@yield('content')

Extending a layout

@extends('layout')

Function to render a view

view('name', ['data' =>‚ 'value'])

Rendering data inside a Blade template

{{ $data }}

By default data is escaped using htmlspecialchars

Rendering unescaped data

{!! $data !!}

Including another view

@include('view.name')

Included view will inherit parent view data

Passing additional data to included view

@include('view.name', ['name' => 'John'])

Generating a URL inside view

<a href="{{ route('home') }}">Home</a>

Source: Laravel Cheat Sheet