Ümit Tunç
518 lines
20 KiB
PHP
518 lines
20 KiB
PHP
<?php
|
|
|
|
namespace App\Services\RegisterCreator;
|
|
|
|
use App\Services\RegisterCreator\DocumentProcessors\DocumentProcessorFactory;
|
|
use Illuminate\Support\Facades\Log;
|
|
use Illuminate\Support\Facades\Cache;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Exception;
|
|
|
|
class RegisterCreatorService
|
|
{
|
|
private ExcelHandler $excelHandler;
|
|
private PdfConverter $pdfConverter;
|
|
private PlaceholderReplacer $placeholderReplacer;
|
|
private ProgressTracker $progressTracker;
|
|
private array $settings;
|
|
private array $statistics;
|
|
|
|
public function __construct()
|
|
{
|
|
$this->excelHandler = new ExcelHandler();
|
|
$this->pdfConverter = new PdfConverter();
|
|
$this->placeholderReplacer = new PlaceholderReplacer();
|
|
|
|
// Initialize statistics
|
|
$this->statistics = [
|
|
'documents_processed' => 0,
|
|
'documents_success' => 0,
|
|
'documents_failed' => 0,
|
|
'by_type' => []
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Process single line with all documents
|
|
*/
|
|
public function processLine(array $lineData, array $documents, array $settings): array
|
|
{
|
|
$startTime = microtime(true);
|
|
$this->settings = $settings;
|
|
|
|
// Initialize progress tracker
|
|
$jobId = $settings['job_id'] ?? uniqid('rc_', true);
|
|
$registerColumnBased = $settings['register_column_based'] ?? 'line_number';
|
|
$lineIdentifier = $lineData[$registerColumnBased] ?? 'unknown';
|
|
|
|
// Set total to document count for proper progress tracking
|
|
$totalDocuments = count($documents);
|
|
$this->progressTracker = new ProgressTracker($jobId, $totalDocuments, 0, $lineIdentifier);
|
|
|
|
Log::info("Processing line started", [
|
|
'job_id' => $jobId,
|
|
'line' => $lineIdentifier,
|
|
'documents_count' => $totalDocuments
|
|
]);
|
|
|
|
$this->progressTracker->update("Loading template for {$lineIdentifier}", 0, 0);
|
|
|
|
try {
|
|
// Get document template info
|
|
$documentInfo = document_template("register");
|
|
if (!$documentInfo) {
|
|
throw new Exception("Register template not found!");
|
|
}
|
|
|
|
// Prepare folder structure - matching blade structure
|
|
$path = $settings['path'] ?? '';
|
|
$basePath = "storage/documents/{$path}";
|
|
$fullFolder = "{$basePath}/{$lineIdentifier}/";
|
|
$fullFolder2 = str_replace("storage/documents/", "", $fullFolder);
|
|
$justFolder = "{$path}/{$lineIdentifier}/";
|
|
|
|
// Clean target directory before processing
|
|
if (Storage::exists($fullFolder2)) {
|
|
Storage::deleteDirectory($fullFolder2);
|
|
}
|
|
Storage::makeDirectory($fullFolder2);
|
|
|
|
// Create log file using fullFolder2 (storage-relative path)
|
|
$this->initializeLogFile($fullFolder2, $lineIdentifier);
|
|
|
|
// Create info.txt file with job and user information
|
|
try {
|
|
Log::info("About to create info.txt", ['folder' => $fullFolder2, 'line' => $lineIdentifier]);
|
|
$this->createInfoFile($fullFolder2, $lineIdentifier, $settings, $totalDocuments, $lineData);
|
|
Log::info("info.txt creation completed", ['folder' => $fullFolder2]);
|
|
} catch (\Throwable $th) {
|
|
Log::error("Failed to create info.txt", [
|
|
'error' => $th->getMessage(),
|
|
'file' => $th->getFile(),
|
|
'line' => $th->getLine()
|
|
]);
|
|
}
|
|
|
|
// Load Excel template
|
|
$this->excelHandler->loadTemplate($documentInfo->files);
|
|
|
|
// Prepare placeholders
|
|
$replacements = $this->placeholderReplacer->prepareReplacements($lineData);
|
|
|
|
// Replace placeholders in Excel
|
|
$this->excelHandler->replacePlaceholders($replacements);
|
|
|
|
// Get contractor information
|
|
$contractor = $this->getContractorName($lineData);
|
|
Cache::put("rc_contractor", $contractor);
|
|
|
|
// Get WPS data if available
|
|
$wpsData = $this->getWpsData($lineData);
|
|
|
|
// Set template row
|
|
$templateRow = setting("register_creator_start_row") ?: 16;
|
|
Cache::put("rc_template_row", $templateRow);
|
|
|
|
$currentRow = $templateRow;
|
|
$rowNo = 1; // Initialize global row number counter
|
|
|
|
// DEBUG: Log documents BEFORE sorting
|
|
Log::info("📋 Documents BEFORE sorting", [
|
|
'documents' => array_map(function($doc, $idx) {
|
|
return [
|
|
'index' => $idx,
|
|
'type' => $doc['type'] ?? 'N/A',
|
|
'order' => $doc['order'] ?? 'N/A',
|
|
'title2' => $doc['title2'] ?? 'N/A'
|
|
];
|
|
}, $documents, array_keys($documents))
|
|
]);
|
|
|
|
// Sort documents by order field before processing
|
|
// This ensures Excel rows are created in the correct document type order
|
|
usort($documents, function($a, $b) {
|
|
$orderA = $a['order'] ?? 999;
|
|
$orderB = $b['order'] ?? 999;
|
|
|
|
// If orders are equal, maintain original order by using type as secondary sort
|
|
if ($orderA === $orderB) {
|
|
$typeA = $a['type'] ?? '';
|
|
$typeB = $b['type'] ?? '';
|
|
return strcmp($typeA, $typeB);
|
|
}
|
|
|
|
return $orderA <=> $orderB;
|
|
});
|
|
|
|
// DEBUG: Log documents AFTER sorting
|
|
Log::info("📋 Documents AFTER sorting", [
|
|
'documents' => array_map(function($doc, $idx) {
|
|
return [
|
|
'index' => $idx,
|
|
'type' => $doc['type'] ?? 'N/A',
|
|
'order' => $doc['order'] ?? 'N/A',
|
|
'title2' => $doc['title2'] ?? 'N/A'
|
|
];
|
|
}, $documents, array_keys($documents))
|
|
]);
|
|
|
|
Log::debug("Documents sorted by order field", [
|
|
'documents_count' => count($documents),
|
|
'first_order' => $documents[0]['order'] ?? 'N/A',
|
|
'last_order' => $documents[count($documents) - 1]['order'] ?? 'N/A'
|
|
]);
|
|
|
|
// Process each document
|
|
foreach ($documents as $index => $document) {
|
|
$startDocTime = microtime(true);
|
|
try {
|
|
// Safe string conversion for title2
|
|
$docTitle = $document['title2'] ?? 'unknown';
|
|
if (is_array($docTitle)) {
|
|
$docTitle = json_encode($docTitle);
|
|
}
|
|
|
|
$currentDoc = $index + 1;
|
|
$progressPercent = (int) (($currentDoc) / count($documents) * 100);
|
|
$this->progressTracker->update(
|
|
"Processing document {$currentDoc}/" . count($documents) . ": {$docTitle}",
|
|
$progressPercent,
|
|
$currentDoc // Update current to show which document we're on
|
|
);
|
|
|
|
Log::debug("Starting document processing", [
|
|
'job_id' => $this->progressTracker->getJobId(),
|
|
'line' => $lineIdentifier,
|
|
'document' => $docTitle,
|
|
'index' => $index + 1,
|
|
'total' => count($documents)
|
|
]);
|
|
|
|
$oldRowNo = $rowNo;
|
|
|
|
$rowNo = $this->processDocument(
|
|
$lineData,
|
|
$document,
|
|
$this->excelHandler->getSheet(),
|
|
$currentRow,
|
|
$wpsData,
|
|
$rowNo,
|
|
$documents // Pass all documents array for dynamic mapping
|
|
);
|
|
|
|
$docDuration = round(microtime(true) - $startDocTime, 2);
|
|
Log::info("📊 Document processed", [
|
|
'job_id' => $this->progressTracker->getJobId(),
|
|
'line' => $lineIdentifier,
|
|
'document' => $docTitle,
|
|
'document_type' => $document['type'] ?? 'N/A',
|
|
'document_order' => $document['order'] ?? 'N/A',
|
|
'rowNo_before' => $oldRowNo,
|
|
'rowNo_after' => $rowNo,
|
|
'rows_added' => ($rowNo - $oldRowNo),
|
|
'duration' => $docDuration . 's'
|
|
]);
|
|
|
|
$this->statistics['documents_success']++;
|
|
|
|
} catch (\Throwable $th) {
|
|
$this->statistics['documents_failed']++;
|
|
|
|
// Safe string conversion for error logging
|
|
$docTitle = $document['title2'] ?? 'unknown';
|
|
if (is_array($docTitle)) {
|
|
$docTitle = json_encode($docTitle);
|
|
}
|
|
$docType = $document['type'] ?? 'unknown';
|
|
if (is_array($docType)) {
|
|
$docType = json_encode($docType);
|
|
}
|
|
$docPath = $document['path'] ?? 'unknown';
|
|
if (is_array($docPath)) {
|
|
$docPath = json_encode($docPath);
|
|
}
|
|
|
|
// Detailed error logging for documents
|
|
Log::error("Document processing error", [
|
|
'job_id' => $this->progressTracker->getJobId(),
|
|
'line' => $lineIdentifier,
|
|
'document' => $docTitle,
|
|
'document_type' => $docType,
|
|
'document_path' => $docPath,
|
|
'error_type' => get_class($th),
|
|
'error_message' => $th->getMessage(),
|
|
'file' => $th->getFile(),
|
|
'line_number' => $th->getLine(),
|
|
'trace' => $th->getTraceAsString()
|
|
]);
|
|
|
|
// Write detailed error to log file
|
|
$errorLog = "❌ Document error: {$docTitle}\n";
|
|
$errorLog .= " Type: {$docType}\n";
|
|
$errorLog .= " Path: {$docPath}\n";
|
|
$errorLog .= " Error: " . get_class($th) . " - {$th->getMessage()}\n";
|
|
$errorLog .= " File: {$th->getFile()}:{$th->getLine()}\n";
|
|
|
|
$this->writeLog($fullFolder2, $errorLog);
|
|
continue;
|
|
}
|
|
|
|
$this->statistics['documents_processed']++;
|
|
}
|
|
|
|
// Apply work permit replacements
|
|
try {
|
|
$spreadsheet = workPermitReplacerExcel2(
|
|
$this->excelHandler->getSpreadsheet(),
|
|
$lineData,
|
|
$documentInfo,
|
|
"replacer"
|
|
);
|
|
} catch (\Throwable $th) {
|
|
Log::warning("Work permit replacer error", [
|
|
'error' => $th->getMessage()
|
|
]);
|
|
}
|
|
|
|
// Remove template row
|
|
$this->excelHandler->removeTemplateRow($templateRow);
|
|
|
|
// Save Excel file
|
|
$registerFileName = $justFolder . "Register.xlsx";
|
|
$this->excelHandler->save($registerFileName, $settings['override'] ?? true);
|
|
|
|
// Convert to PDF
|
|
$pdfPath = $justFolder;
|
|
$this->pdfConverter->convert($registerFileName, $pdfPath, $settings['override'] ?? true);
|
|
|
|
// Calculate duration
|
|
$duration = round(microtime(true) - $startTime, 2);
|
|
|
|
// Write summary to log
|
|
$this->writeSummary($justFolder, $lineIdentifier, $duration);
|
|
|
|
// Mark as complete - will show total/total (e.g., 23/23)
|
|
$this->progressTracker->complete("Completed successfully");
|
|
|
|
Log::info("Line processing completed", [
|
|
'job_id' => $this->progressTracker->getJobId(),
|
|
'line' => $lineIdentifier,
|
|
'duration' => $duration . 's',
|
|
'documents_processed' => $this->statistics['documents_processed'],
|
|
'documents_success' => $this->statistics['documents_success'],
|
|
'documents_failed' => $this->statistics['documents_failed']
|
|
]);
|
|
|
|
return [
|
|
'status' => 'success',
|
|
'line' => $lineIdentifier,
|
|
'duration' => $duration,
|
|
'statistics' => $this->statistics
|
|
];
|
|
|
|
} catch (\Throwable $th) {
|
|
$this->progressTracker->fail($th->getMessage());
|
|
|
|
Log::error("Line processing failed", [
|
|
'job_id' => $this->progressTracker->getJobId(),
|
|
'line' => $lineIdentifier,
|
|
'error' => $th->getMessage(),
|
|
'trace' => $th->getTraceAsString()
|
|
]);
|
|
|
|
throw $th;
|
|
|
|
} finally {
|
|
// Cleanup
|
|
$this->excelHandler->cleanup();
|
|
Cache::forget("rc_lastPage");
|
|
Cache::forget("rc_firstPage");
|
|
Cache::forget("rc_contractor");
|
|
Cache::forget("rc_template_row");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process single document
|
|
*/
|
|
private function processDocument(
|
|
array $lineData,
|
|
array $document,
|
|
$sheet,
|
|
int &$currentRow,
|
|
$wpsData,
|
|
int $rowNo,
|
|
array $allDocuments = [] // All documents array for dynamic type order mapping
|
|
): int {
|
|
// Validate document structure - ensure 'type' field exists
|
|
if (!isset($document['type']) || empty($document['type'])) {
|
|
// Log detailed document information for debugging
|
|
Log::warning("⚠️ Document missing 'type' field, attempting to infer", [
|
|
'document_keys' => array_keys($document),
|
|
'document_id' => $document['id'] ?? 'unknown',
|
|
'document_path' => $document['path'] ?? 'unknown'
|
|
]);
|
|
|
|
// Try to infer type from document structure
|
|
if (isset($document['is_dynamic']) && $document['is_dynamic']) {
|
|
$document['type'] = 'dynamic';
|
|
Log::info(" ✓ Inferred type as 'dynamic' based on is_dynamic flag");
|
|
} else if (isset($document['sql_query'])) {
|
|
// If has SQL query, it's likely a dynamic document
|
|
$document['type'] = 'dynamic';
|
|
Log::info(" ✓ Inferred type as 'dynamic' based on sql_query presence");
|
|
} else if (isset($document['id']) && strpos($document['id'], 'template') !== false) {
|
|
$document['type'] = 'template';
|
|
Log::info(" ✓ Inferred type as 'template' based on id");
|
|
} else {
|
|
// Default fallback
|
|
$document['type'] = 'qa';
|
|
Log::info(" ✓ Using default type 'qa' as fallback");
|
|
}
|
|
}
|
|
|
|
$processor = DocumentProcessorFactory::make($document['type'], $document);
|
|
|
|
// Prepare settings for processor
|
|
$processorSettings = array_merge($this->settings, [
|
|
'wps_data' => $wpsData,
|
|
'row_no' => $rowNo, // Pass global row number to processor
|
|
'all_documents' => $allDocuments // Pass all documents for dynamic mapping
|
|
]);
|
|
|
|
$newRow = $processor->process(
|
|
$lineData,
|
|
$document,
|
|
$sheet,
|
|
$currentRow,
|
|
$processorSettings
|
|
);
|
|
|
|
// Update current row if changed
|
|
if ($newRow > $currentRow) {
|
|
$currentRow = $newRow;
|
|
}
|
|
|
|
// Update statistics
|
|
$docType = $document['type'];
|
|
if (!isset($this->statistics['by_type'][$docType])) {
|
|
$this->statistics['by_type'][$docType] = 0;
|
|
}
|
|
$this->statistics['by_type'][$docType]++;
|
|
|
|
// Get number of documents added from processor and increment rowNo accordingly
|
|
$documentsAdded = $processor->getDocumentsAdded();
|
|
|
|
Log::debug("Documents added by processor", [
|
|
'processor' => get_class($processor),
|
|
'documents_added' => $documentsAdded,
|
|
'current_rowNo' => $rowNo,
|
|
'next_rowNo' => $rowNo + $documentsAdded
|
|
]);
|
|
|
|
return $rowNo + $documentsAdded;
|
|
}
|
|
|
|
/**
|
|
* Get contractor name
|
|
*/
|
|
private function getContractorName(array $lineData): string
|
|
{
|
|
$subcontractors = Cache::get("subcontractors", []);
|
|
$contractorKey = $lineData['contractor'] ?? '';
|
|
|
|
if (isset($subcontractors[$contractorKey])) {
|
|
return $subcontractors[$contractorKey]->company_name_ru ?? $contractorKey;
|
|
}
|
|
|
|
return $contractorKey;
|
|
}
|
|
|
|
/**
|
|
* Get WPS data
|
|
*/
|
|
private function getWpsData(array $lineData)
|
|
{
|
|
$wpsNo = $lineData['wps_no'] ?? '';
|
|
|
|
if (empty($wpsNo)) {
|
|
return null;
|
|
}
|
|
|
|
return db("w_p_s")->where("details", $wpsNo)->first();
|
|
}
|
|
|
|
/**
|
|
* Initialize log file
|
|
*/
|
|
private function initializeLogFile(string $folder, string $lineIdentifier): void
|
|
{
|
|
$logPath = $folder . 'log.txt';
|
|
|
|
Storage::delete($logPath);
|
|
|
|
$header = str_repeat("🚀", 30) . "\n";
|
|
$header .= "REGISTER CREATOR LOG FILE\n";
|
|
$header .= "Line: {$lineIdentifier}\n";
|
|
$header .= "Started: " . now()->toDateTimeString() . "\n";
|
|
$header .= str_repeat("🚀", 30) . "\n\n";
|
|
|
|
Storage::put($logPath, $header);
|
|
}
|
|
|
|
/**
|
|
* Create info.txt file with user information (JSON format)
|
|
*/
|
|
private function createInfoFile(string $folder, string $lineIdentifier, array $settings, int $totalDocuments, array $lineData): void
|
|
{
|
|
$infoPath = $folder . 'info.txt';
|
|
|
|
// Delete old info file if exists
|
|
Storage::delete($infoPath);
|
|
|
|
// Create simple JSON with user information
|
|
$infoData = [
|
|
'user_name' => $settings['user_name'] ?? 'Unknown',
|
|
'user_id' => $settings['user_id'] ?? null,
|
|
'created_at' => now()->format('Y-m-d H:i:s'),
|
|
'line_identifier' => $lineIdentifier
|
|
];
|
|
|
|
Storage::put($infoPath, json_encode($infoData, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
|
|
}
|
|
|
|
/**
|
|
* Write to log file
|
|
*/
|
|
private function writeLog(string $folder, string $message): void
|
|
{
|
|
$logPath = $folder . 'log.txt';
|
|
Storage::append($logPath, $message . "\n");
|
|
}
|
|
|
|
/**
|
|
* Write summary to log file
|
|
*/
|
|
private function writeSummary(string $folder, string $lineIdentifier, float $duration): void
|
|
{
|
|
$summary = "\n" . str_repeat("=", 80) . "\n";
|
|
$summary .= "PROCESSING SUMMARY\n";
|
|
$summary .= str_repeat("=", 80) . "\n";
|
|
$summary .= "Line: {$lineIdentifier}\n";
|
|
$summary .= "Duration: {$duration}s\n";
|
|
$summary .= "Documents Processed: {$this->statistics['documents_processed']}\n";
|
|
$summary .= "Successful: {$this->statistics['documents_success']}\n";
|
|
$summary .= "Failed: {$this->statistics['documents_failed']}\n";
|
|
$summary .= "\nBy Type:\n";
|
|
|
|
foreach ($this->statistics['by_type'] as $type => $count) {
|
|
$summary .= " - {$type}: {$count}\n";
|
|
}
|
|
|
|
$summary .= str_repeat("=", 80) . "\n";
|
|
|
|
$this->writeLog($folder, $summary);
|
|
}
|
|
}
|
|
|