Наследование и базовые элементы Laravel / PHP

// Illuminate\Routing\Controller (упрощённо)
abstract class Controller
{
    protected $middleware = [];

    public function middleware($middleware, array $options = [])
    {
        // Регистрирует middleware для этого контроллера
        $this->middleware[] = [
            'middleware' => $middleware,
            'options'    => &$options,
        ];
    }

    public function getMiddleware() { return $this->middleware; }

    public function callAction($method, $parameters)
    {
        return $this->{$method}(...array_values($parameters));
    }
}

// App\Http\Controllers\Controller (базовый — ты можешь редактировать)
class Controller extends BaseController
{
    use AuthorizesRequests, ValidatesRequests;
}

class UserController extends Controller
{
    public function __construct()
    {
        $this->middleware('auth');            // ← от родителя
        $this->middleware('admin')->only('destroy');
    }

    public function index()
    {
        $this->authorize('viewAny', User::class); // ← от trait AuthorizesRequests
        return User::paginate();
    }

    public function store(StoreUserRequest $request) // ← FormRequest injection
    {
        return User::create($request->validated());
    }

    public function show(User $user)   // ← Route Model Binding
    {
        return $user;
    }
}

// Illuminate\Database\Eloquent\Model (сильно упрощён)
abstract class Model implements Arrayable, Jsonable, JsonSerializable
{
    use HasAttributes, HasEvents, HasRelationships,
        HasTimestamps, HidesAttributes, GuardsAttributes;

    protected $table;         // имя таблицы (Convention: users)
    protected $primaryKey = 'id';
    protected $fillable = [];  // разрешённые для mass assignment
    protected $guarded = ['*']; // запрещённые (по умолчанию — все)
    protected $hidden = [];    // скрыть при toArray/toJson
    protected $casts = [];     // приведение типов
    public $timestamps = true;

    public static function create(array $attributes) { /* ... */ }
    public function save() { /* INSERT или UPDATE */ }
    public function delete() { /* DELETE */ }
    public static function find($id) { /* SELECT WHERE id = ? */ }
    public static function where(...) { /* Query Builder */ }

    // Relationship methods ты определяешь в СВОЕЙ модели
    public function hasMany($related, ...) { /* HasMany relation */ }
    public function belongsTo($related, ...) { /* BelongsTo relation */ }
}

class User extends Model
{
    use HasFactory, Notifiable, SoftDeletes; // ← трейты!

    protected $fillable = ['name', 'email', 'password'];
    protected $hidden   = ['password', 'remember_token'];
    protected $casts    = ['email_verified_at' => 'datetime'];

    // Отношения — ты определяешь, родитель обрабатывает
    public function posts(): HasMany
    {
        return $this->hasMany(Post::class); // ← метод из родителя
    }

    // Scope — ты определяешь, Laravel вызывает как User::active()
    public function scopeActive($query)
    {
        return $query->where('is_active', true);
    }
}

// Illuminate\Foundation\Http\FormRequest (упрощён)
class FormRequest extends Request
{
    // Laravel вызывает это АВТОМАТИЧЕСКИ через Service Container
    public function validateResolved()
    {
        $this->prepareForValidation();    // ← твой hook

        if (! $this->passesAuthorization()) {
            $this->failedAuthorization();   // → 403
        }

        $validator = $this->getValidatorInstance();
        // Правила берёт из $this->rules()

        if ($validator->fails()) {
            $this->failedValidation($validator); // → redirect/422
        }

        $this->passedValidation();           // ← твой hook
    }

    public function authorize() { return true; }
    public function rules()     { return []; }
    public function messages()  { return []; }
    public function validated() { /* возвращает только проверенные данные */ }
    protected function prepareForValidation() { /* пусто — ты переопределяешь */ }
    protected function passedValidation() { /* пусто */ }
}

class LoginRequest extends FormRequest
{
    public function authorize(): bool
    {
        return true; // любой может попробовать залогиниться
    }

    public function rules(): array
    {
        return [
            'email'    => ['required', 'email'],
            'password' => ['required', 'min:8'],
        ];
    }

    public function messages(): array
    {
        return [
            'email.required' => 'Введите email',
        ];
    }

