DEV Community: Odunayo Ogungbure

Shorthand Conditionals in PHP You Should Know

Odunayo Ogungbure — Wed, 30 Apr 2025 08:09:34 +0000

The if...else statement is one of the most common logic patterns we write as programmers. It executes one block of code if a condition is true, and another if the condition is false. It’s so fundamental that I honestly can’t remember a day I didn’t write some form of if condition.

As a quick refresher, here’s what the basic syntax looks like:

if (condition) {
    // code to execute if condition is true
} else {
    // code to execute if condition is false
}

Imagine you’re building an e-commerce backend. When a user makes a payment, you want to handle scenarios where the payment is successful or fails:

if ($payment->isSuccessful()) {
    // Mark order as paid
    // Generate invoice
    // Update user’s purchase history
    // Send confirmation email
} else {
    // Log the failure
    // Notify the user
}

In the example above, both the success and failure paths include multiple steps. This is where the traditional if...else syntax shines; it keeps your logic clean, organised, and easy to maintain.

But sometimes, our logic isn’t that complex. For instance, what if we simply want to check if a user's role is "admin"? If it is, they can access a page; if not, they can’t. Writing the traditional if...else block for this might seem too much.

Luckily, PHP provides shorthand techniques for conditional logic that can keep your code concise and readable.

In this article, we’ll explore some of these shorthand methods and when best to use them.

1. Ternary Operator

This is probably the most well-known shorthand for conditionals, and chances are, you've already seen it in the wild.

$value = (condition) ? 'return this if true' : 'return this if false';

This would normally be a 4–5 line traditional if...else block, but now it is just a single line. It’s great for simple decisions where both outcomes are straightforward.

$score = 70;
$result = ($score >= 70) ? 'pass' : 'fail';

Nesting Ternary Operators

You can nest ternary operators, but here’s a big disclaimer: I don’t recommend it. It quickly becomes unreadable and error-prone. It’s usually better to stick to the traditional if...else block.

$value = ($user->isAdmin())
    ? 'Show admin panel'
    : ($user->isEditor() ? 'Show editor dashboard' : 'Show viewer homepage');

Yes, it works—but imagine debugging this later 😅

2. Elvis Operator (Short Ternary)

You might wonder why it's called "Elvis." Got no idea 🤷🏾‍♂️.

The Elvis operator is a shortened version of the ternary operator where the middle part is omitted. It returns the condition if it's truthy, or a fallback value if not.

$displayName = ($name) ? $name : 'Guest';  // Regular ternary
$displayName = $name ?: 'Guest';          // Elvis shorthand

3. Null Coalescing Operator (`??`)

Ever had to do an isset() check before using a value?

$email = isset($_POST['email']) ? $_POST['email'] : '';

With the null coalescing operator (??), it becomes much cleaner:

$email = $_POST['email'] ?? 'fallback value';

What it does is check if the left-hand side is set and not null. If it is, that value is returned. Otherwise, the right-hand side is returned.

var_dump($a ?? 'fallback') // 'fallback';
var_dump($a['yt'] ?? 'fallback') // 'fallback';
var_dump(null ?? 'fallback') // 'fallback';
var_dump(false ?? 'fallback') // false;
var_dump(true ?? 'fallback'); // true
var_dump('' ?? 'fallback'); // ''
var_dump(0 ?? 'fallback'); // 0

This operator is also super useful for nested data, like accessing array keys or object properties without a ton of isset() checks:

$user['bio']['address'] ?? '-';
$user->bio->address ?? '-';

You can even set defaults in one step using the null coalescing assignment (??=), available in PHP 7.4+:

$_POST['user'] ??= 'Guest';

Which is the same as:

$_POST['user'] = $_POST['user'] ?? 'Guest';

4. Spaceship Operator (`<=>`)

This one isn’t used every day, but it's good to know.

The spaceship operator is also called the three-way comparison operator. It compares two values and returns:

-1 if the left side is less than the right
0 if they are equal
1 if the left side is greater

echo 5 <=> 10;  // -1
echo 10 <=> 10; // 0
echo 15 <=> 10; // 1

It can be used with numbers, strings, arrays, and even objects (if properly implemented). It’s useful when writing custom sorting logic.

Final Thoughts

PHP’s shorthand comparison can help reduce the amount of boilerplate code and keep things concise, but always remember: readability matters. Just because you can write a fancy one-liner doesn’t mean you should. Use shorthand where it makes sense, and fall back to the traditional if...else when the logic gets too layered or complex.

Sometimes, writing it the long way is the smart way.

Deploy a Laravel Project on Heroku with SQL Database

Odunayo Ogungbure — Thu, 27 Jan 2022 20:31:13 +0000

Heroku is a popular Platform-as-a-Service (PaaS) that enables developers to deploy and run their Web or API applications in the cloud. Heroku offers a free plan making it easy for developers to host an application online for testing or cases where you don't need to buy a hosting service just yet. Heroku supports several languages such as Ruby, Java, Node.js, Scala, Clojure, Python, PHP and Go making it a good option among developers for hosting their projects for testing.

In this article, we'll be going over a step-by-step approach to deploying a Laravel project on Heroku.

Requirements

To follow through with this article, you need to have the following setup:

Git
A Laravel project ready for deployment; if you don't have one yet, you can clone this sample project from Github
A Heroku account, and
Heroku command-line interface (CLI) installed on your machine. You can find instructions on installing the CLI here.

To begin, open the terminal, navigate to the Laravel project directory location and type in the command below to login into your Heroku account.

heroku login

The command will open up your browser to log into your Heroku account.

Once you are logged in successfully, you should see a page similar to the one below.

To get our Laravel application on Heroku, we will use Git version control. Initialize git in the Laravel project if git is not initialized else, you can skip this step.

git init
git add .
git commit -m"Initial commit"

Create a file at the root of the Laravel project named Procfile. A Procfile is a simple text file without a file extension that specifies the application's commands on startup in Heroku. The Procfile must be placed in the root directory as it would not function in any other location.

Copy and paste the below in the Procfile. The command launches an Apache server with PHP installed.

web: vendor/bin/heroku-php-apache2 public/

Commit the changes

git add .
git commit -m"Heroku Procfile"

Create Heroku Application

To create an application on Heroku, we can use the heroku create <app-name> command. The command will create an application on Heroku and generate a URL to access the application; however, you will have to supply a new unique name if the name already exists. Also, note that if no <app-name> is provided, Heroku will generate a random name.

heroku create laravel-heroku-deployment

The above command creates an application called laravel-heroku-deployment, as seen on my dashboard

and generates the URL https://laravel-heroku-deployment.herokuapp.com to access the application.

Next, we use the git push command to push our code to Heroku, which will install the project dependencies.

git push heroku main

Visit the Heroku application URL generated, and we should see an error page which we will fix in the next section.

Setting Environment Variables

We had the 500 error after pushing our code in the previous section because the environment variables in the .env file needed for our application to work are not on Heroku. Environment variables can be added in two ways:

Using the Heroku CLI

To set environment variables using the Heroku CLI, we will be using the heroku config:add <ENV_NAME>=<ENV_VALUE> command.

heroku config:add APP_DEBUG=true

To confirm the environment variable is set, click the application on your Heroku dashboard, click on the settings menu, and click on "Reveal Config Vars". The variable has been added to the list of config variables.

Visit the application URL, and we can see what the error is since APP_DEBUG is enabled.

From the Heroku dashboard

The second method of adding environment variables to our application is by adding variables on the "Reveal Config Vars" section. Let's add the APP_KEY variable using this section. Go to your terminal and run the command.

php artisan key:generate --show

and copy the output and paste as the value of APP_KEY on your dashboard.

Now our application should be running 😎.

Connect Database

Now that our Laravel application is running on Heroku, we can connect a database to the application. In this article, we will be using PostgreSQL as Heroku supports PostgreSQL natively. Note that you can use any other database like MySQL etc., through Heroku addons or use third party databases such as db4free.

