DEV Community: Sesha

Integrating Google reCAPTCHA with Laravel, Inertia JS and Vue 3.

Sesha — Mon, 17 Jan 2022 17:04:12 +0000

I will show you how to add the Google reCAPTCHA version 3 with Laravel with a few simple steps.

I assume you already installed Laravel with Jetstream, InertiaJS and Vue3. If not, this link will help you to install.

Setup 1:

Configure those values in the config services.php file for better accessibility and management.


 'google_recaptcha' => [
   'url' => 'https://www.google.com/recaptcha/api/siteverify',
   'site_key' => env('GOOGLE_RECAPTCHA_SITE_KEY'),
   'secret_key' => env('GOOGLE_RECAPTCHA_SECRET_SITE_KEY'),
 ]

To access the reCAPTCHA site key in the frontend, share through the HandleInertiaRequest file. Directly mentioning the site key in the front end isn't a great idea.

 public function share(Request $request)
 {
     return array_merge(parent::share($request), [
      'recaptcha_site_key' => config('services.google_recaptcha.site_key'),
     ]);
 }

Setup 2:

Install Vue recaptcha v3 and import in app.js file.

import { VueReCaptcha, useReCaptcha } from 'vue-recaptcha-v3'
...


createInertiaApp({
  title: (title) => `${title} - ${appName}`,
  resolve: (name) => require(`./Pages/${name}.vue`),
  setup({ el, app, props, plugin }) {
    const captcheKey = props.initialPage.props.recaptcha_site_key;
    return createApp({ render: () => h(app, props) })
      .use(plugin)
      .use(VueReCaptcha, { siteKey: captcheKey } )
      .mixin({ methods: { route } })
      .mount(el)
  },
})

Step 3:

To add Google reCAPTCHA to the form. Here, I used a sample form to demonstrate the Google reCAPTCHA with Vue 3 composition API.

<form action="#" method="POST"  @submit.prevent="recaptcha">
   ...

   <jet-input-error :message="form.errors.captcha_token" class="mt-2" />
</form>

<script>
import { useForm } from '@inertiajs/inertia-vue3'
import { useReCaptcha } from "vue-recaptcha-v3";


export default {

  setup() {

    const form = useForm({
      name: null,
      email: null,
      phone: null,
      message: null,
      captcha_token :null,
    })

    const { executeRecaptcha, recaptchaLoaded } = useReCaptcha()
    const recaptcha = async () => {
      await recaptchaLoaded()
      form.captcha_token = await executeRecaptcha('login')
      submit();
    }

    function submit() {
      form.post(route('contact-us.store'), {
        preserveScroll: true,
        onSuccess: () => console.log('success'),
      })
    }

    return {
      form, submit ,recaptcha,
    }
  },
}


</script>

Step 4

Create a Laravel custom rule to verify the token and score. Here, I rejected the form if the score <= 0.5 and status was not equals to true.

<?php

namespace App\Rules;

use Illuminate\Support\Facades\Http;
use Illuminate\Contracts\Validation\Rule;

class Recaptcha implements Rule
{
    /**
     * Create a new rule instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }

    /**
     * Determine if the validation rule passes.
     *
     * @param  string  $attribute
     * @param  mixed  $value
     * @return bool
     */
    public function passes($attribute, $value)
    {
        $endpoint = config('services.google_recaptcha');

        $response = Http::asForm()->post($endpoint['url'], [
            'secret' => $endpoint['secret_key'],
            'response' => $value,
        ])->json();

        if(  $response['success'] && $response['score'] > 0.5) {
            return true;
        }

        return false;
    }

    /**
     * Get the validation error message.
     *
     * @return string
     */
    public function message()
    {
        return 'Something goes wrong. Please contact us directly through the phone or email.';
    }
}

Finally, add in the controller to validate the input request along with reCAPTCHA token.

use Illuminate\Support\Facades\Request;
use Illuminate\Support\Facades\Redirect;
use App\Rules\Recaptcha;

...

public function store() {
 $contact = Contact::create(
   Request::validate([
     'name' => ['required', 'max:50'],
     'email' => ['required', 'max:100','email'],
     'phone' => ['nullable', 'max:13'],
     'message' => ['required', 'max:2000'],
     'captcha_token'  => [new Recaptcha],
    ])
  );  

 return Redirect::route('contact-us');   

}

I hope, this tutorial helps you to integrate Google reCAPTCHA 3 with Laravel. Please let me know if it doesn't work for you.

Thank you.

Extremely competitive pricing Uptime monitoring tool

