looking for help with code, uploading files into specific IPFS Groups

[myeco-earth]

im creating a plugin for WP that allows users to upload documents to pinata, originally I was just uploading and retrieving with no organisation and it was working fine, I decided to try to use the new FIles SDK to tidy things up, Unfortunatley I could not this to work, lack of skill probably, so i tried to revert to the older method of using IPFS Groups, I created the groups and am following the documentation, the file upload works but places it in generic files, I read from the documents that we can push the upload to a group via its CID, I am trying to incorporate this into my code but still cant get it to work, I am including my current api config file and the error I am getting, can someone pleas help me fix this or atleast point me in the right direction.
Thank you

[2024-10-28 10:12:43] Selected group ID: 2443a975-9739-4643-a575-6c38266304d8
[2024-10-28 10:12:43] File details - Path: /tmp/phpMtNPiI, Name: newtest.txt
[2024-10-28 10:12:43] Starting file upload process
[2024-10-28 10:12:43] File path: /tmp/phpMtNPiI
[2024-10-28 10:12:43] Original name: newtest.txt
[2024-10-28 10:12:43] Group ID: 2443a975-9739-4643-a575-6c38266304d8
[2024-10-28 10:12:43] Original file type detected: application/x-empty
[2024-10-28 10:12:43] Treating empty file as text/plain
[2024-10-28 10:12:43] File has .txt extension, treating as text/plain
[2024-10-28 10:12:43] Final file type: text/plain
[2024-10-28 10:12:43] File size: 0 B
[2024-10-28 10:12:43] Initiating file upload to IPFS
[2024-10-28 10:12:46] File uploaded successfully with hash: QmbFMke1KXqnYyBBWxB74N4c5SBnJMVAiMNRcGu6x1AwQH
[2024-10-28 10:12:46] Adding file to group: 2443a975-9739-4643-a575-6c38266304d8
[2024-10-28 10:12:46] Error adding to group: API request failed with status 404: {"error":{"reason":"INVALID_ROUTE","details":"The provided route does not match a valid Pinata endpoint"}}
[2024-10-28 10:12:46] Upload successful - IPFS Hash: QmbFMke1KXqnYyBBWxB74N4c5SBnJMVAiMNRcGu6x1AwQH
[2024-10-28 10:12:47] IPFS API Initialized
[2024-10-28 10:12:47] Form submission started
[2024-10-28 10:12:47] Not a POST request
[2024-10-28 10:12:48] Raw groups response: [{"id":"2443a975-9739-4643-a575-6c38266304d8","name":"Cultivation","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-27T12:22:09.169Z","updatedAt":"2024-10-27T12:22:09.169Z"},{"id":"69c310ed-a47d-4ac5-a106-41e56cd25a8e","name":"test2","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-26T19:08:37.286Z","updatedAt":"2024-10-26T19:08:37.286Z"},{"id":"104adf44-3f84-4ac4-92e1-857af9d306ef","name":"test3","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-26T22:16:00.288Z","updatedAt":"2024-10-26T22:16:00.288Z"}]
[2024-10-28 10:12:48] Raw groups response: [{"id":"2443a975-9739-4643-a575-6c38266304d8","name":"Cultivation","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-27T12:22:09.169Z","updatedAt":"2024-10-27T12:22:09.169Z"},{"id":"69c310ed-a47d-4ac5-a106-41e56cd25a8e","name":"test2","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-26T19:08:37.286Z","updatedAt":"2024-10-26T19:08:37.286Z"},{"id":"104adf44-3f84-4ac4-92e1-857af9d306ef","name":"test3","user_id":"3eb371bd-a919-4dfb-a3fc-2dbfe2e11268","createdAt":"2024-10-26T22:16:00.288Z","updatedAt":"2024-10-26T22:16:00.288Z"}]

and here is the current code

<?php
if (!defined('ABSPATH')) {
    exit;
}

