
## 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
```

Installing AWS CLI on Mac


Setting up composer to use a private repo is pretty easy... after you've done it once. There are a few things that can trip you up, such as the naming of the package and the version to include. The [docs](https://getcomposer.org/doc/05-repositories.md#using-private-repositories) for getting the configuration set up got me about 95% of the way there.

This guide assumes you already have a *composer.json* file created, and you're looking to add a new private repository to that.


## Part 1: Bitbucket configuration
Composer is going to need access to your Bitbucket account in order to fetch the private git repo. An OAuth consumer can be used to give composer access.
1) In Bitbucket, go to your "Bitbucket Settings" page `https://bitbucket.org/account/user/<username>/`

2) Click "OAuth"

![Click OAuth](/images/posts/using-a-private-repo-with-composer-and-bitbucket/oauth_link.png)

3) Click the "Add consumer" button

![Click the "Add consumer" button](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_button.png)


4) Fill in the name, description, callback URL (this can be anything - composer won't use it but it is required by Bitbucket), select <i>This is a private consumer</i>, and select <i>Repositories: Read</i> for the permissions.

![Consumer config part 1](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt1.png)

![Consumer config part 2](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt2.png)


## Part 2: Composer configuration
Using the *Key* and *Secret* from the OAuth consumer you created in part 1, you will need to add an *auth.json* file in composer's home directory.
```
vi ~/.composer/auth.json
```
```
{
    "bitbucket-oauth": {
        "bitbucket.org": {
            "consumer-key": "myKey",
            "consumer-secret": "mySecret"
        }
    }
}
```

## Part 3: Configure composer.json
1) Add your private repository to the configuration so composer can look there for packages. The URL for the repo can be found in Bitbucket by clicking the "Clone" button in the top right of the repository view.

![Package URL](/images/posts/using-a-private-repo-with-composer-and-bitbucket/package_url.png)

```
"repositories": [
  {
    "type": "git",
    "url": "https://aerosox@bitbucket.org/aerosox/dataconverter.git"
  }
]
```

2) Require the package in *composer.json*. With either of these methods.
- CLI: `composer require aerosox/dataconverter`
- Edit `composer.json`

```
"require": {
    "aerosox/dataconverter": "master@dev"
  }
```

## Troubleshooting
1) the package name in the *require* matches the name from the `composer.json` configuration for the package you are including.

```
// composer.json from aerosox/dataconvert

{
    // even though the git repo is configured as aerosox/dataconverter.git, this name *could* be anything. This is what composer is going to be looking for when it searches for the package to install.
    "name": "aerosox/dataconverter",
    "description": "Convert data formats",
    "type": "library",
    "authors": [
        {
            "name": "Levi Jackson",
            "email": "aerosox@gmail.com"
        }
    ],
    "autoload": {
        "psr-4": {
            "DataConverter\\": "src/"
        }
    },
    "require-dev": {
        "phpunit/phpunit": "^6.5"
    }
}
```
2) I saw a lot of guides say to load the package as `"aerosox/dataconverter": "master-dev"`. I initially thought that *master-dev* was a composer standard, but it's not. If you want to use that, you'd want to set up an alias in the package so it can be found.

```
"extra": {
  "branch-alias": {
    "master-dev": "actual-branch-name"
  }
}
```

Using a private repo with composer and bitbucket


I was discussing the speed of filtering an array with a colleague and I had been under the assumption that using PHP *array_*\* functions are considerably faster than using a loop (foreach, for, while) . I could not find evidence of that when I was doing some Google searches though so I decided to do a little bit of a speed test on my own.

For all of these tests I set up the following beforehand:

```
ini_set('memory_limit', '500M');
$data = range(0, 1000000);
```

## Test 1: array_filter vs loops
| Type         | Time |
| ----         | ---- |
| foreach      | 0.37 |
| while        | 0.58 |
| for          | 0.61 |
| array_filter | 0.74 |


```
// array_filter loop average 0.74 seconds
$start = microtime(true);
$data = array_filter($data, function ($item) {
    return $item%2;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.37 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
    if ($item%2) {
        $newData[] = $item;
    }
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.61 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
    if ($data[$i]%2) {
        $newData[] = $data[$i];
    }
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.58 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
    if ($data[$i]%2) {
        $newData[] = $data[$i];
    }
    $i++;
}
$end = microtime(true);

echo $end - $start;
```


## Test 2: array_map vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.76 |
| array_filter | 1.38 |

```
// array_map average 1.38 seconds
$start = microtime(true);
$data = array_map(function ($item) {
    return $item+1;
}, $data);
$end = microtime(true);

echo $end - $start;

// For loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
    $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
    $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
    $newData[] = $data[$i];
    $i++;
}
$end = microtime(true);

echo $end - $start;
```

## Test 3: array_walk vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.72 |
| array_filter | 0.76 |

```
// array_walk average 0.72 seconds
$start = microtime(true);
$data = array_walk($data, function ($item) {
    return $item+1;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
    $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
    $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
    $newData[] = $data[$i];
    $i++;
}
$end = microtime(true);

echo $end - $start;
```

## End Notes
I was incorrect when I thought that *array_\** functions are faster! Albeit the speed difference is pretty negligible when talking about using it once or twice during page execution. I won't stop using the *array_\** functions because of my findings, they still offer a cleaner way of writing the code. I will only second guess using them when I am writing code that has the potential to be processed thousands of times.

