Laravel Self-Diagnosis Package

 

Laravel Self-Diagnosis is a package by Marcel Pociot that performs self-diagnostics tests on your application. The checks include standard things like setting your APP_KEY environment variable when checking out a new project.

It happened to all of us @laravelphp devs:

We forgot to generate the APP_KEY, our .env.example has keys that our .env file is missing, we forgot to do a composer install, …

Here's our Laravel Self Diagnosis package to help you ????https://t.co/wZdSpyCfn9 pic.twitter.com/qaWlDyJBuf

— Marcel Pociot (@marcelpociot) July 4, 2018

The full list of checks at the time of writing include:

• Is the APP_KEY set?
• Are your composer dependencies up to date?
• Do you have the correct PHP version installed?
• Do you have the correct PHP extensions installed?
• Can a connection to the database be established?
• Do the storage and bootstrap/cache directories have the correct permissions?
• Does the .env file exist?
• Are there environment variables that exist in .env.example but not in .env?
• Are there any migrations that need to be run?
• Is the storage directory linked?

In a team environment, comparing one’s .env file to the .env.example file is super helpful to make sure you have everything configured.

You can even create custom checks by implementing an interface and configuring the check:

<?php

use BeyondCode\SelfDiagnosis\Checks\Check;

class MyCustomCheck implements Check

{

    /**

     * The name of the check.

     *

     * @return string

     */

    public function name(): string

    {

        return 'My custom check.';

    }

    /**

     * Perform the actual verification of this check.

     *

     * @return bool

     */

    public function check(): bool

    {

        return true;

    }

    /**

     * The error message to display in case the check does not pass.

     *

     * @return string

     */

    public function message() : string

    {

        return 'This is the error message that users see if "check" returns false.';

    }

}

Learn More

You can download this package at beyondcode/laravel-self-diagnosis. Marcel has been putting out a ton of excellent packages and content for the Laravel community. Earlier this week we covered his new course, Learn Laravel Forge. Last week we covered an update to Marcel’s Laravel Test Tools Chrome extension, which adds support for Dusk test cases.

Read More

Laravel Relationship Events

 

Laravel Relationship Events is a package by Viacheslav Ostrovskiy that adds extra model relationship events. This package comes with the following traits that are used to register listeners on a model’s boot() method:

• HasOneEvents
• HasBelongsToEvents
• HasManyEvents
• HasBelongsToManyEvents
• HasMorphOneEvents
• HasMorphToEvents
• HasMorphManyEvents
• HasMorphToManyEvents
• HasMorphedByManyEvents

And from the above traits, here’s an example of a few events on a Country model that has many Users using the HasManyEvents trait:

namespace App\Models;

use App\User;

use Chelout\RelationshipEvents\Concerns\HasManyEvents;

use Illuminate\Database\Eloquent\Model;

class Country extends Model

{

    use HasManyEvents;

    protected $fillable = [

        'name',

    ];

    public function users()

    {

        return $this->hasMany(User::class);

    }

    public static function boot()

    {

        parent::boot();

        static::hasManySaving(function ($parent, $related) {

            Log::info("Saving user's country {$parent->name}.");

        });

        static::hasManySaved(function ($parent, $related) {

            Log::info("User's country is now set to {$parent->name}.");

        });

    }

}

And the inverse of the relationship with this package might look like the following:

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

use Chelout\RelationshipEvents\Concerns\HasBelongsToEvents;

class User extends Model

{

    use HasBelongsToEvents;

    /**

     * Get the country associated with the user.

     */

    public function country()

    {

        return $this->belongsTo(Country::class);

    }

    protected static function boot()

    {

        parent::boot();

        static::belongsToAssociating(function ($relation, $related, $parent) {

            Log::info("Associating country {$parent->name} with user.");

        });

        static::belongsToAssociated(function ($relation, $related, $parent) {

            Log::info("User has been assosiated with country {$parent->name}.");

        });

    }

}

Using an overloaded associate() method, you can fire two events belongsToAssociating and belongsToAssociated:

$country = App\Models\Country::first();

$user = factory(User::class)->create([

    'name' => 'John Smith',

]);

// Assosiate user with country

// This will fire belongsToAssociating and belongsToAssociated events

$user->country()->associate($country);

Learn More

The package has documentation for each trait and association type. Check out the package on GitHub at chelout/laravel-relationship-events.

Read More

Count Models With the Laravel Visits Package

 

Laravel Visits is a package by Bader Almutairi for attaching counters to any model to track visits with tags. The main features this package provides, include the following:

