Admin

name	type	size	perms	modified	actions
[parent directory]
AuthService.php	file	2,727 B	0664	2024-12-17 03:56:58	edit
ImportService.php	file	3,616 B	0664	2023-06-12 16:42:06	edit
OrderService.php	file	60,462 B	0664	2026-05-27 19:51:48	edit
QurbanPlusMainWebService.php	file	11,417 B	0664	2026-04-27 10:05:38	edit
QurbanPlusResellerService.php	file	18,579 B	0664	2026-05-22 08:37:59	edit
QurbanService.php	file	62,504 B	0664	2026-05-29 02:34:06	edit
ScheduleMatcher.php	file	5,344 B	0664	2026-05-25 15:23:15	edit

editing: QurbanPlusResellerService.php

<?php

namespace App\Services;

use App\Domain\MessageData;
use App\Jobs\GenerateQRJob;
use App\Models\Order;
use App\Models\Qurban;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Log;

class QurbanPlusResellerService
{
    protected string $baseUrl;
    protected ?string $token = null;
    protected $command;
    protected MessageData $objMsg;

public function __construct($command = null)
    {
        $this->baseUrl = config('services.reseller.api_url');
        $this->command = $command;
        $this->objMsg = new MessageData();

try {
            $this->autoLogin();
        } catch (\Exception $e) {
            Log::error('Failed to initialize QurbanPlus service: '.$e->getMessage());
            throw new \Exception('Failed to initialize QurbanPlus service: '.$e->getMessage());
        }
    }

protected function autoLogin(): void
    {
        $email = config('services.reseller.email');
        $password = config('services.reseller.password');

if (empty($email) || empty($password)) {
            throw new \Exception('QurbanPlus credentials not configured');
        }

Log::info("Attempting auto-login with email: $email");

try {
            $response = Http::withoutVerifying()
                ->post("{$this->baseUrl}/api/login", [
                    'email' => $email,
                    'password' => $password,
                ]);

$responseData = $response->json();
            $result = $responseData['result'];

if ($response->successful() && isset($result['api_token'])) {
                $this->token = $result['api_token'];
                Log::info('Auto-login successful');
            } else {
                $error = $result['message'] ?? 'Unknown error';
                throw new \Exception("Login failed: $error");
            }
        } catch (\Exception $e) {
            Log::error('Auto-login request failed: '.$e->getMessage());
            throw new \Exception('Auto-login request failed: '.$e->getMessage());
        }
    }

protected function ensureValidToken(): void
    {
        if (empty($this->token)) {
            $this->autoLogin();
        }
    }

public function getOrders(?string $startDate = null, ?string $endDate = null, ?string $orderNo = null): MessageData
    {
        try {
            $this->ensureValidToken();

$query = array_filter([
                'startdate' => $startDate,
                'enddate' => $endDate,
                'order_no' => $orderNo,
                'format' => 'datetime',
            ]);

Log::info('Fetching orders'.($startDate ? " from $startDate" : '').($endDate ? " to $endDate" : '').($orderNo ? " order_no: $orderNo" : ''));
            // dd($query);
            $response = Http::withoutVerifying()
                ->withToken($this->token)
                ->get("{$this->baseUrl}/api/orders/all/created_at", $query);

$responseData = $response->json();

if ($response->successful()) {
                $orderCount = count($responseData['data'] ?? []);

$this->objMsg->status = true;
                $this->objMsg->message = 'Orders retrieved successfully';
                Log::info("Successfully retrieved $orderCount orders");
                $this->objMsg->data = $responseData;
            } else {
                $this->objMsg->status = false;
                $errorMessage = is_array($responseData)
                    ? ($responseData['message'] ?? json_encode($responseData))
                    : 'Unknown error';
                $this->objMsg->message = 'Failed to get orders: '.$errorMessage;
                Log::error('Failed to get orders: '.$errorMessage);
            }
        } catch (\Exception $e) {
            $this->objMsg->status = false;
            $this->objMsg->message = 'Failed to get orders: '.$e->getMessage();
            Log::error('Error getting orders: '.$e->getMessage());
        }

return $this->objMsg;
    }

/**
     * Check if the service is properly authenticated.
     */
    public function isAuthenticated(): bool
    {
        return !empty($this->token);
    }

/**
     * Force a new login (useful if token expires).
     */
    public function refreshLogin(): void
    {
        $this->token = null;
        $this->autoLogin();
    }

public function upsertResellerOrder(array $resellerOrder): MessageData
    {
        $orderData = self::mapResellerOrder($resellerOrder);
        $message = new MessageData();
        \DB::beginTransaction();
        try {
            $order = Order::where('code', $resellerOrder['order_no'])->first();
            if ($order) {
                $order->update($orderData);
                $message->code = 201;
            } else {
                $order = Order::create($orderData);
                $message->code = 200;
            }

$item_ids = [];
            foreach ($resellerOrder['items'] as $item) {
                $item_ids[] = $item['id'];
            }

// Archive not existing items
            $this->archiveOrderItems($order, $item_ids);

// Process items
            foreach ($resellerOrder['items'] as $item) {
                $orderItemData = self::mapResellerOrderItem($item);
                $orderItemDetailData = self::mapResellerOrderItemDetail($item, $order['id']);

$orderItem = $order->items()->where('external_id', $item['id'])->first();
                if ($orderItem) {
                    $orderItem->update($orderItemData);
                } else {
                    $orderItem = $order->items()->firstOrCreate($orderItemData);
                }

// Create detail
                $existingDetail = $orderItem->details()->where('external_id', $item['id'])->first();

if ($existingDetail) {
                    $existingDetail->update($orderItemDetailData);
                    $this->syncLinkedQurbanItemData($existingDetail, $orderItemData);
                } else {
                    $orderItem->details()->create($orderItemDetailData);
                }
            }

\DB::commit();
            $message->message = 'success';
            $message->data = $order;
        } catch (\Exception $e) {
            \DB::rollBack();
            Log::error('Failed to insert order: '.$e->getMessage());
            $message->code = 500;
            $message->status = false;
            $message->message = $e->getMessage();
            $message->data = $e->getMessage();
        }

return $message;
    }

private function syncLinkedQurbanItemData($orderItemDetail, array $orderItemData): void
    {
        if (!$orderItemDetail->qurban_id) {
            return;
        }

$qurban = Qurban::find($orderItemDetail->qurban_id);
        if (!$qurban) {
            return;
        }

$orderItemCategory = mb_strtoupper(trim((string) ($orderItemData['category'] ?? '')));
        $qurbanCategory = mb_strtoupper(trim((string) ($qurban->category ?? '')));

if ($orderItemCategory === '' || $orderItemCategory !== $qurbanCategory) {
            return;
        }

$qurban->update([
            'name' => $orderItemData['item'] ?? $qurban->name,
            'variant' => $orderItemData['variant'] ?? $qurban->variant,
        ]);
    }

public function syncOrders(?string $startDate = null, ?string $endDate = null, ?string $orderNo = null): MessageData
    {
        $objMsg = new MessageData();

try {
            $startDate = $startDate ?? now()->subDay()->format('Y-m-d 00:00:00');
            $endDate = $endDate ?? now()->format('Y-m-d 23:59:59');

$ordersResult = $this->getOrders($startDate, $endDate, $orderNo);
            if (!$ordersResult->status) {
                return $ordersResult;
            }

$successCount = 0;
            $failedCount = 0;
            $updatedCount = 0;
            $errors = [];
            $processedOrders = [];

foreach ($ordersResult->data['result'] ?? [] as $resellerOrder) {
                $result = $this->upsertResellerOrder($resellerOrder);
                if ($result->status) {
                    if ($result->code == 201) {
                        ++$updatedCount;
                    } else {
                        ++$successCount;
                    }
                    $processedOrders[] = $result->data;
                } else {
                    ++$failedCount;
                    $errors[] = $result->message;
                }
            }

$objMsg->status = true;
            $objMsg->message = "Sync completed. Success: $successCount, Failed: $failedCount, Updated: $updatedCount";
            $objMsg->data = [
                'success_count' => $successCount,
                'failed_count' => $failedCount,
                'updated_count' => $updatedCount,
                'errors' => $errors,
                'date_range' => [
                    'start' => $startDate,
                    'end' => $endDate,
                    'order_no' => $orderNo,
                ],
                'orders' => $processedOrders,
            ];

(new OrderService())->syncQurban();
            GenerateQRJob::dispatch('order')->afterCommit();
        } catch (\Exception $e) {
            $objMsg->status = false;
            $objMsg->message = 'Sync failed: '.$e->getMessage();
            Log::error('Reseller sync error: '.$e->getMessage(), [
                'start_date' => $startDate,
                'end_date' => $endDate,
                'order_no' => $orderNo,
            ]);
        }

return $objMsg;
    }

private function archiveOrderItems(Order $order, array $item_ids)
    {
        // Archive and delete items not in the current sync
        $itemsToArchive = $order->items()->whereNotIn('external_id', $item_ids)->get();
        foreach ($itemsToArchive as $item) {
            // Archive the item
            \DB::table('order_items_archive')->insert([
                'id' => $item->id,
                'order_id' => $item->order_id,
                'category' => $item->category,
                'item' => $item->item,
                'variant' => $item->variant,
                'qty' => $item->qty,
                'created_at' => $item->created_at,
                'updated_at' => $item->updated_at,
                'deleted_at' => now(),
                'qurban_name' => $item->qurban_name,
                'delivery' => $item->delivery,
                'delivery_address' => $item->delivery_address,
                'delivery_district' => $item->delivery_district,
                'delivery_sub_district' => $item->delivery_sub_district,
                'qurban_process' => $item->qurban_process,
                'presence' => $item->presence,
                'qurban_date' => $item->qurban_date,
                'note' => $item->note,
                'external_id' => $item->external_id,
//                 comment fix error sync
//                 'qurban_phone' => $item->qurban_phone,
//                 'delivery_notice' => $item->delivery_notice,
//                 'receiver_name' => $item->receiver_name,
//                 'receiver_phone' => $item->receiver_phone,
                'delivery_entrust_type' => $item->delivery_entrust_type,
//                 'type' => $item->type,
            ]);

// Archive associated details
            $details = $item->details()->get();
            foreach ($details as $detail) {
                \DB::table('order_item_details_archive')->insert([
                    'id' => $detail->id,
                    'order_item_id' => $detail->order_item_id,
                    'qurban_code' => $detail->qurban_code,
                    'created_at' => $detail->created_at,
                    'updated_at' => $detail->updated_at,
                    'order_item_group_id' => $detail->order_item_group_id,
                    'qurban_id' => $detail->qurban_id,
                    'qurban_name' => $detail->qurban_name,
                    'delivery' => $detail->delivery,
                    'delivery_address' => $detail->delivery_address,
                    'delivery_district' => $detail->delivery_district,
                    'delivery_sub_district' => $detail->delivery_sub_district,
                    'delivery_province' => $detail->delivery_province,
//                     'delivery_postal_code' => $detail->delivery_postal_code,
                    'qurban_process' => $detail->qurban_process,
                    'presence' => $detail->presence,
                    'qurban_date' => $detail->qurban_date,
                    'note' => $detail->note,
                    'order_id' => $detail->order_id,
                    'city' => $detail->city,
                    'notice' => $detail->notice,
                    // Archive metadata
                    'archived_at' => now(),
                    'original_id' => $detail->id,
                    'archive_reason' => 'Parent order item removed during QurbanPlus sync',
                ]);

// Delete the detail
                $detail->delete();
            }
        }

// Now delete the items
        $order->items()->whereNotIn('external_id', $item_ids)->delete();
    }

/**
     * Map QurbanPlus specific order data.
     */
    private static function mapResellerOrder(array $resellerOrder): array
    {
        $referrer = $resellerOrder['referrer'];
        $source = 'RESELLER';
        foreach ($resellerOrder['items'] ?? [] as $item) {
            if (!empty($item['product_category']) && stripos($item['product_category'], 'titip') !== false) {
                $source = 'TITIP';
                break;
            }
        }

return [
            'code' => $resellerOrder['order_no'],
            'period_id' => current_period()?->id,
            'cust_name' => $referrer['name'] ?? 'not-found',
            'cust_email' => $referrer['email'] ?? '',
            'cust_phone' => $referrer['phone_no'] ?? '081234567890',
            'total_qty' => 1,
            'order_date' => $resellerOrder['created_at'],
            'source' => $source,
            'note' => $resellerOrder['notes'] ?: null,
        ];
    }

/**
     * Map QurbanPlus specific order item data.
     */
    private static function mapResellerOrderItem(array $item): array
    {
        return [
            'external_id' => $item['id'],
            'category' => trim(str_ireplace('TITIP', '', $item['product_category'])),
            'item' => $item['product_name'],
            'qty' => 1,
            'variant' => $item['price'],
            'qurban_name' => $item['customer_name'],
            'note' => $item['notes'] ?? null,   // catatan kurir : pengiriman hidup (alamat dll)
        ];
    }

/**
     * Map QurbanPlus specific order item detail data.
     */
    private static function mapResellerOrderItemDetail(array $item, int $orderId): array
    {
        return [
            'external_id' => $item['id'],
            'qurban_name' => $item['customer_name'],
            'qurban_phone' => $item['customer_phone'],
            'order_id' => $orderId,
            'delivery' => self::mapResellerDeliveryType($item['distribute_type'], $item['type'], $item['delivery_entrust_type'] ?? null),
            'delivery_address' => $item['receiver_address'] ?? null,            
            'city' => $item['receiver_city'] ?? null,
            'delivery_district' => $item['receiver_district'] ?? null,
            'delivery_sub_district' => $item['receiver_urban_village'] ?? null,
            'delivery_province' => $item['receiver_province'] ?? null,
            'delivery_postal_code' => $item['receiver_postal_code'] ?? null,
            'delivery_province' => $item['receiver_province'] ?? null,            
            'qurban_process' => self::mapProcessingType($item['processing_type']),
            'presence' => self::mapResellerPresence($item['processing_type']),
            'note' => $item['special_request'] ?? null, // special request pengambilan daging
            'receiver_name' => $item['receiver_name'] ?? null,
            'receiver_phone' => $item['receiver_phone'] ?? null,
            'delivery_entrust_type' => $item['delivery_entrust_type'] ?? null,
            'type' => $item['type'] ?? null,  // kirim hidup / sembelih di lokasi
            'delivery_notice' => $item['delivery_notice'] ?? null, // catatan pengiriman hidup  H-1/H-2
        ];
    }

private static function mapProcessingType(?string $type): ?string
    {
        return match ($type) {
            'Diwakilkan Panitia' => 'Diwakilkan oleh team QurbanPlus',
            // 'Sembelih Sendiri' => 'Sembelih sendiri (dipandu dengan tenaga ahli)',
            // 'Diwakilkan Keluarga' => 'Diwakilkan oleh keluarga (dipandu dengan tenaga ahli)',
            'Sembelih Sendiri Atau Keluarga' => 'Sembelih Sendiri Atau Keluarga (dipandu dengan tenaga ahli)',
            default => null
        };
    }

private static function mapResellerPresence(string $type): string
    {
        return match ($type) {
            'Diwakilkan Keluarga' => 'HADIR',
            'Diwakilkan Panitia' => 'TIDAK HADIR',
            // 'Sembelih Sendiri' => 'HADIR',
            'Sembelih Sendiri Atau Keluarga' => 'HADIR',
            default => 'TIDAK HADIR'
        };
    }

private static function mapResellerType(?string $type): ?string
    {
        return match ($type) {
            'entrus' => 'Sembelih di lokasi',
            'delivery' => 'Kirim Hidup',
            default => 'NONE'
        };
    }

private static function mapResellerDeliveryType(?string $distributeType, ?string $type, ?string $deliveryEntrustType): string
    {
        $delivery = 'NONE';
        if ($distributeType == 'Salurkan Semua') {
            $delivery = 'ALL';
        }
        // elseif ($distributeType == 'Ambil 1/3 Bagian') {
        //      $delivery = 'PARTIAL';
        // }
        // COMMENT FOR TEMP
        elseif ($distributeType == 'Ambil 1/3 Bagian' && $deliveryEntrustType == 'Ambil Di Lokasi') {
            $delivery = 'PARTIAL';
        } elseif ($distributeType == 'Ambil 1/3 Bagian' && $deliveryEntrustType == 'Delivery Ke Rumah') {
            $delivery = 'DELIVERY';
        } elseif ($distributeType == 'Ambil Karkas') {
            $delivery = 'CARCASS';
        } elseif ($type == 'delivery') { // Kirim hidup
            $delivery = 'ALIVE';
        }

return $delivery;
    }
}

cancel