if (!class_exists('IPFS_API')) {
    class IPFS_API {
        private $pinata;
        private $gateway_url;
        private $log_file;
        private $allowed_types;
        private $max_file_size;

        public function __construct() {
            $this->pinata = new PinataSDK([
                'pinataJwt' => defined('PINATA_JWT') ? PINATA_JWT : get_option('pinata_jwt'),
                'pinataGateway' => 'white-major-dingo-569.mypinata.cloud'
            ]);
           
            $this->gateway_url = 'https://white-major-dingo-569.mypinata.cloud';
            $this->log_file = dirname(dirname(dirname(__FILE__))) . '/ipfs.log';
           
            $this->allowed_types = array(
                'application/pdf',
                'application/msword',
                'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                'text/plain',
                'application/x-empty',
                'text/x-empty',
                'application/vnd.ms-excel',
                'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
            );
           
            $this->max_file_size = wp_max_upload_size();
           
            $this->write_log("IPFS API Initialized");
        }

        public function write_log($message) {
            try {
                $timestamp = date('[Y-m-d H:i:s] ');
                $log_message = $timestamp . $message . PHP_EOL;
                file_put_contents($this->log_file, $log_message, FILE_APPEND);
            } catch (Exception $e) {
                error_log("IPFS logging error: " . $e->getMessage());
            }
        }

        public function get_api_key() {
            return $this->pinata->get_api_key();
        }

        public function get_api_secret() {
            return $this->pinata->get_api_secret();
        }

        public function get_pinata_groups() {
            try {
                $groups = $this->pinata->groups->list();
                $this->write_log("Raw groups response: " . json_encode($groups));
                return $groups;
            } catch (Exception $e) {
                $this->write_log("Error fetching groups: " . $e->getMessage());
                return [];
            }
        }

        public function get_group_files($group_id) {
            try {
                $this->write_log("Fetching files for group: " . $group_id);
                $files = $this->pinata->groups->getFiles($group_id);
                $this->write_log("Group files response: " . json_encode($files));
                return $files;
            } catch (Exception $e) {
                $this->write_log("Error getting group files: " . $e->getMessage());
                return [];
            }
        }

        public function upload_to_pinata($file_path, $original_name, $group_id = null) {
            try {
                $this->write_log("Starting file upload process");
                $this->write_log("File path: " . $file_path);
                $this->write_log("Original name: " . $original_name);
                $this->write_log("Group ID: " . ($group_id ?? 'none'));

                if (!file_exists($file_path)) {
                    $this->write_log("Error: File does not exist at path: " . $file_path);
                    throw new Exception('File not found: ' . $file_path);
                }

                if (!is_readable($file_path)) {
                    $this->write_log("Error: File not readable at path: " . $file_path);
                    throw new Exception('File not readable: ' . $file_path);
                }

                $file_type = mime_content_type($file_path);
                $this->write_log("Original file type detected: " . $file_type);
               
                if ($file_type === 'application/x-empty' || $file_type === 'text/x-empty') {
                    $file_type = 'text/plain';
                    $this->write_log("Treating empty file as text/plain");
                }

                $ext = strtolower(pathinfo($original_name, PATHINFO_EXTENSION));
                if ($ext === 'txt') {
                    $file_type = 'text/plain';
                    $this->write_log("File has .txt extension, treating as text/plain");
                }

                $this->write_log("Final file type: " . $file_type);

                if (!in_array($file_type, $this->allowed_types)) {
                    $this->write_log("Error: File type not allowed: " . $file_type);
                    throw new Exception('File type not allowed');
                }

                $file_size = filesize($file_path);
                $this->write_log("File size: " . size_format($file_size));

                if ($file_size > $this->max_file_size) {
                    $this->write_log("Error: File too large: " . size_format($file_size));
                    throw new Exception('File exceeds maximum allowed size');
                }

                $this->write_log("Initiating file upload to IPFS");
                $result = $this->pinata->upload->file($file_path, $original_name);

                if (!$result || !isset($result['IpfsHash'])) {
                    $this->write_log("Error: Failed to get IPFS hash from upload");
                    throw new Exception('Failed to get IPFS hash from upload');
                }

                $ipfs_hash = $result['IpfsHash'];
                $this->write_log("File uploaded successfully with hash: " . $ipfs_hash);

                if ($group_id) {
                    $this->write_log("Adding file to group: " . $group_id);
                    try {
                        $group_result = $this->pinata->groups->addCids($group_id, [$ipfs_hash]);
                        $this->write_log("Group addition result: " . json_encode($group_result));
                    } catch (Exception $e) {
                        $this->write_log("Error adding to group: " . $e->getMessage());
                    }
                }

                return $ipfs_hash;

            } catch (Exception $e) {
                $this->write_log("Upload error: " . $e->getMessage());
                $this->write_log("Stack trace: " . $e->getTraceAsString());
                return null;
            }
        }

        public function get_file_url($cid) {
            if (!$cid || !preg_match('/^[a-zA-Z0-9]+$/', $cid)) {
                return '';
            }
            return $this->gateway_url . '/ipfs/' . $cid;
        }

        public function verify_ipfs_file($cid) {
            try {
                $this->write_log("Verifying file: " . $cid);
                $url = $this->get_file_url($cid);
                $response = wp_remote_head($url, ['timeout' => 15, 'sslverify' => true]);
               
                if (is_wp_error($response)) {
                    $this->write_log("Verification error: " . $response->get_error_message());
                    return false;
                }

                $http_code = wp_remote_retrieve_response_code($response);
                $this->write_log("Verification response code: " . $http_code);
               
                return $http_code === 200;
            } catch (Exception $e) {
                $this->write_log("File verification error: " . $e->getMessage());
                return false;
            }
        }
    }
}

