חב"דפדיה

משתמש:רובין בוט/הפניות כפולות.js – הבדלי גרסאות

עיון אינטראקטיבי בהיסטוריה
→ העריכה הקודמתהעריכה הבאה ←
אין תקציר עריכה
תגית: שוחזרה
ביטול גרסה 782071 של בוט הפניות (שיחה)
שורה 1: שורה 1:
// קרדיט: המכלול (גרסה משופרת - מאפשרת הרצה לכל משתמש מחובר)
(() => {
(() => {
  const BOT_USERS = [8516];
    const api = new mw.Api();
  const api = new mw.Api();


  const getRedirectContent = async (title) => {
    /**
    return api.get({
    * מקבל את תוכן דף ההפניה.
      prop: "revisions",
    * @param {string} title - שם הדף.
      titles: title,
    * @returns {Promise<string|null>} תוכן הדף או null אם הייתה שגיאה.
      rvprop: "content",
    */
      rvslots: "*",
    const getRedirectContent = async (title) => {
      formatversion: "2",
        try {
    });
            const response = await api.get({
  };
                prop: "revisions",
                titles: title,
                rvprop: "content",
                rvslots: "*",
                formatversion: "2",
            });
            const page = response.query?.pages?.[0];
            return page?.revisions?.[0]?.slots?.main?.content ?? null;
        } catch (error) {
            console.error("שגיאה בקבלת תוכן הפניה עבור " + title + ":", error);
            return null;
        }
    };


  const getRedirectTarget = async (title) => {
    /**
    const { query } = await api.get({
    * מקבל את יעד ההפניה הסופי.
      titles: title,
    * @param {string} title - שם דף ההפניה.
      redirects: true,
    * @returns {Promise<string|null>} יעד ההפניה או null אם לא נמצא.
    });
    */
    const getRedirectTarget = async (title) => {
        try {
            const { query } = await api.get({
                titles: title,
                redirects: true, // מאפשר למדיה-וויקי לעקוב אחר הפניות
            });


    if (query?.pages) {
            if (query?.pages) {
      const page = Object.values(query.pages).find((page) => !page.missing);
                // מצא את הדף שאינו חסר (היעד הסופי)
      return page?.title ?? null;
                const page = Object.values(query.pages).find((p) => !p.missing);
    }
                return page?.title ?? null;
    return null;
            }
  };
            return null;
        } catch (error) {
            console.error("שגיאה בקבלת יעד ההפניה עבור " + title + ":", error);
            return null;
        }
    };


  const extractAnchorFromContent = (content) => {
    /**
    const match = content.match(/\[\[.*?(?:#(.+?))?\]\]/);
    * מחלץ את העוגן (anchor) מתוך תוכן הפניה (לדוגמה: [[דף_יעד#עוגן]]).
    return match?.[1] ? `#${match[1]}` : "";
    * @param {string} content - תוכן דף ההפניה.
  };
    * @returns {string} העוגן עם '#' אם קיים, אחרת מחרוזת ריקה.
    */
    const extractAnchorFromContent = (content) => {
        const match = content.match(/#הפניה\s*\[\[[^\]]+?(?:#(.+?))?\]\]/);
        return match?.[1] ? "#" + match[1] : "";
    };


  const getNamespacePrefix = async (title) => {
    /**
    const { query } = await api.get({
    * מקבל את קידומת מרחב השם של דף (לדוגמה: "מדיה ויקי:", "קובץ:").
      titles: title,
    * @param {string} title - שם הדף.
      prop: "info",
    * @returns {Promise<string>} קידומת מרחב השם או מחרוזת ריקה.
    });
    */
    const getNamespacePrefix = async (title) => {
        try {
            const { query } = await api.get({
                titles: title,
                prop: "info",
            });


    if (query?.pages) {
            if (query?.pages) {
      const page = Object.values(query.pages)[0];
                const page = Object.values(query.pages)[0];
      if (page.ns) {
                if (page.ns !== undefined) {
        const namespacePrefixes = {
                    // יש להוסיף כאן מרחבי שמות נוספים במידת הצורך
          4: "חבדפדיה:",
                    const namespacePrefixes = {
          6: "קובץ:",
                        4: "חבדפדיה:",   // Namespace 4
          10: "תבנית:",
                        6: "קובץ:",       // Namespace 6
          12: "עזרה:",
                        10: "תבנית:",     // Namespace 10
        };
                        12: "עזרה:",     // Namespace 12
        return namespacePrefixes[page.ns] ?? "";
                        // ... ניתן להוסיף עוד מרחבי שמות לפי המספרים שלהם בוויקי
      }
                    };
    }
                    return namespacePrefixes[page.ns] ?? "";
    return "";
                }
  };
            }
            return "";
        } catch (error) {
            console.error("שגיאה בקבלת קידומת מרחב שם עבור " + title + ":", error);
            return "";
        }
    };


  const createRedirect = async (title, target) => {
    /**
    try {
    * יוצר/מתקן הפניה.
      await api.postWithEditToken({
    * @param {string} title - שם הדף שיהפוך להפניה.
        action: "edit",
    * @param {string} target - יעד ההפניה.
        format: "json",
    */
        tags: "doubleredirect-bot",
    const createRedirect = async (title, target) => {
        bot: true,
        try {
        title: title,
            await api.postWithEditToken({
        text: `#הפניה [[${target}]]`,
                action: "edit",
      });
                format: "json",
      mw.notify(`\nstatus:${title} succes`);
                // **השורות עם "tags" הוסרו לחלוטין כאן.**
    } catch (error) {
                title: title,
      console.error(error);
                text: "#הפניה [[" + target + "]]",
    }
                summary: "בוט: מתקן הפניה כפולה ל- [[" + target + "]]",
  };
            });
            mw.notify(title + ": ההפניה תוקנה בהצלחה ל- " + target, { type: 'success', title: 'הצלחה' });
        } catch (error) {
            console.error("שגיאה ביצירת הפניה עבור " + title + " ל- " + target + ":", error);
            // בדיקה ספציפית לשגיאת badtags
            if (error.code === 'badtags') {
                mw.notify(title + ": שגיאה: אין הרשאה להשתמש בתגיות עריכה. אנא פנה למנהל המערכת.", { type: 'error', title: 'שגיאת הרשאה' });
            } else {
                mw.notify(title + ": נכשל תיקון ההפניה. פרטים בקונסול.", { type: 'error', title: 'שגיאה' });
            }
        }
    };


  const processRedirect = async (title) => {
    /**
    try {
    * מעבד הפניה כפולה יחידה: מוצא את היעד הסופי ומתקן אותה.
      const contentData = await getRedirectContent(title);
    * @param {string} title - שם הדף של ההפניה הכפולה.
      const content =
    */
        contentData.query.pages[0].revisions[0].slots.main.content;
    const processRedirect = async (title) => {
      const anchor = extractAnchorFromContent(content);
        try {
            const content = await getRedirectContent(title);
            if (content === null) {
                mw.notify(title + ": לא ניתן לאחזר תוכן דף ההפניה.", { type: 'warn' });
                return;
            }


      const finalTarget = await getRedirectTarget(title);
            const anchor = extractAnchorFromContent(content);
      if (!finalTarget) return;
            const finalTarget = await getRedirectTarget(title);


      const namespace = await getNamespacePrefix(finalTarget);
            if (!finalTarget) {
      const fullTarget = namespace + finalTarget + anchor;
                mw.notify(title + ": לא נמצא יעד הפניה סופי.", { type: 'warn' });
                return;
            }


      if (title === finalTarget) {
            const namespace = await getNamespacePrefix(finalTarget);
        alert("הפניה מעגלית");
            const fullTarget = namespace + finalTarget + anchor;
        return;
      }


      console.log("Creating redirect to:", fullTarget);
            // בדיקה למניעת הפניות מעגליות או תיקונים מיותרים
      await createRedirect(title, fullTarget);
            if (title.replace(/_/g, " ") === finalTarget.replace(/_/g, " ") && !anchor) {
    } catch (error) {
                mw.notify(title + ": ההפניה כבר תקינה. אין צורך בתיקון.", { type: 'info' });
      console.error("Error processing redirect:", error);
                return;
    }
            }
  };


  const init = async () => {
            if (title.replace(/_/g, " ") === fullTarget.replace(/_/g, " ")) {
    const userGroups = mw.config.get("wgUserGroups");
                mw.notify(title + ": הפניה מעגלית או תקינה. אין צורך בתיקון.", { type: 'info' });
    const userId = mw.config.get("wgUserId");
                return;
    const pageName = mw.config.get("wgPageName");
            }


    if (!userGroups.includes("bot") && !BOT_USERS.includes(userId)) return;
            console.log("יוצר הפניה חדשה: " + title + " --> " + fullTarget);
    if (pageName !== "מיוחד:הפניות_כפולות") return;
            await createRedirect(title, fullTarget);


    const num = prompt("? כמה הפניות כפולות להציג", 0);
        } catch (error) {
    if (!num) return;
            console.error("שגיאה בעיבוד הפניה כפולה עבור " + title + ":", error);
            mw.notify(title + ": אירעה שגיאה בעת עיבוד ההפניה. פרטים בקונסול.", { type: 'error', title: 'שגיאה' });
        }
    };


     try {
     /**
      const { query } = await api.get({
    * הפונקציה הראשית שמפעילה את הסקריפט.
        list: "querypage",
    */
        qppage: "DoubleRedirects",
    const init = async () => {
        qplimit: num,
        const pageName = mw.config.get("wgPageName");
      });


      const redirects = query.querypage.results;
         // ודא שהסקריפט רץ רק בדף ההפניות הכפולות
      for (const redirect of redirects) {
         if (pageName !== "מיוחד:הפניות_כפולות") {
         const title = redirect.title.replace(/_/g, " ");
            console.log("הסקריפט פועל רק בדף מיוחד:הפניות_כפולות.");
         await processRedirect(title);
            return;
      }
        }
    } catch (error) {
      console.error("Error fetching redirects:", error);
    }
  };


  $(init);
        const numInput = prompt("כמה הפניות כפולות להציג ולתקן? (מומלץ להתחיל עם מספר קטן, לדוגמה: 10)", "0");
        const num = parseInt(numInput, 10);
 
        if (isNaN(num) || num <= 0) {
            mw.notify("קלט לא חוקי. אנא הזן מספר שלם חיובי.", { type: 'error' });
            return;
        }
 
        try {
            mw.notify("מתחיל בדיקת " + num + " הפניות כפולות...", { type: 'info' });
 
            // קבלת רשימת ההפניות הכפולות באמצעות API
            const { query } = await api.get({
                list: "querypage",
                qppage: "DoubleRedirects",
                qplimit: num,
            });
 
            const redirects = query.querypage.results;
            if (redirects.length === 0) {
                mw.notify("לא נמצאו הפניות כפולות לתיקון.", { type: 'info' });
                return;
            }
 
            // לולאה על כל הפניה ותיקונה
            for (const redirect of redirects) {
                const title = redirect.title.replace(/_/g, " ");
                await processRedirect(title);
            }
            mw.notify("סיום עיבוד ההפניות הכפולות.", { type: 'success', title: 'סיום' });
 
        } catch (error) {
            console.error("שגיאה באחזור הפניות כפולות:", error);
            mw.notify("אירעה שגיאה באחזור רשימת ההפניות הכפולות.", { type: 'error', title: 'שגיאה כללית' });
        }
    };
 
    // הפעל את הסקריפט כאשר הדף נטען
    $(init);
})();
})();
אוחזר מתוך "https://chabadpedia.co.il/index.php/משתמש:רובין_בוט/הפניות_כפולות.js"