
## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- **Part 7: Testing**

## What do we want to test?
Let's start by outlining the things that are most important to make sure work.

### Anonymous users
- Can view the blog post list
- Can view single blog posts
- Can not comment on a blog post
- Can not view "draft" posts
- Can not load "new blog post" route
- Can not load "edit blog post" route
- Can not delete blog posts

### Authors
- Can add a new post
- Can edit a post
- Can delete a post
- Can view a draft blog post


## Controllers
We can test response codes for the controllers to get good coverage that our authorization rules are in place.

1) Add some seed data so we can simulate these scenarios.
```bash
./vendor/bin/sail artisan make:seeder PostSeeder
```

We'll add a test active post and a test inactive post.
```php
# database/seeders/PostSeeder.php

namespace Database\Seeders;

use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;

class PostSeeder extends Seeder
{
    const POST_1_SLUG = 'laravel-test-post-1';
    const POST_1_USER_ID = '1';
    const POST_2_SLUG = 'laravel-test-post-2';
    const POST_2_USER_ID = '2';

    /**
     * Run the database seeds.
     *
     * @return void
     */
    public function run()
    {
        DB::table('posts')->insert([
            'user_id' => self::POST_1_USER_ID,
            'title' => 'Test Post 1',
            'body' => 'Test Body 1',
            'slug' => self::POST_1_SLUG,
            'active' => '1',
            'metaDescription' => '',
            'metaTitle' => ''
        ]);

        DB::table('posts')->insert([
            'user_id' => self::POST_2_USER_ID,
            'title' => 'Test Post 2',
            'body' => 'Test Body 2',
            'slug' => self::POST_2_SLUG,
            'active' => '0',
            'metaDescription' => '',
            'metaTitle' => ''
        ]);
    }
}

```

2) Add `PostControllerTest.php`
```bash
./vendor/bin/sail artisan make:test PostControllerTest
```

Add `use DatabaseTransaction` to ensure it rolls back any new database rows created.
```php
class PostControllerTest extends TestCase
{
    use DatabaseTransactions;
```

3) Write the tests! Working down the list from above, write tests that verify functionality.

As you are working on the tests you can run them using artisan.
```bash
./vendor/bin/sail artisan test
```

Anything supported by PHPUnit can be done here as well, such as `--filter`.
```bash
./vendor/bin/sail artisan test --filter=testBlogPageDoesLoadAnonymousUser
```

```php
# tests/Feature/PostControllerTest.php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;
use App\Models\User;
use Database\Seeders\PostSeeder;
use Illuminate\Foundation\Testing\DatabaseTransactions;

class PostControllerTest extends TestCase
{
    use DatabaseTransactions;

    /**
     * Anyone can view the list of blog posts
     *
     * @return void
     */
    public function testBlogPageDoesLoadAnonymousUser(): void
    {
        $response = $this->get('/blog');
        $response->assertStatus(200);
    }

    /**
     * Anyone can view single blog posts
     *
     * @return void
     */
    public function testSingleBlogPostDoesLoadAnonymousUser(): void
    {
        $this->seed(PostSeeder::class);

        $response = $this->get('/blog/post/' . PostSeeder::POST_1_SLUG);
        $response->assertStatus(200);
    }

    /**
     * Draft posts should not load for anonymous users
     *
     * @return void
     */
    public function testDraftBlogPostDoesNotLoadAnonymousUser(): void
    {
        $this->seed(PostSeeder::class);

        $response = $this->get('/blog/post/' . PostSeeder::POST_2_SLUG);
        $response->assertStatus(302);
    }

    /**
     * Draft posts SHOULD load for authors
     *
     * @return void
     */
    public function testDraftBlogPostDoesLoadAuthor(): void
    {
        $this->seed(PostSeeder::class);

        $user = User::factory()->create();
        $user->role = 'author';

        $response = $this->actingAs($user)
            ->get('/blog/post/' . PostSeeder::POST_2_SLUG);
        $response->assertStatus(200);
    }

    /**
     * Anonymous users can not load new blog post page
     *
     * @return void
     */
    public function testNewBlogPostDoesNotLoadAnonymousUser(): void
    {
        $response = $this->get('/admin/blog/post');
        $response->assertStatus(302);
    }

    /**
     * Authors can load the new blog post page
     *
     * @return void
     */
    public function testNewBlogPostDoesLoadAuthor(): void
    {
        $user = User::factory()->create();
        $user->role = 'author';

        $response = $this->actingAs($user)
            ->get('/admin/blog/post');
        $response->assertStatus(200);
    }

    /**
     * Authors can save a new blog post
     *
     * @return void
     */
    public function testNewBlogPostCreatedByAuthor(): void
    {
        $user = User::factory()->create();
        $user->role = 'author';
        $user->id = '1';

        $data = [
            'title' => 'Test new post by author',
            'metaTitle' => '',
            'body' => 'a blog post',
            'metaDescription' => '',
            'slug' => 'test-new-post-by-author'
        ];

        $response = $this->actingAs($user)
            ->post('/admin/blog/post', $data);
        $response->assertStatus(302);
        $this->assertGreaterThan(0, strpos($response->getTargetUrl(), $data['slug']));
    }

    /**
     * Anonymous users can not load a blog post edit page
     *
     * @return void
     */
    public function testEditBlogPostDoesNotLoadAnonymousUser(): void
    {
        $this->seed(PostSeeder::class);

        $response = $this->get('/admin/blog/post/' . PostSeeder::POST_1_SLUG);
        $response->assertStatus(302);
    }

    /**
     * Authors can load the edit blog post page
     *
     * @return void
     */
    public function testEditBlogPostDoesLoadAuthor(): void
    {
        $this->seed(PostSeeder::class);

        $user = User::factory()->create();
        $user->role = 'author';
        $user->id = '1';

        $response = $this->actingAs($user)
            ->get('/admin/blog/post/' . PostSeeder::POST_1_SLUG);
        $response->assertStatus(200);
    }

    /**
     * Authors can save an edit to a blog post
     *
     * @return void
     */
    public function testEditBlogPostSavedByAuthor(): void
    {
        $this->seed(PostSeeder::class);

        $user = User::factory()->create();
        $user->role = 'author';
        $user->id = '1';

        $data = [
            'title' => 'Test new post by author',
            'metaTitle' => '',
            'body' => 'a blog post',
            'metaDescription' => '',
            'slug' => 'test-edit-post-by-author'
        ];

        $response = $this->actingAs($user)
            ->put('/admin/blog/post/' . PostSeeder::POST_1_SLUG, $data);
        $response->assertStatus(302);
        $this->assertGreaterThan(0, strpos($response->getTargetUrl(), $data['slug']));
    }

    /**
     * Authors can delete posts
     *
     * @return void
     */
    public function testAuthorCanDeletePost(): void
    {
        $this->seed(PostSeeder::class);

        $user = User::factory()->create();
        $user->role = 'author';
        $user->id = '1';

        $data = [
            'title' => 'Test post by author',
            'metaTitle' => '',
            'body' => 'a blog post',
            'metaDescription' => '',
            'delete' => 1
        ];

        $response = $this->actingAs($user)
            ->put('/admin/blog/post/' . PostSeeder::POST_2_SLUG, $data);
        $response->assertStatus(302);
        $this->assertGreaterThan(0, strpos($response->getTargetUrl(), '/admin/blog/post'));
    }
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/2e9dc1dcc18c58cedba2d77d9b3cac3d257e4319)

4) Add `CommentControllerTest.php`
```bash
./vendor/bin/sail artisan make:test CommentControllerTest
```

Add `use DatabaseTransaction` to ensure it rolls back any new database rows created.

5) Write the tests!
```php

