sfp_api_laravel_serprati/app/Models/User.php

<?php

namespace App\Models;

use App\Enums\LanguageEnum;
use App\Enums\PartnerAgreementTypeEnum;
use App\Enums\UserStatusEnum;
use App\Enums\UserTypeEnum;
use App\Support\Cpf;
use App\Traits\HasPermissions;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Sanctum\HasApiTokens;
use Carbon\Carbon;

/**
 * @property int $id
 * @property string $name
 * @property string $email
 * @property string|null $phone
 * @property string|null $position_label
 * @property string|null $sector_label
 * @property \Illuminate\Support\Carbon|null $email_verified_at
 * @property string $password
 * @property UserTypeEnum $type
 * @property LanguageEnum $language
 * @property \Illuminate\Support\Carbon|null $created_at
 * @property \Illuminate\Support\Carbon|null $updated_at
 * @property-read \Illuminate\Notifications\DatabaseNotificationCollection<int, \Illuminate\Notifications\DatabaseNotification> $notifications
 * @property-read int|null $notifications_count
 * @property-read \Kalnoy\Nestedset\Collection<int, \App\Models\Permission> $permissions
 * @property-read int|null $permissions_count
 * @property-read \Illuminate\Database\Eloquent\Collection<int, \Laravel\Sanctum\PersonalAccessToken> $tokens
 * @property-read int|null $tokens_count
 * @method static \Database\Factories\UserFactory factory($count = null, $state = [])
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User newModelQuery()
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User newQuery()
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User query()
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereCreatedAt($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereEmail($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereEmailVerifiedAt($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereId($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereLanguage($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereName($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User wherePassword($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereType($value)
 * @method static \Illuminate\Database\Eloquent\Builder<static>|User whereUpdatedAt($value)
 * @property string|null $photo_path
 * @mixin \Eloquent
 */
class User extends Authenticatable
{
    use HasFactory, Notifiable, HasApiTokens, HasPermissions;

    protected $guarded = ["id"];

    /**
     * The attributes that should be hidden for serialization.
     *
     * @var array<int, string>
     */
    protected $hidden = ["password", "remember_token"];

    /**
     * Get the attributes that should be cast.
     *
     * @return array<string, string>
     */
    protected function casts(): array
    {
        return [
            "email_verified_at" => "datetime",
            "password"          => "hashed",
            "type"              => UserTypeEnum::class,
            "language"          => LanguageEnum::class,
            "status"            => UserStatusEnum::class,
            "admission_date"    => "date",
            "first_access_completed_at" => "datetime",
            "terms_accepted_at" => "datetime",
            "expiry_date"       => "date",
            "excluded_at"       => "datetime",
            "on_leave_at"       => "datetime",
        ];
    }

    protected function cpf(): Attribute
    {
        return Attribute::make(
            get: fn(?string $value): ?string => Cpf::format($value),
            set: fn(?string $value): ?string => Cpf::digits($value),
        );
    }

    public function isAdministrador(): bool
    {
        return $this->type === UserTypeEnum::ADMINISTRADOR;
    }

    public function isAssociado(): bool
    {
        return $this->type === UserTypeEnum::ASSOCIADO;
    }

    public function isParceiro(): bool
    {
        return $this->type === UserTypeEnum::PARCEIRO;
    }

    public function isConvenioMedico(): bool
    {
        return $this->isParceiro()
            && $this->partnerAgreement?->type === PartnerAgreementTypeEnum::AGREEMENT;
    }

    public function loginBlockReason(): ?string
    {
        if ($this->isAssociado()) {
            return match (true) {
                $this->status === UserStatusEnum::REFUSED  => 'refused',
                is_null($this->first_access_completed_at)  => 'first_access_required',
                $this->status === UserStatusEnum::PENDING  => 'pending_approval',
                default                                    => null,
            };
        }

        if ($this->isParceiro() && $this->status === UserStatusEnum::INACTIVE) {
            return 'inactive';
        }

        return null;
    }

    /**
     * Indica se o usuário já pode ser autenticado (usado ao concluir o primeiro acesso).
     */
    public function canLogin(): bool
    {
        return $this->loginBlockReason() === null;
    }

    /**
     * Create a new access token for the user.
     */
    public function createAccessToken(string $deviceId): string
    {
        return $this->createToken(
            name: "access_token_{$deviceId}",
            abilities: ["access"],
            expiresAt: Carbon::now()->addMinutes(15),
        )->plainTextToken;
    }

    /**
     * Create a new refresh token for the user.
     */
    public function createRefreshToken(string $deviceId): string
    {
        return $this->createToken(
            name: "refresh_token_{$deviceId}",
            abilities: ["refresh"],
            expiresAt: Carbon::now()->addDays(30),
        )->plainTextToken;
    }

    /**
     * Delete all tokens (access and refresh) for a specific device.
     */
    public function deleteTokensByDevice(string $deviceId): void
    {
        $this->tokens()
            ->where("name", "like", "%_{$deviceId}")
            ->delete();
    }

    public function position(): BelongsTo
    {
        return $this->belongsTo(Position::class);
    }

    public function sector(): BelongsTo
    {
        return $this->belongsTo(Sector::class);
    }

    public function dependents(): HasMany
    {
        return $this->hasMany(UserDependent::class, 'responsible_user_id');
    }

    public function appointments(): HasMany
    {
        return $this->hasMany(Appointment::class);
    }

    public function partnerAgreement(): HasOne
    {
        return $this->hasOne(PartnerAgreement::class);
    }

    public function notificationSends(): HasMany
    {
        return $this->hasMany(NotificationSend::class);
    }

    public function storeItemInterests(): HasMany
    {
        return $this->hasMany(StoreItemInterest::class);
    }

    public function accessLogs(): HasMany
    {
        return $this->hasMany(UserAccessLog::class);
    }

    public function evaluations(): HasMany
    {
        return $this->hasMany(Evaluation::class);
    }

    /**
     * @return BelongsToMany
     */
    public function permissions(): BelongsToMany
    {
        return $this->belongsToMany(
            Permission::class,
            "user_type_permissions",
            "user_type",
            "permission_id",
        );
    }
}