
Building Content Management System from the ground up has been one of those awesome experience.

WordPress has been the de facto standard, especially in content management system industry.
From its website...

> WordPress powers more than 43% of the web — a figure that rises every day. Everything from simple websites, to blogs, to complex portals and enterprise websites, and even applications, are built with WordPress.

However, we can see that WordPress was developed in the times where creating application was not that simple.

Nowadays, PHP developments has accelerated with the signs of recent [PHP updates](https://www.php.net/), software development practices has also evolved.

For instance, the development with MVC structures, inspired with Ruby on Rails, some software architecture principles, have applied to many of software frameworks.

However, this has not applied to WordPress, it still uses its own structures.

So, this writing aims to help you to understand what can be done if content management system, like WordPress, if applied with modern software architecture.

To help with this, we will use [Laravel](https://laravel.com), a PHP web framework which has applied some of software engineering practice.

Let's briefly discuss what features our content management system will have.
Based on WordPress's features, we can extract some key features like:

- Publish with Ease
  If you’ve ever created a document, you’re already a whizz at creating content with WordPress. You can create Posts and Pages, format them easily, insert media, and with the click of a button your content is live and on the web.
- Publishing Tools
  WordPress makes it easy for you to manage your content. Create drafts, schedule publication, and look at your post revisions. Make your content public or private, and secure posts and pages with a password.
- User Management
  Not everyone requires the same access to your website. Administrators manage the site, editors work with content, authors and contributors write that content, and subscribers have a profile that they can manage. This lets you have a variety of contributors to your website, and let others simply be part of your community.
- Media Management
  They say a picture says a thousand words, which is why it’s important for you to be able to quickly and easily upload images and media to WordPress. Drag and drop your media into the uploader to add it to your website. Add alt text and captions, and insert images and galleries into your content. We’ve even added a few image editing tools you can have fun with.
- Built-in Comments
  Your blog is your home, and comments provide a space for your friends and followers to engage with your content. WordPress’s comment tools give you everything you need to be a forum for discussion and to moderate that discussion.
- Search Engine Optimized
  WordPress is optimized for search engines right out of the box. For more fine-grained SEO control, there are plenty of SEO plugins to take care of that for you.

So, let's start working on it!

Installation

```
composer create-project laravel/laravel wp-laravel
```

Let's try accessing our application

```
php artisan serve
```

We'll need to setup a database, SQLite can be our friend in this writing.

```
touch database/database.sqlite
```

We'll need to update our .env

```
DB_CONNECTION=sqlite
DB_DATABASE=database/database.sqlite
DB_FOREIGN_KEYS=true
```

[reference](https://laravel.com/docs/9.x/database#sqlite-configuration)

Let's migrate our initial database change

```
php artisan migrate
```

Now, we can see our database changes like so

```
php artisan db:show
```

All migrations have been applied.

Now, we want to have something like WordPress Post. if you ever have inspected wordpress tables, you know there will be a table called wp_posts. Let's create that

```
php artisan make:model Post
```

this will create a model called Post. Let's create the migration to apply the database changes.

```
php artisan make:migration "create posts table"
```

Now, let's open the migration, and update our code to be following:

```php
$table->string('title');
$table->string('slug')->nullable();
$table->text('excerpt')->nullable();
$table->longText('content')->nullable();
$table->dateTime('published_at')->nullable();
$table->foreignIdFor(\App\Models\User::class)->constrained();
```


How To Build Your Own Content Management System (Like WordPress)


I usually store the user’s subscription plan in the `users` table. say the `plan_id` which refers to the subscription plans.

Let’s make a stage for this…

our subscription plans.php

```
return [

	cheap_plan ⇒ [

		‘maximum_list’ ⇒ 20,

	],

	expensive_plan ⇒ [

		‘maximum_list’ ⇒ 50,

	],

];

```

Then we can use in the controller like this (already assumes that only logged in users can use this endpoint)

```
public function create()
{
	$postCount = Auth::user()->loadCount('posts')->posts_count;

	if ($postCount > Auth::user()->plan->maximum_list) {
		abort(403, "You've reached your maximum list. Please upgrade your plan.");
	}

	// proceed to create the list
	// $list = List::create(...)

	// return redirect()->route('lists.show', ['list' => $list]);
}

```

This is a valid way, and for most application, I think this has served its purpose to validate the creation limit.

However, like you mentioned, there is another ‘more centralized’ approach with this.

Using Gate and Policy.

Let’s refactor our previous code to a Gate

```
// AuthServiceProvider.php

class AuthServiceProvider extends ServiceProvider
{
	//

	public function boot()
	{
		$this->registerPolicies();

		Gate::define('create-list', function($user) {
			$postCount = Auth::user()->loadCount('posts')->posts_count;

			if ($postCount > Auth::user()->plan->maximum_list) {
				return Response::deny("You've reached your maximum list. Please upgrade your plan.");
			}

			return Response::allow();
		});
	}
}

```

And in your controller, we can refactor to this

```
public function create()
{
	$this->authorize('create-list');
	// or Gate::allows('create-list');
	// or Gate::inspect('create-list'); // if you want more customized response.

	// proceed to create the list
	// $list = List::create(...)

	// return redirect()->route('lists.show', ['list' => $list]);
}

```

This should already have served your needs. But, maybe are there more opinionated way?

You’re right. Using the policy.

They say, Policy is best when you are dealing with a “resource” or models in a domain. Like in our case, the List model.

And gate is best when you’re dealing an “action”.

But, my personal opinion is that we should use policy whenever possible, since… other than it gives you an excuse to create separate files, it also doesn’t litter your `AuthServiceProvider`… (I don’t really like to modify the service Provider by the way, unless really needed).

Let’s refactor our previous code to a Policy

```
class ListPolicy
{
	use HandlesAuthorization;

	public function create(User $user)
	{
		$postCount = Auth::user()->loadCount('posts')->posts_count;

		if ($postCount > Auth::user()->plan->maximum_list) {
			return Response::deny("You've reached your maximum list. Please upgrade your plan.");
		}

		return Response::allow();
	}

}

```

Oh, notice the method mimics the resource controller? That’s by design I believe from the Laravel team. Kudos to them.

and we can simply use like this in the controller

```
public function create()
{
	$this->authorize('create', List::class);
	// or Gate::allows('create-list', List::class);
	// or Gate::inspect('create-list', List::class); // if you want more customized response.

	// proceed to create the list
	// $list = List::create(...)

	// return redirect()->route('lists.show', ['list' => $list]);
}

```

the `List::class` is just there to help Laravel infers which Policy class to use.

All in all, this way we can avoid the problems where… you can literally create the list from 10 different controllers. We can just put the `$this->authorize()` there and be done with it.


Blog