namespace Tests\Feature;

use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Foundation\Testing\WithFaker;
use Tests\TestCase;
use App\Models\User;
use Database\Seeders\PostSeeder;
use Illuminate\Foundation\Testing\DatabaseTransactions;

class CommentControllerTest extends TestCase
{
    use DatabaseTransactions;

    /**
     * Anonymous users can not comment on a post
     *
     * @return void
     */
    public function testAnonymousUsersCanNotComment(): void
    {
        $this->seed(PostSeeder::class);

        $response = $this->post('/admin/blog/comment', ['post_id' => '1', 'comment' => 'test comment']);
        $response->assertStatus(403);
    }
    /**
     * Anonymous users can not delete a comment on a post
     *
     * @return void
     */
    public function testAnonymousUsersCanNotDeleteComment(): void
    {
        $this->seed(PostSeeder::class);

        $response = $this->delete('/admin/blog/comment/1');
        $response->assertStatus(403);
    }
}
```

6) Run the tests
```bash
./vendor/bin/sail artisan test
```

```bash
   PASS  Tests\Feature\CommentControllerTest
  ✓ anonymous users can not comment
  ✓ anonymous users can not delete comment

   PASS  Tests\Feature\PostControllerTest
  ✓ blog page does load anonymous user
  ✓ single blog post does load anonymous user
  ✓ draft blog post does not load anonymous user
  ✓ draft blog post does load author
  ✓ new blog post does not load anonymous user
  ✓ new blog post does load author
  ✓ new blog post created by author
  ✓ edit blog post does not load anonymous user
  ✓ edit blog post does load author
  ✓ edit blog post saved by author
  ✓ author can delete post

  Tests:  14 passed
  Time:   3.35s
```


## Roundup
That's it for now. If you want to take this even further you can think about some of these things:
- Adding a WYSIWYG
- Adding an "Author" page that lists all of their posts
- Adding ability to login with another provider like Google, Facebook, LinkedIn, etc..

Create a Laravel 8 Blog - Part 7: Testing


## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- **Part 6: Validation**
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)


Everything a user, whether they are an admin or anonymous, puts into the application needs to be vetted to ensure it's what we expect. It protects from accidents as much as it does from malicious intent. Whether you do this as you're developing the code or make it a separate milestone is up to you. I find benefits with both paths.


## Posts
First off, let's think about what we *know* should be true about posts.
- They always need a title
- They always need a body
- The length of the values should never exceed the length of the database column storing the data
- The URL slug needs to be unique to avoid collisions when routing
- Make sure only URL-friendly characters are used in the slug
- Only admins or authors should be able to add posts
- Only admins or authors should be able to edit posts
- Only admins or authors should be able to delete posts

Now, let's work through these.

[Form Request](https://laravel.com/docs/8.x/validation#creating-form-requests) makes it easy to do validation on the data *before* it hits the controller. Using `artisan` we can create the barebones class to work from.
```bash
./vendor/bin/sail artisan make:request PostRequest
```

```php
<?php 

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class PostRequest extends FormRequest
{
    // This ensures only admins/authors can hit the endpoints this PostRequest is used with
    public function authorize()
    {
        if ($this->user()->canManagePosts()) {
            return true;
        }
        return false;
    }

    public function rules()
    {
        $rules = [
            // We need a title and the database column only allows for 255 chars
            'title' => 'required|max:255',
            // We need a body
            'body' => 'required',
            // The slug should be alphanumeric characters with dashes/spaces allowed
            'slug' => 'unique:posts|regex:/^[A-Za-z0-9- ]+$/i',
            'metaTitle' => 'max:255',
            'metaDescription' => 'max:255'
        ];

        return $rules;
    }

    public function messages()
    {
        return [
            'title.required' => 'Please add a title',
            'body.required' => 'Please add some content to the post',
            'slug.unique' => 'The URL slug has already been used'
        ];
    }
}
```

Update `PostController.php` to use `PostRequest`.
```php
public function save(PostRequest $request)
{
    $data = $request->validated();

    $post = new Post();
    $post->title = $data['title'];
    $post->metaTitle = $data['metaTitle'];
    $post->body = $data['body'];
    $post->metaDescription = $data['metaDescription'];
    $post->slug = $data['urlSlug'] ?? Str::slug($post->title);

...

public function update(PostRequest $request, string $slug)
...
```

Update the blade file to render errors if there are any.
```php
# resources/views/blog/posts/create.blade.php 

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif
```


[See commit 1](https://github.com/levijackson/laravel-blog/commit/a1a6bbf10427cc0586bf29150c3b50a5c286699d)

[See commit 2](https://github.com/levijackson/laravel-blog/commit/68a339de7939e6ed73693fe3ca25eb88d3adef70)


2) If there is an error, show the form values

I'll only show a snippet, but it utilizes Laravel's [old](https://laravel.com/docs/8.x/helpers#method-old) function to populate the values.
```php
<input type="text" name="title" class="form-control" value="{{ old('title') }}" />
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/0a120865634ac518e918d2122ae780f9b62a896d)


