DEV Community: Ajimoti Ibukun

Calculate cache time with ease in PHP

Ajimoti Ibukun — Fri, 21 Jan 2022 10:25:57 +0000

Introduction

A cache is a collection of duplicate data, where the original data is expensive to fetch or compute (usually in terms of access time) relative to the cache. In PHP, caching is used to minimize page generation time. (credit)

Caching is an important part of programming as it helps reduce the frequency of CPU intensive tasks you have to run on your server, thereby improving performance.

Most PHP frameworks have their individual ways of caching, however, developers still find it difficult to calculate the duration for a cache as it is usually in seconds.

For example, say we want to store a user data for 24 hours:

<?php
$duration = 24 * 60 * 60; // 24 hours

Redis::cache($userData, $duration);

From the snippet above, you would notice that for better readability, we had to set the $duration variable to a break down of the number of hours in seconds. Additionally, we included a comment that explains what the value is.

Seems too tacky for something as basic as calculating time in seconds. What if there was a better way, what if we could replace the above snippet with something like this:

<?php
use Ajimoti\CacheDuration\Duration;

Redis::cache($userData, Duration::twentyFourHours());

This is more readable compared to the previous snippet. We have changed the complex $duration variable value, and replaced it with a better readable method. Additionally, another developer going through the code does not have to worry about calculating the cache duration as the method name is self explanatory.

In this article, I will be talking about a package that provides a readable and fluent way to generate cache durations for your PHP applications.

Installation

The first step is to install the package. You can install the package from composer using the script below:

composer require ajimoti/cache-duration --with-all-dependencies

After installation, import the Duration trait inside your class, then you are set.

<?php
require 'vendor/autoload.php';

use Ajimoti\CacheDuration\Duration;

var_dump(Duration::fourtyMinutes()); // returns 2400;
var_dump(Duration::tenHours()); // returns 36000;
var_dump(Duration::fiftyFourDays()); // returns 4665600;

The Duration trait provides a fluent way to generate cache durations. In order to achieve this, make a static call of a number in words (must be in camelCase), followed by the time unit (either Seconds, Minutes, Hours or Days).

How it works

The Duration trait uses PHP __callStatic() magic method to allow you make dynamic calls.

For example, you want to get the number of seconds in 37 days, you can achieve this by calling a camel case text of the number in words (thirtySeven in this case), followed by the unit in title case (Days in this case).

That should leave us with something like this:

<?php

Duration::thirtySevenDays(); // returns the number of seconds in 37 days

Note: The number in words MUST be in camel case. Any other case will throw an InvalidArgumentException. Additionally, it must be followed by the unit in title-case. The available units are Seconds, Minutes, Hours, and Days.

Other Available Methods

In addition to this, the following methods are made available for use:

`seconds($value)`

Get duration in seconds. It basically returns the same value passed into it.

<?php
use Ajimoti\CacheDuration\Duration;

$cacheDuration = Duration::seconds(30); // returns 30

// or dynamically
$cacheDuration = Duration::thirtySeconds(); // returns 30

`minutes($value)`

Converts time in minutes into seconds.

<?php
use Ajimoti\CacheDuration\Duration;

$cacheDuration = Duration::minutes(55); // returns 55 minutes in seconds (55 * 60)

// or dynamically
$cacheDuration = Duration::fiftyFiveMinutes(); // returns 55 minutes in seconds (55 * 60)

`hours($value)`

Converts time in hours into seconds.

<?php
use Ajimoti\CacheDuration\Duration;

$cacheDuration = Duration::hours(7); // returns 7 hours in seconds (7 * 60 * 60)

// or dynamically
$cacheDuration = Duration::sevenHours(); // returns 7 hours in seconds (7 * 60 * 60)

`days($value)`

Converts time in days into seconds.

<?php
use Ajimoti\CacheDuration\Duration;

$cacheDuration = Duration::days(22); // returns 22 days in seconds (22 * 24 * 60 * 60)

// or dynamically
$cacheDuration = Duration::twentyTwoDays(); // returns 22 days in seconds (22 * 24 * 60 * 60)

`at($value)`

This method allows you to convert a Carbon\Carbon instance, DateTime instance or string of date into seconds.

It returns the difference in seconds between the argument passed and the current timestamp.

The date passed into this method MUST be a date in the future. Similarly, when a string is passed, the text MUST be compatible with Carbon::parse() method, else an exception will be thrown

Examples

<?php
use Date;
use Carbon\Carbon;
use Ajimoti\CacheDuration\Duration;

