1#@!#!123s

https 1#@!#!123s
: / dom737635 / wp-content / plugins / Custom-Wasabi-Uploads /
Filename : custom-wasabi-uploads.php
back
<?php
/**
 * Plugin Name: Custom Wasabi Uploads
 * Plugin URI: https://github.com/Kirun1
 * Description: Redirects all WordPress uploads to Wasabi storage.
 * Version: 1.0
 * Author: Kirunda Brian
 */

if (!defined('ABSPATH')) {
    exit;
}

require 'vendor/autoload.php';

use Aws\S3\S3Client;
use Aws\S3\Exception\S3Exception;

function initialize_wasabi()
{
    $wasabi_key = get_option('wasabi_api_key');
    $wasabi_secret = get_option('wasabi_api_secret');
    $wasabi_bucket = get_option('wasabi_api_bucket');

    if (empty($wasabi_key) || empty($wasabi_secret) || empty($wasabi_bucket)) {
        error_log('Wasabi credentials are not set properly.');
        return null;
    }

    return new S3Client(
        [
            'version' => 'latest',
            'region' => 'us-east-1',
            'endpoint' => 'https://s3.wasabisys.com',
            'credentials' => [
                'key' => $wasabi_key,
                'secret' => $wasabi_secret,
            ],
        ]
    );
}

class NF_FU_Wasabi_Integration
{
    public function __construct()
    {
        add_action('admin_menu', [$this, 'add_admin_menu']);
        add_action('admin_init', [$this, 'settings_init']);

        // Initialize Wasabi integration
        add_action('ninja_forms_after_submission', [$this, 'upload_files_to_wasabi']);

        // Add custom filter to modify Ninja Forms submission data
        add_filter('ninja_forms_submit_data', [$this, 'customize_ninja_forms_submission'], 10, 1);

        // Add additional hooks related to media library and file handling
        // add_filter('wp_handle_upload', [$this, 'handle_upload'], 10, 2);
        add_filter('wp_get_attachment_url', [$this, 'filter_attachment_url'], 10, 2);
        add_filter('wp_update_attachment_metadata', [$this, 'update_attachment_metadata'], 10, 2);

        // Inside the constructor of NF_FU_Wasabi_Integration class, add these actions
        add_filter('media_row_actions', [$this, 'add_media_library_actions'], 10, 2);
        add_filter('manage_media_columns', [$this, 'modify_media_library_columns']);
        add_action('manage_media_custom_column', [$this, 'display_media_library_column'], 10, 2);
        
        // Hook the function to the scheduled event
        add_action('delay_update_submission_id_meta', [$this, 'update_submission_id_meta'], 10, 2);
    }