Sesha — Wed, 07 Jul 2021 10:31:29 +0000

What Statusping has to offer:?

Here is what Statusping has to offer: Uptime Monitoring, SSL Certificate Monitoring Performance Monitoring, and unlimited public/private status pages. Enjoy deeper control with String and Status code check, and also Monitor URLs with Custom Headers and basic authentication.

Receive notification wherever you are

StatusPing offers integration with Email, Slack, Twilio, Teams, and Webhook to receive instant downtime notifications. We will also be working on a few other notification channels.

Here, the limited 20% offer. Use 08DFDC93 coupon code on checkout page.

To register : Statusping

Add Snooze functionality to Notification channels.

Sesha — Thu, 17 Jun 2021 06:51:39 +0000

The simple way to add snooze functionality to your notification channels in your Laravel application.


use Carbon\Carbon;

class SnoozeData
{
    public Carbon $snooze_until;

    public function __construct(
        public int $duration,
        public string $type,
    ) {
        $this->getSnoozeUntilTime();
    }

    private function getSnoozeUntilTime(): void
    {
        $time = Carbon::now();

        $this->snooze_until = match ($this->type) {
            'minutes' => $time->addMinutes($this->duration),
            'hours' => $time->addHours($this->duration),
            'days' => $time->addDays($this->duration),
            'weeks' => $time->addWeeks($this->duration),
            default => $time,
        };
    }
}

$details = new SnoozeData(...Request::validate([
   'duration' => ['required', 'integer', 'between:0,1000'],
   'type' => ['required', 'string'],
]));


$notifyUser->update([
  'snooze_until' => $details->snooze_until,
]);

Easy way to Generate and Validate OTP in the Laravel

Sesha — Mon, 21 Dec 2020 12:52:52 +0000

In this post I will show how to generate and validate the OTP (One Time Password) using a simple Laravel package. https://github.com/seshac/otp-generator.

So, Let's start and follow below three simple steps.

You can generate OTP using any unique identification (Prefer Mobile number or Email),
Send to end user using any notification provider
Finally, verify using the same unique identification.

Installation and Setup process :

Installation

You can install the package via composer:

composer require seshac/otp-generator

You can publish and run the migrations with:

php artisan vendor:publish --provider="Seshac\Otp\OtpServiceProvider" --tag="migrations"
php artisan migrate

You can publish the config file with:

php artisan vendor:publish --provider="Seshac\Otp\OtpServiceProvider" --tag="config"

Once you published you can configure all otp-generator.php config values based on your requirements.

Usage

use Seshac\Otp\Otp;
.
.
$otp =  Otp::generate($identifier);
.
$verify = Otp::validate($identifier, $otp->token);
// response
{
  "status": true
  "message": "OTP is valid"
}

You have control to update the setting at otp-generator.php config file, but you control while generating also

Advance Usage

use Seshac\Otp\Otp;
.
.
$otp =  Otp::setValidity(30)  // otp validity time in mins
      ->setLength(4)  // Lenght of the generated otp
      ->setMaximumOtpsAllowed(10) // Number of times allowed to regenerate otps
      ->setOnlyDigits(false)  // generated otp contains mixed characters ex:ad2312
      ->setUseSameToken(true) // if you re-generate OTP, you will get same token
      ->generate($identifier);
.
$verify = Otp::setAllowedAttempts(10) // number of times they can allow to attempt with wrong token
    ->validate($identifier, $otp->token);

Here the GitHub repository https://github.com/seshac/otp-generator

If you find any issues, please, feel to free open an issue here.
https://github.com/seshac/otp-generator/issues

Upgrade to PHP 8.x.0-dev with Homebrew on Mac

Sesha — Sun, 15 Nov 2020 15:44:44 +0000

Now, PHP 8.0.0 Release Candidate 4 available for testing, It's expected to release on November 26, 2020, It's a new major version, and a lot of improvements and new features.

Here, step by step process to install PHP 8.0.0-dev with Homebrew on Mac.

Make sure brew up to date with the following command

  brew update

At the time of writing this article, brew doesn't support php8, So we install using this git repo

Add the tap

Fetch the formulae in this tap.

brew tap shivammathur/php

Install PHP 8.0

brew install shivammathur/php/php@8.0

and finally, link with PHP 8.0

brew link --overwrite --force php@7.3

Check the current version by running PHP -v:

PHP -v

And restart the Restart Nginx or Apache:

sudo nginx -s reload

//or 

sudo apachectl restart

And also you check your local web server using the current version by running the following script.

// create index.php file, this should be accessible to your web server

phpinfo(); die();

