DEV Community: Hamid Semix

What can FFI, preloading and Typed Properties do for us in php?

Hamid Semix — Mon, 29 Jul 2019 15:28:30 +0000

With the introduction of ffi, preloading and typed properties in php >= 7.4, should we now assume that php is fit for developing desktop applications or even more?

Getting started with yuga-framework part 3 (Querying the database and more)

Hamid Semix — Fri, 22 Mar 2019 11:55:25 +0000

In today's tutorial, I am going to take you through how to comment on a post that is already in the database,
this requires to first query the database for that post, then attach a comment to it and then save the changes, so without any further ado, let's get started.

First we need to query the database for a given post say with id 1

Yuga comes with an ORM that might by handy at database manipulation, so, that's what we will use for querying our post from the database but first, lets create a route for accessing our post. Let's open routes/web.php file to create our route.

// routes/web.php

Route::get('/post/{id}', 'BlogController@getPost');

Now let's open app/Controllers/BlogController.php and add getPost method to our class

// app/Controllers/BlogController.php

public function getPost(Post $post, int $id)
{
    $post = $post->find($id);

    return $this->response->json(['post' => $post]);
}

Now let's go to the browser and vist http://localhost:8000/post/1

This must be your result

Now let's edit

In the routes/web.php, let's add this route

// routes/web.php

Route::get('/post/{id}/edit', 'BlogController@editPost');

In the app/Controllers/BlogController.php, let's add the editPost method to the BlogController class but before that, let's first create a relation between the Post model and Comment model found in app/Models

In the app/Models/Post.php

// app/Models/Post.php

public function comments()
{
    return $this->hasMany(Comment::class);
}

In the app/Models/Comment.php

// app/Models/Comment.php

public function post()
{
    return $this->belongsTo(Post::class);
}

In the app/Controllers/BlogController.php

// app/Controllers/BlogController.php

public function editPost(Post $post, int $id): string
{
    $post = $post->find($id);

    // Let's create the comments from here
    // [`creator_name`, `post_id`, `comment_content`]
    $post->comments()->save(new Comment([
        'creator_name' => 'Hamid Semix',
        'comment_content' => 'This is the first comment'
    ]));

    return "Your comment has been saved";
}

Now let's edit our getPost method to incorporate comments to

// app/Controllers/BlogController.php

public function getPost(Post $post, int $id)
{
    $post = $post->with('comments')->where('id', $id)->first();

    return $this->response->json(['post' => $post]);
}

In the editor

This must be your result

Foreign Function Interface for php

Hamid Semix — Tue, 19 Feb 2019 10:44:50 +0000

Is Foreign Function Interface really going to do much in the php world?

Getting started with yuga-framework part 2

Hamid Semix — Fri, 08 Feb 2019 12:10:18 +0000

In today's tutorial, I am going to take you through the steps required to build an actual blog application, I am sure you remember our first part was setting up an environmment.
Let's first list down what we need to do:

We need a database
we need a posts table
we need a comments table
we need a form for submitting a post (will be covered in part 3)
We need a page for displaying all posts (part 3)
We need a mechanism of comment on a post (part 3)
We need to save a post/comment (For now we will use a fairly raw approach)
We need to query the database for posts and their comments

Ok, let's get this over with, shall we?

First we need to make a connection to a database

Yuga comes with three database drivers integrated, the default one is mysql, to change the database to which our application connects, we will need to locate a file (environment/.env). This is the file that holds most of the framework's configurations. Let's name our database blog

Let's now create our tables in the database

To create the blog tables, we will use yuga's command for migrations which is php yuga migration:make.
We will have two tables for now which are posts and comments

Open the project in the terminal and type

php yuga migration:make posts

Do the same for comments, at this point, your database directory should like this

Let's run the command that creates these two tables

Before we create our tables in the database we earlier created, we need to figure out which fields need to go to each of the tables i.e. posts and comments

Posts table
- id
- creator_name
- post_title
- post_content
- created_at
- updated_at
Comments table
- id
- creator_name,
- post_id
- comment_content
- created_at
- updated_at