    public function upload_files_to_wasabi($data)
    {
        if (!isset($data['fields']) || !is_array($data['fields'])) {
            error_log('Ninja Forms: No fields found in submission data.');
            return;
        }

        $wasabi_bucket = get_option('wasabi_api_bucket');
        $s3 = initialize_wasabi();
        if (is_null($s3)) {
            error_log('Failed to initialize Wasabi S3 client.');
            return;
        }

        foreach ($data['fields'] as &$field) {
            if (isset($field['type'])) {
                if ('file_upload' !== $field['type']) {
                    continue;
                }
            } else {
                error_log('Ninja Forms: "type" key not found in field: ' . print_r($field, true));
                continue;
            }

            if (empty($field['value'])) {
                continue;
            }

            foreach ($field['value'] as $upload_id => $url) {
                $upload = $this->get_upload($upload_id);

                error_log('Upload ID is: ' . $upload_id);

                if (!$upload) {
                    error_log('Ninja Forms: Failed to get upload for ID: ' . $upload_id);
                    continue;
                }

                $file_path = $upload->file_path;
                $key = 'ninja-forms/' . basename($file_path);

                try {
                    $result = $s3->putObject(
                        [
                            'Bucket' => $wasabi_bucket,
                            'Key' => $key,
                            'SourceFile' => $file_path,
                            'ACL' => 'public-read',
                        ]
                    );

                    $wasabi_url = 'https://' . $wasabi_bucket . '.s3.wasabisys.com/' . $key;

                    if ($result['@metadata']['statusCode'] === 200) {
                        if (file_exists($file_path)) {
                            unlink($file_path);
                        }

                        $upload_data = $upload->data;
                        $upload_data['removed_from_server'] = true;
                        NF_File_Uploads()->model->update($upload_id, $upload_data);

                        $this->store_wasabi_url_as_attachment_url($upload_id, $wasabi_url);

                        error_log('upload_files_to_wasabi function wasabi url: ' . $wasabi_url);
                        $field['value'][$upload_id] = $wasabi_url;

                        $attachment_id = $this->get_attachment_id_from_upload_id($upload_id, $wasabi_url);
                        if ($attachment_id) {
                            update_post_meta($attachment_id, '_wasabi_url', $wasabi_url);
                        } else {
                            error_log('Ninja Forms: Failed to get attachment ID for upload ID: ' . $upload_id);
                        }
                    } else {
                        error_log('Failed to upload file to Wasabi: ' . $result['@metadata']['statusCode']);
                    }
                } catch (S3Exception $e) {
                    error_log('Error uploading file to Wasabi: ' . $e->getMessage());
                }
            }
        }
    }

    // Function to modify Ninja Forms submission data to add Wasabi URLs
    public function customize_ninja_forms_submission($form_data)
    {
        // Check if the fields array exists and is not empty
        if (isset($form_data['fields']) && is_array($form_data['fields'])) {
            foreach ($form_data['fields'] as &$field) {
                if (isset($field['type']) && $field['type'] === 'file_upload' && isset($field['value']['files'])) {
                    foreach ($field['value']['files'] as &$file) {
                        // Assuming $wasabi_url contains the URL you want to append
                        $wasabi_url = 'https://' . get_option('wasabi_api_bucket') . '.s3.wasabisys.com/' . $file['name'];
                        $file['wasabi_url'] = $wasabi_url; // Adding Wasabi URL to each file entry
                    }
                }
            }
        }

        return $form_data;
    }

    // Function to store the Wasabi URL as attachment URL
    private function store_wasabi_url_as_attachment_url($upload_id, $wasabi_url)
    {
        $attachment_id = $this->get_attachment_id_from_upload_id($upload_id, $wasabi_url);
        if ($attachment_id) {
            // Log the attachment ID and Wasabi URL before updating post meta
            error_log('Updating post meta for attachment ID: ' . $attachment_id . ' with Wasabi URL: ' . $wasabi_url);

            $updated = update_post_meta($attachment_id, '_wasabi_url', $wasabi_url);
            if ($updated) {
                error_log('Successfully updated post meta for attachment ID: ' . $attachment_id);
            } else {
                error_log('Failed to update post meta for attachment ID: ' . $attachment_id);
            }

            // Also update the attachment file URL
            $updated = update_post_meta($attachment_id, '_wp_attached_file', $wasabi_url);
            if ($updated) {
                error_log('Successfully updated _wp_attached_file meta for attachment ID: ' . $attachment_id);
            } else {
                error_log('Failed to update _wp_attached_file meta for attachment ID: ' . $attachment_id);
            }
        } else {
            error_log('Failed to get attachment ID for upload ID: ' . $upload_id);
        }

        //Also update the submission ID post's post's meta. Schedule the task to run after 30 seconds (or 60 seconds)
        wp_schedule_single_event(time() + 30, 'delay_update_submission_id_meta', array($upload_id, $wasabi_url));  
    }

    public function add_admin_menu()
    {
        add_options_page('Wasabi Settings', 'Wasabi Settings', 'manage_options', 'wasabi-settings', [$this, 'options_page']);
    }