• A model item can have many types of recorded visits (using tags).
• It’s not limited to one kind of Model (like some packages that allow only User model).
• Record per visitors and not by visits using IP detecting, so even with refresh visit won’t duplicate (can be changed from config).
• Get Top/Lowest visits per a model.
• Get most visited countries …
• Get visits per a period like a month of a year of an item or model.

Counting Models

The basic usage for counting models includes the following methods for incrementing and decrementing among others:

visits($post)->increment();

// More than one

visits($post)->increment(10);

visits($post)->decrement();

// More than one

visits($post)->decrement(10);

// Only increment once every 30 seconds based on user's IP

visits($post)->seconds(30)->increment()

Getting Data

Once you’ve collected counter data for your model, you can retrieve and filter results with the following:

visits($post)->count();

visits($post)->period('day')->count();

// With the model class

visits('App\Post')->count();

You can also collect other interesting data about country and referrer if you want a quick analytics tool for tracking models:

visits($post)->countries();

// Referrers of visitors

visits($post)->refs();

The geo data for the country functionality is provided through the Torann/laravel-geoip package.

Integration with Eloquent

You can integrate this package directly into your Eloquent model by defining a method like visits:

public function visits()

{

    return visits($this);

}

And then performing calls on the visits object:

$post = Post::find(1);

$post->visits()->increment();

$post->visits()->count();

Learn More

To view the full readme, including installation instructions and source code, check this package out on the GitHub repo awssat/laravel-visits. Great work Bader!

Read More

Laravel View X-Ray

 

Laravel View X-Ray is a package for Laravel 5.6 by Marcel Pociot which enables you to peek into your Laravel views and find out which template matches a specific part of the HTML output.

After installing the package it’s enabled by default in development, and then you can hit Cmd + Shift + X (Ctrl + Shift + X on Windows). Note, at the time of writing the View X-Ray package depends on jQuery.

The result is a beautiful visual representation of your view, and it’s easy to understand the view hierarchy at a glance now with X-Ray enabled. You can hide the X-Ray UI by hitting the shortcut again or pressing the esc key.

You can disable X-Ray and exclude views with the following configuration options:

<?php

return [

    /*

     * Determines if the Xray package should be enabled.

     */

    'enabled' => env('XRAY_ENABLED', true),

    /*

     * If you want to exclude certain views from being processed by Xray,

     * you can list them here. Be aware that the check only applies to the

     * root views that you add here. If these views include other views

     * themselves, they need to be excluded manually.

     */

    'excluded' => [

        //

    ],

];

Learn More

You can install Laravel X-Ray in your Laravel 5.6 applications with the following composer command:

composer require beyondcode/laravel-view-xray --dev

You can learn more by visiting the GitHub repo at beyondcode/laravel-view-xray. Another excellent package by Marcel Pociot, be sure to thank him for his dedication to the Laravel ecosystem!

Read More

Laravel Love: Likes and Dislikes for Eloquent Models

 

Laravel Love is a package by Anton Komarev that lets people express how they feel about content by liking and disliking Eloquent models. The package works by defining a “liker” model defined with a contract. Most likely this will be your application’s User model:

<?php

use Cog\Contracts\Love\Liker\Models\Liker as LikerContract;

use Cog\Laravel\Love\Liker\Models\Traits\Liker;

use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable implements LikerContract

{

    use Liker;

}

On the other end, you define Eloquent models that can be “liked” by your “liker” model:

use Cog\Contracts\Love\Likeable\Models\Likeable as LikeableContract;

use Cog\Laravel\Love\Likeable\Models\Traits\Likeable;

use Illuminate\Database\Eloquent\Model;

class Article extends Model implements LikeableContract

{

    use Likeable;

}

Here are some available methods this package affords your models:

$user->like($article);

$user->likedBy(); // true/false

$user->unlike($article);

$user->toggleLike($article);

// Dislike

$user->dislike($article);

On likable models you here are some of the methods available:

<?php

$article->likesCount;

$article->dislikesCount;

This package also provides model scopes that you can learn about in the GitHub readme, along with installation instructions and API documentation:

<?php

# Find all articles liked by a user

Article::whereLikedBy($user->id)

    ->with('likesCounter') // Allow eager load (optional)

    ->get();

# Get Articles sorted by likes count asc

$sortedArticles = Article::orderByLikesCount('asc')->get();

# The default sort order is desc

$sortedArticles = Article::orderByLikesCount()->get();

The obvious use-case for this package is showing the number of likes/dislikes on content and even sorting content based on that (i.e., Reddit or Hacker News upvotes).

Another use-case that intrigues me more is trying to recommend content to users, and allowing a user to provide feedback on whether they like or dislike specific recommendations. You could use that data to keep improving the recommended content based on user feedback.

Learn More

You can get installation instructions and documentation on the GitHub repository cybercog/laravel-love. What other use-cases come to mind? Respond to @laravelnews on Twitter and let us know!