To get started, click on the Resources menu and in the addons section, search for Heroku Postgres

and select the Hobby Dev plan which is free.

Once the addon heroku-postgresql is attached, a new environment variable DATABASE_URL is automatically added to the Heroku application. You can confirm this by checking the Config Vars section. Also, add a new environment variable DB_CONNECTION and set its value to pgsql

To manually view the database credentials, Click on the attached PostgreSQL addon, navigate to the settings page and click the View Credentials.

To run any of Laravel's artisan command precede all statements with heroku run. Paste the below in your project terminal to migrate all tables.

heroku run php artisan migrate:fresh

If you cloned the sample project on Github, you could run the db:seed command to seed the posts table and visit the /posts route to see the seeded posts.

heroku run php artisan db:seed

Conclusion

Voila 😄! Now you can deploy your Laravel applications on Heroku for free without sweating over server costs. To learn more about Heroku, check the Heroku Docs. Thanks for taking the time to read this article. I hope it helps you. Happy Coding 😎!

Stacky REST API #4 - Push Project to Github

Odunayo Ogungbure — Tue, 01 Dec 2020 08:29:48 +0000

GitHub is a web service that helps developers store, track and control changes to their code.

What Is GitHub, and What Is It Used For?

Ensure to have git installed and setup on your machine. You can download git here.

Visit Github and create an account or sign in if you already have one and then create a new repository called stacky.

Head back to our project, open up the terminal and initialize an empty git repository;

$ git init

Add a .gitignore file at the root of our project. A .gitignore file specifies which files and folders should be ignored in a given source code. This means this files and folder will not be pushed and tracked by git.

/node_modules 
/dist
.env
yarn-error.log

Notice we added our .env file to be ignored because the .env file usually contains sensitive or localized information. In the case of sensitive information, like API keys, authentication keys and so on, we won't want these sitting in version control where they can be publicly accessed.

But then how do any user who pulls our projects knows what environment variables needs to be set. Simple, let's add a .env.example file and as the name implies this is just an example file which users can then use to create their .env file. So let's add this file to the root of our project.

PORT=
DB_HOST=
DB_USERNAME=
DB_PASSWORD=
DB_DATABASE=

Next, we need to stage and commit our changes;

$ git add .
$ git commit -m"First commit"

Back to the Github screen on the browser, scroll down to the "... or push an existing repository from the command line" and copy the commands into your terminal.

Head to your GitHub repo and you should see your codes in the main branch.

Heads up: If you have a previous version of git installed on your system, your default branch might be master.

Stacky REST API #3 - Connecting Database

Odunayo Ogungbure — Sat, 28 Nov 2020 19:46:32 +0000

In this part, we'll be connecting a database to our project. As mentioned in Part #1, PostgreSQL will be used as the database. To set up PostgreSQL on your machine, you can follow this guide for Windows or this for Linux.

We'll also be using an Object-Relational Mapper (ORM) - Sequelize a promise-based Node.js ORM for Postgres, MySQL, MariaDB, SQLite and Microsoft SQL Server to query the database.

Object-Relational Mapping is a technique that lets you query and manipulates data from a database using an object-oriented pattern. This makes interacting with the database easier to work with as we won't be writing SQL statements often but instead interacting with the database using objects.

To begin, install sequelize, sequelize-cli and the driver for our database as a dependency;

$ yarn add sequelize sequelize-cli pg pg-hstore

To create an empty project you will need to execute init command;

$ npx sequelize-cli init

This will create the following folders:

config, contains config file, which tells CLI how to connect with database
models, contains all models for your project
migrations, contains all migration files
seeders, contains all seed files

Let's move these folders into the src folder;

stacky
|-- node_modules
|-- src
    |-- config
    |-- migrations
    |-- models
    |-- seeders
    |-- app.js
|-- package.json
|-- yarn.lock

Since we changed the location of the folders created by sequelize-cli, we need to inform sequelize of this change. To do this, create a .sequelizerc file at the root of our project.

stacky
|-- node_modules
|-- src
|-- .sequelizerc
|-- package.json
|-- yarn.lock

Copy the below into the newly created file.

const path = require('path');

module.exports = {
  "config": path.resolve('./src/config'),
  "models-path": path.resolve('./src/models'),
  "seeders-path": path.resolve('./src/seeders'),
  "migrations-path": path.resolve('./src/migrations')
};

With this config we are telling sequelize-cli to:

Use src/config file for config settings
Use src/models as models folder
Use src/seeders as seeders folder
Use src/migrations as migrations folder

Next, we need to tell sequelize how to connect to the database. To do that, open the config.json file in the src/config folder.

Rename the file to config.js. The reason which we will see in a minute is, we will be using the import statement which we can't use in JSON files. Copy the content below into the file and modify to match your PostgreSQL credentials.

module.exports = {
  development: {
    username: 'username',
    password: 'password',
    database: 'stacky',
    host: '127.0.0.1',
    dialect: 'postgres'
  },
  production: {
    username: 'username',
    password: 'password',
    database: 'stacky',
    host: '127.0.0.1',
    dialect: 'postgres',
  }
};

Edit the .sequelizerc file to inform sequelize of the file name change;

"config": path.resolve('./src/config', 'config.js'),

Next is to create our database. Run the command in the terminal. This will create a database using the name supplied in the config.js file. Launch pgAdmin tool and you will see the database created.

$ npx sequelize-cli db:create

NOTE: If you encounter the error below, ensure you are using the right credentials in the **config.js* file.*

$ ERROR: password authentication failed for user "username"

Let's briefly take a look at the other folders created.

In the models folder, the index.js requires modules needed. It then reads the current environment, if no environment is defined, it defaults to development. Next, it establishes connections with the database, read all the files in the model's folder, imports and adds it to the DB object, applies relationships between models if exists and finally exports the DB object.

It's in this folder, we are going to be adding our model files.

A model is a set of criteria that determines what counts as a valid database entry. In a SQL object-relational manager, each candidate table row flows through the model, which determines whether the row has the required column-cells and whether those cells are well-formed based on the model’s rules. If the row passes all the model’s checks, it is entered into the database
Source

The migrations folder is where we will be creating our migration files.

A migration is a set of database operations that has an “up” function and a “down” function. The “up” function changes the database and the “down” function attempts to restore the database to how it was before the “up” function ran. You can use migrations for structural database operations, like adding tables, columns, and whatnot.
Source

Lastly, the seeder folder is where we will be having our seed files.

