572 lines
22 KiB
PHP
572 lines
22 KiB
PHP
<?php
|
|
|
|
use App\Models\ClaimFilesModel;
|
|
use Mpdf\Mpdf;
|
|
use Mpdf\Output\Destination;
|
|
|
|
if (! defined('MERGED_CLAIM_FILE_TYPE')) {
|
|
// claim_files.file_type values currently in use:
|
|
// 1 = legacy letter, 2 = uploaded claim doc, 3 = approved/settle letter
|
|
// 4 = merged combined PDF (registered by this helper)
|
|
define('MERGED_CLAIM_FILE_TYPE', 4);
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdfs')) {
|
|
/**
|
|
* Merge all active PDF/image rows in claim_files for a given ticket_master id
|
|
* into one combined PDF and register that PDF as a new claim_files row
|
|
* with file_type = MERGED_CLAIM_FILE_TYPE.
|
|
*
|
|
* Source rows are picked from claim_files where:
|
|
* - ticket_id = $ticket_master_id
|
|
* - is_active = 1
|
|
* - mime_type IN $opts['include_mime_types'] (default PDF/JPG/PNG)
|
|
* - file_type IN $opts['include_file_types'] (default [1, 2, 3])
|
|
*
|
|
* @param int $ticket_master_id
|
|
* @param array $opts {
|
|
* @var bool $replace Default true. Soft-delete previous merged row before re-creating.
|
|
* @var int $created_by Override created_by user id on the inserted row.
|
|
* @var int $ticket_type Default 1. Stored on the inserted claim_files row.
|
|
* @var array $include_file_types Default [1, 2, 3].
|
|
* @var array $include_mime_types Default ['application/pdf', 'image/jpeg', 'image/png'].
|
|
* }
|
|
* @return array {status, merged_file_id, file_name, pages, source_count, message}
|
|
*/
|
|
function merge_ticket_pdfs(int $ticket_master_id, array $opts = []): array
|
|
{
|
|
$opts += [
|
|
'replace' => true,
|
|
'created_by' => null,
|
|
'ticket_type' => 1,
|
|
'include_file_types' => [1, 2],
|
|
'include_mime_types' => ['application/pdf', 'image/jpeg', 'image/png'],
|
|
];
|
|
|
|
$result = [
|
|
'status' => false,
|
|
'merged_file_id' => null,
|
|
'file_name' => null,
|
|
'pages' => 0,
|
|
'source_count' => 0,
|
|
'message' => '',
|
|
];
|
|
|
|
if ($ticket_master_id <= 0) {
|
|
$result['message'] = 'Invalid ticket_master_id';
|
|
return $result;
|
|
}
|
|
|
|
$claimFiles = new ClaimFilesModel();
|
|
|
|
$rows = $claimFiles
|
|
->where('ticket_id', $ticket_master_id)
|
|
->where('is_active', 1)
|
|
->whereIn('file_type', $opts['include_file_types'])
|
|
->orderBy('id', 'ASC')
|
|
->findAll();
|
|
|
|
if (empty($rows)) {
|
|
$result['status'] = true;
|
|
$result['message'] = 'No PDF/image files to merge';
|
|
return $result;
|
|
}
|
|
|
|
if (count($rows) ==1){
|
|
//set file_type for for that one file.
|
|
$claimFiles->where('id', $rows[0]['id'])->set(['file_type' => 4])->update();
|
|
$result['status'] = true;
|
|
$result['message'] = 'Only one PDF/image file to merge';
|
|
return $result;
|
|
}
|
|
|
|
$uploadDir = rtrim(WRITEPATH, '/\\') . DIRECTORY_SEPARATOR
|
|
. 'uploads' . DIRECTORY_SEPARATOR
|
|
. 'claim_files' . DIRECTORY_SEPARATOR;
|
|
|
|
$sourceFiles = [];
|
|
foreach ($rows as $row) {
|
|
$full = merge_ticket_pdf_resolve_disk_path($row, $uploadDir, true);
|
|
if ($full !== null) {
|
|
$mime = merge_ticket_pdf_resolve_mime($full, (string) ($row['mime_type'] ?? ''));
|
|
if (! in_array($mime, $opts['include_mime_types'], true)) {
|
|
log_message('error', "merge_ticket_pdfs | unsupported source mime {$mime} | claim_file_id={$row['id']} | path={$full}");
|
|
if (strpos($full, 'claim_files_runtime') !== false) {
|
|
@unlink($full);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
$sourceFiles[] = [
|
|
'path' => $full,
|
|
'mime' => $mime,
|
|
'id' => $row['id'] ?? null,
|
|
'is_temp' => strpos($full, 'claim_files_runtime') !== false,
|
|
];
|
|
} else {
|
|
$name = ! empty($row['url']) ? $row['url'] : ($row['file_name'] ?? '');
|
|
log_message('error', "merge_ticket_pdfs | missing file in local/S3 | claim_file_id={$row['id']} | path=" . $uploadDir . basename((string) $name));
|
|
}
|
|
}
|
|
|
|
if (empty($sourceFiles)) {
|
|
$result['message'] = 'No readable PDF/image files on disk';
|
|
return $result;
|
|
}
|
|
|
|
$cleanupMergeTemps = static function (array $files): void {
|
|
foreach ($files as $sourceFile) {
|
|
if (! empty($sourceFile['is_temp']) && ! empty($sourceFile['path']) && is_file($sourceFile['path'])) {
|
|
@unlink($sourceFile['path']);
|
|
}
|
|
}
|
|
};
|
|
|
|
$result['source_count'] = count($sourceFiles);
|
|
log_message(
|
|
'error',
|
|
'merge_ticket_pdfs | source files resolved | ticket_id=' . $ticket_master_id . ' | sources=' . json_encode(array_map(static function ($sourceFile) {
|
|
return [
|
|
'id' => $sourceFile['id'],
|
|
'mime' => $sourceFile['mime'],
|
|
'file' => basename($sourceFile['path']),
|
|
];
|
|
}, $sourceFiles))
|
|
);
|
|
|
|
$tempDir = rtrim(WRITEPATH, '/\\') . DIRECTORY_SEPARATOR . 'cache' . DIRECTORY_SEPARATOR . 'mpdf';
|
|
if (! is_dir($tempDir)) {
|
|
@mkdir($tempDir, 0775, true);
|
|
}
|
|
$mpdfCacheDir = $tempDir . DIRECTORY_SEPARATOR . 'mpdf';
|
|
if (! is_dir($mpdfCacheDir)) {
|
|
@mkdir($mpdfCacheDir, 0775, true);
|
|
}
|
|
|
|
$mergedName = 'merged_' . $ticket_master_id . '_' . time() . '_' . bin2hex(random_bytes(5)) . '.pdf';
|
|
$mergedPath = $uploadDir . $mergedName;
|
|
|
|
try {
|
|
$mpdf = new Mpdf([
|
|
'tempDir' => $tempDir,
|
|
'mode' => 'utf-8',
|
|
]);
|
|
|
|
$totalPages = 0;
|
|
foreach ($sourceFiles as $sourceFile) {
|
|
$src = $sourceFile['path'];
|
|
try {
|
|
if ($sourceFile['mime'] === 'application/pdf') {
|
|
$pageCount = merge_ticket_pdf_add_pdf_pages($mpdf, $src, $tempDir);
|
|
$totalPages += $pageCount;
|
|
log_message('error', "merge_ticket_pdfs | added PDF | file={$src} | pages={$pageCount}");
|
|
} elseif (in_array($sourceFile['mime'], ['image/jpeg', 'image/png'], true)) {
|
|
if (merge_ticket_pdf_add_image_page($mpdf, $src)) {
|
|
$totalPages++;
|
|
log_message('error', "merge_ticket_pdfs | added image | file={$src} | mime={$sourceFile['mime']}");
|
|
}
|
|
} else {
|
|
log_message('error', "merge_ticket_pdfs | unsupported source mime {$sourceFile['mime']} | {$src}");
|
|
}
|
|
} catch (\Throwable $e) {
|
|
log_message('error', "merge_ticket_pdfs | failed to import {$src} | " . $e->getMessage());
|
|
}
|
|
}
|
|
|
|
if ($totalPages === 0) {
|
|
$cleanupMergeTemps($sourceFiles);
|
|
$result['message'] = 'All source PDF/image files failed to import';
|
|
return $result;
|
|
}
|
|
|
|
$mpdf->Output($mergedPath, Destination::FILE);
|
|
} catch (\Throwable $e) {
|
|
$cleanupMergeTemps($sourceFiles);
|
|
log_message('error', 'merge_ticket_pdfs | mpdf failure | ticket_id=' . $ticket_master_id . ' | ' . $e->getMessage());
|
|
$result['message'] = 'Merge failed: ' . $e->getMessage();
|
|
return $result;
|
|
}
|
|
|
|
if (! is_file($mergedPath)) {
|
|
$cleanupMergeTemps($sourceFiles);
|
|
$result['message'] = 'Merged file was not created';
|
|
return $result;
|
|
}
|
|
|
|
$storage = \Config\Services::getFileStorageService();
|
|
if ($storage->usesS3()) {
|
|
$uploadResult = $storage->upload($mergedPath, rtrim($uploadDir, '/\\'), $mergedName);
|
|
if (! ($uploadResult['success'] ?? false)) {
|
|
log_message('error', 'merge_ticket_pdfs | failed to mirror merged file to S3 | ticket_id=' . $ticket_master_id . ' | ' . json_encode($uploadResult));
|
|
@unlink($mergedPath);
|
|
$cleanupMergeTemps($sourceFiles);
|
|
$result['message'] = 'Merged file upload to storage failed';
|
|
return $result;
|
|
}
|
|
// S3-only: drop permanent local merged copy after successful upload.
|
|
@unlink($mergedPath);
|
|
}
|
|
|
|
if ($opts['replace']) {
|
|
$claimFiles
|
|
->where('ticket_id', $ticket_master_id)
|
|
->where('file_type', MERGED_CLAIM_FILE_TYPE)
|
|
->where('is_active', 1)
|
|
->set(['is_active' => 0])
|
|
->update();
|
|
}
|
|
|
|
$insertData = [
|
|
'ticket_id' => $ticket_master_id,
|
|
// 'ticket_type' => $opts['ticket_type'],
|
|
'file_type' => MERGED_CLAIM_FILE_TYPE,
|
|
'doc_name' => 'MERGED_CLAIM_DOCS_PDF',
|
|
'file_name' => $mergedName,
|
|
'url' => $mergedName,
|
|
'mime_type' => 'application/pdf',
|
|
'is_active' => 1,
|
|
];
|
|
if (! empty($opts['created_by'])) {
|
|
$insertData['created_by'] = $opts['created_by'];
|
|
}
|
|
|
|
$insertedId = $claimFiles->insert($insertData);
|
|
|
|
$cleanupMergeTemps($sourceFiles);
|
|
|
|
if (! $insertedId) {
|
|
log_message('error', 'merge_ticket_pdfs | DB insert failed for merged file | ticket_id=' . $ticket_master_id);
|
|
@unlink($mergedPath);
|
|
$result['message'] = 'Failed to register merged file in claim_files';
|
|
return $result;
|
|
}
|
|
|
|
log_message(
|
|
'info',
|
|
"merge_ticket_pdfs | OK | ticket_id={$ticket_master_id} | sources={$result['source_count']} | pages={$totalPages} | claim_file_id={$insertedId}"
|
|
);
|
|
|
|
$result['status'] = true;
|
|
$result['merged_file_id'] = (int) $insertedId;
|
|
$result['file_name'] = $mergedName;
|
|
$result['pages'] = $totalPages;
|
|
$result['message'] = 'Merged successfully';
|
|
return $result;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_add_pdf_pages')) {
|
|
/**
|
|
* Import PDF pages. If FPDI cannot import the source (commonly encrypted
|
|
* PDFs), normalize through Ghostscript and retry.
|
|
*/
|
|
function merge_ticket_pdf_add_pdf_pages(Mpdf $mpdf, string $pdfPath, string $tempDir): int
|
|
{
|
|
try {
|
|
return merge_ticket_pdf_import_pdf_pages($mpdf, $pdfPath);
|
|
} catch (\Throwable $e) {
|
|
log_message('error', "merge_ticket_pdfs | direct PDF import failed | file={$pdfPath} | " . $e->getMessage());
|
|
|
|
$normalizedPath = merge_ticket_pdf_normalize_with_ghostscript($pdfPath, $tempDir);
|
|
if ($normalizedPath === null) {
|
|
throw $e;
|
|
}
|
|
|
|
try {
|
|
$pageCount = merge_ticket_pdf_import_pdf_pages($mpdf, $normalizedPath);
|
|
log_message('error', "merge_ticket_pdfs | Ghostscript normalized PDF imported | original={$pdfPath} | normalized={$normalizedPath} | pages={$pageCount}");
|
|
@unlink($normalizedPath);
|
|
return $pageCount;
|
|
} catch (\Throwable $normalizedError) {
|
|
@unlink($normalizedPath);
|
|
throw $normalizedError;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_import_pdf_pages')) {
|
|
function merge_ticket_pdf_import_pdf_pages(Mpdf $mpdf, string $pdfPath): int
|
|
{
|
|
$pageCount = $mpdf->setSourceFile($pdfPath);
|
|
for ($p = 1; $p <= $pageCount; $p++) {
|
|
$tplId = $mpdf->importPage($p);
|
|
$mpdf->AddPage();
|
|
// adjustPageSize=true makes the output page match the imported page.
|
|
$mpdf->useTemplate($tplId, 0, 0, null, null, true);
|
|
}
|
|
|
|
return $pageCount;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_normalize_with_ghostscript')) {
|
|
function merge_ticket_pdf_normalize_with_ghostscript(string $pdfPath, string $tempDir): ?string
|
|
{
|
|
$ghostscript = is_executable('/usr/bin/gs') ? '/usr/bin/gs' : trim((string) @shell_exec('command -v gs 2>/dev/null'));
|
|
if ($ghostscript === '' || ! is_executable($ghostscript)) {
|
|
log_message('error', "merge_ticket_pdfs | Ghostscript not available for PDF normalization | file={$pdfPath}");
|
|
return null;
|
|
}
|
|
|
|
$normalizedPath = rtrim($tempDir, '/\\') . DIRECTORY_SEPARATOR . 'normalized_' . uniqid('', true) . '.pdf';
|
|
$cmd = escapeshellarg($ghostscript)
|
|
. ' -q -dNOPAUSE -dBATCH -dSAFER -sDEVICE=pdfwrite -dCompatibilityLevel=1.4'
|
|
. ' -sOutputFile=' . escapeshellarg($normalizedPath)
|
|
. ' ' . escapeshellarg($pdfPath)
|
|
. ' 2>&1';
|
|
|
|
$output = [];
|
|
$exitCode = 1;
|
|
@exec($cmd, $output, $exitCode);
|
|
|
|
if ($exitCode !== 0 || ! is_file($normalizedPath) || filesize($normalizedPath) <= 0) {
|
|
log_message('error', 'merge_ticket_pdfs | Ghostscript normalization failed | file=' . $pdfPath . ' | exit=' . $exitCode . ' | output=' . implode(' ', $output));
|
|
@unlink($normalizedPath);
|
|
return null;
|
|
}
|
|
|
|
return $normalizedPath;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_resolve_mime')) {
|
|
/**
|
|
* Resolve file type from stored MIME, filesystem MIME, and extension.
|
|
* Some uploads can be saved as image/jpg, empty MIME, or octet-stream in DB.
|
|
*/
|
|
function merge_ticket_pdf_resolve_mime(string $path, string $storedMime = ''): string
|
|
{
|
|
$storedMime = strtolower(trim($storedMime));
|
|
if ($storedMime === 'image/jpg') {
|
|
return 'image/jpeg';
|
|
}
|
|
if (in_array($storedMime, ['application/pdf', 'image/jpeg', 'image/png'], true)) {
|
|
return $storedMime;
|
|
}
|
|
|
|
$detectedMime = '';
|
|
if (function_exists('mime_content_type')) {
|
|
$detectedMime = strtolower((string) @mime_content_type($path));
|
|
if ($detectedMime === 'image/jpg') {
|
|
return 'image/jpeg';
|
|
}
|
|
if (in_array($detectedMime, ['application/pdf', 'image/jpeg', 'image/png'], true)) {
|
|
return $detectedMime;
|
|
}
|
|
}
|
|
|
|
$ext = strtolower(pathinfo($path, PATHINFO_EXTENSION));
|
|
if ($ext === 'pdf') {
|
|
return 'application/pdf';
|
|
}
|
|
if (in_array($ext, ['jpg', 'jpeg'], true)) {
|
|
return 'image/jpeg';
|
|
}
|
|
if ($ext === 'png') {
|
|
return 'image/png';
|
|
}
|
|
|
|
if (in_array($detectedMime, ['application/octet-stream', 'binary/octet-stream'], true)) {
|
|
if ($ext === 'pdf') {
|
|
return 'application/pdf';
|
|
}
|
|
if (in_array($ext, ['jpg', 'jpeg'], true)) {
|
|
return 'image/jpeg';
|
|
}
|
|
if ($ext === 'png') {
|
|
return 'image/png';
|
|
}
|
|
}
|
|
|
|
return $detectedMime ?: ($storedMime ?: 'application/octet-stream');
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_resolve_disk_path')) {
|
|
/**
|
|
* Resolve on-disk path for a claim_files row (url and/or file_name).
|
|
*/
|
|
function merge_ticket_pdf_resolve_disk_path(array $row, string $uploadDir, bool $allowTempDownload = true): ?string
|
|
{
|
|
$candidates = [];
|
|
if (! empty($row['url'])) {
|
|
$candidates[] = basename((string) $row['url']);
|
|
}
|
|
if (! empty($row['file_name'])) {
|
|
$candidates[] = basename((string) $row['file_name']);
|
|
}
|
|
|
|
foreach (array_unique($candidates) as $name) {
|
|
if ($name === '' || preg_match('#^https?://#i', $name)) {
|
|
continue;
|
|
}
|
|
$full = $uploadDir . $name;
|
|
if (is_file($full) && is_readable($full)) {
|
|
return $full;
|
|
}
|
|
|
|
if ($allowTempDownload) {
|
|
helper('utility');
|
|
$resolved = storage_resolve_claim_file_path(rtrim($uploadDir, '/\\'), $name);
|
|
if (($resolved['success'] ?? false) && ! empty($resolved['path']) && is_file($resolved['path'])) {
|
|
return $resolved['path'];
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_pdf_add_image_page')) {
|
|
/**
|
|
* Add an uploaded image as a single PDF page, preserving portrait/landscape
|
|
* orientation and fitting the image proportionally inside the page.
|
|
*/
|
|
function merge_ticket_pdf_add_image_page(Mpdf $mpdf, string $imagePath): bool
|
|
{
|
|
$imageInfo = @getimagesize($imagePath);
|
|
$ext = strtolower(pathinfo($imagePath, PATHINFO_EXTENSION));
|
|
$imageType = $ext === 'png' || ((int) ($imageInfo[2] ?? 0) === IMAGETYPE_PNG) ? 'png' : 'jpg';
|
|
|
|
$imageWidthPx = (int) ($imageInfo[0] ?? 0);
|
|
$imageHeightPx = (int) ($imageInfo[1] ?? 0);
|
|
$hasSize = $imageWidthPx > 0 && $imageHeightPx > 0;
|
|
$isLandscape = $hasSize && $imageWidthPx > $imageHeightPx;
|
|
|
|
$pageWidth = $isLandscape ? 297 : 210;
|
|
$pageHeight = $isLandscape ? 210 : 297;
|
|
$margin = 0;
|
|
|
|
$availableWidth = $pageWidth - ($margin * 2);
|
|
$availableHeight = $pageHeight - ($margin * 2);
|
|
if ($hasSize) {
|
|
$scale = min($availableWidth / $imageWidthPx, $availableHeight / $imageHeightPx);
|
|
$drawWidth = $imageWidthPx * $scale;
|
|
$drawHeight = $imageHeightPx * $scale;
|
|
$x = ($pageWidth - $drawWidth) / 2;
|
|
$y = ($pageHeight - $drawHeight) / 2;
|
|
} else {
|
|
// Some PNGs fail getimagesize(), but mPDF can still render them.
|
|
// Use a portrait A4 fallback and let mPDF calculate image height.
|
|
log_message('error', "merge_ticket_pdfs | image size unavailable, using fallback page | {$imagePath}");
|
|
$drawWidth = $availableWidth;
|
|
$drawHeight = 0;
|
|
$x = $margin;
|
|
$y = $margin;
|
|
}
|
|
|
|
$mpdf->AddPageByArray([
|
|
'orientation' => $isLandscape ? 'L' : 'P',
|
|
'sheet-size' => 'A4',
|
|
'margin-left' => 0,
|
|
'margin-right' => 0,
|
|
'margin-top' => 0,
|
|
'margin-bottom' => 0,
|
|
'margin-header' => 0,
|
|
'margin-footer' => 0,
|
|
]);
|
|
|
|
$mpdf->Image($imagePath, $x, $y, $drawWidth, $drawHeight, $imageType);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (! function_exists('merge_ticket_manual_merge_status')) {
|
|
/**
|
|
* UI/status helper: whether manual merge should be offered on Claim Files tab.
|
|
*
|
|
* @return array{
|
|
* has_merged_file: bool,
|
|
* mergeable_count: int,
|
|
* show_manual_merge: bool,
|
|
* button_label: string
|
|
* }
|
|
*/
|
|
function merge_ticket_manual_merge_status(int $ticket_master_id, array $opts = []): array
|
|
{
|
|
$opts += [
|
|
'include_file_types' => [1, 2],
|
|
'include_mime_types' => ['application/pdf', 'image/jpeg', 'image/png'],
|
|
];
|
|
|
|
$status = [
|
|
'has_merged_file' => false,
|
|
'mergeable_count' => 0,
|
|
'show_manual_merge' => false,
|
|
'button_label' => 'Merge documents',
|
|
];
|
|
|
|
if ($ticket_master_id <= 0) {
|
|
return $status;
|
|
}
|
|
|
|
$claimFiles = new ClaimFilesModel();
|
|
$rows = $claimFiles
|
|
->where('ticket_id', $ticket_master_id)
|
|
->where('is_active', 1)
|
|
->whereIn('file_type', array_merge($opts['include_file_types'], [MERGED_CLAIM_FILE_TYPE]))
|
|
->orderBy('id', 'ASC')
|
|
->findAll();
|
|
|
|
$uploadDir = rtrim(WRITEPATH, '/\\') . DIRECTORY_SEPARATOR
|
|
. 'uploads' . DIRECTORY_SEPARATOR
|
|
. 'claim_files' . DIRECTORY_SEPARATOR;
|
|
|
|
$mergeableCount = 0;
|
|
$sourceRowCount = 0;
|
|
foreach ($rows as $row) {
|
|
if ((int) ($row['file_type'] ?? 0) === MERGED_CLAIM_FILE_TYPE) {
|
|
$status['has_merged_file'] = true;
|
|
continue;
|
|
}
|
|
|
|
if (! in_array((int) ($row['file_type'] ?? 0), $opts['include_file_types'], true)) {
|
|
continue;
|
|
}
|
|
|
|
$sourceRowCount++;
|
|
|
|
$full = merge_ticket_pdf_resolve_disk_path($row, $uploadDir, false);
|
|
if ($full === null) {
|
|
helper('utility');
|
|
$name = basename((string) (! empty($row['url']) ? $row['url'] : ($row['file_name'] ?? '')));
|
|
if ($name === '') {
|
|
continue;
|
|
}
|
|
$storage = \Config\Services::getFileStorageService();
|
|
$available = $storage->exists(rtrim($uploadDir, '/\\'), $name);
|
|
if (! $available) {
|
|
continue;
|
|
}
|
|
$mime = merge_ticket_pdf_resolve_mime($name, (string) ($row['mime_type'] ?? ''));
|
|
if (in_array($mime, $opts['include_mime_types'], true)) {
|
|
$mergeableCount++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
$mime = merge_ticket_pdf_resolve_mime($full, (string) ($row['mime_type'] ?? ''));
|
|
if (in_array($mime, $opts['include_mime_types'], true)) {
|
|
$mergeableCount++;
|
|
}
|
|
}
|
|
|
|
$status['mergeable_count'] = $mergeableCount;
|
|
|
|
// Show manual merge when there is no merged file but user has uploaded docs in the list.
|
|
if (! $status['has_merged_file']) {
|
|
if ($mergeableCount >= 1 || $sourceRowCount >= 2) {
|
|
$status['show_manual_merge'] = true;
|
|
$status['button_label'] = 'Merge documents';
|
|
}
|
|
} elseif ($mergeableCount >= 2) {
|
|
$status['show_manual_merge'] = true;
|
|
$status['button_label'] = 'Re-merge documents';
|
|
}
|
|
|
|
return $status;
|
|
}
|
|
}
|