root
606 lines
23 KiB
PHP
606 lines
23 KiB
PHP
<?php
|
|
|
|
namespace App\Controllers\View;
|
|
|
|
use App\Controllers\BaseController;
|
|
use App\Models\ClassSectionModel;
|
|
use App\Models\ConfigurationModel;
|
|
use App\Models\ExamDraftModel;
|
|
use App\Models\TeacherClassModel;
|
|
use App\Models\UserModel;
|
|
use CodeIgniter\HTTP\Files\UploadedFile;
|
|
use Config\Database;
|
|
|
|
class ExamDraftController extends BaseController
|
|
{
|
|
protected ExamDraftModel $examDraftModel;
|
|
protected TeacherClassModel $teacherClassModel;
|
|
protected ClassSectionModel $classSectionModel;
|
|
protected UserModel $userModel;
|
|
protected ConfigurationModel $configModel;
|
|
|
|
protected string $schoolYear;
|
|
protected string $semester;
|
|
protected bool $hasFinalPdfColumn = false;
|
|
protected bool $hasIsLegacyColumn = false;
|
|
|
|
// DB enum: draft, submitted, reviewed, finalized, rejected
|
|
// (string literals used to avoid excess constants)
|
|
|
|
protected const TEACHER_UPLOAD_DIR = 'exams/drafts';
|
|
protected const FINAL_UPLOAD_DIR = 'exams/finals';
|
|
protected const MAX_UPLOAD_BYTES = 12 * 1024 * 1024;
|
|
protected const ALLOWED_EXTENSIONS = ['doc', 'docx'];
|
|
protected const ADMIN_ALLOWED_EXTENSIONS = ['doc', 'docx', 'pdf'];
|
|
|
|
protected array $examTypes = [
|
|
'Final Exam',
|
|
'Midterm Exam',
|
|
'Quiz',
|
|
'Study Guide',
|
|
'Practice Exam',
|
|
'Other',
|
|
];
|
|
|
|
public function __construct()
|
|
{
|
|
$this->examDraftModel = new ExamDraftModel();
|
|
$this->teacherClassModel = new TeacherClassModel();
|
|
$this->classSectionModel = new ClassSectionModel();
|
|
$this->userModel = new UserModel();
|
|
$this->configModel = new ConfigurationModel();
|
|
$this->db = Database::connect();
|
|
|
|
$this->schoolYear = (string) ($this->configModel->getConfig('school_year') ?? '');
|
|
$this->semester = (string) ($this->configModel->getConfig('semester') ?? '');
|
|
$this->hasFinalPdfColumn = $this->schemaHasColumn('exam_drafts', 'final_pdf_file');
|
|
$this->hasIsLegacyColumn = $this->schemaHasColumn('exam_drafts', 'is_legacy');
|
|
|
|
helper(['form', 'url', 'date']);
|
|
}
|
|
|
|
public function teacherIndex()
|
|
{
|
|
$teacherId = (int) (session()->get('user_id') ?? 0);
|
|
if ($teacherId <= 0) {
|
|
return redirect()->to('/login');
|
|
}
|
|
|
|
$assignments = $this->teacherClassModel->getClassAssignmentsByUserId($teacherId, $this->schoolYear);
|
|
$selectedClass = $this->resolveSelectedClassSection($assignments);
|
|
if ($selectedClass > 0) {
|
|
session()->set('class_section_id', $selectedClass);
|
|
}
|
|
|
|
$allDrafts = $this->examDraftModel
|
|
->where('teacher_id', $teacherId)
|
|
->orderBy('created_at', 'DESC')
|
|
->findAll();
|
|
|
|
foreach ($allDrafts as &$row) {
|
|
if (empty($row['final_pdf_file'])) {
|
|
$pdf = $this->ensurePdfExists($row['final_file'] ?? '', pathinfo($row['final_file'] ?? '', PATHINFO_EXTENSION));
|
|
if ($pdf !== null) {
|
|
$row['final_pdf_file'] = $pdf;
|
|
}
|
|
}
|
|
}
|
|
unset($row);
|
|
|
|
$classSectionIds = array_map(static fn($a) => (int) $a['class_section_id'], $assignments);
|
|
$legacyExams = [];
|
|
// Guard against missing schema column in older databases
|
|
if ($this->hasIsLegacyColumn) {
|
|
// Keep all submissions visible; legacy ones are also surfaced in a separate tab
|
|
$drafts = $allDrafts;
|
|
|
|
if (!empty($classSectionIds)) {
|
|
$legacyExams = $this->examDraftModel
|
|
->select('exam_drafts.*, cs.class_section_name')
|
|
->join('classSection cs', 'cs.class_section_id = exam_drafts.class_section_id', 'left')
|
|
->whereIn('exam_drafts.class_section_id', $classSectionIds)
|
|
->where('exam_drafts.is_legacy', 1)
|
|
->where('exam_drafts.final_file IS NOT NULL', null, false)
|
|
->orderBy('cs.class_section_name', 'ASC')
|
|
->orderBy('exam_drafts.created_at', 'DESC')
|
|
->findAll();
|
|
}
|
|
} else {
|
|
// Legacy column absent, show all drafts and skip legacy tab query
|
|
$drafts = $allDrafts;
|
|
}
|
|
|
|
$validation = session()->getFlashdata('validation') ?? $this->validator;
|
|
|
|
return view('teacher/exam_drafts', [
|
|
'assignments' => $assignments,
|
|
'selectedClassSection' => $selectedClass,
|
|
'drafts' => $drafts,
|
|
'legacyExams' => $legacyExams,
|
|
'examTypes' => $this->examTypes,
|
|
'statusBadges' => $this->statusBadgeMap(),
|
|
'schoolYear' => $this->schoolYear,
|
|
'semester' => $this->semester,
|
|
'maxUploadBytes' => self::MAX_UPLOAD_BYTES,
|
|
'validation' => $validation,
|
|
]);
|
|
}
|
|
|
|
public function teacherStore()
|
|
{
|
|
$teacherId = (int) (session()->get('user_id') ?? 0);
|
|
if ($teacherId <= 0) {
|
|
return redirect()->to('/login');
|
|
}
|
|
|
|
$classSectionId = (int) ($this->request->getPost('class_section_id') ?? session()->get('class_section_id') ?? 0);
|
|
$examType = trim((string) $this->request->getPost('exam_type'));
|
|
$description = trim((string) $this->request->getPost('description'));
|
|
|
|
if ($classSectionId <= 0) {
|
|
return redirect()->back()->withInput()->with('error', 'Select a class section before submitting.');
|
|
}
|
|
|
|
$assignment = $this->teacherClassModel
|
|
->where('teacher_id', $teacherId)
|
|
->where('class_section_id', $classSectionId)
|
|
->first();
|
|
|
|
if (empty($assignment)) {
|
|
return redirect()->back()->withInput()->with('error', 'You are not assigned to the selected class section.');
|
|
}
|
|
|
|
session()->set('class_section_id', $classSectionId);
|
|
|
|
if ($classSectionId <= 0) {
|
|
$classSectionId = $this->resolveSelectedClassSection($assignments);
|
|
if ($classSectionId <= 0) {
|
|
return redirect()->back()->withInput()->with('error', 'Select a class section before submitting.');
|
|
}
|
|
}
|
|
|
|
$file = $this->request->getFile('draft_file');
|
|
$teacherFile = null;
|
|
$teacherFilename = null;
|
|
if ($file && $file->isValid() && !$file->hasMoved()) {
|
|
$stored = $this->storeUploadedFile($file, self::TEACHER_UPLOAD_DIR);
|
|
if ($stored === null) {
|
|
return redirect()->back()->withInput()->with('error', 'Failed to store the uploaded file.');
|
|
}
|
|
$teacherFile = $stored;
|
|
$teacherFilename = $file->getClientName();
|
|
} elseif ($file && $file->getError() !== UPLOAD_ERR_NO_FILE) {
|
|
return redirect()->back()->withInput()->with('error', 'Upload failed. Please try again.');
|
|
}
|
|
|
|
$existingDraft = $this->examDraftModel
|
|
->where('teacher_id', $teacherId)
|
|
->where('class_section_id', $classSectionId)
|
|
->where('semester', $this->semester)
|
|
->where('school_year', $this->schoolYear)
|
|
->orderBy('version', 'DESC')
|
|
->first();
|
|
|
|
$nextVersion = 1;
|
|
$previousId = null;
|
|
if (!empty($existingDraft)) {
|
|
$nextVersion = ((int) ($existingDraft['version'] ?? 1)) + 1;
|
|
$previousId = (int) ($existingDraft['id'] ?? 0) ?: null;
|
|
}
|
|
|
|
$title = $examType ?: 'Exam Draft';
|
|
|
|
$payload = [
|
|
'teacher_id' => $teacherId,
|
|
'class_section_id' => $classSectionId,
|
|
'semester' => $this->semester,
|
|
'school_year' => $this->schoolYear,
|
|
'exam_type' => $examType ?: null,
|
|
'draft_title' => $title,
|
|
'description' => $description === '' ? null : $description,
|
|
'teacher_file' => $teacherFile,
|
|
'teacher_filename' => $teacherFilename,
|
|
'status' => 'submitted',
|
|
'version' => $nextVersion,
|
|
'previous_draft_id' => $previousId,
|
|
];
|
|
|
|
if ($this->examDraftModel->insert($payload)) {
|
|
return redirect()->to('/teacher/exam-drafts')->with('success', 'Exam draft submitted for review.');
|
|
}
|
|
|
|
return redirect()->back()->withInput()->with('error', 'Unable to save the exam draft.');
|
|
}
|
|
|
|
public function adminIndex()
|
|
{
|
|
$allDrafts = $this->examDraftModel
|
|
->select('exam_drafts.*, cs.class_section_name, u.firstname AS teacher_first, u.lastname AS teacher_last, a.firstname AS admin_first, a.lastname AS admin_last')
|
|
->join('classSection cs', 'cs.class_section_id = exam_drafts.class_section_id', 'left')
|
|
->join('users u', 'u.id = exam_drafts.teacher_id', 'left')
|
|
->join('users a', 'a.id = exam_drafts.admin_id', 'left')
|
|
->orderBy('exam_drafts.created_at', 'DESC')
|
|
->findAll();
|
|
|
|
foreach ($allDrafts as &$row) {
|
|
if (empty($row['final_pdf_file'])) {
|
|
$pdf = $this->ensurePdfExists($row['final_file'] ?? '', pathinfo($row['final_file'] ?? '', PATHINFO_EXTENSION));
|
|
if ($pdf !== null) {
|
|
$row['final_pdf_file'] = $pdf;
|
|
}
|
|
}
|
|
}
|
|
unset($row);
|
|
|
|
$classSections = $this->classSectionModel
|
|
->select('class_section_id, class_section_name')
|
|
->orderBy('class_section_name', 'ASC')
|
|
->findAll();
|
|
|
|
// Group legacy uploads (admin-uploaded finalized exams) by class_section for separate tab
|
|
$legacyByClass = [];
|
|
if ($this->hasIsLegacyColumn) {
|
|
// Keep all submissions visible; additionally surface legacy items in a separate tab
|
|
$drafts = $allDrafts;
|
|
|
|
foreach ($allDrafts as $d) {
|
|
$isLegacy = !empty($d['is_legacy']);
|
|
if (!$isLegacy) {
|
|
continue;
|
|
}
|
|
$cid = (int)($d['class_section_id'] ?? 0);
|
|
if (!isset($legacyByClass[$cid])) {
|
|
$legacyByClass[$cid] = [
|
|
'class_section_id' => $cid,
|
|
'class_section_name' => $d['class_section_name'] ?? 'Class ' . $cid,
|
|
'items' => [],
|
|
];
|
|
}
|
|
$legacyByClass[$cid]['items'][] = $d;
|
|
}
|
|
} else {
|
|
// Column missing: keep behavior simple and avoid legacy tab
|
|
$drafts = $allDrafts;
|
|
}
|
|
|
|
return view('administrator/exam_drafts', [
|
|
'drafts' => $drafts,
|
|
'statusBadges' => $this->statusBadgeMap(),
|
|
'statusOptions' => $this->statusOptions(),
|
|
'schoolYear' => $this->schoolYear,
|
|
'semester' => $this->semester,
|
|
'allowedExtensions' => self::ADMIN_ALLOWED_EXTENSIONS,
|
|
'maxUploadBytes' => self::MAX_UPLOAD_BYTES,
|
|
'examTypes' => $this->examTypes,
|
|
'classSections' => $classSections,
|
|
'legacyByClass' => $legacyByClass,
|
|
]);
|
|
}
|
|
|
|
public function adminUploadLegacy()
|
|
{
|
|
$adminId = (int) (session()->get('user_id') ?? 0);
|
|
if ($adminId <= 0) {
|
|
return redirect()->to('/login');
|
|
}
|
|
|
|
$classSectionId = (int) ($this->request->getPost('class_section_id') ?? 0);
|
|
$schoolYear = trim((string) ($this->request->getPost('school_year') ?? $this->schoolYear));
|
|
$semester = trim((string) ($this->request->getPost('semester') ?? $this->semester));
|
|
$examType = trim((string) $this->request->getPost('exam_type'));
|
|
|
|
if ($classSectionId <= 0) {
|
|
return redirect()->back()->withInput()->with('error', 'Select a class section.');
|
|
}
|
|
if ($schoolYear === '') {
|
|
return redirect()->back()->withInput()->with('error', 'School year is required.');
|
|
}
|
|
if ($semester === '') {
|
|
return redirect()->back()->withInput()->with('error', 'Semester is required.');
|
|
}
|
|
|
|
$file = $this->request->getFile('old_exam_file');
|
|
if (!$file || !$file->isValid()) {
|
|
return redirect()->back()->withInput()->with('error', 'A valid file is required.');
|
|
}
|
|
|
|
$stored = $this->storeUploadedFile($file, self::FINAL_UPLOAD_DIR, self::ADMIN_ALLOWED_EXTENSIONS);
|
|
if ($stored === null) {
|
|
return redirect()->back()->withInput()->with('error', 'File type not allowed or upload failed.');
|
|
}
|
|
|
|
$payload = [
|
|
'teacher_id' => $adminId, // store under admin user since legacy uploads are admin-only
|
|
'class_section_id' => $classSectionId,
|
|
'semester' => ucfirst(strtolower($semester)),
|
|
'school_year' => $schoolYear,
|
|
'exam_type' => $examType === '' ? null : $examType,
|
|
'draft_title' => $examType === '' ? 'Legacy Exam' : $examType,
|
|
'description' => null,
|
|
'final_file' => $stored,
|
|
'final_filename' => $file->getClientName(),
|
|
'status' => 'finalized',
|
|
'admin_id' => $adminId,
|
|
'reviewed_at' => utc_now(),
|
|
'version' => 1,
|
|
];
|
|
if ($this->hasIsLegacyColumn) {
|
|
$payload['is_legacy'] = 1;
|
|
}
|
|
|
|
$pdfName = null;
|
|
if (strtolower($file->getClientExtension()) === 'pdf') {
|
|
$pdfName = $stored;
|
|
} else {
|
|
$pdfName = $this->convertDocToPdf(
|
|
$this->fullUploadPath(self::FINAL_UPLOAD_DIR, $stored),
|
|
self::FINAL_UPLOAD_DIR
|
|
);
|
|
}
|
|
if ($pdfName !== null && $this->hasFinalPdfColumn) {
|
|
$payload['final_pdf_file'] = $pdfName;
|
|
}
|
|
|
|
if ($this->examDraftModel->insert($payload)) {
|
|
return redirect()->to('/administrator/exam-drafts')->with('success', 'Old exam uploaded successfully.');
|
|
}
|
|
|
|
return redirect()->back()->withInput()->with('error', 'Unable to save the old exam.');
|
|
}
|
|
|
|
public function adminReview()
|
|
{
|
|
$draftId = (int) ($this->request->getPost('draft_id') ?? 0);
|
|
if ($draftId <= 0) {
|
|
return redirect()->back()->with('error', 'Invalid submission selected.');
|
|
}
|
|
|
|
$draft = $this->examDraftModel->find($draftId);
|
|
if (empty($draft)) {
|
|
return redirect()->back()->with('error', 'Submission not found.');
|
|
}
|
|
|
|
$comments = trim((string) $this->request->getPost('admin_comments'));
|
|
$statusInput = trim((string) $this->request->getPost('review_status'));
|
|
$currentStatus = (string) ($draft['status'] ?? 'draft');
|
|
$status = $this->normalizeStatus(
|
|
$statusInput !== '' ? $statusInput : $currentStatus,
|
|
$currentStatus
|
|
);
|
|
$status = strtolower($status);
|
|
if (!in_array($status, $this->statusOptions(), true)) {
|
|
$status = 'reviewed';
|
|
}
|
|
$finalFile = null;
|
|
$finalFilename = null;
|
|
|
|
$file = $this->request->getFile('final_file');
|
|
if ($file && $file->isValid() && !$file->hasMoved()) {
|
|
$stored = $this->storeUploadedFile($file, self::FINAL_UPLOAD_DIR);
|
|
if ($stored === null) {
|
|
return redirect()->back()->with('error', 'Unable to store the final draft.')->withInput();
|
|
}
|
|
$finalFile = $stored;
|
|
$finalFilename = $file->getClientName();
|
|
// Only auto-finalize if the admin explicitly chose "finalized"
|
|
// (previously any uploaded file forced finalization)
|
|
if ($status === 'finalized') {
|
|
$status = 'finalized';
|
|
}
|
|
} elseif ($file && $file->getError() !== UPLOAD_ERR_NO_FILE) {
|
|
return redirect()->back()->with('error', 'Final file upload failed.');
|
|
}
|
|
|
|
$update = [
|
|
'status' => $status,
|
|
'admin_comments' => $comments === '' ? null : $comments,
|
|
'admin_id' => (int) (session()->get('user_id') ?? 0),
|
|
'reviewed_at' => utc_now(),
|
|
];
|
|
|
|
if ($finalFile !== null) {
|
|
$update['final_file'] = $finalFile;
|
|
$update['final_filename'] = $finalFilename;
|
|
$pdfName = $this->ensurePdfExists($finalFile, $file ? $file->getClientExtension() : null);
|
|
if ($pdfName !== null && $this->hasFinalPdfColumn) {
|
|
$update['final_pdf_file'] = $pdfName;
|
|
}
|
|
} elseif (strtolower($status) === 'finalized' && !empty($draft['teacher_file'])) {
|
|
// Auto-promote teacher file when admin finalizes without uploading a final
|
|
$copied = $this->copyDraftToFinal($draft['teacher_file']);
|
|
if ($copied !== null) {
|
|
$update['final_file'] = $copied;
|
|
$update['final_filename'] = $draft['teacher_filename'] ?? $draft['teacher_file'];
|
|
$pdfName = $this->ensurePdfExists($copied, pathinfo($copied, PATHINFO_EXTENSION));
|
|
if ($pdfName !== null && $this->hasFinalPdfColumn) {
|
|
$update['final_pdf_file'] = $pdfName;
|
|
}
|
|
}
|
|
}
|
|
if (strtolower($status) === 'finalized' && $this->hasIsLegacyColumn) {
|
|
$update['is_legacy'] = 1; // finalized exams move to Previous Exams
|
|
}
|
|
|
|
if ($this->hasIsLegacyColumn) {
|
|
// Keep existing legacy flag, do not set legacy automatically here
|
|
}
|
|
|
|
$updated = $this->examDraftModel
|
|
->set($update)
|
|
->where('id', $draftId)
|
|
->update();
|
|
|
|
if ($updated) {
|
|
return redirect()->back()->with('success', 'Review saved successfully.');
|
|
}
|
|
|
|
return redirect()->back()->with('error', 'Unable to save the review.');
|
|
}
|
|
|
|
private function resolveSelectedClassSection(array $assignments): int
|
|
{
|
|
$candidate = (int) ($this->request->getGet('class_section_id') ?? session()->get('class_section_id') ?? 0);
|
|
$validIds = array_map('intval', array_column($assignments, 'class_section_id'));
|
|
if ($candidate > 0 && in_array($candidate, $validIds, true)) {
|
|
return $candidate;
|
|
}
|
|
return $validIds[0] ?? 0;
|
|
}
|
|
|
|
private function statusBadgeMap(): array
|
|
{
|
|
return [
|
|
'draft' => [
|
|
'label' => 'Draft',
|
|
'class' => 'bg-secondary text-white',
|
|
],
|
|
'submitted' => [
|
|
'label' => 'Submitted',
|
|
'class' => 'bg-warning text-dark',
|
|
],
|
|
'reviewed' => [
|
|
'label' => 'Reviewed',
|
|
'class' => 'bg-info text-dark',
|
|
],
|
|
'finalized' => [
|
|
'label' => 'Finalized',
|
|
'class' => 'bg-success text-white',
|
|
],
|
|
'rejected' => [
|
|
'label' => 'Rejected',
|
|
'class' => 'bg-danger text-white',
|
|
],
|
|
];
|
|
}
|
|
|
|
private function statusOptions(): array
|
|
{
|
|
return ['draft', 'submitted', 'reviewed', 'finalized', 'rejected'];
|
|
}
|
|
|
|
private function normalizeStatus(string $input, string $default): string
|
|
{
|
|
$input = strtolower(trim($input));
|
|
$aliases = [
|
|
'pending' => 'submitted', // legacy value
|
|
'final' => 'finalized',
|
|
'approved' => 'finalized', // legacy value
|
|
];
|
|
if (isset($aliases[$input])) {
|
|
$input = $aliases[$input];
|
|
}
|
|
return in_array($input, $this->statusOptions(), true) ? $input : $default;
|
|
}
|
|
|
|
private function storeUploadedFile(UploadedFile $file, string $subdir, array $allowedExtensions = self::ALLOWED_EXTENSIONS): ?string
|
|
{
|
|
$ext = strtolower($file->getClientExtension());
|
|
if (!in_array($ext, $allowedExtensions, true)) {
|
|
return null;
|
|
}
|
|
if ($file->getSize() > self::MAX_UPLOAD_BYTES) {
|
|
return null;
|
|
}
|
|
|
|
$destination = WRITEPATH . 'uploads/' . trim($subdir, '/');
|
|
if (!is_dir($destination)) {
|
|
mkdir($destination, 0755, true);
|
|
}
|
|
|
|
$filename = $file->getRandomName();
|
|
try {
|
|
$file->move($destination, $filename);
|
|
return $filename;
|
|
} catch (\Throwable $e) {
|
|
log_message('error', 'ExamDraftController::storeUploadedFile error: ' . $e->getMessage());
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private function convertDocToPdf(string $sourcePath, string $targetSubdir): ?string
|
|
{
|
|
// Only attempt conversion for doc/docx
|
|
$ext = strtolower(pathinfo($sourcePath, PATHINFO_EXTENSION));
|
|
if (!in_array($ext, ['doc', 'docx'], true)) {
|
|
return null;
|
|
}
|
|
|
|
$targetDir = WRITEPATH . 'uploads/' . trim($targetSubdir, '/');
|
|
if (!is_dir($targetDir)) {
|
|
mkdir($targetDir, 0755, true);
|
|
}
|
|
|
|
$base = pathinfo($sourcePath, PATHINFO_FILENAME);
|
|
$targetPath = $targetDir . '/' . $base . '.pdf';
|
|
|
|
// Attempt conversion via LibreOffice if available
|
|
$cmd = 'soffice --headless --convert-to pdf --outdir ' . escapeshellarg($targetDir) . ' ' . escapeshellarg($sourcePath) . ' 2>/dev/null';
|
|
@exec($cmd);
|
|
|
|
return is_file($targetPath) ? basename($targetPath) : null;
|
|
}
|
|
|
|
private function schemaHasColumn(string $table, string $column): bool
|
|
{
|
|
try {
|
|
$fields = $this->db->getFieldNames($table);
|
|
return in_array($column, $fields, true);
|
|
} catch (\Throwable $e) {
|
|
log_message('error', "Schema check failed for {$table}.{$column}: " . $e->getMessage());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private function fullUploadPath(string $subdir, string $filename): string
|
|
{
|
|
return WRITEPATH . 'uploads/' . trim($subdir, '/') . '/' . $filename;
|
|
}
|
|
|
|
private function neighborPdfIfExists(?string $filename, string $subdir): ?string
|
|
{
|
|
if (empty($filename)) return null;
|
|
$path = $this->fullUploadPath($subdir, $filename);
|
|
$base = pathinfo($path, PATHINFO_FILENAME);
|
|
$dir = pathinfo($path, PATHINFO_DIRNAME);
|
|
$pdfPath = $dir . '/' . $base . '.pdf';
|
|
return is_file($pdfPath) ? basename($pdfPath) : null;
|
|
}
|
|
|
|
private function ensurePdfExists(string $finalFilename, ?string $originalExt): ?string
|
|
{
|
|
$pdfNeighbor = $this->neighborPdfIfExists($finalFilename, self::FINAL_UPLOAD_DIR);
|
|
if ($pdfNeighbor !== null) {
|
|
return $pdfNeighbor;
|
|
}
|
|
$ext = strtolower((string)$originalExt);
|
|
if ($ext === 'pdf') {
|
|
// final file itself is already pdf
|
|
$path = $this->fullUploadPath(self::FINAL_UPLOAD_DIR, $finalFilename);
|
|
return is_file($path) ? $finalFilename : null;
|
|
}
|
|
return $this->convertDocToPdf(
|
|
$this->fullUploadPath(self::FINAL_UPLOAD_DIR, $finalFilename),
|
|
self::FINAL_UPLOAD_DIR
|
|
);
|
|
}
|
|
|
|
private function copyDraftToFinal(string $draftFilename): ?string
|
|
{
|
|
$source = $this->fullUploadPath(self::TEACHER_UPLOAD_DIR, $draftFilename);
|
|
if (!is_file($source)) {
|
|
return null;
|
|
}
|
|
$destinationDir = WRITEPATH . 'uploads/' . trim(self::FINAL_UPLOAD_DIR, '/');
|
|
if (!is_dir($destinationDir)) {
|
|
mkdir($destinationDir, 0755, true);
|
|
}
|
|
$ext = pathinfo($draftFilename, PATHINFO_EXTENSION);
|
|
$destName = uniqid('final_', true) . '.' . $ext;
|
|
$destPath = $destinationDir . '/' . $destName;
|
|
if (!@copy($source, $destPath)) {
|
|
return null;
|
|
}
|
|
return $destName;
|
|
}
|
|
}
|