Switching between versions.

If you want to switch back to PHP 7.4, here you can do that.

Unlink the current version like this

brew unlink PHP

and link to PHP 7.4

 brew link --overwrite --force php@7.4

if you want to link to PHP 7.3

 brew link --overwrite --force php@7.3

If you like, please like and follow me to do more like this. Thank you!.

What's new in PHP 8

Sesha — Sun, 15 Nov 2020 13:37:30 +0000

Index

Null Safe Operator
Union Types
Match Expression
Constructor Property promotion
$object::class
Named Arguments
New PHP Functions
Attributes v2
Weak Maps
Throw Expression
Trailing Comma in Parameter List
Incompatible Method Signatures
Arrays Starting With a Negative Index
Validation for Abstract Trait Methods
Mixed Type
Non-Capturing Catches
Inheritance with private methods
JIT Complier
Breaking Changes and Depreciations

Nullsafe operator

Greatly improve the readability of the code, Instead of writing several 'If statements' you can use the “?” operator to write all those in just 1 line of code. RFC..

class Book {
  public function comments() {
    return new Comments;  //or return null
  }
}

class Comments {
  public function get() {
    return [ 
      'title' => 'My first comment'
    ];
  }
}

$book  = new Book();

// PHP8.x
$book->comments()?->get();

// php7.x
if($book->comments()) {
  $book->comments()->get();
}

Union Types 2.0

PHP is a dynamically typed structure, So union types are very useful in a lot of places.

Union types are specified using the syntax T1|T2|... and can be used in all positions where types are currently accepted.
RFC..

// in PHP7.x
class Order {
  /**
   * @var int|float $total
   */
  private $total;

  /**
   * @param int|float $total
   */
  public function setTotal($total) {
    $this->total = $total;
  }

  /**
   * @return int|float
   */
  public function getTotal() {
    return $this->total;
  }
}

//php8
class Order {
  private int|float $total;

  public function setTotal(int|float $total) : void {
    $this->total = $total;
  }

  public function getTotal() : int|float {
    return $this->total;
  }

}

// $order =  new Order();
// $order->setTotal(100);
// var_dump($order->getTotal());

Match Expression

Does match expression replace the switch?. The match can return values, doesn't require lengthy statements like a switch. It uses strict type comparison and doesn't do any type coercion. RFC..

//The switch statement loosely compares (==) the given value to the case values. This can lead to some very surprising results.
switch ('100') {
  case 100:
    $price = "Oh no!";
    break;
  case '100':
    $price = "This is what I expected";
    break;
}
echo $price;
///> Oh no!

//The match expression uses strict comparison (===) instead. The comparison is strict regardless of strict_types.
echo match ('100') {
  100 => "Oh no!",
  '100' => "This is what I expected",
};
//> This is what I expected

Constructor Property promotion

Why do we need to write a lot of boilerplate? This constructor property promotion helps to promote properties that are shorter, more readable, and less prone to errors. Consider the following simple example to understand more. RFC ..

// in PHP 7.x
class Product {
  protected $price;
  public function __construct($price) {
    $this->price = $price;
  }
}

class Customer {
  protected $name;
  public function __construct($name) {
    $this->name = $name;
  }
}

class Order {
  protected $product;
  protected $customer;
  public function __construct($product, $customer){
    $this->product = $product;
    $this->customer = $customer;
  }
}


// You can write like this in PHP8
class Product {
  public function __construct(protected string $price) {
  }
}

class Customer {
  public function __construct(protected string $name){
  }
}

class Order {
  public function __construct(
  protected Product $product,
  protected Customer $customer) {
  }
}

// $product = new Product('IPhone 12');
// $customer  = new Customer('your name');
// $order = new Order($product, $customer);
// var_dump($order);

So easy right?

$object::class Syntax

The $object::class used to fetch the name of the class of a given object. $object::class provides the same result as get class($object). If $object is not an object, it throws a TypeError exception. RFC..

class Product{};

$class = match (Product::class)  {
  'Product' => 'Product class',
  'Other' => 'Other class'
};
echo $class; //> Product class
// If Object is null thrown a typeError
$object = null;
var_dump($object::class); // TypeError

Named Arguments

It was a close call but named arguments also called named parameters, it has both ins and outs but for me, they will allow us to write more cleaner and better code. RFC...

Here how they will work,

class Log {

  public function __construct(
      private string $title, 
      private string|null $description, 
      private string $type ) {

  }
}

$log = new Log (
  title : 'New Support request',
  description : 'You received a new support ...',
  type: 'support',
);

