Forem: lukapg

How to show featured posts in Ghost blog

lukapg — Thu, 23 Jun 2022 15:05:51 +0000

When you have a blog, sometimes you may want to feature your most popular or important posts above the others. You could do this in various ways but the easiest and recommended way is to use the get helper with some filtering to get the featured posts.

The typical place you would use to show featured post is your blog's homepage, so we will be modifying the index.hbs file of your Ghost theme. To get the featured posts in a query, we will use the featured filter:

{{#get "posts" limit="all" filter="featured:true"}}
    {{#foreach posts}}
        <a href="{{slug}}">{{title}}</a>
    {{/foreach}}
{{/get}}

This code block will show all featured posts links with their title. You can add more post information in the foreach block, for example post excerpt and creation date:

{{#get "posts" limit="all" filter="featured:true"}}
    {{#foreach posts}}
        <a href="{{slug}}">{{title}}</a>
        <p>{{excerpt}}</p>
        <time datetime="{{date format=" YYYY-MM-DD"}}">{{date}}</time>
    {{/foreach}}
{{/get}}

This would be enough to show the featured posts title, excerpt and date. However, we can improve this code in a few ways. First, we can check to see if there are featured posts at all. If there are no featured posts created on our blog, we can show a simple message to the user:

{{#get "posts" filter="featured:true" limit="all"}}
        {{#if posts}}
            {{#foreach posts}}
                <a href="{{url}}">{{title}}</a>
                <p>{{excerpt}}
                <time datetime="{{date format=" YYYY-MM-DD"}}">{{date}}</time>
            {{/foreach}} 
        {{else}}
        <p>There are no featured posts at the moment.</p>
        {{/if}}
{{/get}}

Also, we don't want to show featured posts if the post pagination is active. So, for example if the user switches to a different page using the pagination the featured posts section will not be shown. We can achieve this by combining our code with the is helper:

{{^is "paged"}}
{{#get "posts" filter="featured:true" limit="all"}}
        {{#if posts}}
            {{#foreach posts}}
                <a href="{{url}}">{{title}}</a>
                <p>{{excerpt}}
                <time datetime="{{date format=" YYYY-MM-DD"}}">{{date}}</time>
            {{/foreach}} 
        {{else}}
        <p>There are no featured posts at the moment.</p>
        {{/if}}
{{/get}}
{{/is}}

Here, we are using the negation form of the is helper by using the ^ character. So, essentially if the page is not paged, then the featured posts will be shown to the user.

How to show reading time in Ghost blog posts

lukapg — Wed, 22 Jun 2022 11:04:24 +0000

As we all know by know, the attention span of an average visitor browsing your website is very short. They often just skim through the contents of the homepage and move. A good tactic for increasing the time the visitor spends on your website is to give them an accurate estimate of how much time they need to spend on a particular post.

By providing them with a reading time estimate, the visitor won't get bored of the post content as he/she knows what to expect. Let's see how to do this in Ghost!

The Ghost way

The easiest way to add post reading time in Ghost is by using Ghost's native reading_time helper in your theme. This helper simply counts all the words in a post and assumes a reading speed of 275 words/minute. You can use the reading_time helper both in the single post context and in a posts loop.

To use it in a single post, go to the post.hbs file in your Ghost theme and somewhere within the #post context add the helper:

{{#post}}
  ...
  <span class="reading-time-class">{{reading_time}}</span>
  ...
{{/post}}

If you want to show a reading time for every post in your post list, you can add it in a foreach loop in which you list your posts. For example:

{{#foreach posts}}
  <h1>{{title}}</h1>
  <p>{{excerpt}}</h1>
  <span>{{reading_time}}</span>
{{/foreach}}

Customizing the values

The reading_time helper also accepts two optional arguments which enable you to customize how it outputs the values for the reading time of 1 minute and multiple minutes. The optional arguments are:

minute - the text shown for the reading time of 1 minute
minutes - the text show for the reading time of more than 1 minute Let's see and example of the helper with arguments:

{{reading_time minute="1 minute" minutes="% minutes" }}

As you can see, in the case of multiple minutes, you can get the value of minutes by using the % character in the argument.

Give this helper a try if you are not using it already, as it may just help you decrease your website bounce rates. You can see it in action in the Memo theme demo.

3 custom Laravel validation rules to reuse and make your code cleaner

lukapg — Fri, 19 Mar 2021 13:22:48 +0000

When working with forms and user input in general, validating common fields in various projects, we can extract that field validation logic into a reusable custom validation rule. Using validation rules makes our code easier to read and maintain. We can make them even more powerful by using parameters inside our custom validation rules, allowing us to create pretty complex validation logic where needed.

Consider the scenario in which, as often is the case, we need to validate the user input of a registration form which contains the name, email, password, age and ZIP code fields. In this post, I'll give 3 examples of custom validation rules we can use to validate the password, age and ZIP code fields.

Note: You can find these and more Laravel tips at laravelbit.

Rule #1: Legal age validation rule

Imagine we needed to make a validation rule which validates the legal age of our users, based on a date input. Since the legal age varies around the world, we can pass the legal age as a parameter to our custom rule. Our legal age custom validation rule would look something like this:

namespace App\Rules;

use Illuminate\Contracts\Validation\Rule;
use Carbon\Carbon;

class LegalAgeRule implements Rule
{
    public $legalAge = 18;

    /**
     * Create a new rule instance.
     *
     * @return void
     */
    public function __construct($age)
    {
        $this->legalAge = $age;
    }

    /**
     * Determine if the validation rule passes.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */
    public function passes($attribute, $value)
    {
        $formattedValue = new Carbon($value);
        $legalAge = Carbon::now()->subYears($this->legalAge);
        return $formattedValue < $legalAge;
    }

    /**
     * Get the validation error message.
     *
     * @return string
     */
    public function message()
    {
        return 'You must be at least ' . $this->legalAge . 'years old!';
    }
}

Note that we used a class variable $legalAge to store the parameter value passed to use when calling this rule. Also, we used Carbon to compare the date received from the request and the date which we calculated to be exactly 18 years ago. Now, imagine we needed to actually use this rule somewhere in a form request. That would look like this:

public function rules()
{
    return [
        'name' => 'required|string',
        'email' => 'required|email',
        'password' => 'required|min:8',
        'age' => ['required', new LegalAgeRule(18)],
        'zip' => 'required'
    ];
}

You can see that we passed the age parameter of 18 to the LegalAgeRule custom validation rule when calling it.

Rule #2: Password strength validation rule

Often, we need to validate passwords in our applications. Instead of writing the same (or similar) logic every time, we can extract a custom password validation rule. In this example, we will use one parameter, the password length, in our custom rule. You can always expand this example to include more parameters so that you can always configure this rule when calling, without touching the rule code itself.

namespace App\Rules;

use Illuminate\Contracts\Validation\Rule;
use Illuminate\Support\Str;

class PasswordStrengthRule implements Rule
{

    public $length = 10;

    public $lengthCheck = false;

    public $uppercaseCheck = false;

    public $numericCheck = false;

    public $specialCharacterCheck = false;

    public function __construct($length)
    {
        $this->length = $length;
    }

    /**
     * Determine if the validation rule passes.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */
    public function passes($attribute, $value)
    {
        $this->lengthCheck = Str::length($value) >= $this->length;
        $this->uppercaseCheck = Str::lower($value) !== $value;
        $this->numericCheck = (bool) preg_match('/[0-9]/', $value);
        $this->specialCharacterCheck = (bool) preg_match('/[^A-Za-z0-9]/', $value);

        return ($this->lengthCheck && $this->uppercaseCheck && $this->numericCheck && $this->specialCharacterCheck);
    }

    /**
     * Get the validation error message.
     *
     * @return string
     */
    public function message()
    {
        return 'The :attribute must be at least ' . $this->length . ' 10 characters and contain at least one uppercase character, one number and one special character.';
    }
}

We use several class variables to store different password strength checks. The password length check is passed as a parameter when calling the rule, while other rules simply state that the password must contain at least one uppercase character, one number and one special characters.

Using this rule is quite similar to our last example:

public function rules()
{
    return [
        'name' => 'required|string',
        'email' => 'required|email',
        'password' => ['required', new PasswordStrengthRule(8)],
        'age' => ['required', new LegalAgeRule(18)],
        'zip' => 'required'
    ];
}

Rule #3: ZIP code validation

The last example is also the simplest. Since ZIP codes are (mostly) 5 digits in length and can contain zeros at the start (unlike regular numeric, integer values), we simply combine these two conditions in a regular expression.

namespace App\Rules;

use Illuminate\Contracts\Validation\Rule;

class ZipCodeRule implements Rule
{
    /**
     * Determine if the validation rule passes.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */
    public function passes($attribute, $value)
    {
        return preg_match('/\b\d{5}\b/', $value);
    }

    /**
     * Get the validation error message.
     *
     * @return string
     */
    public function message()
    {
        return 'ZIP code must contain 5 digits!';
    }
}

It is also the only rule out of the 3 which does not use any parameters. Finally, we can add this rule to our example form request validation as well:

public function rules()
{
    return [
        'name' => 'required|string',
        'email' => 'required|email',
        'password' => ['required', new PasswordStrengthRule(8)],
        'age' => ['required', new LegalAgeRule(18)],
        'zip' => ['required', new ZipCodeRule()]
    ];
}

6 useful tips to boost your Laravel code

lukapg — Mon, 01 Mar 2021 08:07:52 +0000

When working with any programming language or framework, you can utilize certain tips & tricks to enhance your coding level and make your application more performant and your code more elegant. The more you use certain design principles and best practices, the more you will grow as a developer. As I am a professional Laravel/Vue developer, I have created a free resource where I publish weekly Laravel tips called laravelbit. In this article, I will show you some of them and, hopefully, you can use them to supercharge your Laravel applications. Here we go!

1. Make your code more elegant using Eloquent query scopes

Often, when using Eloquent ORM in our Laravel applications, we need to match certain conditions when working with data. For example, consider this query:

$active_administrators = User::where('active', '=', 1)->where('is_admin', '=', 1)->get();

One might easily use these conditions in many locations throughout our application. In order to make our code more readable and not be repetitive, we can use query scopes. For our example, we would create the following functions in our User model:

public function scopeActive($query)
{
    return $query->where('active', '=', 1);
}

public function scopeAdmin($query)
{
    return $query->where('is_admin', '=', 1);
}

Now, our original query would look like this:

$active_administrators = User::active()->admin()->get();

2. Set column value automatically on model create

There are some situations in which you want to set a certain column automatically when creating a new record. In order to achieve this, you can use the model's creating event inside the boot method of the model. In this example, we set the value of column paid to 0 (false) on the Invoice model for each record we create:

class Invoice extends Model {
    protected static function boot()
    {
        parent::boot();

        Invoice::creating(function($model) {
            $model->paid = 0;
        });
    }
}

3. Avoid errors by using the optional helper

When accessing object values, if that object is null, your code will raise an error. For example:

return $invoice->total;

Would raise an error if the invoice object was empty. A simple way of avoiding errors is to use the optional Laravel helper:

return optional($invoice)->total;

Now, if the $invoice object is null, your code will return null instead of raising an error. You may also use a closure with the optional helper. It receives the closure as it's second argument and it will be called if the first argument is not null.

return optional(Invoice::find($id), function ($invoice) {
    return $invoice->total;
});

4. Deleting related records automatically

During the design of application databases, it's typical to create related tables. When deleting parent records, it is also standard practice and a good database design principle to delete child related records as well. To achieve this in Laravel, we can use the model's deleting event inside the boot method of the model. For example, to delete all items of an invoice:

class Invoice extends Model
{
    public function items()
    {
        return $this->hasMany('\App\Models\Item');
    }

    public static function boot() {
        parent::boot();

        static::deleting(function($invoice) {
             foreach ($invoice->items as $item) {
                 $item->delete();
             }
        });
    }
}

5. Update or create

While working with databases, it is common to check if a certain record exists and update it accordingly, or create a new record otherwise. Something like this:

$invoice = Invoice::where('active', 1)
    ->where('client', 'My client')
        ->where('price', 49)
    ->first();

if ($invoice) {
    $invoice->update(['price' => 29]);
}

You can use Eloquent's updateOrCreate method instead:

$invoice = Invoice::updateOrCreate(
    ['active' => '1', 'client' => 'My client'],
    ['price' => 29]
);

6. Use Laravel Collection methods

Collections is a huge feature offered by Laravel out of the box which allows us to easily manipulate array data types. It can be a big time saver and utilizes a simple and intuitive syntax. It is particularly useful when combining it with Eloquent. For example, if you have an Eloquent query like this:

$invoices = Invoice::where('active', 1)
               ->orderBy('total')
               ->take(10)
               ->get()

Maybe we want to remove all invoices which were paid from our database selection; essentially filtering them to include only unpaid invoices. We could use Collection's reject method:

$activeInvoices = $invoices->reject(function ($invoice) {
    return $invoice->paid;
});

We can also use the filter method for the same task:

$activeInvoices = $invoices->filter(function ($invoice) {
    return $invoice->paid;
});

For another example, let's get the first item from the Collection that matches a condition:

$activeInvoices = $invoices->first(function ($invoice) {
    return $invoice->paid;
});

Using tips like this while developing your application is important as it improves your code efficiency and readability. If you would like to regularly get new Laravel tips, go to laravelbit.