RootZanli & NinjaCr3

: / home / o5t6x7pgljbm / public_html / admin / app / Http / Controllers / Admin /
Filename : DataImportController.php
back
<?php
namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Libraries\FileStorageSystem;
use App\Models\DataImport\ImportProfile ;
use Illuminate\Http\Request;
use App\Models\DataImport\ImportQueueItem;
use App\Models\DataImport\ImportErrorSummary;
use App\Models\DataImport\ImportAdditionalDetail;
use App\V2\BulkOperations\ImportFactories\ImporterFactory;
use Exception;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class DataImportController extends Controller
{
    protected $fileStorageSystem;

    public function __construct()
    {
        $this->fileStorageSystem = app(FileStorageSystem::class);
    }

    public function showImportForm()
    {
        $importProfiles = ImportProfile::all();
        return view('Admin.DataImport.form', compact('importProfiles'));
    }

    public function uploadCsv(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'import_profile_id' => 'required|exists:import_profiles,import_profile_id',
            'csv_file' => 'required|file|mimes:csv,txt|max:10240',
        ]);

        if ($validator->fails()) {
            return response()->json(['errors' => $validator->errors()], 422);
        }
        $importProfile = ImportProfile::find($request->import_profile_id);
        $file = $request->file('csv_file');
        $importer = ImporterFactory::getImporter($importProfile);
        $previewData = null;
        try{
            DB::transaction(function() use($importer, $file){
                $queueItem = $importer->initiate($file);
            });
            $previewData = $importer->getSampleRecords(10);
        }catch(Exception $e){
            Log::error("Message: {$e->getMessage()}, Stack Trace: {$e->getTraceAsString()}");
            $previewData = null;
        }


        $previewHtml = null;
        if($previewData != null){
            // Simulate file processing and return preview data (for simplicity, we'll just return file name here)
            $previewHtml = view('Admin.DataImport.preview', compact('previewData'))->render();
        } else {
            $errorDetails = 'Error Occured';
            $shouldReload = true;
            $previewHtml = view('Admin.DataImport.error-section',compact('errorDetails', 'shouldReload'))->render();
        }

        return response()->json([
            'error' => $previewData == null ? true : false,
            'preview_html' => $previewHtml,
            'import_queue_item_id' => $importer->getImportQueueItem()->import_queue_item_id,
        ]);
    }

    public function validateCsv(Request $request)
    {
        $queueItem = ImportQueueItem::find($request->import_queue_item_id);

        if($queueItem == null){
            $shouldGoBack = true;
            $errorDetails = "Queued Import not found with import_queue_item_id: {$request->import_queue_item_id}";
            return view('Admin.DataImport.error', compact('errorDetails', 'shouldGoBack'));
        }

        // Simulate CSV validation process
        $queueItem->update([
            'current_status' => 'VALIDATION_INPROGRESS',
            'started_at' => now(),
        ]);

        $importProfile = ImportProfile::find($queueItem->import_profile_id);
        $importer = ImporterFactory::getImporter($importProfile);
        $importer->resumeImportQueueItem($queueItem->import_queue_item_id);
        // try{
        //     DB::transaction(function() use($importer){
                $importer->createTempTableAndValidate();
        //     });
        // }catch(Exception $e){
        //     throw $e;
        // }

        // Simulated validation summary
        $validationSummary = [
            'fileName' => $queueItem->uploaded_file_name,
            'tempTableName' => $queueItem->temp_table_name,
            // 'fileSize' => Storage::size($filePath),
            // 'fileType' => Storage::mimeType($filePath),
            'fileSize' => '?',
            'fileType' => '?',
            'totalRecords' => 1000, // Example data
            'errorRecords' => 10,   // Example data
            'successRecords' => 990 // Example data
        ];

        // Update status
        $queueItem->update([
            'current_status' => 'VALIDATION_SUCCESS',
            'finished_at' => now(),
        ]);

        return view('Admin.DataImport.validation_summary', compact('validationSummary', 'queueItem'));
    }

    public function importCsv(Request $request)
    {
        $queueItem = ImportQueueItem::find($request->import_queue_item_id);

        if($queueItem == null){
            $shouldGoBack = true;
            $errorDetails = "Queued Import not found with import_queue_item_id: {$request->import_queue_item_id}";
            return view('Admin.DataImport.error', compact('errorDetails', 'shouldGoBack'));
        }

        $importProfile = ImportProfile::find($queueItem->import_profile_id);
        $importer = ImporterFactory::getImporter($importProfile);
        $importer->resumeImportQueueItem($queueItem->import_queue_item_id);

        // Simulate import process
        $queueItem->update([
            'current_status' => 'IMPORT_INPROGRESS',
            'started_at' => now(),
        ]);

        try{
            DB::transaction(function() use($importer){
                $importer->importToMain();
            });
        }catch(Exception $e){
            throw $e;
        }

        // Simulated import summary
        $importSummary = [
            'fileName' => $queueItem->uploaded_file_name,
            'tempTableName' => $queueItem->temp_table_name,
            // 'fileSize' => Storage::size($filePath),
            // 'fileType' => Storage::mimeType($filePath),
            'fileSize' => '?',
            'fileType' => '?',
            'totalRecords' => 1000, // Example data
            'errorRecords' => 10,   // Example data
            'successRecords' => 990 // Example data
        ];

        // Update status
        $queueItem->update([
            'current_status' => 'IMPORT_SUCCESS',
            'finished_at' => now(),
        ]);

        $queueItem = ImportQueueItem::find($request->import_queue_item_id);

        return view('Admin.DataImport.import_summary', compact('importSummary','queueItem'));
    }

    public function listImports()
    {
        $imports = ImportQueueItem::with('profile')->get();
        return view('Admin.DataImport.list', compact('imports'));
    }
}

?>