namespace Controller\Custom { use Exception; use Imagick; use ImagickException; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use RecursiveDirectoryIterator; use RecursiveIteratorIterator; use Tqdev\PhpCrudApi\Cache\Cache; use Tqdev\PhpCrudApi\Column\ReflectionService; use Tqdev\PhpCrudApi\Controller\Responder; use Tqdev\PhpCrudApi\Database\GenericDB; use Tqdev\PhpCrudApi\Middleware\Router\Router; use Tqdev\PhpCrudApi\ResponseFactory; class FileManagerController { /**  * @var Responder $responder The responder instance used to send responses.  */ private $responder; /**  * @var Cache $cache The cache instance used for caching data.  */ private $cache; /**  * @var string ENDPOINT The directory where files are uploaded.  */ private const ENDPOINT = '/files'; /**  * @var string UPLOAD_FOLDER_NAME The name of the folder where files are uploaded.  */ private const UPLOAD_FOLDER_NAME = 'uploads'; /**  * @var int MIN_REQUIRED_DISK_SPACE The minimum required disk space for file uploads in bytes.  */ private const MIN_REQUIRED_DISK_SPACE = 104857600; // 100MB in bytes /**  * @var string $dir The directory where files are uploaded.  */ private $dir; /**  * @var array PHP_FILE_UPLOAD_ERRORS An array mapping PHP file upload error codes to error messages.  */ private const PHP_FILE_UPLOAD_ERRORS = [ 0 => 'There is no error, the file uploaded with success', 1 => 'The uploaded file exceeds the upload_max_filesize directive', 2 => 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form', 3 => 'The uploaded file was only partially uploaded', 4 => 'No file was uploaded', 6 => 'Missing a temporary folder', 7 => 'Failed to write file to disk.', 8 => 'A PHP extension stopped the file upload.', ]; /**  * @var array MIME_WHITE_LIST An array of allowed MIME types for file uploads.  */ private const MIME_WHITE_LIST = [ 'image/*', // Images 'video/*', // Videos 'audio/*', // Audios 'application/pdf', // PDF 'application/x-zip-compressed', // ZIP 'application/zip', // ZIP 'application/msword', // DOC 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', // DOCX 'application/vnd.ms-excel', // XLS 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // XLSX 'application/vnd.ms-powerpoint', // PPT 'application/vnd.openxmlformats-officedocument.presentationml.presentation', // PPTX 'application/xml', // XML 'text/xml', // XML 'application/json', // JSON 'text/csv', // CSV ]; /**  * FileManagerController constructor.  *  * This constructor initializes the FileManagerController by setting up the default directory,  * initializing the responder and cache instances, and registering the routes for file-related operations.  *  * @param Router $router The router instance used to register routes.  * @param Responder $responder The responder instance used to send responses.  * @param GenericDB $db The database instance used for database operations.  * @param ReflectionService $reflection The reflection service instance used for column reflection.  * @param Cache $cache The cache instance used for caching data.  */ public function __construct(Router $router, Responder $responder, GenericDB $db, ReflectionService $reflection, Cache $cache) { $this->dir = __DIR__ . DIRECTORY_SEPARATOR . $this::UPLOAD_FOLDER_NAME; $this->validateDefaultDir(); $this->responder = $responder; $this->cache = $cache; $router->register('GET', $this::ENDPOINT, array($this, '_initFileRequest')); $router->register('GET', $this::ENDPOINT . '/limits', array($this, '_initLimits')); $router->register('GET', $this::ENDPOINT . '/view', array($this, '_initFileView')); $router->register('GET', $this::ENDPOINT . '/download', array($this, '_initFileDownload')); $router->register('GET', $this::ENDPOINT . '/stats', array($this, '_initStats')); $router->register('GET', $this::ENDPOINT . '/img_resize', array($this, '_initImgResize')); $router->register('GET', $this::ENDPOINT . '/img_cpr', array($this, '_initImgCompress')); $router->register('POST', $this::ENDPOINT . '/upload', array($this, '_initFileUpload')); $router->register('POST', $this::ENDPOINT . '/move', array($this, '_initFileMove')); $router->register('POST', $this::ENDPOINT . '/rename', array($this, '_initFileRename')); $router->register('POST', $this::ENDPOINT . '/copy', array($this, '_initFileCopy')); $router->register('DELETE', $this::ENDPOINT . '/delete', array($this, '_initFileDelete')); } /**  * Retrieves statistics about the files and folders in the default directory.  *  * This method calculates the total size, number of files, and number of folders  * in the default directory. It returns a response containing these statistics.  *  * @param ServerRequestInterface $request The server request instance.  * @return ResponseInterface The response containing the statistics of the directory.  */ public function _initStats(ServerRequestInterface $request): ResponseInterface { $total_size = 0; $total_files = 0; $total_folders = 0; $directoryIterator = new RecursiveDirectoryIterator($this->dir, RecursiveDirectoryIterator::SKIP_DOTS); $iterator = new RecursiveIteratorIterator($directoryIterator, RecursiveIteratorIterator::SELF_FIRST); foreach ($iterator as $file) { if ($file->isFile()) { $total_size += $file->getSize(); $total_files++; } elseif ($file->isDir()) { $total_folders++; } } $total_size = $this->formatFileSize($total_size); return $this->responder->success([ 'total_files' => $total_files, 'total_folders' => $total_folders, 'total_size' => $total_size, ]); } /**  * Handles a file list request.  *  * This method processes a request to view the contents of a specified directory. It validates the input parameters,  * checks if the directory exists, and returns the list of files in the directory. If the directory is not found,  * it returns an appropriate error response.  *  * @param ServerRequestInterface $request The server request containing query parameters.  * @return ResponseInterface The response containing the list of files in the directory or an error message.  *  * Query Parameters:  * - dir (string, optional): The directory to view. Defaults to the root directory.  * - with_md5 (bool, optional): Whether to include the MD5 hash of the files in the response. Defaults to false.  * - recursive (bool, optional): Whether to recursively list files in subdirectories. Defaults to false.  *  * @throws Exception If there is an error during the file request process.  */ public function _initFileRequest(ServerRequestInterface $request): ResponseInterface { $body = $request->getQueryParams(); $requested_dir = $body['dir'] ?? null; $with_md5 = $body['with_md5'] ?? false; $recursive = $body['recursive'] ?? false; if ($requested_dir !== null) { $requested_dir = str_replace('/', DIRECTORY_SEPARATOR, $requested_dir); } $dir = $requested_dir ? $this->dir . DIRECTORY_SEPARATOR . $requested_dir : $this->dir; $show_dir = $requested_dir ? $requested_dir : 'root'; if (!is_dir($dir)) { return $this->responder->error(404, 'Directory not found'); } else { return $this->responder->success(['current_directory' => $show_dir, 'files' => $this->readFiles($dir, $with_md5, $recursive)]); } } /**  * Views a specified file.  *  * This method handles the viewing of a file from the specified directory. It validates the input parameters,  * checks if the file exists, and returns the file as a response for viewing. If the file is not found or  * any error occurs, it returns an appropriate error response.  *  * @param ServerRequestInterface $request The server request containing query parameters.  * @return ResponseInterface The response containing the file for viewing or an error message.  *  * Query Parameters:  * - filename (string): The name of the file to be viewed.  * - filedir (string, optional): The directory of the file to be viewed. Defaults to the root directory.  *  * @throws Exception If there is an error during the file viewing process.  */ public function _initFileView(ServerRequestInterface $request): ResponseInterface { $body = $request->getQueryParams(); $filename = $this->sanitizeFilename($body['filename']) ?? null; $filedir = $this->sanitizeDir($body['filedir'], true) ?? null; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } $filePath = $filedir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File not found'); } $mimeType = mime_content_type($filePath); $file = file_get_contents($filePath); $response = ResponseFactory::from(200, $mimeType, $file); $response = $response->withHeader('Content-Disposition', 'inline; filename=' . $filename); $response = $response->withHeader('X-Filename', $filename); return $response; } /**  * Handles file upload from the server request.  *  * @param ServerRequestInterface $request The server request containing the uploaded files.  * @return ResponseInterface The response indicating the result of the file upload process.  *  * The method performs the following steps:  * - Retrieves the uploaded files from the request.  * - Checks if any file is uploaded, returns an error response if no file is uploaded.  * - Parses the request body to get the directory path and compression options.  * - Creates the directory if it does not exist.  * - Processes each uploaded file:  * - Checks for upload errors.  * - Verifies memory limit for the file size.  * - Sanitizes the filename.  * - Verifies the MIME type of the file.  * - Checks if the file already exists in the directory.  * - If image compression is enabled and the file is an image, compresses the image and saves it as a .webp file.  * - Moves the uploaded file to the target directory.  * - Collects the result status for each file, including any errors encountered.  * - Returns a response with the overall result status, including the number of successfully uploaded files and errors.  */ public function _initFileUpload(ServerRequestInterface $request): ResponseInterface { $uploadedFiles = $request->getUploadedFiles(); $uploadedFiles = $uploadedFiles['file'] ?? null; if ($uploadedFiles === null) { return $this->responder->error(400, 'No file uploaded.'); } $body = $request->getParsedBody(); $dir = $this->sanitizeDir($body->dir, true); $compress_images = filter_var($body->compress_images ?? false, FILTER_VALIDATE_BOOLEAN, FILTER_NULL_ON_FAILURE) ?? false; $compress_images_quality = $this->sanitizeQualityValue($body->compress_images_quality) ?? 80; if ($dir === null) { return $this->responder->error(400, 'Invalid directory specified.'); } if (!is_dir($dir)) { mkdir($dir, 0755, true); } if (!is_array($uploadedFiles)) { $uploadedFiles = [$uploadedFiles]; } $result_status = []; $count = 0; $total_uploaded_successfully = 0; foreach ($uploadedFiles as $uploadedFile) { $count++; if ($uploadedFile->getError() === UPLOAD_ERR_OK) { if (!$this->checkMemoryLimit($uploadedFile->getSize())) { $result_status[$count] = [ 'status' => 'ERROR', 'message' => 'Not enough memory to process file, file not uploaded.', 'error' => 'Memory limit would be exceeded', 'file_name' => $uploadedFile->getClientFilename(), ]; continue; } $filename = $this->sanitizeFilename($uploadedFile->getClientFilename()); $tmpStream = $uploadedFile->getStream(); $tmpPath = $tmpStream->getMetadata('uri'); $isAllowed = $this->verifyMimeType($tmpPath); if (!$isAllowed) { $result_status[$count] = [ 'status' => 'ERROR', 'message' => 'Error uploading file', 'error' => 'Invalid file type!', 'file_name' => $uploadedFile->getClientFilename(), ]; continue; } if($compress_images && $this->isImage($tmpPath)){ $new_filename = $this->convertFileExtension($filename, 'webp'); if (file_exists($dir . DIRECTORY_SEPARATOR . $new_filename)) { $result_status[$count] = [ 'status' => 'ERROR', 'message' => 'Error uploading file', 'error' => 'File already exists in this directory', 'file_name' => $new_filename, ]; continue; } if ($this->isImage($tmpPath)) { try { $compressed_image = $this->compressImage($tmpPath, $compress_images_quality); $newFilePath = $dir . DIRECTORY_SEPARATOR . $new_filename; $compressed_image->writeImage($newFilePath); $result_status[$count] = [ 'compression_image_status' => 'OK', 'new_file_size' => $this->formatFileSize(filesize($newFilePath)), 'new_file_name' => $new_filename, 'new_file_md5' => md5_file($newFilePath), 'total_savings' => "-" . $this->formatFileSize(filesize($tmpPath) - filesize($newFilePath)), ]; } catch (Exception $e) { $result_status[$count] = [ 'compression_image_status' => 'ERROR', 'message' => 'Error during image compression: ' . $e->getMessage(), ]; } } else { $result_status[$count]['compression_image_status'] = "Not compressed, is not an image"; } } else { if (file_exists($dir . DIRECTORY_SEPARATOR . $filename)) { $result_status[$count] = [ 'status' => 'ERROR', 'message' => 'Error uploading file', 'error' => 'File already exists in this directory', 'file_name' => $uploadedFile->getClientFilename(), ]; continue; } $uploadedFile->moveTo($dir . DIRECTORY_SEPARATOR . $filename); $result_status[$count] = [ 'status' => 'OK', 'message' => 'File uploaded successfully', 'file_name' => $filename, 'file_size' => $this->formatFileSize($uploadedFile->getSize()), 'md5' => md5_file($dir . DIRECTORY_SEPARATOR . $filename), ]; } $total_uploaded_successfully++; } else { $result_status[$count] = [ 'status' => 'ERROR', 'message' => 'Error uploading file', 'file_name' => $uploadedFile->getClientFilename(), 'error' => $this::PHP_FILE_UPLOAD_ERRORS[$uploadedFile->getError()], ]; } } $result_status['total_uploaded_successfully'] = $total_uploaded_successfully . "/" . $count; $result_status['total_errors'] = $count - $total_uploaded_successfully; return $this->responder->success($result_status); } /**  * Downloads a specified file.  *  * This method handles the download of a file from the specified directory. It validates the input parameters,  * checks if the file exists, and returns the file as a response for download. If the file is not found or  * any error occurs, it returns an appropriate error response.  *  * @param ServerRequestInterface $request The server request containing query parameters.  * @return ResponseInterface The response containing the file for download or an error message.  *  * Query Parameters:  * - filename (string): The name of the file to be downloaded.  * - filedir (string, optional): The directory of the file to be downloaded. Defaults to the root directory.  *  * @throws Exception If there is an error during the file download process.  */ public function _initFileDownload(ServerRequestInterface $request): ResponseInterface { $body = $request->getQueryParams(); $filename = $this->sanitizeFilename($body['filename']) ?? null; $filedir = $this->sanitizeDir($body['filedir'], true) ?? null; if ($filename === null or $filename === "") { return $this->responder->error(400, 'No file specified'); } $filePath = $filedir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File not found'); } $response = ResponseFactory::from(200, 'application/octet-stream', file_get_contents($filePath)); $response = $response->withHeader('Content-Disposition', 'attachment; filename=' . $filename); return $response; } /**  * Deletes a specified file.  *  * This method deletes a file in the specified directory. It validates the input parameters,  * checks if the file exists, and attempts to delete it. If successful, it returns a success response.  *  * @param ServerRequestInterface $request The server request containing parsed body parameters.  * @return ResponseInterface The response indicating the result of the delete operation.  *  * Parsed Body Parameters:  * - filename (string): The name of the file to be deleted.  * - filedir (string, optional): The directory of the file to be deleted. Defaults to the root directory.  *  * @throws Exception If there is an error during the delete process.  */ public function _initFileDelete(ServerRequestInterface $request): ResponseInterface { $body = $request->getParsedBody(); $filename = $this->sanitizeFilename($body->filename) ?? null; $filedir = $this->sanitizeDir($body->filedir) ?? null; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } if ($filedir !== null) { $filedir = str_replace('/', DIRECTORY_SEPARATOR, $filedir); } else { $filedir = ''; } $filePath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found in this directory, nothing deleted'); } if (!$this->lockFile($filePath)) { return $this->responder->error(500, 'Unable to lock file for deletion'); } try { if (!unlink($filePath)) { return $this->responder->error(500, 'Error deleting file'); } return $this->responder->success(['message' => 'File [' . $filename . '] deleted successfully']); } finally { $this->unlockFile($filePath); } } /**  * Moves a specified file to a new directory.  *  * This method moves a file from its current directory to a new directory. It validates the input parameters,  * checks if the file exists, and attempts to move it. If successful, it returns a success response.  *  * @param ServerRequestInterface $request The server request containing parsed body parameters.  * @return ResponseInterface The response indicating the result of the move operation.  *  * Parsed Body Parameters:  * - filename (string): The name of the file to be moved.  * - filedir (string, optional): The current directory of the file. Defaults to the root directory.  * - new_dir (string): The new directory to move the file to.  *  * @throws Exception If there is an error during the move process.  */ public function _initFileMove(ServerRequestInterface $request): ResponseInterface { $body = $request->getParsedBody(); $filename = $this->sanitizeFilename($body->filename) ?? null; $filedir = $this->sanitizeDir($body->filedir) ?? null; $new_dir = $this->sanitizeDir($body->new_filedir) ?? null; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } if ($new_dir === null) { return $this->responder->error(400, 'No new directory specified'); } else { $new_dir = str_replace('/', DIRECTORY_SEPARATOR, $new_dir); } if ($filedir !== null) { $filedir = str_replace('/', DIRECTORY_SEPARATOR, $filedir); } else { $filedir = ''; } $filePath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $filename; $newPath = $this->dir . DIRECTORY_SEPARATOR . $new_dir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found, nothing moved'); } if (file_exists($newPath)) { return $this->responder->error(409, 'File [' . $filename . '] already exists in [' . $new_dir . ']. Nothing moved.'); } if (!is_dir($this->dir . DIRECTORY_SEPARATOR . $new_dir)) { mkdir($this->dir . DIRECTORY_SEPARATOR . $new_dir, 0755, true); } if (!$this->lockFile($filePath)) { return $this->responder->error(500, 'Unable to lock source file'); } if (!$this->lockFile($newPath)) { return $this->responder->error(500, 'Unable to lock dest file'); } try { if (!rename($filePath, $newPath)) { return $this->responder->error(500, 'Error moving file'); } return $this->responder->success(['message' => 'File [' . $filename . '] moved successfully to [' . $new_dir . ']']); } finally { $this->unlockFile($filePath); $this->unlockFile($newPath); } } /**  * Initializes the file copy process.  *  * @param ServerRequestInterface $request The server request containing the file details.  * @return ResponseInterface The response indicating the result of the file copy operation.  *  * The function performs the following steps:  * 1. Parses the request body to get the filename, current directory, and new directory.  * 2. Sanitizes the filename and directory paths.  * 3. Validates the presence of the filename and new directory.  * 4. Constructs the source and destination file paths.  * 5. Checks if the source file exists and if the destination file already exists.  * 6. Creates the new directory if it does not exist.  * 7. Locks the source and destination files to prevent concurrent access.  * 8. Copies the file from the source to the destination.  * 9. Unlocks the files after the copy operation.  * 10. Returns a success response if the file is copied successfully, or an error response if any step fails.  */ public function _initFileCopy(ServerRequestInterface $request): ResponseInterface { $body = $request->getParsedBody(); $filename = $this->sanitizeFilename($body->filename) ?? null; $filedir = $this->sanitizeDir($body->filedir, true) ?? null; $new_dir = $this->sanitizeDir($body->new_filedir, true) ?? null; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } if ($new_dir === null) { return $this->responder->error(400, 'No new directory specified'); } $filePath = $filedir . DIRECTORY_SEPARATOR . $filename; $newPath = $new_dir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found in ['. $filePath . '], nothing copied'); } if (!is_dir($new_dir)) { mkdir($new_dir, 0755, true); } if (file_exists($newPath)) { return $this->responder->error(409, 'File [' . $filename . '] already exists in [' . $new_dir . ']'); } // Lock only source file if (!$this->lockFile($filePath)) { return $this->responder->error(500, 'Unable to lock source file'); } try { if (!copy($filePath, $newPath)) { return $this->responder->error(500, 'Error copying file'); } return $this->responder->success(['message' => 'File [' . $filename . '] copied successfully to [' . $new_dir . ']']); } finally { $this->unlockFile($filePath); } } /**  * Renames a specified file.  *  * This method renames a file in the specified directory. It validates the input parameters,  * checks if the file exists, and attempts to rename it. If successful, it returns a success response.  *  * @param ServerRequestInterface $request The server request containing parsed body parameters.  * @return ResponseInterface The response indicating the result of the rename operation.  *  * Parsed Body Parameters:  * - filename (string): The current name of the file to be renamed.  * - new_filename (string): The new name for the file.  * - filedir (string, optional): The directory of the file to be renamed. Defaults to the root directory.  *  * @throws Exception If there is an error during the renaming process.  */ public function _initFileRename(ServerRequestInterface $request): ResponseInterface { $body = $request->getParsedBody(); $filename = $this->sanitizeFilename($body->filename) ?? null; $new_filename = $this->sanitizeFilename($body->new_filename) ?? null; $filedir = $this->sanitizeDir($body->filedir) ?? ''; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } if ($new_filename === null) { return $this->responder->error(400, 'No new filename specified'); } $filePath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $filename; $newPath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $new_filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found, nothing renamed'); } if (file_exists($newPath)) { return $this->responder->error(409, 'File [' . $new_filename . '] already exists in this directory. Nothing renamed.'); } if (!$this->lockFile($filePath)) { return $this->responder->error(500, 'Unable to lock source file'); } try { if (!rename($filePath, $newPath)) { return $this->responder->error(500, 'Error renaming file'); } return $this->responder->success(['message' => 'File [' . $filename . '] renamed successfully to [' . $new_filename . ']']); } finally { $this->unlockFile($newPath); } } /**  * Resizes an image to the specified dimension.  *  * This method checks if the Imagick extension is enabled, validates the input parameters,  * and resizes the specified image file to the desired dimension. The resized image  * is cached to improve performance for subsequent requests.  *  * @param ServerRequestInterface $request The server request containing query parameters.  * @return ResponseInterface The response containing the resized image or an error message.  *  * Query Parameters:  * - filedir (string): The directory of the file to be resized.  * - filename (string): The name of the file to be resized.  * - dimension (string): The dimension to resize ('width' or 'height').  * - dimension_value (int): The value of the dimension to resize to.  *  * @throws ImagickException If there is an error during image resizing.  */ public function _initImgResize(ServerRequestInterface $request): ResponseInterface { if (!extension_loaded('imagick')) { return $this->responder->error(500, 'Imagick extension is not enabled'); } $body = $request->getQueryParams(); $filedir = $this->sanitizeDir($body['filedir']) ?? null; $filename = $this->sanitizeFilename($body['filename']) ?? null; $dimension = $this->sanitizeDimension($body['dimension']) ?? null; $dimension_value = $this->sanitizeDimensionValue($body['dimension_value']) ?? null; if ($filedir !== null) { $filedir = str_replace('/', DIRECTORY_SEPARATOR, $filedir); } else { $filedir = ''; } if ($filename === null) { return $this->responder->error(400, 'No file specified'); } if ($dimension === null) { return $this->responder->error(400, 'No valid dimension specified'); } if ($dimension_value === null) { return $this->responder->error(400, 'No dimension value specified'); } $filePath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $filename; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found, nothing resized'); } if (!$this->isImage($filePath)) { return $this->responder->error(400, 'File is not an image'); } $fileHash = md5_file($filePath); $cacheKey = "resize_{$filename}_{$dimension}_{$dimension_value}_{$fileHash}"; if ($this->cache->get($cacheKey)) { $imageData = $this->cache->get($cacheKey); } else { try { $resized_img = $this->resizeImage($filePath, $dimension, $dimension_value); $imageData = $resized_img->getImageBlob(); $this->cache->set($cacheKey, $imageData); } catch (ImagickException $e) { return $this->responder->error(500, 'Error resizing image: ' . $e->getMessage()); } } $response = ResponseFactory::from(200, 'image', $imageData); $response = $response->withHeader('Content-Length', strlen($imageData)); $response = $response->withHeader('Content-Disposition', 'inline; filename=' . $filename); return $response; } /**  * Initializes image compression.  *  * This method checks if the Imagick extension is enabled, validates the input parameters,  * and compresses the specified image file to the desired quality. The compressed image  * is cached to improve performance for subsequent requests.  *  * @param ServerRequestInterface $request The server request containing query parameters.  * @return ResponseInterface The response containing the compressed image or an error message.  *  * Query Parameters:  * - filedir (string): The directory of the file to be compressed.  * - filename (string): The name of the file to be compressed.  * - quality (int): The quality of the compressed image (default is 80).  *  * @throws ImagickException If there is an error during image compression.  */ public function _initImgCompress(ServerRequestInterface $request): ResponseInterface { if (!extension_loaded('imagick')) { return $this->responder->error(500, 'Imagick extension is not enabled'); } $body = $request->getQueryParams(); $filedir = $this->sanitizeDir($body['filedir']) ?? ''; $filename = $this->sanitizeFilename($body['filename']) ?? null; $quality = $this->sanitizeQualityValue($body['quality']) ?? 80; if ($filename === null) { return $this->responder->error(400, 'No file specified'); } $filePath = $this->dir . DIRECTORY_SEPARATOR . $filedir . DIRECTORY_SEPARATOR . $filename; $fileHash = md5_file($filePath); $cacheKey = "compress_{$filename}_{$quality}_{$fileHash}"; if (!file_exists($filePath)) { return $this->responder->error(404, 'File [' . $filename . '] not found in this directory, nothing compressed'); } if (!$this->isImage($filePath)) { return $this->responder->error(400, 'File is not an image'); } if ($this->cache->get($cacheKey)) { $imageData = $this->cache->get($cacheKey); } else { try { $compressed_img = $this->compressImage($filePath, $quality); $imageData = $compressed_img->getImageBlob(); $this->cache->set($cacheKey, $imageData); } catch (ImagickException $e) { return $this->responder->error(500, 'Error compressing image: ' . $e->getMessage()); } } $response = ResponseFactory::from(200, 'image/webp', $imageData); $response = $response->withHeader('Content-Length', strlen($imageData)); $response = $response->withHeader('Content-Disposition', 'inline; filename=' . $filename); return $response; } /**  * Initializes the limits for file uploads based on server configuration.  *  * This method calculates the maximum file upload size by taking the minimum value  * between 'upload_max_filesize' and 'post_max_size' from the PHP configuration.  * It then returns a response with the maximum size in bytes, a formatted version  * of the maximum size, and a list of allowed MIME types.  *  * @param ServerRequestInterface $request The server request instance.  * @return ResponseInterface The response containing the upload limits and allowed MIME types.  */ public function _initLimits(ServerRequestInterface $request): ResponseInterface { $maxBytes = min( $this->convertToBytes(ini_get('upload_max_filesize')), $this->convertToBytes(ini_get('post_max_size')) ); return $this->responder->success([ 'max_size' => $maxBytes, 'max_size_formatted' => $this->formatFileSize($maxBytes), 'mime_types' => $this::MIME_WHITE_LIST, ]); } /**  * Validates the default directory path.  *  * This method performs several checks to ensure that the default directory path is valid:  * - Checks if the path is empty.  * - Attempts to create the directory if it does not exist.  * - Verifies that the path is a directory.  * - Checks if the directory is readable and writable.  * - Attempts to write and delete a test file in the directory.  *  * @return bool|ResponseInterface Returns true if the directory is valid, otherwise returns an error response.  */ public function validateDefaultDir(): bool | ResponseInterface { // Check if the path is empty if (empty($this->dir)) { return $this->responder->error(403, 'The default directory path cannot be empty. Config one first.'); } $minRequiredSpace = $this::MIN_REQUIRED_DISK_SPACE; $freeSpace = disk_free_space($this->dir); if ($freeSpace === false) { return $this->responder->error(500, "Cannot determine free space on disk."); } if ($freeSpace < $minRequiredSpace) { return $this->responder->error(500, sprintf( "Insufficient disk space. At least %s required, %s available", $this->formatFileSize($minRequiredSpace), $this->formatFileSize($freeSpace) )); } // If the directory does not exist, try to create it if (!file_exists($this->dir)) { try { if (!mkdir($this->dir, 0755, true)) { return $this->responder->error(403, "Unable to create the default directory: " . $this->dir); } // Check that the permissions have been set correctly chmod($this->dir, 0755); } catch (Exception $e) { return $this->responder->error(500, "Error creating the default directory: " . $e->getMessage()); } } // Check that it is a directory if (!is_dir($this->dir)) { return $this->responder->error(403, "The default dir path exists but is not a directory: " . $this->dir); } // Check permissions if (!is_readable($this->dir)) { return $this->responder->error(403, "The default directory is not readable: " . $this->dir); } if (!is_writable($this->dir)) { return $this->responder->error(403, "The default directory is not writable: " . $this->dir); } // Check if we can actually write a test file $testFile = $this->dir . DIRECTORY_SEPARATOR . '.write_test'; try { if (file_put_contents($testFile, '') === false) { return $this->responder->error(403, "Unable to write to the default directory."); } unlink($testFile); } catch (Exception $e) { return $this->responder->error(500, "Write test failed on default directory: " . $e->getMessage()); } if (!$this->generateSecurityServerFile()) { return $this->responder->error(500, "Error generating security file in the default directory."); } return true; } private function generateSecurityServerFile(): bool { $serverSoftware = strtolower($_SERVER['SERVER_SOFTWARE'] ?? ''); try { if (strpos($serverSoftware, 'apache') !== false) { return $this->generateApacheSecurityFile(); } elseif (strpos($serverSoftware, 'nginx') !== false) { return $this->generateNginxSecurityFile(); } return $this->generateApacheSecurityFile(); } catch (Exception $e) { return false; } } private function generateApacheSecurityFile(): bool { $securityFile = __DIR__ . DIRECTORY_SEPARATOR . '.htaccess'; $newContent = "# BEGIN PHP CRUD API FILE MANAGER\n" . '<Directory "/' . $this::UPLOAD_FOLDER_NAME . '">' . "\n" . ' Options -Indexes' . "\n" . ' Order deny,allow' . "\n" . ' Deny from all' . "\n" . '</Directory>' . "\n" . "# END PHP CRUD API FILE MANAGER"; return $this->appendConfigIfNotExists($securityFile, $newContent); } private function generateNginxSecurityFile(): bool { $securityFile = __DIR__ . DIRECTORY_SEPARATOR . 'nginx.conf'; $newContent = "# BEGIN PHP CRUD API FILE MANAGER\n" . 'location /' . $this::UPLOAD_FOLDER_NAME . ' {' . "\n" . ' deny all;' . "\n" . ' autoindex off;' . "\n" . '}' . "\n" . "# END PHP CRUD API FILE MANAGER"; return $this->appendConfigIfNotExists($securityFile, $newContent); } private function appendConfigIfNotExists(string $filePath, string $newContent): bool { if (file_exists($filePath)) { $currentContent = file_get_contents($filePath); if (strpos($currentContent, $newContent) !== false) { return true; // Configuration already exists } return file_put_contents($filePath, $currentContent . "\n" . $newContent) !== false; } return file_put_contents($filePath, $newContent) !== false; } /**  * Reads the files in the specified directory and returns an array of file information.  *  * @param string $dir The directory to read files from. If null, the default directory will be used.  * @param bool $with_md5 Whether to include the MD5 hash of the files in the returned array.  * @param bool $recursive Whether to read files recursively from subdirectories.  * @return array An array of file information. Each file information includes:  * - name: The name of the file.  * - type: The MIME type of the file.  * - path: The web path to the file.  * - size: The formatted size of the file (only for files, not directories).  * - created_on: The creation date of the file.  * - modified_on: The last modified date of the file.  * - md5: The MD5 hash of the file (if $with_md5 is true).  * - files: An array of files within the directory (if the file is a directory).  * @throws Exception If the directory cannot be opened.  */ public function readFiles($dir, $with_md5, $recursive): array { $dir = $dir ?? $this->dir; if (!is_dir($dir)) { return ["Error: dir requested not found"]; } $files = []; $current_dir = @opendir($dir); if ($current_dir === false) { throw new Exception("Impossibile aprire la directory: {$dir}"); } $isEmpty = true; while (($file = readdir($current_dir)) !== false) { if ($file === '.' || $file === '..') { continue; } $isEmpty = false; $filePath = $dir . DIRECTORY_SEPARATOR . $file; $viewWebPath = $this->getPublicUrl($file, 'view', $dir); $downloadWebPath = $this->getPublicUrl($file, 'download', $dir); try { $size = filesize($filePath); $formattedSize = $this->formatFileSize($size); // Get MIME type $mimeType = mime_content_type($filePath) ?: 'application/octet-stream'; if (is_dir($filePath)) { $files[] = [ 'name' => $file, 'type' => $mimeType, 'created_on' => date('Y-m-d H:i:s', filectime($filePath)), 'modified_on' => date('Y-m-d H:i:s', filemtime($filePath)), 'files' => $recursive ? $this->readFiles($filePath, $with_md5, $recursive) : 'Request recursivity to view files', ]; } else { $fileData = [ 'name' => $file, 'type' => $mimeType, 'view_url' => $viewWebPath, 'download_url' => $downloadWebPath, 'size' => $formattedSize, 'created_on' => date('Y-m-d H:i:s', filectime($filePath)), 'modified_on' => date('Y-m-d H:i:s', filemtime($filePath)), ]; if ($with_md5) { $fileData['md5'] = md5_file($filePath); } $files[] = $fileData; } } catch (Exception $e) { continue; // Skip files causing errors } } closedir($current_dir); if ($isEmpty) { return ["0: Empty directory"]; } sort($files); return $files; } /**  * Formats a file size in bytes to a human-readable format.  *  * @param int $size The file size in bytes.  * @return string The formatted file size.  */ public function formatFileSize(int $size): string { $units = ['bytes', 'KB', 'MB', 'GB']; $power = $size > 0 ? floor(log($size, 1024)) : 0; $formattedSize = number_format($size / pow(1024, $power), 2) . ' ' . $units[$power]; return $formattedSize; } /**  * Resizes an image to the specified dimension.  *  * @param string $img_src The source path of the image to be resized.  * @param string $dimension The dimension to resize ('width' or 'height').  * @param int $dimension_value The value of the dimension to resize to.  * @return bool|Imagick|ResponseInterface Returns the resized Imagick object on success, false on failure, or a ResponseInterface on invalid dimension.  * @throws ImagickException If an error occurs during image processing.  */ public function resizeImage($img_src, $dimension, $dimension_value): bool | Imagick | ResponseInterface { try { // Crea un nuovo oggetto Imagick $image = new Imagick($img_src); // Ottieni le dimensioni originali dell'immagine $originalWidth = $image->getImageWidth(); $originalHeight = $image->getImageHeight(); // Calcola le nuove dimensioni if ($dimension == 'width') { $newWidth = ceil($dimension_value); $newHeight = ceil(($originalHeight / $originalWidth) * $newWidth); } elseif ($dimension == 'height') { $newHeight = ceil($dimension_value); $newWidth = ceil(($originalWidth / $originalHeight) * $newHeight); } else { return $this->responder->error(400, 'Invalid dimension specified'); } // Ridimensiona l'immagine $image->resizeImage($newWidth, $newHeight, Imagick::FILTER_LANCZOS, 1); return $image; } catch (ImagickException $e) { echo "Errore: " . $e->getMessage(); return false; } } /**  * Compresses an image by reducing its quality and converting it to the WebP format.  *  * @param string $img_src The path to the source image file.  * @param int|string $quality The quality level for the compressed image (default is 80).  * @return bool|Imagick Returns the compressed Imagick object on success, or false on failure.  * @throws ImagickException If an error occurs during image processing.  */ public function compressImage($img_src, $quality = '80'): bool | Imagick { try { $image = new Imagick($img_src); $image->stripImage(); $image->setImageCompressionQuality($quality); $image->setImageFormat('webp'); return $image; } catch (ImagickException $e) { echo "Errore: " . $e->getMessage(); return false; } } /**  * Checks if the given file path points to a valid image.  *  * @param string $filePath The path to the file to check.  * @return bool True if the file is an image, false otherwise.  */ public function isImage($filePath): bool { $imageInfo = @getimagesize($filePath); if ($imageInfo === false) { return false; } $mimeType = $imageInfo['mime']; if (strpos($mimeType, 'image/') !== 0) { return false; } return true; } /**  * Convert a shorthand byte value from a PHP configuration directive to an integer value.  *  * @param string $value The shorthand byte value (e.g., '2M', '512K').  * @return int The byte value as an integer.  */ private function convertToBytes(string $val): int { if (empty($val)) { return 0; } $val = trim($val); $last = strtolower($val[strlen($val) - 1]); $multiplier = 1; switch ($last) { case 'g': $multiplier = 1024 * 1024 * 1024; break; case 'm': $multiplier = 1024 * 1024; break; case 'k': $multiplier = 1024; break; default: if (!is_numeric($last)) { $val = substr($val, 0, -1); } break; } return max(0, (int) $val * $multiplier); } /**  * Generates a public URL for a specified file.  *  * @param string|null $dir The directory of the file (optional).  * @param string $filename The name of the file.  * @param string $type The type of operation (default 'view').  * @return string The generated public URL.  */ private function getPublicUrl(string $filename, string $type = 'view', ?string $dir = null): string { $base = $_SERVER['HTTP_HOST'] . $_SERVER['SCRIPT_NAME']; $publicPath = $base . $this::ENDPOINT . '/' . $type . '?filename=' . urlencode($filename); if ($dir !== null) { $dir = str_replace(DIRECTORY_SEPARATOR, '/', $dir); $pos = strpos($dir, $this::UPLOAD_FOLDER_NAME); if ($pos !== false) { $dir = substr($dir, $pos + strlen($this::UPLOAD_FOLDER_NAME)); } if ($dir !== '') { $publicPath .= '&filedir=' . urlencode($dir); } } return $publicPath; } /**  * Sanitize a directory path to ensure it is safe and valid.  *  * This method normalizes directory separators, removes unsafe characters,  * and ensures the path does not traverse outside the root directory.  *  * @param string|null $path The directory path to sanitize. If null or empty, returns the root directory.  * @param bool $full Whether to return the full path or just the sanitized relative path.  * @return string The sanitized directory path. If the path is invalid, returns the root directory or null.  */ private function sanitizeDir(?string $path, bool $full = false): string { // Input validation if ($path === null || trim($path) === '') { return $full ? $this->dir . DIRECTORY_SEPARATOR : null; } // Normalize separators and remove leading/trailing spaces $path = trim(str_replace(['\\', '/'], DIRECTORY_SEPARATOR, $path)); // Remove directory traversal sequences $path = preg_replace('/\.{2,}/', '', $path); // Keep only safe characters for directory names // [a-zA-Z0-9] - alphanumeric characters // [\-\_] - dashes and underscores // [\s] - spaces  // [' . preg_quote(DIRECTORY_SEPARATOR) . '] - directory separator $path = preg_replace('/[^a-zA-Z0-9\-\_\s' . preg_quote(DIRECTORY_SEPARATOR) . ']/u', '', $path); // Remove multiple consecutive separators $path = preg_replace('/' . preg_quote(DIRECTORY_SEPARATOR) . '{2,}/', DIRECTORY_SEPARATOR, $path); // Remove leading/trailing separators $path = trim($path, DIRECTORY_SEPARATOR); // Build full path $fullPath = $this->dir . DIRECTORY_SEPARATOR . $path; // Verify path does not escape the root if (strpos($fullPath, $this->dir) !== 0) { return $full ? $this->dir . DIRECTORY_SEPARATOR : null; } return $full ? $fullPath : $path; } private function sanitizeFilename($filename): array | string | null { if ($filename === null) { return null; } else { strval($filename); } $filename = preg_replace('/[^a-zA-Z0-9\-\_\.\s]/', '', $filename); return $filename; } private function sanitizeDimension($dimension): string | null { $dimension = strval($dimension); $dimension = strtolower($dimension); return in_array($dimension, ['width', 'height']) ? $dimension : null; } private function sanitizeDimensionValue($dimension_value): int | null { $dimension_value = intval($dimension_value); $formatted = filter_var( $dimension_value, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1]] ); return $formatted !== false ? $formatted : null; } private function sanitizeQualityValue($quality_value): int | null { $quality_value = intval($quality_value); $formatted = filter_var( $quality_value, FILTER_VALIDATE_INT, ['options' => ['min_range' => 1, 'max_range' => 100]] ); return $formatted !== false ? $formatted : null; } private function verifyMimeType($filepath): bool { $finfo = finfo_open(FILEINFO_MIME_TYPE); $mimeType = finfo_file($finfo, $filepath); finfo_close($finfo); return $this->isMimeTypeAllowed($mimeType); } private function isMimeTypeAllowed(string $mimeType): bool { foreach ($this::MIME_WHITE_LIST as $allowedType) { $pattern = '#^' . str_replace('*', '.*', $allowedType) . '$#'; if (preg_match($pattern, $mimeType)) { return true; } } return false; } /**  * Checks if there is enough memory available to process a file of the given size.  *  * @param int $fileSize The size of the file in bytes  * @return bool True if there is enough memory, false otherwise  */ private function checkMemoryLimit(int $fileSize): bool { $memoryLimit = $this->convertToBytes(ini_get('memory_limit')); $currentMemory = memory_get_usage(); $neededMemory = $fileSize * 2.2; // Factor 2.2 for safe margin return ($currentMemory + $neededMemory) < $memoryLimit; } /**  * Locks a file for exclusive access.  *  * @param string $path The path to the file to lock.  * @return bool True if the file was successfully locked, false otherwise.  */ private function lockFile(string $path): bool { $fileHandle = fopen($path, 'r+'); if ($fileHandle === false) { return false; } if (!flock($fileHandle, LOCK_EX)) { fclose($fileHandle); return false; } return true; } /**  * Unlocks a file.  *  * @param string $path The path to the file to unlock.  * @return bool True if the file was successfully unlocked, false otherwise.  */ private function unlockFile(string $path): bool { $fileHandle = fopen($path, 'r+'); if ($fileHandle === false) { return false; } $result = flock($fileHandle, LOCK_UN); fclose($fileHandle); return $result; } /**  * Converts the file extension of a given filename to a new extension.  *  * @param string $filename The name of the file whose extension is to be changed.  * @param string $newExtension The new extension to be applied to the file.  * @return string The filename with the new extension.  */ private function convertFileExtension(string $filename, string $newExtension): string { $pathInfo = pathinfo($filename); return $pathInfo['filename'] . '.' . $newExtension; } } }