<?php
|
namespace JVBase\managers;
|
|
use JVBase\base\Site;
|
use JVBase\Instance;
|
use Exception;
|
use Imagick;
|
use JVBase\managers\queue\executors\UploadExecutor;
|
use JVBase\managers\queue\mergers\UploadMerger;
|
use JVBase\managers\queue\Queue;
|
use JVBase\managers\queue\TypeConfig;
|
use WP_Error;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
/**
|
* The goal here was mainly for membership sites, to organize files by userID, rather than the date structure.
|
* This way, if a user deletes their account, or performs a data request, we can simply copy their directory.
|
*
|
* I started with user name so we could search by name, but issues arose if a user changed their name/display name. So I set it to go to user_id.
|
*
|
* The general flow is:
|
* -> Upload, ensure files are stored in appropriate directory, usually {root}/tmp
|
* -> Conversion is queued with Queue, as with the /tmp cleanup
|
*
|
* Proposed directory structure:
|
* Site::has('membership') || Site::has('is_directory')
|
* -> defaults to {user_id}/{post_type}/file
|
* Default:
|
* -> defaults to {post_type}/file
|
* Drawback: if a post is uploaded to one post type, then used in another, the organization is slightly flawed.
|
*
|
* Also, we wanted to ensure images were converted to webp, for speed.
|
* -> The front-end javascript attempts to do this in browser
|
* -> If this couldn't be handled, it is queued for server processing
|
* Of course, some integrations (even google, sillies) only accept jpeg/png, so in some cases we need a jpeg fallback
|
*
|
*
|
*/
|
class UploadManager
|
{
|
use Instance;
|
protected array $allowedTypes = [
|
// Images
|
'image/jpeg' => 'image',
|
'image/png' => 'image',
|
'image/gif' => 'image',
|
'image/webp' => 'image',
|
// Videos
|
'video/mp4' => 'video',
|
'video/webm' => 'video',
|
'video/ogg' => 'video',
|
'video/ogv' => 'video',
|
'video/quicktime' => 'video',
|
'video/x-msvideo' => 'video',
|
// Documents
|
'application/pdf' => 'document',
|
'application/msword' => 'document',
|
'application/vnd.openxmlformats-officedocument.wordprocessingml.document' => 'document',
|
'application/vnd.ms-excel' => 'document',
|
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' => 'document',
|
'text/plain' => 'document',
|
'text/csv' => 'document',
|
'application/rtf' => 'document'
|
];
|
|
|
protected array $supportedFormats = [
|
'webp' => 'image/webp',
|
'jpeg' => 'image/jpeg',
|
'jpg' => 'image/jpeg',
|
'png' => 'image/png',
|
'gif' => 'image/gif'
|
];
|
|
protected array $defaultConfig = [
|
'allowed_types' => null, // null = all types allowed
|
'max_size' => [
|
'image' => 5242880, // 5MB
|
'video' => 104857600, // 100MB
|
'document' => 10485760 // 10MB
|
],
|
// Image settings
|
'convert' => 'webp',
|
'quality' => 80,
|
'optimize_images' => true,
|
'create_thumbnails' => true,
|
'use_imagick' => null,
|
// Video settings
|
'extract_video_thumbnail' => true,
|
'video_thumbnail_time' => 0,
|
// Document settings
|
'extract_document_preview' => false,
|
// Directory structure
|
'directory_pattern' => '{user_id}/{post_type}',
|
// General
|
'original_retention' => 2592000, // 30 days
|
];
|
|
/******************************************************************
|
* UPLOAD SETTINGS
|
******************************************************************/
|
/**
|
* @var array|int[] Max size of file types
|
*/
|
protected array $maxSize = [
|
'image' => 5242880, // 5MB
|
'video' => 104857600, // 100MB
|
'document' => 15728640 // 15MB
|
];
|
//Image Specific
|
/**
|
* @var bool Whether to convert the image
|
*/
|
protected bool $convertImage = true;
|
/**
|
* @var string Default image conversion
|
*/
|
protected string $convertImageTo = 'webp';
|
/**
|
* @var int Default image quality
|
*/
|
protected int $convertQuality = 80;
|
/**
|
* @var bool Whether to optimize images
|
*/
|
protected bool $optimizeImages = true;
|
/**
|
* @var bool Whether to create image thumbnails
|
*/
|
protected bool $createThumbnails = true;
|
//Video specific
|
/**
|
* @var bool Whether to automatically extract a thumbnail from a video
|
*/
|
protected bool $extractVideoThumbnail = true;
|
/**
|
* @var int Time, in microseconds, to grab thumbnail from
|
*/
|
protected int $videoThumbnailPosition = 0;
|
//Document specific
|
/**
|
* @var bool Whether to extract thumbnail from document.
|
*/
|
protected bool $extractDocumentThumbnail = false;
|
/**
|
* @var int How long to keep originals (default 3 months)
|
*/
|
protected int $keep_originals;
|
/******************************************************************
|
* UPLOAD DIRECTORIES
|
******************************************************************/
|
/**
|
* @var string WordPress' base upload directory
|
*/
|
protected string $upload_dir;
|
/**
|
* @var string WordPress' base upload directory url
|
*/
|
protected string $upload_url;
|
protected string $dir_pattern;
|
/*****************************************************************
|
* FEATURE FLAG
|
*****************************************************************/
|
protected bool $has_imagick = false;
|
private function __construct()
|
{
|
$upload = wp_upload_dir();
|
$this->upload_dir = $upload['basedir'];
|
$this->upload_url = $upload['baseurl'];
|
|
if (Site::has('membership') || Site::has('is_directory')) {
|
$this->dir_pattern = '{user_id}/{post_type}';
|
} else {
|
$this->dir_pattern = '{post_type}';
|
}
|
$this->has_imagick = extension_loaded('imagick');
|
$this->keep_originals = MONTH_IN_SECONDS * 3;
|
|
add_action('init', [$this, 'registerUploadExecutors'], 5);
|
}
|
|
/**
|
* Register upload operation types with the queue's TypeRegistry
|
*/
|
public function registerUploadExecutors(): void
|
{
|
$registry = Queue::getInstance()->registry();
|
$executor = new UploadExecutor();
|
$merger = new UploadMerger('secured_files');
|
|
// Image uploads - chunked at 5 files
|
$registry->register('image_upload', new TypeConfig(
|
mergeable: $merger,
|
executor: $executor,
|
chunkKey: 'secured_files',
|
chunkSize: 3
|
));
|
|
// Video uploads - one at a time (heavy processing)
|
$registry->register('video_upload', new TypeConfig(
|
mergeable: $merger,
|
executor: $executor,
|
chunkKey: 'secured_files',
|
chunkSize: 1
|
));
|
|
// Document uploads - chunked at 10
|
$registry->register('document_upload', new TypeConfig(
|
mergeable: $merger,
|
executor: $executor,
|
chunkKey: 'secured_files',
|
chunkSize: 5
|
));
|
|
// Metadata updates
|
$registry->register('update_image_meta', new TypeConfig(
|
executor: $executor
|
));
|
|
// Cleanup - chunked at 5
|
$registry->register('temporary_cleanup', new TypeConfig(
|
executor: $executor,
|
chunkKey: 'files',
|
chunkSize: 5
|
));
|
|
// Attach to content (depends on upload completing)
|
$registry->register('attach_upload_to_content', new TypeConfig(
|
executor: $executor
|
));
|
|
// Process upload groups into posts
|
$registry->register('process_upload_groups', new TypeConfig(
|
executor: $executor,
|
chunkKey: 'posts',
|
chunkSize: 5
|
));
|
}
|
|
/**
|
* @param string|array $file_path
|
* @param array $context
|
* @return ?string
|
* @throws Exception
|
*/
|
protected function testFile(string|array $file_path, array $context):?string
|
{
|
$file_type = null;
|
if (is_array($file_path)) {
|
if (!isset($file_path['tmp_name']) || $file_path['error'] !== UPLOAD_ERR_OK) {
|
throw new Exception('Invalid file upload');
|
}
|
$file_path = $file_path['tmp_name'];
|
}
|
// Validate file upload
|
if (!isset($file_path)) {
|
throw new Exception('Invalid file upload');
|
}
|
|
$mime_type = mime_content_type($file_path);
|
$file_type = $this->allowedTypes[$mime_type] ?? 'unknown';
|
if ($file_type === 'unknown') {
|
throw new Exception('Unsupported file type: ' . $mime_type);
|
}
|
|
// Check allowed types if specified
|
if (array_key_exists('allowed_types', $context) && !in_array($mime_type, $context['allowed_types'])) {
|
throw new Exception('File type not allowed: ' . $mime_type);
|
}
|
|
return $file_type;
|
}
|
|
/**
|
* Initial, basic processing of upload data for later processing through OperationQueue.php
|
* @param array $file_data
|
* @param array $context
|
* @return array
|
*/
|
public function secureUploadedFile(array $file_data, array $context): array
|
{
|
try {
|
$file_type = $this->testFile($file_data, $context);
|
|
$context['pattern'] = $this->dir_pattern.'/tmp';
|
$temp_dir = $this->generateDirectory($file_type, $context);
|
|
// Generate a unique filename for temporary storage
|
$temp_filename = uniqid() . '_' . sanitize_file_name($file_data['name']);
|
$temp_path = "{$this->upload_dir}/{$temp_dir}/{$temp_filename}";
|
|
// Move the uploaded file to our temporary storage
|
if (!move_uploaded_file($file_data['tmp_name'], $temp_path)) {
|
// Fallback to copy if needed
|
if (!copy($file_data['tmp_name'], $temp_path)) {
|
throw new Exception('Failed to store uploaded file');
|
}
|
}
|
|
// Return metadata about the stored file
|
return [
|
'temp_path' => $temp_path,
|
'original_name' => $file_data['name'],
|
'mime_type' => $file_data['type'],
|
'file_type' => $file_type,
|
'file_size' => $file_data['size'],
|
'stored_at' => current_time('mysql')
|
];
|
} catch (Exception $e) {
|
Errors::getInstance()->log('UploadManager','Failed to store uploaded file: ' . print_r($e->getMessage(), true));
|
return [];
|
}
|
}
|
|
/**
|
* Process an uploaded file with full context
|
*
|
* @param string $temp_path
|
* @param array $context Upload context and configuration
|
* @return array|WP_Error Result with attachment_id, url, file path
|
*/
|
public function processUpload(string $temp_path, array $context): array|WP_Error
|
{
|
try {
|
$file_type = $this->testFile($temp_path, $context);
|
|
// Extract context
|
$user_id = $context['user_id'] ?? get_current_user_id();
|
$post_id = $context['post_id'] ?? 0;
|
|
// Validate file size
|
$this->validateFileSize($temp_path, $file_type, $context);
|
|
// Generate directory structure for final storage
|
$directory = $this->generateDirectory($file_type, $context);
|
|
// Generate filename
|
$original_name = $context['original_name'] ?? basename($temp_path);
|
$filename = $this->generateFilename($original_name, $context);
|
|
// Process based on file type
|
return match($file_type) {
|
'image' => $this->processImage($temp_path, $directory, $filename, $post_id, $context),
|
'video' => $this->processVideo($temp_path, $directory, $filename, $post_id, $context),
|
'document' => $this->processDocument($temp_path, $directory, $filename, $post_id, $context),
|
default => throw new Exception('Unknown file type')
|
};
|
|
} catch (Exception $e) {
|
Errors::getInstance()->log(
|
'[UploadManager]:processUpload',
|
$e->getMessage(),
|
['temp_path' => $temp_path, 'context' => $context]
|
);
|
|
return new WP_Error('upload_failed', $e->getMessage());
|
}
|
}
|
|
|
/**
|
* Clean up empty temporary directories
|
*/
|
public function cleanupEmptyTempDirs(int $user_id): void
|
{
|
$temp_base = "{$this->upload_dir}/{$user_id}/temp";
|
|
if (!is_dir($temp_base)) {
|
return;
|
}
|
|
// Get all subdirectories
|
$dirs = glob($temp_base . '/*', GLOB_ONLYDIR);
|
|
foreach ($dirs as $dir) {
|
// Check if directory is empty
|
$files = scandir($dir);
|
$files = array_diff($files, ['.', '..']);
|
|
if (empty($files)) {
|
@rmdir($dir);
|
}
|
}
|
|
// Try to remove temp base if empty
|
$files = scandir($temp_base);
|
$files = array_diff($files, ['.', '..']);
|
if (empty($files)) {
|
@rmdir($temp_base);
|
}
|
}
|
|
/**
|
* Generate directory structure based on pattern
|
* @param string $file_type
|
* @param array $config
|
* @return string
|
* @throws Exception
|
*/
|
public function generateDirectory(string $file_type, array $config): string
|
{
|
$pattern = array_key_exists('pattern', $config) && is_string($config['pattern']) ? $config['pattern'] : $this->dir_pattern;
|
|
$pattern = explode('/', $pattern);
|
$parts = [];
|
foreach ($pattern as $part) {
|
$newPart = match($part) {
|
'{user_id}' => $context['user_id'] ?? null,
|
'{post_type}', '{content}' => $context['content'] ?? null,
|
'{tax}', '{taxonomy}' => $context['taxonomy'] ?? null,
|
'{term}' => $context['term'] ?? null,
|
'{file_type}' => $file_type,
|
'{year}' => date('Y'),
|
'{month}' => date('m'),
|
'{day}' => date('d'),
|
default => $part
|
};
|
if (is_null($newPart)) {
|
error_log('[Uploader] Pattern key was not provided for '.$part);
|
}
|
if (str_contains($newPart, '{')) {
|
error_log('[Uploader] Unhandled pattern found: '. $newPart);
|
}
|
$newPart = $this->sanitizeFileName($newPart);
|
$parts[] = $newPart;
|
}
|
//Remove any null values
|
$parts = array_filter($parts);
|
|
$directory = implode('/', $parts);
|
|
// Allow filtering
|
$directory = apply_filters('jvb_upload_directory', $directory, $file_type, $config);
|
|
// Ensure directories exist
|
$this->ensureDirectories($directory);
|
return $directory;
|
}
|
|
/**
|
* Ensure directory structure exists
|
*/
|
protected function ensureDirectories(string $rel_path): void
|
{
|
$dirs = [
|
"{$this->upload_dir}/{$rel_path}"
|
];
|
|
foreach ($dirs as $dir) {
|
if (!wp_mkdir_p($dir)) {
|
throw new Exception("Failed to create directory: {$dir}");
|
}
|
}
|
}
|
|
|
/**
|
* Validate file size based on type and config
|
* @param string $file_path
|
* @param string $file_type
|
* @param array $config
|
* @return void
|
* @throws Exception
|
*/
|
protected function validateFileSize(string $file_path, string $file_type, array $config): void
|
{
|
$size = filesize($file_path);
|
$max_size = $this->maxSize[$file_type];
|
if (array_key_exists('max_size', $config)) {
|
if (is_int($config['max_size'])) {
|
$max_size = $config['max_size'];
|
} else if (is_array($config['max_size']) && array_key_exists($file_type, $config['max_size'])) {
|
$max_size = $config['max_size'][$file_type];
|
}
|
}
|
|
if ($size > $max_size) {
|
$max_mb = round($max_size / 1048576, 2);
|
$actual_mb = round($size / 1048576, 2);
|
throw new Exception("File too large: {$actual_mb}MB (max: {$max_mb}MB)");
|
}
|
}
|
|
protected function validateMimeType(string $file_path, string $declared_type): bool
|
{
|
// Get actual MIME type
|
$actual_type = mime_content_type($file_path);
|
|
// Check if actual type is allowed
|
if (!array_key_exists($actual_type, $this->allowedTypes)) {
|
return false;
|
}
|
|
// For images, verify it's actually an image
|
if (str_starts_with($actual_type, 'image/')) {
|
$image_info = @getimagesize($file_path);
|
if ($image_info === false) {
|
return false;
|
}
|
}
|
|
return true;
|
}
|
|
/**
|
* Process image file
|
* @throws Exception
|
*/
|
protected function processImage(string $original_path, string $directory, string $filename, int $post_id, array $context): array
|
{
|
$full_dir = "{$this->upload_dir}/{$directory}";
|
$original_mime = mime_content_type($original_path);
|
|
// Determine if conversion is needed
|
$should_convert = false;
|
$target_format = false;
|
|
if ((array_key_exists('convert', $context) && $context['convert'] !== false) || $this->convertImage) {
|
$target_format = empty($context['convertTo']??'') ? $this->convertImage : $context['convertTo'];
|
if (!empty($target_format)) {
|
// Validate format
|
if (!isset($this->supportedFormats[$target_format])) {
|
error_log('[Uploader] Unsupported conversion format: '.$target_format.'... will not convert');
|
} else {
|
// Check if conversion is needed
|
$target_mime = $this->supportedFormats[$target_format];
|
$should_convert = ($original_mime !== $target_mime);
|
}
|
}
|
}
|
|
// Convert or copy based on configuration
|
if ($should_convert) {
|
$final_path = "{$full_dir}/{$filename}.{$target_format}";
|
|
try {
|
|
$this->convertImage(
|
$original_path,
|
$final_path,
|
$target_format,
|
array_key_exists('quality', $context) && is_int($context['quality']) && $context['quality'] <= 100 ?
|
$context['quality'] :
|
$this->convertQuality,
|
);
|
|
} catch (Exception $e) {
|
Errors::getInstance()->log('Uploader', 'Image conversion failed: ' . print_r($e->getMessage(), true));
|
// Fallback to original
|
$ext = pathinfo($original_path, PATHINFO_EXTENSION);
|
$final_path = "{$full_dir}/{$filename}.{$ext}";
|
copy($original_path, $final_path);
|
}
|
} else {
|
// Keep original format
|
$ext = pathinfo($original_path, PATHINFO_EXTENSION);
|
$final_path = "{$full_dir}/{$filename}.{$ext}";
|
copy($original_path, $final_path);
|
}
|
|
// Create attachment
|
$attachment_id = $this->createAttachment($final_path, $filename, $context, $post_id);
|
|
// Set alt text if provided
|
$alt_text = apply_filters('jvb_upload_alt_text', '', $context);
|
if ($alt_text !== '') {
|
update_post_meta($attachment_id, '_wp_attachment_image_alt', $alt_text);
|
}
|
|
// Generate thumbnails
|
$hasOption = array_key_exists('create_thumbnails', $context);
|
if (($hasOption && $context['create_thumbnails']) || (!$hasOption && $this->createThumbnails)) {
|
$this->generateThumbnails($attachment_id);
|
}
|
|
return [
|
'success' => true,
|
'attachment_id' => $attachment_id,
|
'url' => wp_get_attachment_url($attachment_id),
|
'file' => $final_path,
|
'type' => 'image',
|
'format' => $target_format ?: pathinfo($final_path, PATHINFO_EXTENSION),
|
'context' => $context
|
];
|
}
|
|
/**
|
* Process video file
|
* @throws Exception
|
*/
|
protected function processVideo(string $original_path, string $directory, string $filename, int $post_id, array $context): array
|
{
|
$full_dir = "{$this->upload_dir}/{$directory}";
|
$ext = pathinfo($original_path, PATHINFO_EXTENSION);
|
$final_path = "{$full_dir}/{$filename}.{$ext}";
|
|
// Copy video to final location
|
copy($original_path, $final_path);
|
|
// Create attachment
|
try {
|
$attachment_id = $this->createAttachment($final_path, $filename, $context, $post_id);
|
} catch (Exception $e) {
|
Errors::getInstance()->log('Uploader', 'Attachment creation failed: '.print_r($e->getMessage(), true));
|
return ['success' => false];
|
}
|
|
|
// Extract thumbnail if enabled
|
$hasOption = array_key_exists('extract_thumbnail', $context);
|
if (($hasOption && $context['extract_thumbnail']) || (!$hasOption && $this->extractVideoThumbnail)) {
|
$time = $context['thumbnail_time']??$this->videoThumbnailPosition;
|
$this->extractVideoThumbnail($attachment_id, $final_path, $time);
|
}
|
|
return [
|
'success' => true,
|
'attachment_id' => $attachment_id,
|
'url' => wp_get_attachment_url($attachment_id),
|
'file' => $final_path,
|
'type' => 'video',
|
'context' => $context
|
];
|
}
|
|
/**
|
* Process document file
|
*/
|
protected function processDocument(string $original_path, string $directory, string $filename, int $post_id, array $context): array
|
{
|
$full_dir = "{$this->upload_dir}/{$directory}";
|
$ext = pathinfo($original_path, PATHINFO_EXTENSION);
|
$final_path = "{$full_dir}/{$filename}.{$ext}";
|
|
// Copy document to final location
|
copy($original_path, $final_path);
|
|
// Create attachment
|
try {
|
$attachment_id = $this->createAttachment($final_path, $filename, $context, $post_id);
|
} catch (Exception $e) {
|
Errors::getInstance()->log('Uploader','Conversion failed: '.print_r($e->getMessage(), true));
|
return ['success' => false];
|
}
|
|
return [
|
'success' => true,
|
'attachment_id' => $attachment_id,
|
'url' => wp_get_attachment_url($attachment_id),
|
'file' => $final_path,
|
'type' => 'document',
|
'context' => $context
|
];
|
}
|
|
/**
|
* Generate SEO-friendly filename
|
*/
|
public function generateFilename(string $original_name, array $context): string
|
{
|
$name_parts = pathinfo($original_name);
|
$base_name = $this->sanitizeFileName($name_parts['filename']);
|
$user_data = array_key_exists('user_id', $context) ? get_userdata((int)$context['user_id']) : get_current_user();
|
$username = $user_data ? sanitize_title($user_data->display_name) : 'user';
|
$timestamp = time();
|
|
return $this->sanitizeFileName(apply_filters(
|
'jvb_upload_filename',
|
"{$base_name}-{$timestamp}",
|
$context
|
));
|
}
|
|
protected function sanitizeFileName(string $filename): string
|
{
|
// Remove path info
|
$filename = basename($filename);
|
|
// Remove special characters
|
$filename = preg_replace('/[^a-zA-Z0-9._-]/', '_', $filename);
|
|
// Remove multiple underscores
|
$filename = preg_replace('/_+/', '_', $filename);
|
|
// Ensure it's not too long (255 char limit in most filesystems)
|
if (strlen($filename) > 200) {
|
$ext = pathinfo($filename, PATHINFO_EXTENSION);
|
$name = pathinfo($filename, PATHINFO_FILENAME);
|
$name = substr($name, 0, 200 - strlen($ext) - 1);
|
$filename = $name . '.' . $ext;
|
}
|
|
return $filename;
|
}
|
|
/**
|
* Create WordPress attachment
|
*/
|
protected function createAttachment(string $file_path, string $title, array $context, int $post_id = 0): int
|
{
|
$file_url = str_replace($this->upload_dir, $this->upload_url, $file_path);
|
$mime_type = mime_content_type($file_path);
|
|
$title = apply_filters('jvb_upload_title', $title, $file_path, $context);
|
|
$attachment_id = wp_insert_attachment([
|
'guid' => $file_url,
|
'post_mime_type' => $mime_type,
|
'post_title' => $title,
|
'post_status' => 'inherit'
|
], $file_path, $post_id);
|
|
if (is_wp_error($attachment_id)) {
|
throw new Exception('Failed to create attachment');
|
}
|
|
require_once(ABSPATH . 'wp-admin/includes/image.php');
|
$metadata = wp_generate_attachment_metadata($attachment_id, $file_path);
|
wp_update_attachment_metadata($attachment_id, $metadata);
|
|
return $attachment_id;
|
}
|
|
|
/**
|
* Convert an existing attachment to a different format
|
*
|
* @param int $attachment_id WordPress attachment ID
|
* @param string $format Target format: 'webp', 'jpeg', 'png', 'gif'
|
* @param int $quality Conversion quality (1-100)
|
* @param bool $replace Replace original file (default: true)
|
* @return array|WP_Error Result with new attachment details
|
*/
|
public function convertImageTo(int $attachment_id, string $format, int $quality = 80, bool $replace = false): array|WP_Error
|
{
|
try {
|
// Validate format
|
$format = strtolower($format);
|
if (!isset($this->supportedFormats[$format])) {
|
throw new Exception("Unsupported format: {$format}");
|
}
|
|
// Get original file
|
$original_path = get_attached_file($attachment_id);
|
if (!$original_path || !file_exists($original_path)) {
|
throw new Exception('Original file not found');
|
}
|
|
// Check if it's an image
|
$mime_type = get_post_mime_type($attachment_id);
|
if (!str_starts_with($mime_type, 'image/')) {
|
throw new Exception('Attachment is not an image');
|
}
|
|
// Don't convert if already in target format
|
$current_mime = $this->supportedFormats[$format];
|
if ($mime_type === $current_mime) {
|
return [
|
'success' => true,
|
'message' => 'Already in target format',
|
'attachment_id' => $attachment_id,
|
'url' => wp_get_attachment_url($attachment_id)
|
];
|
}
|
|
// Generate new filename
|
$path_info = pathinfo($original_path);
|
$new_filename = $path_info['filename'] . '.' . $format;
|
$new_path = $path_info['dirname'] . '/' . $new_filename;
|
|
// Perform conversion
|
$this->convertImage($original_path, $new_path, $format, $quality);
|
|
if ($replace) {
|
// Replace the original file
|
$this->replaceAttachmentFile($attachment_id, $new_path, $current_mime);
|
$result_attachment_id = $attachment_id;
|
} else {
|
// Create new attachment
|
$post_id = wp_get_post_parent_id($attachment_id);
|
$result_attachment_id = $this->createAttachment(
|
$new_path,
|
get_the_title($attachment_id),
|
['user_id' => get_post_field('post_author', $attachment_id)],
|
$post_id
|
);
|
}
|
|
// Regenerate thumbnails
|
$this->generateThumbnails($result_attachment_id);
|
|
return [
|
'success' => true,
|
'attachment_id' => $result_attachment_id,
|
'url' => wp_get_attachment_url($result_attachment_id),
|
'format' => $format,
|
'file' => $new_path
|
];
|
|
} catch (Exception $e) {
|
return new WP_Error('conversion_failed', $e->getMessage());
|
}
|
}
|
|
/**
|
* Generic image conversion method
|
*/
|
/**
|
* @param string $source
|
* @param string $destination
|
* @param string $format
|
* @param int $quality
|
* @return void
|
* @throws Exception
|
*/
|
protected function convertImage(string $source, string $destination, string $format, int $quality): void
|
{
|
if ($this->has_imagick) {
|
$this->convertWithImagick($source, $destination, $format, $quality);
|
} else {
|
$this->convertWithGd($source, $destination, $format, $quality);
|
}
|
}
|
|
/**
|
* Convert image with Imagick
|
* @param string $source
|
* @param string $destination
|
* @param string $format
|
* @param int $quality
|
* @return void
|
* @throws Exception
|
*/
|
protected function convertWithImagick(string $source, string $destination, string $format, int $quality): void
|
{
|
try {
|
$image = new Imagick($source);
|
|
// Set format
|
$image->setImageFormat($format);
|
|
// Set quality
|
$image->setImageCompressionQuality($quality);
|
|
// Format-specific optimizations
|
if ($format === 'webp') {
|
$image->setOption('webp:method', '6'); // Better compression
|
} elseif ($format === 'jpeg' || $format === 'jpg') {
|
$image->setImageCompression(Imagick::COMPRESSION_JPEG);
|
} elseif ($format === 'png') {
|
$image->setImageCompression(Imagick::COMPRESSION_ZIP);
|
}
|
|
$image->writeImage($destination);
|
$image->clear();
|
} catch (Exception $e) {
|
throw new Exception("Imagick conversion to {$format} failed: " . $e->getMessage());
|
}
|
}
|
|
/**
|
* Convert image with GD
|
* @param string $source
|
* @param string $destination
|
* @param string $format
|
* @param int $quality
|
* @return void
|
* @throws Exception
|
*/
|
protected function convertWithGd(string $source, string $destination, string $format, int $quality): void
|
{
|
$mime_type = mime_content_type($source);
|
|
// Create image resource from source
|
$image = match($mime_type) {
|
'image/jpeg' => imagecreatefromjpeg($source),
|
'image/png' => imagecreatefrompng($source),
|
'image/gif' => imagecreatefromgif($source),
|
'image/webp' => imagecreatefromwebp($source),
|
default => throw new Exception('Unsupported source image type for GD conversion')
|
};
|
|
if (!$image) {
|
throw new Exception('Failed to create image resource');
|
}
|
|
// Convert to target format
|
$result = match($format) {
|
'webp' => imagewebp($image, $destination, $quality),
|
'jpeg', 'jpg' => imagejpeg($image, $destination, $quality),
|
'png' => imagepng($image, $destination, $this->qualityToPngCompression($quality)),
|
'gif' => imagegif($image, $destination),
|
default => throw new Exception("Unsupported target format for GD: {$format}")
|
};
|
|
imagedestroy($image);
|
|
if (!$result) {
|
throw new Exception("GD conversion to {$format} failed");
|
}
|
}
|
|
/**
|
* Convert quality (1-100) to PNG compression level (0-9)
|
*/
|
protected function qualityToPngCompression(int $quality): int
|
{
|
// PNG compression is inverted: 0 = no compression, 9 = max compression
|
// Quality: 100 = best quality, 1 = worst quality
|
// So: quality 100 -> compression 0, quality 1 -> compression 9
|
return (int) round((100 - $quality) / 11.11);
|
}
|
|
/**
|
* Generate image thumbnails
|
*/
|
protected function generateThumbnails(int $attachment_id): void
|
{
|
require_once(ABSPATH . 'wp-admin/includes/image.php');
|
$metadata = wp_generate_attachment_metadata($attachment_id, get_attached_file($attachment_id));
|
wp_update_attachment_metadata($attachment_id, $metadata);
|
}
|
|
/**
|
* Extract video thumbnail (placeholder - requires ffmpeg)
|
*/
|
protected function extractVideoThumbnail(int $attachment_id, string $video_path, int $time): void
|
{
|
// This would require ffmpeg or similar
|
// Placeholder for future implementation
|
apply_filters('jvb_extract_video_thumbnail', null, $attachment_id, $video_path, $time);
|
}
|
}
|
