Posted on Leave a comment

Writing A Real Time Location Service – Models and Migrations

[callaction url=”https://www.youtube.com/user/JPlaya01″ background_color=”#333333″ text_color=”#ffffff” button_text=”Go Now” button_background_color=”#e64429″]Subscribe To My Youtube Page[/callaction]

Overview

In this programming series I am going to show you how to create a real time Laravel app that shows the location of an android device on a Google map in real time. This design can easily be applied to iOS and I will cover it at a later date. This project will be constructed of three parts:

  • Laravel app that handles registration/login, saves coordinates and timestamps
  • Node Application that talks to Laravel application and android devices
  • Android application that talks to node application

In this post I will create the Laravel + Node apps and I will write the Android app at a later post. The Laravel app is a run down version of my new application SocketDroid, an application that allows you to control android devices from a web panel. click a button and alert the Android device to send geolocation information back to the server and push it to the browser. The application will store the geolocation information in a database for later analysis if you so choose (in a later post I will expand upon the admin panel). The Laravel app will communicate with the Node app via Redis using the built-in Event system. From there the Node app will communicate with our devices via Socket.io. The Android device will listen on a websocket connection in a background service and listen for an event to start grabbing and posting GPS data, and another event to stop listening. Make sense so far? Good, let’s get started!
 

Scaffolding The Laravel Application

If you have followed any of my Laravel tutorials in the past, you know the drill, create a new application, and scaffold the authentication routes and views:


laravel new real-time-gps
cd real-time-gps
php artisan make:auth

Now we have a basic Laravel application with registration and login logic established. Let’s talk about database design for a moment shall we? This application is going to have 3 really important tables they are:

  • Users (Already made for us be default)
  • Devices
  • Locations
  • ActivationCodes

A user can have many devices, a device can have many locations and belongs to one user, and a location belong to one device, that is the basic relationship structure. Activation codes are for you guessed it activating devices to use the app. Go ahead and create the relations and models for devices and locations using the following commands:


php artisan make:model -m Device
php artisan make:model -m Location
php artisan make:model -m ActivationCode

Device Model

Open up the devices migration file and add the following content to the up() function:


Schema::create('devices', function (Blueprint $table) {
$table->increments('id');
$table->string('uuid');
$table->integer('user_id')->unsigned();
$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');
$table->timestamps();
});

The only things we need to know about devices are who they belong to and what channel they are listening on. We also want to make sure that when a user account is deleted from the database, that all of their devices are also removed from the database.  Now open up the Device model (app/Device.php), there are three things we need to do with this model, the first is tell it which parameters to accept when inserting into the database. The second thing is to tell the model about its relation to the User model, while the third is to tell the model about it’s relation to the Location model. The finished version should look like this:


<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Device extends Model
{
//
protected $guarded = [];
public function user(){
return $this->belongsTo('App\User');
}
public function locations(){
return $this->hasMany('App\Location');
}
}

The Device model and migration is now complete, now on to the Location model and migration.

Location Model

Open up the location migration file and in its up() function we are going to add the following:


Schema::create('locations', function (Blueprint $table) {
$table->increments('id');
$table->string('lat');
$table->string('long');
$table->integer('device_id')->unsigned();
$table->foreign('device_id')->references('id')->on('devices')->onDelete('cascade');
$table->timestamps();
});

Hopefully by now you understand what is going on, we are saving the lat/long acquired from the device, as well as its id. Using this information we can associate geolocations with independent devices. Next we will open up the Location(app/Location.php) model, tell it which properties to fill, and it’s relation to the Device model.


<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Location extends Model
{
//
public $guarded = [];
public function device(){
return $this->belongsTo('App\Device');
}
}

User Model

The only thing we need to do the user model is make it aware of it’s new device relation open up the User(app/User.php) model and add the following function:


public function devices(){
return $this->hasMany('App\Device');
}

ActivationCode Model

The activation code model is responsible for storing the activation code given from the Android device on app installation to register the device with your account. It will take in the UUID of the device and the activation code, open up the migration file and add the following:


public function up()
{
Schema::create('activation_codes', function (Blueprint $table) {
$table->increments('id');
$table->string('uuid');
$table->string('code');
$table->timestamps();
});
}

Now open up the ActivationCode(app/ActivationCode.php) model and add the following:


<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class AuthCode extends Model
{
//
public $guarded = [];
}

That’s all that’s needed you can now run your migrations!


php artisan migrate

In the next lesson we will be creating the views and front end logic needed to visualize the devices on a Google map!

Posted on Leave a comment

Crash Course Into PHP – Data Types

[callaction url=”https://www.youtube.com/user/JPlaya01″ background_color=”#333333″ text_color=”#ffffff” button_text=”Go Now” button_background_color=”#e64429″]Subscribe To My Youtube Page[/callaction]

PHP Data Types

PHP variables can store several different data types. Different data types can perform different functions, the basic data types includ:

  • String.e
  • Integer.
  • Float (floating point numbers – also called double)
  • Boolean.
  • Array.
  • Object.
  • NULL.

String

A string is a series of characters wrapped in either single or double quotes, a few examples of strings include:

  • $x = 'Hello my name is Jyrone';
  • $x = "Programming is awesome!"
  • $x = 'The number 13 is very unlucky'

Integer

An integer is any NON-DECIMAL number between -2,147,483,648 and 2,147,483,647 some examples include

  • $x = 1234;
  • $x = -4567;

Float

A float (floating point number) is a number with a decimal point or a number in exponential form some examples include:

  • $x = 1.234
  • $x =1.2e3;
  • $x = 9E-10

Boolean

The boolean data type only has two possible states, true(1) or false(0) some examples include:

  • $x = true;
  • $x = false;

Array

The array data type maps several values to a single variable. Arrays can be initialized with the array() function or the [] shorthand syntax. Arrays can contain other arrays, some examples include:

  • $x = [
    "a" => 1,
    "b" => "xyz"
    ];
  • $x = [
    "a" => [
    "a1" => 2
    ],
    "b" =>345
    ];

Object

The object data type is arguably the most important data type. An object stores data in its properties, and manipulates that data using methods. Objects have to be declared explicitly using the class keyword, a class is a structure that contains methods and properties, an example would be:


class Person{
protected $height, $weight;
public function __construct( $height,$weight){
$this->height = $height;
$this->weight = $weight;
}
public function getWeight(){
return $this->weight;
}
public function getHeight(){
return $this->height;vb
}
public function setWeight($weight){
$this->weight = $weight;
}
public function setHeight($height){
$this->height = $height;
}
}
$person = new Person(70,163);
//returns 70
echo $person->getHeight();

Objects and classes will be covered more in depth as time goes on.

Null

The null data type can only be assigned one value, and that is you guessed it, null. You use null when no value has yet been assigned to a variable:

  • $x = null;

Conclusion

As you progress through my tutorials I will go deeper and deeper into each data type as the need arises in code. Next I will explain the basic operators of PHP. If you haven’t already please subscribe to my newsletter to get real time updates on my blog entries.

Posted on Leave a comment

Crash Course Into PHP – Syntax

[callaction url=”https://www.youtube.com/user/JPlaya01″ background_color=”#333333″ text_color=”#ffffff” button_text=”Go Now” button_background_color=”#e64429″]Subscribe To My Youtube Page[/callaction]

By now you guys should know

That I specialize in Laravel development, it’s what 90% of my blog content comprises of. I want to kick off 2017 with my new online coding classes, these will be Youtube series (mostly screen recordings, but a few face to camera as well you can subscribe to my channel here), designed to teach coding to beginners as well as advance methodologies for more seasoned programmers. The main concern I receive from newcomers coming to my site, is that they would like to see more basic PHP tutorials. As I thought about it, I couldn’t agree more, thus today starts the crash course in PHP lessons. I say crash course because I’m only going over the basic concepts, enough where the Laravel code will start making more sense to the n00bs.

What Is PHP?

PHP is a server-side scripting language designed primarily for web development but also used as a general-purpose programming language. It powers the majority of websites in the world (82.3%). The largest social media platform (Facebook) is powered by PHP, among others. It by far has the most support libraries than any other language. It is free to use and develop with both for personal and commercial applications, making it ideal for programmers with a low budget. PHP code can be directly embedded into HTML, making it ideal to create rich dynamic web pages (and apps).

How To Install PHP

Anyone who knows me, knows I love virtual machines! It makes installing software such as PHP and a full LEMP stack a breeze. Since learning Laravel is the ultimate goal, I will direct you to install the Laravel Homestead virtual machine on your computer, it has the following software already bundled in, meaning you won’t have to do a lick of package management:

  • Ubuntu 16.04
  • Git
  • PHP 7.0
  • Nginx
  • MySQL
  • MariaDB
  • Sqlite3
  • Postgres
  • Composer
  • Node (With PM2, Bower, Grunt, and Gulp)
  • Redis
  • Memcached
  • Beanstalkd

Mac users have the option of using Laravel Valet as well.

PHP Syntax

All PHP files end in .php which shouldn’t be too surprising. Do me a favor, open up your terminal (log into the virtual machine) and create a new php file

nano hello.php

Now paste in the following content and let’s break it down:


<?php
echo "Hello World!";
?>

The first and last parts of this script tell the preprocessor that PHP code needs to be interpreted


<?php
// PHP code goes here
?>

The middle part uses the built-in PHP function (we will get to functions later) echo to print the text “Hello World!” to the screen
The semicolon tells the preprocessor that the PHP statement is completed.
If you run the following command you should see the text “Hello World!” pop up.

php hello.php

The really cool thing about PHP is that you can embed it straight into your HTML, so if you wanted to show this same snippet of code in a webpage instead of the terminal you can simply do this:

HTML Embedding


<!DOCTYPE html>

 

<html>

 

<body>

 

<h1>My first PHP page</h1>

 

<?php echo “Hello World!”; ?>

 

</body>

 

</html>

PHP Comments

Often times when coding you need to leave a note to yourself or fellow programmers. In PHP there are two ways to leave comments in your code

  • // – Creates a SINGLE LINE comment
  • # – Creates a SINGLE LINE comment
  • /**/ – Creates a MULTILINE comment that spans several lines

<?php
// This is a single-line comment
# This is also a single-line comment
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
?>

This is the most basic syntax of PHP, next we will go over variables and data types. If you haven’t please subscribe to my newsletter to get real time updates when I push new material.
 

Posted on Leave a comment

Sending Twilio Notifications With Laravel 5.3

[callaction url=”https://www.youtube.com/user/JPlaya01″ background_color=”#333333″ text_color=”#ffffff” button_text=”Go Now” button_background_color=”#e64429″]Subscribe To My Youtube Page[/callaction]

Sending Twilio Notifications With Laravel 5.3

One of the greatest features added to Laravel 5.3 IMHO was the introduction of notifications. Notifications allow you to send messages to users over a variety of channels including mail, sms, and slack. You also have the option of storing them in the database. “THIS IS GREAT” I thought as I was reading up on it and contemplating how I was going to refactor my existing hoemebrew Twilio notification systems. There was just one problem. The Laravel notification system’s default SMS driver is for Nexmo, not Twilio! Luckily I found a solution, and I am going to share it with you today

The Application

The application I am going to walk you through writing a simple Laravel 5.3 app that signs users up and sends them daily inspirational quotes. The order of which the application will be written is thus:

  • Create App/Install dependencies
  • Prepare database/Registration
  • Create notification
  • Modify inspire console command

While this application won’t be very exciting, it will demonstrate the groundwork needed to get Twilio up and running in your web application.

Creating App/Installing Dependencies

First off we must create the application open up your terminal and use the following command

laravel new TwilioNotifications

Once the appcation has been scaffolded cd into the new directory and add the following composer package

composer require laravel-notification-channels/twilio

This will add the Twilio dependency we need to make SMS notifications. Now we need to add the following to the providers array in config/app.php

// config/app.php
'providers' => [
    ...
    NotificationChannels\Twilio\TwilioProvider::class,
],

Next we need to update our config/services.php file and add the Twilio credentials
 

// config/services.php
...
'twilio' => [
    'account_sid' => env('TWILIO_ACCOUNT_SID'),
    'auth_token' => env('TWILIO_AUTH_TOKEN'),
    'from' => env('TWILIO_FROM'), // optional
],
...

Make sure you update you .env file to suit, other than that we are ready to go onto the database/registration logic.

Database/Registration

Open up the default database migration. We just need to add a ‘phone_number’ attribute to the migration, add the following

$table->string('phone_number');

You can safely run your migration, nothing else to be done here. Now we need to scaffold the application of authentication logic, please enter the following command in your terminal.
php artisan make:auth
This command creates the views, controllers, and routes for registering users, we just need to add some logic to accommodate for phone_number. First open up resources/views/auth/register.blade.php and underneath the email block of HTML add the following:


<div class="form-group{{ $errors->has('phone_number') ? ' has-error' : '' }}">
<label for="phone" class="col-md-4 control-label">Phone</label>
<div class="col-md-6">
<input id="phone_number" type="tel" class="form-control" name="phone_number" value="{{ old('phone_number') }}" required>
@if ($errors->has('phone_number'))
<span class="help-block">
<strong>{{ $errors->first('phone_number') }}</strong>
</span>
@endif
</div>
</div>

Next open up app/Http/Controllers/Auth/RegisterController.php in your Validator array add the following rule:

'phone_number' => 'required'

In the create method simply add the following in the User::Create array:

'phone_number' => $data['phone_number'],

You should be able to register accounts now! On to the next part, creating the notification

Creating The Notification

Laravel provides an artisan command for creating notifications. Go to the terminal and enter the following

php artisan make:notification InspireUser

This will create a Notifications folder under app/, go there and open InspireUser.php file
In the constructor we are going to be passing in a quote string so we should grab and set it


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

Look at the via($notifiable) method, notice is returns an array of channels to send the message to. Since we are not using mail in this example you can safely remove that and replace it with this


public function via($notifiable)
{
return [TwilioChannel::class];
}

Be sure to add the following use clauses at the top


use NotificationChannels\Twilio\TwilioChannel;
use NotificationChannels\Twilio\TwilioSmsMessage;

For every channel you want to broadcast on you must have a corresponding method toChannel($notifiable). So for Twilio we need a toTwilio($notifiable) where $notifiable is the class that is being notified.


public function toTwilio($notifiable)
{
return (new TwilioSmsMessage())
->content("Hello {$notifiable->name} here is your inspiring quote for the day: {$this->quote}");
}

That’s all we have to do, now on to the last part, modifying the inspire console command.

Modifying The Inspire Console Command

Laravel ships with a predefined console command called inspire, it simply echos an inspiring quote to the console. It’s located in routes/console.php delete everything and replace it with this


<?php
use Illuminate\Foundation\Inspiring;
use App\User;
use App\Notifications\InspireUser;
/*
|--------------------------------------------------------------------------
| Console Routes
|--------------------------------------------------------------------------
|
| This file is where you may define all of your Closure based console
| commands. Each Closure is bound to a command instance allowing a
| simple approach to interacting with each command's IO methods.
|
*/
Artisan::command('inspire', function () {
$users = User::all();
$users->each(function($item, $key){
$this->info("Notifying {$item->name}");
$item->notify(new InspireUser(Inspiring::quote()));
});
})->describe('Send an in inspiring quote to all your users');

This version of inspire grabs all the users and sends them a text message with the inspiring quote. You can go to the terminal and type

 php artisan inspire

and all your users will be notified. That’s it in a nutshell, although I would advise putting this command on a daily schedule so you don’t have to manually go into the terminal everyday, but I will leave you to that. If you would like to see the source code, it is available here on Github.

Posted on 6 Comments

Create A Real-Time Microservice With Lumen

Laravel 6 Is Out Which Means New Lumen!

When I was at Laracon 2019 I interviewed Taylor Otwell and one of the things we talked about was new Lumen updates. I have switched to a primarily micro service mentality and I’m excited to write up scalable robust production ready microservices.

Laracon 2019 I interviewed Taylor Otwell

What Is Lumen?

Lumen is microframework provided by Laravel. I use it all the time when I need to create standalone APIs and microservices. Today I will show you how to create a generic real time microservice that can be used for later mobile back end tutorials . The microservice will take messages and push them out to all clients listening setting the ground for push notifications. Without further ado, let’s get started!

Getting Started

Because I want to focus on development, and not system administration, please follow this guide to getting your environment up and running, after doing so, go to your terminal, cd into an empty directory and type in this command or clone the repo:

lumen new real-time-microservice-skeleton

cd into your newly created app. First thing we are going to do is define our events. This microservice will give us real-time updates from those who sent messages to it. In order to provide this, we will leverage the broadcasting paradigm included in the Event class. If you are interested in a deeper understanding on how broadcasting works check here, but in short you tell the event what channel to broadcast on and you give it a driver (Redis, Pusher, log). We will being using Redis with a Node.js implementation. Before we can do any of that, we have to add a dependency or two:

For Composer:

composer require predis/predis

For NPM:

npm install --save socket.io-client

Now open up app/Providers/EventServiceProvider.php and change  the array to this:

protected $listen = [
        'App\Events\NewMessageEvent' => [
            'App\Listeners\NewMessageListener',
        ],
    ];

Event & Listener

Lumen doesn’t have generators so we have to do things manually. Now create those corresponding classes in the app/Events and app/Listeners directories respectively. In the NewMessageEvent add this code:

<?php
namespace App\Events;
use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Broadcasting\PresenceChannel;
use Illuminate\Broadcasting\PrivateChannel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
use Illuminate\Queue\SerializesModels;
class NewMessageEvent extends Event implements ShouldBroadcast
{
public $message;
/**
* Create a new event instance.
*
* @return void
*/
public function __construct($channel, $message)
{
//
$this->message = $message;
}
public function broadcastOn()
{
return new PrivateChannel('example-channel');
}
}

In the NewMessageListener it can just have the default listener code

<?php
namespace App\Listeners;
use App\Events\NewMessageEvent;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Queue\InteractsWithQueue;
class NewMessageListener
{
    /**
     * Create the event listener.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }
    /**
     * Handle the event.
     *
     * @param  NewMessageEvent  $event
     * @return void
     */
    public function handle(NewMessageEvent $event)
    {
        //
    }
}

Routing

For the lumen skeleton I will just add two addition routes to the web.php file one GET and one POST that do the same thing. Pass a message parameter to a controller method.

<?php
/*
|--------------------------------------------------------------------------
| Application Routes
|--------------------------------------------------------------------------
|
| Here is where you can register all of the routes for an application.
| It is a breeze. Simply tell Lumen the URIs it should respond to
| and give it the Closure to call when that URI is requested.
|
*/
$router->get('/', function () use ($router) {
    return $router->app->version();
});
$router->get('/message', 'MessageController@sendMessage');
$router->post('/message', 'MessageController@sendMessage');

Controller

The controller will have one method that calls a new event and passes the message as the parameter.

<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class MessageController extends Controller
{
    /**
     * Create a new controller instance.
     *
     * @return void
     */
    public function __construct()
    {
        //
    }
    public function sendMessage(Request $request){
      event(new \App\Events\NewMessageEvent($request->message));
    }
    //
}

Socket-IO Client

We will use Laravel Echo to interact with out redis pub/sub mechanism. Create a new file called socket-client.js and input the following

import Echo from "laravel-echo"
window.io = require('socket.io-client');
window.Echo = new Echo({
    broadcaster: 'socket.io',
    host: window.location.hostname + ':6001'
});
Echo.private('example-channel')
    .listen('NewMessageEvent', (e) => {
        console.log(e.message);
    });

As you can see we are listening for a private channel with the same name that we broadcasted on in the Event class. Now the only thing needed is an actual socket.io server. I won’t get into that in this tutorial but the official Laravel documentation recommends that you use this github package. In the next step of the tutorial I will add authentication to secure channels.