    public function settings_init()
    {
        register_setting('wasabiSettings', 'wasabi_api_key');
        register_setting('wasabiSettings', 'wasabi_api_secret');
        register_setting('wasabiSettings', 'wasabi_api_bucket');

        add_settings_section('wasabiSettings_section', __('Wasabi API Settings', 'wordpress'), null, 'wasabiSettings');

        add_settings_field('wasabi_api_key', __('API Key', 'wordpress'), [$this, 'render_api_key_field'], 'wasabiSettings', 'wasabiSettings_section');
        add_settings_field('wasabi_api_secret', __('API Secret', 'wordpress'), [$this, 'render_api_secret_field'], 'wasabiSettings', 'wasabiSettings_section');
        add_settings_field('wasabi_api_bucket', __('API Bucket', 'wordpress'), [$this, 'render_api_bucket_field'], 'wasabiSettings', 'wasabiSettings_section');
    }

    public function render_api_key_field()
    {
        $value = get_option('wasabi_api_key');
        echo '<input type="text" name="wasabi_api_key" value="' . esc_attr($value) . '">';
    }

    public function render_api_secret_field()
    {
        $value = get_option('wasabi_api_secret');
        echo '<input type="text" name="wasabi_api_secret" value="' . esc_attr($value) . '">';
    }

    public function render_api_bucket_field()
    {
        $value = get_option('wasabi_api_bucket');
        echo '<input type="text" name="wasabi_api_bucket" value="' . esc_attr($value) . '">';
    }

    public function options_page()
    {
        ?>
        <form action='options.php' method='post'>
            <h1>Wasabi Settings</h1>
            <?php
            settings_fields('wasabiSettings');
            do_settings_sections('wasabiSettings');
            submit_button();
            ?>
        </form>
        <?php
    }

    private function get_upload($id)
    {
        $upload = NF_File_Uploads()->model->get($id);

        if (is_null($upload)) {
            return false;
        }

        $data = unserialize($upload->data);

        foreach ($data as $key => $value) {
            $upload->$key = $value;
        }

        $upload->data = $data;

        return $upload;
    }

    // Function to get the attachment ID from the upload ID
    private function get_attachment_id_from_upload_id($upload_id, $wasabi_url)
    {
        // Add debug logging to check the value of $upload_id
        error_log('Retrieving attachment ID for upload ID: ' . $upload_id);

        global $wpdb;
        $ninja_forms_uploads_table = $wpdb->prefix . 'ninja_forms_uploads';
        
        // Prepare and execute the SQL query
        $result = $wpdb->get_row($wpdb->prepare("SELECT data FROM {$ninja_forms_uploads_table} WHERE id = %d", $upload_id));

        if ($result) {
            $data = maybe_unserialize($result->data);

            // Check if data is valid and contains 'attachment_id'
            if (is_array($data) && isset($data['attachment_id'])) {
                $attachment_id = $data['attachment_id'];
                error_log('Extracted attachment ID: ' . $attachment_id);

                // Update the URL and path in the serialized data
                $data['file_url'] = $wasabi_url;
                $data['file_path'] = $wasabi_url;

                // Serialize the data back
                $updated_data = maybe_serialize($data);

                // Update the database with the new serialized data
                $updated = $wpdb->update(
                    $ninja_forms_uploads_table,
                    array('data' => $updated_data),
                    array('id' => $upload_id),
                    array('%s'),
                    array('%d')
                );

                if ($updated !== false) {
                    error_log("Successfully updated {$ninja_forms_uploads_table} table for upload ID: " . $upload_id);
                } else {
                    error_log("Failed to update {$ninja_forms_uploads_table} table for upload ID: " . $upload_id);
                }

                return $attachment_id;
            } else {
                error_log('Invalid data or missing attachment ID for upload ID: ' . $upload_id);
            }
        } else {
            error_log('No data found for upload ID: ' . $upload_id);
        }
    }