3) Add validation to the post update route

Update `PostRequest.php` slug validation. 
```php
public function rules()
{
    $rules = [
        'title' => 'required|max:255',
        'body' => 'required',
        'slug' => 'unique:posts|regex:/^[A-Za-z0-9 ]+$/i',
        'metaTitle' => 'max:255',
        'metaDescription' => 'max:255'
    ];

    if ($this->method() === 'PUT') {
        // this ensures that an existing post still requires a slug, but that
        // it doesn't validate against itself and trigger an error!
        $rules['slug'] = 'unique:posts,title,' . $this->get('slug') . '|regex:/^[A-Za-z0-9\- ]+$/i';
    }

    return $rules;
}
```

Update the blade file to render errors if there are any.
```php
# resources/views/blog/posts/edit.blade.php 

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif
```

[See commit 1](https://github.com/levijackson/laravel-blog/commit/37be2ee92eb3e40067551c981628489941a7d412)

[See commit 2](https://github.com/levijackson/laravel-blog/commit/1baa6768c9ebb97ef6a87aa68ed1fd5f04b09f2d)


## Comments
Let's think about what we *know* should be true about comments.
- There always needs to be a comment
- The length of the values should never exceed the length of the database column storing the data
- Logged in users can add comments
- Anonymous users can not add comments

1) Add comment validation
```bash
./vendor/bin/sail artisan make:request CommentRequest
```

```php
# app/Http/Requests/CommentRequest.php

<?php 

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class CommentRequest extends FormRequest
{
    public function authorize()
    {
        if ($this->user() && $this->user()->id > 0) {
            return true;
        }
        return false;
    }

    public function rules()
    {
        return [
            'comment' => 'required|string',
            'post_id' => 'required|integer'
        ];
    }
} 
```

Update the comment blade file to display errors
```php
#  resources/views/blog/comments/create.blade.php 

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif
```

Update `CommentController.php` to use the new `CommentRequest` class.
```php
public function save(CommentRequest $request)
{
    $data = $request->validated();

    $comment = new Comment();
    $comment->comment = $data['comment'];
    $comment->user_id = $request->user()->id;
    $comment->post_id = $data['post_id'];

    $comment->save();

    return redirect()
        ->back();
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/d6a401ae183b9f42ef2f57ccffa16214df86a83f)


2) Add delete comment validation
The main goal here is to make sure only admins and authors can delete comments.

```bash
./vendor/bin/sail artisan make:request DeleteCommentRequest
```

```php
# app/Http/Requests/DeleteCommentRequest.php

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class DeleteCommentRequest extends FormRequest
{
    public function rules()
    {
        return [];
    }

    public function authorize()
    {
        if ($this->user() && $this->user()->canManagePosts()) {
            return true;
        }
        return false;
    }
}
```

Update `CommentController.php` to use the new `DeleteCommentRequest` class.
```php
public function delete(DeleteCommentRequest $request, int $commentId)
```

[See commit 1](https://github.com/levijackson/laravel-blog/commit/d1a2b3c0f695200c7d8d943d3ce632f09ef38a26)

[See commit 2](https://github.com/levijackson/laravel-blog/commit/bfdb32255dd617891675fc0c04ccf36e0f425250)


## Roundup
That's it for now. Part 7 will go through automating the testing to ensure the functionality works.

Next: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)

Create a Laravel 8 Blog - Part 6: Validation


## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- **Part 5: Comment CRUD**
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)


At the end of this you'll have a blog post view like this
![Single blog post example](/images/posts/laravel-8-blog/post-details.png)

## New post form
1) Make a new folder for the blade files
```bash
mkdir resources/views/blog/comments/
```

2) Add new `CommentController`
```bash
./vendor/bin/sail artisan make:controller CommentController
```

3) Add a `save` method + path (`/admin/blog/comment`) to the route file.

Add the route inside the `/blog` prefix group.
```php
# routes/web.php 

Route::post('/comment', 'App\Http\Controllers\CommentController@save');
```

```php
# app/Http/Controllers/CommentController.php

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Comment;

class CommentController extends Controller
{
    public function save(Request $request)
    {
        $comment = new Comment();
        $comment->comment = $request->get('comment');
        $comment->user_id = $request->user()->id;
        $comment->post_id = $request->get('post_id');

        $comment->save();

        return redirect()
            ->back();
    }
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/6631e68a85ed78d6faf3ef34f0bce0a1c2e5ed8c)


4) Add the form to create a comment and add it to the single post view

```php
# resources/views/blog/comments/create.blade.php

<form action="/admin/blog/comment" method="post" class="container">
    <input type="hidden" name="_token" value="{{ csrf_token() }}" />
    <input type="hidden" name="post_id" value={{ $post->id }} />
    <div class="form-group">
        <label for="comment">Comment</label>
        <textarea name="comment" class="form-control"></textarea>
    </div>
    <input type="submit" name="submit" class="btn btn-success" value="Comment" />
</form>
```