// Carbon instance
$cacheDuration = Duration::at(Carbon::now()->addMonths(3)); // returns time in seconds between the present timestamp and three months time

// Datetime instance
$cacheDuration = Duration::at(new DateTime('2039-09-30')); // returns time in seconds between the present timestamp and the date passed (2039-09-30).

// String
$cacheDuration = Duration::at('first day of January 2023'); // returns time in seconds between the present timestamp and the first of January 2023.

And that's it

If you find this useful, feel free to star ⭐️ or fork the repository .

Thanks for reading.

Laravel dynamic roles and permissions package

Ajimoti Ibukun — Thu, 13 Jan 2022 20:27:56 +0000

Introduction

Roles and permissions are an important part of most applications, and as a result there has been a lot of packages built to make it easier for developers to implement.

The most popular Laravel roles-and-permissions package built by Spatie has proven to solve most roles-and-permissions related problems, except a few parts:

Role hierarchy
Roles and permissions on a pivot table (many-to-many relationship)

In this post, I will talk about a Laravel package that allows you to assign roles and permissions to any Laravel model, or on a pivot table (many to many relationships), and also solves most of the problems highlighted above.

Basic usage

Before diving in, here is a basic illustration of how it can be used.

// Assign a 'Super Admin' role to this user
$user->assign(Role::SuperAdmin);

// Check the user role 
$user->isSuperAdmin(); // or 
$user->hasRole(Role::SuperAdmin);

// Check if the user can perform the operation
$user->canDeleteTransactions(); // or
$user->can(Permission::DeleteTransactions);

// Check if the user has multiple permissions
$user->holds(Permission::DeleteTransactions, Permission::BlockUsers);

Roles and permissions on many-to-many relationship (pivot table)

// Assign a 'Super Admin' role to this user on the selected model
$user->of($merchant)->assign(Role::SuperAdmin);

// Or check the user role like this
$user->of($merchant)->isSuperAdmin();  // or
$user->of($merchant)->hasRole(Role::SuperAdmin); 

// Check if the user can 'delete transactions' on the selected model
$user->of($merchant)->canDeleteTransactions(); // or
$user->of($merchant)->can(Permission::DeleteTransactions); 

// Check if the user has multiple permissions on the selected model
$user->of($merchant)->holds(Permission::DeleteTransactions, Permission::BlockUsers);

Installation

You can install the package via composer:

composer require ajimoti/roles-and-permissions

Once the package has been installed, run the command below, and you are set to use the package.

php artisan roles:install

Explanation

After installing the package, the following files are being made available to your application

Ajimoti\RolesAndPermissions\HasRoles trait,
app\Enums\Role.php
app\Enums\Permission.php

This trait should be imported to the eloquent model you would like to assign roles and permissions to. Below is a sample of how the import and use the trait:

use Illuminate\Foundation\Auth\User as Authenticatable;
use Ajimoti\RolesAndPermissions\HasRoles;

class User extends Authenticatable
{
    use HasRoles;
    // ...
}

Roles Declaration (`app\Enums\Role.php`)

This file is used when validating roles and permissions. You are expected to declare the roles available on this file, and assign permissions to them in the permissions() method.

Below is a sample of what the role class can look like:

<?php

namespace App\Enums;

use Ajimoti\RolesAndPermissions\Helpers\BaseRole;

final class Role extends BaseRole
{
    const SuperAdmin = 'super_admin';
    const Admin = 'admin';
    const Customer = 'customer';

    public static $useHierarchy = true;

    /**
    * Set available roles and their permissions.
    *
    * @return array
    */
    final public static function permissions(): array
    {
        return [
            self::SuperAdmin  => [
                Permission::DeleteProducts, 
                Permission::DeleteTransactions, 
                Permission::ViewTransactions,
            ],

            self::Admin  => [
                Permission::EditProducts, 
                Permission::CreateProducts, 
            ],

            self::Customer  => [
                Permission::BuyProducts,
            ],
        ];
    }
}

From the above class, the SuperAdmin, Admin and Customer constants are the declared roles, and as you can see, each role has been assigned permissions in the permissions() method.

Additionally, the role class has a $useHierarchy property set to true which means that the higher roles should inherit the permissions of their respective lower roles. As a result, the SuperAdmin role is known to be the highest level role because it is the first constant declared in the class, while the Customer role is believed to be the lowest level role as it appears last.

SuperAdmin > Admin > Customer

Hence, the SuperAdmin role has inherited every other role permission,

Their permissions are as follows