    // Function to get the Submission ID from the upload ID
    private function get_submission_id_from_upload_id($upload_id, $wasabi_url)
    {
        error_log('Retrieving Submission ID for upload ID: ' . $upload_id);

        global $wpdb;
        $ninja_forms_uploads_table = $wpdb->prefix . 'ninja_forms_uploads';
        
        $result = $wpdb->get_row($wpdb->prepare("SELECT data FROM {$ninja_forms_uploads_table} WHERE id = %d", $upload_id));

        if ($result) {
            error_log('Query Result: ' . print_r($result, true));
            $data = maybe_unserialize($result->data);

            if (is_array($data) && isset($data['sub_id'])) {
                $sub_id = $data['sub_id'];
                error_log('Extracted Submission ID: ' . $sub_id);

                return $sub_id;  // Correctly return $sub_id here
            } else {
                error_log('Invalid data or missing Submission ID for upload ID: ' . $upload_id);
            }
        } else {
            error_log('No data found for upload ID while trying to find the submission ID: ' . $upload_id);
        }

        return null; // Return null if the sub_id is not found
    }

    public function update_attachment_metadata($data, $attachment_id)
    {
        $wasabi_url = get_post_meta($attachment_id, '_wasabi_url', true);
        if ($wasabi_url) {
            $data['file'] = $wasabi_url;
            error_log('Updated attachment metadata: ' . $attachment_id . ' with URL: ' . $wasabi_url);
        }
        return $data;
    }

    public function handle_upload($upload)
    {
        $file = $upload['file'];
        $filename = basename($file);

        $s3 = initialize_wasabi();
        if (is_null($s3)) {
            error_log('Failed to initialize Wasabi S3 client.');
            return $upload;
        }

        $bucket = get_option('wasabi_api_bucket');
        $key = 'uploads/' . $filename;

        try {
            $result = $s3->putObject(
                [
                    'Bucket' => $bucket,
                    'Key' => $key,
                    'SourceFile' => $file,
                    'ACL' => 'public-read',
                ]
            );

            if ($result['@metadata']['statusCode'] === 200) {
                if (file_exists($file)) {
                    unlink($file);
                }

                $wasabi_url = $result['ObjectURL'];
                $upload['url'] = $wasabi_url;
                error_log('handle_upload function wasabi url: ' . $wasabi_url);
                error_log('Upload ID: ' . $upload['ID']);

                // Update post meta with Wasabi URL
                update_post_meta($upload['ID'], '_wasabi_url', $wasabi_url);
                error_log('Set Wasabi URL meta for attachment: ' . $upload['ID'] . ' to: ' . $wasabi_url);
            } else {
                error_log('Failed to upload file to Wasabi: ' . $result['@metadata']['statusCode']);
            }
        } catch (S3Exception $e) {
            error_log('Error uploading file to Wasabi: ' . $e->getMessage());
        }

        return $upload;
    }

    public function filter_attachment_url($url, $post_id)
    {
        $wasabi_url = get_post_meta($post_id, '_wasabi_url', true);
        error_log('filter_attachment_url function wasabi url: ' . $wasabi_url);
        if ($wasabi_url) {
            error_log('Filtered URL for post: ' . $post_id . ' to: ' . $wasabi_url);
            return $wasabi_url;
        } else {
            error_log('No Wasabi URL found for post: ' . $post_id . ', returning original URL: ' . $url);
        }
        return $url;
    }

    // Add this inside your NF_FU_Wasabi_Integration class
    public function add_media_library_actions($actions, $post)
    {
        if (strpos(get_post_mime_type($post->ID), 'image') === false) {
            return $actions;
        }

        $wasabi_url = get_post_meta($post->ID, '_wasabi_url', true);
        if ($wasabi_url) {
            $actions['wasabi_copy_url'] = '<a href="#" data-url="' . esc_attr($wasabi_url) . '">Copy Link</a>';
            $actions['wasabi_download_url'] = '<a href="' . esc_url($wasabi_url) . '" target="_blank">Download</a>';
        }

        return $actions;
    }