[Database seeding is the initial seeding of a database with data. Seeding a database is a process in which an initial set of data is provided to a database when it is being installed. It is especially useful when we want to populate the database with data we want to develop in future. This is often an automated process that is executed upon the initial setup of an application. The data can be dummy data or necessary data such as an initial administrator account.
Source

Environment Variables

Let's paint a scenario where a developer, B picks up our project to work on. Definitely, his database credentials will be different, so he needs to edit the database config file in our project. Developer C also picks up the project and on his system port 3000 which we are serving the project on is in use by another application, he needs to change this. By the time we are moving to production the same thing. What about the secret keys our project might use.

One thing common above is some values change depending on the environment the project is in. This is why we need environment variables. It takes away the continuous tweaking of certain values in our code base.

Simply put, use environment variables in any place a value in your code will change based on the environment. Using an environment variable in our node application is as simple as;

const PORT = process.env.VARIABLE_NAME

To manage our environment variables, a popular solution is by creating a .env file in our project.

Create a .env file in the root of the project and let's add variables and values to it.

stacky
|-- node_modules
|-- src
|-- .env
|-- .sequelizerc
|-- package.json
|-- yarn.lock

Let's add some environment variables and its value to the file;

PORT=3000
DB_HOST=127.0.0.1 
DB_USERNAME=username
DB_PASSWORD=password
DB_DATABASE=database

NOTE: If any value will have space between, wrap in double quotes ("another value").

Next is to find a way for Node.js to be aware of the .env file, its location and contents. This is a good package - dotenv we can install to do the heavy lifting.

$ yarn add dotenv

Next is to import the package as early as possible and configure it. This we can do in the app.js file.

import express from 'express';
import dotenv from 'dotenv';

dotenv.config();
const app = express();

// Rest of code omitted

Still in the app.js file, let us use the PORT environment variable.

// Rest of code omitted

// Environment variables are returned as strings
// so we need to convert to number
const port = parseInt(process.env.PORT, 10) || 5000;

// Rest of code omitted

Run the application and everything should still work.

NOTE: Any changes to the *.env** file requires the application to be stopped and started again for the application to be aware of the changes*

Let's head back to the config.js file in the config folder and user the environment variables.

const dotenv = require('dotenv');
dotenv.config();

module.exports =  {
  development: {
    username: process.env.DB_USERNAME,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_DATABASE,
    host: process.env.DB_HOST,
    dialect: 'postgres'
  },
  production: {
    username: process.env.DB_USERNAME,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_DATABASE,
    host: process.env.DB_HOST,
    dialect: 'postgres',
  }
};

In this part, we have successfully created and connected a database to our project. In the next part, we'll be pushing our code to Github.

Stacky REST API #2 - Babel Setup

Odunayo Ogungbure — Fri, 27 Nov 2020 10:58:26 +0000

Welcome to part two of building a REST API with Node.js. In the previous part, we covered the initial setup and in this part, we'll be adding babel to our project.

Babel is a tool used to convert ECMAScript 2015+ code not included in the recent Node.js versions, into a backwards-compatible version that older environment will understand.

Open up the app.js file and use javascript import statement instead of require.

import express from 'express';

Run the application and sadly it breaks 😟!

To fix this let's set up our hero 🦸‍♂️ Babel by installing the following dev-dependencies;

$ yarn add @babel/core @babel/preset-env @babel/node -D

@babel/core - the core functionality of Babel.
@babel/preset-env - common bundles of plugins needed to transpile new and upcoming features.
@babel/node - works exactly the same as the Node.js CLI, with the added benefit of compiling with Babel presets and plugins before running it.

Edit the start script in the package.json file;

"start": "nodemon --exec babel-node src/app"

In the project's root folder, create a .babelrc;

{
    "presets": [
        "@babel/preset-env"
    ]
}

Run the application again and it works!

What babel is simply doing is transpiling our code to vanilla JavaScript under the hood. Anytime you use a JavaScript feature, which hasn't been introduced in Node.js, Babel makes sure that Node.js understands it so our application doesn't break.

One more important step we have to do is to build our application. In reality, we won't be using nodemon and transpiling our code at runtime when we move our application to production. Rather, we push the transpiled codes to our production server.

Install the @babel/cli module which allows us to use babel from the terminal.

$ yarn add @babel/cli -D

Let's add a build script to our package.json file. This executes babel on the javascript files in the src folder and outputs the transpiled code to a dist folder which we can then upload to our production server.

"build": "babel src/ -d dist/"

Build the application and we should see a dist folder in our project. You can take a look at the app.js file to see the output.

$ yarn build

Lastly, we need to modify the scripts section in the package.json file.

"scripts": {
    "build": "babel src/ -d dist/",
    "dev": "nodemon --exec babel-node src/app",
    "start": "node dist/app"
},

In the next article, we’ll be setting up a database for our application.

Stacky REST API #1 - Introduction

Odunayo Ogungbure — Wed, 25 Nov 2020 21:59:53 +0000

In this tutorial series, we’ll be learning how to build a REST API with Node.js by building a simple Q&A platform, Stacky. We'll be covering authentication, authorization, mails, testing, documentation, deployment and more.

This tutorial requires an intermediate knowledge of JavaScript along with basic knowledge of Node.js and PostgreSQL.

Requirements

Node
Postgresql
Yarn (optional)
Postman

Application Overview

User can signup and sign in.
Users can verify their email address.
Authenticated users can post a question.
Authenticated users can answer a question.
Question owner can mark an answer as accepted.
Question owner can delete his question.
Answer owner can delete his answer
Question owner can mark an answer as accepted and much more.

Getting started

To get started let's create our project folder and name it stacky. Open up the terminal and run the command to initialize the app;

$ yarn init -y

This creates a package.json file that holds information about our application.

Next is to add express as a dependency.

$ yarn add express

Create a folder src in the project folder. Within this src folder we'll also create a new app.js file which will serve as our application entry point. Our folder structure should be something like this;

stacky
|-- node_modules
|-- src
|   |--- app.js
|-- package.json
|-- yarn.lock

Let's add a basic hello world example. Copy the snippet below into the app.js file.

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => res.send('Hello World 😎!'));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

To run this file, open up the terminal and run the command below. This spins up a server on port 3000.

$ node src/app

Navigate to localhost:3000 on your browser and you should see "Hello World" printed on your screen.

NPM Scripts

The node src/app command seems not to be friendly to always type. What if we could automate this?

NPM scripts are scripts used to automate repetitive tasks.

Open up the package.json file and add a scripts object if absent. Within this object, the key is the name of the script and the value contains the script you want to execute.

"scripts": {

}

Let's use one of the special NPM scripts, the start script. You’ve probably seen this or will probably see this a lot;

"scripts": {
    "start": "node src/app"
}

Your package.json file should be looking like this;

"name": "stacky",
"version": "1.0.0",
"main": "index.js",
"license": "MIT",
"scripts": {
    "start": "node src/app"
},
"dependencies": {
  "express": "^4.17.1"
}

Go back to the terminal and type in the command below and notice our application still works.

$ yarn start

To learn more about NPM scripts - Introduction to NPM Scripts

Let's make a change to the app.js file;

// Change the response text
app.get('/', (req, res) => res.send('We are one 💪🏾!'));

Refresh the page on the browser and you will notice there's no change. No matter how many times you refresh, you still see the previous text.

To solve this, you need to go to the terminal, stop the server and start again with the yarn start command.

This is a big problem! Imagine having to always restart the server anytime you make a change to your codebase, that's way too stressful. What if we have a tool that automatically re-starts the server anytime we make a change?

Nodemon

Nodemon is a utility that will monitor for any changes in your source code and automatically restart your server.

Open up the terminal and install nodemon as a dev-dependency as it's only needed for development purpose.

$ yarn add nodemon -D

Once installed, change your start script to;

"scripts": {
    "start": "nodemon src/app"
},

Start the server and visit the browser, you should see the text on the screen;

$ yarn start

To test if nodemon works, change the text in the app.js file and save.

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => res.send('One of a kind 🤩'));

app.listen(port, () => console.log(`Example app listening at http://localhost:${port}`));

Go back to your browser, refresh and it's changed 🍻

Next on building stacky API, we'll be adding babel to our project.

Setup Linux, Apache, MySQL, PHP(LAMP) Stack on Ubuntu 18.04

Odunayo Ogungbure — Tue, 24 Nov 2020 13:18:17 +0000

The LAMP stack is a set of open-source software used to host web applications. A web application requires an operating system (Linux), an HTTP Server (Apache), a database management system (MySQL), and a programming language (PHP).

While there are other alternatives to MySQL as the database such as MariaDB, PostgreSQL, NoSQL databases, and also alternatives to PHP as the programming language such as Perl and Python. This guide will focus mainly on MySQL as the database and PHP as the programming language.

Prerequisites

To follow this guide, an Ubuntu server setup with a non-root sudo enabled user is required. In this guide, my domain will be demoapp.com.

Apache

Install Apache using Ubuntu's package manager apt:

sudo apt update
sudo apt install apache2

apt will display the packages it's about to install and the disk space that will be taken up. Press Y and hit ENTER to continue, and the installation will proceed.

