app/Models/Tap.php - master - itp_practice/itp_backend

app/Models/Tap.php
363 строки8 KB
vivanenko
tariff buy
27 май 2025, 20:52
27 май 2025, 20:529a8b3c7
<?php

namespace App\Models;

use Carbon\Carbon;
use App\Enums\TapStatus;
use App\Enums\TapProcessState;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\SoftDeletes;

/**
 * @property int $id
 * @property string $name
 * @property string $phone
 * @property TapStatus $status
 * @property Carbon|null $created_at
 * @property Carbon|null $updated_at
 * @property Carbon|null $expired_at
 * @property string|null $crm_user_id
 * @property float $balance
 * @property TapProcessState $process_state
 * @property array|null $process_info
 * @property Carbon|null $last_process_check
 * @property string|null $proxy
 * @property string|null $auth_id
 */
class Tap extends Model
{
    use HasFactory;

    protected $fillable = [
        'name',
        'phone',
        'status',
        'expired_at',
        'crm_user_id',
        'balance',
        'process_state',
        'process_info',
        'last_process_check',
        'proxy',
        'auth_id',
        'tap_app_id',
    ];

    protected $casts = [
        'status' => TapStatus::class,
        'expired_at' => 'datetime',
        'balance' => 'float',
        'process_state' => TapProcessState::class,
        'process_info' => 'json',
        'last_process_check' => 'datetime',
    ];

    /**
     * Scope a query to only include active taps
     */
    public function scopeActive(Builder $query): Builder
    {
        return $query->where('status', TapStatus::ACTIVE)
            ->where(function ($query) {
                $query->whereNull('expired_at')
                    ->orWhere('expired_at', '>', now());
            });
    }

    /**
     * Scope a query to only include expired taps
     */
    public function scopeExpired(Builder $query): Builder
    {
        return $query->where('expired_at', '<=', now());
    }

    /**
     * Scope a query to only include taps with errors
     */
    public function scopeWithErrors(Builder $query): Builder
    {
        return $query->whereIn('status', [TapStatus::ERROR, TapStatus::BANNED]);
    }

    /**
     * Check if tap is active
     */
    public function isActive(): bool
    {
        return $this->status->isActive() && 
            (!$this->expired_at || $this->expired_at->isFuture());
    }

    /**
     * Check if tap is expired
     */
    public function isExpired(): bool
    {
        return $this->expired_at && $this->expired_at->isPast();
    }

    /**
     * Check if process is running
     */
    public function isProcessRunning(): bool
    {
        return $this->process_state->isActive();
    }

    /**
     * Check if process has error
     */
    public function hasProcessError(): bool
    {
        return $this->process_state->hasError();
    }

    /**
     * Mark tap as active
     */
    public function markAsActive(): self
    {
        $this->update([
            'status' => TapStatus::ACTIVE,
            'process_state' => TapProcessState::RUNNING,
        ]);

        return $this;
    }

    /**
     * Mark tap as banned
     */
    public function markAsBanned(): self
    {
        $this->update([
            'status' => TapStatus::BANNED,
            'process_state' => TapProcessState::STOPPED,
        ]);

        return $this;
    }

    /**
     * Mark tap as having error
     */
    public function markAsError(string $error = null): self
    {
        $this->update([
            'status' => TapStatus::ERROR,
            'process_state' => TapProcessState::FATAL,
            'process_info' => array_merge($this->process_info ?? [], [
                'last_error' => $error,
                'error_at' => now()->toDateTimeString(),
            ]),
        ]);

        return $this;
    }

    /**
     * Update process state
     */
    public function updateProcessState(TapProcessState $state, array $info = null): self
    {
        $this->update([
            'process_state' => $state,
            'process_info' => $info ? array_merge($this->process_info ?? [], $info) : $this->process_info,
            'last_process_check' => now(),
        ]);

        return $this;
    }

    /**
     * Record process check
     */
    public function recordProcessCheck(): self
    {
        $this->update([
            'last_process_check' => now(),
        ]);

        return $this;
    }

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

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

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

    public function subscriptions(): BelongsToMany
    {
        return $this->belongsToMany(
            UserTariffSubscription::class,
            'user_tariff_subscription_taps'
        )->withTimestamps();
    }

    public function getUserId(): int
    {
        return $this->user_id;
    }

    public function getPhone(): string
    {
        return $this->phone;
    }

    public function getAuthId(): ?string
    {
        return $this->auth_id;
    }

    public function getProxyId(): ?int
    {
        return $this->proxy_id;
    }

    public function getProcessState(): TapProcessState
    {
        return $this->process_state;
    }

    public function getProcessData(): ?array
    {
        return $this->process_data;
    }

    public function getTelegramData(): ?array
    {
        return $this->telegram_data;
    }

    public function getErrorCount(): int
    {
        return $this->error_count;
    }

    public function getErrorMessage(): ?string
    {
        return $this->error_message;
    }

    public function getLastActivity(): ?DateTime
    {
        return $this->last_activity;
    }

    public function getLastError(): ?DateTime
    {
        return $this->last_error;
    }

    public function getIsActive(): bool
    {
        return $this->is_active;
    }

    public function setUserId(int $userId): self
    {
        $this->user_id = $userId;
        return $this;
    }

    public function setPhone(string $phoneNumber): self
    {
        // Validate phone number format
        if (!preg_match('/^\+?[1-9]\d{1,14}$/', $phoneNumber)) {
            throw new \InvalidArgumentException('Invalid phone number format');
        }
        $this->phone = $phoneNumber;
        return $this;
    }

    public function setAuthId(?string $authId): self
    {
        $this->auth_id = $authId;
        return $this;
    }

    public function setProxyId(?int $proxyId): self
    {
        $this->proxy_id = $proxyId;
        return $this;
    }

    public function setProcessState(TapProcessState $state): self
    {
        $this->process_state = $state;
        return $this;
    }

    public function setProcessData(?array $data): self
    {
        $this->process_data = $data;
        return $this;
    }

    public function setTelegramData(?array $data): self
    {
        $this->telegram_data = $data;
        return $this;
    }

    public function setErrorCount(int $count): self
    {
        if ($count < 0) {
            throw new \InvalidArgumentException('Error count cannot be negative');
        }
        $this->error_count = $count;
        return $this;
    }

    public function setErrorMessage(?string $message): self
    {
        $this->error_message = $message;
        return $this;
    }

    public function setLastActivity(?DateTime $lastActivity): self
    {
        $this->last_activity = $lastActivity;
        return $this;
    }

    public function setLastError(?DateTime $lastError): self
    {
        $this->last_error = $lastError;
        return $this;
    }

    public function setIsActive(bool $isActive): self
    {
        $this->is_active = $isActive;
        return $this;
    }

    public function incrementErrorCount(): self
    {
        $this->error_count++;
        return $this;
    }

    public function resetErrorCount(): self
    {
        $this->error_count = 0;
        return $this;
    }
}