Add the `include` to the blog post blade file so it displays the comment form.
```php
#  resources/views/blog/posts/single.blade.php

<h3>Comments</h3>
@include('blog.comments.create')
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/e932e8247fc740eb14bcb611c430acbee12d249c)


5) Display comments on a post

We'll update the PostController to include the comments as view data.
```php
$comments = $post->comments()->get();
return view('blog.posts.single', ['post' => $post, 'comments' => $comments]);
```

Add a new blade file for an individual comment
```php
# resources/views/blog/comments/single.blade.php

<li>
    <div>
        <h4>{{ $comment->author()->first()->name }} <small>({{ date('Y-m-d', strtotime($comment->created_at)) }})</small></h4>
        <p>{{ $comment->comment }}</p>
    </div>
</li> 
```

Update the single post blade file to loop the comments and render them.
```php
# resources/views/blog/posts/single.blade.php

@extends('layouts.app')

@section('content')
    <div class="container">
        <h1>{{ $post->title }}</h1>

        <p>{{ $post->body }}</p>

        <h3>Comments</h3>
        @include('blog.comments.create')

        <br /><br />
        <ul class="comment-list">
        @foreach ($comments as $comment)
            @include('blog.comments.single')
        @endforeach
        </ul>
    </div>
@stop
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/6b228f6d851401763fa9bc081995b5d594cd5808)


6) Add a way to delete a comment for admins only

Update the single post blade file to include a `delete` button.
```php
# resources/views/blog/comments/single.blade.php 

@auth
    <form action="/admin/blog/comment/{{ $comment->id }}" method="post">
        <input type="hidden" name="_token" value="{{ csrf_token() }}" />
        <input type="hidden" name="_method" value="DELETE">
        <input type="submit" name="delete" class="btn btn-danger" value="Delete" />
    </form>
@endauth
```

Add the route
```php
# routes/web.php

Route::delete('/comment/{commentId}', 'App\Http\Controllers\CommentController@delete');
```

Update CommentController to support the new delete route.
```php
# app/Http/Controllers/CommentController.php

public function delete(Request $request, int $commentId)
{
    $comment = Comment::where('id', $commentId)->first();

    if ($request->has('delete')) {
        $comment->delete();
        $message = 'Comment deleted!';
    }

    return redirect()->back();
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/c5d1b86c1d0e0518cebde9d62230de74b7842492)


## Roundup
That's it for now. Part 6 will go through adding validation to ensure nothing breaks from user input.

Next: [Validation](/posts/create-a-laravel-8-blog-part-6-validation/)

Create a Laravel 8 Blog - Part 5: Comment CRUD


## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- **Part 4: Post CRUD**
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)


At the end of this you'll have a form like this
![Post form](/images/posts/laravel-8-blog/post-form.png)

## New post form
1) Make a new folder for the blade files
```bash
mkdir resources/views/blog/posts/
```

2) Add the form and controller paths to create a new post

Add the routes to view the form and save the post.
```php
# routes/web.php

Route::group(['prefix' => 'admin'], function () {
    Route::group(['prefix' => 'blog'], function () {
        Route::get('/post', 'App\Http\Controllers\PostController@create');
        Route::post('/post', 'App\Http\Controllers\PostController@save');
    });
});
```

Add the blade file with the fields you want to store for the blog post.
```php
# resources/views/blog/posts/create.blade.php

@extends('layouts.app')

@section('content')
    @if (session('message'))
        <div class="alert alert-success">
            {{ session('message') }}
        </div>
    @endif

    <form action="/admin/blog/post" method="post" class="container">
        <input type="hidden" name="_token" value="{{ csrf_token() }}">
        <div class="form-group">
            <label for="title">Title</label>
            <input type="text" name="title" class="form-control" />
        </div>
        <div class="form-group">
            <label for="metaTitle">Meta Title</label>
            <input type="text" name="metaTitle" class="form-control" />
        </div>
        <div class="form-group">
            <label for="body">Body</label>
            <textarea name="body" class="form-control"></textarea>
        </div>
        <div class="form-group">
            <label for="metaDescription">Meta Description</label>
            <textarea name="metaDescription" class="form-control"></textarea>
        </div>
        <div class="form-group">
            <label for="urlSlug">URL Slug (optional)</label>
            <small>If not specified one will be created from the title</small>
            <input type="text" name="urlSlug" class="form-control" />
        </div>
        <input type="submit" name="publish" class="btn btn-success" value="Publish" />
        <input type="submit" name="draft" class="btn btn-default" value="Save Draft" />
    </form>
@stop
```

The controller has two new methods. `create` handles rendering the form to add a new post. `save` handles processing the POST request and storing the new post.
```php
# app/Http/Controllers/PostController.php 

public function create(Request $request)
{
    if ($request->user()->canManagePosts()) {
    return view('blog.posts.create');
    } else {
    return redirect('/')
        ->withErrors('You do not have permission to create posts.');
    }
}

public function save(Request $request)
{
    $post = new Post();
    $post->title = $request->get('title');
    $post->metaTitle = $request->get('metaTitle');
    $post->body = $request->get('body');
    $post->metaDescription = $request->get('metaDescription');
    $post->slug = $request->get('urlSlug') ?? Str::slug($post->title);
    $post->user_id = $request->user()->id;

    if ($request->has('draft')) {
        $post->active = 0;
        $message = 'Draft saved!';
    } else {
        $post->active = 1;
        $message = 'Post published!';
    }

    $post->save();

    return redirect('admin/blog/post/' . $post->slug)
        ->withMessage($message);
}
```

The user model needs an update to show which `role` can add posts.
```php
#  app/Models/User.php 