Note: sudo command operations are executed with root privileges, so you might be required to input your user's password.

On your browser navigate to the server's public IP address (http://server_ip) and you should see the Apache2 Ubuntu default page.

PHP

Install the ppa:ondrej/php PPA repository which has the latest build packages of PHP.

sudo apt install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt-get update

In this guide, we will be installing php7.4;

sudo apt install php7.4

Confirm the installation using the command;

php -v

Next, install some commonly used PHP extensions;

sudo apt install php7.4-common php7.4-mysql php7.4-xml php7.4-xmlrpc php7.4-curl php7.4-gd php7.4-imagick php7.4-cli php7.4-dev php7.4-imap php7.4-mbstring php7.4-text php7.4-opcache php7.4-soap php7.4-zip php7.4-intl

Setting Up Virtual Hosts

When using Apache web server, we can create virtual hosts to enclose configuration details. This allows us to host more than one domain on a single server. Apache on Ubuntu is enabled by default to serve files from the /var/www/html folder. This works well for a single site, so if this is what you need, you can dump in your code files into this folder and skip to the next section.

Create a directory within the /var/www for our domain site and assign ownership of the directory;

sudo mkdir /var/www/demoapp.com
sudo chown -R $USER:$USER /var/www/demoapp.com

Create an index.php page using nano;

nano /var/www/domain/index.php

Add the following and save the file;

<html>
    <head>
        <title>Hello World</title>
    </head>
    <body>
        <h1>Hello world from demoapp</h1>
    </body>
</html>

Next, create a virtual host file to serve this content. Let's make a copy of the default configuration file and modify;

cd /etc/apache2/sites-available
sudo cp 000-default.conf demoapp.com.conf

Open the file and modify the following directives to the correct value, save and close the file when done.

ServerName - demoapp.com (sets the request scheme, hostname and port that the server uses to identify itself).
ServerAlias - www.demoapp.com (sets the alternate names for a host).
DocumentRoot - /var/www/demoapp.com (sets the directory from which httpd - Apache Hypertext Transfer Protocol Server will serve files).

Enable the new configuration file and disable the default configuration file;

sudo a2ensite demoapp.com.conf
sudo a2dissite 000-default.conf

Check for configuration errors and if no errors restart Apache;

sudo apache2ctl configtest
sudo systemctl restart apache2

Test your changes by visiting the URL in your browser. You should see something like the below;

MySQL

Run the command below to install from apt package manager

sudo apt install mysql-server

Once the installation is complete, we need to run a script pre-installed with MySQL that helps improve the security of our installation in the following ways:

Sets a password for the user root account.
Remove root accounts that are accessible from outside the local machine.
Remove anonymous user accounts (These are accounts that allows anyone to connect into the MySQL server without having a user account).
Remove the test database, which can be accessed by anonymous users.

sudo mysql_secure_installation

First, you would be asked if you want to enable the validate password plugin. It's important to note that if enabled, passwords that don't match the specified criteria will be rejected by MySQL. For this guide, it won't be enabled, and if you do same ensure to use strong and unique passwords for database credentials.

Next, configure a password for the MySQL root user. For the rest of the questions, press Y and hit the ENTER key at each prompt.

Let's test our installation by logging in as the root user;

sudo mysql

Exit the MySQL console by typing exit and hit ENTER

Password Access For MySQL Account

When you connected with MySQL as the root user, you did not supply a password even though one was supplied during installation. This is because, on Ubuntu systems running MySQL 5.7 and later versions, the default authentication method for the root user is using the auth_socket plugin instead of a password.

This means, only system users with sudo privileges connecting from the terminal or through an application with the same privileges are allowed to log in as the root user. While this is a nice secure feature, you won’t be able to use the root user to connect from your PHP application or an external program like phpMyAdmin.

It is important to note that for increased security, it is better to create other users with fewer privileges especially if there will be multiple databases hosted on the server.

To switch the authentication method from auth_socket to mysql_native_password for your root user open up the MySQL prompt from your terminal:

sudo mysql

Next, confirm the root user does truly authenticate using the auth_socket plugin with the query below:

SELECT user,authentication_string,plugin,host FROM mysql.user;

Configure the root user to authenticate with a password. Replace 'password' below with a stronger password of your choice.

ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Reload the grant tables to enable your new changes.

FLUSH PRIVILEGES;

At this point, you have successfully set up a LAMP Stack. You can continue below for other optional setup options.

phpMyAdmin

To get started, install phpMyAdmin using Ubuntu's package manager apt:

sudo apt install phpmyadmin

This will ask you a few questions to configure your installation correctly. Take note of the following:

When the prompt appears, "apache2" is highlighted, but not selected. Press SPACE to select Apache followed by TAB and then ENTER.
When asked whether to use dbconfig-common to set up the database, select YES.

Next is to enter a MySQL application password for phpMyAdmin and enable the mbstring PHP extension using the command

sudo phpenmod mbstring

Restart Apache to enable the changes

sudo systemctl restart apache2

Navigate to http://demoapp.com/phpmyadmin to confirm your installation.

Note: You might encounter a count(): Parameter must be an array or an object that implements Countable error while working with the phpMyAdmin installed. While there are a ton of ways to solve this error on the web, I will go with the simplest option which is to upgrade phpMyAdmin.

Upgrading phpMyAdmin

Navigate to the home directory and install the dependency.

cd ~
sudo apt install unzip

Next, create a backup of the current phpMyAdmin directory.

sudo mv /usr/share/phpmyadmin/ /usr/share/phpmyadmin.bak

Download the latest version of phpMyAdmin and extract its contents.

wget www.phpmyadmin.net/downloads/phpMyAdmin-latest-all-languages.zip
unzip phpMyAdmin-latest-all-languages.zip

Create a new phpMyAdmin directory and move the contents of the extracted folder into the newly-created directory;

sudo mkdir /usr/share/phpmyadmin
sudo mv phpMyAdmin-*/* /usr/share/phpmyadmin/

Clean up the downloaded zip file and the extracted folder;

sudo rm phpMyAdmin-latest-all-languages.zip
sudo rm -rf phpMyAdmin-*/*

Update the TEMP_DIR and CONFIG_DIR constants in the vendor_config.php file.

sudo nano /usr/share/phpmyadmin/libraries/vendor_config.php

and update the value of the constant

define('TEMP_DIR', '/var/lib/phpmyadmin/tmp/');
define('CONFIG_DIR', '/etc/phpmyadmin/');

Save the file and log into phpMyAdmin and you should see you are on the latest version.

Secret passphrase in configuration is too short

If you see an error like the above, open the blowfish_secret.inc.php file

sudo nano /var/lib/phpmyadmin/blowfish_secret.inc.php

and update the value of $cfg['blowfish_secret']. This is a good tool to generate a random string

$cfg['blowfish_secret'] = '{^QP+-(3mlHy+Gd~FE3mN{gIATs^1lX+T=KVYv{ubK*U0V';

Save the file and the error should be gone on your phpMyAdmin dashboard.

Composer

within the home directory, download the composer installer using curl.

curl -sS https://getcomposer.org/installer -o composer-setup.php

Next, verify that the installer matches the SHA-384 hash for the latest installer found on the Composer Public Keys/Checksums page. Copy the hash and replace appropriately

php -r "if (hash_file('sha384', 'composer-setup.php') === '756890a4488ce9024fc62c56153228907f1545c228516cbf63f885e036d37e9a59d27d63f46af1d4d07ee0f76181c7d3') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

If you see Installer corrupt, redownload the installation script again and double-check that you’re using the correct hash. Once you have a verified installer, you can continue.

Install composer globally

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

To test the installation, type composer and hit ENTER in your terminal and you should see an output displaying composer's version and available commands.

Let’s Encrypt Free SSL Wildcard Certificate

Let’s Encrypt is a free, automated, and open certificate authority (CA), that provides digital certificates needed to enable HTTPS (SSL/TLS) for websites in the most user-friendly possible.

