%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /var/www/html/hr/api/app/Models/
Upload File :
Create Path :
Current File : /var/www/html/hr/api/app/Models/Payment.php

<?php

namespace App\Models;

use Carbon\Carbon;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Support\Facades\DB;
use Throwable;

/**
 * @property integer id
 * @property string status
 * @property integer amount
 * @property mixed sent_at
 * @property mixed paid_at
 * @property integer project_id
 * @property Project project
 */
class Payment extends BaseModel
{
    const PENDING = 'PENDING';
    const PAID = 'PAID';
    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'status',
        'sent_at',
        'paid_at',
        'amount',
    ];

    protected $guarded = [
        'project_id',
    ];

    /**
     * The attributes that should be cast to native types.
     *
     * @var array
     */
    protected $casts = [
        'id'         => 'integer',
        'status'     => 'string',
        'sent_at'    => 'date',
        'paid_at'    => 'date',
        'amount'     => 'integer',
        'project_id' => 'integer',
    ];

    /**
     * @param $data
     * @return Payment|null
     * @throws Throwable
     */
    public static function createItem($data)
    {
        try {
            DB::beginTransaction();
            /** @var self $item */
            $item = self::query()
                        ->make([
                            'status'  => self::PENDING,
                            'sent_at' => Carbon::now(),
                            'amount'  => $data['amount'],
                        ]);
            $item->project()
                 ->associate($data['project_id']);
            $item->save();
            DB::commit();
            return $item->fresh();
        } catch (Throwable $e) {
            DB::rollBack();
            throw $e;
        }
    }

    public function project()
    {
        return $this->belongsTo(Project::class);
    }

    public static function getMonthly($from = null, $to = null)
    {
        $projectPayments = self::query()
                               ->where('status', self::PAID);
        if ($from) {
            $projectPayments = $projectPayments->where('paid_at', '>=', Carbon::parse($from));
        }
        if ($to) {
            $projectPayments = $projectPayments->where('paid_at', '<=', Carbon::parse($to));
        }
        $projectPayments = $projectPayments->join('projects as project', 'payments.project_id', '=', 'project.id')
                                           ->where('project.is_private', false)
                                           ->select([
                                               'currency',
                                               DB::raw('sum(amount) as amount'),
                                               DB::raw("DATE_FORMAT(paid_at,'%y-%m') as month"),
                                           ]);

        $projectPayments = $projectPayments->groupBy('month', 'project.currency')
                                           ->get();

        $payments = collect($projectPayments);

        $transactions = MaintenancePaymentTransaction::query()
                                                     ->leftJoin('maintenance_payments', 'maintenance_payment_transactions.payment_id', '=', 'maintenance_payments.id');

        $transactions = $transactions->select([
            'maintenance_payment_transactions.currency',
            DB::raw("SUM( ( CASE WHEN maintenance_payments.type = 'EARNING' THEN maintenance_payment_transactions.amount ELSE -maintenance_payment_transactions.amount END ) ) AS amount"),
            DB::raw("DATE_FORMAT(maintenance_payment_transactions.paid_at,'%y-%m') as month"),
        ])
                                     ->groupBy('month', 'currency')
                                     ->get();

        $data = collect();
        $payments->merge($transactions)
                 ->groupBy(['currency', 'month'])
                 ->map(function ($e) {
                     return $e->map(function ($q) {
                         return $q->sum('amount');
                     });
                 })
                 ->map(function ($d, $k) use ($data) {
                     $d->map(function ($item, $key) use ($data, $k) {
                         $data->push([
                             'currency' => $k,
                             'date'     => $key,
                             'amount'   => $item,
                         ]);
                     });
                 });
        return $data;
    }

    public static function awaitingPayment()
    {
        $to = Carbon::now()
                    ->addMonth();
        $projectPayments = self::query()
                               ->where('status', self::PENDING);
        $projectPayments = $projectPayments->join('projects as project', 'payments.project_id', '=', 'project.id')
                                           ->select([
                                               'currency',
                                               DB::raw('sum(amount) as amount'),
                                           ]);

        $projectPayments = $projectPayments->groupBy('project.currency')
                                           ->get();

        $payments = collect($projectPayments);

        $maintenance = MaintenancePayment::query()
                                         ->where('type', MaintenancePayment::EARNING)
                                         ->where('is_active', true)
                                         ->where('next_payment_date', '<=', $to);

        $maintenance = $maintenance->select([
            'currency',
            DB::raw('sum(amount) as amount'),
        ])
                                   ->groupBy('currency')
                                   ->get();
        $data = collect();
        $payments->merge($maintenance)
                 ->groupBy('currency')
                 ->map(function ($e) {
                     return $e->sum('amount');
                 })
                 ->map(function ($item, $k) use ($data) {
                     $data->push([
                         'currency' => $k,
                         'amount'   => $item,
                     ]);
                 });
        return $data;
    }

    public function scopePrivate(Builder $query, $user)
    {
        return $query->whereHas('project', function (Builder $q) use ($user) {
            $q->where('is_private', false);
            $q->orWhere(function (Builder $u) use ($user) {
                $u->where('is_private', true);
                $u->where('manager_id', $user->id);
            });
        });
    }

    /**
     * @return $this
     * @throws Throwable
     */
    public function paid()
    {
        try {
            if ($this->status === self::PAID) {
                return $this;
            }
            $this->status = self::PAID;
            $this->paid_at = Carbon::now();
            $this->save();
            return $this;
        } catch (Throwable $e) {
            throw $e;
        }
    }

    public function isDeletable()
    {
        return $this->status !== self::PAID;
    }

}

Zerion Mini Shell 1.0