Role	Permissions
`SuperAdmin`	Delete products, Delete transactions, View transactions, Edit products, Create products, Buy products
`Admin`	Edit products, Create products, Buy products
`Customer`	Buy products

You can read the official documentation to better understand the Permission class

Available methods

The example below explains some of the methods available on a model after installation.

use App\Enums\Role;
use App\Enums\Permission;

// Assign a 'Super Admin' role to this user
$user->assign(Role::SuperAdmin);

// Check if the user has the role
$user->hasRole(Role::SuperAdmin);

// Or check the user role like this
// $model->is{role_key}();
$user->isSuperAdmin();

// Check if the user can perform a operation
$user->can(Permission::DeleteTransactions);

// Or check if the user can perform the operation like this:
// $model->can{permission_key}();
$user->canDeleteTransactions();

// Check if the user has multiple permissions
$user->holds(Permission::DeleteTransactions, Permission::BlockUsers);

// Give a user a permission directly
$user->give(Permission::DeleteTransactions); // the user now has this permission

Roles and permissions on a many-to-many relationship (Pivot table)

Using the package on a many-to-many relationship is slightly different from using it on a normal model. The following are required for the package to work correctly on a many-to-many relationship:

A pivot table is needed
The pivot table MUST have a role column. This column will be used to keep track of the role assigned to the relationship. (if you want to use a different column name, you can set this in the config file).
A belongsToMany relationship for the pivot table must exist on one of the models.

Quick sample

The first step is to import the Ajimoti\RolesAndPermissions\HasRoles trait and have a belongs-to-many relationship on the model.

Let's assume we are building an application that allows merchants to manage their users, additionally, a user can be a member of many merchants, i.e a merchant has many users.

Hence we have a database structure like this:

users
    id - integer
    name - string

merchant
    id - integer
    name - string

merchant_user (the pivot table)
    merchant_id - integer
    user_id - integer
    role - string (nullable)

From the above database structure, here is an illustration of what the user model should look like:

use Illuminate\Foundation\Auth\User as Authenticatable;
use Ajimoti\RolesAndPermissions\HasRoles;

class User extends Authenticatable
{
    use HasRoles;

    // ...
    public function merchants()
    {
        return $this->belongsToMany(Merchant::class);
    }
    // ...
}

After doing the above, the HasRole trait provides an of() method that can be used to perform roles and permissions related logic between two models via the belongs to many relationships.

Usage

For the examples below, we would assume the variable $merchant is set to a merchant with name wallmart like so:

$merchant = Merchant::where('name', 'wallmart')->first();

use App\Enums\Role;
use App\Enums\Permission;

// Sample merchant
$merchant = Merchant::where('name', 'wallmart')->first();

// Assign a 'Super Admin' role to this user on the selected merchant (wallmart)
$user->of($merchant)->assign(Role::SuperAdmin);

// Check if the user has a super admin role on the selected merchant (wallmart)
$user->of($merchant)->hasRole(Role::SuperAdmin);

// Or check the user role like this
// $user->of($model)->is{role_key}();
$user->of($merchant)->isSuperAdmin();

// Check if the user can 'delete transactions' on the selected merchant (wallmart)
$user->of($merchant)->can(Permission::DeleteTransactions);

// Or check if the user can has the permissions like this
// $user->of($model)->can{permission_key}();
$user->of($merchant)->canDeleteTransactions();

// Check if the user has multiple permissions on the selected merchant (wallmart)
$user->of($merchant)->holds(Permission::DeleteTransactions, Permission::BlockUsers);

This is just a summary of a few things you can do with the package, a few other features still exists on the documentation.

Finally

If you find this useful, or you are searching for a package that supports roles and permissions on a many-to-many relationship, roles in hierarchy, or declaration of roles and permissions as enum constants, this is the package to work with.

Running laravel queue worker on two different applications that share the same database

Ajimoti Ibukun — Sun, 10 Nov 2019 21:06:19 +0000

Prerequisites

PHP
LARAVEL

NOTE: If you already understand laravel queues, and you're not interested in stories, go straight to the second heading.

"Queues are used to delay time-consuming tasks until a later time" - larashout.com

Why use Laravel Queues?

Queues are set up for better user experience, they are used to make time-consuming tasks run in the background while the user gets to move on to something else, not having to wait till the end of these tasks.

For example, say you are building an application that allows a store owner send a promotional email to all their users; and it takes approximately two(2) seconds to send said email to one user, imagine how long the store owner would have to wait to send the email to a thousand users.

