50 Laravel Tricks in 50 Minutes

class Post extends Eloquent
{
public static $autoValidate = true;
protected static $rules = array();
protected static function boot()
{
parent::boot();
// You can also replace this with static::creating or static::updating
static::saving(function($model)
{
if ($model::$autoValidate)
{
return $model->validate();
}
});
}
public function validate()
{
}
}

class Post extends Eloquent
{
{
parent::boot();
static::updating(function($model)
{
return false;
});
}
}

class myModel extents Model
{
public function category()
{
return $this->belongsTo('myCategoryModel', 'categories_id')
->where('users_id', Auth::user()->id);
}
}

$products = Product::where('category', '=', 3)->get();
$products = Product::where('category', 3)->get();
$products = Product::whereCategory(3)->get();

SELECT *, COUNT(*) FROM products GROUP BY category_id HAVING count(*) > 1;
DB::table('products')
->select('*', DB::raw('COUNT(*) as products_count'))
->groupBy('category_id')
->having('products_count', '>' , 1)
->get();
Product::groupBy('category_id')->havingRaw('COUNT(*) > 1')->get();

$q->whereDate('created_at', date('Y-m-d'));
$q->whereDay('created_at', date('d'));
$q->whereMonth('created_at', date('m'));
$q->whereYear('created_at', date('Y'));