Install the ppa:certbot/certbot PPA repository and install certbot

sudo add-apt-repository ppa:certbot/certbot
sudo apt install certbot

Generate a wild card certificate using the command below;

sudo certbot certonly --manual -d *.demoapp.com -d demoapp.com --agree-tos --no-bootstrap --manual-public-ip-logging-ok --preferred-challenges dns-01 --server https://acme-v02.api.letsencrypt.org/directory

You should see something similar once you run the above command

Saving debug log to /var/log/letsencrypt/letsencrypt.log
Plugins selected: Authenticator manual, Installer None
Obtaining a new certificate
Performing the following challenges:
dns-01 challenge for demoapp.com
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Please deploy a DNS TXT record under the name
_acme-challenge.demoapp.com with the following value:
OGdBk2JteHzs8eWxNomoCWRrOJN83ECovDwRiL51ONY
Before continuing, verify the record is deployed.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
Press Enter to Continue

Create a DNS TXT record in your domain provider with the name _acme-challenge. Wait for a few minutes for the record to be propagated over the internet and then press ENTER. You should see a similar output

Waiting for verification...
Cleaning up challenges
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at:
/etc/letsencrypt/live/demoapp.com/fullchain.pem
Your key file has been saved at:
/etc/letsencrypt/live/demoapp.com/privkey.pem
Your cert will expire on 2021-02-23. To obtain a new or tweaked
version of this certificate in the future, simply run certbot
again. To non-interactively renew *all* of your certificates, run
"certbot renew"
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
Donating to EFF:                    https://eff.org/donate-le
Congratulations!! Your wildcard certificate is generated. You can use this wildcard certificate with any sub-domain you create for your domain name.

Modify the virtual host configuration file;

sudo nano /etc/apache2/sites-available/demoapp.com.conf

and add the following. Replace the appropriate values

<VirtualHost *:443>
    ServerName demoapp.com
    ServerAlias www.demoapp.com
    ServerAdmin info@demoapp.com
    SSLEngine On
    DocumentRoot /var/www/demoapp.com
    ErrorLog ${APACHE_LOG_DIR}/demoapp.com-error.log
    CustomLog ${APACHE_LOG_DIR}/demoapp.com-access.log combined
    SSLCertificateFile /etc/letsencrypt/live/demoapp.com/fullchain.pem
    SSLCertificateKeyFile /etc/letsencrypt/live/demoapp.com/privkey.pem
</VirtualHost>

Enable SSL module which is responsible for creating and serving SSL connections.

sudo a2enmod ssl

Check for configuration errors and if no errors restart Apache

sudo apache2ctl configtest
sudo systemctl restart apache2

Now you can visit https://demoapp.com

Conclusion

Following this guide, you should be able to successfully set up a LAMP stack and also install some necessary applications. Hope you found this useful.

Laravel Breeze - Minimalistic Authentication Scaffolding

Odunayo Ogungbure — Thu, 12 Nov 2020 14:11:13 +0000

Laravel Breeze was released by Taylor Otwell and the Laravel team a few days ago:

// Detect dark theme var iframe = document.getElementById('tweet-1325890243493556224-256'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1325890243493556224&theme=dark" }

I was one of the very few who wasn't so tripped with Jetstream for authentication scaffolding with the release of Laravel 8. I prefer using only Larvel Fortify and then build my own UI components around it.

Breeze?

According to the Github docs

Breeze provides a minimal and simple starting point for building a Laravel application with authentication. Styled with Tailwind, Breeze publishes authentication controllers and views to your application that can be easily customized based on your own application's needs.

This package can be said to be a lightweight simpler version of laravel/ui but uses Tailwind instead of Bootstrap. It has no presets like React or Vue, although that is subject to change in the future.

To get started with the package:

laravel new breeze-auth
cd breeze-auth

Next, we require the breeze library and run the install commands

composer require laravel/breeze --dev
php artisan breeze:install
npm run install
npm run dev

Run the migrate command and serve up the project and we should have our application enabled with authentication.

It's that simple to use!

Laravel 8: Routing Change

Odunayo Ogungbure — Wed, 16 Sep 2020 14:55:10 +0000

With the release of Laravel 8, there has been a change to the routing syntax which might catch you by surprise, at least it did to me. It wasn't under the high or low impact changes so I skipped reading to the end and it came back to haunt me.

In a fresh laravel 8 install, I have this in my web.php file:



Route::get('/', 'HomeController@index');

and this in the index method of the HomeController.php



    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        return view('welcome');
    }

This should be very familiar and we'd be expecting a view when we visit the / route. Rather what we see is an error page

You might start thinking you messed thing up, but no you didn't. Rather, in laravel 8 this syntax doesn't work by default. In the upgrade guide, it was mentioned but the likelihood of impact was optional 🤨. Though this was mentioned:

In most cases, this won't impact applications that are being upgraded because your RouteServiceProvider will still contain the $namespace property with its previous value. However, if you upgrade your application by creating a brand new Laravel project, you may encounter this as a breaking change.

The way to define your routes in laravel 8 is either



use App\Http\Controllers\HomeController;

// Using PHP callable syntax...
Route::get('/', [HomeController::class, 'index']);



// Using string syntax...
Route::get('/', 'App\Http\Controllers\HomeController@index');

A resource route becomes



Route::resource('/', HomeController::class);

This means that in laravel 8, there is no automatic controller declaration prefixing by default.

If you want to stick to the old way, then you need to add a namespace property in the RouteServiceProvider.php (This property was present in previous versions) and activate in the routes method.



    /**
     * This namespace is applied to your controller routes.
     *
     * In addition, it is set as the URL generator's root namespace.
     *
     * @var string
     */
    protected $namespace = 'App\Http\Controllers';

    // Edit boot method  
    /**
     * Define your route model bindings, pattern filters, etc.
     *
     * @return void
     */
    public function boot()
    {
        $this->configureRateLimiting();

        $this->routes(function () {
            Route::middleware('web')
                ->namespace($this->namespace)
                ->group(base_path('routes/web.php'));

            Route::prefix('api')
                ->middleware('api')
                ->namespace($this->namespace)
                ->group(base_path('routes/api.php'));
    });

To recap, in laravel 8 you can use the new syntax to define your routes or stick to the old way.

Build a Product Review REST API with Laravel

Odunayo Ogungbure — Fri, 31 Jul 2020 20:15:22 +0000

In this tutorial, we will be building a product reviews API. Users will be able to add, view, update and delete products. Users will also be able to rate and review a product. We will also be implementing authentication functionality with JSON Web Tokens (JWT) to secure our API.

Prerequisites

Basic knowledge of Laravel
Basic knowledge of REST APIs

Creating a new project

First we need to create a new laravel project

$ laravel new product-review-api

Then create your database and update the database credentials in the .envfile.

Create models and migrations

This API will be having 3 models: user, product and review. By default laravel comes with a user model, migration and factory file, so we will just be creating the remaining two. Let's start with the Product model:

$ php artisan make:model Product -a

The -a flag will create corresponding migration, controller, factory and seeder file for the model. We will be looking at the factory and seeder file in a bit.

Lets edit the product migration file as below:

Schema::create('products', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->longText('description');
    $table->decimal('price');
    $table->unsignedBigInteger('user_id');
    $table->timestamps();

    $table->foreign('user_id')
        ->references('id')
        ->on('users')
        ->onDelete('cascade');
});

We are just defining the columns for the products table and defining its relationship with the users table and what happens if the parent data is deleted.

Now we'll do the same for the Review model

$ php artisan make:model Review -a

And also define the reviews table structure