// even you can write something like these
$log = new Log (
  title : 'New Support request',
  type: 'support',
);

// but without this we need to write something like these
$log = new Log (
  'New Support request',
  '',
  'support',
);

PHP New Functions

Here the list of the new functions,
1.str_contains
2.str_start_with
3.str_ends_with
4.get_debug_type

Str_contains

 str_contains ( string $haystack , string $needle ) : bool

It checks the needle found in the haystack and returns the boolean.

if (str_contains('This is my first blog', 'blog')) {
  echo 'blog has been found';
}

//in PHP 7.x
 if (strpos('This is my first blog post', 'blog') !== false) { 
     echo 'blog is has been found';
 }

str_start_with

It checks the given haystack starts with the needle.

str_starts_with (string $haystack , string $needle) : bool

//example
if (str_starts_with('This is my first blog post', "this")) { 
   echo "it is started with 'this'";
}

str_ends_with

It checks the given haystack ends with the needle.

str_ends_with (string $haystack , string $needle) : bool

//example
if (str_ends_with('This is my first blog post', "post")) { 
   echo "it is ended with 'post'";
}

get_debug_type

It's pretty straight forward just returns the type of the variable.
Here an example.

class Book {}

class Comments {}

$book = new Book();

// earlier 
if(! ($book instanceof Comment)) {
  echo 'Expected ' .  Comment::class . ' but got the ' .  (is_object($book) ? get_class($book) : gettype($book));
}

//in PHP8
if(! ($book instanceof Comment)) {
  echo 'Expected ' .  Comment::class . ' but got the ' .  get_debug_type($book);;
}

Attributes v2

Attributes are known as the annotations in many other languages, it's to add metadata to classes, methods, variables, parameters, and constants. without having a parse doc block. RFC....

Weak Maps

It's used for storing references, It allows us to create a map from objects to arbitrary values without preventing the objects that are used as keys from being garbage collected

In long-running processes, this would prevent memory leaks and improve performance. See the following example from the RFC:

Here is an example.

class Population{
}

class Country {
  protected WeakMap $total;

  public function __construct() {
    $this->total = new WeakMap();
  }
  public function IncrementPopulation(Population $pop) :void {
    $this->total[$pop] ??= 0;
    $this->total[$pop]++;
  }
}

$population = new Population();
$country = new Country();

$country->IncrementPopulation($population);
$country->IncrementPopulation($population);
var_dump($country)

Throw Expression

This RFC Change throw from being a statement to being an expression. Earlier we can't able to use this one in some places like arrow functions, the coalesce operator, and the ternary/elvis operator because in these places only expressions are allowed.

Here is an example from RFC.

$callable = fn() => throw new Exception();

// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();

// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();

Trailing Comma in Parameter List

PHP 8 allows an optional trailing comma in the parameter list. This includes parameter lists for functions, methods, and closures. for more..
Here a simple example.

class Comment {
  public function __construct(
   string $titla,
   string $description,
   int $status, // trailing comma
 ) {
   // do something
 }
}

Incompatible Method Signatures

Now, this RFC proposes to always throw a fatal error for incompatible method signatures.

Consider the a following simple example:

class Product {
 public function get(string $price) {}
}
class SubProduct extends Product {
 public function get(int $price) {}
}

In PHP 7.4, the code above would simply throw a warning:

Warning: Declaration of SubProduct::get(int $price) should be compatible with Product::get(string $price) in /path/to/your/index.php on line 7

With PHP 8, It throws a fatal error

Fatal error:  Declaration of SubProduct::get(int $price) must be compatible with Product::get(string $price) in /path/to/your/index.php on line 7

Arrays Starting With a Negative Index

Now, this RFC proposes the second index would be start_index + 1

Consider the following example.

$book = array_fill(-4, 6, 'title');
var_dump($book);
//output 
array(6) {
  [-4]=>
  string(5) "title"
  [-3]=>
  string(5) "title"
  [-2]=>
  string(5) "title"
  [-1]=>
  string(5) "title"
  [0]=>
  string(5) "title"
  [1]=>
  string(5) "title"
}

// In PHP 7.4 like these
//output 
array(6) {
  [-4]=>
  string(5) "title"
  [0]=>
  string(5) "title"
  [1]=>
  string(5) "title"
  [2]=>
  string(5) "title"
  [3]=>
  string(5) "title"
  [4]=>
  string(5) "title"
}
=> null

Validation for Abstract Trait Methods

Now this RFC proposes to throw a fatal error if the implementing method is not compatible with the abstract trait method.