/**
 * Check if a user can CRUD posts
*/
public function canManagePosts(): bool
{
    if ($this->role === 'author' || $this->isAdmin()) {
        return true;
    }
    return false;      
}

/**
 * Check if the user is an admin
*/
public function isAdmin(): bool
{
    return $this->role === 'admin';
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/b6dd99af67b35906bc47eb21a03a1bb37789cee3)


3) Add the paths to update/delete a post

Add the edit/update routes into the `blog` prefix group
```php
# routes/web.php
Route::get('/post/{slug}', 'App\Http\Controllers\PostController@edit');
Route::put('/post/{slug}', 'App\Http\Controllers\PostController@update');
```

Add the blade file/form to edit a post.
```php
# resources/views/blog/posts/edit.blade.php

@extends('layouts.app')

@section('content')
    @if (session('message'))
        <div class="alert alert-success">
            {{ session('message') }}
        </div>
    @endif

    <form action="/admin/blog/post/{{ $post->slug }}" method="post" class="container">
        <input type="hidden" name="_method" value="PUT">

        <input type="hidden" name="_token" value="{{ csrf_token() }}">
        <div class="form-group">
            <label for="title">Title</label>
            <input type="text" name="title" class="form-control" value={{ $post->title }} />
        </div>
        <div class="form-group">
            <label for="metaTitle">Meta Title</label>
            <input type="text" name="metaTitle" class="form-control" value={{ $post->metaTitle }}  />
        </div>
        <div class="form-group">
            <label for="body">Body</label>
            <textarea name="body" class="form-control">{{ $post->body }}</textarea>
        </div>
        <div class="form-group">
            <label for="metaDescription">Meta Description</label>
            <textarea name="metaDescription" class="form-control">{{ $post->metaDescription }}</textarea>
        </div>
        <div class="form-group">
            <label for="urlSlug">URL Slug (optional)</label>
            <small>If not specified one will be created from the title</small>
            <input type="text" name="urlSlug" class="form-control" value={{ $post->slug }} />
        </div>
        <input type="submit" name="update" class="btn btn-success" value="Update" />
        <input type="submit" name="delete" class="btn btn-danger" value="Delete" />
    </form>
@stop
```

The controller has two new methods. `edit` handles rendering the form to edit an existing post. `update` handles processing the PUT request to change the post.
```php
# app/Http/Controllers/PostController.php 

public function edit(Request $request, string $slug)
{
    $post = Post::where('slug', $slug)->first();

    if ($post && ($request->user()->id == $post->user_id || $request->user()->isAdmin())) {
        return view('blog.posts.edit', ['post' => $post]);
    }
    
    return redirect('/')
        ->withErrors('You do not have permission to edit this post.');
}

public function update(Request $request, string $slug)
{
    $post = Post::where('slug', $slug)->first();

    if ($request->has('delete')) {
        $post->delete();
        $message = 'Post deleted!';
        return redirect('admin/blog/post/')
            ->withMessage($message);
    }

    $post->title = $request->get('title');
    $post->metaTitle = $request->get('metaTitle');
    $post->body = $request->get('body');
    $post->metaDescription = $request->get('metaDescription');
    $post->slug = $request->get('urlSlug') ?? Str::slug($post->title);
    $post->user_id = $request->user()->id;

    $message = 'Post updated!';

    $post->save();

    return redirect('admin/blog/post/' . $post->slug)
        ->withMessage($message);
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/3ef54dd07119be628d027fb27175f3ff6a401493)


4) Add path to view post details on front-end

Set up the route. I created a `blog` prefix group to make managing the prefix easier and consolidated the existing `/blog` path.
```php
# routes/web.php 

Route::group(['prefix' => 'blog'], function () {
    Route::get('/', 'App\Http\Controllers\PostController@index');
    Route::get('/post/{slug}', 'App\Http\Controllers\PostController@single');
});
```

Add the controller method to fetch the post and render the view.
```php
# app/Http/Controllers/PostController.php

public function single(Request $request, string $slug)
{
    $post = Post::where('slug', $slug)->first();

    if ($post) {
        return view('blog.posts.single', ['post' => $post]);
    }
    
    return redirect('/')
        ->withErrors('This post does not exist.');
}
```

Update the blog landing page to list out the posts along with an edit/view link if the user is logged in.
```php
# resources/views/blog/index.blade.php 

@extends('layouts.app')

@section('content')
    <h1>{{$title}}</h1>
    @forelse ($posts as $post)
        @guest
            <li>{{ $post->title }}</li>
        @endguest
        @auth
            <li>{{ $post->title }} - <a href="/blog/post/{{ $post->slug }}">View</a> | <a href="/admin/blog/post/{{ $post->slug }}">Edit</a></li>
        @endauth
    @empty
        <p>No posts</p>
    @endforelse
@stop
```

Add a simple blade file that just prints the title and body content out.
```php
# resources/views/blog/posts/single.blade.php

@extends('layouts.app')

@section('content')
    <h1>{{ $post->title }}</h1>

    <p>{{ $post->body }}</p>
@stop 
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/e66c4d2bf3ebb85c9867dd55bfc172f32e2975e2)


5) Add menu items to access these new paths easily!

```php
# resources/views/layouts/app.blade.php

<a class="nav-link" href="{{ url('/blog') }}">All Posts</a>
@auth
<a class="nav-link"  href="{{ url('/admin/blog/post') }}">+ New Post</a>
@endauth
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/c3f0d49f0081b1008ea8e1acffbe802ccd8d7a0b)


## Roundup
That's it for now. Part 5 will go through adding the ability to comment on posts.

Next: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)

Create a Laravel 8 Blog - Part 4: Post CRUD


## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- **Part 3: Authentication/Login**
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)

## Install the UI theme
We are going to make use of the [laravel/ui](https://github.com/laravel/ui) utilities to get a basic style and authentication setup in place.

1) Install the utility
```bash
./vendor/bin/sail composer require laravel/ui
```

2) Load the `bootstrap` UI along with the authentication controllers/views
```bash
./vendor/bin/sail artisan ui bootstrap --auth
```

## Build the JS/CSS
1) Install the npm packages that will allow us to build the CSS/JS
```bash
./vendor/bin/sail npm install
```

2) Build the compiled CSS/JS so the front-end has files to load. You may see broken styling if this is not done.
```bash
./vendor/bin/sail npm run prod
```

*It will wipe out the app.blade.php we had set up before. That is OK.*
```bash
 The [layouts/app.blade.php] view already exists. Do you want to replace it? (yes/no) [no]:
 > yes
