Epicnabbo-Catalogus-Updated-Daily/Updated_Cms/app/Models/User.php

<?php

namespace App\Models;

use App\Models\Articles\WebsiteArticle;
use App\Models\Articles\WebsiteArticleComment;
use App\Models\Community\Staff\WebsiteStaffApplications;
use App\Models\Community\Staff\WebsiteStaffTeam;
use App\Models\Game\Furniture\Item;
use App\Models\Game\Permission;
use App\Models\Game\Player\MessengerFriendship;
use App\Models\Game\Player\UserBadge;
use App\Models\Game\Player\UserCurrency;
use App\Models\Game\Player\UserSetting;
use App\Models\Game\Player\UserSubscription;
use App\Models\Game\Room;
use App\Models\Help\WebsiteHelpCenterTicket;
use App\Models\Miscellaneous\CameraWeb;
use App\Models\Miscellaneous\WebsiteBetaCode;
use App\Models\Shop\WebsitePaypalTransaction;
use App\Models\Shop\WebsiteUsedShopVoucher;
use App\Models\User\Ban;
use App\Models\User\ClaimedReferralLog;
use App\Models\User\Referral;
use App\Models\User\UserReferral;
use App\Models\User\WebsiteUserGuestbook;
use Filament\Models\Contracts\FilamentUser;
use Filament\Models\Contracts\HasName;
use Filament\Panel;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Str;
use Laravel\Fortify\TwoFactorAuthenticatable;
use Laravel\Fortify\TwoFactorAuthenticationProvider;
use Laravel\Sanctum\HasApiTokens;
use Spatie\Activitylog\LogOptions;
use Spatie\Activitylog\Traits\LogsActivity;
use App\Models\ChatlogRoom;
use App\Models\ChatlogPrivate;

/**
 * @property int $id
 * @property string $username
 * @property string $mail
 * @property string $password
 * @property string $look
 * @property string $motto
 * @property int $credits
 * @property int $rank
 * @property string $ip_register
 * @property string $ip_current
 * @property int $account_created
 * @property int $last_login
 * @property int $last_online
 * @property string|null $auth_ticket
 * @property int $home_room
 * @property string|null $referral_code
 * @property bool $online
 * @property bool $hidden_staff
 * @property int|null $team_id
 * @property string|null $two_factor_secret
 * @property string|null $two_factor_recovery_codes
 * @property \Illuminate\Support\Carbon|null $two_factor_confirmed_at
 * @property string|null $remember_token
 * @property \Illuminate\Support\Carbon|null $email_verified_at
 * @property int $website_balance
 */
class User extends Authenticatable implements FilamentUser, HasName
{
    use HasApiTokens, HasFactory, LogsActivity, Notifiable, TwoFactorAuthenticatable;

    public $timestamps = false;

    protected $guarded = ['id'];

    protected $hidden = ['id', 'password', 'remember_token'];

    protected function casts(): array
    {
        return [
            'email_verified_at' => 'datetime',
            'password' => 'hashed',
            'hidden_staff' => 'boolean',
            'online' => 'boolean',
        ];
    }

    /**
     * @return HasMany<UserCurrency, $this>
     */
    public function currencies(): HasMany
    {
        return $this->hasMany(UserCurrency::class, 'user_id');
    }

    /**
     * @return HasMany<Session, $this>
     */
    public function sessions(): HasMany
    {
        return $this->hasMany(Session::class);
    }

    public function currency(string $currency): int
    {
        if (! $this->relationLoaded('currencies')) {
            $this->load('currencies');
        }

        $type = match ($currency) {
            'duckets' => 0,
            'diamonds' => 5,
            'points' => 101,
            default => 0,
        };

        $currency = $this->currencies->where('type', $type)->first();

        return $currency ? $currency->amount : 0;
    }

    /**
     * @return HasOne<Permission, $this>
     */
    public function permission(): HasOne
    {
        return $this->hasOne(Permission::class, 'id', 'rank');
    }

    /**
     * @return HasMany<WebsiteArticle, $this>
     */
    public function articles(): HasMany
    {
        return $this->hasMany(WebsiteArticle::class);
    }

    /**
     * @return HasOne<UserReferral, $this>
     */
    public function referrals(): HasOne
    {
        return $this->hasOne(UserReferral::class);
    }

    /**
     * @return HasMany<Referral, $this>
     */
    public function userReferrals(): HasMany
    {
        return $this->hasMany(Referral::class);
    }

    /**
     * @return HasMany<ClaimedReferralLog, $this>
     */
    public function claimedReferralLog(): HasMany
    {
        return $this->hasMany(ClaimedReferralLog::class);
    }

    /**
     * @return HasMany<UserBadge, $this>
     */
    public function badges(): HasMany
    {
        return $this->hasMany(UserBadge::class);
    }

    /**
     * @return HasMany<Room, $this>
     */
    public function rooms(): HasMany
    {
        return $this->hasMany(Room::class, 'owner_id');
    }

    /**
     * @return HasMany<MessengerFriendship, $this>
     */
    public function friends(): HasMany
    {
        return $this->hasMany(MessengerFriendship::class, 'user_one_id');
    }

    public function referralsNeeded(): int
    {
        $referrals = 0;

        if (! is_null($this->referrals)) {
            $referrals = $this->referrals->referrals_total;
        }

        return (int) setting('referrals_needed') - $referrals;
    }

    /**
     * @return HasOne<Ban, $this>
     */
    public function ban(): HasOne
    {
        return $this->hasOne(Ban::class, 'user_id')->where('ban_expire', '>', time())->whereIn('type', ['account', 'super']);
    }