Schema::create('reviews', function (Blueprint $table) {
    $table->id();
    $table->unsignedBigInteger('user_id');
    $table->unsignedBigInteger('product_id');
    $table->text('review');
    $table->integer('rating');
    $table->timestamps();

    $table->foreign('user_id')
        ->references('id')
        ->on('users')
        ->onDelete('cascade');

    $table->foreign('product_id')
        ->references('id')
        ->on('products')
        ->onDelete('cascade');
});

Run the migrate artisan command and head over to your database manager and you should see the users, products and reviews table.

$ php artisan migrate

Model Relationships

While writing our migrations, we could see there's a relationship between the users, products and reviews table. Laravel ships with Eloquent ORM which provides a beautiful simple implementation for interacting with our tables.

Let's see what relationship exists between this tables.

A user can add many products but a product can only belong to one user. This is a one to many relationship between user and product.
A product can have many reviews but a review can only belong to one product. This is a one to many relationship between product and review.
And finally user can make many reviews (be it same or different products) but a review can only belong to one user. This is a one to many relationship between the user and review.

Now that we can see the relationship, let's define this in our model. The reason we are doing this is that eloquent makes managing and working with relationships easy, and supports a lot of relationship types.

In the User model (app\User.php), let us define the relationship between the user and the other models.

<?php

namespace App;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    // Rest omitted for brevity

    /**
    * Get the products the user has added.
    */
     public function products()
     {
         return $this->hasMany('App\Product');
     }

     /**
     * Get the reviews the user has made.
     */
     public function reviews()
     {
    return $this->hasMany('App\Review');
     }
}

On the product model we will define the relationship between the product and the review model, and also the inverse relationship to the user model.

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Product extends Model
{
    /**
     * Get the reviews of the product.
     */
    public function reviews()
    {
        return $this->hasMany('App\Review');
    }

    /**
     * Get the user that added the product.
     */
    public function user()
    {
        return $this->belongsTo('App\User');
    }
}

On the review model we will define the inverse relationship to the user and product model.

<?php

namespace App;

use Illuminate\Database\Eloquent\Model;

class Review extends Model
{
    /**
     * Get the product that owns the review.
     */
    public function product()
    {
        return $this->belongsTo('App\Product');
    }

    /**
     * Get the user that made the review.
     */
    public function user()
    {
        return $this->belongsTo('App\User');
    }
}

Database Seeding

Remember the factory and seeder file created when we ran the make:model command with the -a flag? Now it's the time to see this files in action.

Database seeding in summary is just populating tables with data we want to develop. In essence this means having fake data which we can be used for but not limited to testing, demo, building routes or views to consume this data, initial setup etc. without the need to start inputting this data manually.

Laravel ships with a PHP faker library Faker which is an awesome library by the way and this is the library used in creating the fake data.

Opening the UserFactory file which is included in by default, we see that how this works is we define the model we want to generate fake data for and return an associative array in which the key is the attributes on the model and the value is the relevant property or method on the faker library.

Now it's time to do same for the ProductFactory

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Product;
use App\User;
use Faker\Generator as Faker;

$factory->define(Product::class, function (Faker $faker) {
    return [
        'name' => $faker->word,
        'description' => $faker->paragraph,
        'price' => $faker->numberBetween(1000, 20000),
        'user_id' => function() {
            return User::all()->random();
        },
    ];
});

And ReviewFactory

<?php

/** @var \Illuminate\Database\Eloquent\Factory $factory */

use App\Review;
use App\User;
use Faker\Generator as Faker;

$factory->define(Review::class, function (Faker $faker) {
    return [
        'review' => $faker->paragraph,
        'rating' => $faker->numberBetween(0, 5),
        'user_id' => function() {
            return User::all()->random();
        },
    ];
});

Next is to write out our seeders. According to laravel's documentation

A seeder class only contains one method by default: run. This method is called when the db:seed Artisan command is executed. Within the run method, you may insert data into your database however you wish or use model factories to conveniently generate large amounts of database records.

While laravel comes with default user model, migration and factory files, it doesnt include a user seeder class. So we need to create one by running the command:

$ php artisan make:seeder UserSeeder

This will create a UserSeeder.php file in the database\seeds folder. Open the file and edit

/**
 * Run the database seeds.
 *
 * @return void
 */
public function run()
{
    factory(App\User::class, 50)->create();
}

We are using the factory helper method to insert 50 user records into the users table.

To run our seeders, open the database\seeds\DatabaseSeeder.php file and uncomment the line

$this->call(UserSeeder::class);

Then we can use the db:seed artisan command to seed the database. Head over to your users and you should see 50 user records created.

$ php artisan db:seed

Cool! Let's do the same for the ProductSeeder with a little twist

<?php

use Illuminate\Database\Seeder;

class ProductSeeder extends Seeder
{
    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        factory(App\Product::class, 100)->create()->each(function ($product) {
            $product->reviews()->createMany(factory(App\Review::class, 5)->make()->toArray());
        });
    }
}

No magic here, what we doing is simply creating 100 products and for each product we are creating 5 reviews for that product.

To call additional seeders in our DatabaseSeeder.php file, we pass an array instead to the call method

$this->call([
    UserSeeder::class,
    ProductSeeder::class,
]);

Let's use the migrate:fresh command, which will drop all tables and re-run all of our migrations. This command is useful for completely re-building our database. The --seed flag instructs laravel to seed the database once the migration is completed.

$ php artisan migrate:fresh --seed

Check your tables and Voila! I know this section might be overwhelming. If you are feeling overwhelmed by database seeding, I'll recommend going through laravel's documentation or search online for materials (there are a lot out there).

Authentication

To secure our application we will be using the package jwt-auth for authentication with JSON Web Tokens (JWT). Run the command to install the package latest version:

$ composer require tymon/jwt-auth

Note: If you are using Laravel 5.4 and below, you will need to manually register the service provider. Add the service provider to the providers array in the config/app.php config file as follows:

'providers' => [

    ...

    Tymon\JWTAuth\Providers\LaravelServiceProvider::class,
]

Next is to publish the package config file:

$ php artisan vendor:publish --provider="Tymon\JWTAuth\Providers\LaravelServiceProvider"

You should now have a config/jwt.php file that allows you to configure the basics of this package.

Next is to run the command below to generate a secret key. This secret key will be used to sign our tokens.

$ php artisan jwt:secret

This will update the .env file with something like JWT_SECRET=value

Before we can start authenticating our users using JWT we need to update the user model to implement the Tymon\JWTAuth\Contracts\JWTSubject contract, which requires we implement the 2 methods getJWTIdentifier() and getJWTCustomClaims().

<?php

namespace App;

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Tymon\JWTAuth\Contracts\JWTSubject;

class User extends Authenticatable implements JWTSubject
{
        // Rest omitted for brevity

    /**
     * Get the identifier that will be stored in the subject claim of the JWT.
     *
     * @return mixed
     */
    public function getJWTIdentifier()
    {
        return $this->getKey();
    }

    /**
     * Return a key value array, containing any custom claims to be added to the JWT.
     *
     * @return array
     */
    public function getJWTCustomClaims()
    {
        return [];
    }
}

To use laravel's built in auth system, with jwt-auth doing the heavy lifting we need to make a few changes to the config/auth.php.

'defaults' => [
    'guard' => 'api',
    'passwords' => 'users',
],

...

'guards' => [
    'api' => [
        'driver' => 'jwt',
        'provider' => 'users',
    'hash' => false,
    ],
],

Here we are telling the api guard to use the jwt driver, and setting the api guard as the default auth guard.

Now we can begin implementing the authentication logic into our application. Let's start by creating an AuthController

$ php artisan make:controller AuthController

Let's add a few methods to this controller.

<?php

namespace App\Http\Controllers;

use App\User;
use Illuminate\Http\Request;

class AuthController extends Controller
{
    public function __construct()
    {
      $this->middleware('auth')->except(['register', 'login']);
    }

