portal-api/app/Http/Controllers/Api/Admin/Order/OrderController.php

<?php

namespace App\Http\Controllers\Api\Admin\Order;

use App\Http\Controllers\Controller;
use App\Http\Requests\OrderRequest;
use App\Http\Requests\UpdateOrderRequest;
use App\Exports\BrandedReportWriter;
use App\Http\Requests\BillingExportRequest;
use App\Exports\OrdersExport;
use App\Http\Resources\Api\Admin\OrderItemServiceResource;
use App\Http\Resources\Api\Admin\OrderResource;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use App\Models\Order;
use App\Models\DomainPricing;
use App\Repositories\Order\OrderRepositoryInterface;
use App\Services\OrderService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;

class OrderController extends Controller
{
    public function __construct(
        private readonly OrderRepositoryInterface $orderRepository,
        private readonly OrderService $orderService,
    ) {}

    public function index(Request $request): JsonResponse
    {
        $perPage = min((int) $request->get('per_page', 15), 100);

        $data = $this->orderRepository->filter(
            $request->all(),
            [
                'payment',
                'customer',
                'invoice',
                'orderItems.os',
                ...OrderItemServiceResource::relationsFor('orderItems'),
                'tags',
            ],
            [],
            ['*'],
            true
        )->paginate($perPage);

        return response()->json([
            'error' => false,
            'data' => [
                'items' => OrderResource::collection($data->items())->resolve(),
                'total' => $data->total(),
                'per_page' => $data->perPage(),
            ],
        ]);
    }

    public function export(BillingExportRequest $request, BrandedReportWriter $writer): BinaryFileResponse
    {
        $query = $this->orderRepository->filter(
            array_filter($request->validated(), fn ($value) => $value !== null && $value !== []),
            ['payment', 'customer', 'invoices:id,order_id,invoice_number', ...OrderItemServiceResource::relationsFor('orderItems')],
            [],
            ['*'],
            true
        );

        return $writer->download(new OrdersExport($query), 'don-hang-' . now()->format('Y-m-d-His') . '.xlsx');
    }

    public function domainPricing(): JsonResponse
    {
        return response()->json([
            'error' => false,
            'data' => DomainPricing::toResponseArray(),
        ]);
    }

    public function store(OrderRequest $request): JsonResponse
    {
        try {
            $order = $this->orderService->createOrder($request->validated());

            return response()->json([
                'error' => false,
                'message' => 'Order created successfully',
                'data' => new OrderResource($order),
            ], 201);
        } catch (\InvalidArgumentException $e) {
            return response()->json(['error' => true, 'message' => $e->getMessage()], 422);
        } catch (\Exception $e) {
            return response()->json(['error' => true, 'message' => $e->getMessage()], 500);
        }
    }

    public function show(string $order_num): JsonResponse
    {
        $order = $this->orderRepository->findByOrderNum($order_num);

        abort_if(!$order, 404, "Can't find order by ID #{$order_num}");

        return response()->json([
            'error' => false,
            'data' => new OrderResource($order),
        ]);
    }

    public function update(int $id, UpdateOrderRequest $request): JsonResponse
    {
        $order = $this->orderRepository->findWithRelationships($id, ['invoice', 'orderItem']);

        abort_if(!$order, 404, "Can't find order by ID #{$id}");

        match ($request->action) {
            'accept' => $this->orderService->confirmOrder($order, (bool) $request->module),
            'cancel' => $this->orderService->setStatus($order, 2),
            default => $this->orderService->setStatus($order, 0),
        };

        return response()->json(['error' => false, 'message' => 'Order updated successfully']);
    }

    public function destroy(int $id): JsonResponse
    {
        $order = Order::with('invoice', 'invoice.invoiceItems')->find($id);

        abort_if(!$order, 404, "Can't find order by ID #{$id}");

        $this->orderService->deleteOrder($order);

        return response()->json(['error' => false, 'message' => 'Order deleted successfully']);
    }

    public function accept(int $id): JsonResponse
    {
        $order = $this->orderRepository->find($id);

        abort_if(!$order, 404, "Can't find order by ID #{$id}");

        $this->orderService->setStatus($order, 1);

        return response()->json(['error' => false, 'message' => 'Order accepted successfully']);
    }

    public function cancel(int $id): JsonResponse
    {
        $order = $this->orderRepository->find($id);

        abort_if(!$order, 404, "Can't find order by ID #{$id}");

        $this->orderService->setStatus($order, 2);

        return response()->json(['error' => false, 'message' => 'Order cancelled successfully']);
    }

    public function uploadProof(Request $request): JsonResponse
    {
        $request->validate(['file' => 'required|image|max:5120']);

        $path = $request->file('file')->store('payment-proofs', 'public');

        return response()->json([
            'error' => false,
            'url'   => Storage::disk('public')->url($path),
            'path'  => $path,
        ]);
    }
}