Quick maths: The total estimated time would be the number of users (say N), multiplied by two seconds (N x 2s), so we have 1000 x 2s = 2000s. Meaning the store owner would have to wait for 2000seconds (approximately 33.3 minutes) to reach a thousand users before getting a response, which is not great. Now think of how long it'd take to reach five thousand or ten thousand users.

This is where queues come in, Laravel queues pick all the action that you need to be carried out, store them on a driver with a predefined delay time set by the developer, returns a response to the user, then proceeds to dispatch the queues on the server without interfering with the user's activities.

Let me rephrase the previous paragraph to fit our store example, Laravel queue picks the customers email addresses selected by the store owner, stores them on a drive as a job with a predefined delay time set by the developer, returns a response to the store owner, then proceeds to dispatch the emails in the background at the set predefined time. The dispatch is done on the server without interfering with other activities the store owner might be doing on the application.

Below is a code sample that enables the store owner to send promotional emails using a queue.

$emailJob = new SendPromotionalEmail()->delay(Carbon::now()->addMinutes(5));
dispatch($emailJob);

Before the above code can work, there has to be a queue worker running. Here is what a queue worker does: A queue worker checks the driver for any pending jobs, and execute them. In this case, SendPromotionalEmail() is a job that would be stored on the drive waiting to be executed by the queue worker.

To run a queue worker, run the following command on your terminal.

php artisan queue:work

If you have read to this point, and still don't understand what queues are or what they are meant to do, you should read the queues section of the Laravel documentation for a better understanding and how to set them up.

Diving straight to the Point

You might be wondering why you would want to run a queue worker on two different applications that share the same database, I recently ran into a situation like this, and spent hours trying to debug the issue before realizing the problem.

PS: In this example below, I used database as the queue driver.

Let's use the ride-hailing company Uber as an example, Say we built an application like Uber using laravel, but this time we built two different applications, the riders' version, and the drivers' version, and made both share the same database instead of using an API. (this example is a bad idea, but it's the best fit for this topic).

Building applications this big will require running queues in the background to carry out the time-consuming tasks, so we would have a queue worker running on both applications using the command:

php artisan queue:work

The above command will constantly check the jobs table on the database and executes any pending job it finds. Now here is the problem, since we have this command (the queue worker) running on both applications, there are times the riders queue worker will try to execute jobs that belong to the drivers' application, and vice versa depending on which queue worker hits the database first. And here's what happens whenever a queue worker tries to run a job that doesn't belong to it, the job would be executed but fails instantly because of its codebase differs from the job payload.

To solve this, we would have to customize our queue worker to only process particular queues on each of our application and to do this the jobs should be dispatched with a name using something like this
->onQueue('name_here'); and the queue worker should run on both apps with their respective names.

Going by the explanation above, here's what the code would look like on the riders app

$emailJob = new EmailNotification()->delay(Carbon::now()->addMinutes(5));
dispatch($emailJob)->onQueue('UberRiders');

Now that we have categorized the rider jobs, the queue worker should run with a flag indicating that it only runs the UberRiders jobs, so we have something like this:

php artisan queue:work database --queue=UberRiders

instead of using the below default command:

php artisan queue:work

The same thing would be done on the drivers laravel app, so we have something like this:

$emailJob = new EmailNotification()->delay(Carbon::now()->addMinutes(5));
dispatch($emailJob)->onQueue('UberDrivers');

And the queue worker looks like this

php artisan queue:work database --queue=UberDrivers

For practical examples about laravel queues, you can read about queues, and how they work here.

Conclusion

The best way to go about this is to build a central API and have both applications connect to them, that way you wouldn't have to bother yourself about running different queue workers on the same database, but if you find yourself in this type of issue, this should help you fix the issue.

DEV Community: Ajimoti Ibukun

Calculate cache time with ease in PHP

Introduction

Installation

How it works

Other Available Methods

seconds($value)

minutes($value)

hours($value)

days($value)

at($value)

Examples

And that's it

Laravel dynamic roles and permissions package

Introduction

Basic usage

Roles and permissions on many-to-many relationship (pivot table)

Installation

Explanation

Roles Declaration (app\Enums\Role.php)

Available methods

Roles and permissions on a many-to-many relationship (Pivot table)

Quick sample

Usage

Finally

Running laravel queue worker on two different applications that share the same database

Prerequisites

Why use Laravel Queues?

Diving straight to the Point

Conclusion

`seconds($value)`

`minutes($value)`

`hours($value)`

`days($value)`

`at($value)`

Roles Declaration (`app\Enums\Role.php`)