Laravel Scout is now open for developer testing

     Laravel Scout is a driver based full-text search for Eloquent that is going to be available when Laravel 5.3 launches.

The driver is not officially released yet, however, the repository is now live and available for those that want to play with more engines.

Taylor said he would be working on docs this week in anticipation of the official 5.3 release and this first release should only be used in testing until it’s officially launched.

For those not familiar with Scout it is an optional package that makes full-text searching simple.

Scout works by implementing a “Searchable” trait with your existing models. Then it’s just a matter of syncing the data with the search service like this:

php artisan scout:import App\\Post

After that you can search your models with:

Post::search('Alice')->get();

You can even paginate:

Post::search('Alice')->paginate()

And it even includes simple where clauses:

Post::search(‘Alice’)—>where('acount_id', '>', 1)->paginate()

The repository has already had a few pull requests for adding additional search engines and Taylor is recommending developers create their own packages like what is being done with Laravel Notifications.

Once 5.3 is official the documentation for Scout will be available and it’ll be ready for all.

Read More

TNTSearch Driver is now available for Laravel Scout

 

Laravel Scout was just opened for developer testing and TNTStudio has already launched a new package for implementing their TNTSearch into Scout.

TNTSearch is full-text search engine written in PHP with no dependencies. For more information on how it works, they have a tutorial on building and searching an index.

Read More

Laravel Passport – Easily setup your own OAuth2 server

 

Creating your own OAuth server can be difficult and Laravel 5.3 comes with a free optional package called Passport that is a full OAuth2 server that is ready to go in minutes.

Taylor demoed this new package during his Laracon talk and it was amazing seeing just how quick you can add this to your app. Today, he visited Laracasts and created a 15-minute overview video.

If you want to learn even more checkout the documentation and Matt Stauffer’s coverage.

Read More

Easily deleting old soft-deleted records with Quicksand

 

When building applications, there are times when you would like to allow users to remove data from their view but keep the record in the database. An example could be allowing a user to delete their account, but you want to give them the opportunity to restart it later. If all their data is completely removed, then they would have to start completely over.

Laravel’s Eloquent provides this ability out of the box, and when models are soft-deleted, they are not removed from the database. Instead, a deleted_at attribute is stored. The database record remains, and Eloquent ignores it unless explicitly told otherwise by a withTrashed attribute.

One problem with this is over time your soft-deleted records can fill up your database and take up a lot of space.

Tighten Co. recently released a new package called “Quicksand” which will help you solve this problem by automating and scheduling the deleting of old soft-deleted records.

Quicksand is an Artisan command that you can run through the Laravel scheduler to force the deletion of your soft-deleted records. You can specify which classes you want to clean up, how long the records should remain, and it does the rest. Let’s take a look at this package.

Installation:

First, install Quicksand through Composer:

composer require tightenco/quicksand

Then add Quicksand Service provider in config/app.php:

'providers' => [
    ...
    Tightenco\Quicksand\QuicksandServiceProvider::class,

After that you should publish Quicksand config to edit it as you want, run the following command in your terminal:

php artisan vendor:publish --provider="Tightenco\Quicksand\QuicksandServiceProvider"

Finally, Schedule the following command by adding it in app/Http/Console/Kernel.php:

protected function schedule(Schedule $schedule)
{
    $schedule->command('quicksand:run')
        ->daily();
}

Quicksand Options

Let’s take a look at the available options in Quicksand that are available in the config/quicksand.php file

return [
    // Days before deleting soft deleted content
    'days' => 30,

    // Whether to log the number of soft deleted records per model
    'log' => false,

    // List of models to run Quicksand on
    'models' => [
        // Example::class,
        // User::class => [
        //     'days' => '30' // per-model days setting override
        // ]
    ]
];

First, you have the option to set the days before permanent removal, an option to turn logging on or off for the number of soft deleted records. Lastly, the most important option is the “models” array where you can add the list of models that you would like Quicksand to do its cleanup process on.

You can add your models simply like this:

User::class,

Or if you want more control, you can override the days for a particular model independently like this:

Post::class => [
    'days' => '60' // per-model days setting override
]

If you are curious about how it works, here’s the core of it:

What Quicksand is doing is fetching all the soft-deleted records using the onlyTrashed method, then limits based on the deleted_at column when it’s less than the config days and finally force deletes the results.

That’s it, simple options, easy to use, and a very convenient package. If you are looking to automate the cleanup of your soft deleted records give these a try and you can check out the source code of Quicksand at Github

Read More

Laravel Lambo – A package to quickly scaffold out a new project

 

Laravel Lambo is a new package by Tighten.co that allows you to quickly scaffold out a new Laravel application from your terminal.

It works similar to laravel new but supercharged. For example, you start a new project like this:

lambo myproject

Then behind the scenes it runs the following commands:

laravel new $PROJECTNAME
cd $PROJECTNAME
git init
git commit -am 'Initial Commit'

Next, it modifies your local .env to add your database credentials and replaces APP_URL with the project name, then opens up the browser to your URL.

Lambo is Mac only and requires both the Laravel command line installer and Laravel Valet.

Read More

Improved model generation with Laracademy Generators

 

Laravel provides the Artisan command line tool that allows you to save time by including several generators. Some examples include make:controller, make:model, and make:migration.

Building on top of this idea is a third party package named Laracademy Generators that will automatically generate your models based on your database structure.

Installation:

Let’s explore the workflow when using Laracademy Generators:

First, create your migration as always:

php artisan make:migration create_posts_table —create=posts

Then add your fields to the generated migration file. For example, your field might look like:

public function up()
{
    Schema::create(‘posts’, function (Blueprint $table) {
        $table->increments(‘id’);
        $table->string(‘title’);
        $table->text(‘body’);
        $table->boolean(‘featured’);
        $table->datetime(‘publish_date’);
        $table->timestamps();
    });
}

After that, you will migrate your tables by execution the following command in your terminal:

php artisan migrate
Migrated: 2016_08_26_145636_create_posts_table

Now let’s install Laracademy Generators:

composer require "laracademy/generators"

Then add Laracademy Generators into your config/app.php file:

Laracademy\Generators\GeneratorsServiceProvider::class

Alternatively, you can add the provider to your ‘app/Providers/AppServiceProvider.php’ if you only want to use this provider for local development:

public function register()
{
    if($this->app->environment() == 'local') {
        $this->app->register('\Laracademy\Generators\GeneratorsServiceProvider');
    }
}

Now you have everything you need to start using the Laracademy Generators. Let’s explore how to use it and what are the available options.If you check your Artisan cli, a new command will appear in the list:

generate:modelfromtable

First, you can pass –all flag to tell Laracademy Generators to generate models for all tables existed in your database:

php artisan generate:modelfromtable --all

Another option is –table which makes you be able to specify the tables that you want Laracademy Generators to generate models for, like this:

php artisan generate:modelfromtable --table=posts

Or multiple tables at once:

php artisan generate:modelfromtable --table=users,posts

There are another two options; one is for choosing your database connection (–connection=example) and the second is for specifying you where the generated models goes (–folder=app\Models).

Take a look at what the generated model looks like, if you are following along with me in the posts table example, the generated app/Post.php content will look like this:

Just note that the generated code will often require some edits but it gives you a great starting point.

Read More