Read More

Laravel Befriended

 

Right on the heels of our post about Laravel Love: Likes and Dislikes for Eloquent Models, a reader mentioned another similar package called Befriended:

Eloquent Befriended brings social media-like features like following, blocking and filtering content based on following or blocked models. Laravel Befriended comes with scopes that manage filtering content that gives you easy control better what your user can see and cannot see.

Befriended uses traits and contracts to implement the ability to follow, block, and like Eloquent models. Although the readme examples show the User model, it can be for any eloquent model. For example, you could allow a user to follow a model like Company or Project, to name a few.

Here’s a few code examples of using the follow/following features:

<?php

$eric = User::where('name', 'Eric Barnes')->first();

$user->follow($eric);

$user->following()->count(); // 1

$eric->followers()->count(); // 1

And here’s an example of interacting with a model Page which can be followed, but cannot follow other models:

<?php

$ericPage = Page::where('username', 'ericlbarnes')->first();

$user->follow($ericPage);

$user->following()->count(); // 0, because it doesn't follow any User instance

$user->following(Page::class)->count(); // 1, because it follows only Eric's page.

You can also check if a model is following another model with:

<?php

$user->isFollowing($friend);

$user->follows($friend); // alias

Learn More

You can learn more about this package on the official GitHub readme at rennokki/befriended and install the package in your Laravel project with composer require rennokki/befriended.

Read More

Laravel Enum Package

 

Laravel Enum is a package by Ben Sampson that adds support for creating enums in PHP and includes a generator for Laravel. Here’s an example of what an Enum class looks like using this package:

<?php

namespace App\Enums;

use BenSampo\Enum\Enum;

final class UserType extends Enum

{

    const Administrator = 0;

    const Moderator = 1;

    const Subscriber = 2;

    const SuperAdministrator = 3;

}

Check out the readme for a list of methods and other examples of how to use this package.

One of my favorite features I noticed from the readme is controller validation using a supplied EnumValue rule:

<?php

public function store(Request $request)

{

    $this->validate($request, [

        'user_type' => ['required', new EnumValue(UserType::class)],

    ]);

}

You can also validate on the keys using the EnumKey rule:

<?php

public function store(Request $request)

{

    $this->validate($request, [

        'user_type' => ['required', new EnumKey(UserType::class)],

    ]);

}

Another Laravel-specific feature that you might find useful is localization:

<?php

// resources/lang/en/enums.php

use App\Enums\UserType;

return [

    'user-type' => [

        UserType::Administrator => 'Administrator',

        UserType::SuperAdministrator => 'Super administrator',

    ],

];

// resources/lang/es/enums.php

use App\Enums\UserType;

return [

    'user-type' => [

        UserType::Administrator => 'Administrador',

        UserType::SuperAdministrator => 'Súper administrador',

    ],

];

Learn More

Ben Sampson wrote a post Using enums in Laravel which is an excellent follow-up resource to the inspiration and thought process behind his package.

You can view the Laravel Enum source code and get installation instructions from the BenSampo/laravel-enum GitHub repository.

Read More

 

LaRecipe is a code-driven package created by Saleem Hadad that provides an easy way to create beautiful documentation for your product or application inside your Laravel app using Markdown.

To get started in your project, you need to install it via composer and run the setup command to publish the necessary assets and configuration:

php artisan larecipe:install

Out of the box, LaRecipe put’s your documentation at the /docs URL, and you can version control your documentation alongside your application. The folder structure of a typical installation looks like this:

├─ config

│  └─ larecipe.php

└─ resources

   └─ docs

      │─ 1.0

      │  │─ index.md

      │  └─ overview.md

      └─ 2.0

         │─ index.md

         └─ overview.md

The above example would have routes to /docs/1.0 and /docs/2.0. You can customize the base route, path to the documentation files, and the landing page. For example, configuring the landing configuration option to overview would map to overview.md.

You can also configure the default version, and control published versions of the documentation:

return [

    'versions'      => [

        'default'   => '1.0',

        'published' => [

            '1.0'

        ]

    ]

];

LaRecipe includes other configurations that you can learn about in the documentation and from the PHP configuration file.

LaRecipe converts your markdown documents into HTML, with optional Vue component support. You can read about Vue component support in the documentation. Out of the box, it includes Vue components for Cards, Buttons, Badges, and Progress.

You can get started with LaRecipe by reading through the LaRecipe documentation. The source code is also available at saleem-hadad/larecipe on GitHub.

Read More

Laratables: Ajax support of DataTables in Laravel

Laratables is a package by Gaurav Makhecha to handle server-side AJAX of DataTables (Table plug-in for jQuery) in Laravel +5.5:

This package helps with simple requirements of displaying data from eloquent models into data tables with ajax support. Plus, using simple relationships and customizing column values.

With this package the client-side code looks similar to any other usage of the Datatables plugin for jQuery:

$('#users-table').DataTable({

    serverSide: true,

    ajax: "{{ route('admin.users.datatables') }}",

    columns: [

        { name: 'id' },

        { name: 'name' },

        { name: 'email' },

        { name: 'role.name' },

        { name: 'action', orderable: false, searchable: false }

    ],

    ...

});

Note role.name in the columns property, which is a relationship column on the User model with the name of the relationship and the field.

On the server-side, here’s what a data tables controller might look like to provide the data:

use App\User;

use Freshbitsweb\Laratables\Laratables;

...

return Laratables::recordsOf(User::class);

Customizing columns and the query is possible, and this package does so via model methods. I am not one that likes a ton of extra methods on my models to support third-party packages, so perhaps a trait would be an option to contain the overrides on a model for this specific package. Check the readme for full customization options.

Laratables has an online demo available, and you can check out the source code/installation instructions from the GitHub – freshbitsweb/laratables repository.

 

Read More

Luhn Algorithm Package for Laravel

 

Laravel Luhn is a package by Vincent Prat that provides utilities to ease validation and computation of credit cards, SIREN codes, and other use-cases for the Luhn algorithm.

The Luhn algorithm (Wikipedia), developed in the 1950’s by IBM scientist Hans Peter Luhn, is a “simple checksum formula used to validate a variety of identification numbers.” Such numbers range from credit card numbers to various types of government identification numbers such as NPI numbers issued to health care providers.

Using the Laravel Luhn package, you can validate numbers using the package’s validation rule:

<?php

$validator = Validator::make($data, [

    'number1' => 'luhn', // Using shorthand notation

    'number2' => new LuhnRule(), // Using custom rule class

]);

The Luhn algorithm implementation using the provided facade includes three methods, including isValid(), computeCheckDigit(), and computeCheckSum():

<?php

Luhn::isValid('1234');

Luhn::computeCheckDigit('1234');

Luhn::computeCheckSum('1234');

Check out marvinlabs/laravel-luhn on GitHub for complete installation and usage instructions. If you are interested in learning more about the Luhn algorithm, the Luhn algorithm page on Wikipedia has some good information, even including some code examples of how the algorithm works.

Read More

Laravel View Models

 

The Laravel View Models by Brent Roose of Spatie is a package that can move the work you might do in a controller to a “view model”:

Have you ever made a controller where you had to do a lot of work to prepare variables to be passed to a view? You can move that kind of work to a so-called view model. In essence, view models are simple classes that take some data and transform it into something usable for the view.

A view model class is designed to house the complex logic of your views and clean up view-related logic from controllers:

class PostViewModel extends ViewModel

{

    public $indexUrl = null;

    public function __construct(User $user, Post $post = null)

    {

        $this->user = $user;

        $this->post = $post;

        $this->indexUrl = action([PostsController::class, 'index']);

    }

    public function post(): Post

    {

        return $this->post ?? new Post();

    }

    public function categories(): Collection

    {

        return Category::canBeUsedBy($this->user)->get();

    }

}

The above view model class gets created in the controller:

class PostsController

{

    public function create()

    {

        $viewModel = new PostViewModel(

            current_user()

        );

        return view('blog.form', $viewModel);

    }

    public function edit(Post $post)

    {

        $viewModel = new PostViewModel(

            current_user(),

            $post

        );

        return view('blog.form', $viewModel);

    }

}

And together, the view model and the controller provide your view with the following abilities:

<input type="text" value="{{ $post->title }}" />

<input type="text" value="{{ $post->body }}" />

<select>

    @foreach ($categories as $category)

        <option value="{{ $category->id }}">{{ $category->name }}</option>

    @endforeach

</select>

<a href="{{ $indexUrl }}">Back</a>

All public methods and properties in a view model are automatically exposed to the view.

I think this package is an excellent abstraction of this logic, and instead of passing the view model to the view, you can return a view directly like this:

class PostsController

{

    public function update(Request $request, Post $post)

    {

        // …

        return (new PostViewModel($post))->view('post.form');

    }

}

And last but not least, you can expose functions which require extra parameters:

class PostViewModel extends ViewModel

{

    public function formatDate(Carbon $date): string

    {

        return $date->format('Y-m-d');

    }

}

Which you can then reference in your template:

{{ $formatDate($post->created_at) }}

Thanks to Brent Roose and the folks at Spatie for this excellent package! You can access the code and installation instructions from the GitHub repository spatie/laravel-view-models.

Read More