*I tested these with a pretty basic data set. Speed may vary depending on the type of data being used as well as the version of PHP (I used 5.5.4).*

Are array_* functions faster than loops?


I was working with [Grunt](http://gruntjs.com/) the other day attempting to update some legacy code to use [uglify](https://github.com/gruntjs/grunt-contrib-uglify) and I kept getting errors such as:
```
>> Uglifying source path/to/file.js failed.
Warning: Uglification failed.
Unexpected token punc «(», expected punc «:».
Line 12 in path/to/file.js
 Use --force to continue.

Aborted due to warnings.
```

 When I went to line 12 I saw absolutely nothing wrong. It was a comment block like the following:
 
 ```
 /*
An unobtrusive comment goes here
*/
```

I tried removing the file from the list being included and it happened again. Same error different file. Everything I was reading said it was most likely invalid Javascript doing it, but since I write code perfectly, that could not be the case. Fast forward 10-20 minutes and I found this [issue on Github](https://github.com/mishoo/UglifyJS2/issues/521) that sounded similar. A comment from [Eric Range](https://github.com/ericrange) advised that their code editor had added a line ending of "\n\r" to the file and that caused their build to fail. So I took a look at line endings and sure enough, a handful of the files were using "\n\r". I did a find/replace and changed them all to just a single new line ("\n"). I attempted to uglify it once more and yet again I was shown an error! I was beginning to think uglify and I were not going to be good friends.

```
Running "uglify:build" (uglify) task
{ message: 'Unexpected token: eof (undefined)',
  filename: 'file.js',
  line: 3032,
  col: 0,
  pos: 129381,
  stack: 'Error\n    at new JS_Parse_Error (/path/to/node/node_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:196:18)\n    at js_error (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:204:11)\n    at croak (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:678:41)\n    at token_error (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:682:9)\n    at unexpected (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:688:9)\n    at block_ (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1000:28)\n    at /path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:974:25\n    at function_ (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:979:15)\n    at expr_atom (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1187:24)\n    at maybe_unary (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1357:19)' }
>> Uglifying source path/to/file.js failed.
Warning: Uglification failed.
Unexpected token: eof (undefined).
Line 3032 in path/to/file.js
 Use --force to continue.

Aborted due to warnings.
```

I looked at the differences between the files that worked and the ones that failed. The only difference I found was that the failed files used tabs instead of spaces (they were created at a time when there was no convention for tabs vs spaces). So I converted the files that were using tabs to spaces and tried again. Bingo! It worked perfect.

## Final Solution

My final solution was to change all files to use unix line endings ("\n") and to convert tabs to spaces.

GruntJS "Warning: Uglification failed."


This is a super quick and simple post... but maybe it'll save someone time down the line. I sure won't make the mistake again. I spent more time than I would like to admit figuring out this issue. There are a lot of posts sprinkled around about different causes of the error, none of which were the cause of my error.

Given the following RequireJS config: 

```
require.config({
    "baseUrl":"\/path\/to\/dir\/",
    "paths":{
        "jQuery":"jquery.js"
    }
});
```

I was trying to do the following: 
```
require([jQuery], function ($) {
    console.log($);
});
```
That gave me the dreaded "jQuery not defined" error!

## Solution

Add quotes around "jQuery"!
```
require(["jQuery"], function ($) {
    console.log($);
});
```
Without the quotes jQuery was being treated as a Javascript variable instead of a string. So when it was looking for the jQuery dependency it did not exist. "jQuery" on the other hand does.

RequireJS "jQuery not defined"


Took a little bit of digging because a lot of the solutions were related to different versions of CKEditor. I finally came across [a solution on stackoverflow](http://stackoverflow.com/questions/18250404/ckeditor-strips-i-tag).

Add this to your CKEditor config.js file and the font awesome tags will stick around.

```
config.protectedSource.push(/<i[^>]*><\/i>/g);
```

 What the answer doesn't say is *why* this works though. If you look at the [documentation](http://docs.cksource.com/ckeditor_api/symbols/CKEDITOR.config.html) it says that what you push into protectedSource is "<span style="color: #000000;">List of regular expressions to be executed on input HTML, indicating HTML source code that when matched, must</span> **not** <span style="color: #000000;">be available in the WYSIWYG mode for editing." So this keeps the <i> tags intact because source mode of CKEditor does not get HTML validation, whereas the WYSIWYG mode does.</span></i[^>

CKEditor 3.x is stripping out font awesome tags


I had a strange issue where CrashPlan Pro wouldn't start up. I kept getting the error "Cannot connect to backup engine". After reviewing some <a href="http://support.code42.com/CrashPlan/Latest/Troubleshooting/Unable_To_Connect_To_The_Backup_Engine" target="_blank" rel="noopener noreferrer">help docs from CrashPlan</a> it was still not working. Every time I tried to start the CrashPlanService it would start and immediately stop. The log files weren't much help to me, they were just letting me know what I already knew, it had started and stopped for some strange reason.

A lot of the results that come up when you Google "CrashPlan Pro cannot connect to backup engine" show solutions where users were able to increase their memory from 512M to 1024M and it would resolve it. For me, when I went to `C:\Program Files\CrashPlan\CrashPlanService.ini` and checked what was there, it already had 1024M, so I figured maybe it wanted more. So I set it to 2048M to see if that would work. Nope.

After fruitlessly trying other things such as updating Java, turning it off and then on again, saying pretty please, I finally caved and sent their support team a message about it along with the log files from my attempts to start the service. They replied back within  a few hours that I should try lowering the memory used from 1024M to 512M. So I gave that a shot, and to my surprise it started up perfectly! My guess is that since the computer has some other memory intensive applications running, it was trying to use more memory than was available at the time.

## Solution
So the final solution was to open up the file `C:\Program Files\CrashPlan\CrashPlanService.ini` and to update `-Xmx1024m` to `-Xmx512m`

Crashplan Pro won't start


I have gotten the *" This diff includes files which are not valid UTF-8 (they contain invalid byte sequences). You can either stop this workflow and fix these files, or continue. If you continue, these files will be marked as binary."* quite a few times lately. I tried various things like using SublimeText to save as UTF-8, and nothing seems to work. I was convinced there was an invalid character being appended somewhere in the file on save. I stumbled across this post about [stripping invalid UTF-8 characters](http://jbuckley.ca/2011/05/stripping-invalid-utf-8-characters-from-a-file/).

Following that suggestion I tried the following: 
```
iconv -c -f UTF8 -t UTF8 /Users/Levi/Desktop/file.php > /Users/Levi/Desktop/file.php
```
It kept spitting out an empty file though for some reason. After a bit of head scratching I realized it may be writing to the file it was reading to it, which would mean that it was creating a new blank file.php, reading from file.php and encoding, and saving file.php. So it was doing this on a blank file! So what you need to do is save it to a new file name.
```
iconv -c -f UTF8 -t UTF8 /Users/Levi/Desktop/file.php > /Users/Levi/Desktop/file-new.php
```

After all that you may be thinking that fixed this, right? I was still getting the same error message so I decided to do some debugging and try and isolate the line it had an issue with in arcanist. After var_dump'ing down the path the diff takes in libphutil and arcanist I found out the reason I was continually getting the error was because the string it was sending to phabricator was the git diff of the file. So even though I removed the invalid character in the new revision, the old revision still had the invalid character.

## So how do you get around this?

The only way I could get around this issue was to: - edit the original file, remove the invalid character - push that live - merge that branch in with my dev branch - arc diff So after all the debugging the issue was not with the current file, but with the original file I was editing... which was to say the least a little frustrating to find out. So if the original file has an invalid character, your best bet is to edit the original to remove that character and push that live before diff'ing your branch.

"not valid UTF-8" in your phabricator diff?

I came across "Invalid UTF-8 Sitemap contains CO or C1 control codes" in WMT tools the other day. The sitemaps had recenlty been changed from a normal www.sitename.com/sitemap.xml to www.sitename.com/sitemap.xml.gz (the compressed version).

I looked through the uncompressed version of the sitemap and didn't see anything out of the ordinary characters-wise. When I ran it through some UTF-8 checks it came back as valid, so I was at a loss as to what was causing the error.

What do you do when you need some answers? Google it! The [only post I found with that error message had 0 replies](https://productforums.google.com/forum/#!topic/webmasters/56cWijxmgqY) and it wasn't posted by someone having a PHP problem. After broadening my search a little bit I came across this useful [stackoverflow post](http://stackoverflow.com/questions/5270665/gz-compressing-an-xml-sitemap-file-with-php) that alluded it was because fopen/fclose were appending characters that were not being encoded. Switching to gzopen, gzwrite, and gzclose worked perfect for me. gzwrite is binary-safe, so best guess would be that fwrite was including a PHP_EOL in the file that was resulting in the error. 

```
$xml = '
<urlset
              xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
              xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9
                    http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd">
<url>
	<loc>http://www.sitename.com/</loc>
	<lastmod>2014-03-14T09:39:11-04:00</lastmod>
	<changefreq>daily</changefreq>
	<priority>1.0</priority>
</url>
</urlset>
';
$gz = gzopen('sitemap.xml.gz','w9');
gzwrite($gz, $xml);
gzclose($gz);
```

Invalid UTF-8 Sitemap contains CO or C1 control codes


*Something awesome that I didn't find out about until I was finishing up the install on Mavericks is that you can copy files/data over to the new install if you are installing Mavericks on another HD or partition in the same computer! So what I ended up doing was creating a new install, copying the data over, and I was all set! It allowed me to ensure that I always had a working copy of OSX to use.*

I made the switch to OSX and have been running Lion for nearly a year and a half now. I had skipped over Mountain Lion because I didn't want to go through the hassle of upgrading everything. After a little debating about whether to upgrade to Mavericks, I decided to go for it because I didn't want to fall too many versions behind and I also wanted some of the small things like the updated Calendars and the compressed memory! I figured it wouldn't be a cake walk though and so I decided to install it on another HD I had been using before attempting to upgrade my existing Lion install (I was pleasantly surprised to find I had the ability to copy data from Lion to Mavericks after installing it on the partition though!)

## Some problems I ran into

*   Using Unibeast to put the installer on the partition I was to install Mavericks on. I figured it would be easier so I didn't need to worry about using a USB drive. When I booted up and selected the partition it started to spin the apple wheel, but then it clonked and restarted. After a few failed attempts at this I decided to follow the instructions online and use a flash drive :) In retrospect this wouldn't have worked anyway because you need to have a clean formatted HD to install it on.
*   The monitor would go black after selecting the USB drive to boot from. I solved this by unplugging my second monitor that was using the VGA port and to just use the HDMI port.
*   I could not load up Mavericks without using these flags on install "GraphicsEnabler=Yes PCIRootUID=1 -v -f". (The -v turns on verbose mode, it lets you see what it is doing as it installs so you can use it to debug if it failes. The -f forces the it to load the kexts directly and to now use a cache. GraphicsEnabler=Yes tells OSX it is ok to play around with the graphics settings to try and get ideal settings. I have not figured out exactly what the PCIRootUID=1 does, but I believe it has something to do with enabling/disabling the PCI slot and/or permissions to the PCI slot the graphics card is using.
*   No mouse and keyboard once you get to the installer? I had originally selected the 'Legacy Support' option in Unibeast so that my USB drives would work since I have an 1156 socket motherboard. That wasn't working and suggestions online were to not select that and copy over the DSDT file from the Lion install that it did work on.

## My final process was to:

1.  Create a bootable USB using Unibeast.
2.  Copy the DSDT file from /Extra/ into the /Volumes/USBDRIVENAME/Extra/ directory.
3.  Restart and boot into the installer with the following flags "GraphicsEnabler=Yes PCIRootUID=1 -v -f"
4.  Format the HD I want to put Mavericks on to use the GUID EXT format.
5.  After install it asks you to restart. It should bring you to a bootloader where you should pick the new HD you installed Mavericks onto. Use the same flags from step 3 when booting.
6.  Copy data if you want to from another OSX install or proceed to the next step.
7.  If you haven't already grab a copy of [MultiBeast](http://www.multibeast.com/)
8.  Once you load into OSX you should open up MultiBeast and do the 'Quick Start'. If you have an existing DSDT file that worked for you, you can import that or you can stat from scratch. Work your way through the settings and adjust as needed. If something doesn't work when you restart you can open it back up and look around for anything you may have missed related to the device malfunctioning.
9.  **(Possible)** I had a last step you may not have if you are not installing mavericks on a different HD than your current install. After I installed Mavericks and restarted (and removed the USB bootloader) I tried booting up and every time I selected Mavericks it would start to load and then crash and the computer would restart. After a little bit of going in circles and redoing MultiBeast it clicked that the issue may be the bootloader. I realized I was still using the old bootloader I had installed with Lion. So what I did was install a new bootloader on the Mavericks HD and set that to be the first HD in the boot order. After I did that and restarted it booted up perfect!

## My parts list

### (I didn't upgrade anything from my Lion install, so these are all 2+ year old parts)

*   Intel Core i5-760 Processor 2.8 GHz 8 MB Cache Socket LGA1156
*   Thermaltake Silent 1156 CLP0552 92mm CPU Cooler For Intel Socket LGA1156
*   Seagate Barracuda 7200.12 ST31000528AS 1TB 7200 RPM 32MB Cache SATA 3.0Gb/s 3.5" (eventually I will make the leap and buy an SSD...)
*   XFX HD-465X-ZDF2 Radeon HD 4650 1GB 128-bit DDR2 PCI Express 2.0 x16 HDCP Ready Video Card
*   GIGABYTE GA-H55-USB3 LGA 1156 Intel H55 HDMI USB 3.0 ATX Intel Motherboard
*   Mushkin Enhanced Silverline 6GB (3 x 2GB) 240-Pin DDR3 SDRAM DDR3 1333 (PC3 10666) Desktop Memory Model 998768
*   CORSAIR TX Series CMPSU-650TX 650W ATX12V / EPS12V SLI Ready CrossFire Ready 80

## Other thoughts:

- When my monitor went black and I was reading about other causes one of the predominant ones was that the graphics card was being used instead of the onboard graphics. So if it still isn't working for you, try removing the graphics card and using the onboard one. **Some of the sites I used to help me debug my issues:** [Enable USB Legacy Support](http://biosx86.blogspot.com/2013/10/no-usb-mouse-and-keyboard-fix-for-os-x.html) [Copy the DSDT from your previous version of OSX](http://www.tonymacx86.com/mavericks-desktop-support/112666-mouse-keyboard-not-working-during-installation-4.html#post_message_688107) [http://www.macbreaker.com/2012/01/list-of-common-hackintosh-boot-flags_29.html](http://www.macbreaker.com/2012/01/list-of-common-hackintosh-boot-flags_29.html)

Hackintosh upgrading to Mavericks


I've had a broad understanding of how PHP maintains and stores variables, but recently I did some more reading about it so that I could understand a solution on stackoverflow better.

## zvals Container
When you assign a variable it creates a "row" in what is known as a *zval container*. At this stage I find it easiest to think of them like table rows, or an array item. They contain:
- Type of the variable
- Value of the variable
- a boolean value for *is_ref*. This lets PHP know if the variable is a [reference](http://php.net/manual/en/language.references.php)
- *refcount*, which contains how many variables point to this value. This doesn't always mean it is a variable assigned by reference. If for instance you do

```
// refcount is 1 after you set this
$a = 'Levi Jackson';
// refcount is 2 after this point
$b = $a;

// refcount for $a is 1 and $b is 1
$b = 'Jackson Levi';
```

It is important to note that the zvals table does not include variable names. Those are stored in what is called a *symbol table*.

## Symbol Table
There is a symbol table for each level of scope (global, functions, methods, etc...). as well for certain types value  types. Scalar values like a string are pretty straight forward, at the most basic level a symbol table maps a variable name to a zval slot. *[Compound Types](http://php.net/manual/en/features.gc.refcounting-basics.php#example-388)* such as arrays and objects create separate symbol tables for their properties. So for an object like the following:

```
Class Person{
public $name;
public $email;

public function __construct($name = '', $email = ''){
    $this->name = $name;
    $this->email = $email;
    }
}

$levi = new Person('Levi', 'test@test.com');
```

This would add an entry for `$levi` in the global symbol table and then it would create two more symbol tables for both properties name and email.

## Garbage Collection
Once a variable in the zval container has 0 for a refcount it is deleted from memory. An interesting example posed on the php.net site though shows where you can lull yourself into the false idea that all of your values have been removed from memory. For instance, given the following

```
$tmpArray = array( 'name' => 'Levi');
```

You have a symbol table for `$tmpArray` as well as for `$tmpArray['name']`. If you were to then unset(`$tmpArray`) that would remove the value for `$tmpArray`, but the key 'name' would still exist because it still has a refcount of 1 since it has a value of 'Levi'. So to remove that you would need to unset(`$tmparray['name']`) and then `unset($tmpArray)` to remove both from memory.


Pretty interesting stuff, and I hope to do some more reading on the internals of PHP soon. One of the more interesting things I've come across recently related to the above is that the foreach loop has the potential to copy the array it is looping (and rightly so) if the refcount for the array variable is more than 1.

[http://php.net/manual/en/features.gc.refcounting-basics.php](http://php.net/manual/en/features.gc.refcounting-basics.php)

PHP zvals and symbol table(s)


I answered [this question on stackoverflow](https://stackoverflow.com/questions/17892290/passing-a-session-variable-getting-errors/17892633#17892633) the other day and it led me to question why `$_SESSION[1] = 'Something';` doesn't work in PHP &lt; 5.4 (5.3, 5.2, etc...). Give it a try, it should give you a notice along the lines of

```
Notice: Unknown: Skipping numeric key 1 in Unknown on line 0
```

I found this [bug report](https://bugs.php.net/bug.php?id=42472) when I was researching which says that the reason it throws the notice is because "false/true/null/etc are not valid key names".  To me that isn't a great answer though because normal arrays can have numeric keys. Luckily  [Wiseguy](https://stackoverflow.com/users/185544/wiseguy) replied to my answer and pointed out that the PHP docs used to say 

> The keys in the `$_SESSION` associative array are subject to the same limitations as regular variable names in PHP, i.e. they cannot start with a number and must start with a letter or underscore. For more details see the section on variables in this manual. I guess this was a side effect of `register_globals`. Curiously, the docs no longer state this. Perhaps this limitation was removed when the `register_globals` option was removed in PHP 5.4.0

I wasn't sure how register_globals fit into this though. I did some digging and was close to posting on stackoverflow to get some feedback about it! So I started working from a different angle, forget about it being a $_SERVER specific issue, maybe that didn't have anything to do with it. That landed me on the [super globals page](http://php.net/manual/en/language.variables.superglobals.php).

## Super Globals
Not to regurgitate info, but super globals are global variables in scope in any part of a script without the need to prepend them with a 'global' keyword. With register_globals on PHP would create variables for all of the child items in the super global. For instance:

```
$_SERVER['Levi'] = 'Levi Jackson';
```

This would create a variable $Levi that has the value of 'Levi Jackson'. So if you had set a key of `$_SERVER[1] = 'Levi Jackson'` it would try and create a variable `$1` set to 'Levi Jackson'. Which if you are familiar with [variable basics](http://php.net/manual/en/language.variables.basics.php) is a big "no no".

## PHP 5.4
Not that PHP 5.4 removed support for register_globals you can now use numeric keys with your super globals like $_SESSION. Enjoy.

$_SESSION doesn't allow numeric keys in PHP < 5.4


I've had this one partially written for a while, so I figured I would finish it out so that anyone who needs that extra shove has yet another reference to read from!

I was a native Windows user for many years. I used XAMPP for all my local development and life was good. I won't get into all the details of how or why I started using Mac, but suffice to say I enjoy it a bit more than Windows. There are a lot more tools available out of the box that I don't need to install and finagle with. Anyway, I started using MAMP instead of XAMPP when I made the switch. As you may or may not know MAMP is a tad bit different than XAMPP is out of the box. MAMP defaults the webserver to use port 8888 and the MySQL database to use port 8889\. While those are not really problems, they are something to pay attention to as they add a couple more steps into the process of setting up subdomains.

The first thing you want to do is figure out the subdomain you want and edit your hosts file to include it.

```
sudo vim /private/etc/hosts/ 
```

I added in the line: 
```
127.0.0.1 levi.local
``` 

Then I went over to my virtual host file in MAMP located at */Applications/MAMP/conf/apache/extra/httpd-vhosts.conf* and I added the following: 
```
<VirtualHost *:8888>
    ServerName leadingchange.local
    DocumentRoot /Applications/MAMP/htdocs/usm/leadingchangenetwork>
    <Directory /Applications/MAMP/htdocs/usm/leadingchangenetwork/>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Order allow,deny
        allow from all
    </Directory>
</VirtualHost>
```

Pay attention the *VirtualHost* line to note that it has apache listening on port 8888\. Now if you restart apache/mysql and visit http://levi.local:8888 it will load the site that would normally show up at http://localhost:8888/levi/

Setting up a local subdomain/virtual host on MAMP


A few months back I had built and started using a Hackintosh running OSX 10.7.4 using the guides from [www.tonymacx86.com](www.tonymacx86.com) as my base. After a few hiccups where I lost sound , everything has worked very nicely! Prior to installing OSX I had been running the Windows 8 developer preview and had been enjoying playing around with it. So this past week I picked up a new hard drive from Newegg so that I could install Windows 8 on it now that is has been released into the wild.. My full plan was to partition this new 1TB drive into two 500GB chunks so I could install Windows 8 on a piece and use the other for Time Machine in OSX.

I purchased the Windows 8 Pro upgrade so my first step in this process was to install Windows 7 on the new hard drive. After it booted into the installer I partitioned and attempted to install only to be greeted by a nice error saying "Windows cannot be installed, error code 0X8030024". Nice and descriptive eh? I took to Google to figure out the issue and found several solutions:

*   Reformat the new hard drive
*   Unplug any other hard drive that has an OS on it (my OSX install)
*   Pray to the heavens

Since it was the easiest I tried reformatting the drive in the hopes it was that easy. Nope. So I shut everything down, opened the computer up and unplugged the power and SATA cable going to my first hard drive. I left the SATA cable plugged into the motherboard though for what it is worth. I rebooted and waited while Windows unpacked the files yet again... and bingo. I was able to run through the install process perfect. 

After that finished I put in the Windows 8 upgrade disc and restarted the computer. After a long pause (about 2-3 minutes) of what I think was supposed to be the Windows 8 logo spinning (it had frozen in position) the installer started. It was easy to walk through and setup and just as quickly as Windows 7 was installed so was Windows 8.

Overall it was a quick process. It took me about an hour to install the new hard drive, debug why W7 wasn't installing, and then to finally install everything. I would say the bulk of that time was waiting for the installers to finish though. So relatively simple. I imagine if you are trying to dual boot from the same hard drive you might run into issues with the bootloader which is why I chose to go for a new hard drive rather than partitioning.

Dual booting OSX 10.7.4 and Windows 8 from separate hard drives


Just a little background info, I have been doing more and more work locally using [XAMPP](http://www.xamp.org). Because the files are being worked on locally until they are worthy of being put into a live site there is a lot of room for murphy to make my day worse. Every once and a while I would backup my files onto my external drive just in case something happened to my computer. This while better than nothing, was not the best solution.

## Dropbox

For anyone that doesn't know what<a hef="http://www.dropbox.com" target="_blank">Dropbox</a> is - it a fantastic service that allows you to sync files between multiple devices. Dropbox creates one directory usually called "My Dropbox" that syncs anything inside of it to the cloud.

## Thoughts on using Dropbox

My initial thought was to just copy and paste the files to My Dropbox. Backing the files up daily would definitely be an improvement over my first method of using my external to backup once a week. I always try and figure out pros and cons to anything I do, it helps me to prepare for the worst. The biggest con I had was that if I backed up daily, what happens if I worked for 23.5 hours one day and just as I am backing my files up the computer crashes?

## Past experience with SymLink

I had done some work with Ruby/Rails on my web host a couple years ago that required me to setup a SymLink from the root of the server to a directory accessible on the web. I wondered if it would be possible to create a SymLink between the directories on my computer so that it would continually sync the files I am working on in real time.

## Junction to sync the files

After one quick Google search I came across [Junction](http://technet.microsoft.com/en-us/sysinternals/bb896768.aspx), a Windows utility that creates a link between directories.

> Quick tip: If you place junction.exe in C:\WINDOWS you can execute the junction command from anywhere in the command prompt.

## Steps to create junction

1.  Move the folder you want to sync with Dropbox into "My Dropbox".
2.  Jot down the path to "My DropBox" (c:\Documents and Settings\User\My Documents\My Dropbox) and "htdocs" (c:\xampp\htdocs).

4.  Open the command prompt (Start => Run OR hold down the windows key and press "R" and enter CMD into the prompt and press enter).
5.  > junction "c:\xampp\htdocs" "c:\Documents and Settings\User\My Documents\My Dropbox\htdocs"

6.  It should prompt you with the directory created and the directory it targeted.

For more information on syncing with Dropbox visit [their wiki](http://wiki.dropbox.com/TipsAndTricks/SyncOtherFolders).

Creating a junction to sync files from anywhere on your PC with Dropbox


The other day at work I was given the task of updating all page URLs to always use the trailing slash. On the surface it seemed like a pretty simple request, drop in a RewriteCond and RewriteRule into the host file and call it a day. For those that are looking for the final code, here is what I used: 

```
RewriteCond %{REQUEST_METHOD} !=POST
RewriteCond %{REQUEST_URI} !(.*)/$
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-f
RewriteRule ^(.*)$ http://%{HTTP_HOST}$1/ [R=301,NE]
```

Everyone else, read on as I explain how I got to that.

## Version 1, tested on my virtual machine

```
# This looks at the URI for the page and if it does not have a trailing slash already it moves on to the next condition. If it does have a trailing slash, it stops checking and serves the page.
RewriteCond %{REQUEST_URI} !(.*)/$

# This checks that the requested path is not for a file. If it is, just serve the file
RewriteCond %{DOCUMENT_ROOT}%{REQUEST_FILENAME} !-f

# If it gets to this point, redirect the url to the version with the trailing slash
RewriteRule ^(.*)$ http://%{HTTP_HOST}$1/ [R=301,NE]
```

 *\* One thing to note: when I was reading up on checking to make sure the file exists I found a lot of sources saying that apache 2.2 needs the %{DOCUMENT_ROOT} but that apache 2.0, %{REQUEST_FILENAME} contained the absolute path. So if you are having trouble with that line, check the version of apache and double check what path it is checking for the file at.* I gave this a few test runs and noticed a few things wrong with it.

1.  Some of our forms had been hard coded to use URIs that did not have trailing slashes. This means that when the data was POSTed it would 301 redirect and NOT pass along the POST data. So the forms would be useless.
2.  Some of our code that referenced files actually had a RewriteRule further down that mapped the path to the directory. So the second RewriteCond to see if the requested path was a file was returning false (allowing it to continue onward). For example: http://domain.com/directory/filename.xml mapped to http://domain.com/anotherdirectory/filename.xml. So when it didn't find the file at http://domain.com/directory/filename.xml it would redirect to http://domain.com/directory/filename.xml/

### Fixing the form URIs

My options for fixing the form paths were to either update all of the actions or to figure out a way to ignore POST requests. Sure enough I found I could use the %{REQUEST_METHOD} to ignore POST requests. I was turned on to by this [stackoverflow question.](http://stackoverflow.com/questions/8541932/how-to-prevent-mod-rewrite-from-handling-http-post-requests)
```
RewriteCond %{REQUEST_METHOD} !=POST
```

### Fixing the file paths that have URL rewriting already in place

The situation was similar to this. Request a path like http://domain.com/directory/filename.xml and that would be rewritten to /anotherdirectory/filename.xml. In my situation the files in that directory were more often than not referenced with an absolute path ending in the file extension. So I was able to just add another RewriteCond that excluded URLs in that directory from being processed.
```
RewriteCond %{REQUEST_URI} !^/directory/(.*)
```

### Debugging mod_rewrite

While working on this I found it useful to do some debugging when I found instances that didn't work as I expected. I enabled logging so that I could see the route an incoming URL takes when it comes in. To turn it on you can add this to the conf file for apache:

```
# This path must be writeable by the web server
RewriteLog /var/log/apache2/rewrite.log
RewriteLogLevel 5
```

Once activated you can _tail_ the file to view it in real time as you access the page. These were some helpful pages I used to help me out when I was working on this: [http://apache-http-server.18135.x6.nabble.com/mod-rewrite-loaded-but-not-writing-or-logging-td4746292.html](http://apache-http-server.18135.x6.nabble.com/mod-rewrite-loaded-but-not-writing-or-logging-td4746292.html) [http://amandine.aupetit.info/135/apache2-mod_rewrite/](http://amandine.aupetit.info/135/apache2-mod_rewrite/)

mod_rewrite add a trailing slash to all pages


I was just reading up on some PHP while I work on one of my final projects and I came across the topic of *passing by reference*. Which if you are not familiar with it, this is the [PHP.net reference page](http://php.net/manual/en/language.references.pass.php). I had no idea that it existed and it instantly reminded me of the past three weeks of C++ where we have been discussing and using [pointers](http://www.cplusplus.com/doc/tutorial/pointers/) as a means of "returning" more than one value from a function.

A good explanation of a reference is:

> "References are a way to have multiple variables referencing the same variable container using different names -- so whatever name you're using an operation on that variable will always have an effect on the others." - [Johannes Schlüter](http://schlueters.de/blog/archives/125-Do-not-use-PHP-references.html)

My experience with pointers and passing by reference has been in the classroom and so the only benefit I have seen is that you can modify variables outside of a function. Check this snippet out for instance:

```
function addOne(&$input){
    $input++;
}
$var = 1;

addOne($var); //returns 2.
```

## Conclusion

I don't know that I would really pass by reference outside of the classroom at this stage as I have not encountered a situation where I *needed* to return or modify more than one value at a time.

Passing by reference in PHP


So what I found out tonight was that you cannot format an external hard drive over 100GB at least (probably a lot lower) with the Windows GUI. You need to take it to the command line to achieve format it. The steps I took to format a Seagate Freeagent are:

1.  Goto Start > Run
2.  Enter in CMD and press enter
3.  Type in *format /FS:FAT32 DRIVELETTER:* and press enter
4.  It may ask you to enter the *volume label*, just enter what it shows up as in My Computer when it loads up normally
5.  It will give you the final confirmation - press "Y" and hit enter

There you have it, sit back and enjoy a cold while you wait for the drive to finish.

Formatting external hard drive to FAT32


So I was puttering along with a project I came across a situation I have come across before. How to delete information from a table that is related, such as deleting a user, their profile, and any other information associated with said user. In the past I had just executed as many queries as it took to get the job done. This isn't the best option though for one big reason.

## Performance

The more results a query returns, the more system resources it uses. So executing multiple queries can often times end up with the server doing more work than necessary. So my suggestion is to create a multi-table query that narrows the results using the _where_ clause.

Imagine a scenario where you had the following tables, keep in mind the tables are in no way what I would use for an actual site, they are far from being normalized:

```
CREATE TABLE `User_Info` (
  `User_ID` int(11) NOT NULL auto_increment,
  `User_Type_ID` int(11) NOT NULL,
  `User_Title` varchar(255) NOT NULL,
  `User_Address_ID` int(11)NOT NULL,
  `User_Profile_ID` int(11)NOT NULL,
  PRIMARY KEY  (`User_ID`)
  FOREIGN KEY  (`User_Address_ID`)
  FOREIGN KEY  (`User_Profile_ID`)
) ENGINE=MyISAM AUTO_INCREMENT=80 DEFAULT CHARSET=latin1;
```

```
CREATE TABLE `User_Address` (
  `User_Address_ID` int(11) NOT NULL auto_increment,
  `User_Address` varchar(100) NOT NULL,
  `User_Town` varchar(100) NOT NULL,
  `User_State` varchar(100) NOT NULL,
  `User_ID` varchar(100) NOT NULL,
  PRIMARY KEY  (`User_Address_ID`),
  FOREIGN KEY (`User_ID`),
) ENGINE=MyISAM AUTO_INCREMENT=80 DEFAULT CHARSET=latin1;
```

```
CREATE TABLE `User_Profile` (
  `User_Profile_ID` int(11) NOT NULL auto_increment,
  `User_Name` varchar(100) NOT NULL,
  `User_Password` varchar(100) NOT NULL,
  `User_ID` varchar(100) NOT NULL,
  PRIMARY KEY  (`User_Profile_ID`),
  FOREIGN KEY (`User_ID`),
) ENGINE=MyISAM AUTO_INCREMENT=80 DEFAULT CHARSET=latin1;
```

## The acceptable solution

My old method would have had me doing multiple queries

```
DELETE FROM User_Info WHERE User_ID=1;
DELETE FROM User_Address WHERE User_ID=1;
DELETE FROM User_Profile WHERE User_ID=1;
```

## The better solution

The better way to do this is of course as I said above using one query.

```
DELETE FROM User_Info, User_Address, User_Profile
USING User_Info
WHERE User_Address.User_ID = User_Info.User_ID
AND User_Profile.User_ID = User_Info.User_ID
AND User_Info.User_ID =  1;
```

If you are interested in learning other methods of doing multi-table deletes, check out this site that uses [joins](http://www.haughin.com/2007/11/01/mysql-delete-across-multiple-tables-using-join/) to accomplish the same result.

Delete rows from multiple tables


I was thinking about the future of my web site the other day. One of the questions I began to think about was, _what if I decide to change to a different Content Management System (CMS)?_ Which was never really a problem before because I did not have much content to move over. In the past I had pages for my portfolio, about me, contacting me, and that is about it. Now that I have begun to write on my site as well, I now have to worry about how to preserve the content. The two areas I am concerned with are:

*   Moving data from one database to another.
*   How to handle URL rewriting so that my pages don't suddenly go AWOL in search engines.

## Set-up

Say you have an existing table in a database called DB1,
```
CREATE TABLE `Event_Info` (
  `Event_ID` int(11) NOT NULL auto_increment,
  `Event_Type_ID` int(11) NOT NULL,
  `Event_Title` varchar(255) NOT NULL,
  `Event_Date` varchar(100) NOT NULL,
  `Event_Address` varchar(100) NOT NULL,
  `Event_Town` varchar(100) NOT NULL,
  `Event_Desc` longtext NOT NULL,
  `Event_Inserted` varchar(100) NOT NULL,
  `Event_Updated` varchar(100) NOT NULL,
  `User_ID` int(11) NOT NULL,
  `Event_Pending` varchar(255) NOT NULL default '0',
  PRIMARY KEY  (`Event_ID`)
) ENGINE=MyISAM AUTO_INCREMENT=80 DEFAULT CHARSET=latin1;
```

You are tasked with moving over the id, title, town, and description to a new database/table to be used with a different application. I put together this test table to move the information into, it is located in a database named DB2.

```
CREATE TABLE `event_stuff` (
  `eventID` int(11) NOT NULL auto_increment,
  `eventTitle` varchar(255) NOT NULL,
  `eventTown` varchar(255) NOT NULL,
  `eventDesc` varchar(255) NOT NULL,
  PRIMARY KEY  (`eventID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;
```

## Moving the data

So what we need to do is **select** the title, town, and description from _Event_Info_ and **insert** it into _event_stuff_. The first step is to write a query that selects the data from _Event_Info_. In the past when I have transferred info between two tables I have used a subquery to get the values to insert. Something along the lines of this, INSERT INTO Table_One VALUES(SELECT field1,field2,field3 FROM Table_Two). I tried to set something like this up and ran into one problem, I am working not between tables but between databases.

## The query

After reading some documentation on the MySQL site and spending a couple hours working out queries. I figured that I must need to reference the database somehow but I really could not find adequate information about it and so I finally gave in and went to [Stackoverflow](http://stackoverflow.com/questions/1786963/is-there-a-way-to-transfer-info-from-one-database-into-another-database/1787003#1787003). There I found out that I didn't need the schema files as I thought I might have and all I needed to do was reference the database. The final query that worked flawlessly for me was

```
INSERT INTO DB2.event_stuff (eventTitle,eventTown,eventDesc) 
SELECT t.Event_Title, t.Event_Town, t.Event_Desc FROM DB1.Event_Info t;
```

Something I learned from this query is that you can set an alias for a table _after_ you use it! I had always been under the impression it was like PHP, PERL, ASP, etc... in that you needed to instantiate the variable before using it. I wonder if MySQL reads the whole query before executing it? Anyway, if you have any input let me know, if there is a more efficient way to do this with **one** query I would be interested to see that.

Part two will cover URL rewriting so there isn't a loss in ranking with the search engines.

Blog posts