查看“Widget:EditReport”的源代码

<includeonly>
    <script>
        const YEAR = `<!--{$y}-->` || 2024;
        const WIKINAME="恋与深空WIKI";
        const timeOrder = {
            '早晨': [[6, 7, 8, 9], ["早起的鸟儿不一定有虫吃，但是早起的猎人编辑有很多wiki要写o(╥﹏╥)o", "太阳当空照，花儿对你笑，小鸟说早早早，这么早就开始写wiki"]],
            '上午': [[10, 11, 12], ["上班的忙上班，上学的忙上学，摸鱼的忙……忙着写wiki（", "这么宝贵的一日之计用来写wiki是wiki的福气！"]],
            '下午': [[13, 14, 15, 16, 17], "快下班了写写wiki庆祝一下！"],
            '晚上': [[18, 19, 20, 21, 22], "公司，下班！wiki，上班！"],
            '深夜': [[23, 0, 1, 2, 3, 4, 5], "公司，加班（没加班工资）！wiki，加班（甚至没调休）！o(╥﹏╥)o"]
        };
        const editCountText = {
            1: "Wiki需要所有人参与，感谢你的加入！",
            100: "wiki幸甚有你！",
            1000: "你是Wiki的中坚力量，感谢你百忙之中抽出时间为wiki添砖加瓦！",
            5000: "你是Wiki的核心编辑，wiki的日益完善离不开你的辛苦制作！",
            10000: "你是Wiki的大佬，所有读者都受益于你的编辑，流浪体来了都要为你的编辑次数而倾倒，特此宣布你彻底拿下今年wiki锦标赛的36星！",
        };
        const editCountMaxText = '你是编辑的传奇，是wiki的顶梁柱，哈特见了为之落泪，豆佬见了都要撒币（付加班费），恋与深空wiki幸甚有你！';
        

        (function (global) {
            'use strict';
            // 年度编辑统计
            var EditYearCount = {
                // 配置对象
                config: {
                    year: YEAR,
                },
                // 初始化函数
                init: function () {
                    Utils.onApiReady(async function () {
                        try {
                            var data = await DataFetcher.fetchAllData();
                            if (!data) {
                                HTMLLogger.log("获取数据失败，请确保已登录并重试。");
                                return;
                            }
                            data = EditYearCount.stat(data);
                            console.log("loadData end", data);
                            window.data = data;
                            console.log("可以在控制台访问 data 变量查看数据");

                            // 渲染结果
                            await Renderer.display(data);
                        } catch (error) {
                            console.error("处理数据时发生错误:", error);
                            HTMLLogger.log("处理数据时发生错误: " + error.message);
                        }
                    });
                },

                stat: function (d) {
                    var eidt_ns = (data, ns) => data.contributions.filter(t => t.ns === ns).length
                    var edit_type = (data, type = ".css") => data.contributions.filter(t => t.title.endsWith(type)).length
                    d.stat = {
                        editcount: d.user.editcount,
                        editcount_year: d.contributions.length,
                        eidt_ns: {
                            0: eidt_ns(d, 0),
                            2: eidt_ns(d, 2),
                            4: eidt_ns(d, 4),
                            6: eidt_ns(d, 6),
                            8: eidt_ns(d, 8),
                            10: eidt_ns(d, 10),
                            12: eidt_ns(d, 12),
                            14: eidt_ns(d, 14),
                            274: eidt_ns(d, 274),
                            828: eidt_ns(d, 828),
                        },
                        edit_type: {
                            "css": edit_type(d, ".css"),
                            "js": edit_type(d, ".js"),
                        },
                        groups: d.user.groups,
                        registration: d.user.registrationdate,
                    }

                    const timeStats = {
                        earliest: null,
                        latest: null,
                        hourDistribution: new Array(24).fill(0)
                    };

                    // 获取时间段
                    const getTimeSlot = (hour) => {
                        for (const [slot, [hours]] of Object.entries(timeOrder)) {
                            if (hours.includes(hour)) return slot;
                        }
                        return null;
                    };

                    d.contributions.forEach(edit => {
                        const editDate = new Date(edit.timestamp);
                        const hour = editDate.getHours();
                        const minute = editDate.getMinutes();
                        
                        timeStats.hourDistribution[hour]++;

                        const timeString = editDate.toLocaleTimeString('zh-CN', { 
                            hour: '2-digit', 
                            minute: '2-digit',
                            hour12: false 
                        });

                        // 获取当前编辑的时间段
                        const currentSlot = getTimeSlot(hour);

                        // 查找最早的编辑
                        if (!timeStats.earliest) {
                            timeStats.earliest = {
                                timestamp: edit.timestamp,
                                time: timeString,
                                title: edit.title,
                                slot: currentSlot
                            };
                        } else {
                            const existingSlot = getTimeSlot(new Date(timeStats.earliest.timestamp).getHours());
                            const slotOrder = Object.keys(timeOrder);
                            const currentIndex = slotOrder.indexOf(currentSlot);
                            const existingIndex = slotOrder.indexOf(existingSlot);

                            if (currentIndex < existingIndex ||
                                (currentIndex === existingIndex &&
                                    editDate.getHours() < new Date(timeStats.earliest.timestamp).getHours())) {
                                timeStats.earliest = {
                                    timestamp: edit.timestamp,
                                    time: timeString,
                                    title: edit.title,
                                    slot: currentSlot
                                };
                            }
                        }

                        // 修改最晚编辑的判断逻辑
                        if (!timeStats.latest) {
                            timeStats.latest = {
                                timestamp: edit.timestamp,
                                time: timeString,
                                title: edit.title,
                                slot: currentSlot
                            };
                        } else {
                            const existingDate = new Date(timeStats.latest.timestamp);
                            const existingHour = existingDate.getHours();
                            const existingMinute = existingDate.getMinutes();
                            
                            // 转换时间为可比较的数值
                            // 对于凌晨时段（0-5点），加上24小时以确保正确比较
                            const currentValue = (hour >= 0 && hour <= 5 ? hour + 24 : hour) * 60 + minute;
                            const existingValue = (existingHour >= 0 && existingHour <= 5 ? existingHour + 24 : existingHour) * 60 + existingMinute;
                            
                            if (currentValue > existingValue) {
                                timeStats.latest = {
                                    timestamp: edit.timestamp,
                                    time: timeString,
                                    title: edit.title,
                                    slot: currentSlot
                                };
                            }
                        }
                    });

                    // 计算每个时段的编辑次数
                    const slotStats = Object.entries(timeOrder).map(([slot, [hours]]) => {
                        const count = hours.reduce((sum, hour) => sum + timeStats.hourDistribution[hour], 0);
                        return { slot, count };
                    }).filter(stat => stat.count > 0);

                    // 找出编辑次数最多的时段
                    const maxEditSlot = slotStats.reduce((max, current) =>
                        current.count > max.count ? current : max
                        , slotStats[0]);

                    // 为最多编辑的时段随机选择一句话
                    if (maxEditSlot) {
                        const messages = timeOrder[maxEditSlot.slot][1];
                        const randomMessage = Array.isArray(messages) ?
                            messages[Math.floor(Math.random() * messages.length)] :
                            messages;
                        timeStats.maxEditSlotMessage = randomMessage;
                    }

                    d.stat.timeStats = timeStats;
                    d.stat.slotStats = slotStats;
                    return d;
                },
            };

            // 数据获取模块
            var DataFetcher = {
                fetchAllData: async function () {
                    HTMLLogger.log("开始获取数据！这可能需要一点时间，请耐心等待。")

                    var wiki_path = RLCONF.wgGameName;
                    console.log("wiki_path:", wiki_path);  // 调试日志

                    // 获取用户名
                    var user = await DataFetcher.getUserInfo(wiki_path)
                    console.log("获取到的用户信息:", user);  // 调试日志

                    if (!user || !user.name) {
                        console.warn('未获取到用户名，无法继续。');
                        HTMLLogger.log("获取用户名失败，程序终止。这可能是由于未登录导致的。")
                        return null;
                    }

                    const contributions = await DataFetcher.getUserContributions(wiki_path, user.name);
                    console.log("获取到的编辑记录:", contributions);  // 调试日志

                    const bwikiData = await DataFetcher.getBwikiData();
                    console.log("获取到的bwiki数据:", bwikiData);  // 调试日志

                    return {
                        user: user,
                        contributions: contributions,
                        bwiki: bwikiData,
                    };
                },

                getBwikiData: async function () {
                    const url = 'https://tools-wiki.biligame.com/api/home/getAggregateResult';
                    try {
                        const response = await fetch(url);
                        if (!response.ok) {
                            HTMLLogger.log("BWIKI改了接口？全站统计数据无法获取。")
                            return {};
                        }
                        const data = await response.json();
                        return data.data.site_info;
                    } catch (error) {
                        HTMLLogger.log("BWIKI改了接口？全站统计数据无法获取。")
                        return {}
                    }
                },

                getUserContributions: async function (wikiName, username) {
                    var allContributions = [];

                    var api = new mw.Api();
                    api.defaults.ajax.url = '/' + wikiName + '/api.php';

                    var params = {
                        action: 'query',
                        list: 'usercontribs',
                        ucuser: username,
                        ucstart: YEAR.toString() + "-12-31T16:00:00Z", // 2025.1.1 -8小时 因为处于+8时区
                        ucend: (YEAR - 1) + "-12-31T16:00:00Z", // 2024.1.1 -8小时 因为处于+8时区
                        uclimit: 'max',
                        ucprop: 'title|timestamp',
                        format: 'json',
                    };

                    try {
                        do {
                            var response = await api.get(params);
                            if (response && response.query && response.query.usercontribs) {
                                allContributions = allContributions.concat(response.query.usercontribs);
                            }
                            params.uccontinue = response.continue?.uccontinue || null;
                        } while (response.continue);
                    } catch (e) {
                        console.warn('API 请求出错，数据可能不完整。错误：', e);
                    }
                    return allContributions;
                },

                getUserInfo: async function (wikiName) {
                    var params = {
                        action: 'query',
                        meta: 'userinfo',
                        uiprop: 'groups|editcount|registrationdate',
                    };
                    var api = new mw.Api();
                    api.defaults.ajax.url = '/' + wikiName + '/api.php';
                    var response = await api.get(params);
                    if (response.query && response.query.userinfo) {
                        return response.query.userinfo;
                    } else {
                        return {};
                    }
                }
            };

            var HTMLLogger = {
                log: function (message) {
                    var containerId = 'year-edit-log';
                    var container = document.getElementById(containerId);
                    if (!container) {
                        container = document.createElement('div');
                        container.id = containerId;
                        document.querySelector('.mw-parser-output').appendChild(container);
                    }
                    container.innerHTML += message;
                },
                clear: function () {
                    var containerId = 'year-edit-log';
                    var container = document.getElementById(containerId);
                    if (!container) {
                        container = document.createElement('div');
                        container.id = containerId;
                        document.querySelector('.mw-parser-output').appendChild(container);
                    }
                    container.innerHTML = "";
                }
            }

            // 展示模块
            var Renderer = {
                display: async function (d) {
                    try {
                        // 插入容器
                        var containerId = 'year-edit-container';
                        var container = document.getElementById(containerId) || (() => {
                            var newDiv = document.createElement('div');
                            newDiv.id = containerId;
                            document.querySelector('.mw-parser-output').appendChild(newDiv);
                            return newDiv;
                        })();

                        var innerHTML = '';

                        // 拼接 wikitext
                        var wikitext = "";
                        wikitext += `<center><big><big><b>${WIKINAME}年度报告[${YEAR}]</b></big></big></center>\n\n\n\n`;

                        // bwiki的接口，不确定是否能获取到数据
                        try {
                            wikitext += `BWiki托管了${d.bwiki.wiki_count}个Wiki，${WIKINAME}是其中之一。`;
                        } catch (e) { }
                        try {
                            wikitext += `BWiki目前的活跃用户有${d.bwiki.active_user_count}个，累计编辑${d.bwiki.edit_count}次。\n\n`;
                        } catch (e) { }

                        wikitext += `${WIKINAME}建站至今，累计编辑 {{NUMBEROFEDITS:R}}次，有{{NUMBEROFUSERS:R}}名用户，其中活跃编辑{{NUMBEROFACTIVEUSERS:R}}个，希望编辑的小伙伴在新的一年越来越多！\n\n\n\n`;

                        wikitext += `==你在${WIKINAME}==\n\n`

                        wikitext += `你在 ${d.stat.registration.split("T")[0]}首次访问${WIKINAME}，至今已经累计编辑${d.stat.editcount}次\n\n\n\n`;

                        wikitext += `你在今年总计编辑了${d.stat.editcount_year}次，`;

                        // 找到对应的编辑次数档位文本
                        const editThresholds = Object.keys(editCountText)
                            .map(Number)
                            .sort((a, b) => a - b);

                        let summaryText = '';
                        for (let threshold of editThresholds) {
                            if (d.stat.editcount_year >= threshold) {
                                summaryText = editCountText[threshold];
                            } else {
                                break;
                            }
                        }

                        // 如果编辑次数超过最大阈值，使用最大文本
                        if (d.stat.editcount_year >= Math.max(...editThresholds)) {
                            summaryText = editCountMaxText;
                        }

                        wikitext += `${summaryText}\n\n`;

                        // 添加命名空间统计信息
                        const nsNames = {
                            0: "主空间",
                            2: "用户",
                            4: "项目",
                            6: "文件",
                            8: "MediaWiki",
                            10: "模板",
                            12: "帮助",
                            14: "分类",
                            274: "Widget",
                            828: "模块"
                        };

                        // 过滤掉编辑数为0的命名空间并生成列表
                        const nsStats = Object.entries(d.stat.eidt_ns)
                            .filter(([_, count]) => count > 0)
                            .map(([ns, count]) => `* ${nsNames[ns]}：${count}次编辑`);

                        if (nsStats.length > 0) {
                            wikitext += `${nsStats.join('\n')}\n`;
                        }

                        // 如果有CSS或JS编辑，单独列出
                        if (d.stat.edit_type.css > 0 || d.stat.edit_type.js > 0) {
                            wikitext += `\n作为专业人士，你还贡献了：\n`;
                            if (d.stat.edit_type.css > 0) {
                                wikitext += `* CSS：${d.stat.edit_type.css}次编辑\n`;
                            }
                            if (d.stat.edit_type.js > 0) {
                                wikitext += `* JS：${d.stat.edit_type.js}次编辑\n`;
                            }
                        }

                        wikitext += `\n\n`

                        wikitext += `== 你的编辑时间段 ==\n`;

                        if (d.stat.timeStats.earliest) {
                            wikitext += `* 最早的编辑时间是 ${d.stat.timeStats.earliest.time}（编辑了[[${d.stat.timeStats.earliest.title}]]）\n`;
                        }

                        if (d.stat.timeStats.latest) {
                            wikitext += `* 最晚的编辑时间是 ${d.stat.timeStats.latest.time}（编辑了[[${d.stat.timeStats.latest.title}]]）\n`;
                        }

                        // 显示时段分布
                        wikitext += `\n各时段编辑分布：\n`;
                        d.stat.slotStats
                            .forEach(({ slot, count }) => {
                                const hours = timeOrder[slot][0];
                                const startHour = String(hours[0]).padStart(2, '0');
                                // 结束时间应该是最后一个小时的59分
                                const endHour = String(hours[hours.length-1]).padStart(2, '0');
                                const timeRange = `${startHour}:00-${endHour}:59`;
                                wikitext += `* ${slot}（${timeRange}）：${count}次编辑\n`;
                            });

                        // 显示编辑最多时段的总结和随机消息
                        if (d.stat.timeStats.maxEditSlotMessage) {
                            const maxSlot = d.stat.slotStats.reduce((max, curr) => curr.count > max.count ? curr : max);
                            const hours = timeOrder[maxSlot.slot][0];
                            const startHour = String(hours[0]).padStart(2, '0');
                            const endHour = String(hours[hours.length-1]).padStart(2, '0');
                            const timeRange = `${startHour}:00-${endHour}:59`;
                            
                            wikitext += `\n你最常在${maxSlot.slot}（${timeRange}）进行编辑，${d.stat.timeStats.maxEditSlotMessage}\n`;
                        }

                        wikitext += `\n`;


                        // wikitext to html
                        var params = {
                            action: 'parse',
                            contentmodel: 'wikitext',
                            text: wikitext,
                            prop: 'text|headhtml',
                            format: 'json'
                        };
                        var api = new mw.Api();
                        var res = await api.get(params);
                        console.log("wikitext2html", res);

                        if (!res.parse || !res.parse.text) {
                            throw new Error("无法解析 wikitext");
                        }

                        innerHTML = res.parse.text["*"];

                        // 确保容器存在
                        var container = document.getElementById('year-edit-container');
                        if (!container) {
                            container = document.createElement('div');
                            container.id = 'year-edit-container';
                            document.querySelector('.mw-parser-output').appendChild(container);
                        }

                        container.innerHTML = innerHTML;
                        HTMLLogger.clear();

                        // 清理备份输入框（如果存在）
                        const backupInputs = document.querySelector('#year-backup-inputs');
                        if (backupInputs) {
                            backupInputs.innerHTML = "";
                        }

                    } catch (error) {
                        console.error("渲染数据时发生错误:", error);
                        HTMLLogger.log("渲染数据时发生错误: " + error.message);
                    }
                }
            };

            // 工具模块
            var Utils = {
                // 等待 mw.Api 加载完成
                onApiReady: function (callback) {
                    var maxRetry = 32; // 最大重试次数
                    var retryTimeout = 81; // 每次重试间隔时间 81ms * 32 ≈ 2600ms
                    var retryCount = 0;

                    function waitApi() {
                        if (window.mw && typeof mw.Api === 'function') {
                            setTimeout(callback, retryTimeout); // 81ms 后才开始执行, 以确保相关功能已加载且可用
                        } else {
                            retryCount++;
                            if (retryCount < maxRetry) {
                                setTimeout(waitApi, retryTimeout); // 等待 retryTimeout 毫秒
                            } else {
                                var errorLogText = "等待mw.Api加载超时。已经等待 " + maxRetry.toString() + " 次";
                                errorLogText += "累计时间：" + (maxRetry * retryTimeout).toString() + " 毫秒。";
                                console.error(errorLogText);
                                // 触发错误处理
                                ErrorHandler.handleError(new Error(errorLogText));
                            }
                        }
                    }

                    waitApi();
                }
            };


            // 将命名空间暴露到全局（可选）
            window.EditAchievement = EditYearCount;


            // 启动初始化
            EditYearCount.init();


        })(this);
    </script>
</includeonly>
<noinclude>
    结果通过拼接wikitext渲染，可以自行魔改，比如嵌入模板、表格等等。


    {{#Widget:EditReport}}
</noinclude>