webstatement/app/Http/Controllers/PrintStatementController.php

<?php

    namespace Modules\Webstatement\Http\Controllers;

    use App\Http\Controllers\Controller;
    use Illuminate\Http\Request;
    use Illuminate\Support\Facades\Auth;
    use Modules\Webstatement\Http\Requests\PrintStatementRequest;
    use Modules\Webstatement\Models\PrintStatementLog;
    use Modules\Basicdata\Models\Branch;

    class PrintStatementController extends Controller
    {
        /**
         * Display a listing of the statements.
         */
        public function index(Request $request)
        {
            $branches = Branch::orderBy('name')->get();

            return view('webstatement::statements.index', compact('branches'));
        }

        /**
         * Show the form for creating a new statement request.
         */
        public function create()
        {
            $branches = Branch::orderBy('name')->get();
            return view('webstatement::statements.create', compact('branches',));
        }

        /**
         * Store a newly created statement request.
         */
        public function store(PrintStatementRequest $request)
        {
            $validated = $request->validated();

            // Add user tracking data
            $validated['user_id'] = Auth::id();
            $validated['created_by'] = Auth::id();
            $validated['ip_address'] = $request->ip();
            $validated['user_agent'] = $request->userAgent();

            // Create the statement log
            $statement = PrintStatementLog::create($validated);

            // Process statement availability check (this would be implemented based on your system)
            $this->checkStatementAvailability($statement);

            return redirect()->route('webstatement.statements.show', $statement->id)
                             ->with('success', 'Statement request has been created successfully.');
        }

        /**
         * Display the specified statement.
         */
        public function show(PrintStatementLog $statement)
        {
            $statement->load(['user', 'branch', 'creator', 'authorizer']);
            return view('webstatement::statements.show', compact('statement'));
        }

        /**
         * Download the statement if available and authorized.
         */
        public function download(PrintStatementLog $statement)
        {
            // Check if statement is available and authorized
            if (!$statement->is_available) {
                return back()->with('error', 'Statement is not available for download.');
            }

            if ($statement->authorization_status !== 'approved') {
                return back()->with('error', 'Statement download requires authorization.');
            }

            // Update download status
            $statement->update([
                'is_downloaded' => true,
                'downloaded_at' => now(),
                'updated_by' => Auth::id()
            ]);

            // Generate or fetch the statement file (implementation depends on your system)
            $filePath = $this->generateStatementFile($statement);

            // Return file download response
            return response()->download($filePath, $this->generateFileName($statement));
        }

        /**
         * Authorize a statement request.
         */
        public function authorize(Request $request, PrintStatementLog $statement)
        {
            $request->validate([
                'authorization_status' => ['required', Rule::in(['approved', 'rejected'])],
                'remarks' => ['nullable', 'string', 'max:255'],
            ]);

            // Update authorization status
            $statement->update([
                'authorization_status' => $request->authorization_status,
                'authorized_by' => Auth::id(),
                'authorized_at' => now(),
                'remarks' => $request->remarks,
                'updated_by' => Auth::id()
            ]);

            $statusText = $request->authorization_status === 'approved' ? 'approved' : 'rejected';

            return redirect()->route('webstatement.statements.show', $statement->id)
                             ->with('success', "Statement request has been {$statusText} successfully.");
        }

        /**
         * Check if the statement is available in the system.
         * This is a placeholder method - implement according to your system.
         */
        protected function checkStatementAvailability(PrintStatementLog $statement)
        {
            // This would be implemented based on your system's logic
            // For example, checking an API or database for statement availability

            // Placeholder implementation - set to available for demo
            $statement->update([
                'is_available' => true,
                'updated_by' => Auth::id()
            ]);
        }

        /**
         * Generate or fetch the statement file.
         * This is a placeholder method - implement according to your system.
         */
        protected function generateStatementFile(PrintStatementLog $statement)
        {
            // This would be implemented based on your system's logic
            // For example, calling an API to generate a PDF or fetching from storage

            // Placeholder implementation - return a dummy path
            $tempFile = tempnam(sys_get_temp_dir(), 'statement_');
            file_put_contents($tempFile, 'Statement content would go here');
            return $tempFile;
        }

        /**
         * Generate a filename for the statement download.
         */
        protected function generateFileName(PrintStatementLog $statement)
        {
            $accountNumber = $statement->account_number;

            if ($statement->is_period_range) {
                return "statement_{$accountNumber}_{$statement->period_from}_to_{$statement->period_to}.pdf";
            }

            return "statement_{$accountNumber}_{$statement->period_from}.pdf";
        }

        /**
         * Provide data for datatables.
         */
        public function dataForDatatables(Request $request)
        {
            // Check permissions if needed
            // if (!auth()->user()->can('view_statements')) {
            //     abort(403, 'Sorry! You are not allowed to view statements.');
            // }

            // Retrieve data from the database
            $query = PrintStatementLog::query();

            // Apply search filter if provided
            if ($request->has('search') && !empty($request->get('search'))) {
                $search = $request->get('search');
                $query->where(function ($q) use ($search) {
                    $q->where('account_number', 'LIKE', "%$search%")
                      ->orWhere('branch_code', 'LIKE', "%$search%")
                      ->orWhere('period_from', 'LIKE', "%$search%")
                      ->orWhere('period_to', 'LIKE', "%$search%")
                      ->orWhere('authorization_status', 'LIKE', "%$search%");
                });
            }

            // Apply column filters if provided
            if ($request->has('filters') && !empty($request->get('filters'))) {
                $filters = json_decode($request->get('filters'), true);

                foreach ($filters as $filter) {
                    if (!empty($filter['value'])) {
                        if ($filter['column'] === 'branch_code') {
                            $query->where('branch_code', $filter['value']);
                        } elseif ($filter['column'] === 'authorization_status') {
                            $query->where('authorization_status', $filter['value']);
                        } elseif ($filter['column'] === 'is_downloaded') {
                            $query->where('is_downloaded', filter_var($filter['value'], FILTER_VALIDATE_BOOLEAN));
                        }
                    }
                }
            }

            // Apply sorting if provided
            if ($request->has('sortOrder') && !empty($request->get('sortOrder'))) {
                $order = $request->get('sortOrder');
                $column = $request->get('sortField');

                // Map frontend column names to database column names if needed
                $columnMap = [
                    'branch' => 'branch_code',
                    'account' => 'account_number',
                    'period' => 'period_from',
                    'status' => 'authorization_status',
                    // Add more mappings as needed
                ];

                $dbColumn = $columnMap[$column] ?? $column;
                $query->orderBy($dbColumn, $order);
            } else {
                // Default sorting
                $query->latest('created_at');
            }

            // Get the total count of records
            $totalRecords = $query->count();

            // Apply pagination if provided
            if ($request->has('page') && $request->has('size')) {
                $page = $request->get('page');
                $size = $request->get('size');
                $offset = ($page - 1) * $size; // Calculate the offset

                $query->skip($offset)->take($size);
            }

            // Get the filtered count of records
            $filteredRecords = $query->count();

            // Eager load relationships to avoid N+1 query problems
            $query->with(['user', 'branch', 'authorizer']);

            // Get the data for the current page
            $data = $query->get()->map(function ($item) {
                // Transform data for frontend if needed
                return [
                    'id' => $item->id,
                    'branch_code' => $item->branch_code,
                    'branch_name' => $item->branch->name ?? 'N/A',
                    'account_number' => $item->account_number,
                    'period_from' => $item->period_from,
                    'period_to' => $item->is_period_range ? $item->period_to : null,
                    'authorization_status' => $item->authorization_status,
                    'is_available' => $item->is_available,
                    'is_downloaded' => $item->is_downloaded,
                    'created_at' => $item->created_at->format('Y-m-d H:i:s'),
                    'created_by' => $item->user->name ?? 'N/A',
                    'authorized_by' => $item->authorizer ? $item->authorizer->name : null,
                    'authorized_at' => $item->authorized_at ? $item->authorized_at->format('Y-m-d H:i:s') : null,
                ];
            });

            // Calculate the page count
            $pageCount = ceil($filteredRecords / ($request->get('size') ?: 1));

            // Calculate the current page number
            $currentPage = $request->get('page') ?: 1;

            // Return the response data as a JSON object
            return response()->json([
                'draw' => $request->get('draw'),
                'recordsTotal' => $totalRecords,
                'recordsFiltered' => $filteredRecords,
                'pageCount' => $pageCount,
                'page' => $currentPage,
                'totalCount' => $totalRecords,
                'data' => $data,
            ]);
        }
    }