shipping-portal/app/Classes/Modules/Billplzs/Processors/CallbackBillplzProcessor.php

<?php

namespace App\Classes\Modules\Billplzs\Processors;

use Illuminate\Http\Request;
use App\Models\Wallet;
use App\Models\Group;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Classes\ValueObjects\Constants\TransactionType;
use App\Classes\ValueObjects\Constants\PaymentMethodType;
use App\Classes\Modules\Transactions\Processors\CreatePaymentTransactionProcessor;
use App\Classes\Modules\Transactions\Processors\CreateStorageInvoiceDocTransactionProcessor;
use App\Classes\Modules\Transactions\Services\UpdatesTransactionStatus;
use App\Classes\Modules\Wallets\Services\UpdatesWalletBalance;
use App\Classes\Modules\Orders\Processors\UpdateDoFromVTPortalProcessor;
use App\Classes\Modules\Orders\Processors\UpdateDoFromYDPortalProcessor;
use Illuminate\Support\Facades\Log;

class CallbackBillplzProcessor
{
    /** @var UpdatesTransactionStatus */
    private $updatesTransactionStatus;

    /** @var UpdateDoFromVTPortalProcessor */
    private $updateDoFromVTPortalProcessor;

    /** @var UpdateDoFromYDPortalProcessor */
    private $updateDoFromYDPortalProcessor;

    /** @var UpdatesWalletBalance */
    private $updatesWalletBalance;

    /** @var CreatePaymentTransactionProcessor */
    private $createPaymentTransactionProcessor;

    /** @var CreateStorageInvoiceDocTransactionProcessor */
    private $ceateStorageInvoiceDocTransactionProcessor;

    /**
     * CreateUserProcessor constructor.
     * @param UpdatesTransactionStatus $updatesTransactionStatus
     * @param UpdateDoFromVTPortalProcessor $updateDoFromVTPortalProcessor
     * @param UpdateDoFromYDPortalProcessor $updateDoFromYDPortalProcessor
     * @param UpdatesWalletBalance $updatesWalletBalance
     * @param CreatePaymentTransactionProcessor $createPaymentTransactionProcessor
     * @param CreateStorageInvoiceDocTransactionProcessor $ceateStorageInvoiceDocTransactionProcessor
     */
    public function __construct(UpdatesTransactionStatus $updatesTransactionStatus, UpdateDoFromVTPortalProcessor $updateDoFromVTPortalProcessor, UpdateDoFromYDPortalProcessor $updateDoFromYDPortalProcessor, UpdatesWalletBalance $updatesWalletBalance, CreatePaymentTransactionProcessor $createPaymentTransactionProcessor, CreateStorageInvoiceDocTransactionProcessor $ceateStorageInvoiceDocTransactionProcessor)
    {
        $this->updatesTransactionStatus = $updatesTransactionStatus;
        $this->updateDoFromVTPortalProcessor = $updateDoFromVTPortalProcessor;
        $this->updateDoFromYDPortalProcessor = $updateDoFromYDPortalProcessor;
        $this->updatesWalletBalance = $updatesWalletBalance;
        $this->createPaymentTransactionProcessor = $createPaymentTransactionProcessor;
        $this->ceateStorageInvoiceDocTransactionProcessor = $ceateStorageInvoiceDocTransactionProcessor;
    }


