blog_app/re

```php
<?php

return [
    'name' => env('APP_NAME', 'Laravel'),
    'env' => env('APP_ENV', 'production'),
    'debug' => (bool) env('APP_DEBUG', false),
    'url' => env('APP_URL', 'http://localhost'),
    'timezone' => env('APP_TIMEZONE', 'UTC'),
    'locale' => env('APP_LOCALE', 'en'),
    'fallback_locale' => env('APP_FALLBACK_LOCALE', 'en'),
    'faker_locale' => env('APP_FAKER_LOCALE', 'en_US'),
    // ... остальные настройки по умолчанию
];
```

## Шаг 4: Создание миграций

### Migration: create_posts_table
```bash
php artisan make:migration create_posts_table
```

```php
<?php
// database/migrations/xxxx_xx_xx_create_posts_table.php

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

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->string('title');
            $table->string('slug')->unique();
            $table->text('content');
            $table->enum('status', ['draft', 'published', 'scheduled'])->default('draft');
            $table->timestamp('published_at')->nullable();
            $table->timestamp('scheduled_at')->nullable();
            $table->timestamps();
            $table->softDeletes();
            
            $table->index('status');
            $table->index('scheduled_at');
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};
```

### Migration: create_comments_table
```bash
php artisan make:migration create_comments_table
```

```php
<?php
// database/migrations/xxxx_xx_xx_create_comments_table.php

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

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('comments', function (Blueprint $table) {
            $table->id();
            $table->foreignId('post_id')->constrained()->onDelete('cascade');
            $table->string('author_name');
            $table->string('author_email');
            $table->text('content');
            $table->enum('status', ['pending', 'approved', 'rejected'])->default('pending');
            $table->timestamps();
            
            $table->index(['post_id', 'status']);
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('comments');
    }
};
```

Запустите миграции:
```bash
php artisan migrate
```

## Шаг 5: Создание моделей

### Model: Post
```bash
php artisan make:model Post
```

```php
<?php
// app/Models/Post.php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Str;
use App\Events\PostPublished;
use App\Events\PostScheduled;

class Post extends Model
{
    use HasFactory, SoftDeletes;

    protected $fillable = [
        'title',
        'slug',
        'content',
        'status',
        'published_at',
        'scheduled_at',
    ];

    protected $casts = [
        'published_at' => 'datetime',
        'scheduled_at' => 'datetime',
    ];

    protected $dispatchesEvents = [
        'created' => PostPublished::class,
    ];

    // Автоматическое создание slug
    protected static function boot()
    {
        parent::boot();
        
        static::creating(function ($post) {
            if (empty($post->slug)) {
                $post->slug = Str::slug($post->title);
            }
        });
    }

    // Связь с комментариями
    public function comments()
    {
        return $this->hasMany(Comment::class);
    }

    // Только опубликованные посты
    public function scopePublished($query)
    {
        return $query->where('status', 'published')
                    ->whereNotNull('published_at')
                    ->where('published_at', '<=', now());
    }

    // Посты, готовые к автопубликации
    public function scopeReadyForPublishing($query)
    {
        return $query->where('status', 'scheduled')
                    ->whereNotNull('scheduled_at')
                    ->where('scheduled_at', '<=', now());
    }

    // Публикация поста
    public function publish()
    {
        $this->update([
            'status' => 'published',
            'published_at' => now(),
        ]);
        
        event(new PostPublished($this));
    }

    // Снятие с публикации
    public function unpublish()
    {
        $this->update([
            'status' => 'draft',
        ]);
    }

    // Планирование публикации
    public function schedule($dateTime)
    {
        $this->update([
            'status' => 'scheduled',
            'scheduled_at' => $dateTime,
        ]);
        
        event(new PostScheduled($this));
    }
}
```

### Model: Comment
```bash
php artisan make:model Comment
```

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

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use App\Events\CommentCreated;
use App\Events\CommentApproved;

class Comment extends Model
{
    use HasFactory;

    protected $fillable = [
        'post_id',
        'author_name',
        'author_email',
        'content',
        'status',
    ];

    protected $dispatchesEvents = [
        'created' => CommentCreated::class,
    ];

    // Связь с постом
    public function post()
    {
        return $this->belongsTo(Post::class);
    }

    // Только одобренные комментарии
    public function scopeApproved($query)
    {
        return $query->where('status', 'approved');
    }

    // Ожидающие модерации
    public function scopePending($query)
    {
        return $query->where('status', 'pending');
    }

    // Одобрить комментарий
    public function approve()
    {
        $this->update(['status' => 'approved']);
        event(new CommentApproved($this));
    }