    public function register(Request $request)
    {
        $request->validate([
            'name' => 'required|string',
            'email' => 'required|string|unique:users',
            'password' => 'required|string|min:8',
        ]);

        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => bcrypt($request->password),
        ]);
        $token = auth()->login($user);
        return $this->respondWithToken($token);
    }

    public function login(Request $request)
    {
        $request->validate([
            'email' => 'required|string',
            'password' => 'required|string',
        ]);
        $credentials = $request->only(['email', 'password']);
        if (!$token = auth()->attempt($credentials)) {
            return response()->json(['error' => 'Invalid Credentials'], 401);
        }
        return $this->respondWithToken($token);
    }

    protected function respondWithToken($token)
    {
        return response()->json([
            'access_token' => $token,
            'token_type' => 'bearer',
            'expires_in' => auth()->factory()->getTTL() * 60
        ]);
    }

    /**
     * Get the authenticated User.
     *
     * @return \Illuminate\Http\JsonResponse
     */
    public function me()
    {
        return response()->json(auth()->user());
    }

    /**
     * Log the user out (Invalidate the token).
     *
     * @return \Illuminate\Http\JsonResponse
     */
    public function logout()
    {
        auth()->logout();
        return response()->json(['message' => 'Successfully logged out']);
    }

}

We use the auth middleware to only allow authenticated users to access the methods while exempting the register and login methods. The register method creates and stores a new user into the database while the login method which logs user into the application. This two methods returns a JWT response by calling the respondWithToken() method. The me method returns the currently authenticated user while the logout method logs out the currently authenticated user from the application.

Let's define our api routes. Open up the routes/api.php and add the following routes.

Route::get('me', 'AuthController@me');
Route::post('login', 'AuthController@login');
Route::post('register', 'AuthController@register');
Route::post('logout', 'AuthController@logout');

Test the endpoints and we should see authentication working.

Product Endpoints

Let's begin by defining the product endpoints.

GET /products - Fetch all products
GET /products/:id - Fetch a single product and its reviews
POST /products - Create a product
PUT /products/:id - Update a product
DELETE /products/:id - Delete a product

In our routes/api.php file we can define this routes individually or use laravel resource routing feature or even better still use the api resource route feature. According to the laravel docs

When declaring resource routes that will be consumed by APIs, you will commonly want to exclude routes that present HTML templates such as create and edit. For convenience, you may use the apiResource method to automatically exclude these two routes:

So we add the products routes in the route file:

Route::apiResource('products', 'ProductController');

In the ProductController.php file

<?php

namespace App\Http\Controllers;

use App\Product;
use App\Review;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    public function __construct()
    {
      $this->middleware('auth')->except(['index', 'show']);
    }

    /**
     * Display a listing of the resource.
     *
     * @return \Illuminate\Http\Response
     */
    public function index()
    {
        $products = Product::with('user:id,name')
            ->withCount('reviews')
            ->latest()
            ->paginate(20);
        return response()->json(['products' => $products]);
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request)
    {
        $request->validate([
            'name' => 'required|string',
            'description' => 'required|string',
            'price' => 'required|numeric|min:0',
        ]);

        $product = new Product;
        $product->name = $request->name;
        $product->description = $request->description;
        $product->price = $request->price;

        auth()->user()->products()->save($product);
        return response()->json(['message' => 'Product Added', 'product' => $product]);
    }

    /**
     * Display the specified resource.
     *
     * @param  \App\Product  $product
     * @return \Illuminate\Http\Response
     */
    public function show(Product $product)
    {
        $product->load(['reviews' => function ($query) {
            $query->latest();
        }, 'user']);
        return response()->json(['product' => $product]);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Product  $product
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, Product $product)
    {
        if (auth()->user()->id !== $product->user_id) {
            return response()->json(['message' => 'Action Forbidden']);
        }
        $request->validate([
            'name' => 'required|string',
            'description' => 'required|string',
            'price' => 'required|numeric',
        ]);

        $product->name = $request->name;
        $product->description = $request->description;
        $product->price = $request->price;
        $product->save();

        return response()->json(['message' => 'Product Updated', 'product' => $product]);
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  \App\Product  $product
     * @return \Illuminate\Http\Response
     */
    public function destroy(Product $product)
    {
        if (auth()->user()->id !== $product->user_id) {
            return response()->json(['message' => 'Action Forbidden']);
        }
        $product->delete();
        return response()->json(null, 204);
    }
}

In the constructor we are using the auth middleware but exempting the index and show methods from using the middleware. This means unauthenticated users will be able to view all products and a single product which is okay for our api.

The index method, returns a list of products ordered by the created date, the number of reviews the product has and paginates the records.

The store method validates the request input and then creates a new product and attaches the product to the currently authenticated user and returns the newly created product.

The show method returns a single product, the creator(user) and its reviews.

The update method checks the currently authenticated user trying to update the record is the user that created the record. If the user is not the creator, a forbidden response is returned else we carry out the update operation.

The delete method checks the currently authenticated user trying to delete the record is the user that created the record. If the user is not the creator, a forbidden response is returned else we carry out the delete operation.

Review Endpoints

Let's begin by defining the review endpoints.

POST /products/:id/reviews - Create a review for a product
PUT /products/:id/reviews/:id - Update a product review
DELETE /products/:id/reviews/:id - Delete a product review

We define the apiResource route for the reviews and also specifying actions the controller should handle instead of the full set of default actions.

Route::apiResource('products/{product}/reviews', 'ReviewController')
    ->only('store', 'update', 'destroy');

In the ReviewController.php file

<?php

namespace App\Http\Controllers;

use App\Product;
use App\Review;
use Illuminate\Http\Request;

class ReviewController extends Controller
{
    public function __construct()
    {
      $this->middleware('auth');
    }

    /**
     * Store a newly created resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Product  $product
     * @return \Illuminate\Http\Response
     */
    public function store(Request $request, Product $product)
    {
        $request->validate([
            'review' => 'required|string',
            'rating' => 'required|numeric|min:0|max:5',
        ]);

        $review = new Review;
        $review->review = $request->review;
        $review->rating = $request->rating;
        $review->user_id = auth()->user()->id;

        $product->reviews()->save($review);
        return response()->json(['message' => 'Review Added', 'review' => $review]);
    }

    /**
     * Update the specified resource in storage.
     *
     * @param  \Illuminate\Http\Request  $request
     * @param  \App\Product  $product
     * @param  \App\Review  $review
     * @return \Illuminate\Http\Response
     */
    public function update(Request $request, Product $product, Review $review)
    {
        if (auth()->user()->id !== $review->user_id) {
            return response()->json(['message' => 'Action Forbidden']);
        }
        $request->validate([
            'review' => 'required|string',
            'rating' => 'required|numeric|min:0|max:5',
        ]);

        $review->review = $request->review;
        $review->rating = $request->rating;
        $review->save();

        return response()->json(['message' => 'Review Updated', 'review' => $review]);
    }

    /**
     * Remove the specified resource from storage.
     *
     * @param  \App\Product  $product
     * @param  \App\Review  $review
     * @return \Illuminate\Http\Response
     */
    public function destroy(Product $product, Review $review)
    {
        if (auth()->user()->id !== $review->user_id) {
            return response()->json(['message' => 'Action Forbidden']);
        }
        $review->delete();
        return response()->json(null, 204);
    }
}

Conclusion

That’s it! In this tutorial, we have built a simple api and covered authentication, database seeding and CRUD operation.

The complete code for this tutorial is available on GitHub.

Staying healthy 2020

Odunayo Ogungbure — Fri, 10 Jan 2020 21:54:32 +0000

As developers, we tend to spend a significant amount of time in front of computer screens solving brain tasking problems, and if one is not careful it could lead to having a problematic lifestyle hazardous to the health and social life.

Luckily, it's surprisingly easy to make some changes with very little effort and one of the things I have decided to do this year is to take care of myself. So here are some things I will be doing differently this year below:

1. Enough Sleep