    protected function prepareForValidation()
    {
        $this->merge([
            'email' => strtolower($this->email),
        ]);
    }
}

// Middleware — просто класс с handle()
class CheckAge
{
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->age < 18) {
            return redirect('home');
        }

        return $next($request); // передаём дальше по цепочке
    }
}

// After middleware
public function handle($request, Closure $next)
{
    $response = $next($request);  // сначала контроллер
    $response->header('X-Custom', 'value');  // потом модификация
    return $response;
}

// Terminable middleware
public function terminate($request, $response)
{
    // Логирование — после того как клиент УЖЕ получил ответ
    Log::info('Request processed', ['url' => $request->url()]);
}

class SendWelcomeEmail implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    public $tries = 3;         // макс попытки
    public $backoff = [10, 60]; // задержка между попытками
    public $timeout = 120;      // таймаут выполнения

    public function __construct(
        public readonly User $user // ← SerializesModels сохранит только ID
    ) {}

    public function handle(MailService $mail): void // ← DI из контейнера
    {
        $mail->send($this->user, 'welcome');
    }

    public function failed(Throwable $e): void // ← hook при неудаче
    {
        Log::error('Welcome email failed', ['user' => $this->user->id]);
    }
}

// Вызов:
SendWelcomeEmail::dispatch($user)->onQueue('emails');

class CleanOldLogs extends Command
{
    protected $signature   = 'logs:clean {--days=30 : Сколько дней хранить}';
    protected $description = 'Удаляет старые лог-файлы';

    public function handle(): int
    {
        $days = $this->option('days');
        $this->info("Cleaning logs older than {$days} days...");

        $files = Storage::files('logs');
        $this->withProgressBar($files, function($file) use ($days) {
            // удаление старых файлов...
        });

        $this->newLine();
        $this->info('Done!');
        return Command::SUCCESS;
    }
}

class OrderShipped extends Notification implements ShouldQueue
{
    use Queueable;

    public function __construct(public readonly Order $order) {}

    public function via($notifiable): array
    {
        return ['mail', 'database'];
    }

    public function toMail($notifiable): MailMessage
    {
        return (new MailMessage)
            ->subject('Ваш заказ отправлен!')
            ->line("Заказ #{$this->order->id} в пути.")
            ->action('Отследить', url("/orders/{$this->order->id}"));
    }

    public function toArray($notifiable): array
    {
        return [
            'order_id' => $this->order->id,
            'message'  => 'Заказ отправлен',
        ];
    }
}

// Вызов:
$user->notify(new OrderShipped($order)); // ← метод из trait Notifiable

class WelcomeMail extends Mailable implements ShouldQueue
{
    use Queueable, SerializesModels;

    public function __construct(public readonly User $user) {}

    public function envelope(): Envelope
    {
        return new Envelope(subject: 'Добро пожаловать!');
    }

    public function content(): Content
    {
        return new Content(view: 'emails.welcome');
    }

    public function attachments(): array
    {
        return [
            Attachment::fromPath('/docs/guide.pdf'),
        ];
    }
}

// Вызов:
Mail::to($user)->send(new WelcomeMail($user));

// Просто класс с данными
class OrderPlaced
{
    use Dispatchable, SerializesModels;

    public function __construct(
        public readonly Order $order
    ) {}
}

// Вызов:
OrderPlaced::dispatch($order);
// или
event(new OrderPlaced($order));

class SendOrderConfirmation implements ShouldQueue
{
    public function handle(OrderPlaced $event): void
    {
        $event->order->user->notify(new OrderConfirmation($event->order));
    }

    public function shouldQueue(OrderPlaced $event): bool
    {
        return $event->order->total > 0; // условная очередь
    }
}

class PostPolicy
{
    // Может ли пользователь обновить пост?
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }

    // before() — суперадмин может всё
    public function before(User $user, string $ability): ?bool
    {
        if ($user->isAdmin()) {
            return true;
        }
        return null; // null = проверяй дальше конкретный метод
    }

    public function delete(User $user, Post $post): bool
    {
        return $user->id === $post->user_id
            && $post->published_at === null;
    }
}

