webstatement/app/Models/PrintStatementLog.php

<?php

namespace Modules\Webstatement\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Modules\Basicdata\Models\Branch;
use Modules\Usermanagement\Models\User;

class PrintStatementLog extends Model
{
    use HasFactory, SoftDeletes;

    protected $fillable = [
        'user_id',
        'branch_code',
        'account_number',
        'request_type',
        'batch_id',
        'target_accounts',
        'total_accounts',
        'processed_accounts',
        'success_count',
        'failed_count',
        'status',
        'started_at',
        'completed_at',
        'error_message',
        'period_from',
        'period_to',
        'is_period_range',
        'is_available',
        'is_downloaded',
        'ip_address',
        'user_agent',
        'downloaded_at',
        'authorization_status',
        'created_by',
        'updated_by',
        'deleted_by',
        'authorized_by',
        'authorized_at',
        'remarks',
        'email',
        'email_sent_at',
    ];

    protected $casts = [
        'is_period_range' => 'boolean',
        'is_available'    => 'boolean',
        'is_downloaded'   => 'boolean',
        'downloaded_at'   => 'datetime',
        'authorized_at'   => 'datetime',
        'started_at'      => 'datetime',
        'completed_at'    => 'datetime',
        'target_accounts' => 'array',
    ];

    /**
     * Get the formatted period display
     *
     * @return string
     */
    public function getPeriodDisplayAttribute()
    {
        if ($this->is_period_range) {
            return $this->formatPeriod($this->period_from) . ' - ' . $this->formatPeriod($this->period_to);
        }

        return $this->formatPeriod($this->period_from);
    }

    /**
     * Format period from YYYYMM to Month Year
     *
     * @param string $period
     *
     * @return string
     */
    protected function formatPeriod($period)
    {
        if (strlen($period) !== 6) {
            return $period;
        }

        $year  = substr($period, 0, 4);
        $month = substr($period, 4, 2);

        return date('F Y', mktime(0, 0, 0, (int) $month, 1, (int) $year));
    }

    /**
     * Get the user who requested the statement
     */
    public function user()
    {
        return $this->belongsTo(User::class, 'user_id');
    }

    /**
     * Get the user who created the record
     */
    public function creator()
    {
        return $this->belongsTo(User::class, 'created_by');
    }

    /**
     * Get the user who updated the record
     */
    public function updater()
    {
        return $this->belongsTo(User::class, 'updated_by');
    }

    /**
     * Get the user who authorized the record
     */
    public function authorizer()
    {
        return $this->belongsTo(User::class, 'authorized_by');
    }

    /**
     * Scope a query to only include pending authorization records
     */
    public function scopePending($query)
    {
        return $query->where('authorization_status', 'pending');
    }

    /**
     * Scope a query to only include approved records
     */
    public function scopeApproved($query)
    {
        return $query->where('authorization_status', 'approved');
    }

    /**
     * Scope a query to only include rejected records
     */
    public function scopeRejected($query)
    {
        return $query->where('authorization_status', 'rejected');
    }

    /**
     * Scope a query to only include downloaded records
     */
    public function scopeDownloaded($query)
    {
        return $query->where('is_downloaded', true);
    }

    /**
     * Scope a query to only include available records
     */
    public function scopeAvailable($query)
    {
        return $query->where('is_available', true);
    }

    /**
     * Check if the statement is for a single period
     */
    public function isSinglePeriod()
    {
        return !$this->is_period_range;
    }

    /**
     * Check if the statement is authorized
     */
    public function isAuthorized()
    {
        return $this->authorization_status === 'approved';
    }

    /**
     * Check if the statement is rejected
     */
    public function isRejected()
    {
        return $this->authorization_status === 'rejected';
    }

    /**
     * Check if the statement is pending authorization
     */
    public function isPending()
    {
        return $this->authorization_status === 'pending';
    }

    public function branch(){
        return $this->belongsTo(Branch::class, 'branch_code','code');
    }

    /**
     * Check if this is a single account request
     */
    public function isSingleAccountRequest()
    {
        return $this->request_type === 'single_account';
    }

    /**
     * Check if this is a branch request
     */
    public function isBranchRequest()
    {
        return $this->request_type === 'branch';
    }

    /**
     * Check if this is an all branches request
     */
    public function isAllBranchesRequest()
    {
        return $this->request_type === 'all_branches';
    }

    /**
     * Check if processing is completed
     */
    public function isCompleted()
    {
        return $this->status === 'completed';
    }

    /**
     * Check if processing is in progress
     */
    public function isProcessing()
    {
        return $this->status === 'processing';
    }

    /**
     * Check if processing failed
     */
    public function isFailed()
    {
        return $this->status === 'failed';
    }

    /**
     * Get progress percentage
     */
    public function getProgressPercentage()
    {
        if (!$this->total_accounts || $this->total_accounts == 0) {
            return 0;
        }

        return round(($this->processed_accounts / $this->total_accounts) * 100, 2);
    }

    /**
     * Get success rate percentage
     */
    public function getSuccessRate()
    {
        if (!$this->processed_accounts || $this->processed_accounts == 0) {
            return 0;
        }

        return round(($this->success_count / $this->processed_accounts) * 100, 2);
    }

    /**
     * Scope for batch requests
     */
    public function scopeBatch($query)
    {
        return $query->whereIn('request_type', ['branch', 'all_branches']);
    }

    /**
     * Scope for single account requests
     */
    public function scopeSingleAccount($query)
    {
        return $query->where('request_type', 'single_account');
    }
}