    // Отклонить комментарий
    public function reject()
    {
        $this->update(['status' => 'rejected']);
    }
}
```

## Шаг 6: Создание событий (Events)

### Event: PostPublished
```bash
php artisan make:event PostPublished
```

```php
<?php
// app/Events/PostPublished.php

namespace App\Events;

use App\Models\Post;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class PostPublished
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public function __construct(public Post $post)
    {
    }
}
```

### Event: PostScheduled
```bash
php artisan make:event PostScheduled
```

```php
<?php
// app/Events/PostScheduled.php

namespace App\Events;

use App\Models\Post;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class PostScheduled
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public function __construct(public Post $post)
    {
    }
}
```

### Event: CommentCreated
```bash
php artisan make:event CommentCreated
```

```php
<?php
// app/Events/CommentCreated.php

namespace App\Events;

use App\Models\Comment;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class CommentCreated
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public function __construct(public Comment $comment)
    {
    }
}
```

### Event: CommentApproved
```bash
php artisan make:event CommentApproved
```

```php
<?php
// app/Events/CommentApproved.php

namespace App\Events;

use App\Models\Comment;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class CommentApproved
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public function __construct(public Comment $comment)
    {
    }
}
```

## Шаг 7: Создание слушателей (Listeners)

### Listener: SendPostPublishedNotification
```bash
php artisan make:listener SendPostPublishedNotification --event=PostPublished
```

```php
<?php
// app/Listeners/SendPostPublishedNotification.php

namespace App\Listeners;

use App\Events\PostPublished;
use Illuminate\Support\Facades\Log;

class SendPostPublishedNotification
{
    public function handle(PostPublished $event): void
    {
        Log::info('Post published: ' . $event->post->title);
        // Здесь можно добавить отправку уведомлений, email и т.д.
    }
}
```

### Listener: LogPostScheduled
```bash
php artisan make:listener LogPostScheduled --event=PostScheduled
```

```php
<?php
// app/Listeners/LogPostScheduled.php

namespace App\Listeners;

use App\Events\PostScheduled;
use Illuminate\Support\Facades\Log;

class LogPostScheduled
{
    public function handle(PostScheduled $event): void
    {
        Log::info('Post scheduled: ' . $event->post->title . 
                  ' for ' . $event->post->scheduled_at);
    }
}
```

### Listener: NotifyAdminAboutComment
```bash
php artisan make:listener NotifyAdminAboutComment --event=CommentCreated
```

```php
<?php
// app/Listeners/NotifyAdminAboutComment.php

namespace App\Listeners;

use App\Events\CommentCreated;
use Illuminate\Support\Facades\Log;

class NotifyAdminAboutComment
{
    public function handle(CommentCreated $event): void
    {
        Log::info('New comment awaiting moderation on post: ' . 
                  $event->comment->post->title);
        // Здесь можно отправить email администратору
    }
}
```

### Listener: NotifyCommentAuthor
```bash
php artisan make:listener NotifyCommentAuthor --event=CommentApproved
```

```php
<?php
// app/Listeners/NotifyCommentAuthor.php

namespace App\Listeners;

use App\Events\CommentApproved;
use Illuminate\Support\Facades\Log;

class NotifyCommentAuthor
{
    public function handle(CommentApproved $event): void
    {
        Log::info('Comment approved and author notified: ' . 
                  $event->comment->author_email);
        // Здесь можно отправить email автору комментария
    }
}
```

## Шаг 8: Регистрация событий (EventServiceProvider)

```php
<?php
// app/Providers/EventServiceProvider.php

namespace App\Providers;

use App\Events\PostPublished;
use App\Events\PostScheduled;
use App\Events\CommentCreated;
use App\Events\CommentApproved;
use App\Listeners\SendPostPublishedNotification;
use App\Listeners\LogPostScheduled;
use App\Listeners\NotifyAdminAboutComment;
use App\Listeners\NotifyCommentAuthor;
use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider;

class EventServiceProvider extends ServiceProvider
{
    protected $listen = [
        PostPublished::class => [
            SendPostPublishedNotification::class,
        ],
        PostScheduled::class => [
            LogPostScheduled::class,
        ],
        CommentCreated::class => [
            NotifyAdminAboutComment::class,
        ],
        CommentApproved::class => [
            NotifyCommentAuthor::class,
        ],
    ];

    public function boot(): void
    {
        //
    }
}
```

## Шаг 9: Консольная команда для автопубликации

```bash
php artisan make:command PublishScheduledPosts
```

```php
<?php
// app/Console/Commands/PublishScheduledPosts.php

namespace App\Console\Commands;

use App\Models\Post;
use Illuminate\Console\Command;

class PublishScheduledPosts extends Command
{
    protected $signature = 'posts:publish-scheduled';
    protected $description = 'Публикация запланированных постов';