// Использование:
$this->authorize('update', $post);       // в контроллере
@can('update', $post) ... @endcan    // в Blade
Gate::allows('update', $post);        // программно

class UserSeeder extends Seeder
{
    public function run(): void
    {
        User::factory(50)->create(); // ← Factory!
    }
}

class UserFactory extends Factory
{
    protected $model = User::class;

    public function definition(): array
    {
        return [
            'name'     => fake()->name(),
            'email'    => fake()->unique()->safeEmail(),
            'password' => bcrypt('password'),
        ];
    }

    public function admin(): static // state
    {
        return $this->state(['role' => 'admin']);
    }
}

// Вызов:
User::factory()->admin()->count(3)->create();

class UserResource extends JsonResource
{
    public function toArray(Request $request): array
    {
        return [
            'id'    => $this->id,
            'name'  => $this->name,
            'email' => $this->email,
            'posts' => PostResource::collection(
                $this->whenLoaded('posts') // ← только если загружено
            ),
            'is_admin' => $this->when(
                $request->user()?->isAdmin(), $this->role === 'admin'
            ),
        ];
    }
}

// Использование в контроллере:
return UserResource::collection(User::paginate());

// bootstrap/app.php
return Application::configure(...)
    ->withExceptions(function (Exceptions $exceptions) {
        $exceptions->render(function (NotFoundHttpException $e) {
            return response()->json(['error' => 'Not found'], 404);
        });

        $exceptions->reportable(function (PaymentException $e) {
            Sentry::captureException($e);
        });
    })
    ->create();

class Handler extends ExceptionHandler
{
    protected $dontReport = [
        AuthorizationException::class,
    ];

    public function register(): void
    {
        $this->renderable(function (NotFoundHttpException $e) {
            return response()->json(['error' => 'Not found'], 404);
        });
    }
}

class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Привязка интерфейса к реализации
        $this->app->bind(
            PaymentGatewayInterface::class,
            StripePaymentGateway::class
        );
    }

    public function boot(): void
    {
        User::observe(UserObserver::class);

        Blade::directive('money', function ($amount) {
            return "<?php echo number_format($amount, 2) . ' ₸'; ?>";
        });
    }
}

// Контракт
interface PaymentGatewayInterface
{
    public function charge(float $amount, string $token): PaymentResult;
    public function refund(string $transactionId): bool;
}

// Реализация
class StripeGateway implements PaymentGatewayInterface
{
    public function charge(float $amount, string $token): PaymentResult
    {
        // Stripe API call
    }

    public function refund(string $transactionId): bool
    {
        // Stripe refund
    }
}

// Привязка в ServiceProvider
$this->app->bind(PaymentGatewayInterface::class, StripeGateway::class);

// В контроллере — зависишь от ИНТЕРФЕЙСА, не реализации
public function pay(PaymentGatewayInterface $gateway) { ... }

class User extends Authenticatable   // ← наследование (1 родитель)
{
    use HasFactory;          // User::factory() — тестирование
    use Notifiable;          // $user->notify() — уведомления
    use SoftDeletes;         // $user->delete() → deleted_at
    use HasApiTokens;        // Sanctum tokens
    use HasRoles;            // Spatie permissions

    // Теперь User УМЕЕТ всё вышеперечисленное!
}

trait HasSlug
{
    public static function bootHasSlug(): void // boot{TraitName} — авто-вызов
    {
        static::creating(function ($model) {
            $model->slug = Str::slug($model->title);
        });
    }

    public function getRouteKeyName(): string
    {
        return 'slug';
    }
}

// Использование:
class Post extends Model { use HasSlug; }

// 1. Сервис
class SmsService
{
    public function send(string $phone, string $message): bool { /* ... */ }
}

// 2. Фасад
class Sms extends Facade
{
    protected static function getFacadeAccessor(): string
    {
        return SmsService::class; // ← ключ в контейнере
    }
}

// 3. Регистрация (ServiceProvider)
$this->app->singleton(SmsService::class);

// 4. Использование
Sms::send('+77001234567', 'Код: 1234');
// ↑ на самом деле: app(SmsService::class)->send(...)