Trying to meet deadlines or working on personal stuff, we tend to deprive themselves of good sleep, but I have learnt from the previous year that continuous sleep deprivation affects your focus during the day, ability to think, productivity and immune system, and even your memory.
That is why this year, I have decided to create and stick to a bedtime routine.

2. Exercise

Exercising regularly has a wide range of benefits that will pay dividends in the long run. Sitting means sedentary muscles, and blood doesn’t flow as well in muscles that aren’t active. Exercising keeps your body fit, improves your health, and it also makes you mentally more resilient.

3. Posture

Poor posture damages the relationship between muscle and bone. It puts stress on tendons and ligaments and can leave you with chronic neck and back pain. I struggled with a lot of back and neck pains the previous year due to my sitting posture. So this year I will be working on getting a more comfortable ergonomic chair and practising good seating postures. I might consider working on a standing desk and see how it helps.

4. Taking short breaks

When you’re striving to hit a deadline, or a tough challenge has got you feeling the pressure, it's tempting to force yourself to focus well past the point of fatigue. I have heard a lot of developers talk about taking a five minutes recess after every hour and doing this will let you think about the problem from a different angle and most often than not come up with a solution during the break. I tried this a few times the previous year and this year I will be doing it more.

5. Socialise more often

Growing up, I was very shy and then I joined the development world where you might not be interacting very often with people as it is you and your computer most times. I struggled the previous year starting and sustaining conversations with folks outside the workplace or who are not family members. This sort of made me become a loner when I'm away from work environments as I find it hard to interact with people. This year I will be challenging myself to try going out more often even if I don't want to, meeting new folks, trying to talk with people no matter how uncomfortable I might get.

6. Stop worrying too much

Worries, doubts, and anxieties are a normal part of life. It's natural to worry about an unpaid bill, future events, and a whole lot and this took a toll on me and put a dark, depressing cloud over me. That's why I've decided to worry less this 2020, avoid putting pressure on myself, take life as it comes and be grateful for the things I have.

7. Staying hydrated

Keeping hydrated is crucial for health and well-being, but many people do not consume enough fluids each day, of which I'm also guilty of. I only drink water when I'm thirsty or after a meal. Some scientists have proposed that consuming more water might enhance performance during strenuous activity, and that is why drinking enough each day is on my lists of priorities this year.

Setting up a Laravel project with SQL Server AND XAMPP / WAMP on Windows

Odunayo Ogungbure — Fri, 16 Aug 2019 11:47:03 +0000

I spent a large part of yesterday trying to connect an existing Laravel project to MsSQL. I made some mistakes and used different tutorials but I finally got it setup.

Note: This article assumes you have SQL Server, xampp or wamp and laravel correctly installed on your system.

First, we create a fresh Laravel installation and when it's complete we can open the folder in our editor.

laravel new mssql

Open the database.php file in the config folder and make this change.

 /*
    |--------------------------------------------------------------------------
    | Default Database Connection Name
    |--------------------------------------------------------------------------
    |
    | Here you may specify which of the database connections below you wish
    | to use as your default connection for all database work. Of course
    | you may use many connections at once using the Database library.
    |
    */
    //from
    'default' => env('DB_CONNECTION', 'mysql'),
    //to
    'default' => env('DB_CONNECTION', 'sqlsrv'),

This is not really important as we are still going to update the .env file, but hey I just feel like doing it :).

Next, we need to update our .env file database credentials

DB_CONNECTION=sqlsrv
DB_HOST=127.0.0.1
DB_PORT=1433
DB_DATABASE=laravel
DB_USERNAME= #SQL Server username
DB_PASSWORD= #SQL Server password

Let's run our migrations using the migrate artisan command in our terminal.

 php artisan migrate

We should get the error below. This means we need to download Microsoft drivers for PHP for SQL Server. (If your migrations did run successfully, then there's no further setup to do).

 Illuminate\Database\QueryException: could not find driver 
(SQL: select * from sysobjects where type = 'U' and name = migrations)

You can download the appropriate drivers from Microsoft store or this GitHub page. I used the latter so I can easily download the drivers for my PHP version(Windows-7.2.zip). (I'm using PHP 7.2).

Extract the contents of the zip file and copy the php_pdo_sqlsrv_7x_ts.dll and php_sqlsrv_7x_ts.dll file.

On WAMPP

Paste the files in C:\wamp64\bin\php\php7.x\ext
Open the php.ini file in C:\wamp64\bin\php\php7.x folder and add the following lines

 extension=php_pdo_sqlsrv_7x_ts.dll
 extension=php_sqlsrv_7x_ts.dll

Open the php.ini file in C:\wamp64\bin\apache\apache2.4.xx\bin folder and add the following lines

 extension=php_pdo_sqlsrv_7x_ts.dll
 extension=php_sqlsrv_7x_ts.dll

Restart wampp server.

On XAMP

Paste the files in C:\xampp\php\ext
Open the php.ini file in C:\xampp\php folder and add the following lines

 extension=php_pdo_sqlsrv_7x_ts.dll
 extension=php_sqlsrv_7x_ts.dll

Restart xamp server.

Run the migration command in our terminal.

 php artisan migrate

Now we should be able to run our migrations.

Migrating: 2014_10_12_000000_create_users_table
Migrated:  2014_10_12_000000_create_users_table (0.01 seconds)
Migrating: 2014_10_12_100000_create_password_resets_table
Migrated:  2014_10_12_100000_create_password_resets_table (0.01 seconds)

Bonus: (I'm on SQL Server 2012 by the way) Using unsignedBigInteger() will throw an error, instead use bigInteger(). More on this here.

UPDATE: You might need to download Microsoft ODBC Driver to fix this - Illuminate\Database\QueryException : SQLSTATE[IMSSP]: This extension requires the Microsoft ODBC Driver for SQL Server to communicate with SQL Server. Access the following URL to download the ODBC Driver for SQL Server for x64: https://go.microsoft.com/fwlink/?LinkId=163712

That’s All Folks!
Happy Coding 🖖

DEV Community: Odunayo Ogungbure

Shorthand Conditionals in PHP You Should Know

1. Ternary Operator

Nesting Ternary Operators

2. Elvis Operator (Short Ternary)

3. Null Coalescing Operator (??)

4. Spaceship Operator (<=>)

Final Thoughts

Deploy a Laravel Project on Heroku with SQL Database

Requirements

Create Heroku Application

Setting Environment Variables

Using the Heroku CLI

From the Heroku dashboard

Connect Database

Conclusion

Stacky REST API #4 - Push Project to Github

Stacky REST API #3 - Connecting Database

Environment Variables

Stacky REST API #2 - Babel Setup

Stacky REST API #1 - Introduction

Requirements

Application Overview

Getting started

NPM Scripts

Nodemon

Setup Linux, Apache, MySQL, PHP(LAMP) Stack on Ubuntu 18.04

Prerequisites

Apache

PHP

Setting Up Virtual Hosts

MySQL

Password Access For MySQL Account

phpMyAdmin

Upgrading phpMyAdmin

Secret passphrase in configuration is too short

Composer

Let’s Encrypt Free SSL Wildcard Certificate

Conclusion

Laravel Breeze - Minimalistic Authentication Scaffolding

Breeze?

Laravel 8: Routing Change

Build a Product Review REST API with Laravel

Prerequisites

Creating a new project

Create models and migrations

Model Relationships

Database Seeding

Authentication

Product Endpoints

Review Endpoints

Conclusion

Staying healthy 2020

1. Enough Sleep

2. Exercise

3. Posture

4. Taking short breaks

5. Socialise more often

6. Stop worrying too much

7. Staying hydrated

Setting up a Laravel project with SQL Server AND XAMPP / WAMP on Windows

Note: This article assumes you have SQL Server, xampp or wamp and laravel correctly installed on your system.

3. Null Coalescing Operator (`??`)

4. Spaceship Operator (`<=>`)