    /**
     * @return HasOne<UserSetting, $this>
     */
    public function settings(): HasOne
    {
        return $this->hasOne(UserSetting::class);
    }

    public function ssoTicket(): string
    {
        $sso = sprintf('%s-%s', Str::replace(' ', '', setting('hotel_name')), Str::uuid());

        if (User::where('auth_ticket', $sso)->exists()) {
            return $this->ssoTicket();
        }

        $this->update([
            'auth_ticket' => $sso,
        ]);

        return $sso;
    }

    /**
     * @return HasOne<WebsiteBetaCode, $this>
     */
    public function betaCode(): HasOne
    {
        return $this->hasOne(WebsiteBetaCode::class);
    }

    /**
     * @return BelongsTo<WebsiteStaffTeam, $this>
     */
    public function team(): BelongsTo
    {
        return $this->belongsTo(WebsiteStaffTeam::class, 'team_id');
    }

    /**
     * @return HasMany<WebsiteStaffApplications, $this>
     */
    public function applications(): HasMany
    {
        return $this->hasMany(WebsiteStaffApplications::class, 'user_id');
    }

    /**
     * @return HasOne<UserSubscription, $this>
     */
    public function hcSubscription(): HasOne
    {
        return $this->hasOne(UserSubscription::class);
    }

    /**
     * @return HasMany<WebsiteArticleComment, $this>
     */
    public function articleComments(): HasMany
    {
        return $this->hasMany(WebsiteArticleComment::class);
    }

    /**
     * @return HasMany<WebsitePaypalTransaction, $this>
     */
    public function transactions(): HasMany
    {
        return $this->hasMany(WebsitePaypalTransaction::class);
    }

    /**
     * @return HasMany<WebsiteUsedShopVoucher, $this>
     */
    public function usedShopVouchers(): HasMany
    {
        return $this->hasMany(WebsiteUsedShopVoucher::class);
    }

    /**
     * @return HasMany<Item, $this>
     */
    public function items(): HasMany
    {
        return $this->hasMany(Item::class, 'user_id');
    }

    /**
     * @return HasMany<WebsiteHelpCenterTicket, $this>
     */
    public function tickets(): HasMany
    {
        return $this->hasMany(WebsiteHelpCenterTicket::class);
    }

    /**
     * @return HasMany<CameraWeb, $this>
     */
    public function photos(): HasMany
    {
        return $this->hasMany(CameraWeb::class);
    }

    protected static function newFactory(): \Database\Factories\UserFactory
    {
        return \Database\Factories\UserFactory::new();
    }

    /**
     * @return HasMany<WebsiteUserGuestbook, $this>
     */
    public function profileGuestbook(): HasMany
    {
        return $this->hasMany(WebsiteUserGuestbook::class, 'profile_id');
    }

    /**
     * @return HasMany<WebsiteUserGuestbook, $this>
     */
    public function guestbook(): HasMany
    {
        return $this->hasMany(WebsiteUserGuestbook::class, 'user_id');
    }

    /**
     * @return HasMany<ChatlogRoom, $this>
     */
    public function chatLogs(): HasMany
    {
        return $this->hasMany(ChatlogRoom::class, 'user_from_id');
    }

    /**
     * @return HasMany<ChatlogPrivate, $this>
     */
    public function chatLogsPrivate(): HasMany
    {
        return $this->hasMany(ChatlogPrivate::class, 'user_from_id');
    }

    /**
     * @return \Illuminate\Database\Eloquent\Collection<int, \App\Models\Game\Player\MessengerFriendship>
     */
    public function getOnlineFriends(int $total = 10): \Illuminate\Database\Eloquent\Collection
    {
        /** @var \Illuminate\Database\Eloquent\Collection<int, \App\Models\Game\Player\MessengerFriendship> $friends */
        $friends = $this->friends()
            ->select(['user_two_id', 'users.id', 'users.username', 'users.look', 'users.motto', 'users.last_online'])
            ->join('users', 'users.id', '=', 'user_two_id')
            ->where('users.online', '1')
            ->inRandomOrder()
            ->limit($total)
            ->get();

        return $friends;
    }

    public function confirmTwoFactorAuthentication(string $code): bool
    {
        $secret = $this->two_factor_secret;

        if (! is_string($secret)) {
            return false;
        }

        $decrypted = decrypt($secret);

        if (! is_string($decrypted)) {
            return false;
        }

        $codeIsValid = app(TwoFactorAuthenticationProvider::class)
            ->verify($decrypted, $code);

        if (! $codeIsValid) {
            return false;
        }

        $this->update([
            'two_factor_confirmed' => true,
        ]);

        return true;
    }

    public function hasAppliedForPosition(int $rankId): bool
    {
        return $this->applications()->where('rank_id', '=', $rankId)->exists();
    }

    public function changePassword(string $newPassword): void
    {
        $this->password = Hash::make($newPassword);
        $this->save();
    }

    public function getFilamentName(): string
    {
        return $this->username ?? 'Guest';
    }

    public function canAccessPanel(Panel $panel): bool
    {
        return (bool) hasHousekeepingPermission('can_access_housekeeping');
    }

    public function getActivitylogOptions(): LogOptions
    {
        return LogOptions::defaults()
            ->logOnly(['id', 'username', 'motto', 'rank', 'credits'])
            ->logOnlyDirty()
            ->dontSubmitEmptyLogs();
    }

    #[\Override]
    public function save(array $options = [])
    {
        if (! $this->isDirty()) {
            return false;
        }

        return parent::save($options);
    }
}