// src/Illuminate/Database/Eloquent/Model.php
public function save(array $options = array())
// src/Illuminate/Database/Eloquent/Model.php
protected function performUpdate(Builder $query, array $options = [])
{
if ($this->timestamps && array_get($options, 'timestamps', true))
{
$this->updateTimestamps();
}
$product = Product::find($id);
$product->updated_at = '2015-01-01 10:00:00';
$product->save(['timestamps' => false]);

// app/Article.php
class Article extends Model
{
use DimsavTranslatableTranslatable;
public $translatedAttributes = ['name', 'text'];
}
// database/migrations/create_articles_table.php
public function up()
{
Schema::create('articles', function (Blueprint $table) {
$table->increments('id');
$table->boolean('online');
$table->timestamps();
});
}
// resources/views/article.blade.php
<h1>{{ $article->name }}</h1>
{{ $article->text }}
//database/migrations/create_articles_table.php
{
$table->increments('id');
$table->integer('article_id')->unsigned();
$table->string('locale')->index();
$table->string('name');
$table->text('text');
$table->unique(['article_id','locale']);
$table->foreign('article_id')->references('id')
->on('articles')
->onDelete('cascade');
}
// app/ArticleTranslation.php
class ArticleTranslation extends Model
{
public $timestamps = false;
}
// app/http/routes.php
Route::get('{locale}', function($locale) {
app()->setLocale($locale);
$article = Article::first();
return view('article')->with(compact('article'));
});
http://50LaravelTricksIn50Minutes.com/fr -- French Translation

$questions = Question::orderByRaw('RAND()')->take(10)->get();

use RamseyUuidUuid;
trait UUIDModel
{
public $incrementing = false;
{
parent::boot();
static::creating(function ($model) {
$key = $model->getKeyName();
if (empty($model->{$key})) {
$model->{$key} = (string) $model->generateNewId();
}
});
}
public function generateNewUuid()
{
return Uuid::uuid4();
}
}

class Category extends Model
{
public function products()
{
return $this->hasMany('AppProduct')->orderBy(‘name');
}
}

$customer = Customer::find($customer_id);
$loyalty_points = $customer->loyalty_points + 50;
$customer->update(['loyalty_points' => $loyalty_points]);
// adds one loyalty point
Customer::find($customer_id)->increment('loyalty_points', 50);
// subtracts one loyalty point
Customer::find($customer_id)->decrement('loyalty_points', 50);

$employees = Employee::where('branch_id', 9)->lists('name', 'id');
return view('customers.create', compact('employees'));
{!! Form::select('employee_id', $employees, '') !!}
public function getFullNameAttribute() {
return $this->name . ' ' . $this->surname;
}
[2015-07-19 21:47:19] local.ERROR: exception 'PDOException'
with message 'SQLSTATE[42S22]: Column not found:
1054 Unknown column 'full_name' in 'field list'' in
...vendorlaravelframeworksrcIlluminateDatabaseConnection.php:288
$employees = Employee::where('branch_id', 9)->get()->lists('full_name', 'id');

function getFullNameAttribute() {
return $this->first_name . ' ' . $this->last_name;
}
{
"id":1,
"first_name":"Povilas",
"last_name":"Korop",
"email":"povilas@webcoderpro.com",
"created_at":"2015-06-19 08:16:58",
"updated_at":"2015-06-19 19:48:09"
}
class User extends Model
{
protected $appends = ['full_name'];
{
"id":1,
"first_name":"Povilas",
"last_name":"Korop",
"email":"povilas@webcoderpro.com",
"created_at":"2015-06-19 08:16:58",
"updated_at":"2015-06-19 19:48:09",
"full_name":"Povilas Korop"
}

class Category extends Model
{
public function products() {
return $this->hasMany('AppProduct');
}
}
public function getIndex() {
$categories = Category::with('products')->has('products')->get();
return view('categories.index', compact('categories'));
}

public function store()
{
$post = new Post;
$post->fill(Input::all());
$post->user_id = Auth::user()->user_id;
$post->user;
return $post->save()
}

// eloquent
Post::whereSlug('slug')->get();
// instead of
View::make('posts.index')->with(‘posts’, $posts);
// do this
View::make('posts.index')->withPosts($posts);

//hide all but the first item
@foreach ($menu as $item)
<div @if ($item != reset($menu)) class="hidden" @endif>
<h2>{{ $item->title }}</h2>
</div>
@endforeach
//apply css to last item only
@foreach ($menu as $item)
<div @if ($item == end($menu)) class="no_margin" @endif>
<h2>{{ $item->title }}</h2>
</div>
@endforeach

$devs = [
['name' => 'Anouar Abdessalam','email' => 'dtekind@gmail.com'],
['name' => 'Bilal Ararou','email' => 'have@noIdea.com']
];
$devs = new IlluminateSupportCollection($devs);
$devs->first();
$devs->last();
$devs->push(['name' => 'xroot','email' => 'xroot@root.com']);

$customers = Customer::all();
$us_customers = $customers->filter(function ($customer) {
return $customer->country == 'United States';
});
$non_uk_customers = $customers->reject(function ($customer) {
return $customer->country == 'United Kingdom';
});

// returns a single row as a collection
$collection = AppPerson::find([1]);
// can return multiple rows as a collection
$collection = AppPerson::find([1, 2, 3]);

$collection = AppPerson::all();
$programmers = $collection->where('type', 'programmer');
$critic = $collection->where('type', 'critic');
$engineer = $collection->where('type', 'engineer');

$names = $collection->implode('first_name', ',');

// returns a collection of first names
$collection = AppPerson::all()->where('type', 'engineer')->lists('first_name');
// returns all the meta records for user 1
$collection = AppWP_Meta::whereUserId(1)->get();
// returns the first & last name meta values
$first_name = $collection->where('meta_key', 'first_name')->lists('value')[0];
$last_name = $collection->where('meta_key', 'last_name')->lists('value')[0];

class Link extends Model
{
public function users()
{
return $this->belongsToMany('PhpleaksUser')->withTimestamps();
}
}
@if ($link->users->count() > 0)
<strong>Recently Favorited By</strong>
@foreach ($link->users()->orderBy('link_user.created_at', 'desc')->take(15)->get() as $user)
<p>
<a href="{{ URL::Route('user.show', array('id' => $user->id)) }}">{{ $user->name }}</a>
</p>
@endforeach
@endif

$collection = collect([
['name' => 'Desk'],
['name' => 'Chair'],
['name' => 'Bookcase']
]);
$sorted = $collection->sortBy(function ($product, $key)
{
return array_search($product['name'], [1=>'Bookcase', 2=>'Desk', 3=>'Chair']);
});

$library = $books->keyBy('title');
[
'Lean Startup' => ['title' => 'Lean Startup', 'price' => 10],
'The One Thing' => ['title' => 'The One Thing', 'price' => 15],
'Laravel: Code Bright' => ['title' => 'Laravel: Code Bright', 'price' => 20],
'The 4-Hour Work Week' => ['title' => 'The 4-Hour Work Week', 'price' => 5],
]

$grouped = $collection->groupBy('type');

// the point is to actually combine results from different models
$programmers = AppPerson::where('type', 'programmer')->get();
$critic = AppPerson::where('type', 'critic')->get();
$engineer = AppPerson::where('type', 'engineer')->get();
$collection = new Collection;
$all = $collection->merge($programmers)->merge($critic)->merge($engineer);

$collection = collect([1=>11, 5=>13, 12=>14, 21=>15])->getCachingIterator();
foreach ($collection as $key => $value) {
dump($collection->current() . ':' . $collection->getInnerIterator()->current());
}

Route::group(['prefix' => 'account', 'as' => 'account.'], function () {
Route::get('login', ['as' => 'login', 'uses' => 'AccountController@getLogin']);
Route::get('register', ['as' => 'register', 'uses' => 'AccountController@getRegister']);
Route::group(['middleware' => 'auth'], function () {
Route::get('edit', ['as' => 'edit', 'uses' => 'AccountController@getEdit']);
});
});
<a href="{{ route('account.login') }}">Login</a>
<a href="{{ route('account.register') }}">Register</a>
<a href="{{ route('account.edit') }}">Edit Account</a>

// app/Http/routes.php
Route::group(['middleware' => 'auth'], function () {
Route::get('{view}', function ($view) {
try {
return view($view);
} catch (Exception $e) {
abort(404);
}
})->where('view', '.*');
});

// api controller
public function show(Car $car)
{
if (Input::has('fields')) {
// do something
}
}
// internal request to api - fields are lost
$request = Request::create('/api/cars/' . $id . '?fields=id,color', 'GET');
$response = json_decode(Route::dispatch($request)->getContent());
// internal request to api - with fields
$originalInput = Request::input();
$request = Request::create('/api/cars/' . $id . '?fields=id,color', 'GET');
Request::replace($request->input());
$response = json_decode(Route::dispatch($request)->getContent());
Request::replace($originalInput);

// phpunit.xml
<php>
<env name="APP_ENV" value="testing"/>
<env name="CACHE_DRIVER" value="array"/>
<env name="SESSION_DRIVER" value="array"/>
<env name="QUEUE_DRIVER" value="sync"/>
<env name="DB_DATABASE" value=":memory:"/>
<env name="DB_CONNECTION" value="sqlite"/>
<env name="TWILIO_FROM_NUMBER" value="+15005550006"/>
</php>
// .env.test – add to .gitignore
TWILIO_ACCOUNT_SID=fillmein
TWILIO_ACCOUNT_TOKEN=fillmein
// tests/TestCase.php
<?php
class TestCase extends IlluminateFoundationTestingTestCase
{
/**
* The base URL to use while testing the application.
*
* @var string
*/
protected $baseUrl = 'http://localhost';
/**
* Creates the application.
*
* @return IlluminateFoundationApplication
*/
public function createApplication()
{
$app = require __DIR__.'/../bootstrap/app.php';
if (file_exists(dirname(__DIR__) . '/.env.test')) {
Dotenv::load(dirname(__DIR__), '.env.test');
}
$app->make(IlluminateContractsConsoleKernel::class)->bootstrap();
return $app;
}
}
// access directly from your tests using helper function
env('TWILIO_ACCOUNT_TOKEN');

// gulpfile.js
var elixir = require('laravel-elixir');
mix.phpUnit();
$ gulp tdd

// app/Http/Middleware/EncryptCookies.php
protected $except = [
'shared_cookie'
];
Cookie::queue('shared_cookie', 'my_shared_value', 10080, null, '.example.com');

$ composer require genealabs/laravel-sparkinstaller --dev
//
LaravelSparkProvidersSparkServiceProvider::class,
GeneaLabsLaravelSparkInstallerProvidersLaravelSparkInstallerServiceProvider::class,
// do not run php artisan spark:install
$ php artisan spark:upgrade
// backup /resources/views/home.blade.php or it will be overwritten
$ php artisan vendor:publish --tag=spark-full

<?php namespace AppExceptions;
use Exception;
use IlluminateFoundationExceptionsHandler as ExceptionHandler;
use SymfonyComponentDebugExceptionHandler as SymfonyDisplayer;
class Handler extends ExceptionHandler
{
protected function convertExceptionToResponse(Exception $e)
{
$debug = config('app.debug', false);
if ($debug) {
return (new SymfonyDisplayer($debug))->createResponse($e);
}
return response()->view('errors.default', ['exception' => $e], 500);
}
}

// app/Providers/AppServiceProvider.php
public function register()
{
$this->app->bind(
'IlluminateContractsAuthRegistrar',
'AppServicesRegistrar'
);
if ($this->app->environment('production')) {
$this->app->register('AppProvidersProductionErrorHandlerServiceProvider');
} else {
$this->app->register('AppProvidersVerboseErrorHandlerServiceProvider');
}
}

{
Schema::table('users', function($table)
{
$table->string('name', 50)->change();
});
}
$ composer require doctrine/dbal

if (view()->exists('emails.' . $template))
{
// ... sending an email to the customer
}

// bootstrap/app.php
// replace this:
$app = new IlluminateFoundationApplication(
realpath(__DIR__.'/../')
);
// with this:
$app = new FantabulousApplication(
realpath(__DIR__.'/../')
);
<?php namespace Fantabulous;
class Application extends IlluminateFoundationApplication
{
/**
* Get the path to the storage directory.
*
* @return string
*/
public function storagePath()
{
return $this->basePath.'/FantabulousStorage';
}
}

class fakeApiCaller
{
public function getResultsForPath($path)
{
return [
'status' => 200,
'body' => json_encode([
'title' => "Results for path [$path]"
]),
'headers' => [
"Content-Type" => "application/json"
]
];
}
}
$app->get('{path?}', function($path)
{
$result = Cache::remember($path, 60, function() use ($path) {
return (new fakeApiCaller)->getResultsForPath($path);
});
return response($result['body'], $result['status'], array_only(
$result['headers'], ['Content-Type', 'X-Pagination']
));
})->where('path', '.*');

$ composer create-project laravel/laravel your-project-name-here dev-develop
// composer.json
{
"require": {
"php": ">=5.5.9",
"laravel/framework": "5.2.*"
},
"minimum-stability": "dev"
}
$ composer update

DB::listen(function($query, $bindings, $time) {
var_dump($query);
var_dump($bindings);
var_dump($time);
});
Event::listen('illuminate.query', function($query) {
var_dump($query);
});

// app/Policies/AdminPolicy.php
class AdminPolicy
{
public function managePages($user)
{
return $user->hasRole(['Administrator', 'Content Editor']);
}
}
// app/Providers/AuthServiceProvider.php
public function boot(IlluminateContractsAuthAccessGateContract $gate)
{
foreach (get_class_methods(new AppPoliciesAdminPolicy) as $method) {
$gate->define($method, "AppPoliciesAdminPolicy@{$method}");
}
$this->registerPolicies($gate);
}
$this->authorize('managePages'); // in Controllers
@can('managePages') // in Blade Templates
$user->can('managePages'); // via Eloquent

$disk= Storage::disk('s3');
$disk->put($targetFile, file_get_contents($sourceFile));
$disk = Storage::disk('s3');
$disk->put($targetFile, fopen($sourceFile, 'r+'));
$disk = Storage::disk('s3');
$stream = $disk->getDriver()->readStream($sourceFileOnS3);
file_put_contents($targetFile, stream_get_contents($stream), FILE_APPEND);
$stream = Storage::disk('s3')->getDriver()->readStream($sourceFile);
Storage::disk('sftp')->put($targetFile, $stream)

$schedule->call(function () {
Storage::delete($logfile);
})->weekly();

$result = (new IlluminatePipelinePipeline($container)
->send($something)
->through('ClassOne', 'ClassTwo', 'ClassThree')
->then(function ($something) {
return 'foo';
});

class PurchasePodcastCommand extends Command
{
public $user;
public $podcast;
public function __construct(User $user, Podcast $podcast)
{
$this->user = $user;
$this->podcast = $podcast;
}
}
class PurchasePodcastCommandHandler
{
public function handle(BillingGateway $billing)
{
// Handle the logic to purchase the podcast...
event(new PodcastWasPurchased($this->user, $this->podcast));
}
}
class PodcastController extends Controller
{
public function purchasePodcastCommand($podcastId)
{
$this->dispatch(
new PurchasePodcast(Auth::user(), Podcast::findOrFail($podcastId))
);
}
}

class PurchasePodcast extends Command implements SelfHandling
{
protected $user;
protected $podcast;
{
}
public function handle(BillingGateway $billing)
{
// Handle the logic to purchase the podcast...
event(new PodcastWasPurchased($this->user, $this->podcast));
}
}
{
public function purchasePodcast($podcastId)
{
$this->dispatch(
new PurchasePodcast(Auth::user(), Podcast::findOrFail($podcastId))
);
}
}

{
public function purchasePodcast(PurchasePodcastRequest $request)
{
$this->dispatchFrom('FantabulousCommandsPurchasePodcastCommand', $request);
}
}
{
public function purchasePodcast(PurchasePodcastRequest $request)
{
$this->dispatchFrom('FantabulousCommandsPurchasePodcastCommand', $request, [
'firstName' => 'Taylor',
]);
}
}

class PurchasePodcast extends Command
implements ShouldBeQueued, SerializesModels
{
public $user;
public $podcast;
{
}
}

// AppProvidersBusServiceProvider::boot
$dispatcher->pipeThrough(['UseDatabaseTransactions', 'LogCommand']);
class UseDatabaseTransactions
{
public function handle($command, $next)
{
return DB::transaction(function() use ($command, $next)
{
return $next($command);
});
}
}
// AppProvidersBusServiceProvider::boot
$dispatcher->pipeThrough([function($command, $next)
{
return DB::transaction(function() use ($command, $next)
{
return $next($command);
});
}]);

// app/http/routes.php
Route::get('/api/posts/{post}', function(Post $post) {
return $post;
});
// behind the scenes
Post::findOrFail($post);

$schedule->command('emails:send')
->hourly()
->appendOutputTo($filePath);

// returns titles for all posts
$titles = $posts->pluck(‘posts.*.title’);

<p>
<input type="text" name="person[1][id]">
<input type="text" name="person[1][name]">
</p>
<p>
<input type="text" name="person[2][id]">
<input type="text" name="person[2][name]">
</p>
$v = Validator::make($request->all(), [
'person.*.id' => 'exists:users.id',
'person.*.name' => 'required:string',
]);

// included in database session driver
user_id
ip_address

50 Laravel Tricks in 50 Minutes

More Related Content

What's hot (20)

Similar to 50 Laravel Tricks in 50 Minutes (20)

Recently uploaded (20)

50 Laravel Tricks in 50 Minutes