Forem: Yong Dev

FlyEnv: The All-in-One Tool That Could Replace Your Docker Workflow

Yong Dev — Fri, 16 Jan 2026 10:07:18 +0000

For the last decade, the local development narrative has been dominated by one giant: Docker. While containerization revolutionized how we deploy, it brought a heavy tax to local development, high RAM usage, battery drain, and the complexity of managing docker-compose.yml files for simple tasks.

Enter FlyEnv, a new contender that promises the convenience of legacy tools like XAMPP or Laragon, but with the power and modern stack support required by today’s full-stack developers.

Here is why this tool is turning heads in the developer community.

What is FlyEnv?

FlyEnv is a cross-platform (Windows, macOS, Linux) local environment manager. Unlike Docker, which relies on virtualization and containers, FlyEnv runs services as native static binaries.

Its goal is simple: eliminate the friction of setting up a development environment. Whether you need a specific version of PHP for a legacy client, the latest Go version for a side project, or a complex stack involving Redis, RabbitMQ, and PostgreSQL, FlyEnv manages it all through a unified GUI or CLI.

Key Features That Stand Out

1. Native Performance (No Virtualization)

The biggest selling point of FlyEnv is performance. Because it doesn't use containers, there is no virtualization overhead.

Startup: Services start instantly.
Resources: Running Nginx, MySQL, and PHP via FlyEnv reportedly consumes about one-third of the resources required by an equivalent Docker setup.
Battery Life: For developers working on laptops, avoiding the Docker engine background process can significantly extend battery life.

2. True "Polyglot" Support

Older tools like Laragon or MAMP were excellent for PHP but struggled when you needed to introduce Python or Node.js. FlyEnv treats all languages as first-class citizens. It supports:

Languages: PHP, Node.js, Java, Go, Python, Ruby, Rust, Bun, Deno, and Erlang.
Web Servers: Nginx, Apache, Caddy, Tomcat.
Databases: MySQL, MariaDB, PostgreSQL, MongoDB, Redis, Memcached.
Tools: Elasticsearch, Mailpit, RabbitMQ.

3. Project-Level Isolation & Version Management

One of the hardest things to manage locally is version conflict.

Project A requires Node 14 and PHP 7.4.
Project B requires Node 20 and PHP 8.3.

FlyEnv allows you to define these versions per project. When you switch directories in your terminal, FlyEnv can automatically switch the active binaries to match that project's requirements. You can even run different versions of the same language simultaneously on different ports.

4. Built-in Production Simulators

FlyEnv includes features that mimic production environments to reduce "it works on my machine" errors:

One-Click SSL: Instantly generate trusted self-signed certificates for HTTPS testing.
Local Domains: Easily map .test or .localhost domains to your projects without manually hacking your hosts file.

FlyEnv vs. Docker: Which Should You Use?

While FlyEnv is impressive, it is not a direct 1:1 replacement for Docker in all scenarios. Here is how to decide:

Use FlyEnv if:

You value speed: You want to code immediately without waiting for containers to build.
Hardware constraints: You are on a machine with 8GB or 16GB of RAM and can't afford to give 4GB to Docker.
You are a Full-Stack/Web Dev: You work primarily with web frameworks (Laravel, Django, Rails, Spring) and standard databases.
You hate config files: You prefer a GUI where you can just click "Start" on Redis and MySQL.

Stick with Docker if:

Strict Parity is vital: You need your local kernel/OS libraries to match production exactly (e.g., specific Linux distros).
Complex Microservices: You are running an architecture with 15+ different services that need complex networking orchestration.
Team Standardization: Your team relies on a shared Dockerfile to ensure every single developer has the exact same bits and bytes.

Conclusion

FlyEnv feels like the spiritual successor to tools like Laragon, but modernized for the 2020s. It bridges the gap between the "install everything manually" chaos and the "heavy virtualization" of Docker.

For freelancers, solo developers, and those working on standard web applications, FlyEnv offers a frictionless, lightweight, and incredibly fast development experience. It proves that sometimes, you don't need a container; you just need a better manager.

Adding TypingDNA Verify as a 2FA to your Auth0 login

Yong Dev — Thu, 09 Mar 2023 11:10:42 +0000

User authentication in web applications has become a major challenge in recent years. One-time passwords (OTPs), for example, are used to authenticate a user's identification; the most common means of delivering OTPs is by SMS to the user's registered cellphone number.

TypingDNA, on the other hand, substitutes the usual OTP through SMS with a unique four-word code. In this post, you'll learn how to utilize Auth0 and TypingDNA's Verify2FA to build two-factor authentication.
Prerequisite
To follow this tutorial, you need the following components:
PHP 7.4 (ideally 8.1) installed on your development machine with curl.
Composer globally installed.
A TypingDNA account. If you are new to TypingDNA, click here to create a free account.
An Auth0 account. If you are new to TypingDNA, click here to create a free account.
Ngrok to expose your local server.

Create the application’s directory.
Create and navigate into the project's root directory, labeled authxdna, by running the two commands below in a terminal.

mkdir  authxdna
cd authxdna

Install the required dependencies.

Now that the directory for the application has been created, it is time to install the external dependencies:

Library	Description
Guzzle	Guzzle is a PHP HTTP client that makes it easy to send HTTP requests and trivial to integrate with web services.
Psr7	PSR-7 message implementation that also provides common utility methods.
HTTP Factory Guzzle	An HTTP Factory using Guzzle PSR7
Auth0-php	This package handles API requests from your application to the Auth0 API endpoint.
PHPdotenv	This package combines variables defined in a`.env` file with PHP's `$_ENV` and `$_SERVER` Superglobals.
Simple PHP router	This is a simple and small single class PHP router that can handle the whole url routing for your project.

Run the command below in your terminal in the application’s root directory to install these dependencies.

composer require --with-all-dependencies \
    guzzlehttp/guzzle \
    guzzlehttp/psr7 \
    http-interop/http-factory-guzzle \
    auth0/auth0-php \
    steampixel/simple-php-router \
    vlucas/phpdotenv

This will add a vendor folder to your project and download all of the dependencies required to utilize the Auth0 PHP SDK. This will also generate a vendor/autoload.php file, which will be used to load all of the classes required for the application to run. It is essential that you include this autoload file in your project for the SDK to function properly.
Starting the Server
Since TypingDNA cannot interact with the localhost, we must expose our local server using ngrok. To do this, run this command below.

ngrok http 3000

This creates a bridge that exposes our local server to the web.

Our application will now be accessed via the link https://6b5b-105-112-60-199.ngrok.io (which would be different in your case, but make sure you use the HTTPS version).
!!!tip
If you try accessing the site, you might get a 502 bad gateway. This is because we haven’t set up our local server, which we will do much later.
!!!tip
Add the required environment variables.
Once the dependencies have been installed, create a new file called .env in the root directory of your application and paste the code below into it.

# The URL of your Auth0 tenant domain
AUTH0_DOMAIN=https://YOUR_DOMAIN
# Your Auth0 application's Client ID
AUTH0_CLIENT_ID=YOUR_AUTH0_CLIENT_ID
# Your Auth0 application's Client Secret
AUTH0_CLIENT_SECRET=YOUR_AUTH0_CLIENT_SECRET
# A long, secret value used to encrypt the session cookie.
# This can be generated using `openssl rand -hex 32` from your shell.
AUTH0_COOKIE_SECRET=YOUR_COOKIE_SECRET
# A URL your application is accessible from. Update this as appropriate.
AUTH0_BASE_URL=YOUR_NGROK_SERVER_ADDRESS
# Your TypingDNA application's Client Id
VERIFY_2FA_CLIENT_ID=YOUR_VERIFY_CLIENT_ID
# Your TypingDNA application's Client Secret
VERIFY_2FA_CLIENT_SECRET=YOUR_VERIFY_CLIENT_SECRET
# Your TypingDNA application's Id
VERIFY_2FA_APPLICATION_ID=YOUR_VERIFY_APPLICATION_ID

Following that, you would add the right value to their variable, which I will guide you through.

Configuring Auth0 and TypingDNA.
Open your Auth0 dashboard and you should find something similar to this.

Now click on the applications dropdown and select the applications link as aligned in the picture above. Click the create application button and a pop-up window appears.

Input the application name Authxdna Select the “Regular Web Applications” and click on the "Create" button.
You would then be greeted with a “Quick Start” tab. Navigate to the “Settings” tab.

You need the following information:
Domain
Client ID
Client Secret
Click on the copy icon on the text fields and replace :
YOUR_DOMAIN with the value of the domain.
YOUR_AUTH0_CLIENT_ID with the value of Client ID.
YOUR_AUTH0_CLIENT_SECRET with the value of Client Secret.
Also replace YOUR_NGROK_SERVER_ADDRESS with the ngrok address.
To generate the cookie secret, run this code in the terminal.

openssl rand -hex 32

Setup Auth0 Callback URLs