    public function modify_media_library_columns($columns)
    {
        $columns['wasabi_url'] = 'Wasabi URL';
        return $columns;
    }

    public function display_media_library_column($column_name, $post_id)
    {
        if ($column_name === 'wasabi_url') {
            $wasabi_url = get_post_meta($post_id, '_wasabi_url', true);
            echo esc_url($wasabi_url);
        }
    }

    // Function to filter attachment meta
    public function filter_attachment_meta($meta, $post_id)
    {
        // Add debug logging to check the post ID
        error_log('Filtering attachment meta for post ID: ' . $post_id);

        $wasabi_url = get_post_meta($post_id, '_wasabi_url', true);

        // Add debug logging to check the Wasabi URL
        error_log('filter_attachment_meta function wasabi url: ' . $wasabi_url);

        if ($wasabi_url) {
            return $wasabi_url;
        } else {
            error_log('No Wasabi URL found for post: ' . $post_id . ', returning original URL: ' . $meta);
            return $meta;
        }
    }

    // Function to update the submission ID meta
    public function update_submission_id_meta($upload_id, $wasabi_url)
    {
        $submission_id = $this->get_submission_id_from_upload_id($upload_id, $wasabi_url);
        if ($submission_id) {
            error_log('Extracted Submission ID: ' . $submission_id);

            // Get all meta keys for the given submission ID
            $meta_keys = get_post_meta($submission_id);

            error_log('Meta Keys: ' . print_r($meta_keys, true));

            // Flag to check if update was successful
            $updated = false;

            foreach ($meta_keys as $key => $value) {
                // Get the data for the meta key
                $sub_id_data = get_post_meta($submission_id, $key, true);

                // Check if the data is an array or serialized
                if (is_array($sub_id_data)) {
                    // Update the URL with Wasabi URL
                    $sub_id_data[$upload_id] = $wasabi_url;
                    
                    // Update the modified array data in post meta
                    update_post_meta($submission_id, $key, $sub_id_data);
                    $updated = true;
                    error_log('Updated array data for key: ' . $key . ' for Submission ID: ' . $submission_id);
                    break; // Exit loop after updating
                } elseif ($this->is_serialized($sub_id_data)) {
                    // Handle serialized data as before
                    $unserialized_data = unserialize($sub_id_data);
                    if (is_array($unserialized_data) && isset($unserialized_data[$upload_id])) {
                        // Modify and update serialized data
                        $unserialized_data[$upload_id] = $wasabi_url;
                        $updated_serialized_data = serialize($unserialized_data);
                        update_post_meta($submission_id, $key, $updated_serialized_data);
                        $updated = true;
                        error_log('Updated serialized data for key: ' . $key . ' for Submission ID: ' . $submission_id);
                    }
                } else {
                    // Handle other types of data if needed
                    error_log('Unhandled data type for key ' . $key . ': ' . gettype($sub_id_data));
                }

                // Exit loop after updating the correct meta key
                if ($updated) {
                    break;
                }
            }

            if (!$updated) {
                error_log('No matching meta key found for Submission ID: ' . $submission_id);
            }
        } else {
            error_log('Failed to get submission ID for upload ID: ' . $upload_id);
        }
    }

    // Helper function to check if a value is serialized
    function is_serialized($data)
    {
        // If it's not a string, it can't be serialized
        if (!is_string($data)) {
            return false;
        }

        // Trim whitespace
        $data = trim($data);

        // Serialized null or false
        if ($data === 'N;' || $data === 'b:0;' || $data === 'b:0;' || $data === 'a:0;') {
            return true;
        }

        // Attempt to unserialize it
        $unserialized = @unserialize($data);

        // Check if unserializing didn't return false or if it's an array
        return ($unserialized !== false) || ($data === 'b:0;') || is_array(json_decode($data, true));
    }

}

// Initialize the plugin
new NF_FU_Wasabi_Integration();