[Share] Add word to eudic wordlist / 添加单词到欧陆词典

[khakiakhaki]

Description

treat annotaion with purple as word to eudic wordlist
将紫色标记注释认为是单词添加到欧路词典生词本当中

Event

Creat Annotation

Operation

Script

Data

// add word to eudic wordlist 
// @author khakiakhaki
// @usage Replace the `G_Authorization` and `G_wordListName`
// @link https://github.com/windingwind/zotero-actions-tags/discussions/403

if (!item) {
    return;
}

// only annotation with color purple was treat as single word
if (!item.isAnnotation() || !item.annotationColor || item.annotationColor !== "#a28ae5") {
    return;
}

const wordToAdd = item.annotationText;

// get authorization code of eudic from https://my.eudic.net/OpenAPI/Authorization 
const G_Authorization = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx';
const G_wordListName = 'zotero';
const G_language = 'en';


async function getAllWordListInfo() {
    try {
        const response = await fetch(`https://api.frdic.com/api/open/v1/studylist/category?language=${G_language}`, {
            headers: {
                'Authorization': G_Authorization,
            }
        });

        if (!response.ok) {
            throw new Error(`Failed to fetch study list: ${response.statusText}`);
        }
        return await response.json();
    } catch (error) {
        popinfo(`${error}`);
        return null;
    }
}

async function createNewStudyList() {
    try {
        const response = await fetch('https://api.frdic.com/api/open/v1/studylist/category', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': G_Authorization,
            },
            body: JSON.stringify({
                language: G_language,
                name: G_wordListName,
            }),
        });

        if (!response.ok) {
            popinfo(`Failed to create study list: ${response.statusText}`);
        }
        return await response.json();
    } catch (error) {
        popinfo(`${error}`);
        return null;
    }
}

async function addWordToWordList(studyListId, word) {
    try {
        const response = await fetch('https://api.frdic.com/api/open/v1/studylist/words', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': G_Authorization,
            },
            body: JSON.stringify({
                id: studyListId,
                language: G_language,
                words: [word],
            }),
        });

        if (!response.ok) {
            popinfo(`Failed to add word: ${response.statusText}`);
        }
        return await response.json();
    } catch (error) {
        popinfo(`${error}`);
        return null;
    }
}

const allWordLists = await getAllWordListInfo();
if (allWordLists && allWordLists.data) {
    const existingList = allWordLists.data.find(list => list.name === G_wordListName);
    if (existingList) {
        let info = await addWordToWordList(existingList.id, wordToAdd);
        return `${info.message}`;
    } else {
        const newList = await createNewStudyList();
        if (newList && newList.data) {
            let info = await addWordToWordList(newList.data.id, wordToAdd);
            return `${info.message}`;
        }
        else {
            return "Create wordlist fail";
        }
    }
}


function popinfo(msg) {
    const popMsg = new Zotero.ProgressWindow({ closeOnClick: true });
    popMsg.changeHeadline("Action & Tag", "", "");
    popMsg.addDescription(`${msg}`);
    popMsg.show();
    popMsg.startCloseTimer(3000);
}

Anything else

No response

[Jackson2z]

非常有用

[khakiakhaki]

补充一个在调用本地的eudic 进行划词翻译或者查询单词的脚本；用的时候要修改的就是eudic 的可执行文件路径 ，修改这个 const G_eudic_bin = "C:\\eudic\\eudic.exe" 就可以了。触发事件是主窗口加载。成功以后划词就是下图这样，第一个是pdftranslate 的按钮，第二个是直接跳转到eudic的窗口

// Add a button to call local eudic to translate or lookup 
// @author khakiakhaki
// @usage Replace the ` G_eudic_bin`
// @link https://github.com/windingwind/zotero-actions-tags/discussions/403

// replace the eudic execute binary path
const G_eudic_bin = "C:\\applicationc\\eudic\\eudic.exe"; // Path to Eudic

// Function to ensure ztoolkit is loaded, with a maximum of 5 attempts
function ensureZtoolkitLoaded() {
    let attempt = 0; // Attempt counter
    const maxAttempts = 5; // Maximum number of attempts

    return new Promise((resolve, reject) => {
        const checkAndResolve = () => {
            attempt++; // Increment the counter each attempt
            if (attempt > maxAttempts) {
                reject('Failed to load ztoolkit after ' + maxAttempts + ' attempts'); // Reject the Promise if maximum attempts are exceeded
                return;
            }
            if (Zotero.ActionsTags.data.ztoolkit) {
                resolve(Zotero.ActionsTags.data.ztoolkit);
            } else {
                setTimeout(checkAndResolve, 2000); // Check every 2 seconds
            }
        };
        checkAndResolve();
    });
}

// Function to build the popup
function selectReaderPopupEudic(event) {
  const { doc, append } = event;
  const annotation = event.params.annotation.text.trim();
  const ztoolkit = event.params.ztoolkit; // Retrieve ztoolkit from event parameters


  append(
    ztoolkit.UI.createElement(doc, "fragment", {
      children: [
        {
          tag: "button",
          namespace: "html",
          id: "eudic-lookup-native",
          classList: [
            "toolbar-button",
            "wide-button",
            "eudic-lookup-readerpopup",
          ],
          properties: {
            innerHTML: `Eudic Lookup`,
          },
          listeners: [
            {
              type: "click",
              listener: (ev) => {
                Zotero.Utilities.Internal.subprocess(G_eudic_bin, [
                  "-w",
                  annotation,
                ]);
              },
            },
          ],
          ignoreIfExists: true,
        },
      ],
    })
  );
}

// Main function to initialize the plugin
async function init() {
    try {
        // Wait for ztoolkit to load, throw an error if it fails
        const ztoolkit = await ensureZtoolkitLoaded();

        // Register event listener to build the popup when text is selected
        Zotero.Reader.registerEventListener(
            "renderTextSelectionPopup",
            (event) => {
                const { params } = event;
                // Pass ztoolkit to the selectReaderPopupEudic function
                params.ztoolkit = ztoolkit; // Add ztoolkit to event parameters
                selectReaderPopupEudic(event);
            },
            "eudic-native-lookup"
        );

        return "eudic already prepared!";
    } catch (error) {
        console.error(error); // Log error information
        return "[eudic lookup] Failed to initialize"; // Return error information
    }
}

// Call the main function
return await init();