Let's put these fields with their appropriate data types in the migrations we just created

Now, In your terminal, enter this command

php yuga migration:up

This command will create the tables and now we should have the following

Models for posts table and comments table

Now that we have our tables created, we need a way we can communicate with them in a flawless way, Luckly for us, yuga comes with an ORM for database manipulation, so let's create the Post model and the Comment model.
NB: Because our tables are posts and comments, this explains while our Models will be Post and Comment respectively as yuga converts the class name of the model and pluralizes and lowercases it, that's what it takes as the table (But customisable).

That's what we will use to save and retrieve data from the tables (models)

Let's use the yuga commands again for this task,

php yuga make:model Post

php yuga make:model Comment

Save data in our post table

To interact with our tables, we need a route which in the end calls a controller on our behalf. It's in the controller that we write our logic for saving our post to a database.
To create a controller we use php yuga make:controller BlogController command.

Let's open the created controller and create a method called createPost.

Now let's open routes/web.php file to create our route. This file has one route which is /, now let's add another route /post/create which we will use to create our blog post.

// routes/web.php

Route::all('/post/create', 'BlogController@createPost');

In the controller

// app/Controllers/BlogController.php

public function createPost(Post $post): string
{
    $post->save([
        'creator_name' => 'Jone Doe',
        'post_title' => 'I believe every human has a finite number of heartbeats. I don\'t intend to waste any of mine.',
        'post_content' => 'Never in all their history have men been able truly to conceive of the world as one: a single sphere, a globe, having the qualities of a globe, a round earth in which all the directions eventually meet, in which there is no center because every point, or none, is center — an equal earth which all men occupy as equals. The airman\'s earth, if free men make it, will be truly round: a globe in practice, not in theory.',
    ]);
    return 'Your Post has been saved';
}

You must have the following result when you vist http://localhost:8000/post/create

Getting started with the yuga-framework part 1

Hamid Semix — Tue, 05 Feb 2019 12:45:40 +0000

There is a full list of frameworks most of which are php frameworks, these frameworks help in Rapid Application
Development. However, some of these frameworks are really had to get started with, have complex paradigms,
and some are not good enough for an advanced php developer. This is where the yuga-framework comes in handy.

In this tutorial, I will introduce you to yuga-framework a framework for PHP that leverages between a beginner and advanced developer. Yuga-framework can be used just to develop apis or fully fledged web applications.

What is Yuga-framework?

Yuga is a php framework that is ideal for rapid web app development, It can be used to develop apis or an entire web application like mentioned earlier. It supports all HTTP verbs or methods (GET, POST, PUT, DELETE, PATCH, and custom ones). It has automatic form validation, automatic cross site request forgery protection on routes and does not force the user to use Route methods if they aren't coming from that background. You can learn and advance with the framework.

Steps needed to get started with yuga-framework

Step 1: Install Composer

Install composer (php package manager) if you don't already have it on your machine from here

Step 2: Install Yuga Framework From Packagist using composer

To get started you just need one command

composer create-project yuga/yuga Blog

Step 3: Run the application

To run the application we have just created using composer, we cd to Blog and open the project in terminal or console, type the following yuga command, Oooh, Did I forget to mention that the framework comes with its own console application, I just did.

php yuga start

Step 4: See output

To see what the yuga start command has done, go to your browser and visit http://localhost:8000

Step Finale

Open the project in your favorite editor, in my case it's vs code. Let's try to see the file structure

app
- Controllers
- helpers (optional)
- Middleware (created automatically when you make a middleware using a yuga command).
- Models
- Providers (houses your application service providers)
- ViewModels (Where view models live). The framework is well integrated with ViewModels so that's where our logic will reside
boot (framework specific) do not touch
config (Where the configuration settings of you application reside). Feel free to alter and see how the application changes
database (Where migrations live)
environment (Where environment settings live)
mailables (Where files that can be sent as emails reside). This can change
public (Where you should point your server instance)
resouces (Where views are saved)
routes
- web.php (A file that holds all our routes)
storage
tests