```

## Clean up default files
Some `welcome` blade files and routes are automatically generated that we'll clean up.

1) Remove the `resources/views/welcome.blade.php` file. We'll replace it with the new blade file created by using `laravel/ui`.
```bash
git rm resources/views/welcome.blade.php
```

2) Update the `/` route in `routes/web.php` to point to the `home.blade.php` file.

[See the commit](https://github.com/levijackson/laravel-blog/commit/fe7b92c2e5c9a815dfacb7d3197185002e6095f2)


## Create the admin account
If you load the site, [http://localhost:6001](http://localhost:6001), you'll now see `Log in` and `Register ` in the top right of the page. Click `Register` and fill it out. We will turn this into your admin account.

![Login and register buttons](/images/posts/laravel-8-blog/login-register-buttons.png)


We don't have an admin interface to work with users, so for now we'll manually adjust it from SQL.

1) Connect to mysql
```bash
./vendor/bin/sail mysql
```

2) Run the SQL to set your role to `admin`
```sql
UPDATE users SET role='admin' where ID='1';
```


## Roundup
That's it for now. Part 4 will go through adding controllers/views to manage blog posts now that we have an `admin` user.

Next: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)

Create a Laravel 8 Blog - Part 3: Authentication


## Overview
- Part 1: [Walk-through installing and configuring Laravel](/posts/create-a-laravel-8-blog-part-1-setup/)
- **Part 2: Create the core models/tables, controllers, and views**
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)

## Add MySQL tables

### Posts and Comments
We're going to add migration files that create the MySQL tables.

```bash
./vendor/bin/sail artisan make:migration posts
./vendor/bin/sail artisan make:migration comments
```

```php
# database/migrations/2021_06_23_155553_posts.php 

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class Posts extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('user_id');
            $table->foreign('user_id')
              ->references('id')->on('users')
              ->onDelete('cascade');
            $table->string('title')->unique();
            $table->text('body');
            $table->text('metaDescription');
            $table->string('metaTitle');
            $table->string('slug')->unique();
            $table->boolean('active');
            $table->timestamps();
          });      
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('posts');
    }
}
```


```php
# database/migrations/2021_06_23_155557_comments.php

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

class Comments extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id();
            $table->unsignedBigInteger('post_id');
            $table->unsignedBigInteger('user_id');
            $table->foreign('post_id')
              ->references('id')->on('posts')
              ->onDelete('cascade');
            $table->foreign('user_id')
              ->references('id')->on('users')
              ->onDelete('cascade');
            $table->text('comment');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::drop('comments');
    }
}
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/e2d4698250df30513037caa7084dcbf647f5d223)


### Users
Adjust the standard user migration to add a new columnn to track the user's `role`.
```php
# database/migrations/2014_10_12_000000_create_users_table.php

$table->enum('role',['admin','author','user'])->default('author');
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/cc70e0508cec5ebf251617c9b9e57d69a35a3c77)


### Run the Migrations
```bash
./vendor/bin/sail artisan migrate
```


## Make the models
Make the `Post` and `Comment` model + adjust the `User` model to fetch the linked posts or comments.

```bash
./vendor/bin/sail artisan make:model Post
./vendor/bin/sail artisan make:model Comment
```

```php
# app/Models/Post.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    use HasFactory;

    /**
     * Get the comments made on the post
     *
     * @return array App\Models\Comment
     */
    public function comments()
    {
        return $this->hasMany('App\Models\Comment', 'post_id');
    }
    
    /**
     * Get the user who created the post
     *
     * @return App\Models\User
     */
    public function author()
    {
        return $this->belongsTo('App\Models\User', 'user_id');
    }
}
```

```php
<?php
#  app/Models/Comment.php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Comment extends Model
{
    use HasFactory;

    /**
     * The user who wrote the comment
     *
     * @return App\Models\User
     */
    public function author()
    {
      return $this->belongsTo('App\Models\User', 'user_id');
    }
    
    /**
     * The post the comment is associated with
     *
     * @return App\Models\Post
     */
    public function post()
    {
      return $this->belongsTo('App\Models\Posts', 'post_id');
    }
  
}
```

Add these to the existing User model.
```php
# app/Models/User.php

public function posts()
{
    return $this->hasMany('App\Models\Posts', 'user_id');
}

public function comments()
{
    return $this->hasMany('App\Models\Comments', 'user_id');
}
```

[See commit 1](https://github.com/levijackson/laravel-blog/commit/9b36804f49804c8a0610afc96a6be4722444ee5b)

[See commit 2](https://github.com/levijackson/laravel-blog/commit/687103f1e3817db2f1a4a1a6c9c7ec1323e0ee02)


## View/Layout
Add the base template to get a shared HTML structure started.

```bash
mkdir resources/views/layouts
```

Copy the welcome blade file and adjust it to include a `@yield('content')` where you want the content to show up and `@yield('title')` where you want the page title to show up.
```bash
cp resources/views/welcome.blade.php resources/views/layouts/app.blade.php
```

[See the commit](https://github.com/levijackson/laravel-blog/commit/4c4ac0bf2fa3d411f23a1b2008ca43e25b307705)


## Add Post controller, view, and route

```bash
./vendor/bin/sail artisan make:controller PostController