trait Sluggable {
  abstract public function slug(string $title);
}
class Page {
  use Sluggable;
  // Allowed, but shouldn't be due to invalid type.
  public function slug(int $x) {}
}

// Output
//Fatal error: Declaration of Page::slug(int $x) must be compatible with Sluggable::slug(string $title) in /php8/index.php on line 9

Mixed Type

Mixed type is a good addition to php8 type system. It is equivalent to one of these types.

  array|bool|callable|int|float|null|object|resource|string

LSP, Covariance and Contravariance

The below things we need to consider

Be careful when using mixed type because Parameter types are contravariant.

Parameter type was widened from int to mixed, this is allowed in LSP.

// Valid Example
class Project {
    public function title(string $title) {}
}

class Task extends Project {
    // Parameter type was widened from int to mixed, this is allowed
    public function title(mixed $title) {}
}

A parameter type may not be narrowed in a subclass to a more specific type as this is not contravariant and so violates LSP.

// Invalid Example
class Project {
  public function title(mixed $title) {}
}

class Task extends Project {
  // Parameter type cannot be narrowed from mixed to string
  // Fatal error thrown
  public function title(string $title) {}
}

Return types are covariant

// Valid Example
class Project {
  public function title(string $title) :mixed { }
}

class Task extends Project {
  // return type was narrowed from mixed to string, this is allowed 
  public function title(string $title) :string {}
}

// Invalid Example
class Project {
  public function title(string $title)  :string {}
}

class Task extends Project {
  // the return type cannot be widened from string to mixed
  // Fatal error thrown
  public function title(string $title) :mixed  {}
}

Property types are invariant

class Project {
  public mixed $title;
  public string $description;
  public $priority;
  public int  $points;
}

class Task extends Project {
  // property type cannot be narrowed from mixed to string
  // Fatal error thrown
  public string $title;

  // property type cannot be widened from string to mixed
  // Fatal error thrown
  public mixed  $description;

  // property type cannot be added
  // Fatal error thrown
  public int $priority;

  // property type cannot be removed
  // Fatal error thrown
  public  $points;
}

And finally, one more thing to remember:
// Fatal error: Mixed types cannot be nullable, null is already part of the mixed type.

function book(): ?mixed {}

You can read more from the RFC

Non-Capturing Catches

Before PHP 8, requires to capture the exception being caught to Variable, regardless of whether you used that variable or not.

//Before PHP 8
try {
    AddUser();
} catch (PermissionException $ex) {
    echo "You don't have permission to add user";
}

Above, you need to specify the $ex variable even if it's not used.
In PHP 8, you can do that one easily without using $variable

//PHP 8
try {
    AddUser();
} catch (PermissionException) {   //The intention is clear: exception details are irrelevant
    echo "You don't have permission to add user";
}

Inheritance with private methods

This RFC remove inappropriate inheritance signature checks on private methods.
It doesn't make sense because the private method won't able to access by child classes. So applying the same signature rules for all public, protected, and private methods not good. So in PHP 8, the inheritance checks are not performed on private methods anymore.

class Product { 
    final private function slug() { 
        echo 'final  product slug';
    } 
} 

class Category extends Product { 
    private function slug() { 
        echo  'echo category slug ';
    } 
}
// before PHP 8 produces
// Fatal error: Cannot override final method Product::slug()

// In PHP 8 produce
$product = new Product(); 
$product->slug();  
//output : final  product slug

$category = new Category(); 
$category->slug();   //output : final category slug

And also using final on private methods doesn't make sense either so using the final keyword on private methods will trigger a warning.

Warning: Private methods cannot be final as they are never overridden by other classes in ...

JIT Compiler (Just in Time Compiler)

The most interesting feature coming with PHP 8 is the Just-in-time (JIT) compiler.

The RFC proposal describes JIT as follows:

“PHP JIT is implemented as an almost independent part of OPcache. It may be enabled/disabled at PHP compile-time and at run-time. When enabled, the native code of PHP files is stored in an additional region of the OPcache shared memory and op_array→opcodes[].handler(s) keep pointers to the entry points of JIT-ed code.”
I would like to write a separate post about JIT to explain more about It, So stay tuned for that!

Breaking Changes and Depreciation

PHP 8 is a major update and there will be some breaking changes. I'm writing a detailed post about breaking Changes and will be published soon. Please follow me on Twitter to know more about that.

Conclusion

I'm very excited and waiting for PHP 8 release. What an interesting improvement and a new feature in PHP 8, I hope you enjoyed this article, won't you.

Please, let me know your thoughts in the comment section.
If you like this and interested more about like, please follow me on Twitter