Lam Hoang

Posted on Jun 9, 2020

Laravel Cheat Sheet

#laravel #php

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

DEV Community