mkdir resources/views/blog/
```

Add the `PostController`, it will fetch all active posts.
```php
<?php
# app/Http/Controllers/PostController.php

namespace App\Http\Controllers;

use Illuminate\Support\Str;
use Illuminate\Http\Request;

use App\Models\Post;

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::where('active', 1)
            ->orderBy('created_at','desc')
            ->get();

        //return blog.blade.php template from resources/views folder
        return view('blog.index', ['posts' => $posts, 'title' => 'Blog Posts']);
    }
}
```

```php
# resources/views/layouts/app.blade.php 

<!DOCTYPE html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>{{ $title }}</title>
    </head>
    <body>
        @yield('content')
    </body>
</html>
```

```php
# resources/views/blog/index.blade.php

@extends('layouts.app')

@section('content')
    <h1>{{$title}}</h1>
    @forelse ($posts as $post)
        <li>{{ $post->title }}</li>
    @empty
        <p>No posts</p>
    @endforelse
@stop
```

Add the route to send the URI `/blog` to the controller
```php
# routes/web.php

Route::get('/blog', 'App\Http\Controllers\PostController@index');
```


[See commit 1](https://github.com/levijackson/laravel-blog/commit/63855a3f367aecb095ac45be90530d892f78db57)

[See commit 2](https://github.com/levijackson/laravel-blog/commit/f9684de97f1469b7dbaf535b70684aa8815d5939)

### Test it out
Load the `/blog` path in the browser and confirm it works. [http://localhost:6001/blog](http://localhost:6001/blog). You should see the title of `Blog Posts` and `No posts` because we haven't added anything yet.

![No posts image](/images/posts/laravel-8-blog/no-posts.png)

## Roundup
That's it for now. Part 3 will go through setting up a login mechanism and handling authorization.

Next: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)

Create a Laravel 8 Blog - Part 2: Scaffolding


## Prerequisites
1) [Docker](https://www.docker.com/)
2) Patience


## Overview
- **Part 1: Walk-through installing and configuring Laravel**
- Part 2: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)
- Part 3: [Authorization/Login](/posts/create-a-laravel-8-blog-part-3-authentication/)
- Part 4: [Post CRUD](/posts/create-a-laravel-8-blog-part-4-post-crud/)
- Part 5: [Comment CRUD](/posts/create-a-laravel-8-blog-part-5-comment-crud/)
- Part 6: [Validation ](/posts/create-a-laravel-8-blog-part-6-validation/)
- Part 7: [Testing](/posts/create-a-laravel-8-blog-part-7-testing/)


## Install Laravel
We are going to install Laravel using [Sail](https://laravel.com/docs/8.x/sail). Sail is a robust tool that utilizes Docker to create *all* of the resources you need to develop with. Among other things it will handle creating containers for MYSQL and [Redis](https://redis.io/) while ensuring they can communicate to your laravel web container.

Follow the "Getting Started..." steps on [laravel.com](https://laravel.com/docs/8.x#getting-started-on-linux) for your OS. I'm running Linux so my steps were as follows:

```bash
curl -s https://laravel.build/laravel-blog | bash
```
*If you want to call your directory something other than "laravel-blog" you can the URL your request to anything. The utility uses the uri segment as the folder name.*


### Start it up!
This will take a while to start up the first time as Docker will need to download all of the images it needs to build the containers.


Move into the project directory
```bash
cd laravel-blog
```

Copy `.env.example` to `.env` so that Laravel has a base configuration.
```bash
cp .env.example .env
```

Start the server
```bash
# Option 1: If port 80 and 3306 are open on your local machine
./vendor/bin/sail up

# Option 2: If port 80 (web) or 3306 (mysql) is in use
# on your local machine by something else
APP_PORT=6001 FORWARD_DB_PORT=6002 ./vendor/bin/sail up
```

### Generate an application key
The application key is used to encrypt data in Laravel, NOT for password hashing. Cookie values and signed URLs use this to encrypt the data being passed from the front-end to the back-end.

You can change this value after the application is running, however it will invalidate any user sessions and potentially other things utilizing it.

```bash
./vendor/bin/sail artisan key:generate
```

This will update the entry `APP_KEY=` in `.env` to have something like
```php
APP_KEY=base64:mHPrczpq0PuT0Hh88uyjEU+NiG88T6T7q+oyiXg3OLg=
```

### Test it out
Load it in a browser [http://localhost:6001/](http://localhost:6001/)
![Laravel 8 welcome page](/images/posts/laravel-8-blog/laravel-loaded.png)


## Set up the Database
You'll need a database to store posts, users, and comments in.

### Configure Laravel to use the Database
We'll want to add the connection settings to the `.env` file.

The `docker-compose.yml` service name is `mysql`, so that is the host name within this docker network to use.

If you used the `FORWARD_DB_PORT=6002` when starting it up, you **do not** need to put `6002`. Outside the Docker network it uses port `6002` to avoid conflicts, but within the docker network it is referenced on port 3306.

```php
DB_HOST=mysql
DB_PORT=3306
DB_DATABASE=laravel-db
DB_USERNAME=dev-user
DB_PASSWORD=password
```

## Roundup
That's it for now. Part 2 will go through creating models, controllers, and views to get us started down the path of making this into a blog.

Next: [Create the core models/tables, controllers, and views](/posts/create-a-laravel-8-blog-part-2-scaffolding/)

Create a Laravel 8 Blog - Part 1: Setup


## CAUTION: This is not an ideal path I would use in Production. I would need to think very strongly before using it in Development too. 

I am posting with the intention that it helps bring together some of the info and it does help someone in a pinch, or maybe even to work out a long-term solution.

There are a few tickets and posts out there noting that you can't run Wordpress Multisite on a non-standard port (80 or 443).

[https://core.trac.wordpress.org/ticket/21077](https://core.trac.wordpress.org/ticket/21077)

[https://core.trac.wordpress.org/ticket/42993](https://core.trac.wordpress.org/ticket/42993)

[https://wordpress.stackexchange.com/questions/212978/multisite-network-port-num-issues](https://wordpress.stackexchange.com/questions/212978/multisite-network-port-num-issues)


That said, here are my notes/steps towards adjusting it to get it working. It is completely outside the realm of what I would do in Production, but for testing in development where I can't use port 80, it works.


## Initial setup
1) Clone the [docker-compose repo](https://github.com/levijackson/docker-wordpress)
2) Set up Wordpress [http://localhost:8000](http://localhost:8000)
3) Enable Multisite in `wp-config.php`
```
define( 'WP_ALLOW_MULTISITE', true );
```
4) Edit `/etc/hosts` and add a few entries for the sites you want to configure
```
172.99.0.9     wordpress1.localhost
172.99.0.9     wordpress2.localhost
```

## Adjustments
If you go to `Tools` => `Network Setup` now, you'll see 
```
Error: You cannot install a network of sites with your server address.`
You cannot use port numbers such as :8000.
```

