[share] Copy the full text of the pdf of an item and saves it in markdown .md format in the defined folder.

[blkdark]

Description

Zotero extracts the full text of the associated document each time we add a reference. This script looks for this file in the zotero storage, makes a copy, renames it to "fullText_{citekey}.md" and moves it to the folder specified in the script.

Event

None

Operation

Script

Data

// Copy citation keys with PDF attachment keys from selected items
// AND extract zotero-ft-cache files as markdown resumes
try {
    // CONFIGURATION - Modify these paths as needed
    const ZOTERO_STORAGE_PATH = "C:\\Users\\blkda\\Zotero\\storage";
    const DESTINATION_FOLDER = "C:\\Users\\blkda\\Mi unidad\\Academico\\Obsidian\\Academics\\fullText";
    const COPY_FILES = true; // Set to false if you only want clipboard data
    
    var dataArray = [];
    var copiedFiles = [];
    var items = Zotero.getActiveZoteroPane().getSelectedItems();
   
    if (!items || items.length === 0) {
        return "No items selected";
    }

    // Helper function to ensure destination folder exists
    function ensureDirectoryExists(dirPath) {
        try {
            var file = Components.classes["@mozilla.org/file/local;1"]
                              .createInstance(Components.interfaces.nsIFile);
            file.initWithPath(dirPath);
            
            if (!file.exists()) {
                file.create(Components.interfaces.nsIFile.DIRECTORY_TYPE, 0o755);
            }
            return true;
        } catch (e) {
            return false;
        }
    }

    // Helper function to copy and rename zotero-ft-cache file
    function copyZoteroCache(attachmentKey, citationKey) {
        try {
            // Source path: storage folder with attachment key
            var sourceFolderPath = `${ZOTERO_STORAGE_PATH}\\${attachmentKey}`;
            var sourceFilePath = `${sourceFolderPath}\\.zotero-ft-cache`;
            
            // Check if source file exists
            var sourceFile = Components.classes["@mozilla.org/file/local;1"]
                                     .createInstance(Components.interfaces.nsIFile);
            sourceFile.initWithPath(sourceFilePath);
            
            if (!sourceFile.exists()) {
                return false;
            }

            // Destination path: fullText_citationkey.md
            var sanitizedCitationKey = sanitizeFilename(citationKey);
            var destinationFileName = `fullText_${sanitizedCitationKey}.md`;
            var destinationPath = `${DESTINATION_FOLDER}\\${destinationFileName}`;
            
            var destFile = Components.classes["@mozilla.org/file/local;1"]
                                   .createInstance(Components.interfaces.nsIFile);
            destFile.initWithPath(destinationPath);
            
            // If destination file already exists, remove it
            if (destFile.exists()) {
                destFile.remove(false);
            }
            
            var destDir = destFile.parent;
            var fileName = destFile.leafName;
            
            sourceFile.copyTo(destDir, fileName);
            return true;
        } catch (e) {
            return false;
        }
    }

    // Helper function to sanitize filename
    function sanitizeFilename(filename) {
        // Remove or replace invalid characters for filenames
        return filename.replace(/[<>:"/\\|?*]/g, '_')
                      .replace(/\s+/g, '_')
                      .substring(0, 100); // Limit length
    }

    // Ensure destination folder exists if copying files
    if (COPY_FILES) {
        if (!ensureDirectoryExists(DESTINATION_FOLDER)) {
            return "Error: Could not create destination folder: " + DESTINATION_FOLDER;
        }
    }
   
    for (let item of items) {
        if (item.isRegularItem() && !(item instanceof Zotero.Collection)) {
            // Get parent item key
            var parentItemKey = item.key;
           
            // Get citation key from Better BibTeX
            var citationKey = '';
            if (typeof Zotero.BetterBibTeX !== 'undefined') {
                try {
                    citationKey = Zotero.BetterBibTeX.KeyManager.get(item.id).citationKey;
                } catch (e) {
                    // Skip if can't get citation key
                    continue;
                }
            }
           
            if (!citationKey) {
                continue;
            }

            // Sanitize citation key for filename
            var sanitizedCitationKey = sanitizeFilename(citationKey);
           
            // Get all attachments for this item
            var attachments = item.getAttachments();
           
            for (let attachmentID of attachments) {
                let attachment = Zotero.Items.get(attachmentID);
               
                // Check if attachment is a PDF
                if (attachment && attachment.isPDFAttachment()) {
                    let attachmentKey = attachment.key;
                    if (attachmentKey) {
                        let dataEntry = `${parentItemKey},${citationKey},${attachmentKey}`;
                        if (!dataArray.includes(dataEntry)) {
                            dataArray.push(dataEntry);
                        }

                        // Copy zotero-ft-cache file if enabled
                        if (COPY_FILES) {
                            try {
                                if (copyZoteroCache(attachmentKey, citationKey)) {
                                    copiedFiles.push({
                                        citationKey: citationKey,
                                        attachmentKey: attachmentKey,
                                        fileName: `fullText_${sanitizeFilename(citationKey)}.md`
                                    });
                                }
                            } catch (e) {
                                // Continue even if file copy fails
                            }
                        }
                    }
                }
            }
        }
    }
   
    if (dataArray.length === 0) {
        return "No PDF attachments found in selected items";
    }
   
    // Copy data to clipboard
    var clipboardText = dataArray.join('\r\n');
    Zotero.Utilities.Internal.copyTextToClipboard(clipboardText);
    
    // Prepare result message
    var resultMessage = `${dataArray.length} citation key(s) with PDF attachment(s) copied`;
    
    if (COPY_FILES) {
        if (copiedFiles.length > 0) {
            resultMessage += `\n${copiedFiles.length} zotero-ft-cache file(s) copied as markdown resumes to: ${DESTINATION_FOLDER}`;
        } else {
            resultMessage += "\nNo zotero-ft-cache files were found or copied (check that PDFs have been indexed by Zotero)";
        }
    }
    
    return resultMessage;
   
} catch (error) {
    return "Error: " + error.message;
}

Anything else

No response