<?php
|
namespace JVBase\rest\routes;
|
|
use JVBase\JVB;
|
use JVBase\rest\RestRouteManager;
|
use JVBase\meta\MetaManager;
|
use JVBase\managers\UploadManager;
|
use JVBase\utility\Features;
|
use WP_REST_Request;
|
use WP_REST_Response;
|
use WP_Error;
|
use Exception;
|
|
if (!defined('ABSPATH')) {
|
exit; // Exit if accessed directly
|
}
|
class UploadRoutes extends RestRouteManager
|
{
|
|
public function __construct()
|
{
|
$this->action = 'dash-';
|
parent::__construct();
|
add_filter(BASE.'handle_bulk_operation', [$this, 'processOperation'], 10, 3);
|
}
|
|
/**
|
* Registers upload routes
|
* @return void
|
*/
|
public function registerRoutes():void
|
{
|
// Main upload endpoint
|
register_rest_route($this->namespace, '/uploads', [
|
'methods' => 'POST',
|
'callback' => [$this, 'handleUpload'],
|
'permission_callback' => [$this, 'checkPermission']
|
]);
|
|
register_rest_route($this->namespace, '/uploads/groups', [
|
'methods' => 'POST',
|
'callback' => [$this, 'handleGroupingRequest'],
|
'permission_callback' => [$this, 'checkPermission'],
|
'args' => [
|
'id' => [
|
'required' => true,
|
'type' => 'string',
|
'description' => 'Original upload operation ID'
|
],
|
'content' => [
|
'required' => true,
|
'type' => 'string'
|
],
|
'user' => [
|
'required' => true,
|
'type' => 'integer'
|
],
|
]
|
]);
|
|
register_rest_route($this->namespace, '/uploads/meta', [
|
'methods' => 'POST',
|
'callback' => [$this, 'handleMetadataUpdate'],
|
'permission_callback' => [$this, 'checkPermission'],
|
'args' => [
|
'user' => [
|
'type' => 'integer',
|
'required' => true
|
],
|
'items' => [
|
'type' => 'array',
|
'required' => true,
|
'description' => 'Direct attachment IDs (for updates after completion)',
|
],
|
]
|
]);
|
}
|
|
/**
|
* Build the main $context for UploadManager from the $request params
|
* @param WP_REST_Request $request
|
* @return array
|
*/
|
protected function buildUploadArgs(WP_REST_Request $request):array
|
{
|
$data = $request->get_params();
|
$args = [];
|
foreach ($data as $key => $value) {
|
switch ($key) {
|
// Post Type/Taxonomy
|
case 'content':
|
$key = str_replace('-', '_', $key);
|
if ($value === 'options' || array_key_exists($value, JVB_CONTENT) || Features::forTaxonomy($key)->has('is_content')) {
|
$args['content'] = $value;
|
}
|
break;
|
case 'destination':
|
if (in_array($value, ['meta', 'post', 'post_group'])) {
|
$args['destination'] = sanitize_text_field($value);
|
if (in_array($value, ['post', 'post_group']) && empty($data['content'])) {
|
throw new Exception("Content type required for destination: {$value}");
|
}
|
}
|
break;
|
// User ID
|
case 'user':
|
if ($this->userCheck($value)) {
|
$args['user'] = (int) $value;
|
if (!array_key_exists('post_id', $data) && !array_key_exists('term_id', $data)) {
|
$args['post_id'] = (int)get_user_meta((int) $value, BASE.'link', true);
|
}
|
}
|
break;
|
// Operation ID
|
case 'id':
|
if (is_string($value)) {
|
$value = sanitize_text_field($value);
|
$args['id'] = $value;
|
$args['upload'] = $value.'_upload';
|
}
|
break;
|
// Post ID
|
case 'post_id':
|
if (is_numeric($value)) {
|
$args['post_id'] = absint($value);
|
}
|
break;
|
// Term ID
|
case 'term_id':
|
if (is_numeric($value)) {
|
$args['term_id'] = absint($value);
|
}
|
break;
|
// Field Name, as defined for MetaManager.php
|
case 'field_name':
|
if (is_string($value)) {
|
$args['field_name'] = sanitize_text_field($value);
|
}
|
break;
|
// Upload Mode
|
case 'mode':
|
if (in_array($value, ['direct', 'selection'])) {
|
$args['mode'] = sanitize_text_field($value);
|
}
|
break;
|
case 'upload_ids':
|
if (is_string($value)) {
|
// Parse JSON array
|
$decoded = json_decode($value, true);
|
if (is_array($decoded)) {
|
$args['upload_ids'] = $decoded;
|
}
|
} elseif (is_array($value)) {
|
// Already an array (shouldn't happen with FormData JSON, but handle it)
|
$args['upload_ids'] = $value;
|
}
|
break;
|
case 'metadata':
|
if (!empty($value)) {
|
$metadata = is_string($value) ? json_decode($value, true) : $value;
|
if (is_array($metadata)) {
|
foreach ($metadata as $k => $v) {
|
if (in_array($k, ['title', 'caption', 'alt', 'depends_on'])) {
|
$args['metadata'][$k] = sanitize_text_field($v);
|
}
|
}
|
}
|
}
|
break;
|
case 'posts':
|
if (is_string($value)) {
|
$decoded = json_decode($value, true);
|
if (is_array($decoded)) {
|
$args['posts'] = $decoded;
|
}
|
}
|
break;
|
|
case 'group_titles':
|
if (is_string($value)) {
|
$decoded = json_decode($value, true);
|
if (is_array($decoded)) {
|
$args['group_titles'] = array_map('sanitize_text_field', $decoded);
|
}
|
}
|
break;
|
// Other field info
|
case 'field_key':
|
case 'field_type':
|
case 'subtype':
|
case 'item_id':
|
case 'context':
|
if (is_string($value)) {
|
$args[$key] = sanitize_text_field($value);
|
}
|
break;
|
}
|
}
|
return $args;
|
}
|
|
/**
|
* Handle upload request with immediate feedback
|
*/
|
/**
|
* @param WP_REST_Request $request
|
*
|
* @return WP_REST_Response
|
*/
|
public function handleUpload(WP_REST_Request $request): WP_REST_Response
|
{
|
try {
|
$files = $request->get_file_params();
|
$args = $this->buildUploadArgs($request);
|
|
if (!$args['content'] || !$args['user']) {
|
|
$this->logError('Missing required data');
|
return new WP_REST_Response([
|
'success' => false,
|
'message' => 'Missing required data'
|
]);
|
}
|
|
// Step 1: Secure all uploaded files
|
$secured_files = $this->secureFiles($files, $args);
|
|
if (empty($secured_files)) {
|
$this->logError('No valid files to upload');
|
return new WP_REST_Response([
|
'success' => false,
|
'message' => 'No valid files to upload'
|
]);
|
}
|
|
// Step 2: Queue for processing via OperationQueue
|
$operation_id = $this->queueProcessing($secured_files, $args);
|
|
return new WP_REST_Response([
|
'success' => true,
|
'operation_id' => $operation_id,
|
'file_count' => count($secured_files),
|
'message' => 'Files secured and queued for processing'
|
], 200);
|
|
} catch (Exception $e) {
|
// Error handling...
|
JVB()->error()->log(
|
'[UploadRoutes]:handleUploadRequest',
|
$e->getMessage(),
|
[
|
'request_data' => $request->get_params(),
|
'files_info' => $this->getFilesInfo($_FILES),
|
'trace' => $e->getTraceAsString()
|
]
|
);
|
|
return $this->sendResponse(
|
false,
|
['error_code' => 'upload_failed'],
|
'Upload processing failed: ' . $e->getMessage()
|
);
|
}
|
}
|
|
/**
|
* Secure uploaded files to temporary storage
|
*/
|
protected function secureFiles(array $files, array $args): array
|
{
|
$uploader = new UploadManager();
|
$secured_files = [];
|
$upload_map = [];
|
$errors = [];
|
|
$context = $args;
|
unset($context['upload_ids']);
|
|
$config = $this->getFieldConfig($args);
|
|
$file_array = $files['files'] ?? $files;
|
$tmp_names = isset($file_array['tmp_name'][0]) && is_array($file_array['tmp_name'][0])
|
? $file_array['tmp_name'][0]
|
: $file_array['tmp_name'];
|
|
foreach ($tmp_names as $index => $tmp_name) {
|
$file_data = isset($file_array['tmp_name'][0]) && is_array($file_array['tmp_name'][0]) ? [
|
'name' => $file_array['name'][0][$index],
|
'type' => $file_array['type'][0][$index],
|
'tmp_name' => $tmp_name,
|
'error' => $file_array['error'][0][$index],
|
'size' => $file_array['size'][0][$index]
|
] : [
|
'name' => $file_array['name'][$index],
|
'type' => $file_array['type'][$index],
|
'tmp_name' => $tmp_name,
|
'error' => $file_array['error'][$index],
|
'size' => $file_array['size'][$index]
|
];
|
|
if ($file_data['error'] !== UPLOAD_ERR_OK) {
|
$errors[$index] = $this->getUploadErrorMessage($file_data['error']);
|
continue;
|
}
|
|
try {
|
$secured = $uploader->secureUploadedFile($file_data, $context);
|
|
if (empty($secured)) {
|
throw new Exception('Failed to secure file');
|
}
|
|
$frontend_id = $args['upload_ids'][$index] ?? 'upload_' . $index;
|
$upload_map[$index] = $frontend_id;
|
|
$secured_files[] = $secured;
|
} catch (Exception $e) {
|
$errors[$index] = $e->getMessage();
|
}
|
}
|
|
return [
|
'files' => $secured_files,
|
'upload_map' => $upload_map,
|
'errors' => $errors
|
];
|
}
|
|
protected function getUploadErrorMessage(int $error_code): string
|
{
|
return match($error_code) {
|
UPLOAD_ERR_INI_SIZE => 'File exceeds maximum upload size',
|
UPLOAD_ERR_FORM_SIZE => 'File exceeds form maximum size',
|
UPLOAD_ERR_PARTIAL => 'File was only partially uploaded',
|
UPLOAD_ERR_NO_FILE => 'No file was uploaded',
|
UPLOAD_ERR_NO_TMP_DIR => 'Missing temporary folder',
|
UPLOAD_ERR_CANT_WRITE => 'Failed to write file to disk',
|
UPLOAD_ERR_EXTENSION => 'Upload stopped by extension',
|
default => 'Unknown upload error'
|
};
|
}
|
|
|
/**
|
* Queue files for processing
|
*/
|
protected function queueProcessing(array $secured_data, array $args):string
|
{
|
$operation_type = $this->determineOperationType($secured_data['files'][0] ?? []);
|
|
$chunkSize = 5;
|
if ($operation_type === 'video') {
|
$chunkSize = 1;
|
} elseif ($operation_type === 'document') {
|
$chunkSize = 10;
|
}
|
JVB()->queue()->queueOperation(
|
$operation_type,
|
$args['user'],
|
array_merge(
|
[
|
'secured_files' => $secured_data['files'],
|
'upload_map' => $secured_data['upload_map'],
|
],
|
$args
|
),
|
[
|
'operation_id' => $args['upload'],
|
'chunk_key' => 'secured_files',
|
'chunk_size' => $chunkSize
|
]
|
);
|
|
if ($args['mode'] !== 'selection') {
|
JVB()->queue()->queueOperation(
|
'attach_upload_to_content',
|
$args['user'],
|
$args,
|
[
|
'priority' => 'high',
|
'operation_id' => $args['id'],
|
'depends_on' => $args['upload']
|
]
|
);
|
}
|
|
JVB()->queue()->queueOperation(
|
'temporary_cleanup',
|
$args['user'],
|
[
|
'files' => $secured_data['files'],
|
'context' => $args,
|
],
|
[
|
'priority' => 'low',
|
'chunk_size' => 5,
|
'chunk_key' => 'files',
|
'depends_on' => $args['upload']
|
]
|
);
|
return $args['id'];
|
}
|
|
/**
|
* Determine operation type from file data
|
*/
|
protected function determineOperationType(array $file): string
|
{
|
$file_type = $file['file_type'] ?? 'image';
|
|
return match($file_type) {
|
'video' => 'video_upload',
|
'document' => 'document_upload',
|
default => 'image_upload'
|
};
|
}
|
|
/**
|
* Step 3: Process operation from queue
|
* Called by OperationQueue
|
* @param WP_Error|array $result
|
* @param object $operation
|
* @param array $data
|
*
|
* @return array|WP_Error
|
*/
|
public function processOperation(array $result, object $operation, array $data): array
|
{
|
// Only handle our operation types
|
$handled_types = [
|
'image_upload',
|
'video_upload',
|
'document_upload',
|
'update_metadata',
|
'temporary_cleanup',
|
'attach_upload_to_content',
|
'process_upload_groups'
|
];
|
|
if (!in_array($operation->type, $handled_types)) {
|
return $result; // Not our operation, pass through
|
}
|
|
try {
|
// Route to appropriate handler
|
$handler_result = match($operation->type) {
|
'image_upload' => $this->processImageUpload($operation, $data),
|
'video_upload' => $this->processVideoUpload($operation, $data),
|
'document_upload' => $this->processDocumentUpload($operation, $data),
|
'update_metadata' => $this->processUploadMeta($result, $operation, $data),
|
'temporary_cleanup' => $this->processTemporaryCleanup($result, $operation, $data),
|
'attach_upload_to_content' => $this->processAttachToContent($operation, $data),
|
'process_upload_groups' => $this->processUploadGroups($result, $operation, $data),
|
default => new WP_Error('unknown_type', 'Unknown operation type')
|
};
|
|
// Handle WP_Error
|
if (is_wp_error($handler_result)) {
|
return [
|
'success' => false,
|
'result' => $handler_result->get_error_message()
|
];
|
}
|
|
return $handler_result;
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:processOperation',
|
$e->getMessage(),
|
[
|
'operation_id' => $operation->id,
|
'operation_type' => $operation->type
|
]
|
);
|
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
/**
|
* Standardize processing result
|
*/
|
protected function standardizeResult(array $result): array
|
{
|
return [
|
'attachment_id' => $result['attachment_id'],
|
'url' => $result['url'],
|
'file' => $result['file'],
|
'upload_id' => $result['upload_id'] ?? null
|
];
|
}
|
|
protected function processAttachToContent(object $operation, array $data): array
|
{
|
try {
|
// Get the results from the upload operation
|
$upload_results = JVB()->queue()->getOperationValue($data['upload'], 'result', true);
|
|
if (empty($upload_results)) {
|
throw new Exception('No upload results found for operation: ' . $data['upload']);
|
}
|
|
// Now attach to the specified content
|
if (!empty($data['field_name'])) {
|
$this->updateFieldValue($data, $upload_results);
|
}
|
|
return [
|
'success' => true,
|
'result' => 'Attachments linked to content'
|
];
|
|
} catch (Exception $e) {
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
|
/**
|
* Cleanup temporary files after processing
|
*/
|
protected function cleanupTempFiles(array $secured_files, int $user_id): void
|
{
|
$uploader = new UploadManager();
|
|
foreach ($secured_files as $secured) {
|
if (!empty($secured['temp_path']) && file_exists($secured['temp_path'])) {
|
@unlink($secured['temp_path']);
|
}
|
}
|
|
// Clean up empty directories
|
$uploader->cleanupEmptyTempDirs($user_id);
|
}
|
|
/**
|
* Update field value with new attachment IDs
|
*/
|
protected function updateFieldValue(array $data, array $results): void
|
{
|
if ((!array_key_exists('post_id', $data) && !array_key_exists('term_id', $data) && !array_key_exists('user', $data)) && !array_key_exists('field_name', $data)) {
|
return;
|
}
|
|
$attachment_ids = array_column($results, 'attachment_id');
|
if (array_key_exists('post_id', $data)) {
|
$meta = new MetaManager($data['post_id'], 'post');
|
} elseif (array_key_exists('term_id', $data)) {
|
$meta = new MetaManager($data['term_id'], 'term');
|
} else {
|
$link = (int)get_user_meta($data['user'], BASE.'link');
|
$meta = new MetaManager($link, 'post');
|
}
|
|
// Get existing value
|
$existing = $meta->getValue($data['field_name']);
|
$existing_ids = !empty($existing) ? explode(',', $existing) : [];
|
|
// Merge with new IDs
|
$all_ids = array_unique(array_merge($existing_ids, $attachment_ids));
|
|
// Update with comma-separated string
|
$meta->updateValue($data['field_name'], implode(',', $all_ids));
|
}
|
|
/**
|
* Generic file upload processor - works for images, videos, documents
|
*/
|
protected function processFileUpload(object $operation, array $data, string $file_type): WP_Error|array
|
{
|
try {
|
$uploader = new UploadManager();
|
$processed_results = [];
|
$config = $this->getFieldConfig($data);
|
|
$args = $data;
|
unset($args['secured_files']);
|
unset($args['upload_map']);
|
|
foreach ($data['secured_files'] as $index => $secured_file) {
|
$result = $uploader->processUpload(
|
$secured_file['temp_path'],
|
array_merge(
|
$config,
|
[
|
'file_type' => $file_type,
|
'user_id' => $operation->user_id,
|
'post_id' => (int)($data['post_id'] ?? 0),
|
'term_id' => (int)($data['term_id'] ?? 0),
|
'original_name' => $secured_file['original_name'],
|
'mime_type' => $secured_file['mime_type'],
|
'content' => $data['content'] ?? '', // For directory pattern
|
]
|
)
|
);
|
|
if (!is_wp_error($result)) {
|
$standardized = $this->standardizeResult($result);
|
|
// Map to frontend upload ID
|
if (isset($data['upload_map'][$index])) {
|
$standardized['upload_id'] = $data['upload_map'][$index];
|
}
|
|
// Apply frontend metadata if provided
|
if (!empty($data['frontend_metadata'][$index])) {
|
$this->applyMeta(
|
$standardized['attachment_id'],
|
$data['frontend_metadata'][$index]
|
);
|
}
|
|
$processed_results[$standardized['upload_id']] = $standardized;
|
}
|
}
|
|
$this->handleUploadDestination($data, $processed_results);
|
|
// Cleanup temporary files
|
$this->cleanupTempFiles($data['secured_files'], $operation->user_id);
|
|
return [
|
'success' => true,
|
'result' => $processed_results
|
];
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:processFileUpload',
|
$e->getMessage(),
|
[
|
'operation_id' => $operation->id,
|
'file_type' => $file_type,
|
'user_id' => $operation->user_id
|
]
|
);
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
|
/**
|
* Process image uploads
|
*/
|
protected function processImageUpload(object $operation, array $data): WP_Error|array
|
{
|
return $this->processFileUpload($operation, $data, 'image');
|
}
|
|
/**
|
* Process video uploads
|
*/
|
protected function processVideoUpload(object $operation, array $data): WP_Error|array
|
{
|
return $this->processFileUpload($operation, $data, 'video');
|
}
|
|
/**
|
* Process document uploads
|
*/
|
protected function processDocumentUpload(object $operation, array $data): WP_Error|array
|
{
|
return $this->processFileUpload($operation, $data, 'document');
|
}
|
|
/**
|
* Process temporary cleanup operation
|
* Called by OperationQueue for 'temporary_cleanup' operations
|
*
|
* @param array $result
|
* @param object $operation
|
* @param array $data
|
* @return array
|
*/
|
protected function processTemporaryCleanup(array $result, object $operation, array $data): array
|
{
|
try {
|
// Cleanup temporary files if they exist
|
if (!empty($data['secured_files'])) {
|
$this->cleanupTempFiles($data['secured_files'], $operation->user_id);
|
}
|
|
// If specific temp paths provided
|
if (!empty($data['temp_paths']) && is_array($data['temp_paths'])) {
|
foreach ($data['temp_paths'] as $temp_path) {
|
if (file_exists($temp_path)) {
|
@unlink($temp_path);
|
}
|
}
|
}
|
|
// Cleanup empty temp directories for this user
|
if (!empty($operation->user_id)) {
|
$uploader = new UploadManager();
|
$uploader->cleanupEmptyTempDirs($operation->user_id);
|
}
|
|
return [
|
'success' => true,
|
'result' => 'Temporary files cleaned up successfully'
|
];
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:processTemporaryCleanup',
|
$e->getMessage(),
|
[
|
'operation_id' => $operation->id,
|
'user_id' => $operation->user_id
|
]
|
);
|
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
|
/**
|
* Handle metadata update requests
|
*/
|
public function handleMetadataUpdate(WP_REST_Request $request): WP_REST_Response
|
{
|
try {
|
$data = $request->get_params();
|
|
// Validate user permissions
|
if (!$this->userCheck($data['user'])) {
|
return $this->sendResponse(
|
false,
|
['error_code' => 'invalid_user'],
|
'Invalid user specified'
|
);
|
}
|
|
$items = $data['items']??false;
|
if (!$items) {
|
return $this->sendResponse(
|
true,
|
[
|
],
|
'No items to update'
|
);
|
}
|
$pending = [];
|
$attachments = array_filter($items, function ($item) {
|
return is_numeric($item);
|
}, ARRAY_FILTER_USE_KEY);
|
if (count($attachments) !== count($items)) {
|
$pending = array_filter($items, function ($item) {
|
return !is_numeric($item);
|
}, ARRAY_FILTER_USE_KEY);
|
}
|
|
|
if (!empty($attachments)) {
|
// Phase 2B: Direct attachment update (images already processed)
|
return $this->updateMeta($attachments, $data['user']);
|
}
|
elseif (!empty($pending)) {
|
// Phase 2A: Queue metadata update with dependency on upload operation
|
return $this->queueMetaUpdate($pending, $data['user']);
|
}
|
|
return $this->sendResponse(
|
false,
|
['error_code' => 'missing_identifiers'],
|
'Must provide either attachment_ids or operation_id'
|
);
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:handleMetadataUpdate',
|
$e->getMessage(),
|
[
|
'request_data' => $request->get_params(),
|
'trace' => $e->getTraceAsString()
|
]
|
);
|
|
return $this->sendResponse(
|
false,
|
['error_code' => 'metadata_update_failed'],
|
'Metadata update failed: ' . $e->getMessage()
|
);
|
}
|
}
|
/**
|
* Update metadata directly on completed attachments
|
*/
|
protected function updateMeta(array $data, int $user): WP_REST_Response
|
{
|
$updated_count = 0;
|
$errors = [];
|
|
foreach ($data as $attachment_id => $info) {
|
try {
|
// Verify attachment exists and user has permission
|
if (!$this->verifyAttachmentAccess($attachment_id, $user)) {
|
$errors[] = "No permission to edit attachment {$attachment_id}";
|
continue;
|
}
|
|
$this->applyMeta($attachment_id, $info);
|
$updated_count++;
|
|
} catch (Exception $e) {
|
$errors[] = "Failed to update attachment {$attachment_id}: " . $e->getMessage();
|
}
|
}
|
|
return $this->sendResponse(
|
$updated_count > 0,
|
[
|
'updated_count' => $updated_count,
|
'errors' => $errors,
|
'attachment_ids' => $data['attachment_ids']
|
],
|
$updated_count > 0 ?
|
"Updated metadata for {$updated_count} attachment(s)" :
|
'No attachments were updated'
|
);
|
}
|
/**
|
* Queue metadata update with dependency on upload operation
|
*/
|
protected function queueMetaUpdate(array $data, int $user): WP_REST_Response
|
{
|
$queue = JVB()->queue();
|
$depends_on = [];
|
$errors = [];
|
$original = count($data);
|
foreach ($data as $uploadID => $info) {
|
if (!array_key_exists('depends_on', $info)) {
|
unset($data[$uploadID]);
|
$errors[$uploadID] = $info;
|
continue;
|
}
|
if (!in_array($info['depends_on'], $depends_on)) {
|
$depends_on[] = $info['depends_on'];
|
}
|
}
|
$operationID = $queue->queueOperation(
|
'update_metadata',
|
$user,
|
$data,
|
[
|
'depends_on' => $depends_on,
|
'priority' => 'medium',
|
]
|
);
|
|
return $this->sendResponse(
|
true,
|
[
|
'operation_id' => $operationID,
|
'message' => "Successfully queued ".count($data)." of {$original} meta updates"
|
],
|
'Metadata update queued - will apply after upload completes'
|
);
|
}
|
|
/**
|
* Process metadata update operation (called by queue processor)
|
*/
|
public function processUploadMeta(WP_Error|array $result, object $operation, array $data): WP_Error|array
|
{
|
try {
|
if (!is_array($operation->depends_on)) {
|
$operation->depends_on = [$operation->depends_on];
|
}
|
$updated_count = 0;
|
$errors = [];
|
foreach ($operation->depends_on as $dependency) {
|
$operationData = JVB()->queue()->getOperation($dependency);
|
if (!$operationData || $operationData->status !== 'completed') {
|
throw new Exception('Original upload operation not found or not completed');
|
}
|
|
$uploadResults = json_decode($operationData->result, true);
|
if (!$uploadResults || !$uploadResults['success']) {
|
throw new Exception('Original upload operation failed');
|
}
|
$attachmentsToUpdate = array_filter($data, function ($item) use ($dependency) {
|
return $item['depends_on'] === $dependency;
|
});
|
|
$uploadIDToAttachment = $this->buildUploadToAttachmentMapping(
|
array_keys($attachmentsToUpdate),
|
$uploadResults['data']
|
);
|
|
if (empty($uploadIDToAttachment)) {
|
throw new Exception('No valid upload ID to attachment ID mappings found');
|
}
|
|
foreach ($uploadIDToAttachment as $uploadId => $attachmentId) {
|
try {
|
$this->applyMeta($attachmentId, $attachmentsToUpdate[$uploadId]);
|
$updated_count++;
|
} catch (Exception $e) {
|
$errors[] = "Upload {$uploadId} (Attachment {$attachmentId}): " . $e->getMessage();
|
}
|
}
|
}
|
|
return [
|
'success' => $updated_count > 0,
|
'result' => [
|
'updated_count' => $updated_count,
|
'mappings' => $uploadIDToAttachment,
|
'errors' => $errors,
|
'message' => "Applied metadata to {$updated_count} attachment(s)"
|
]
|
];
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:processUploadMeta',
|
$e->getMessage(),
|
[
|
'operation_id' => $operation->id,
|
'original_operation_id' => $data['original_operation_id'] ?? 'unknown'
|
]
|
);
|
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
|
protected function applyMeta(int $attachment_id, array $metadata): void
|
{
|
// Update alt text
|
if (!empty($metadata['alt'])) {
|
update_post_meta($attachment_id, '_wp_attachment_image_alt', sanitize_text_field($metadata['alt']));
|
}
|
$postUpdates = [];
|
// Update title
|
if (!empty($metadata['title'])) {
|
$postUpdates['post_title'] = $metadata['title'];
|
}
|
|
// Update caption
|
if (!empty($metadata['caption'])) {
|
$postUpdates['post_excerpt'] = sanitize_textarea_field($metadata['caption']);
|
}
|
|
if (!empty($postUpdates)) {
|
$postUpdates['ID'] = $attachment_id;
|
wp_update_post($postUpdates);
|
}
|
}
|
|
/**
|
* Build mapping from frontend upload IDs to WordPress attachment IDs
|
*/
|
protected function buildUploadToAttachmentMapping(array $upload_ids, array $results): array
|
{
|
$mapping = [];
|
|
foreach ($results as $result) {
|
if (!isset($result['upload_id']) || !isset($result['attachment_id'])) {
|
continue;
|
}
|
|
$upload_id = $result['upload_id'];
|
$attachment_id = $result['attachment_id'];
|
|
// Validate that this upload_id was requested
|
if (in_array($upload_id, $upload_ids)) {
|
$mapping[$upload_id] = $attachment_id;
|
}
|
}
|
|
return $mapping;
|
}
|
|
/**
|
* Verify user has access to attachment
|
*/
|
protected function verifyAttachmentAccess(int $attachment_id, int $user_id): bool
|
{
|
$attachment = get_post($attachment_id);
|
|
if (!$attachment || $attachment->post_type !== 'attachment') {
|
return false;
|
}
|
|
// Check if user owns the attachment or has admin privileges
|
return ($attachment->post_author == $user_id) || current_user_can('manage_options');
|
}
|
|
/**
|
* Get field configuration for upload processing
|
*/
|
protected function getFieldConfig(array $data): array
|
{
|
static $config_cache = [];
|
|
$cache_key = md5(json_encode([
|
$args['content'] ?? '',
|
$args['field_name'] ?? ''
|
]));
|
|
if (isset($config_cache[$cache_key])) {
|
return $config_cache[$cache_key];
|
}
|
|
$config = [
|
'allowed_types' => null,
|
'max_size' => null,
|
'convert' => 'webp',
|
'quality' => 80,
|
'create_thumbnails' => true,
|
];
|
|
// Get field definition from registry if available
|
if (!empty($args['content']) && !empty($args['field_name'])) {
|
$content_type = $args['content'];
|
$field_name = $args['field_name'];
|
|
if (array_key_exists($content_type, JVB_CONTENT)) {
|
$content_fields = JVB_CONTENT[$content_type]['fields'] ?? [];
|
if (array_key_exists($field_name, $content_fields)) {
|
$field_def = $content_fields[$field_name];
|
|
// Extract relevant config from field definition
|
$config = array_merge($config, [
|
'allowed_types' => $field_def['accepted_types'] ?? null,
|
'max_size' => $field_def['max_size'] ?? null,
|
'convert' => $field_def['convert'] ?? 'webp',
|
'quality' => $field_def['quality'] ?? 80,
|
'create_thumbnails' => $field_def['create_thumbnails'] ?? true,
|
]);
|
}
|
}
|
}
|
|
$config_cache[$cache_key] = $config;
|
return $config;
|
}
|
|
|
|
/**
|
* Get files info for error logging
|
*/
|
protected function getFilesInfo(array $files): array
|
{
|
return [
|
'files_count' => is_array($files['name']) ? count($files['name']) : 1,
|
'total_size' => is_array($files['size']) ? array_sum($files['size']) : $files['size'],
|
'file_types' => is_array($files['type']) ? array_unique($files['type']) : [$files['type']]
|
];
|
}
|
|
protected function sendResponse(bool $success, array $data = [], string $message = '', string $operation_id = ''): WP_REST_Response
|
{
|
$response = [
|
'success' => $success,
|
'message' => $message,
|
'data' => $data,
|
'timestamp' => current_time('mysql')
|
];
|
|
if ($operation_id) {
|
$response['operation_id'] = $operation_id;
|
}
|
|
return new WP_REST_Response($response);
|
}
|
|
|
|
|
|
public function handleGroupingRequest(WP_REST_Request $request): WP_REST_Response
|
{
|
try {
|
$files = $request->get_file_params();
|
$args = $this->buildUploadArgs($request);
|
$data = $request->get_params();
|
|
if (!$args['content'] || !$args['user'] || !$args['posts']) {
|
|
$this->logError('Missing required data');
|
return new WP_REST_Response([
|
'success' => false,
|
'message' => 'Missing required data'
|
]);
|
}
|
|
// Secure files to temporary storage
|
$secured_files = $this->secureFiles($files, $args);
|
|
if (empty($secured_files['files'])) {
|
return $this->sendResponse(
|
false,
|
['error_code' => 'no_files'],
|
'No valid files to upload'
|
);
|
}
|
|
// Queue file upload operation
|
$operation_type = $this->determineOperationType($secured_data['files'][0] ?? []);
|
$chunkSize = 5;
|
if ($operation_type === 'video') {
|
$chunkSize = 1;
|
} elseif ($operation_type === 'document') {
|
$chunkSize = 10;
|
}
|
|
JVB()->queue()->queueOperation(
|
$operation_type,
|
$args['user'],
|
array_merge(
|
[
|
'secured_files' => $secured_files['files'],
|
'upload_map' => $secured_files['upload_map'],
|
],
|
$args
|
),
|
[
|
'operation_id' => $args['upload'],
|
'chunk_key' => 'secured_files',
|
'chunk_size' => $chunkSize
|
]
|
);
|
|
JVB()->queue()->queueOperation(
|
'process_upload_groups',
|
$args['user'],
|
$args,
|
[
|
'operation_id' => $args['id'],
|
'depends_on' => [$args['upload']],
|
'priority' => 'high'
|
]
|
);
|
|
return $this->sendResponse(
|
true,
|
[
|
'operation_id' => $args['id'],
|
'upload_operation_id' => $args['upload'],
|
'post_count' => count($args['posts']),
|
'file_count' => count($secured_files['files'])
|
],
|
'Files uploaded and posts queued for creation'
|
);
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:handleGroupingRequest',
|
$e->getMessage(),
|
[
|
'request_data' => $request->get_params(),
|
'trace' => $e->getTraceAsString()
|
]
|
);
|
|
return $this->sendResponse(
|
false,
|
['error_code' => 'grouping_failed'],
|
'Grouping operation failed: ' . $e->getMessage()
|
);
|
}
|
}
|
|
protected function processUploadGroups(WP_Error|array $result, object $operation, array $data): WP_Error|array
|
{
|
try {
|
$queue = JVB()->queue();
|
$all_uploaded_images = [];
|
|
// Get the upload operation ID from data
|
$dependencies = json_decode($operation->dependencies, true);
|
$uploads = [];
|
foreach($dependencies as $dependency) {
|
$op = $queue->getOperation($dependency);
|
|
$res = json_decode($op->result, true);
|
if ($op->status === 'completed') {
|
$uploads = array_merge($uploads, $res);
|
}
|
}
|
|
|
if (empty($uploads)) {
|
return [
|
'success' => false,
|
'result' => 'No uploads to process'
|
];
|
}
|
|
// Build map of upload_id => attachment_id
|
foreach ($uploads as $img) {
|
if (isset($img['upload_id'], $img['attachment_id'])) {
|
$all_uploaded_images[$img['upload_id']] = [
|
'upload_id' => $img['upload_id'],
|
'attachment_id' => (int)$img['attachment_id']
|
];
|
}
|
}
|
|
$content = jvbCheckBase($data['content']);
|
$user = (int)$data['user'];
|
$created_posts = [];
|
$used_upload_ids = [];
|
|
// Create posts from groups
|
foreach ($data['posts'] as $index => $post) {
|
$post_title = !empty($post['fields']['post_title'])
|
? sanitize_text_field($post['fields']['post_title'])
|
: 'New ' . JVB_CONTENT[$content]['singular'] . ' ' . ($index + 1);
|
|
$post_excerpt = !empty($post['fields']['post_excerpt'])
|
? sanitize_textarea_field($post['fields']['post_excerpt'])
|
: '';
|
|
$new_post_id = wp_insert_post([
|
'post_type' => $content,
|
'post_author' => $user,
|
'post_status' => 'draft',
|
'post_title' => $post_title,
|
'post_excerpt' => $post_excerpt,
|
]);
|
|
if ($new_post_id && !is_wp_error($new_post_id)) {
|
$created_posts[] = $new_post_id;
|
|
// Get featured image upload_id
|
$featured_upload_id = (int)$post['fields']['featured'] ?? null;
|
$featured_attachment_id = null;
|
$gallery_attachment_ids = [];
|
|
// Process all images for this post
|
foreach ($post['images'] as $key => $img) {
|
$upload_id = $img['upload_id'];
|
$used_upload_ids[] = $upload_id;
|
|
if (isset($all_uploaded_images[$upload_id])) {
|
$attachment_id = (int)$all_uploaded_images[$upload_id]['attachment_id'];
|
|
if ($upload_id === $featured_upload_id) {
|
$featured_attachment_id = $attachment_id;
|
} else {
|
$gallery_attachment_ids[] = $attachment_id;
|
}
|
}
|
}
|
|
// Set featured image
|
if ($featured_attachment_id) {
|
set_post_thumbnail($new_post_id, (int)$featured_attachment_id);
|
} elseif (!empty($gallery_attachment_ids)) {
|
// If no featured set, use first image
|
set_post_thumbnail($new_post_id, (int)$gallery_attachment_ids[0]);
|
array_shift($gallery_attachment_ids);
|
}
|
|
// Set gallery images
|
if (!empty($gallery_attachment_ids)) {
|
$meta = new MetaManager($new_post_id, 'post');
|
$fields = jvbGetFields($content, 'post');
|
|
foreach ($fields as $name => $config) {
|
if ($config['type'] === 'gallery') {
|
$meta->updateValue($name, implode(',', $gallery_attachment_ids));
|
break;
|
}
|
}
|
}
|
}
|
}
|
|
return [
|
'success' => true,
|
'result' => [
|
'created_posts' => $created_posts,
|
'total_posts' => count($created_posts),
|
'used_images' => count($used_upload_ids),
|
'message' => "Created " . count($created_posts) . " post(s) from uploads"
|
]
|
];
|
|
} catch (Exception $e) {
|
JVB()->error()->log(
|
'[UploadRoutes]:processUploadGroups',
|
$e->getMessage(),
|
[
|
'operation_id' => $operation->id,
|
'user_id' => $operation->user_id
|
]
|
);
|
|
return [
|
'success' => false,
|
'result' => $e->getMessage()
|
];
|
}
|
}
|
|
protected function cleanupUnusedImages(array $unused_images): array
|
{
|
$cleaned_count = 0;
|
$errors = [];
|
|
foreach ($unused_images as $upload_id => $image_data) {
|
try {
|
$attachment_id = $image_data['attachment_id'];
|
|
// Verify this attachment exists and wasn't already deleted
|
if (get_post($attachment_id)) {
|
// Delete the attachment and its files
|
$deleted = wp_delete_attachment($attachment_id, true);
|
|
if ($deleted) {
|
$cleaned_count++;
|
} else {
|
$errors[] = "Failed to delete attachment {$attachment_id} for upload {$upload_id}";
|
}
|
} else {
|
// Attachment already doesn't exist, count as cleaned
|
$cleaned_count++;
|
}
|
|
} catch (Exception $e) {
|
$errors[] = "Error cleaning up upload {$upload_id}: " . $e->getMessage();
|
}
|
}
|
|
return [
|
'cleaned_count' => $cleaned_count,
|
'errors' => $errors
|
];
|
}
|
|
function getAttachmentID(array $image, array $storedResults): int|false
|
{
|
foreach ($storedResults as $operationID => $uploads) {
|
foreach ($uploads as $upload) {
|
// FIX: Handle both case variations
|
$stored_upload_id = $upload['upload_id'];
|
$search_upload_id = $image['upload_id'];
|
|
if ($stored_upload_id === $search_upload_id) {
|
return (int)$upload['attachment_id'];
|
}
|
}
|
}
|
return false;
|
}
|
|
function extractFeaturedItem(array &$items, string $meta_key = 'featured'): array
|
{
|
// Handle empty array
|
if (empty($items)) {
|
return [
|
'featured' => null,
|
'remaining' => []
|
];
|
}
|
|
$featured_index = null;
|
|
// First pass: look for featured item
|
foreach ($items as $index => $item) {
|
if (isset($item['meta'][$meta_key])) {
|
$featured_index = $index;
|
break;
|
}
|
}
|
|
// If no featured item found, use first item (index 0)
|
if ($featured_index === null) {
|
$featured_index = 0;
|
}
|
|
// Extract the featured/first item
|
$featured = $items[$featured_index];
|
|
// Remove the item from the original array
|
unset($items[$featured_index]);
|
|
// Re-index the array to maintain sequential indices
|
$remaining = array_values($items);
|
|
return [
|
'featured' => $featured,
|
'remaining' => $remaining
|
];
|
}
|
|
protected function mapUploadIdsToAttachments(array $uploadIds, array $uploadedImages): array
|
{
|
$mappedImages = [];
|
|
foreach ($uploadIds as $uploadId) {
|
$imageData = $this->findImageByUploadId($uploadId, $uploadedImages);
|
if ($imageData) {
|
$mappedImages[] = $imageData;
|
}
|
}
|
|
return $mappedImages;
|
}
|
|
protected function findImageByUploadId(string $uploadId, array $uploadedImages): ?array
|
{
|
// Handle both flat array and grouped results
|
foreach ($uploadedImages as $image) {
|
if (is_array($image)) {
|
// If it's a grouped result, check each image in the group
|
if (isset($image[0]) && is_array($image[0])) {
|
foreach ($image as $groupImage) {
|
if (isset($groupImage['upload_id']) && $groupImage['upload_id'] === $uploadId) {
|
return $groupImage;
|
}
|
}
|
} else {
|
// Single image result
|
if (isset($image['upload_id']) && $image['upload_id'] === $uploadId) {
|
return $image;
|
}
|
}
|
}
|
}
|
|
return null;
|
}
|
|
protected function determineFeaturedImage(array $group, array $groupImages): ?int
|
{
|
// Check if user has starred a specific image
|
if (!empty($group['featured_upload_id'])) {
|
foreach ($groupImages as $image) {
|
if (isset($image['upload_id']) && $image['upload_id'] === $group['featured_upload_id']) {
|
return $image['attachment_id'];
|
}
|
}
|
}
|
|
// Default to first image
|
return !empty($groupImages) ? $groupImages[0]['attachment_id'] : null;
|
}
|
|
protected function sanitizeGroupMetadata(array $metadata): array
|
{
|
$sanitized = [];
|
|
foreach ($metadata as $key => $value) {
|
$sanitizedKey = sanitize_key($key);
|
|
if (is_string($value)) {
|
$sanitized[$sanitizedKey] = sanitize_text_field($value);
|
} elseif (is_array($value)) {
|
$sanitized[$sanitizedKey] = array_map('sanitize_text_field', $value);
|
} else {
|
$sanitized[$sanitizedKey] = $value;
|
}
|
}
|
|
return $sanitized;
|
}
|
|
protected function generatePostTitle(string $content, int $userId): string
|
{
|
$username = get_user_meta($userId, 'first_name', true) ?: get_user_meta($userId, 'display_name', true);
|
$link = get_user_meta($userId, BASE.'link', true);
|
$city = function_exists('jvbArtistCity') ? jvbArtistCity($link) : '';
|
|
$title = ucfirst($content);
|
if ($username) {
|
$title .= ' by ' . $username;
|
}
|
if ($city) {
|
$title .= ' from ' . $city;
|
}
|
|
return $title;
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
* Determine how to save uploaded files based on configuration
|
*/
|
protected function handleUploadDestination(array $data, array $results): void
|
{
|
// Determine destination from config
|
$destination = $data['destination'] ?? 'meta';
|
|
switch ($destination) {
|
case 'meta':
|
// Save to post/term/user meta
|
$this->saveToMeta($data, $results);
|
break;
|
|
case 'post':
|
// Create individual posts for each file
|
$this->createIndividualPosts($data, $results);
|
break;
|
|
case 'post_group':
|
// Create posts with grouped files
|
$this->createGroupedPosts($data, $results);
|
break;
|
|
default:
|
// No destination specified - files processed but not attached
|
break;
|
}
|
}
|
|
/**
|
* Infer destination from existing data (backward compatibility)
|
*/
|
protected function inferDestination(array $data): string
|
{
|
// If field_name exists → saving to meta
|
if (!empty($data['field_name'])) {
|
return 'meta';
|
}
|
|
// If post_type exists without field_name → creating posts
|
if (!empty($data['content'])) {
|
return 'post';
|
}
|
|
// No destination
|
return 'none';
|
}
|
|
/**
|
* Save attachment IDs to meta field
|
*/
|
protected function saveToMeta(array $data, array $results): void
|
{
|
if (empty($data['field_name'])) {
|
return;
|
}
|
|
$attachment_ids = array_column($results, 'attachment_id');
|
|
// Determine meta type
|
if (!empty($data['post_id'])) {
|
$meta = new MetaManager($data['post_id'], 'post');
|
} elseif (!empty($data['term_id'])) {
|
$meta = new MetaManager($data['term_id'], 'term');
|
} elseif (!empty($data['user'])) {
|
$link = (int)get_user_meta($data['user'], BASE.'link', true);
|
$meta = new MetaManager($link, 'post');
|
} else {
|
return;
|
}
|
|
// Get existing value
|
$existing = $meta->getValue($data['field_name']);
|
$existing_ids = !empty($existing) ? explode(',', $existing) : [];
|
|
// Merge with new IDs
|
$all_ids = array_unique(array_merge($existing_ids, $attachment_ids));
|
|
// Update with comma-separated string
|
$meta->updateValue($data['field_name'], implode(',', $all_ids));
|
}
|
|
/**
|
* Create individual posts from uploads
|
*/
|
protected function createIndividualPosts(array $data, array $results): array
|
{
|
if (empty($data['content'])) {
|
return [];
|
}
|
|
$created_posts = [];
|
|
foreach ($results as $result) {
|
$attachment_id = $result['attachment_id'];
|
$attachment = get_post($attachment_id);
|
|
// Create post
|
$post_data = [
|
'post_type' => jvbCheckBase($data['content']),
|
'post_title' => $attachment->post_title,
|
'post_status' => 'draft',
|
'post_author' => $data['user'] ?? get_current_user_id(),
|
];
|
|
$post_id = wp_insert_post($post_data);
|
|
if (!is_wp_error($post_id)) {
|
// Set as featured image or attach to gallery
|
$this->attachFileToPost($post_id, $attachment_id, $data);
|
|
$created_posts[] = [
|
'post_id' => $post_id,
|
'attachment_id' => $attachment_id,
|
];
|
}
|
}
|
|
return $created_posts;
|
}
|
|
/**
|
* Create posts with grouped uploads
|
*/
|
protected function createGroupedPosts(array $data, array $results): array
|
{
|
if (empty($data['content'])) {
|
return [];
|
}
|
|
$id_map = [];
|
foreach ($results as $result) {
|
if (isset($result['upload_id'], $result['attachment_id'])) {
|
$id_map[$result['upload_id']] = $result['attachment_id'];
|
}
|
}
|
|
// Groups come from frontend as metadata
|
$groups = $data['groups'] ?? [array_column($results, 'attachment_id')];
|
$created_posts = [];
|
|
foreach ($groups as $group_index => $group_upload_ids) {
|
$group_attachment_ids = array_filter(
|
array_map(fn($uid) => $id_map[$uid] ?? null, $group_upload_ids)
|
);
|
|
if (empty($group_attachment_ids)) continue;
|
// Create post for this group
|
$first_attachment = get_post($group_attachment_ids[0]);
|
|
$post_data = [
|
'post_type' => jvbCheckBase($data['content']),
|
'post_title' => $data['group_titles'][$group_index] ?? $first_attachment->post_title,
|
'post_status' => $data['post_status'] ?? 'draft',
|
'post_author' => $data['user'] ?? get_current_user_id(),
|
];
|
|
$post_id = wp_insert_post($post_data);
|
|
if (!is_wp_error($post_id)) {
|
// Attach all files in group
|
foreach ($group_attachment_ids as $index => $attachment_id) {
|
if ($index === 0) {
|
// First is featured
|
set_post_thumbnail($post_id, $attachment_id);
|
} else {
|
// Others go to gallery
|
$meta = new MetaManager($post_id, 'post');
|
$existing = $meta->getValue('gallery');
|
$existing_ids = !empty($existing) ? explode(',', $existing) : [];
|
$existing_ids[] = $attachment_id;
|
$meta->updateValue('gallery', implode(',', $existing_ids));
|
}
|
}
|
|
$created_posts[] = [
|
'post_id' => $post_id,
|
'attachment_ids' => $group_attachment_ids,
|
];
|
}
|
}
|
|
return $created_posts;
|
}
|
|
/**
|
* Attach file to post based on file type
|
*/
|
protected function attachFileToPost(int $post_id, int $attachment_id, array $data): void
|
{
|
$attachment = get_post($attachment_id);
|
$mime_type = $attachment->post_mime_type;
|
|
// Determine file type
|
if (str_starts_with($mime_type, 'image/')) {
|
// Set as featured image
|
set_post_thumbnail($post_id, $attachment_id);
|
} elseif (str_starts_with($mime_type, 'video/')) {
|
// Save to video field
|
$meta = new MetaManager($post_id, 'post');
|
$meta->updateValue('video', $attachment_id);
|
} else {
|
// Documents - save to documents field
|
$meta = new MetaManager($post_id, 'post');
|
$existing = $meta->getValue('documents');
|
$existing_ids = !empty($existing) ? explode(',', $existing) : [];
|
$existing_ids[] = $attachment_id;
|
$meta->updateValue('documents', implode(',', $existing_ids));
|
}
|
}
|
}
|