    /**
     * @param Request $request
     * @throws \App\Classes\Exceptions\MalformedRequestException
     */
    public function execute($transaction, $status)
    {
        $invoice = $transaction->owner;
        $packingList = $invoice->owner;

        $proceed = $this->checkAmountPaidVSRequired($transaction);
        if(!$proceed) return false;

        $this->updatesTransactionStatus->execute($transaction, $status);

        // check if is wallet top up
        if ($transaction->owner instanceof Wallet && $status === ApprovalStatus::APPROVED) {

            $this->updatesWalletBalance->execute($transaction->owner, $transaction->amount);

            $group = Group::where('reference', $transaction->payment_reference)->first();

            // check if is group payment
            if ($group) {
                foreach ($group->groupTransactions as $groupTransaction) {
                    $invoice = $groupTransaction->transaction;

                    $paymentTransaction = $this->createPaymentTransactionProcessor->execute($invoice, PaymentMethodType::WALLET, null);

                    if($paymentTransaction && $paymentTransaction->status == ApprovalStatus::APPROVED){
                        $pL = $invoice->owner;
                        $this->processPackingListAndInvoice($pL, $invoice);
                    }
                }

                $group->status = $status;
                $group->save();
            }
        }

        if (!$transaction->owner instanceof Wallet) {
            $this->processPackingListAndInvoice($packingList, $invoice);
        }

        return true;
    }

    private function checkAmountPaidVSRequired($transaction){
        //command:check-storage-invoices must already run for this part of the code to work properly
        $group = Group::withTrashed()->where('reference', $transaction->payment_reference)->first();
        if ($group) {
            $totalAmountToBePaid = 0;
            $actualAmountPaid = $transaction->amount;

            foreach ($group->groupTransactions as $groupTransaction) {
                $invoice = $groupTransaction->transaction;
                $totalAmountToBePaid += $invoice->amount;
            }

            if(($totalAmountToBePaid - $actualAmountPaid) < 0.01){

            }
            else{
                Log::channel('storage_invoices')->info('Total amount from current transaction: '.$totalAmountToBePaid); //cief todo: to be removed
                Log::channel('storage_invoices')->info('Total amount from paid transaction: '.$transaction->amount); //cief todo: to be removed
                return false;
            }
        }
        return true;
    }

    private function processPackingListAndInvoice($packingList, $invoice = null){
        $result = false;
        $totalInvoicesAmountPaid = 0.00;
        $totalInvoicesAmount = 0.00;
        $invoiceTransactions = $packingList->transactions()->where('status', [ApprovalStatus::APPROVED])->whereIn('type', [TransactionType::SHIPPING_INVOICE, TransactionType::STORAGE_INVOICE])->get();

        //Part 1: Process each single invoice type and get the total of all invoices
        foreach($invoiceTransactions as $invoiceTransaction){

            $totalInvoiceAmountPaid = $invoiceTransaction->transactions->where('type', TransactionType::PAYMENT)->whereIn('status', [ApprovalStatus::APPROVED, ApprovalStatus::COMPLETED])->sum('amount');
            if ($invoice && $invoice->type == $invoiceTransaction->type) {
                if(($invoice->amount - $totalInvoiceAmountPaid) < 0.01){
                    $this->updatesTransactionStatus->execute($invoice, ApprovalStatus::COMPLETED);

                    if($invoice->type == TransactionType::STORAGE_INVOICE){
                        $this->ceateStorageInvoiceDocTransactionProcessor->execute($packingList);
                    }
                }
            }

            $totalInvoicesAmount = $totalInvoicesAmount + $invoiceTransaction->amount;
            $totalInvoicesAmountPaid = $totalInvoicesAmountPaid + $totalInvoiceAmountPaid;
        }

        Log::channel('storage_invoices')->info('Total invoice amount paid 1: '.$totalInvoicesAmount); //cief todo: to be removed
        Log::channel('storage_invoices')->info('Total invoice amount paid 2: '.$totalInvoicesAmountPaid); //cief todo: to be removed

        //Part 2: Based on the collected info for all the total of all invoices
        if (($totalInvoicesAmount - $totalInvoicesAmountPaid) < 0.01) {
            Log::channel('storage_invoices')->info('Total invoice amount paid 3: '.$totalInvoicesAmountPaid); //cief todo: to be removed

            $packingList->status = ApprovalStatus::APPROVED;
            $packingList->save();

            if (app()->environment('production')) {
                $this->updateDoFromVTPortalProcessor->execute($packingList);
                $this->updateDoFromYDPortalProcessor->execute($packingList);
            }

            $result = true;
        }

        return $result;
    }
}