Admin

name	type	size	perms	modified	actions
[parent directory]
CacheHelper.php	file	2,837 B	0664	2026-06-08 06:46:36	edit
GlobalHelper.php	file	9,236 B	0664	2026-09-14 10:34:26	edit

editing: GlobalHelper.php

<?php

namespace App\Helpers;
use App\Models\WalletHistory;
use App\Models\MainWallet;
use App\Models\Campaign; // fix error duplicate campaign
use App\Models\Invoice;
use App\Models\CampaignOrder;
use Carbon\Carbon;

class GlobalHelper
{
    public static function formatDate($date, $format = 'Y-m-d')
    {
        return \Carbon\Carbon::createFromFormat($format, $date);
    }

protected static $excelToDateCache = [];

public static function excel_to_date($value, $format = 'Y-m-d')
    {
        if ($value === null) {
            return null;
        }

$trimmed = trim((string)$value);
        if ($trimmed === '' || $trimmed === '-' || strtolower($trimmed) === 'n/a') {
            return null;
        }

$cacheKey = $trimmed . '_' . $format;
        if (array_key_exists($cacheKey, self::$excelToDateCache)) {
            return self::$excelToDateCache[$cacheKey];
        }

if (is_numeric($trimmed)) {
            // Excel serial date starts from 1900-01-01
            // 25569 is the number of days between 1900-01-01 and 1970-01-01
            $unix_date = ((float)$trimmed - 25569) * 86400;
            try {
                $result = \Carbon\Carbon::createFromTimestamp($unix_date)->format($format);
                self::$excelToDateCache[$cacheKey] = $result;
                return $result;
            } catch (\Exception $e) {
                self::$excelToDateCache[$cacheKey] = null;
                return null;
            }
        }

try {
            $result = \Carbon\Carbon::parse($trimmed)->format($format);
            self::$excelToDateCache[$cacheKey] = $result;
            return $result;
        } catch (\Exception $e) {
            self::$excelToDateCache[$cacheKey] = null;
            return null;
        }
    }

public static function maybe_serialize($value)
    {
        if (is_array($value) || is_object($value)) {
            return json_encode($value);
        }
        return $value;
    }

public static function maybe_unserialize($value)
    {
        if (is_string($value)) {
            $decoded = json_decode($value, true);
            if (json_last_error() === JSON_ERROR_NONE) {
                return $decoded;
            }
        }
        return $value;
    }

public static function number_to_roman($number)
    {
        $map = [
            'M' => 1000,
            'CM' => 900,
            'D' => 500,
            'CD' => 400,
            'C' => 100,
            'XC' => 90,
            'L' => 50,
            'XL' => 40,
            'X' => 10,
            'IX' => 9,
            'V' => 5,
            'IV' => 4,
            'I' => 1
        ];
        $returnValue = '';
        while ($number > 0) {
            foreach ($map as $roman => $int) {
                if ($number >= $int) {
                    $number -= $int;
                    $returnValue .= $roman;
                    break;
                }
            }
        }
        return $returnValue;
    }

public static function createWalletHistory($subject_type, $subject_id, $subject_name, $subject_wallet_code, $transaction_type, $amount, $status = 1, $disbursement_request_id = null)
    {
        $maxQ = WalletHistory::whereDate('created_at', date('Y-m-d'))
            ->max('transaction_number');
        $wallet_history_number = !empty($maxQ) ? ($maxQ + 1) : 1;
        $wallet_history_date = Carbon::now();

// Build data
        $authUser = \Auth::user();
        $data_wallet_history = [
            'uuid' => \Str::uuid(),
            'subject_type' => $subject_type,
            'subject_id' => $subject_id,
            'subject_name' => $subject_name,
            'subject_wallet_code' => $subject_wallet_code,
            'transaction_code' => date('y/m/d', strtotime($wallet_history_date)) . '/' . str_pad($wallet_history_number, 3, '0', STR_PAD_LEFT),
            'transaction_number' => $wallet_history_number,
            'transaction_type' => $transaction_type,
            'amount' => $amount,
            'status' => $status ?? 1,
            'disbursement_request_id' => $disbursement_request_id,
            'created_id' => $authUser?->id,
            'created_name' => $authUser?->name,
            'updated_id' => $authUser?->id,
            'updated_name' => $authUser?->name,
        ];

$walet_history = WalletHistory::create($data_wallet_history);

// Auto sync if subject is campaign
        if ($subject_type == 'campaign') {
            $campaign = Campaign::find($subject_id);
            if ($campaign) {
                // 1. Reconcile Achievement from Invoices (Credits)
                $achievement = 0;
                $orderIds = CampaignOrder::where('campaign_id', $campaign->id)->pluck('id')->toArray();
                switch ($campaign->type) {
                    case 'rutin':
                    case 'patungan':
                    case 'nafi_peduli':
                        // Direct linkage
                        $achievement = Invoice::where('status', 3) // Paid
                            ->where('reference_type', 'nafi_peduli')
                            ->whereIn('reference_id', $orderIds)
                            ->sum('invoice_value');
                        break;
                    default:
                        // Indirect linkage via CampaignOrder
                        $achievement = Invoice::where('status', 3) // Paid
                            ->whereIn('reference_id', $orderIds)
                            ->whereIn('reference_type', $campaign->type)
                            ->sum('invoice_value');
                        break;
                }

// 2. Reconcile Disbursed from Wallet History (Debits)
                $disbursed = WalletHistory::where('subject_type', 'campaign')
                    ->where('subject_id', $campaign->id)
                    ->where('transaction_type', 'debit')
                    ->where('status', 1)
                    ->sum('amount');

$campaign->update([
                    'donation_achievement' => (float) $achievement,
                    'donation_disbursed' => (float) $disbursed,
                ]);
            }
        }

$totalCredit = WalletHistory::where('transaction_type', 'credit')->sum('amount');
        $totalDebit = WalletHistory::where('transaction_type', 'debit')->sum('amount');

//main wallet
        MainWallet::updateOrCreate(
            ['id' => 1],
            [
                'total_in' => $totalCredit,
                'total_out' => $totalDebit
            ]
        );

return $walet_history;
    }

/**
     * Sync meta data for a model.
     * Deletes existing meta keys that are not present in provided data, 
     * unless they are protected.
     *
     * @param \Illuminate\Database\Eloquent\Model $model
     * @param array $metaData
     * @param array $protectedKeys
     * @return void
     */
    public static function syncMetas($model, array $metaData, array $protectedKeys = [])
    {
        // If model is User, protect vital profile meta keys from being deleted during partial meta updates
        if ($model instanceof \App\Models\User || (method_exists($model, 'getTable') && $model->getTable() === 'users')) {
            $userProfileKeys = ['keycloak_id', 'city', 'province', 'district', 'address', 'postal_code', 'media', 'gender', 'birth_date', 'wag', 'bio'];
            $protectedKeys = array_unique(array_merge($protectedKeys, $userProfileKeys));
        }

$newKeys = array_keys($metaData);

// Log if city is explicitly updated via metaData
        if (array_key_exists('city', $metaData)) {
            $oldCity = $model->metas()->where('meta_key', 'city')->first()?->meta_value;
            \Illuminate\Support\Facades\Log::info("GlobalHelper::syncMetas UPDATING CITY for Model #{$model->id}:", [
                'old_city' => $oldCity,
                'new_city' => $metaData['city'],
                'caller' => debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 3)
            ]);
        }

// Update or Create
        foreach ($metaData as $key => $value) {
            $model->metas()->updateOrCreate(
                ['meta_key' => $key],
                ['meta_value' => self::maybe_serialize($value)]
            );
        }

// Delete keys not in the new metaData, excluding protected ones
        $query = $model->metas()->whereNotIn('meta_key', $newKeys);
        if (!empty($protectedKeys)) {
            $query->whereNotIn('meta_key', $protectedKeys);
        }

// Log if city is about to be deleted
        if (method_exists($model, 'getTable') && $model->getTable() === 'users') {
            $keysToDelete = (clone $query)->pluck('meta_key')->toArray();
            if (in_array('city', $keysToDelete)) {
                \Illuminate\Support\Facades\Log::warning("ALERT: GlobalHelper::syncMetas WOULD DELETE META CITY for User #{$model->id}!", [
                    'new_keys_passed' => $newKeys,
                    'protected_keys' => $protectedKeys,
                    'trace' => debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS, 4)
                ]);
            }
        }

$query->delete();
    }
}

cancel