### Code changes
1) Edit `wp-admin/includes/network.php` to add the port you configured Docker to use, `8000` in my case.
```
# function network_step1 

if ( ( false !== $has_ports && ! in_array( $has_ports, array( ':80', ':443', ':8000' ), true ) ) ) {
```

2) Go to `Tools` => `Network Setup` and [run through step 3](https://wordpress.org/support/article/create-a-network/#step-3-installing-a-network). You'll end up on a page that looks like this
![Setup messages](/images/posts/wordpress-multi-site-network/wordpress_multisite_settings.png)


3) Follow the instructions and adjust `wp-config.php` and `.htaccess`

4) At this stage you need to log back into admin. If you try, it won't work. The cookies that are set during the login process don't strip out the port from the host name used with the cookie. 
You'll need to edit another spot to strip out the port when it assigns the cookie.
```
# wp-includes/ms-default-constants.php

define( 'COOKIE_DOMAIN', '.' . $current_network->cookie_domain );

=>

define( 'COOKIE_DOMAIN', '.' . str_replace(':8000', '', $current_network->cookie_domain ));
```

### Database changes
1) Add a new site
`My Sites` => `Network Admin` => `Sites`
![New site fields](/images/posts/wordpress-multi-site-network/new_site_fields.png)

2) It adds the site and strips out the port, so you'll need to log in and adjust the URL in the database directly.

```
# In wp_2_options (each site will have a table of their own)
- Adjust the `option_name` with the values of `siteurl` and `home`
http://wordpress1.localhost8000
=> 
http://wordpress1.localhost:8000
```

3) Make the same adjustment in `wp_blogs` for the site

4) You'll now be able to load the site from [http://wordpress1.localhost:8000/](http://wordpress1.localhost:8000/)



## Now what?
That is a lot of manual work to make it work well in development. If I needed this to work on a custom port I would look to see if I could work out a way to do it with a plugin. The path I went down in this post will not allow for updating Wordpress easily.


### Alternatives to Multisite
If I was looking to setup a true multisite environment, I would lean more strongly towards seeing if using `wp-config.php` as suggested in [this ticket](https://core.trac.wordpress.org/ticket/15467#comment:1) is a viable option.

Multisite is powerful, but it also has some big pieces that make it harder to pick as an option for hosting many web sites with it.
- A combined `wp_users` table means all users funnel into one spot. It makes it tricker to segment client data and spin up test environments with "just enough" data.
- The nomenclature still references them as `blogs`. It's minor, but it does feel symbolic that the Multisite system has lagged behind with regard to dispelling the feeling that Wordpress is more than just a blog platform.




Setting up Wordpress Multisite using Docker and a custom port


Lately I've been finding myself experimenting with Wordpress. I created a [docker-compose file](https://github.com/levijackson/docker-wordpress) to help me stand up a new clean setup more quickly.

It is based upon the [Docker compose guide](https://docs.docker.com/compose/wordpress/)), but includes some extras, like phpMyAdmin.

## Usage
1) Clone the repository or copy the docker-compose file
2) Start the container `docker-compose up -d`
3) Run through the Wordpress installer http://localhost:8000

## Adding a theme or plugin
The `wp-content/` directory is mounted to the local file system. It makes it easy to copy plugins, or edit the theme files from your IDE.

## phpMyAdmin
You can access phpMyAdmin from http://localhost:8080 using the credentials set in the `docker-compose.yml` file (`MYSQL_USER` and `MYSQL_PASSWORD`).

## Reset the database
If you find you need to reset the data, you can delete the volumes created.
```
docker-compose down --volumes
```


Develop Wordpress using Docker


The [AWS guide](https://docs.aws.amazon.com/cli/latest/userguide/install-macos.html) is still a good starting point for this. The main piece I had trouble with was using `aws --version` once it was installed.

*Prerequisite:* have Python3 and Pip3 installed

## Quick answer:
Adjust _$PATH_ so it has the path to the AWS executable.


## Longer answer:
### 1) Find where it installed AWS

The guide says to use `which python3` - but when I installed Python it installed it to my user, not the system. 

When you run `pip3 install awscli --updgrade --user` it should spit out something like this
```
... awscli in ./Library/Python/3.8/lib/python/site-packages (1.18.18)
```
The **"./"** indicated it is a local path, NOT the system path. You can confirm by checking 
```
ls -la /Users/<insert_user_name>/Library/Python/3.8/bin/aws
```

### 2) Edit  `~./bash_profile` and add the path
```
export PATH=/Users/<insert_user_name>/Library/Python/3.8/bin:$PATH
```

### 3) Reload the profile
```
source .bash_profile
```
### 4) Test - `aws --version`. It should output
```
aws-cli/1.18.18 Python/3.8.2 Darwin/17.7.0 botocore/1.15.18
```

Hello there!