A callback URL is a URL in your application to which Auth0 sends the user after authentication. In the Application Settings, enter the ngrok link (with the respective URI’s as seen in the image below) as the callback URL for your app to the Allowed Callback URLs. If this field is not set, users will be unable to log in and will receive an error.
For login (https://YOUR_SUBDOMAIN.ngrok.io/login).
For callback (https://YOUR_SUBDOMAIN.ngrok.io/callback).
For logout (https://YOUR_SUBDOMAIN.ngrok.io/logout).

Scroll to the bottom and click on the save button.
TypingDNA

Log in to the TypingDNA dashboard. The Verify 2FA dashboard will provide you with the client Id and client secret. Copy the values and replace them accordingly in the .env file.

To generate the application ID, go to the Settings page by hitting the "Add your first integration" option. When you click the "Add integration" link, a pop-up window appears.
Fill in the name and domain fields with 'Authxdna' in the name field and the ngrok link produced previously in the domain field. After that, the application ID is generated. Copy the value and replace it with YOUR_VERIFY_APPLICATION_ID in the .env file.
Introducing PHP
Create a new file index.php in the root directory in your editor or IDE, then put the content below into it.

<?php
session_start();
// Import our router library:
use Steampixel\Route;
// Import the Composer Autoloader to make the SDK classes accessible:
require 'vendor/autoload.php';

// Load our environment variables from the .env file:
(Dotenv\Dotenv::createImmutable(__DIR__))->load();

// Now instantiate the Auth0 class with our configuration:
$auth0 = new \Auth0\SDK\Auth0([
  'domain' => $_ENV['AUTH0_DOMAIN'],
  'clientId' => $_ENV['AUTH0_CLIENT_ID'],
  'clientSecret' => $_ENV['AUTH0_CLIENT_SECRET'],
  'cookieSecret' => $_ENV['AUTH0_COOKIE_SECRET']
]);


// Define route constants:
define('ROUTE_URL_INDEX', rtrim($_ENV['AUTH0_BASE_URL'], '/'));
define('ROUTE_URL_LOGIN', ROUTE_URL_INDEX . '/login');
define('ROUTE_URL_CALLBACK', ROUTE_URL_INDEX . '/callback');
define('ROUTE_URL_VERIFY', ROUTE_URL_INDEX . '/verify');
define('ROUTE_URL_LOGOUT', ROUTE_URL_INDEX . '/logout');

Route::add('/', function () use ($auth0) {
  $session = $auth0->getCredentials();

  if ($session === null) {
    // The user isn't logged in.
    echo '
    <!DOCTYPE html>
    <html lang="en">

    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Ath0 - Verify</title>

    </head>

    <body>
    <p>Please <a href="/login">log in</a>.</p>
    </body>

    </html>';
    return;
  }
  if (!isset($_COOKIE['2fa'])) {
    // The user isn't verified.
    header("Location: " . ROUTE_URL_VERIFY);

   }
 // The user is logged in.
 echo '<pre>';
 print_r($session->user);
 echo '</pre>';

 echo '<p>You can now <a href="/logout">log out</a>.</p>';


  return;

 });

Route::add('/login', function () use ($auth0) {
  // It's a good idea to reset user sessions each time they go to login to avoid "invalid state" errors, should they hit network issues or other problems that interrupt a previous login process:
  $auth0->clear();

  // Finally, set up the local application session, and redirect the user to the Auth0 Universal Login Page to authenticate.
  header("Location: " . $auth0->login(ROUTE_URL_CALLBACK));
  exit;
});

Route::add('/callback', function () use ($auth0) {
  // Have the SDK complete the authentication flow:
  $auth0->exchange(ROUTE_URL_CALLBACK);

  // Finally, redirect our end user back to the / index route, to display their user profile:
  header("Location: " . ROUTE_URL_INDEX);
  exit;
});
Route::add('/verify', function ()  use ($auth0) {
  $session = $auth0->getCredentials();
  if ($session === null) {
    header("Location: " . ROUTE_URL_INDEX);
    return;
  }
  if(isset($_COOKIE['2fa'])){
    header("Location: " . ROUTE_URL_INDEX);

    return;
  }
  else {


    include('verify.php');
  }
});

Route::add('/logout', function () use ($auth0) {
  unset($_COOKIE['2fa']);
setcookie('2fa', null, time()-3600);
  // Clear the user's local session with our app, then redirect them to the Auth0 logout endpoint to clear their Auth0 session.
  header("Location: " . $auth0->logout(ROUTE_URL_INDEX));
  exit;
});

// This tells our router that we've finished configuring our routes, and we're ready to begin routing incoming HTTP requests:
Route::run('/');

The code starts off by importing the required class and Composer's autoloader. Following that, it uses PHP Dotenv to load the application settings in .env into PHP's $_ENV Superglobals.

After that, it initializes a new Auth0 class, and defines all the necessary routes for the application as constants.
With that done, routes were added, and a session was created. The Auth0 PHP SDK's 'getCredentials()' method is useful for checking if our user has authenticated and returned their profile. The next lines of code publish the user's profile if they're signed in, or tell them that they need to log in or verify their identity if they haven’t.
Next, the '/login' route is then included, which will create a user session using the Auth0 PHP SDK's login() method and deliver a customized URL to Auth0's Universal Login Page for this user to login, as well as the /callback route, which will return the user from authenticating with Auth0's Universal Login Page. When Auth0 returns our users to the application, it adds a few important elements in the HTTP request query. Working with them is handled by the Auth0 PHP SDK's exchange() method, so ending our authentication flow is simple. If the user hasn't been authenticated yet, the '/verify' route is generated to redirect them to the authentication page.
The /logout route, which redirects the user to Auth0's logout() function, is the final route added. The Auth0 PHP SDK's logout() function clears the session cookies in the application and redirects the user to Auth0's /logout endpoint (which logs out the Auth0 session layer and any identity provider session layers), and then returns the user to our /index route.
Last but not least, we need to inform our routing middleware to use Route::run('/'); to actually route requests. This informs our router that we've completed our route configuration and are ready to start routing incoming HTTP requests.
Enabling TypingDNA

In the root folder, add the file TypingDNAVerifyClient.php that can be found in the repository: https://github.com/TypingDNA/TypingDNA-Verify-Client/blob/main/php/TypingDNAVerifyClient.php.
Now that the TypingDNAVerifyClient.php file is in the root folder, create a file verify.php in the root folder and paste the following code.

<?php

// set Verify credentials
$client_id = $_ENV['VERIFY_2FA_CLIENT_ID'];
$secret = $_ENV['VERIFY_2FA_CLIENT_SECRET'];
$application_id = $_ENV['VERIFY_2FA_APPLICATION_ID'];

// include TypingDna Verify library
include('TypingDNAVerifyClient.php');

// create and store a TypingDNAVerifyClient instance using your Verify credentials
$typingDNAVerifyClient = new TypingDNAVerifyClient($client_id, $application_id, $secret);

// if there is opt param in the link it means the Verify flow is completed and we need to validate it
if (isset($_GET['otp'])) {

    // validate opt code
    $response = $typingDNAVerifyClient->validateOTP([
        'email' => $session->user['email'],
    ], $_GET['otp']);


    if ($response['success']==1) {
        setcookie("2fa", true);
        header("Location: " .ROUTE_URL_INDEX);

    }


}

// create the data object required to generate Verify button
$typingDNADataAttributes = $typingDNAVerifyClient->getDataAttributes([
    'email' =>  $session->user['email'],
    'language' => "en",
    'mode' => "standard"
]);
?>
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Ath0 - Verify</title>
    <script src="https://cdn.typingdna.com/verify/typingdna-verify.js"></script>
    <script>
        // crate the callback function that will be invoked by the Verify window
        function callbackFn(payload) {
            window.location.href = `?otp=${payload["otp"]}`;
        }
    </script>
</head>

<body>
    <p>Second factor of authentication</p>
    <button class="typingDNA-verify" data-typingdna-client-id="<?= $typingDNADataAttributes['clientId']; ?>" data-typingdna-application-id="<?= $typingDNADataAttributes['applicationId']; ?>" data-typingdna-payload="<?= $typingDNADataAttributes['payload']; ?>" data-typingdna-callback-fn="callbackFn">
        Verify with Typingdna
    </button>
    <p><a href="/logout">Log Out</a></p>
</body>

</html>

We include the TypingDNAVerifyClient library first, then initialize our variable in the same way we did in index.php. Using the credentials from the Verify 2FA Dashboard, we additionally construct a TypingDNAVerifyClient object and place it in the $typingDNAVerifyClient variable.

Once we have a TypingDNAVerifyClient instance, we will generate the data attributes required to start TypingDNA Verify 2FA. We'll use the email from the Auth0 session callback to register the user on TypingDNA in order to prevent mix up.

Next, we will add the JavaScript library that will allow us to draw the TypingDNA Verify pop-up at the start of the file.

Next, we will create the callbackFn that will redirect the user to the same page where we will process the result obtained from the Verify pop-up.
To verify the created OTP code, the user will be sent to the same page, where the code will be confirmed and, if true, a cookie will be set to indicate that the user has been verified.

Finally, we will add the TypingDNA Verify button that will start the pop-up.
Let's run the application with this command.

php -S 127.0.0.1:3000 index.php

Our first screen
Followed by this

Next, this

After clicking the "Verify with TypingDNA" button.

After we complete the instructions from the TypingDNA Verify 2FA button, the final screen will contain the user details.

For more support, contact us at support@typingdna.com.

Send One Time Passwords Over Voice Calls in PHP Using Twilio Verify

Yong Dev — Mon, 01 Aug 2022 18:30:00 +0000

In recent years, user authentication in web applications has become a serious concern. For example, one-time passwords (OTP) are utilized to verify a user's identity; the most frequent method for sending OTPs is via SMS to the user's registered cellphone number.

In this article, however, you will learn how to deliver one-time passwords to users via voice calls using Twilio's Verify Api. In doing so, you will create an OTP system that can be used as an additional security layer for specific operations in your application.

Prerequisites

To follow this tutorial, you need the following:

PHP 7.4 or higher with the PDO extension and PDO MySQL extension installed and enabled.
Composer globally installed.
MySQL and the MySQL command-line client (or an alternative database tool, such as DataGrip).
A Twilio account. If you are new to Twilio, click here to create a free account.

Application Process

Here's how the application will work. Each time a user attempts to register or sign in, a voice call containing a one-time password will be sent to them.
If the user attempts to register, a form to verify the user's phone number is filled out and, if verified, the user is redirected to a form where personal information is collected for storing in the application's database.

When a user attempts to sign in, the data entered in the registration form is compared to the data in the database. If a match is found, an OTP is sent to the user's phone number, and the user is then taken to a page where the OTP is validated. If the OTP is valid, the user is then redirected to the user dashboard.

Create the project directory

Create the project's root directory, called voice-otp, and navigate to it by running the commands below in the terminal.

mkdir voice-otp

cd voice-otp

Create the database

The next step is to create the user table, which will have the following fields:

id
fullName
email
password
tel (telephone)

In the terminal, run the command below to connect to the MySQL database using MySQL's command-line client, substituting your username for the placeholder ([username]) and enter your password when prompted.

 mysql -u [username] -p

Then, create a database called voice_otp by running the command below.

CREATE DATABASE voice_otp;

After that, use the command below to verify that the database was created. If it were, you'd see it listed in the terminal output.

SHOW DATABASES;

With the database created, create the users table in the voice_otp database, by running the commands below.

USE voice_otp;
CREATE TABLE user (
  id int auto_increment, 
  fullName varchar(300) NOT NULL,
  email varchar(300) NOT NULL,
  tel varchar(20) NOT NULL,
  password varchar(300) NOT NULL,
  PRIMARY KEY (id) 
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

This generates a table with four columns: id (which is auto-increment), fullName, email, tel, and password. Confirm that the table was created by running the SQL statement below.

DESCRIBE user;

With that done, exit MySQL's command-line client by pressing CTRL+D.

Set up the Twilio PHP Helper Library

To utilize Twilio's Verify API for user authentication, you need to install the Twilio PHP Helper Library. To do this, run the command below in your terminal.

composer require twilio/sdk

Then, in your editor or IDE, create a new file named config.php which will contain the app's configuration settings, and paste the code below into the new file.

<?php 

$err_message =  "";

require_once './vendor/autoload.php';

use Twilio\Rest\Client;

$sid = "ACCOUNT_SID";
$token = "AUTH_TOKEN";
$serviceId = "SERVICE_SID";
$twilio = new Client($sid, $token);

The code:

Creates a variable for storing errors.
Includes Composer's Autoloader file, vendor/autoload.php.
Imports Twilio's PHP Helper Library.
Creates three variables to store the required Twilio credentials and settings.
Initializes a Twilio Client object, which is required to interact with Twilio's Verify API.

The Twilio Console dashboard contains your Twilio Auth Token and Account SID. Copy them and paste them in place of ACCOUNT_SID and AUTH_TOKEN, respectively in config.php.

The next step is to create a Twilio Verify service. First, go to the Twilio Verify Dashboard. Then, click the “Create Service Now” button and give the service a nice name in the "Create New Service" box, as seen in the screenshot below.

Create a new Twilio Verify service with a suitable name, such as "verify".

After you've entered a suitable name for the new service, click the blue Create button. The "General Settings" page will appear, which you can see in the screenshot below, where you can view the credentials for your new Twilio Verify service.

Copy the SERVICE SID value and paste it in place of SERVICE_SID in config.php.

Then, you need to add your database connection details. To do this, first, add the following code to the bottom of config.php.

define('DBHOST', 'localhost'); 
define('DBUSER', 'root');
define('DBPASS', ' ');
define('DBNAME', 'voice_otp');

try {
    $pdo = new PDO("mysql:host=".DBHOST.";dbname=".DBNAME, DBUSER, DBPASS);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch( PDOException $exception ) {
    echo "Connection error :" . $exception->getMessage();
}

Then update the define statements for DBHOST, DBUSER, DBPASS, and DBNAME to match your database's settings. The code uses the four variables and attempts to create a connection to the database.

PDO is used to connect to the database, because it supports several database vendors, including MySQL, MSSQL Server, PostgreSQL, and Oracle.

Next, paste the code below at the end of config.php.


function mask_no($number)
{
    return substr($number, 0, 4) . '************' . substr($number, -4);
}

The function above hides the user's phone number by displaying only the first three and final four digits.

Create the signup and sign in page

Create a new file named signup.php in the project's root directory, and paste the code below into it.

<?php require_once('process.php');

$page = ((empty($_GET['p'])) ? 'step1' : strval($_GET['p']));

if (isset($_SESSION['init']) != true || is_array($_SESSION['init']) != true) {
    $_SESSION['init'] = array();
}

?>

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
    <title>Voice OTP</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet" />
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Karla">
    <link rel="stylesheet" href="assets/styles.css">
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.15/css/intlTelInput.css">
    <style>
        .hide {
            display: none;
        }
        #error-msg {
            color: red;
        }
    </style>
</head>

<body style="font-family: Karla, sans-serif;">

    <?php if ($page == 'step1') :  ?>
        <?php require_once('assets/content/step1.phtml'); ?>
    <?php elseif ($page == 'step2' && isset($_SESSION['init']['status']) && !empty($_SESSION['init']['status'])) : ?>
        <?php require_once('assets/content/step2.phtml'); ?>
    <?php else : ?>
        <?php require_once('assets/content/step1.phtml'); ?>

    <?php endif; ?>


    <script src="https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.15/js/intlTelInput.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.15/js/intlTelInput-jquery.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

    <script>
        var input = document.querySelector("#phone"),
            errorMsg = document.querySelector("#error-msg"),
            validMsg = document.querySelector("#valid-msg");

        // Error messages based on the code returned from getValidationError
        var errorMap = ["Invalid number", "Invalid country code", "Too short", "Too long", "Invalid number"];

        // Initialise plugin
        var intl = window.intlTelInput(input, {
            hiddenInput: "tel",
            initialCountry: "auto",
            autoHideDialCode: true,
            preferredCountries: ['us', 'gb', 'ca', 'ng', 'cn'],
            geoIpLookup: function(success, failure) {
                $.get("https://ipinfo.io", function() {}, "jsonp").always(function(resp) {
                    var countryCode = (resp && resp.country) ? resp.country : "";
                    success(countryCode);
                });
            },
            utilsScript: "https://cdnjs.cloudflare.com/ajax/libs/intl-tel-input/17.0.15/js/utils.js"
        });

        var reset = function() {
            input.classList.remove("error");
            errorMsg.innerHTML = "";
            errorMsg.classList.add("hide");
            validMsg.classList.add("hide");
        };

        // Validate on blur event
        input.addEventListener('blur', function() {
            reset();
            if (input.value.trim()) {
                if (intl.isValidNumber()) {
                    validMsg.classList.remove("hide");
                } else {
                    input.classList.add("error");
                    var errorCode = intl.getValidationError();
                    errorMsg.innerHTML = errorMap[errorCode];
                    errorMsg.classList.remove("hide");
                }
            }
        });

        // Reset on keyup/change event
        input.addEventListener('change', reset);
        input.addEventListener('keyup', reset);
    </script>
</body>

</html>

The code, above, generates a simplistic form for registering new users. It includes the file process.php, which contains the code for processing the sign-in & sign-up forms, connecting to Twilio's Verify API, and preventing users from registering without verifying their phone number.

Next, in the project's root directory, create a new directory named assets, and in that directory, create another directory called content, by running the following commands.

mkdir assets
mkdir assets\content

Then, create two new files, step1.phtml and step2.phtml, in the assets/content directory.

Add the code below to step1.phtml.

<div class="page">
        <section class="register">
            <div class="form-container">
                <form method="POST">
                    <h2 class="text-center"><strong>Create</strong> an account.</h2>
                    <?php if ($err_message) : ?>
                        <div class="callout text-danger">
                            <p><?php echo $err_message; ?></p>
                        </div>
                    <?php endif; ?>

                    <div class="mb-3"><input class="form-control" type="tel" id="phone" name="phone" placeholder="Phone Number" value="<?php echo ((isset($_POST['tel'])) ? $_POST['tel'] : ''); ?>" required></div>
                    <span id="valid-msg" class="hide">✓ Valid</span>
                    <span id="error-msg" class="hide"></span>

                    <div class="mb-3"><button class="btn btn-primary d-block w-100" type="submit" name="telsign" required>Sign Up</button></div><a class="already" href="signin.php">Already have an account? Sign in here.</a>
                </form>
            </div>
        </section>
    </div>

step1.phtml contains code that collects the user’s phone number and sends it to process.php.

International telephone input is used to get all country codes.

Add the code below to step2.phtml.

<div class="page">
        <section class="register">
            <div class="form-container">
                <form method="POST">
                    <h2 class="text-center"><strong>Create</strong> an account.</h2>

                    <?php if ($err_message) : ?>
                        <div class="callout text-danger">
                            <p><?php echo $err_message; ?></p>
                        </div>
                    <?php endif; ?>

                    <div class="mb-3"><input class="form-control" type="text" name="fullName" placeholder="Full Name" value="<?php if (isset($_POST['fullName'])) echo $_POST['fullName']; ?>" ></div>
                    <div class="mb-3"><input class="form-control" type="email" name="email" placeholder="Email" value="<?php if (isset($_POST['email'])) echo $_POST['email']; ?>" ></div>
                    <div class="mb-3"><input class="form-control" type="tel" id="phone" name="phone" placeholder="Phone Number" value="<?php  echo $_SESSION['init']['phone']; ?>"  disabled></div>
                    <div class="mb-3"><input class="form-control" type="password" name="password" placeholder="Password" minlength="8" required></div>
                    <div class="mb-3"><input class="form-control" type="password" name="re_password" placeholder="Password (repeat)" ></div>
                    <div class="mb-3">
                        <div class="form-check"><label class="form-check-label"><input class="form-check-input" type="checkbox"required>I agree to the license terms.</label></div>
                    </div>
                    <div class="mb-3"><button class="btn btn-primary d-block w-100" type="submit" name="signup" required>Sign Up</button></div>
                </form>
            </div>
        </section>
    </div>

Now, create a file named signin.php in the root directory and paste the following code into it:

<?php 
require_once('process.php') 
?>
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
    <title>Sign in-OTP</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet"/>
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Karla">
    <link rel="stylesheet" href="assets/styles.css">
</head>

<body style="font-family: Karla, sans-serif;">
    <div class="page">
        <section class="register">
            <div class="form-container">

                <form method="post">
                    <h2 class="text-center"><strong>Sign in</strong> to your account.</h2>
                    <?php if ($err_message) : ?>
                        <div class="callout text-danger">

                            <p><?php echo $err_message; ?></p>
                        </div>
                    <?php endif; ?>
                    <div class="mb-3"><input class="form-control" type="email" name="email" placeholder="Email"></div>
                    <div class="mb-3"><input class="form-control" type="password" name="password" placeholder="Password"></div>
                    <div class="mb-3"><button class="btn btn-primary d-block w-100" type="submit" name="signin">Sign in</button></div><a class="already" href="signup.php">Don't have an account? Sign up here.</a>
                </form>
            </div>
        </section>
    </div>
</body>

</html>

Then, create a file named styles.css in the assets folder and paste the following code in to it:

body {
    background: #f1f7fc;
}

.register {

    padding: 80px 0;
}

.register .form-container {
    display: table;
    max-width: 500px;
    width: 90%;
    margin: 0 auto;
    box-shadow: 1px 1px 5px rgba(0, 0, 0, 0.1);
}

.register form {
    display: table-cell;
    width: 400px;
    background-color: #ffffff;
    padding: 40px 60px;
    color: #505e6c;
}

@media (max-width:991px) {
    .register form {
        padding: 40px;
    }
}

.register form h2 {
    font-size: 24px;
    line-height: 1.5;
    margin-bottom: 30px;
}

.register form .form-control {
    background: #f7f9fc;
    border: none;
    border-bottom: 1px solid #dfe7f1;
    border-radius: 0;
    box-shadow: none;
    outline: none;
    color: inherit;
    text-indent: 6px;
    height: 40px;
}

.register form .form-check {
    font-size: 13px;
    line-height: 20px;
}

.register form .btn-primary {
    background: #f4476b;
    border: none;
    border-radius: 4px;
    padding: 11px;
    box-shadow: none;
    margin-top: 35px;
    text-shadow: none;
    outline: none !important;
}

.register form .btn-primary:hover,
.register form .btn-primary:active {
    background: #eb3b60;
}

.register form .btn-primary:active {
    transform: translateY(1px);
}

.register form .already {
    display: block;
    text-align: center;
    font-size: 12px;
    color: #6f7a85;
    opacity: 0.9;
    text-decoration: none;
}

Following that, create a file named process.php in the project's root directory, and add the following code to it. This code is responsible for processing all requests from the sign in and signup pages.

<?php

//Create Session
require_once("config.php");
ob_start();
session_start();

if (isset($_POST['telsign'])) {
  $phone = $_POST['tel'];

  $statement = $pdo->prepare("SELECT * FROM user WHERE tel=?");
  $statement->execute(array($_POST['tel']));
  $total = $statement->rowCount();
  if ($total) {
    $valid = 0;
    $err_message .= 'An account is already associated with the provided Phone Number<br>';
  }
  else{
  $verification = $twilio->verify->v2->services($serviceId)
    ->verifications
    ->create($phone, "call");
  if ($verification->status) {
    $_SESSION['phone']= $phone;
    header("Location: verify.php?p=signup");

    exit();
  } else {
    echo 'Unable to send verification code';
  }
}
}
if (isset($_POST['signup_verify'])) {
  $code = $_POST['code'];
  $phone = $_SESSION['phone'];

  $verification_check = $twilio->verify->v2->services($serviceId)
    ->verificationChecks
    ->create(
      $code,
      ["to" => "+" . $phone]
    );
  if ($verification_check->status == 'approved') {
    $_SESSION['init']['status'] = 'success';
    $_SESSION['init']['phone'] = $phone;

    header("location: signup.php?p=step2");
  } else {
    $err_message .= 'Invalid code entered<br>';
  }
}

//If the Signup button is triggered
if (isset($_POST['signup'])) {
  $valid = 1;

  /* Validation to check if fullname is inputed */
  if (empty($_POST['fullName'])) {
    $valid = 0;
    $err_message .= " FullName can not be empty<br>";
  }
  //Filtering fullname if not empty
  else {
    $fullname = filter_var($_POST['fullName'], FILTER_SANITIZE_STRING);
  }

  /* Validation to check if email is inputed */
  if (empty($_POST['email'])) {
    $valid = 0;
    $err_message .= 'Email address can not be empty<br>';
  }
  /* Validation to check if email is valid */
  else {
    if (filter_var($_POST['email'], FILTER_VALIDATE_EMAIL) === false) {
      $valid = 0;
      $err_message .= 'Email address must be valid<br>';
    }
    /* Validation to check if email already exist */ else {
      // Prepare our SQL, preparing the SQL statement will prevent SQL injection.
      $statement = $pdo->prepare("SELECT * FROM user WHERE email=?");
      $statement->execute(array($_POST['email']));
      $total = $statement->rowCount();
      //If There is a match gives an error message
      if ($total) {
        $valid = 0;
        $err_message .= 'An account is already asociated with the provided email address<br>';
      }
    }
  }
  /* Validation to check if password is inputed */
  if (empty($_POST['password']) || empty($_POST['re_password'])) {
    $valid = 0;
    $err_message .= "Password can not be empty<br>";
  }
  /* Validation to check if passwords match*/

  if (!empty($_POST['password']) && !empty($_POST['re_password'])) {
    if ($_POST['password'] != $_POST['re_password']) {
      $valid = 0;
      $err_message .= "Passwords do not match<br>";
    }
    //If Passwords Matches Generates Hash
    else {
      //Generating Password hash
      $password = filter_var($_POST['password'], FILTER_SANITIZE_STRING);
      $hashed_password = password_hash($password, PASSWORD_DEFAULT);
    }
  }

  if ($valid == 1) {
    //if There Error Messages are empty Store data in the database
    if (empty($err_message)) {
      //Saving Data Into Database
      $statement = $pdo->prepare("INSERT INTO user (fullName,email,tel,password) VALUES (?,?,?,?)");
      $statement->execute(array($fullname, $_POST['email'], $_POST['tel'], $hashed_password));
      unset($_SESSION['phone']);
      header("location: signin.php");
    } else {
      $err_message .= "Problem in registration.Please Try Again!";
    }
  }
}

if (isset($_POST['signin'])) {
  //Checks if Both input fields are empty
  if (empty($_POST['email'] || empty($_POST['password']))) {
    $err_message .= 'Email and/or Password can not be empty<br>';
  }
  //Checks if email is valid

  else {
    $email = filter_var($_POST['email'], FILTER_VALIDATE_EMAIL);
    if ($email === false) {
      $err_message .= 'Email address must be valid<br>';
    } else {
      //Checks if email exists

      $statement = $pdo->prepare("SELECT * FROM user WHERE email=?");
      $statement->execute(array($email));
      $total = $statement->rowCount();
      $result = $statement->fetchAll(PDO::FETCH_ASSOC);

      if ($total == 0) {
        $err_message .= 'Email Address does not match<br>';
      } else {
        //if email exists save all data in the same column of the email in the row array

        foreach ($result as $row) {
          $stored_password = $row['password'];
        }
      }
    }
    //Checks Provided password matches the password in database if it does logs user in
    if (password_verify($_POST['password'], $stored_password)) {
      //setting the session variables
      $_SESSION['user'] = $row;
      $_SESSION['user']['status'] = '';
      $_SESSION['phone'] = $row['tel'];
      //setting the session signin time
      $_SESSION['user']['loggedin_time'] = time();
      $verification = $twilio->verify->v2->services($serviceId)
        ->verifications
        ->create($_SESSION['phone'], "sms");
      if ($verification->status) {

        header("Location: verify.php?p=signin");

        exit();
      }
    } else {
      $err_message .= 'Password does not match<br>';
    }
  }
}
if (isset($_POST['signin_verify'])) {
  $code = $_POST['code'];
  $phone = $_SESSION['phone'];

  $verification_check = $twilio->verify->v2->services($serviceId)
    ->verificationChecks
    ->create(
      $code,
      ["to" => "+" . $phone]
    );
  if ($verification_check->status == 'approved') {
  $_SESSION['user']['status'] = 'success';

    header("Location: index.php");

    //destroy created session

  } else {
    $err_message .= 'Invalid code entered<br>';
  }
}

Stepping through the code, first, config.php, which contains the app's configuration settings, is included. Then, a session is created with a condition that checks if the provided number is not registered in the database. It then sends a verification code to the user, who is then directed to a page that verifies the authenticity of the code. If it is, then a session that allows the user to access the step2.phtml file, which collects the data which would be stored in the database, is created.

The next line verifies the form input and saves it to a database. If a user signs in successfully, they are routed to the verification page, and if authorized a session named user and a sub-array called status are initialized to success, allowing the user to access index.php, which is the dashboard.

Now, create three files in the root directory:

index.php for the dashboard
verify.php for inputting the verification code
logout.php which signs out a user from the existing session

After they're created, paste the following code into index.php:

<?php
session_start();
//require_onces database config
require_once("config.php");
// Check if the user is logged in or not
if (!isset($_SESSION['user'])) {
    header('location: signin.php');
    exit;
}
// Check if the user has verified number or not
if ($_SESSION['user']['status']!=='success') {
    header('location: signin.php');
    exit;
}
?>
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
    <title>DashBoard</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet"/>
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Karla">
    <link rel="stylesheet" href="assets/styles.css">
</head>

<body style="font-family: Karla, sans-serif;">
    <div class="page">
        <section class="register">
            <div class="form-container">

                <h2 class="text-center"><strong>User </strong> DashBoard.</h2>


                <div class="callout text-primary">
                    Welcome <?php echo $_SESSION['user']['fullName']; ?>. Click here to <a href="logout.php" tite="Logout">Logout.

                </div>


            </div>
        </section>
    </div>
    </body>

</html>

Now, start PHP's built-in web server by running the following command:

php -S localhost:8000

Then, open http://localhost:8000/ in your browser, the sign in screen should look like:

In verify.php, paste the code below.

<?php require_once('process.php');


$page = ((empty($_GET['p'])) ? '' : strval($_GET['p']));
$number = $_SESSION['phone'];
?>
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, shrink-to-fit=no">
    <title>Voice OTP</title>
    <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Karla">
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet"/>
    <link rel="stylesheet" href="assets/styles.css">
</head>

<body style="font-family: Karla, sans-serif;">
    <div class="page">
    <?php if($page=='signup' && isset($_SESSION['phone'])):  ?>
        <section class="register">
            <div class="form-container">

                <form method="post">
                    <h2 class="text-center"><strong>Verify</strong> your account.</h2>

                    </p>A verification code has been sent through Voice call to
                    <b><?php echo mask_no($number); ?></b>, <br />
                    enter the code below to continue.</p>
                    <?php if ($err_message) : ?>
                        <div class="callout text-danger">

                            <p><?php echo $err_message; ?></p>
                        </div>
                    <?php endif; ?>
                    <div class="mb-3"><input class="form-control" type="text" name="code" placeholder="Code"></div>

                    <div class="mb-3"><button class="btn btn-primary d-block w-100" type="submit" name="signup_verify">Verify</button></div><a class="already" href="signup.php">Wrong Number?</a>
                </form>
            </div>
        </section>
        <?php elseif($page=='signin'  && isset($_SESSION['phone'])):?>
        <section class="register">
            <div class="form-container">

                <form method="post">
                    <h2 class="text-center"><strong>Verify</strong> your account.</h2>

                    </p>A verification code has been sent through Voice call to
                    <b><?php echo mask_no($number); ?></b>, <br />
                    enter the code below to continue.</p>
                    <?php if ($err_message) : ?>
                        <div class="callout text-danger">

                            <p><?php echo $err_message; ?></p>
                        </div>
                    <?php endif; ?>
                    <div class="mb-3"><input class="form-control" type="text" name="code" placeholder="Code"></div>

                    <div class="mb-3"><button class="btn btn-primary d-block w-100" type="submit" name="signin_verify">Verify</button></div>
                </form>
            </div>
        </section>
            <?php else: ?>

                        <?php header('HTTP/1.0 403 Forbidden'); echo 'Error Cannot access resource'; ?>

                    <?php endif; ?>
    </div>
</body>

</html>

The Verification screen:

Parameters were set in place to prevent a user from accessing the verify.php page, if they haven't gone through the verification process.
And in logout.php, paste the code below.

<?php
ob_start();
session_start();
//includes app  config file
require_once('config.php');
//Unset the session variable
unset($_SESSION['user']);
//destroy created session
session_destroy();
// Redirect to login page
header("location: signin.php");

Note

If you are making calls from a trial account, the "To" phone number must be verified with Twilio. You can verify your phone number by adding it to your Verified Caller IDs in the console.

That's how to use Twilio Verify to deliver an OTP via calls with PHP.

There you have it, a mechanism to encrypt crucial activities in your app using one-time passwords sent via phone calls to users. In this tutorial, you learned how to send an OTP via a phone call with Twilio verify.
However, Verify has a great deal more functionality than has been covered in this tutorial. Check out Twilio’s Verify docs if you're keen to learn more about the available functionality. For your convenience, the whole code for this article is accessible on Github.

If you enjoyed this piece you can follow me on twitter @ _yongdev

Help me please!

Yong Dev — Thu, 21 Apr 2022 20:24:43 +0000

Hi, am prosper and am having a downtime currently. My pc is broken and I need a replacement. please help
You can support me via buy me a coffee or via PayPal

How to Manage Dates and Times in PHP Using Carbon

Yong Dev — Sun, 09 Jan 2022 06:37:08 +0000

Date and time manipulation is one of a few frequently-experienced challenges of developing web apps in PHP. And one of it's most prevalent issues is identifying time disparities and making them readable, such as "one hour ago".

However, handling dates and times — and issues such as this — is greatly simplified by using Carbon; it's a library which reduces lengthy hours of coding and debugging to only a few lines of code. This is because Carbon, created by Brian Nesbit, extends PHP's own DateTime class and makes it much simpler to use.

If you've not heard of it before, it is self-described as:

A basic PHP API extension for DateTime

In this tutorial, you will learn Carbon's core features and capabilities, giving you the ability to far more easily manipulate date and time in PHP.

Prerequisites

To follow this tutorial you need the following components:

PHP 7.4 or higher.
Composer globally installed.

Installation

To install Carbon, first create a new project directory called carbon, change into the directory, and install the package, by executing the following commands:

mkdir carbon
cd carbon
composer require nesbot/carbon

!!!tip

Carbon is already included if you're using Laravel. If you are, have a look at the suggested Laravel settings and best practices. If you're using Symfony, have a look at the Symfony configuration and best-practices guidelines.

!!!tip

Format dates using Carbon

With Carbon installed, in your editor or IDE, create a new PHP file, named index.php in the root of your project directory. Then, add the code below to index.php to include Composer's Autoloader file, vendor/autoload.php, and imported Carbon's core class_._

<?php 
require 'vendor/autoload.php';
use Carbon\Carbon;

Print dates

Now that Carbon's installed, let's start working through some examples, starting with the most essential: printing out some dates. To do that, we'll use carbon::today to retrieve today's date via Carbon, which you can see in the example below.

<?php

require __DIR__ . "/vendor/autoload.php";

echo carbon::today() . "\n";

Add that to index.php and then run it.

2021-10-25 00:00:00

The output, which you can see an example of above, returns the current date, with the time being blank. However, if you update index.php to use carbon:: now instead, which you can see in the example below, you can retrieve the time along with the date.

<?php

require __DIR__ . "/vendor/autoload.php";

$now = carbon::now()
echo "$now\n";

After updating index.php and running it, you should see output similar to the example below, in your terminal.

2021-01-25 22:49:56

In contrast to Carbon::now() which returns the current date and time, and Carbon:today() which only returns the current date, Carbon::yesterday() and Carbon::tomorrow() generate Carbon instances for yesterday and tomorrow, respectively, as in the examples below.

<?php

require __DIR__ . "/vendor/autoload.php";

$yes = Carbon::yesterday();
echo "Yesterday: $yes\n";

$tomorrow = Carbon::tomorrow();
echo "Tomorrow: $tomorrow\n";

The functions today(), yesterday(), now, and tomorrow() are examples of common static instantiation helpers.

Create dates with precision

Carbon also allows us to generate dates and times based on a set of parameters. For example, to create a new Carbon instance for a specific date use the Carbon::createFromDate() method, passing in the year, month, day, and timezone, as in the following example.

<?php

require __DIR__ . "/vendor/autoload.php";

$year = 2020;
$month = 08;
$day = 21;
$timezone = 'Europe/Berlin';
Carbon::createFromDate($year, $month, $day, $timezone);

You can also specify the time, by calling Carbon::create(), passing in the year, month, day, timezone, hour, minute, and second, as in the following example

<?php

require __DIR__ . "/vendor/autoload.php";

$year = 2021;
$month = 04;
$day = 21;
$timezone = 'Europe/Berlin';
$hour = 11;
$minute = 11;
$second = 11;
Carbon::create($year, $month, $day, $hour, $minute, $second, $timezone);

If any one or more of $year, $month, $day, $hour, $minute, or $second are set to null their now() equivalent values will be used. If $hour is not null, however, then the default values for $minute and $second will be 0.

If you pass in null for any of those attributes, it will default to the current date and time.

Update index.php in your editor or IDE to match the code below and run it.


<?php

require __DIR__ . "/vendor/autoload.php";

use Carbon\Carbon;

$date1 = Carbon::create(2021,10, 25, 12, 48, 00);
echo $date1 . "\n";

$date2 = Carbon::create(2021, 8, 25, 22, 48, 00, 'Europe/Moscow');
echo $date2 . "\n";

$date3 = Carbon::createFromDate(2018, 8, 14, 'America/Chicago');
echo $date3 . "\n";

$date4 = Carbon::createFromDate(2021,10, 25, 'Africa/Lagos');
$date5 = Carbon::createFromTimestamp(1633703084);
echo $date5. "\n";

The create() function in the first variable creates a Carbon instance from date and time components; A timezone was supplied on the constructor to the second variable.

A Carbon object was constructed using date components with Carbon::createFromDate() when initializing the third and fourth variables. Doing so generates a Carbon instance based on just on a date.

It's worth pointing out that if no timezone is specified, your default timezone is used. However, if a timezone other than yours is specified, the timezone's actual time is supplied. The current time is set in the time section.

The final variable, initialized using Carbon::createFromTimestamp, generates a date based on a timestamp.

Relative Modifiers

Another fantastic feature of Carbon is relative modifiers. These allow strings such as "next friday" or "a year ago" to be used when constructing Carbon instances relative to the current date.

The following are examples of strings that are considered relative modifiers.

+
-
ago
first
next
last
this
today
tomorrow

Modify the date and time

When working with dates, you'll need to do more than just get the date and time. You'll frequently need to modify the date or time as well, such as adding a day or a week or subtracting a month.

A good example of needing this functionality is when building an affiliate program. In this scenario you'll want the affiliate cookie which the user receives to expire after a specified period of time, making the referral invalid.

Let's assume a cookie has a 90-day lifespan. With Carbon's add and subtract methods, we could compute that time quite trivially. The example below uses addDays() to determine when the cookie expires.

<?php

require __DIR__ . "/vendor/autoload.php";

$name = 'Affliate_Program';
$value = 'Referrer ID';
$path = '/';
$current = Carbon::now();

// add 90 days to the current time
$time = $current->addDays(90);
$expires = strtotime($time);
setcookie($name, $value, $expires, $path);

It also uses some of the other add() and sub() methods which Carbon provides. If you're adding a single date, such as a day, you use addDay(), but if you're adding several days, you use addDays(). Using Carbon’s add and subtract methods can provide you with adjusted date and times.

Looking forward and back

Carbon also provides the next() and previous() functions which return the upcoming and previous occurrences of a particular weekday, which you can see an example of in the code below.

<?php

require __DIR__ . "/vendor/autoload.php";

use Carbon\Carbon;

$now = Carbon::now();
echo "$now\n";

$next_monday = $now->next(Carbon::MONDAY);
echo "Next monday: $next_monday\n";

$prev_monday = $now->previous(Carbon::MONDAY);
echo "Previous monday: $prev_monday\n";

Format the date and time

Yet another fantastic option Carbon provides is the ability to format dates and times in whatever format that you desire.

As Carbon is an expanded version of PHP's built-in date and time functions, Carbon can use PHP's built-in date formats via the format() function. In addition, toXXXString() methods are available to display dates and times with predefined formatting.

<?php

require __DIR__ . "/vendor/autoload.php";

$dt = Carbon::create(2021,10, 25, 12, 48, 00);
echo $dt->toDateString();//2021-10-25
echo $dt->toFormattedDateString();//Oct 25, 2021
echo $dt->toTimeString();//12:48:00
echo $dt->toDateTimeString();//2021-10-25 12:48:00
echo $dt->toDayDateTimeString();//Mon, Oct 25, 2021 12:48 PM
echo $dt->format('Y-m-d h:i:s A');//2021-10-25 12:48:00 PM

Other typical datetime formatting methods available to Carbon include the following.

<?php

require __DIR__ . "/vendor/autoload.php";

$dt->toAtomString();
$dt->toCookieString();
$dt->toIso8601String();
$dt->toIso8601ZuluString();
$dt->toRfc822String();
$dt->toRfc850String(); 
$dt->toRfc1036String();
$dt->toRfc1123String();
$dt->toRfc3339String(); 
$dt->toRfc7231String(); 
$dt->toRssString();
$dt->toW3cString();

Calculate relative time

The diffForHumans() functions in Carbon also allow us to represent time in relative terms. Datetime discrepancies are frequently displayed in a so-called humanized format, such as in one year or three minutes ago.

Let's assume we're developing an extension for a blog CMS and we want to display the article's publish time in "hours ago" or the comments publish time in "hours ago."

First, the time and date the article was published, as well as other parameters, would be recorded in a database field. As a result, we extract the date from the database in the format Y-m-d H:i:s and store it in a variable. Let's call it $time.


<?php

$time = $row['articledate'];

If the date in our database is August 4th, 2021, such as in the example below, you would use the carbonCreateFromFormat() function to produce a Carbon date, and then use diffForHumans() to find the difference.

<?php

require __DIR__ . "/vendor/autoload.php";

$row['articledate'] = 2021-08-04 16:19:49;
$dt = Carbon::createFromFormat('Y-m-d H:i:s', $time);

echo $dt->diffForHumans() . "\n";

If the date was saved as a timestamp, you can call Carbon::createFromTimestamp. Carbon also provides user translator services. So if your site makes use of a user's language preferences, call the language. If you have a user that speaks French, for example, all you have to do is call the function before the code, as seen below.

<?php

require __DIR__ . "/vendor/autoload.php";

Carbon::setLocale()'.Carbon::setLocale('fr');
echo $dt->diffForHumans() . "\n";

Output in this case would be, for example, 'il y a 2 mois'.

That's the essentials of managing dates and times in PHP using Carbon

In this tutorial, you learned how to install Carbon and its core functionality. However, Carbon has a great deal more functionality than has been covered in this tutorial. Check out their docs if you're keen to learn more about the available functionality.

What did you learn this Week

Yong Dev — Fri, 15 Oct 2021 11:31:30 +0000

Get Paid Writing

Yong Dev — Fri, 08 Oct 2021 18:23:34 +0000

Here are a few sites to assist you locate sites that pay technical authors if you're a geek who enjoys writing technical stuff.

You Learnt ?

Yong Dev — Thu, 23 Sep 2021 19:30:38 +0000

Good day, folks! How are you doing? The week is almost up, so tell me what you've learned.

How To Send Email Using PHPMailer in PHP

Yong Dev — Sun, 12 Sep 2021 17:09:11 +0000

Introduction

In order to add email services to your PHP application, the PHPMailer class is the ideal choice. PHP frameworks of all kinds are supported (Laravel or Symfony are based on the SwiftMailer library, though, but it is still possible to use PHPMailer as well.) An HTML email with attachments is created using this sophisticated tool, which can then be sent out through SMTP or web server on your local network to a large number of recipients in real time. At the end of this article You'll be able to send a mail using the php library.

Prerequisites

The following criteria must be met in order to follow along with this guide:

A PHP development environment that runs at least PHP 7.0.
(Optional) Composer.

Installation

You can send emails using mail(), Sendmail or Qmail, or you can send them directly through SMTP servers.
Additional advanced features include:

SSL/SMTP Authentication
Attachments in fs, string, and binary
A plain-text email can be sent to clients that do not support HTML email.
An active development community maintains it secure and current.

Installing PHPMailer

You must install PHPMailer through Composer, a dependency management for PHP, starting with version 6.0 released in August 2017. This method is suggested by PHPMailer's developers on Github.
In your terminal, type the following code to install the library:

composer require phpmailer/phpmailer

PHPMailer can be added manually if you don't want to install Composer in a testing environment, for example. PHPMailer source code files may be downloaded here. Once downloaded, transfer the PHPMailer folder to one of the include path directories provided in your PHP setup, then manually load each class file:

<?php
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

require 'path_to_PHPMailer/src/Exception.php';
require 'path_to_PHPMailer/src/PHPMailer.php';
require 'path_to_PHPMailer/src/SMTP.php';

See the PHPMailer documentation on Github for comprehensive information on how to install the package without composer.

Use PHPMailer to send emails from a local server

The most likely scenario is that you will utilize HTML to create your email message As a result, you'll be using HTML techniques and attributes to deliver the messages to recipients.
Include the autoload.php file created by Composer if you have used Composer to install:

require 'path/to/composer/vendor/autoload.php';

This is how to use PHPMailer if you have manually installed it:

require 'path_to_PHPMailer/src/PHPMailer.php';
require 'path_to_PHPMailer/src/SMTP.php';
require 'path_to_PHPMailer/src/Exception.php';

Then include the PHPMailer class:

use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;

Creating a new PHPMailer object is the next stage in the process:

    $mail = new PHPMailer();

In the next step, we'll provide the headers:

    $mail->setFrom('noreply@example.com', 'Admin');//Add a sender
    $mail->addAddress('joe@example.net', 'User');//Add a recipient
    $mail->addReplyTo('info@example.com', 'Information');//Add an address that the mail reply should be sent
    $mail->addCC('cc@example.com'); //Add a more recipient
    $mail->addBCC('bcc@example.com');//Add a more recipient

If you need to add many addresses, create a new code for each one:

    $mail->AddBCC('bcc2@example.com', 'mick');
    $mail->AddBCC('bcc3@example.com', 'doe');

A file can be attached by specifying its path. Also, you can specify a filename, although it's not required: the script will use the real filename:

    $mail->addAttachment('path_to/file.csv', 'file.csv');

In other to add image,you use CID attachments to embed an image here:

    $mail->addEmbeddedImage('path_to/image_file.jpg', 'image');

and in the message body add

    $mail->Body = '<img src="cid:image">';

Add a subject, indicate that it should delivered with sendmail, and specify that the message contains HTML.

    $mail->Subject = 'Test Email Using PHPMailer';
    $mail->IsSendmail();sets to send mail using Sendmail.
    $mail->isHTML(true); //Set email format to HTML

You may now enter the email body:

   $mail->Body = "<H1>Mail body in HTML</H1><p>Email testing</p>";
   $mail->AltBody = "This is the plain text version of the email content";

Lastly, define the email sending features as follows:

try {
    $mail->send();
    echo "Message has been sent successfully";
} catch (Exception $e) {
    echo "Mailer Error: " . $mail->ErrorInfo;
}

Finally, let's put all the code you've created to send an email together.

<?php
require 'path/to/composer/vendor/autoload.php';
use PHPMailer\PHPMailer\PHPMailer;
use PHPMailer\PHPMailer\Exception;
    $mail = new PHPMailer();
    $mail->setFrom('noreply@example.com', 'Admin');//Add a sender
    $mail->addAddress('joe@example.net', 'User');//Add a recipient
    $mail->addReplyTo('info@example.com', 'Information');//Add an address that the mail reply should be sent
    $mail->addCC('cc@example.com'); //Add a more recipient
    $mail->addBCC('bcc@example.com');//Add a more recipient
    $mail->addAttachment('path_to/file.csv', 'file.csv');
    $mail->addEmbeddedImage('path_to/image_file.jpg', 'image');
    $mail->Subject = 'Test Email Using PHPMailer';
    $mail->IsSendmail();sets to send mail using Sendmail.
    isHTML(true) sets the email's format to HTML.
    $mail->isHTML(true); //Set email format to HTML
    $mail->Body = "<H1>Mail body in HTML</H1><p>Email testing<img src="cid:image"></p>";
   $mail->AltBody = "This is the plain text version of the email content";
try {
    $mail->send();
    echo "Message has been sent successfully";
} catch (Exception $e) {
    echo "Mailer Error: " . $mail->ErrorInfo;
}

Sending emails with SMTP server


 //Server settings
$mail->SMTPDebug = 1;//Enable SMTP debugging 
//Send using SMTP 
 $mail->isSMTP(); 
//Enable SMTP authentication
$mail->SMTPAuth   = true;
//SMTP Host
$mail->Host='smtp.example.com';
 //SMTP username                            
$mail->Username= 'user@example.com';
//SMTP password                     
$mail->Password= 'secret';   
//Enable implicit TLS encryption                            
$mail->SMTPSecure=  PHPMailer::ENCRYPTION_SMTPS; 
//TCP port to connect           
$mail->Port= 465; 
$mail->isHTML(true); //Set email format to HTML
$mail->Body = "<H1>Mail body in HTML</H1><p>Email testing</p>";
$mail->AltBody = "This is the plain text version of the email content";
try {
    $mail->send();
    echo "Message has been sent successfully";
} catch (Exception $e) {
    echo "Mailer Error: " . $mail->ErrorInfo;
}

Let's go through the variables now

$mail->SMTPDebug is used to enable debugging and display error messages.
$mail->isSMTP() is used to notify the PHPMailer to use SMTP to convey messages.
$mail->SMTPAuth is used to set authentication.
$mail->Host is used to define server host
$mail->Username is used to define the username for smtp server host account.
$mail->Password is used to define the password for smtp server host account
$mail->SMTPSecure sets the encryption type.
$mail->Port is used to define server port in which the email should be sent.

Conclusion

As a PHP developer, there's little chance you'll be able to avoid sending emails through script. Using third-party services like mailtrap or mailchimp may be a possibility in some cases, but developing your own email sending library may not be feasible. Therein lies the value of PHPMailer and its equivalents (such as Zend Mail and Swift Mailer).
Here we've covered the most frequent uses of Phpmailer: delivering pictures and attachments in HTML emails over SMTP or localhost, as well as debugging settings.

How to Debug PHP Using Xdebug On Vscode

Yong Dev — Fri, 10 Sep 2021 12:13:15 +0000

Introduction

It's important to keep a few things in mind while developing web apps.
When it comes to building large and powerful applications, a competent developer will always follow best practices. Testing, debugging, performance, and security of websites or apps are some of these techniques.
Using VSCode and the PHP xDebug module, you'll enable full-featured functional debugging throughout your whole application.

Prerequisites

The following criteria must be met in order to follow along with this guide:

A PHP development environment that runs at least PHP 7.0.
An appropriate version of Visual Studio Code for your operating system

Step 1 — How to Download and Install the XDebug Tool

Real-time debugging is made possible using Xdebug, a PHP extension. On the other hand, it can be useful for troubleshooting server-side problems. Since it shouldn't be active on most requests, Xdebug isn't enabled in the same manner as the other extensions are.You would install it following the steps below:

Windows

Xdebug provides a wizard tool for Windows users to obtain a .dll file. In order to do this, first create a PHP file in a folder, and then add the following code line:

<?php 
phpinfo();
?>

Use your browser to launch the index.php file . This will provide the information displayed in the image below.

Select and copy all information on the page.
You'll next need to go to the XDebug Wizard tool and paste the information into a Text Box input field.
Look for 'Analyze my phpinfo() output' and click it.
There is a module that may be downloaded under Instructions, number 1. As you can see in the image below:

Please note that the path to the directory in this example may be different from yours, so please pay attention to the directions in the image above.

MAC

You can install PHP7 Xdebug using pecl extension:

pecl install xdebug

Linux

On Linux distribution like fedora 32, you can use Sudo to install Xdebug in PHP:

sudo yum install php-xdebug

you can refer to the xdebug docs if you use other linux distribution.
It's time to enable Xdebug by adding the following code to file xdebug.ini under etc/php/7.0/mods-available/

xdebug.profiler_enable_trigger = 1
xdebug.profiler_enable = 0
xdebug.remote_enable = 1
xdebug.profiler_output_dir = "/tmp"

Now restart your server.

Step 2 — Enabling the XDebug extension in PHP

Microsoft's Visual Studio Code (VS Code) is a free open source text editor. VS Code is available for Windows, Linux, and Mac. There are significant features in the editor that make VS Code one of the most popular programming environments in recent years, despite its size.
Firt

Launch VS Code
Install the Felix Becker PHP Debug extension. The PHP Debug extension may be found in VSCode's Extensions tab by searching for it.
Click on the Run tab and click on add configuration.

Now, you'll need to pick the PHP environment. A new launch.json file will be added to the root directory by VSCode.

Finally, add the runtimeExecutable property to the list after port replacing path_to_php_executable with the path to your php executable:

"runtimeExecutable": "path_to_php_executable"

Please save the file launch.json. Start debugging by opening the debug mode tab and clicking the green debug button.

You will now see several options in the window, via which you can pick what logs Xdebugger will show like:

Notices
Warnings
Errors
Exceptions
Everything

Access the Debug Console, which displays error information and debug execution buttons at the top.

You have the option to make your selections. What I'm going to tell you now is something I've previously addressed in the early stage breakpoints. A breakpoint on a line of code is now available. It's important to note that Xdebug will display the PHP debug script name and line number in the bottom left area.

In order to debug the application correctly you may launch it in the browser and then go through the code line-by line to spot the issues and fix them. A few shortcut keys for functions and lines of codes should also be remembered:

F5: Continue Debugging

F10: Step Over

F11: Step into

Shift + F11: Step out

Conclusion

Software development is never complete without debugging.
You can't tell what's wrong with the code without it.
A PHP debugger that identifies problems and warning signals fast is a fantastic idea if you're working on an application with thousands of lines of code and you want to be sure you've set up your debugging environment before you start writing code.

In this article, you learnt how to enable PHP debugging with Xdebug and setup it in VSCode. IDEs like as Eclipse, PHPstorm, and others can also be used to incorporate it.

API

Yong Dev — Sun, 05 Sep 2021 20:47:28 +0000

Applications can access data and interact with external software components, operating systems, or microservices through APIs (Application Programming Interfaces).

To put it simply, an API sends a user's response to a system and receives the system's response back. An API notifies the site that you have added a product to your cart; the website adds the product to your cart, and your cart is updated.
With regards to API, you could encounter the phrase "microservices." Nevertheless, they're not the same thing! In a web application, microservices are used to separate functions. API, on the other hand, is the structure through which web application developers communicate with a web site. As a matter of fact, microservices can communicate via APIs.

What are APIs and how do they work?

An Application programming interface is made up of two parts that are interconnected. Firstly, there is a specification that explains how information is shared between programmes, in the form of a request for processing and a return of the necessary data. An interface developed to that standard and made available for usage is the second. Calling and publishing are two terms that refer to software that wishes to use the features and capabilities of an API. In other words, APIs allow users and other programmes to access data that has been requested by them.For example, preset roles govern which services may access certain actions or data, and access to a given service or feature is authenticated against predefined roles. APIs also offer a system audit trail that shows who or what accessed the system when.

A lot of the time, the applications that call APIs have been developed in a specific programming language. However, web APIs may also be accessible using HTML or application generation tools. Representative state transfer (REST) and Simple Object Access Protocol (SOAP) are the two most prevalent API architectures, and they both offer standard communication protocol specifications for XML-based message exchange. However, REST APIs are easier to scale and redeploy as well as to build and connect with websites and services than SOAP APIs, which need less low-level infrastructure-related code. Particularly for web-based interactions, REST APIs are the current industry standard.

SQL Injection 101

Yong Dev — Mon, 30 Aug 2021 11:18:32 +0000

Security flaws such as SQL injection allow an attacker to meddle with a database query. It allows an attacker to access data that they would not usually be able to. Data belonging to other users, or any other data that the programme itself has access to, may be included in this. As a result, the application's content or behaviour can be permanently altered by an attacker in many instances.

Sometimes, an attacker can use a denial-of-service attack in conjunction with a SQL injection attack to compromise a server.

SQL Injection - What is It?

SQL Injection (Sqli) is a sort of injection attack that allows malicious SQL queries to be executed. These statements are used to operate a database server that is hidden behind a web app. By exploiting SQL Injection vulnerabilities, attackers are able to circumvent application security controls. SQL Injection is a technique that allows hackers to add, edit, or remove entries in a database by bypassing the authentication and permission of a web page or online application.
Any website or online application that uses a SQL database, such as Oracle, SQL Server,MySQL, or others, may be vulnerable to the SQL Injection vulnerability. Cybercriminals may use it to obtain illegal access to your sensitive data, including your customer information, personal information, and more, Security experts consider SQL Injection attacks to be one of the web's oldest, most common, and most serious weaknesses. Injections are the number one danger to online application security, according to the OWASP organisation (Open Web Application Security Project).

An SQL Injection Attack: How It Works and Why it Is

An attacker must first discover immune - compromised user inputs on a web page or web application in order to launch a SQL Injection attack against them. Such user input is used directly in a SQL query on a web page or web application that contains a SQL Injection vulnerability. The attacker has the ability to produce input material and modify it. Malicious payloads are commonly used to describe this type of material. As soon as the attacker delivers this material to the database, malicious SQL instructions are performed.

In relational databases, SQL is the query language of choice. Access, change and delete data is possible with it. As a result, SQL databases are used by many online apps and websites to store all the data. Additionally, you can utilise SQL commands to perform operating-system commands in specific situations. SQL Injection attacks can have significant repercussions if they succeed.

It is possible for hackers to discover other users' passwords by using SQL Injections on the database. Then, they can pose as these users and get access to their accounts. Alternatively, the impersonated user may be an administrator of a database with full access capabilities.
SQL allows you to retrieve and produce data from a database using a query language. Unpatched SQL Injection flaws might enable a hacker access to all of the information contained within an organization's database server.
Some database servers allow you to connect to the operating system through the database server itself. This might be deliberate or unintentional. SQL Injection might be used in such a scenario to attack the internal network behind a firewall.
SQL also allows you to add and edit data in a database. Example: An attacker might use SQL Injection in a banking software to manipulate balances and move money to their account.
As well as deleting entries, you can also drop tables using SQL. In spite of database backups, loss of data might impair app availability until backups are restored, assuming they are made. In addition, backups may not include the most current data, which might be problematic.

These attacks can be classified as in-band (using database faults or UNION commands), blind, and out-of-band (using a remote server). Please see the following articles for further information about them: SQL Injections.

An Example of SQL Injection

To begin, let's look at a basic example. An attacker can circumvent application security by exploiting a SQL Injection vulnerability to authenticate as the administrator.

A web server executes the following pseudocode. Authentication with a username and password is demonstrated in this example. Username and password are stored in a table named users in the sample database.

# Define POST variables
user = $_POST['username'];
pass = $_POST['password'];

# SQL query vulnerable to SQLi
sql = “SELECT id FROM users WHERE username=’” + user + “’ AND password=’” + pass + “’”

# Execute the SQL statement
database.execute(sql)

SQL Injection is possible in these input fields. An attacker might utilise SQL instructions in the input to change the SQL statement that the database server executes. They could, for example, use a single quote technique to change the pass field to:badguy' OR 1=1
So, the database server executes this SQL query:
SELECT id FROM users WHERE username='username' AND password='password' OR 1=1'
The WHERE clause returns the first id from the users table regardless what the username and password are because of the OR 1=1statement. The administrator is frequently the initial user id in a database. The attacker not only gets administrator access but also bypasses authentication.

How to Prevent an SQL Injection

SQL Injection issues can be difficult to prevent. SQLi vulnerability subtypes, SQL database engines, and programming languages all have different protection methods. If you want to make your online application safe, there are a few broad strategic guidelines to follow.

Step 1: Train yourself and stay mindful

If you want to make your online application safe, everyone engaged in creating it has to know about SQL Injections. All your developers, QA personnel, DevOps, and SysAdmins should receive appropriate security training. You might start by directing them to this website.

Step 2: Don't rely on any input from the user.

You should consider all user input to be suspect. As long as a user input is utilised in a SQL query, there is a possibility of SQL Injection occurring. Use the same approach when dealing with input from authorised and/or internal users.

Step 3:Take advantage of the newest technology.

There's no SQLi security in older web development tools. Ensure that you're using the newest version of the development environment and language, as well as the latest technology associated with those environments/languages Use PDO instead of MySQLi, for example, in PHP.

Step 4: Using whitelists instead of blacklists.

The usage of blacklists should not be used to censor the input of users. A smart attacker will almost always find a method to get around your blacklist. Whenever feasible, only employ tight whitelists to validate and restrict user inputs.
Step 5: Scan on a frequent basis.
It is possible for your developers to add SQL Injections, or for other libraries/modules/software to do so. A web vulnerability scanner should be used to check your online applications on a regular basis.

Step 6: Verify your methods.

Don't try to create SQLi protection from the ground up. Almost all of today's programming tools have techniques for protecting against SQLi. Such techniques should be used instead of attempting to try something new from scratch Use structured query language, for example, or stored procedures.

Forem: Yong Dev

FlyEnv: The All-in-One Tool That Could Replace Your Docker Workflow

What is FlyEnv?

Key Features That Stand Out

1. Native Performance (No Virtualization)

2. True "Polyglot" Support

3. Project-Level Isolation & Version Management

4. Built-in Production Simulators

FlyEnv vs. Docker: Which Should You Use?

Conclusion

Adding TypingDNA Verify as a 2FA to your Auth0 login

Install the required dependencies.

Send One Time Passwords Over Voice Calls in PHP Using Twilio Verify

Prerequisites

Application Process

Create the project directory

Create the database

Set up the Twilio PHP Helper Library

Create the signup and sign in page

Note

That's how to use Twilio Verify to deliver an OTP via calls with PHP.

Help me please!

How to Manage Dates and Times in PHP Using Carbon

Prerequisites

Installation

Format dates using Carbon

Print dates

Create dates with precision

Relative Modifiers

Looking forward and back

Format the date and time

Calculate relative time

That's the essentials of managing dates and times in PHP using Carbon

What did you learn this Week

Get Paid Writing

You Learnt ?

How To Send Email Using PHPMailer in PHP

Introduction

Prerequisites

Installation

Installing PHPMailer

Use PHPMailer to send emails from a local server

Sending emails with SMTP server

Conclusion

How to Debug PHP Using Xdebug On Vscode

Introduction

Prerequisites

Step 1 — How to Download and Install the XDebug Tool

Windows

MAC

Linux

Step 2 — Enabling the XDebug extension in PHP

Conclusion

API

What are APIs and how do they work?

SQL Injection 101

SQL Injection - What is It?

An SQL Injection Attack: How It Works and Why it Is

An Example of SQL Injection

How to Prevent an SQL Injection

Step 1: Train yourself and stay mindful

Step 2: Don't rely on any input from the user.

Step 3:Take advantage of the newest technology.

Step 4: Using whitelists instead of blacklists.

Step 6: Verify your methods.