if (!class_exists('PinataSDK')) {
    class PinataSDK {
        private $jwt;
        public $groups;
        public $upload;

        public function __construct($config) {
            $this->jwt = $config['pinataJwt'];
            $this->groups = new PinataGroups($this->jwt);
            $this->upload = new PinataUpload($this->jwt);
        }

        public function get_api_key() {
            return $this->jwt;
        }

        public function get_api_secret() {
            return 'API Secret Exists';
        }
    }
}

if (!class_exists('PinataGroups')) {
    class PinataGroups {
        private $jwt;
        private $api_url = 'https://api.pinata.cloud';

        public function __construct($jwt) {
            $this->jwt = $jwt;
        }

        private function make_request($endpoint, $method = 'GET', $data = null) {
            $curl = curl_init();
           
            $full_url = $this->api_url . $endpoint;
            error_log("Making request to: " . $full_url);
           
            $options = [
                CURLOPT_URL => $full_url,
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_CUSTOMREQUEST => $method,
                CURLOPT_HTTPHEADER => [
                    "Authorization: Bearer " . $this->jwt,
                    "Content-Type: application/json"
                ],
                CURLOPT_SSL_VERIFYPEER => true
            ];

            if ($data) {
                $json_data = json_encode($data);
                $options[CURLOPT_POSTFIELDS] = $json_data;
                error_log("Request Method: " . $method);
                error_log("Request Headers: Authorization Bearer [JWT] and Content-Type: application/json");
                error_log("Request Data: " . $json_data);
            }

            curl_setopt_array($curl, $options);
           
            $response = curl_exec($curl);
            $http_code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
            $err = curl_error($curl);
           
            error_log("API Response Code: " . $http_code);
            error_log("API Response: " . $response);
           
            if ($err) {
                error_log("Curl Error: " . $err);
                throw new Exception($err);
            }

            if ($http_code >= 400) {
                error_log("API Error Response: " . $response);
                throw new Exception("API request failed with status " . $http_code . ": " . $response);
            }

            curl_close($curl);
            return json_decode($response, true);
        }

        public function list() {
            return $this->make_request('/groups');
        }

        public function getFiles($group_id) {
            return $this->make_request('/groups/' . urlencode($group_id) . '/files');
        }

        public function create($name) {
            return $this->make_request('/groups', 'POST', ['name' => $name]);
        }

        public function delete($group_id) {
            return $this->make_request('/groups/' . urlencode($group_id), 'DELETE');
        }

        public function addCids($group_id, $cids) {
            $data = [
                'hashToPin' => $cids[0], // Since we're adding one hash at a time
                'pinataMetadata' => [
                    'groupId' => $group_id
                ]
            ];
            error_log("Attempting to add CIDs with data: " . json_encode($data));
            return $this->make_request('/pinning/addHashToIPFSGroup', 'POST', $data);
        }
    }
}

if (!class_exists('PinataUpload')) {
    class PinataUpload {
        private $jwt;
        private $api_url = 'https://api.pinata.cloud';

        public function __construct($jwt) {
            $this->jwt = $jwt;
        }

        public function file($file_path, $file_name) {
            $curl = curl_init();
           
            $pinataMetadata = [
                "name" => $file_name
            ];

            $post_fields = [
                'file' => new CURLFile($file_path, mime_content_type($file_path), $file_name),
                'pinataMetadata' => json_encode($pinataMetadata)
            ];

            curl_setopt_array($curl, [
                CURLOPT_URL => $this->api_url . '/pinning/pinFileToIPFS',
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_CUSTOMREQUEST => "POST",
                CURLOPT_POSTFIELDS => $post_fields,
                CURLOPT_HTTPHEADER => [
                    "Authorization: Bearer " . $this->jwt
                ]
            ]);

            $response = curl_exec($curl);
            $err = curl_error($curl);

            if ($err) {
                error_log("Pinata Upload Error: " . $err);
                throw new Exception($err);
            }

            $result = json_decode($response, true);
           
            if (!$result) {
                error_log("Pinata Upload Error: Empty response");
                throw new Exception("Empty response from Pinata");
            }

            error_log("Pinata Upload Response: " . json_encode($result));
           
            curl_close($curl);
            return $result;
        }
    }
}

[stevedylandev]

Hey @zer0ize! Thanks for reaching out! :) Our SDK only supports typescript and JavaScript at the moment, so it looks like you or perhaps some AI suggestions tried to build its own SDK. I would recommend trying to revert back to what you had before and reference the API endpoints instead since they can work in php.

Another quick clarification: Pinata recently released a new Files API. This API allows for both public and private files and does not use IPFS. If you need IPFS for web3 applications then you can use the IPFS API instead. The Files API is great for more traditional file storage and retrieval. I'll post links to both API references below:

IPFS API
Files API

[myeco-earth]

thank you for the clarification