    public function handle()
    {
        $posts = Post::readyForPublishing()->get();
        
        if ($posts->isEmpty()) {
            $this->info('Нет постов для публикации');
            return 0;
        }

        foreach ($posts as $post) {
            $post->publish();
            $this->info("Опубликован пост: {$post->title}");
        }

        $this->info("Всего опубликовано постов: {$posts->count()}");
        return 0;
    }
}
```

## Шаг 10: Настройка планировщика (Kernel.php)

```php
<?php
// app/Console/Kernel.php

namespace App\Console;

use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule): void
    {
        // Проверка и публикация запланированных постов каждые 5 минут
        $schedule->command('posts:publish-scheduled')
                 ->everyFiveMinutes()
                 ->withoutOverlapping();
    }

    protected function commands(): void
    {
        $this->load(__DIR__.'/Commands');

        require base_path('routes/console.php');
    }
}
```

## Шаг 11: Создание контроллеров

### PostController
```bash
php artisan make:controller PostController --resource
```

```php
<?php
// app/Http/Controllers/PostController.php

namespace App\Http\Controllers;

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

class PostController extends Controller
{
    public function index()
    {
        $posts = Post::published()->latest('published_at')->paginate(10);
        return view('posts.index', compact('posts'));
    }

    public function show(Post $post)
    {
        if ($post->status !== 'published') {
            abort(404);
        }
        
        $comments = $post->comments()->approved()->latest()->get();
        return view('posts.show', compact('post', 'comments'));
    }

    public function create()
    {
        return view('posts.create');
    }

    public function store(Request $request)
    {
        $validated = $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
            'status' => 'required|in:draft,published,scheduled',
            'scheduled_at' => 'nullable|date|after:now',
        ]);

        $post = Post::create($validated);

        if ($validated['status'] === 'published') {
            $post->publish();
        } elseif ($validated['status'] === 'scheduled' && $validated['scheduled_at']) {
            $post->schedule($validated['scheduled_at']);
        }

        return redirect()->route('posts.show', $post)
                        ->with('success', 'Пост успешно создан');
    }

    public function edit(Post $post)
    {
        return view('posts.edit', compact('post'));
    }

    public function update(Request $request, Post $post)
    {
        $validated = $request->validate([
            'title' => 'required|max:255',
            'content' => 'required',
            'status' => 'required|in:draft,published,scheduled',
            'scheduled_at' => 'nullable|date|after:now',
        ]);

        $post->update($validated);

        if ($validated['status'] === 'published' && $post->status !== 'published') {
            $post->publish();
        } elseif ($validated['status'] === 'scheduled' && $validated['scheduled_at']) {
            $post->schedule($validated['scheduled_at']);
        }

        return redirect()->route('posts.show', $post)
                        ->with('success', 'Пост обновлен');
    }

    public function destroy(Post $post)
    {
        $post->delete();
        return redirect()->route('posts.index')
                        ->with('success', 'Пост удален');
    }
}
```

### CommentController
```bash
php artisan make:controller CommentController
```

```php
<?php
// app/Http/Controllers/CommentController.php

namespace App\Http\Controllers;

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

class CommentController extends Controller
{
    public function store(Request $request, Post $post)
    {
        $validated = $request->validate([
            'author_name' => 'required|max:255',
            'author_email' => 'required|email',
            'content' => 'required|max:1000',
        ]);

        $post->comments()->create($validated);

        return redirect()->route('posts.show', $post)
                        ->with('success', 'Комментарий отправлен на модерацию');
    }

    public function moderate()
    {
        $comments = Comment::pending()->with('post')->latest()->paginate(20);
        return view('comments.moderate', compact('comments'));
    }

    public function approve(Comment $comment)
    {
        $comment->approve();
        return back()->with('success', 'Комментарий одобрен');
    }

    public function reject(Comment $comment)
    {
        $comment->reject();
        return back()->with('success', 'Комментарий отклонен');
    }
}
```

## Шаг 12: Маршруты (routes/web.php)

```php
<?php
// routes/web.php

use App\Http\Controllers\PostController;
use App\Http\Controllers\CommentController;
use Illuminate\Support\Facades\Route;

Route::get('/', [PostController::class, 'index'])->name('home');

Route::resource('posts', PostController::class);
Route::post('posts/{post}/comments', [CommentController::class, 'store'])
     ->name('comments.store');

// Административные маршруты
Route::prefix('admin')->group(function () {
    Route::get('comments/moderate', [CommentController::class, 'moderate'])
         ->name('comments.moderate');
    Route::post('comments/{comment}/approve', [CommentController::class, 'approve'])
         ->name('comments.approve');
    Route::post('comments/{comment}/reject', [CommentController::class, 'reject'])
         ->name('comments.reject');
});