P站画师个人作品批量下载工具

配合Aria2,一键批量下载P站画师的全部作品

当前为 2024-10-11 提交的版本,查看 最新版本

  1. // ==UserScript==
  2. // @name PixivUserBatchDownload
  3. // @name:zh-CN P站画师个人作品批量下载工具
  4. // @name:zh-TW P站畫師個人作品批量下載工具
  5. // @name:zh-HK P站畫師個人作品批量下載工具
  6. // @description Batch download pixiv user's images in one key.(Based on Aria2)
  7. // @description:zh-CN 配合Aria2,一键批量下载P站画师的全部作品
  8. // @description:zh-TW 配合Aria2,一鍵批量下載P站畫師的全部作品
  9. // @description:zh-HK 配合Aria2,一鍵批量下載P站畫師的全部作品
  10. // @version 5.21.152
  11. // @author Mapaler <mapaler@163.com>
  12. // @copyright 2016~2024+, Mapaler <mapaler@163.com>
  13. // @namespace http://www.mapaler.com/
  14. // @icon https://www.pixiv.net/favicon.ico
  15. // @homepage https://github.com/Mapaler/PixivUserBatchDownload
  16. // @supportURL https://github.com/Mapaler/PixivUserBatchDownload/issues
  17. // @match *://www.pixiv.net/*
  18. // @exclude *://www.pixiv.net/upload.php*
  19. // @exclude *://www.pixiv.net/messages.php*
  20. // @exclude *://www.pixiv.net/ranking.php*
  21. // @exclude *://www.pixiv.net/info.php*
  22. // @exclude *://www.pixiv.net/ranking_report_user.php*
  23. // @exclude *://www.pixiv.net/setting*
  24. // @exclude *://www.pixiv.net/stacc*
  25. // @exclude *://www.pixiv.net/premium*
  26. // @exclude *://www.pixiv.net/discovery*
  27. // @exclude *://www.pixiv.net/howto*
  28. // @exclude *://www.pixiv.net/idea*
  29. // @exclude *://www.pixiv.net/ads*
  30. // @exclude *://www.pixiv.net/terms*
  31. // @exclude *://www.pixiv.net/novel*
  32. // @exclude *://www.pixiv.net/cate_r18*
  33. // @exclude *://www.pixiv.net/manage*
  34. // @exclude *://www.pixiv.net/report*
  35. // @resource pubd-style https://github.com/Mapaler/PixivUserBatchDownload/raw/master/PixivUserBatchDownload%20ui.css?v=5.20.146
  36. // @require https://cdn.jsdelivr.net/npm/crypto-js@4.2.0/core.min.js
  37. // @require https://cdn.jsdelivr.net/npm/crypto-js@4.2.0/md5.min.js
  38. // @require https://cdn.jsdelivr.net/npm/crypto-js@4.2.0/sha256.min.js
  39. // @require https://cdn.jsdelivr.net/npm/crypto-js@4.2.0/enc-base64.min.js
  40. // @grant window.close
  41. // @grant window.focus
  42. // @grant GM_xmlhttpRequest
  43. // @grant GM_getValue
  44. // @grant GM_setValue
  45. // @grant GM_deleteValue
  46. // @grant GM_addStyle
  47. // @grant GM_getResourceText
  48. // @grant GM_addValueChangeListener
  49. // @grant GM_registerMenuCommand
  50. // @grant GM_unregisterMenuCommand
  51. // @connect pixiv.net
  52. // @connect pximg.net
  53. // @connect localhost
  54. // @connect 127.0.0.1
  55. // @noframes
  56. // ==/UserScript==
  57.  
  58. (function() {
  59. 'use strict';
  60.  
  61. //获取当前是否是本地开发状态,自己用 localStorage.setItem("pubd-dev", "1") 既可以开启,localStorage.removeItem("pubd-dev") 关闭
  62. //注意开发状态下为了方便随时调整预览,css 不会自动加载,需要自己用 Stylus 扩展添加 PixivUserBatchDownload ui.css 的内容。
  63. const mdev = Boolean(localStorage.getItem("pubd-dev"));
  64. if (mdev) console.log("GM_info信息:",GM_info); //开发模式时显示meta数据
  65.  
  66. /*
  67. * 公共变量区
  68. */
  69.  
  70. //储存vue框架下P站页面主要内容的DIV位置,现在由程序自行搜索判断,搜索依据为 mainDivSearchCssSelectorArray。
  71. //#root vue的root,源代码中固定存在
  72. //#root>div:nth-of-type(2) 真正存储页面内容的动态 div,搜索条件为root下新增的没有 id 的 node(P站目前是这样)。
  73. //#root>div:nth-of-type(2)>div 再往下由于只有一个单独div,因此再往继续找到有 2 个以上的 node 的时候,记为子 root,其实后面的代码基本不会用到。
  74. let subRoot = null;
  75. //子 root 下面能找到按钮插入点的 node,暨主要内容的 div 而不是顶栏,记为 mainDiv
  76. let mainDiv = null;
  77. //不同页面开始按钮的插入位点
  78. //哪天P站位置改版了,可能就需要手动调整这些路径
  79. //下面的 :scope 指的是 mainDiv,2023年8月9日 当前路径为 #root>div:nth-of-type(2)>div>div:nth-of-type(3)
  80. // 先使用 selectors 字符串搜索,获取失败时使用 fallcack 处理函数
  81. const mainDivSearchCssSelector = [
  82. {selectors: '#spa-contents .user-stats'}, // 手机版用户页
  83. {selectors: '#spa-contents .user-details-card'}, // 手机版作品页
  84. // PC版 单个作品页
  85. {selectors: ':scope aside section:has(button[data-gtm-user-id][data-click-label])',
  86. fallcack: (node) => {
  87. const ele = node.querySelector(':scope main+aside>section div[title]');
  88. return ele?.closest('section');
  89. },
  90. },
  91. //2024年10月11日 目前火狐更新到128后,支持 :has 了,定位全部被导向这一条了,上面一条不起作用了。
  92. // PC版 用户资料页
  93. {selectors: ':scope :has(>div>h1,>div>button[data-gtm-user-id][data-click-label])',
  94. fallcack: (node) => {
  95. const ele = node.querySelector(':scope div[title]:not(a [title])');
  96. return ele?.parentElement?.parentElement?.nextElementSibling;
  97. },
  98. },
  99. ];
  100. //搜索页,列表的ul位置(用来显示收藏状态)
  101. const searchListCssPath = ':scope>div>div:nth-of-type(6)>div>section>div:nth-of-type(2)>ul';
  102. //作者页面“主页”按钮的CSS位置(用来获取作者ID)
  103. const userMainPageCssPath = ":scope nav>a";
  104. //作品页,收藏按钮的CSS位置(用来获取当前作品ID)
  105. const artWorkStarCssPath = ":scope main>section>div>div>figcaption>div>div>ul>li:nth-of-type(2)>a";
  106. //作品页,作者头像链接的CSS位置(用来获取作者ID)
  107. const artWorkUserHeadCssPath = ":scope aside>section>h2>div>a";
  108.  
  109. const scriptVersion = GM_info.script.version.trim(); //本程序的版本
  110. const scriptIcon = GM_info.script.icon64 || GM_info.script.icon; //本程序的图标
  111. const scriptName = (defaultName=>{ //本程序的名称
  112. if (typeof(GM_info) != "undefined") //使用了扩展
  113. {
  114. if (GM_info.script.name_i18n)
  115. {
  116. return GM_info.script.name_i18n[navigator.language.replaceAll("-","_")]; //支持Tampermonkey
  117. } else
  118. {
  119. return GM_info.script.localizedName || //支持Greasemonkey 油猴子 3.x
  120. GM_info.script.name; //支持Violentmonkey 暴力猴
  121. }
  122. }
  123. return defaultName;
  124. })('PixivUserBatchDownload');
  125.  
  126. const pubd = { //储存程序设置
  127. configVersion: 2, //当前设置版本,用于处理老版本设置的改变
  128. touch: false, //是否为手机版
  129. loggedIn: false, //登录了(未启用)
  130. start: null, //开始按钮指针
  131. menu: null, //菜单指针
  132. dialog: { //窗口们的指针
  133. config: null, //设置窗口
  134. login: null, //登录窗口
  135. refresh_token: null, //刷新token窗口
  136. downthis: null, //下载当前窗口
  137. downillust: null, //下载当前作品窗口
  138. importdata: null, //导入数据窗口(还未开发)
  139. multiple: null, //多画师批量下载窗口(还未开发)
  140. },
  141. oAuth: null, //储存账号密码
  142. downSchemes: [], //储存下载方案
  143. downbreak: false, //是否停止发送Aria2的flag
  144. ajaxTimes: 0, //已经从P站获取信息的次数(用来判断是否要减速)
  145. fastStarList: null, //储存快速收藏的简单数字
  146. starUserlists: [], //储存完整的下载列表
  147. };
  148.  
  149. //匹配P站内容的正则表达式
  150. const illustPathRegExp = /(\/.+\/\d{4}\/\d{2}\/\d{2}\/\d{2}\/\d{2}\/\d{2}\/((\d+)(?:-([0-9a-zA-Z]+))?(?:_p|_ugoira)))\d+(?:_\w+)?\.([\w\d]+)/i; //P站画作地址 path部分 正则匹配式
  151. const limitingPathRegExp = /(\/common\/images\/(limit_(?:mypixiv|unknown)_\d+))\.([\w\d]+)/i; //P站无权访问作品地址 path部分 正则匹配式
  152. const limitingFilenameExp = /limit_(mypixiv|unknown)/ig; //P站上锁图片文件名正则匹配式
  153.  
  154. //Header使用
  155. const PixivAppVersion = "6.127.0"; //Pixiv APP的版本
  156. const AndroidVersion = "15.0.0"; //安卓的版本
  157. const UA = `PixivAndroidApp/${PixivAppVersion} (Android ${AndroidVersion}; Android SDK built for x64)`; //向P站请求数据时的UA
  158.  
  159. //X_Client加密的salt,目前是固定值
  160. const X_Client_Hash_Salt = "28c1fdd170a5204386cb1313c7077b34f83e4aaf4aa829ce78c231e05b0bae2c";
  161. /*
  162. const X_Client_Hash_Salt = [ //数值写法
  163. 0x28,0xC1,0xFD,0xD1,
  164. 0x70,0xA5,0x20,0x43,
  165. 0x86,0xCB,0x13,0x13,
  166. 0xC7,0x07,0x7B,0x34,
  167. 0xF8,0x3E,0x4A,0xAF,
  168. 0x4A,0xA8,0x29,0xCE,
  169. 0x78,0xC2,0x31,0xE0,
  170. 0x5B,0x0B,0xAE,0x2C
  171. ].map(n=>n.toString(16).toLowerCase()).join('');
  172. */
  173.  
  174. const Referer = "https://app-api.pixiv.net/"; //手机app的 Referer,不是这个无法下载图片
  175. const ContentType = "application/x-www-form-urlencoded; charset=UTF-8"; //重要,不要轻易修改
  176. //登录时的固定参数
  177. const client_id = "MOBrBDS8blbauoSck0ZfDbtuzpyT"; //安卓版固定数据
  178. const client_secret = "lsACyCD94FhDUtGTXi3QzcFE2uU1hqtDaKeqrdwj"; //安卓版固定数据
  179.  
  180.  
  181. let thisPageUserid = null, //当前页面的画师ID
  182. thisPageIllustid = null, //当前页面的作品ID
  183. downIllustMenuId = null, //下载当前作品的菜单的ID(Tampermonker菜单内的指针)
  184. recommendList = null; //推荐作品列表Dom位置
  185.  
  186. const startDelayAjaxTimes = 100; //开始执行延迟的ajax次数
  187. const ajaxDelayDuration = 1000; //每次延迟的时间
  188. const changeTermwiseCount = 6000; //图片数量大于这个值就从按作者发送切换为按图片发送
  189.  
  190. /*
  191. * 初始化数据库,这个功能没继续开发了的
  192. */
  193. if (mdev)
  194. {
  195. const dbName = "PUBD";
  196. var db;
  197. const DBOpenRequest = indexedDB.open(dbName);
  198.  
  199. DBOpenRequest.onsuccess = function(event) {
  200. db = event.target.result; //DBOpenRequest.result;
  201. console.log("PUBD:数据库已可使用");
  202. };
  203. DBOpenRequest.onerror = function(event) {
  204. // 错误处理
  205. console.log("PUBD:数据库无法启用",event);
  206. };
  207. DBOpenRequest.onupgradeneeded = function(event) {
  208. let db = event.target.result;
  209.  
  210. // 建立一个对象仓库来存储用户的相关信息,我们选择 user.id 作为键路径(key path)
  211. // 因为 user.id 可以保证是不重复的
  212. let usersStore = db.createObjectStore("users", { keyPath: "user.id" });
  213. // 建立一个索引来通过姓名来搜索用户。名字可能会重复,所以我们不能使用 unique 索引
  214. usersStore.createIndex("name", "user.name", { unique: false });
  215. // 使用账户建立索引,我们确保用户的账户不会重复,所以我们使用 unique 索引
  216. usersStore.createIndex("account", "user.account", { unique: true });
  217.  
  218. let illustsStore = db.createObjectStore("illusts", { keyPath: "id" });
  219. illustsStore.createIndex("type", "type", { unique: false });
  220. illustsStore.createIndex("userid", "user.id", { unique: false });
  221. // 使用事务的 oncomplete 事件确保在插入数据前对象仓库已经创建完毕
  222. illustsStore.transaction.oncomplete = function(event) {
  223. console.log("PUBD:数据库建立完毕");
  224. };
  225. };
  226. }
  227. /*
  228. * 获取初始状态
  229. */
  230. //尝试获取旧版网页对象
  231. /*if (typeof(unsafeWindow) != "undefined")
  232. { //原来的信息-除少部分页面外已失效2020年7月9日
  233. const pixiv = unsafeWindow.pixiv;
  234. }*/
  235. if (typeof(pixiv) != "undefined")
  236. {
  237. if (mdev) console.log("PUBD:本页面存在 pixiv 对象:",pixiv);
  238. thisPageUserid = parseInt(pixiv.context.userId);
  239. if (pixiv.user.loggedIn)
  240. {
  241. pubd.loggedIn = true;
  242. }
  243. if (/touch/i.test(pixiv.touchSourcePath))
  244. {
  245. pubd.touch = true; //新版的手机页面也还是老板结构-2020年7月9日
  246. document.body.classList.add('pubd-touch');
  247. }
  248. }
  249.  
  250. //尝试获取当前页面画师ID
  251. const metaPreloadData = document.querySelector('#meta-preload-data'); //HTML源代码里有,会被前端删掉的数据
  252. if (metaPreloadData != undefined) //更加新的存在于HTML元数据中的页面信息
  253. {
  254. pubd.loggedIn = true;
  255. if (mdev) console.log("PUBD:本页面抢救出 metaPreloadData 对象:",metaPreloadData);
  256. const preloadData = JSON.parse(metaPreloadData.content);
  257. if (mdev) console.log("PUBD:metaPreloadData 中的 preloadData 元数据:",preloadData);
  258. if (preloadData.user) thisPageUserid = parseInt(Object.keys(preloadData.user)[0]);
  259. if (preloadData.illust) thisPageIllustid = parseInt(Object.keys(preloadData.illust)[0]); //必须判断是否存在,否则会出现can't convert undefined to object错误
  260. }
  261. //获取是否为老的手机版
  262. if (location.host.includes("touch")) //typeof(pixiv.AutoView)!="undefined"
  263. {
  264. pubd.touch = true;
  265. document.body.classList.add('pubd-touch');
  266. }
  267.  
  268. /*
  269. * 自定义对象区
  270. */
  271. Date.PixivTimezoneOffset = (date=>{ //国内为 +08:00
  272. const o = date.getTimezoneOffset(); //本地时区差分钟数,正时区为负数
  273. //时区 +差时:差分
  274. return `${Math.trunc(-o/60).toLocaleString(void 0,{
  275. style: "decimal",
  276. minimumIntegerDigits: 2,
  277. signDisplay: "always"
  278. })}:${(o%60).toLocaleString(void 0,{
  279. style: "decimal",
  280. minimumIntegerDigits: 2,
  281. signDisplay: "never"
  282. })}`;
  283. //return `${o<=0?'+':'-'}${[o/60,o%60].map(n=>Math.trunc(Math.abs(n)).toString().padStart(2,'0')).join(':')}`;
  284. })(new Date());
  285. /**
  286. * 生成P站需要的时间格式
  287. * @returns P站时间格式如 "2019-09-03T18:51:40+08:00"
  288. */
  289. Date.prototype.toPixivString = function() {
  290. let s = this.toJSON();
  291. return s.substring(0,s.indexOf('.')) + Date.PixivTimezoneOffset;
  292. };
  293. //
  294. /**
  295. * 日期格式化
  296. * @param {string} format 格式 y:年,M:月,d:日,h:时,m:分,s:秒
  297. * @returns {string} 格式化的日期字符串
  298. * @see {@link https://www.cnblogs.com/tugenhua0707/p/3776808.html|代码来源}
  299. * @example
  300. * // returns "2023-08-29 21:22:51"
  301. * new Date().format("yyyy-MM-dd hh:mm:ss");
  302. */
  303. Date.prototype.format = function(format) {
  304. let fmt = format; //复制到新的字符串内
  305. const o = [
  306. ["M+" , this.getMonth()+1], //月份
  307. ["d+" , this.getDate()], //日
  308. ["h+" , this.getHours()], //小时
  309. ["m+" , this.getMinutes()], //分
  310. ["s+" , this.getSeconds()], //秒
  311. ["q+" , Math.floor((this.getMonth()+3)/3)], //季度
  312. ["S" , this.getMilliseconds()] //毫秒
  313. ];
  314. let regRes;
  315. if(regRes = /(y+)/.exec(fmt)) {
  316. fmt = fmt.replace(regRes[1], (this.getFullYear()+"").substr(4 - regRes[1].length));
  317. }
  318. for (let i = 0; i < o.length; i++) {
  319. let [k, v] = o[i];
  320. if(regRes = new RegExp("("+ k +")").exec(fmt)) {
  321. fmt = fmt.replace(regRes[1], (regRes[1].length===1) ? v : v.toString().padStart(2,'0'));
  322. }
  323. }
  324. return fmt;
  325. }
  326. /*
  327. //一个被收藏的画师
  328. class StarUser{
  329. constructor(id){
  330. const user = this;
  331. user.id = id;
  332. user.infoDone = false;
  333. user.downDone = false;
  334. user.userinfo = null;
  335. user.illusts = null;
  336. }
  337. }
  338. */
  339.  
  340. //一个画师收藏列表
  341. class UsersStarList{
  342. constructor(title,userArr = []){
  343. this.title = title;
  344. this.users = new Set(Array.from(userArr));
  345. this.users.delete(null);
  346. }
  347. add(userid)
  348. {
  349. if (isNaN(userid)) userid = parseInt(userid,10);
  350. if (!isNaN(userid) && userid != null) this.users.add(userid);
  351. }
  352. delete(userid)
  353. {
  354. if (isNaN(userid)) userid = parseInt(userid,10);
  355. this.users.delete(userid);
  356. }
  357. has(userid)
  358. {
  359. if (isNaN(userid)) userid = parseInt(userid,10);
  360. return this.users.has(userid);
  361. }
  362. toggle(userid)
  363. { //切换有无
  364. if (isNaN(userid)) userid = parseInt(userid,10);
  365. const _users = this.users;
  366. if (_users.has(userid) || isNaN(userid) || userid == null)
  367. {
  368. _users.delete(userid);
  369. return false;
  370. }else
  371. {
  372. _users.add(userid);
  373. return true;
  374. }
  375. }
  376. importArray(arr)
  377. {
  378. const arrMaxLength = 500000;
  379. arr = arr.filter(uid=>!isNaN(uid));
  380. if (arr.length>arrMaxLength)
  381. {
  382. alert(`PUBD:收藏用户最多仅允许添加 ${arrMaxLength.toLocaleString()} 个数据。`);
  383. arr = arr.splice(500000); //删除50万以后的
  384. }
  385. const _users = this.users;
  386. arr.forEach(uid=>_users.add(uid));
  387. }
  388. exportArray()
  389. {
  390. return Array.from(this.users);
  391. }
  392. }
  393. //一个本程序使用的headers数据
  394. class HeadersObject{
  395. constructor(importObj){
  396. const header = this;
  397. const timeStr = new Date().toPixivString();
  398. header["App-OS"] = "android";
  399. header["App-OS-Version"] = AndroidVersion;
  400. header["App-Version"] = PixivAppVersion;
  401. header["User-Agent"] = UA;
  402. header["Content-Type"] = ContentType; //重要
  403. header["Referer"] = Referer; // jshint ignore:line
  404. header["X-Client-Hash"] = CryptoJS.MD5(timeStr + X_Client_Hash_Salt).toString();
  405. header["X-Client-Time"] = timeStr;
  406.  
  407. if (typeof(obj) == "object") Object.assign(this, importObj);
  408. }
  409. }
  410.  
  411. //储存一项图片列表分析数据的对象
  412. class Works{
  413. constructor(){
  414. this.done = false; //是否分析完毕
  415. this.item = []; //储存图片数据
  416. this.break = false; //储存停止分析的Flag
  417. this.runing = false; //是否正在运行的Flasg
  418. this.next_url = ""; //储存下一页地址(断点续传)
  419. }
  420. };
  421.  
  422. Math.randomInteger = function(max, min = 0)
  423. {
  424. let _max = Math.max(max, min),
  425. _min = Math.min(max, min);
  426. return this.floor(this.random()*(_max-_min+1)+_min);
  427. }
  428. //认证方案
  429. class oAuth2
  430. {
  431. constructor(existAuth){
  432. this.code_verifier = this.constructor.random_code_verifier();
  433. this.login_time = null;
  434. this.authorization_code = null;
  435. this.auth_data = null;
  436. this.idp_urls = { //默认的综合网址集
  437. "account-edit": "https://accounts.pixiv.net/api/v2/account/edit",
  438. "auth-token": "https://oauth.secure.pixiv.net/auth/token",
  439. "auth-token-redirect-uri": "https://app-api.pixiv.net/web/v1/users/auth/pixiv/callback",
  440. };
  441. if (typeof(existAuth) == "object" && existAuth.auth_data)
  442. {
  443. Object.assign(this, existAuth);
  444. }
  445. }
  446. static random_code_verifier()
  447. {
  448. //OAuth 2.0 客户端应用生成一个43~128位的随机字符串 (code_verifier)并查找它的 SHA256 哈希,这称为 code_challenge。
  449. const codeLen = Math.randomInteger(43, 128); //产生43~128位
  450. const passArray = new Uint8Array(codeLen);
  451. window.crypto.getRandomValues(passArray); //获取符合密码学要求的安全的随机值
  452. const unreservedChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
  453. const charsLength = unreservedChars.length - 1;
  454. const codeArray = Array.from(passArray).map(x => unreservedChars.charAt(x/0xFF * charsLength));
  455. return codeArray.join('');
  456. }
  457. get_code_challenge(code_challenge_method)
  458. {
  459. if (code_challenge_method == "S256") //S256
  460. {
  461. const bytes = CryptoJS.SHA256(this.code_verifier);
  462. const base64 = bytes.toString(CryptoJS.enc.Base64);
  463. const base64url = this.constructor.base64_to_base64url(base64);
  464. return base64url;
  465. }
  466. else //plain
  467. {
  468. return this.code_verifier;
  469. }
  470. }
  471. static base64_to_base64url(base64)
  472. {
  473. let base64url = base64
  474. .replace(/\+/g, '-')
  475. .replace(/\//g, '_')
  476. .replace(/=+$/, '');
  477. return base64url;
  478. }
  479. refresh_idp_urls(options = {})
  480. {
  481. const thisAuth = this;
  482. //登录的Auth API
  483. GM_xmlhttpRequest({
  484. url: "https://app-api.pixiv.net/idp-urls",
  485. method: "get",
  486. responseType: "text",
  487. headers: new HeadersObject(),
  488. onload: function(response) {
  489. let jo;
  490. try {
  491. jo = JSON.parse(response.responseText);
  492. } catch (e) {
  493. console.error("获取综合网址集失败,返回可能不是JSON格式。", e, response);
  494. if(options.onload_notJson) options.onload_notJson(response.responseText);
  495. return;
  496. }
  497. if (jo.has_error || jo.errors) {
  498. console.error("获取综合网址集失败,返回错误消息", jo);
  499. if(options.onload_hasError) options.onload_hasError(jo);
  500. return;
  501. } else { //登录成功
  502. Object.assign(thisAuth.idp_urls, jo);
  503. console.info("获取综合网址集成功", jo);
  504. if(options.onload) options.onload(jo);
  505. return;
  506. }
  507. },
  508. onerror: function(response) {
  509. console.error("获取登录重定向网址失败,网络请求发生错误", response);
  510. if(options.onerror) options.onerror(response);
  511. return;
  512. }
  513. });
  514. }
  515. get_login_url()
  516. {
  517. const code_challenge_method = "S256"; //P站不支持plain
  518. const loginURL = new URL("https://app-api.pixiv.net/web/v1/login");
  519. loginURL.searchParams.set("code_challenge", this.get_code_challenge(code_challenge_method));
  520. loginURL.searchParams.set("code_challenge_method", code_challenge_method);
  521. loginURL.searchParams.set("client","pixiv-android");
  522. return loginURL;
  523. }
  524. login(authorization_code, options = {})
  525. {
  526. this.authorization_code = authorization_code;
  527.  
  528. const thisAuth = this;
  529. const postObj = new URLSearchParams();
  530. postObj.set("code_verifier", thisAuth.code_verifier);
  531. postObj.set("code", authorization_code);
  532. postObj.set("grant_type","authorization_code");
  533. postObj.set("redirect_uri",thisAuth.idp_urls["auth-token-redirect-uri"]);
  534. postObj.set("client_id", client_id);
  535. postObj.set("client_secret", client_secret);
  536. postObj.set("include_policy","true");
  537.  
  538. this.refresh_idp_urls({
  539. onload: function(){
  540. //登录的Auth API
  541. GM_xmlhttpRequest({
  542. url: thisAuth.idp_urls["auth-token"],
  543. method: "post",
  544. responseType: "text",
  545. headers: new HeadersObject(),
  546. data: postObj.toString(),
  547. onload: function(response) {
  548. let jo;
  549. try {
  550. jo = JSON.parse(response.responseText);
  551. } catch (e) {
  552. console.error("登录失败,返回可能不是JSON格式,或本程序异常。", e, response);
  553. if(options.onload_notJson) options.onload_notJson(response.responseText);
  554. return;
  555. }
  556. if (jo.has_error || jo.errors) {
  557. console.error("登录失败,返回错误消息", jo);
  558. if(options.onload_hasError) options.onload_hasError(jo);
  559. return;
  560. } else { //登录成功
  561. thisAuth.auth_data = jo;
  562. thisAuth.login_time = new Date().getTime();
  563. console.info("登录成功", jo);
  564. if(options.onload) options.onload(jo);
  565. return;
  566. }
  567. },
  568. onerror: function(response) {
  569. console.error("登录失败,网络请求发生错误", response);
  570. if(options.onerror) options.onerror(response);
  571. return;
  572. }
  573. });
  574. }
  575. });
  576. }
  577. refresh_token(options = {})
  578. {
  579. const thisAuth = this;
  580. const postObj = new URLSearchParams();
  581. postObj.set("client_id", client_id);
  582. postObj.set("client_secret", client_secret);
  583. postObj.set("grant_type","refresh_token");
  584. postObj.set("refresh_token",thisAuth.auth_data.refresh_token);
  585. postObj.set("include_policy","true");
  586.  
  587. //登录的Auth API
  588. GM_xmlhttpRequest({
  589. url: thisAuth.idp_urls["auth-token"],
  590. method: "post",
  591. responseType: "text",
  592. headers: new HeadersObject(),
  593. data: postObj.toString(),
  594. onload: function(response) {
  595. let jo;
  596. try {
  597. jo = JSON.parse(response.responseText);
  598. } catch (e) {
  599. console.error("刷新Token失败,返回可能不是JSON格式,或本程序异常。", e, response);
  600. if(options.onload_notJson) options.onload_notJson(response.responseText);
  601. return;
  602. }
  603. if (jo.has_error || jo.errors) {
  604. console.error("刷新Token失败,返回错误消息", jo);
  605. if(options.onload_hasError) options.onload_hasError(jo);
  606. return;
  607. } else { //登录成功
  608. thisAuth.auth_data = jo;
  609. thisAuth.login_time = new Date().getTime();
  610. console.info("刷新Token成功", jo);
  611.  
  612. if(options.onload) options.onload(jo);
  613. return;
  614. }
  615. },
  616. onerror: function(response) {
  617. console.error("刷新Token失败,网络请求发生错误", response);
  618. if(options.onerror) options.onerror(response);
  619. return;
  620. }
  621. });
  622. }
  623. save()
  624. {
  625. GM_setValue("pubd-oauth", this);
  626. }
  627. }
  628. //一个掩码
  629. var Mask = function(name, logic, content){
  630. this.name = name;
  631. this.logic = logic;
  632. this.content = content;
  633. };
  634. //一个下载方案
  635. var DownScheme = function(name) {
  636. //默认值
  637. this.name = name ? name : "默认方案";
  638. this.rpcurl = "http://localhost:6800/jsonrpc";
  639. this.proxyurl = "";
  640. this.downloadurl = "%{illust.parsedURL.protocol}//%{illust.parsedURL.host}%{illust.parsedURL.path_before_page}%{page}.%{illust.extention}";
  641. this.downfilter = "";
  642. this.savedir = "D:/PixivDownload/";
  643. this.savepath = "%{illust.user.id}/%{illust.filename}%{page}.%{illust.extention}";
  644. this.textout = "%{illust.url_without_page}%{page}.%{illust.extention}\n";
  645. this.masklist = [];
  646. };
  647. DownScheme.prototype.maskAdd = function(name, logic, content) {
  648. var mask = new Mask(name, logic, content);
  649. this.masklist.push(mask);
  650. return mask;
  651. };
  652. DownScheme.prototype.maskRemove = function(index) {
  653. this.masklist.splice(index, 1);
  654. };
  655. DownScheme.prototype.loadFromJson = function(json) {
  656. if (typeof(json) == "string") {
  657. try {
  658. json = JSON.parse(json);
  659. } catch (e) {
  660. console.error("读取的方案数据是字符串,但非JSON。",e);
  661. return false;
  662. }
  663. }
  664. const _this = this;
  665. Object.keys(_this).forEach(function(key){
  666. if (key=="masklist")
  667. {
  668. _this.masklist.length = 0; //清空之前的
  669. json.masklist.forEach(function(mask){
  670. _this.masklist.push(new Mask(mask.name, mask.logic, mask.content));
  671. });
  672. }else if(json[key] != undefined)
  673. {
  674. _this[key] = json[key];
  675. }
  676. });
  677. return true;
  678. };
  679.  
  680. //创建菜单类
  681. var pubdMenu = function(classname) {
  682. //生成菜单项
  683. function buildMenuItem(title, classname, callback, submenu) {
  684. var item = document.createElement("li");
  685. if (title == 0) //title为0时,只添加一条菜单分割线
  686. {
  687. item.className = "pubd-menu-line" + (classname ? " " + classname : "");
  688. return item;
  689. }
  690. item.className = "pubd-menu-item" + (classname ? " " + classname : "");
  691.  
  692. //如果有子菜单则添加子菜单
  693. if (typeof(submenu) == "object") {
  694. item.classList.add("pubd-menu-includesub"); //表明该菜单项有子菜单
  695. submenu.classList.add("pubd-menu-submenu"); //表明该菜单是子菜单
  696. //a.addEventListener("mouseenter",function(){callback.show()});
  697. //a.addEventListener("mouseleave",function(){callback.hide()});
  698. item.appendChild(submenu);
  699. item.subitem = submenu;
  700. }else
  701. {
  702. item.subitem = null; //子菜单默认为空
  703. }
  704.  
  705. //添加链接
  706. var a = item.appendChild(document.createElement("a"));
  707. a.className = "pubd-menu-item-a";
  708. //添加图标
  709. var icon = a.appendChild(document.createElement("i"));
  710. icon.className = "pubd-icon";
  711. //添加文字
  712. var span = a.appendChild(document.createElement("span"));
  713. span.className = "text";
  714. span.innerHTML = title;
  715.  
  716. //添加菜单操作
  717. if (typeof(callback) == "string") { //为字符串时,当作链接处理
  718. a.target = "_blank";
  719. a.href = callback;
  720. } else if (typeof(callback) == "function") { //为函数时,当作按钮处理
  721. item.addEventListener("click", callback);
  722. //a.onclick = callback;
  723. }
  724. return item;
  725. }
  726.  
  727. var menu = document.createElement("ul");
  728. menu.className = "pubd-menu display-none" + (classname ? " " + classname : "");
  729. menu.item = [];
  730. //显示该菜单
  731. menu.show = function() {
  732. menu.classList.remove("display-none");
  733. };
  734. menu.hide = function() {
  735. menu.classList.add("display-none");
  736. };
  737. //添加菜单项
  738. menu.add = function(title, classname, callback, submenu) {
  739. var itm = buildMenuItem(title, classname, callback, submenu);
  740. this.appendChild(itm);
  741. this.item.push(itm);
  742. return itm;
  743. };
  744. //鼠标移出菜单时消失
  745. menu.addEventListener("mouseleave", function(e) {
  746. this.hide();
  747. });
  748. return menu;
  749. };
  750.  
  751. //创建通用对话框类
  752. var Dialog = function(caption, classname, id) {
  753. //构建标题栏按钮
  754. function buildDlgCptBtn(text, classname, callback) {
  755. if (!callback) classname = "";
  756. const btn = document.createElement("a");
  757. btn.className = "dlg-cpt-btn" + (classname ? " " + classname : "");
  758. if (typeof(callback) == "string") {
  759. btn.target = "_blank";
  760. btn.href = callback;
  761. } else {
  762. if (callback)
  763. btn.addEventListener("click", callback);
  764. }
  765. var btnTxt = btn.appendChild(document.createElement("span"));
  766. btnTxt.className = "dlg-cpt-btn-text";
  767. btnTxt.innerHTML = text;
  768.  
  769. return btn;
  770. }
  771.  
  772. var dlg = document.createElement("div");
  773. if (id) dlg.id = id;
  774. dlg.className = "pubd-dialog display-none" + (classname ? " " + classname : "");
  775.  
  776. //添加图标与标题
  777. var cpt = dlg.appendChild(document.createElement("div"));
  778. cpt.className = "caption";
  779. dlg.icon = cpt.appendChild(document.createElement("i"));
  780. dlg.icon.className = "pubd-icon";
  781. var captionDom = cpt.appendChild(document.createElement("span"));
  782. Object.defineProperty(dlg , "caption", {
  783. get() {
  784. return captionDom.textContent;
  785. },
  786. set(str) {
  787. captionDom.innerHTML = str;
  788. }
  789. });
  790. dlg.caption = caption;
  791.  
  792. //添加标题栏右上角按钮 captionButtons
  793. var cptBtns = dlg.cptBtns = dlg.appendChild(document.createElement("div"));
  794. cptBtns.className = "dlg-cpt-btns";
  795. //添加按钮的函数
  796. cptBtns.add = function(text, classname, callback) {
  797. var btn = buildDlgCptBtn(text, classname, callback);
  798. this.insertBefore(btn, this.firstChild);
  799. return btn;
  800. };
  801. //添加关闭按钮
  802. cptBtns.close = cptBtns.add("X", "dlg-btn-close", (function() {
  803. dlg.classList.add("display-none");
  804. }));
  805.  
  806. //添加内容区域
  807. var content = dlg.content = dlg.appendChild(document.createElement("div"));
  808. content.className = "dlg-content";
  809.  
  810. //窗口激活
  811. dlg.active = function() {
  812. if (!this.classList.contains("pubd-dlg-active")) { //如果没有激活的话才执行
  813. var dlgs = document.querySelectorAll(".pubd-dialog"); //获取网页已经载入的所有的窗口
  814. for (var dlgi = 0; dlgi < dlgs.length; dlgi++) { //循环所有窗口
  815. if (dlgs[dlgi] != this)
  816. {
  817. dlgs[dlgi].classList.remove("pubd-dlg-active"); //取消激活
  818. dlgs[dlgi].style.zIndex = parseInt(window.getComputedStyle(dlgs[dlgi], null).getPropertyValue("z-index")) - 1; //从当前网页最终样式获取该窗体z级,并-1.
  819. }
  820. }
  821. this.classList.add("pubd-dlg-active"); //添加激活
  822. this.style.zIndex = ""; //z级归零
  823. }
  824. };
  825. //窗口初始化
  826. dlg.initialise = function() { //窗口初始化默认情况下什么也不做,具体在每个窗口再设置
  827. return;
  828. };
  829. //窗口显示
  830. dlg.show = function(posX, posY, arg) {
  831. if (posX) dlg.style.left = posX + "px"; //更改显示时初始坐标
  832. if (posY) dlg.style.top = posY + "px";
  833. dlg.initialise(arg); //对窗体进行初始化(激活为可见前提前修改窗体内容)
  834. dlg.classList.remove("display-none");
  835. dlg.active(); //激活窗口
  836. };
  837. //窗口隐藏
  838. dlg.hide = function() { //默认情况下等同于关闭窗口
  839. dlg.cptBtns.close.click();
  840. };
  841. //添加鼠标拖拽移动
  842. var drag = dlg.drag = [0, 0]; //[X,Y] 用以储存窗体开始拖动时的鼠标相对窗口坐标差值。
  843. //startDrag(cpt, dlg);
  844. cpt.addEventListener("mousedown", function(e) { //按下鼠标则添加移动事件
  845. var eX = e.pageX>0?e.pageX:0, eY = e.pageY>0?e.pageY:0; //不允许鼠标坐标向上、左超出网页。
  846. drag[0] = eX - dlg.offsetLeft;
  847. drag[1] = eY - dlg.offsetTop;
  848. var handler_mousemove = function(e) { //移动鼠标则修改窗体坐标
  849. var eX = e.pageX>0?e.pageX:0, eY = e.pageY>0?e.pageY:0; //不允许鼠标坐标向上、左超出网页。
  850. dlg.style.left = (eX - drag[0]) + 'px';
  851. dlg.style.top = (eY - drag[1]) + 'px';
  852. };
  853. var handler_mouseup = function(e) { //抬起鼠标则取消移动事件
  854. document.removeEventListener("mousemove", handler_mousemove);
  855. };
  856. document.addEventListener("mousemove", handler_mousemove);
  857. document.addEventListener("mouseup", handler_mouseup, { once: true });
  858. });
  859. //点击窗口任何区域激活窗口
  860. dlg.addEventListener("mousedown", function(e) {
  861. dlg.active();
  862. });
  863. return dlg;
  864. };
  865.  
  866. //创建框架类
  867. var Frame = function(title, classname) {
  868. var frame = document.createElement("fieldset");
  869. frame.className = "pubd-frame" + (classname ? " " + classname : "");
  870.  
  871. var caption = frame.appendChild(document.createElement("legend"));
  872. caption.className = "pubd-frame-caption";
  873. caption.textContent = title;
  874. var content = frame.content = frame.appendChild(document.createElement("div"));
  875. content.className = "pubd-frame-content";
  876.  
  877. frame.rename = function(newName) {
  878. if (typeof(newName) == "string" && newName.length > 0) {
  879. this.querySelector("legend").textContent = newName;
  880. return true;
  881. } else
  882. return false;
  883. };
  884.  
  885. return frame;
  886. };
  887.  
  888. //创建带Label的Input类
  889. const LabelInput = function(text, classname, name, type, value, beforeText, title) {
  890. var label = document.createElement("label");
  891. if (text) label.appendChild(document.createTextNode(text));
  892. label.className = classname;
  893. if (title) label.title = title;
  894.  
  895. var ipt = label.input = document.createElement("input");
  896. ipt.name = name;
  897. ipt.id = ipt.name;
  898. ipt.type = type;
  899. ipt.value = value;
  900.  
  901. if (beforeText && label.childNodes.length>0)
  902. label.insertBefore(ipt, label.firstChild);
  903. else
  904. label.appendChild(ipt);
  905. return label;
  906. };
  907.  
  908. //构建错误信息显示模块
  909. const ErrorMsg = function() {
  910. const error_msg_list = document.createElement("ul");
  911. error_msg_list.className = "error-msg-list";
  912. //添加错误显示功能
  913. error_msg_list.clear = function() {
  914. this.innerHTML = ""; //清空当前信息
  915. };
  916. error_msg_list.add = function(arg) {
  917. function addLine(str)
  918. {
  919. const li = document.createElement("li");
  920. li.className = "error-msg-list-item";
  921. li.appendChild(document.createTextNode(str));
  922. return li;
  923. }
  924. const fragment = document.createDocumentFragment();
  925. if (Array.isArray(arg)) //数组
  926. {
  927. arg.forEach(str=>fragment.appendChild(addLine(str)));
  928. }
  929. else //单文本
  930. {
  931. fragment.appendChild(addLine(arg));
  932. }
  933. this.appendChild(fragment);
  934. };
  935.  
  936. error_msg_list.replace = function(arg) {
  937. this.clear();
  938. this.add(arg);
  939. };
  940. return error_msg_list;
  941. }
  942.  
  943. //创建进度条类
  944. const Progress = function(classname, align_right) {
  945. const progress = document.createElement("div");
  946. progress.className = "pubd-progress" + (classname ? " " + classname : "");
  947. if (align_right) progress.classList.add("pubd-progress-right");
  948.  
  949. progress.scaleNum = 0;
  950.  
  951. const bar = progress.appendChild(document.createElement("div"));
  952. bar.className = "pubd-progress-bar";
  953.  
  954. const txt = progress.appendChild(document.createElement("span"));
  955. txt.className = "pubd-progress-text";
  956.  
  957. progress.set = function(scale, pos = 2, str = null) {
  958. const percentStr = (scale * 100).toFixed(pos) + "%"; //百分比的数字
  959. this.scaleNum = Math.min(Math.max(scale, 0), 1);
  960. bar.style.width = percentStr;
  961. txt.textContent = str || percentStr;
  962. };
  963. Object.defineProperty(progress , "scale", {
  964. get() {
  965. return this.scaleNum;
  966. },
  967. set(num) {
  968. this.set(num);
  969. }
  970. });
  971.  
  972. return progress;
  973. };
  974.  
  975. //创建 卡片类
  976. function InfoCard(datas) {
  977. var cardDiv = this.dom = document.createElement("div");
  978. cardDiv.className = "pubd-infoCard";
  979. var thumbnailDiv = cardDiv.appendChild(document.createElement("div"));
  980. thumbnailDiv.className = "pubd-infoCard-thumbnail";
  981. var thumbnailImgDom = thumbnailDiv.appendChild(document.createElement("img"));
  982. var infosDlDom = cardDiv.appendChild(document.createElement("dl"));
  983. infosDlDom.className = "pubd-infoCard-dl";
  984. Object.defineProperty(this , "thumbnail", {
  985. get() {
  986. return thumbnailImgDom.src;
  987. },
  988. set(url) {
  989. thumbnailImgDom.src = url;
  990. }
  991. });
  992. var infoObj;
  993. this.reload = function() //重构Card文本区域
  994. {
  995. infosDlDom.classList.add('display-none');
  996. for (let ci = infosDlDom.childNodes.length-1;ci >= 0;ci--)
  997. { //删掉所有老子元素
  998. var x = infosDlDom.childNodes[ci];
  999. x.remove();
  1000. x = null;
  1001. }
  1002. const fragment = document.createDocumentFragment();
  1003. Object.entries(infoObj).forEach(entry=>{
  1004. const dt = fragment.appendChild(document.createElement("dt"));
  1005. const dd = fragment.appendChild(document.createElement("dd"));
  1006. dt.appendChild(document.createTextNode(entry[0]));
  1007. if (entry[1]) dd.appendChild(document.createTextNode(entry[1]));
  1008. });
  1009. infosDlDom.appendChild(fragment);
  1010. infosDlDom.classList.remove('display-none');
  1011. };
  1012.  
  1013. Object.defineProperty(this , "infos", {
  1014. get() {
  1015. return infoObj;
  1016. },
  1017. set(obj) {
  1018. infoObj = obj;
  1019. this.reload();
  1020. }
  1021. });
  1022. this.infos = datas || {}; //使用传入data进行初始设定
  1023. }
  1024. //创建下拉框类
  1025. var Select = function(classname, name) {
  1026. var select = document.createElement("select");
  1027. select.className = "pubd-select" + (classname ? " " + classname : "");
  1028. select.name = name;
  1029. select.id = select.name;
  1030.  
  1031. select.add = function(text, value) {
  1032. var opt = new Option(text, value);
  1033. this.options.add(opt);
  1034. };
  1035. select.remove = function(index) {
  1036. var x = this.options.remove(index);
  1037. x = null;
  1038. };
  1039.  
  1040. return select;
  1041. };
  1042.  
  1043. //创建Aria2类
  1044. var Aria2 = (function() {
  1045. var jsonrpc_version = '2.0';
  1046.  
  1047. function get_auth(url) {
  1048. return url.match(/^(?:(?![^:@]+:[^:@\/]*@)[^:\/?#.]+:)?(?:\/\/)?(?:([^:@]*(?::[^:@]*)?)?@)?/)[1];
  1049. }
  1050.  
  1051. function request(jsonrpc_path, method, params, callback, priority) {
  1052. if (callback == undefined) callback = ()=>{};
  1053. var auth = get_auth(jsonrpc_path);
  1054. jsonrpc_path = jsonrpc_path.replace(/^((?![^:@]+:[^:@\/]*@)[^:\/?#.]+:)?(\/\/)?(?:(?:[^:@]*(?::[^:@]*)?)?@)?(.*)/, '$1$2$3'); // auth string not allowed in url for firefox
  1055.  
  1056. var request_obj = {
  1057. jsonrpc: jsonrpc_version,
  1058. method: method,
  1059. id: priority ? 1 : Date.now(),
  1060. };
  1061. if (params) request_obj.params = params;
  1062. if (auth && auth.indexOf('token:') == 0)
  1063. {
  1064. if (method == "system.multicall")
  1065. { //多项目操作时单独设置token
  1066. params.forEach(function(param){
  1067. param.forEach(function(method){
  1068. method.params.unshift(auth);
  1069. });
  1070. });
  1071. }else
  1072. {
  1073. params.unshift(auth);
  1074. }
  1075. }
  1076.  
  1077. var headers = { "Content-Type": ContentType };
  1078. if (auth && auth.indexOf('token:') != 0) {
  1079. headers.Authorization = "Basic " + btoa(auth);
  1080. }
  1081. GM_xmlhttpRequest({
  1082. url: jsonrpc_path + "?tm=" + (new Date()).getTime().toString(),
  1083. method: "POST",
  1084. responseType: "text",
  1085. data: JSON.stringify(request_obj),
  1086. headers: headers,
  1087. onload: function(response) {
  1088. try {
  1089. var JSONreq = JSON.parse(response.response);
  1090. callback(JSONreq);
  1091. } catch (e) {
  1092. console.error("Aria2发送信息错误", e, response);
  1093. callback(false);
  1094. }
  1095. },
  1096. onerror: function(response) {
  1097. console.error(response);
  1098. callback(false);
  1099. }
  1100. });
  1101. }
  1102.  
  1103. return function(jsonrpc_path) {
  1104. const _this = this;
  1105. _this.jsonrpc_path = jsonrpc_path;
  1106. _this.addUri = function(uri, options, callback) {
  1107. request(_this.jsonrpc_path, 'aria2.addUri', [
  1108. [uri, ], options
  1109. ], callback);
  1110. };
  1111. _this.addTorrent = function(base64txt, options, callback) {
  1112. request(_this.jsonrpc_path, 'aria2.addTorrent', [base64txt, [], options], callback);
  1113. };
  1114. _this.getVersion = function(callback) {
  1115. request(_this.jsonrpc_path, 'aria2.getVersion', [], callback, true);
  1116. };
  1117. _this.getGlobalOption = function(callback) {
  1118. request(_this.jsonrpc_path, 'aria2.getGlobalOption', [], callback, true);
  1119. };
  1120. _this.system = {
  1121. multicall:function(params,callback){
  1122. request(_this.jsonrpc_path, 'system.multicall', params, callback);
  1123. },
  1124. };
  1125. return this;
  1126. };
  1127. })();
  1128.  
  1129. /*
  1130. * 自定义函数区
  1131. */
  1132. //仿GM_notification函数v1.2,发送网页通知。
  1133. //此函数非Debug用,为了替换选项较少但是兼容其格式的GM_notification插件
  1134. function GM_notification(text, title, image, onclick) {
  1135. const options = {};
  1136. let rTitle, rText;
  1137. let ondone, onclose;
  1138. const dataMode = Boolean(typeof(text) == "string"); //GM_notification有两种模式,普通4参数模式和option对象模式
  1139. if (dataMode)
  1140. { //普通模式
  1141. rTitle = title;
  1142. rText = text;
  1143. options.body = text;
  1144. options.icon = image;
  1145. }else
  1146. { //选项模式
  1147. const details = text;
  1148. rTitle = details.title;
  1149. rText = details.text;
  1150. if (details.text) options.body = details.text;
  1151. if (details.image) options.icon = details.image;
  1152. if (details.timeout) options.timestamp = details.timeout;
  1153. ondone = title;
  1154. onclose = image;
  1155. //if (details.highlight) options.highlight = details.highlight; //没找到这个功能
  1156. }
  1157.  
  1158. function sendNotification(general){
  1159. const n = new Notification(rTitle, options);
  1160. if (general)
  1161. { //普通模式
  1162. if (onclick) n.onclick = onclick;
  1163. }else
  1164. { //选项模式,这里和TamperMonkey API不一样,区分了关闭和点击。
  1165. if (ondone) n.onclick = ondone;
  1166. if (onclose) n.onclose = onclose;
  1167. }
  1168. }
  1169. // 先检查浏览器是否支持
  1170. if (!("Notification" in window)) {
  1171. alert(rTitle + "\r\n" + rText);
  1172. // 检查用户是否同意接受通知
  1173. } else if (Notification.permission === "granted") {
  1174. Notification.requestPermission(function(permission) {
  1175. sendNotification(dataMode);
  1176. });
  1177. }
  1178. // 否则我们需要向用户获取权限
  1179. else if (Notification.permission !== 'denied') {
  1180. Notification.requestPermission(function(permission) {
  1181. // 如果用户同意,就可以向他们发送通知
  1182. if (permission === "granted") {
  1183. sendNotification(dataMode);
  1184. }
  1185. });
  1186. }
  1187. }
  1188. //有默认值的获取设置
  1189. function getValueDefault(name, defaultValue) {
  1190. var value = GM_getValue(name);
  1191. if (value != null)
  1192. return value;
  1193. else
  1194. return defaultValue;
  1195. }
  1196. //加入了Auth的网络请求函数
  1197. function xhrGenneral(url, onload_suceess_Cb, onload_hasError_Cb, onload_notJson_Cb, onerror_Cb, dlog=str=>str) {
  1198. const headersObj = new HeadersObject();
  1199. const auth = pubd.oAuth.auth_data;
  1200. if (auth) {
  1201. headersObj.Authorization = auth.token_type[0].toUpperCase() + auth.token_type.substring(1) + " " + auth.access_token;
  1202. } else {
  1203. console.info(dlog("未登录账户,尝试以非登录状态获取信息"));
  1204. }
  1205.  
  1206. GM_xmlhttpRequest({
  1207. url: url,
  1208. method: "get",
  1209. responseType: "text",
  1210. headers: headersObj,
  1211. onload: function(response) {
  1212. let jo;
  1213. try {
  1214. jo = JSON.parse(response.responseText);
  1215. } catch (e) {
  1216. console.error(dlog("错误:返回可能不是JSON格式,或本程序异常"), e, response);
  1217. onload_notJson_Cb(response);
  1218. return;
  1219. }
  1220.  
  1221. if (jo)
  1222. {
  1223. if (mdev) console.log("请求URL %s,结果 %o",url,JSON.parse(response.responseText));
  1224. //jo.error.message 是JSON字符串的错误信息,Token错误的时候返回的又是普通字符串
  1225. //jo.error.user_message 是单行文本的错误信息
  1226. if (jo.error) {
  1227. if (jo.error.message.includes("Error occurred at the OAuth process.")) {
  1228. if (auth) {
  1229. console.warn(dlog("授权 Token 过期,开始自动更新。"),jo);
  1230. //自动重新登录
  1231. pubd.dialog.refresh_token.show(
  1232. (document.body.clientWidth - 370)/2,
  1233. window.scrollY+300,
  1234. {
  1235. onload: ()=>{
  1236. pubd.dialog.refresh_token.hide();
  1237. xhrGenneral(url, onload_suceess_Cb, onload_hasError_Cb, onload_notJson_Cb, onerror_Cb);
  1238. },
  1239. onload_hasError: onload_hasError_Cb,
  1240. onload_notJson: onload_notJson_Cb,
  1241. onerror: onerror_Cb,
  1242. }
  1243. );
  1244. } else {
  1245. console.info(dlog("非登录模式尝试获取信息失败"),jo);
  1246. onload_hasError_Cb(jo);
  1247. }
  1248. return;
  1249. }else if (jo.error.message.includes("Rate Limit")) {
  1250. console.warn(dlog("获取信息速度太快,触发P站速度限制,1分钟后自动重试。"),jo);
  1251. setTimeout(()=>{
  1252. xhrGenneral(url, onload_suceess_Cb, onload_hasError_Cb, onload_notJson_Cb, onerror_Cb);
  1253. }, 1000 * 60)
  1254. return;
  1255. }else
  1256. {
  1257. onload_hasError_Cb(jo);
  1258. return;
  1259. }
  1260. } else { //登录成功
  1261. //console.info("JSON返回成功",jo);
  1262. onload_suceess_Cb(jo);
  1263. return;
  1264. }
  1265. }
  1266. },
  1267. onerror: function(response) {
  1268. console.error(dlog("错误:网络请求发送失败"), response);
  1269. onerror_Cb(response);
  1270. }
  1271. });
  1272. }
  1273. //用id来获取动画帧数据
  1274. function getUgoiraMeta(iid, onload_suceess_Cb, onload_hasError_Cb, onload_notJson_Cb, onerror_Cb)
  1275. {
  1276. xhrGenneral(
  1277. "https://app-api.pixiv.net/v1/ugoira/metadata?illust_id=" + iid,
  1278. onload_suceess_Cb,
  1279. onload_hasError_Cb,
  1280. onload_notJson_Cb,
  1281. onerror_Cb
  1282. );
  1283. }
  1284. //为了区分设置窗口和保存的设置,产生一个新的下载方案数组
  1285. function NewDownSchemeArrayFromJson(jsonarr) {
  1286. if (typeof(jsonarr) == "string") {
  1287. try {
  1288. jsonarr = JSON.parse(jsonarr);
  1289. } catch (e) {
  1290. console.error("PUBD:拷贝新下载方案数组时失败(是字符串,但不是JSON)", e);
  1291. return false;
  1292. }
  1293. }
  1294. let sarr = [];
  1295. if (Array.isArray(jsonarr)) {
  1296. sarr = jsonarr.map(json=>{
  1297. let scheme = new DownScheme();
  1298. scheme.loadFromJson(json);
  1299. return scheme;
  1300. });
  1301. }
  1302. return sarr;
  1303. }
  1304. //获取URL参数
  1305. function getQueryString(name, url = document.location) {
  1306. const urlObj = new URL(url);
  1307. return urlObj.searchParams.get(name);
  1308. }
  1309. //从图片URL获取图片属性
  1310. function parseIllustUrl(url) {
  1311. let src
  1312. try {
  1313. src = new URL(url);
  1314. } catch (error) {
  1315. return null;
  1316. }
  1317. const obj = {
  1318. domain: src.host, //为了兼容老的
  1319. parsedURL: { //目前用到的不多,只保留这两个值
  1320. host: src.host, //域(即主机名)后跟端口
  1321. protocol: src.protocol, //URL 协议名
  1322. }
  1323. };
  1324. const parsedURL = obj.parsedURL;
  1325. let regRes = new RegExp(illustPathRegExp.source, illustPathRegExp.flags).exec(src.pathname);
  1326. if (regRes)
  1327. {
  1328. //为了兼容老的
  1329. obj.url_without_page = `${src.origin}${regRes[1]}`;
  1330. obj.filename = regRes[2];
  1331. //id直接在原始数据有
  1332. obj.token = regRes[4];
  1333. obj.extention = regRes[5];
  1334.  
  1335. parsedURL.path_before_page = regRes[1];
  1336. parsedURL.filename = regRes[2];
  1337. parsedURL.id = regRes[3];
  1338. parsedURL.token = regRes[4];
  1339. parsedURL.extention = regRes[5];
  1340. }else if (regRes = new RegExp(limitingPathRegExp.source, limitingPathRegExp.flags).exec(src.pathname)) //上锁图片
  1341. {
  1342. //为了兼容老的
  1343. obj.url_without_page = `${src.origin}${regRes[1]}`;
  1344. obj.filename = regRes[2];
  1345. //id直接在原始数据有
  1346. obj.extention = regRes[3];
  1347.  
  1348. parsedURL.path_before_page = regRes[1];
  1349. parsedURL.limited = true;
  1350. parsedURL.filename = regRes[2];
  1351. parsedURL.extention = regRes[3];
  1352. }else
  1353. {
  1354. parsedURL.unknown = true;
  1355. }
  1356. return obj;
  1357. }
  1358. //从一个作品数据得到原始图片的下载地址
  1359. function getIllustDownUrl(scheme, userInfo, illust, page)
  1360. {
  1361. return showMask(scheme.downloadurl, scheme.masklist, userInfo, illust, page);
  1362. //return `${illust.parsedURL.protocol}//${illust.parsedURL.host}${illust.parsedURL.path_before_page}${page}.${illust.extention}`;
  1363. }
  1364.  
  1365. //获取当前用户ID
  1366. function getCurrentUserId()
  1367. {
  1368. //从URL获取作者ID
  1369. function getUserIdFromUrl(url) {
  1370. let userid = parseInt(getQueryString("id",url),10); //老地址:https://www.pixiv.net/member_illust.php?id=3896348
  1371. if (!userid)
  1372. {
  1373. const regSrc = new RegExp("users/(\\d+)", "ig"); //新地址:https://www.pixiv.net/users/3896348
  1374. const regRes = regSrc.exec(url.pathname);
  1375. if (regRes) {
  1376. return parseInt(regRes[1],10);
  1377. }
  1378. }
  1379. return userid;
  1380. }
  1381. let userid = getUserIdFromUrl(document.location);
  1382. if(!userid)
  1383. {
  1384. userid = thisPageUserid;
  1385. if (mainDiv)
  1386. {
  1387. const userMainPageLink = mainDiv.querySelector(userMainPageCssPath); //作者主页的“主页”按钮
  1388. //var artWorkLink = mainDiv.querySelector(artWorkStarCssPath);
  1389. const userHeadLink = mainDiv.querySelector(artWorkUserHeadCssPath);
  1390. if (userMainPageLink) //如果是作者页面
  1391. {
  1392. userid = getUserIdFromUrl(userMainPageLink);
  1393. }
  1394. if (userHeadLink) //如果是作品页面
  1395. {
  1396. userid = getUserIdFromUrl(userHeadLink);
  1397. }
  1398. if(pubd.touch)
  1399. {
  1400. const touch_userHeadLink = mainDiv.querySelector('.user-details-card .user-details-icon'); //如果是作品页面
  1401. if (touch_userHeadLink) //如果是作品页面
  1402. {
  1403. userid = getUserIdFromUrl(touch_userHeadLink);
  1404. }
  1405. }
  1406. }
  1407. }
  1408. return userid;
  1409. }
  1410. //检查并快速添加画师收藏的函数
  1411. function toggleStar(userid)
  1412. {
  1413. userid = userid || getCurrentUserId();
  1414. const res = pubd.fastStarList.toggle(userid);
  1415. if (res)
  1416. { //添加
  1417. pubd.start.star.classList.add("stars");
  1418. }else
  1419. { //删除
  1420. pubd.start.star.classList.remove("stars");
  1421. }
  1422.  
  1423. GM_setValue("pubd-faststar-list",pubd.fastStarList.exportArray());
  1424. }
  1425. //检查是否有画师并改变星星状态
  1426. function checkStar()
  1427. {
  1428. const userid = getCurrentUserId();
  1429. const res = pubd.fastStarList.has(userid);
  1430. if (res)
  1431. { //存在,则标记
  1432. pubd.start.star.classList.add("stars");
  1433. return true;
  1434. }else
  1435. { //不存在,则去掉标记
  1436. pubd.start.star.classList.remove("stars");
  1437. return false;
  1438. }
  1439. }
  1440. //更改推荐列表里的收藏显示状态
  1441. function refreshRecommendListState() {
  1442. if (!recommendList) return;
  1443. const liNodes = recommendList.getElementsByTagName("li");
  1444. for (const liNode of liNodes) {
  1445. const imgLink = liNode.querySelector(":scope a[data-gtm-user-id]");
  1446. const uid = parseInt(imgLink.dataset.gtmUserId, 10); //得到这个作品的作者ID
  1447. liNode.classList.toggle("pubd-stared", pubd.fastStarList.has(uid));
  1448. }
  1449. }
  1450. //构建开始按钮
  1451. function buildbtnStart() {
  1452. const btnStart = document.createElement("div");
  1453. btnStart.id = "pubd-start";
  1454. btnStart.className = "pubd-start";
  1455. //添加图标
  1456. const star = btnStart.star = btnStart.appendChild(document.createElement("i"));
  1457. star.className = "pubd-icon star";
  1458. star.title = "快速收藏当前画师(开发中功能,目前没用)";
  1459. //添加文字
  1460. const caption = btnStart.caption = btnStart.appendChild(document.createElement("div"));
  1461. caption.className = "text";
  1462. caption.innerHTML = "使用PUBD扒图";
  1463. caption.title = "快速下载当前画师";
  1464. //添加文字
  1465. const menu = btnStart.menu = btnStart.appendChild(document.createElement("i"));
  1466. menu.className = "pubd-icon menu";
  1467. menu.title = "PUBD菜单";
  1468.  
  1469. //鼠标移入和按下都起作用
  1470. //btnStart.addEventListener("mouseenter",function(){pubd.menu.show()});
  1471. star.onclick = function(){toggleStar();};
  1472. menu.onclick = function(){pubd.menu.classList.toggle("display-none");};
  1473. caption.onclick = function(){pubd.menu.downthis.click();};
  1474. return btnStart;
  1475. }
  1476.  
  1477. //构建开始菜单
  1478. function buildbtnMenu() {
  1479. /*
  1480. var menu2 = new pubdMenu();
  1481. menu2.add("子菜单1","",function(){alert("子菜单1")});
  1482. menu2.add("子菜单2","",function(){alert("子菜单2")});
  1483. var menu1 = new pubdMenu();
  1484. menu1.add("子菜单1","",function(){alert("子菜单1")});
  1485. menu1.add("子菜单2","",null,menu2);
  1486. var menu3 = new pubdMenu();
  1487. menu3.add("子菜单1","",function(){alert("子菜单1")});
  1488. menu3.add("子菜单2","",function(){alert("子菜单2")});
  1489. menu3.add("子菜单2","",function(){alert("子菜单3")});
  1490. menu3.add("子菜单2","",function(){alert("子菜单4")});
  1491. var menu4 = new pubdMenu();
  1492. menu4.add("子菜单1","",null,menu3);
  1493. menu4.add("子菜单2","",function(){alert("子菜单2")});
  1494. menu4.add("子菜单2","",function(){alert("子菜单5")});
  1495. menu4.add("子菜单2","",function(){alert("子菜单6")});
  1496. */
  1497. var menu = new pubdMenu("pubd-menu-main");
  1498. menu.id = "pubd-menu";
  1499. menu.downillust = menu.add("下载当前作品", "pubd-menu-this-illust", function(e) {
  1500. pubd.dialog.downillust.show(
  1501. (document.body.clientWidth - 500)/2,
  1502. window.scrollY+150,
  1503. {id:getQueryString('illust_id',
  1504. pubd.touch ?
  1505. mainDiv.querySelector('.illust-details-content .work-stats>a') : //手机版
  1506. mainDiv.querySelector(artWorkStarCssPath) //新版Vue结构
  1507. )}
  1508. );
  1509. menu.hide();
  1510. });
  1511. menu.downthis = menu.add("下载该画师所有作品", "pubd-menu-this-user", function(e) {
  1512. pubd.dialog.downthis.show(
  1513. (document.body.clientWidth - 440)/2,
  1514. window.scrollY+100,
  1515. {id:getCurrentUserId()}
  1516. );
  1517. menu.hide();
  1518. });
  1519. /*
  1520. menu.add("占位用","",null,menu1);
  1521. menu.add("没功能","",null,menu4);
  1522. menu.add("多个画师下载",null,function()
  1523. {//做成“声音”的设备样子
  1524. alert("这个功能也没有开发")
  1525. }
  1526. );
  1527. */
  1528. menu.add(0);
  1529. if (mdev) menu.downmult = menu.add("多画师下载", "pubd-menu-multiple", function(e) {
  1530. pubd.dialog.multiple.show(
  1531. (document.body.clientWidth - 440)/2,
  1532. window.scrollY+100
  1533. );
  1534. menu.hide();
  1535. });
  1536. menu.add("选项", "pubd-menu-setting", function(e) {
  1537. pubd.dialog.config.show(
  1538. (document.body.clientWidth - 400)/2,
  1539. window.scrollY+50
  1540. );
  1541. menu.hide();
  1542. });
  1543. return menu;
  1544. }
  1545.  
  1546. //构建Token剩余时间进度条
  1547. function buildProgressToken()
  1548. {
  1549. const progress = new Progress("pubd-token-expires", true);
  1550. progress.animateHook = null; //储存Token进度条动画句柄
  1551. progress.token_animate = function(){
  1552. const _this = progress;
  1553. if (!pubd.oAuth.auth_data)
  1554. {
  1555. _this.set(0, 2, "尚未登录");
  1556. clearInterval(_this.animateHook);
  1557. return;
  1558. }
  1559. const nowdate = new Date();
  1560. const olddate = new Date(pubd.oAuth.login_time);
  1561. const expires_in = parseInt(pubd.oAuth.auth_data.expires_in);
  1562. const differ = expires_in - (nowdate - olddate) / 1000;
  1563. if (differ > 0) {
  1564. const scale = differ / expires_in;
  1565. _this.set(scale, 2, "Token有效剩余 " + parseInt(differ) + " 秒");
  1566. } else {
  1567. _this.set(0, 2, "Token已失效,请刷新");
  1568. clearInterval(_this.animateHook);
  1569. }
  1570. //console.log("Token有效剩余" + differ + "秒"); //检测动画后台是否停止
  1571. }
  1572. //开始动画
  1573. progress.start_token_animate = function(){
  1574. const _this = progress;
  1575. _this.stop_token_animate();
  1576. requestAnimationFrame(_this.token_animate);
  1577. _this.animateHook = setInterval(()=>requestAnimationFrame(_this.token_animate), 1000);
  1578. };
  1579. //停止动画
  1580. progress.stop_token_animate = function(){
  1581. const _this = progress;
  1582. clearInterval(_this.animateHook);
  1583. };
  1584. return progress;
  1585. }
  1586.  
  1587. //构建设置对话框
  1588. function buildDlgConfig() {
  1589. const dlg = new Dialog("PUBD选项 v" + scriptVersion, "pubd-config", "pubd-config");
  1590. dlg.cptBtns.add("反馈", "dlg-btn-debug", "https://github.com/Mapaler/PixivUserBatchDownload/issues");
  1591. dlg.cptBtns.add("?", "dlg-btn-help", "https://github.com/Mapaler/PixivUserBatchDownload/wiki");
  1592. dlg.token_ani = null; //储存Token进度条动画句柄
  1593.  
  1594. var dl = dlg.content.appendChild(document.createElement("dl"));
  1595.  
  1596. var dt = dl.appendChild(document.createElement("dt"));
  1597.  
  1598. var dd = dl.appendChild(document.createElement("dd"));
  1599.  
  1600. dlg.frmLogin = dd.appendChild(new Frame("Pixiv访问权限", "pubd-token"));
  1601.  
  1602. var dl_t = dlg.frmLogin.content.appendChild(document.createElement("dl"));
  1603.  
  1604. var dd_t = dl_t.appendChild(document.createElement("dd"));
  1605.  
  1606. var ul_t = dd_t.appendChild(document.createElement("ul"));
  1607. ul_t.className = "horizontal-list";
  1608. var li_t = ul_t.appendChild(document.createElement("li"));
  1609. const userAvatar = li_t.appendChild(document.createElement("div"));
  1610. userAvatar.className = "user-avatar";
  1611. userAvatar.img = userAvatar.appendChild(document.createElement("img"));
  1612. userAvatar.img.className = "avatar-img";
  1613.  
  1614. var li_t = ul_t.appendChild(document.createElement("li"));
  1615. const userName = li_t.appendChild(document.createElement("div"));
  1616. userName.className = "user-name";
  1617. const userAccount = li_t.appendChild(document.createElement("div"));
  1618. userAccount.className = "user-account";
  1619.  
  1620. var li_t = ul_t.appendChild(document.createElement("li"));
  1621. //登录/退出
  1622. const btnLogin = li_t.appendChild(document.createElement("button"));
  1623. btnLogin.className = "pubd-tologin";
  1624. btnLogin.onclick = function(){
  1625. if (dlg.frmLogin.classList.contains("logged-in"))
  1626. {
  1627. //退出
  1628. pubd.oAuth = new oAuth2();
  1629. pubd.oAuth.save();
  1630.  
  1631. dlg.refreshLoginState();
  1632. }else
  1633. {
  1634. //登录
  1635. pubd.dialog.login.show(
  1636. (document.body.clientWidth - 370)/2,
  1637. window.scrollY+200
  1638. );
  1639. }
  1640. }
  1641.  
  1642. const tokenInfo = dlg.tokenInfo = dl_t.appendChild(document.createElement("dd"));
  1643. tokenInfo.className = "pubd-token-info";
  1644.  
  1645. const progress = dlg.tokenExpires = tokenInfo.appendChild(buildProgressToken());
  1646.  
  1647. const btnRefresh = tokenInfo.appendChild(document.createElement("button"));
  1648. btnRefresh.className = "pubd-open-refresh-token";
  1649. btnRefresh.appendChild(document.createTextNode("刷新许可"));
  1650. btnRefresh.onclick = function() {
  1651. //刷新许可
  1652. pubd.dialog.refresh_token.show(
  1653. (document.body.clientWidth - 370)/2,
  1654. window.scrollY+300
  1655. );
  1656. };
  1657.  
  1658. dlg.refreshLoginState = function() {
  1659. if (!pubd.oAuth) return;
  1660. const auth_data = pubd.oAuth.auth_data;
  1661. if (auth_data)
  1662. {
  1663. userAvatar.img.src = auth_data.user.profile_image_urls.px_50x50;
  1664. userAvatar.img.alt = userAvatar.title = auth_data.user.name;
  1665. userName.textContent = auth_data.user.name;
  1666. userAccount.textContent = auth_data.user.account;
  1667. btnLogin.textContent = "退出";
  1668. progress.start_token_animate();
  1669. btnRefresh.disabled = false;
  1670. dlg.frmLogin.classList.add("logged-in");
  1671. }else
  1672. {
  1673. userAvatar.img.src = "";
  1674. userAvatar.img.alt = userAvatar.title = "";
  1675. userName.textContent = "未登录";
  1676. userAccount.textContent = "Not logged in";
  1677. btnLogin.textContent = "登录";
  1678. progress.token_animate();
  1679. progress.stop_token_animate();
  1680. btnRefresh.disabled = true;
  1681. dlg.frmLogin.classList.remove("logged-in");
  1682. }
  1683. }
  1684.  
  1685. //“通用分析选项”窗口选项
  1686. var dt = document.createElement("dt");
  1687. dl.appendChild(dt);
  1688. var dd = document.createElement("dd");
  1689.  
  1690. var frm = new Frame("通用分析选项", "pubd-commonanalyseoptions");
  1691. var chk_getugoiraframe = new LabelInput("获取动图帧数", "pubd-getugoiraframe", "pubd-getugoiraframe", "checkbox", "1", true);
  1692. dlg.getugoiraframe = chk_getugoiraframe.input;
  1693.  
  1694. frm.content.appendChild(chk_getugoiraframe);
  1695. dd.appendChild(frm);
  1696. dl.appendChild(dd);
  1697.  
  1698. //“下载该画师”窗口选项
  1699. var dt = document.createElement("dt");
  1700. dl.appendChild(dt);
  1701. var dd = document.createElement("dd");
  1702.  
  1703. var frm = new Frame("下载窗口", "pubd-frm-downthis");
  1704. var chk_autoanalyse = new LabelInput("打开窗口自动获取数据", "pubd-autoanalyse", "pubd-autoanalyse", "checkbox", "1", true);
  1705. dlg.autoanalyse = chk_autoanalyse.input;
  1706. var chk_autodownload = new LabelInput("获取完成自动发送下载", "pubd-autodownload", "pubd-autodownload", "checkbox", "1", true);
  1707. dlg.autodownload = chk_autodownload.input;
  1708.  
  1709. frm.content.appendChild(chk_autoanalyse);
  1710. frm.content.appendChild(chk_autodownload);
  1711. dd.appendChild(frm);
  1712. dl.appendChild(dd);
  1713.  
  1714. //向Aria2的发送模式
  1715. var dt = dl.appendChild(document.createElement("dt"));
  1716. var dd = dl.appendChild(document.createElement("dd"));
  1717.  
  1718. var frm = dd.appendChild(new Frame("向Aria2逐项发送模式", "pubd-frm-termwisetype"));
  1719. var radio0 = frm.content.appendChild(new LabelInput("完全逐项(按图片)", "pubd-termwisetype", "pubd-termwisetype", "radio", "0", true));
  1720. var radio1 = frm.content.appendChild(new LabelInput("半逐项(按作品)", "pubd-termwisetype", "pubd-termwisetype", "radio", "1", true));
  1721. var radio2 = frm.content.appendChild(new LabelInput("不逐项(按作者)", "pubd-termwisetype", "pubd-termwisetype", "radio", "2", true));
  1722. dlg.termwiseType = [radio0.input, radio1.input, radio2.input];
  1723.  
  1724. //“发送完成后,点击通知”窗口选项
  1725. var dt = dl.appendChild(document.createElement("dt"));
  1726. var dd = dl.appendChild(document.createElement("dd"));
  1727.  
  1728. var frm = dd.appendChild(new Frame("发送完成通知", "pubd-frm-clicknotification"));
  1729. var radio0 = frm.content.appendChild(new LabelInput("点击通知什么也不做", "pubd-clicknotification", "pubd-clicknotification", "radio", "0", true));
  1730. var radio1 = frm.content.appendChild(new LabelInput("点击通知激活该窗口", "pubd-clicknotification", "pubd-clicknotification", "radio", "1", true));
  1731. var radio2 = frm.content.appendChild(new LabelInput("点击通知关闭该窗口", "pubd-clicknotification", "pubd-clicknotification", "radio", "2", true));
  1732. var radio3 = frm.content.appendChild(new LabelInput("通知自动消失关闭该窗口", "pubd-clicknotification", "pubd-clicknotification", "radio", "3", true));
  1733. dlg.noticeType = [radio0.input, radio1.input, radio2.input, radio3.input];
  1734.  
  1735. //配置方案储存
  1736. dlg.schemes = null;
  1737. dlg.reloadSchemes = function() { //重新读取所有下载方案
  1738. if (dlg.schemes.length < 1) {
  1739. alert("目前本程序没有任何下载方案,需要正常使用请先新建方案。");
  1740. }
  1741. dlg.downSchemeDom.options.length = 0;
  1742. dlg.schemes.forEach(function(item, index) {
  1743. dlg.downSchemeDom.add(item.name, index);
  1744. });
  1745. if (dlg.downSchemeDom.options.length > 0)
  1746. dlg.selectScheme(0);
  1747. };
  1748. dlg.loadScheme = function(scheme) { //读取一个下载方案
  1749. if (scheme == undefined) {
  1750. dlg.rpcurl.value = "";
  1751. dlg.proxyurl.value = "";
  1752. dlg.downloadurl.value = "";
  1753. dlg.downfilter.value = "";
  1754. dlg.savedir.value = "";
  1755. dlg.savepath.value = "";
  1756. dlg.textout.value = "";
  1757. dlg.loadMasklistFromArray([]);
  1758. } else {
  1759. dlg.rpcurl.value = scheme.rpcurl;
  1760. dlg.proxyurl.value = scheme.proxyurl;
  1761. dlg.downloadurl.value = scheme.downloadurl;
  1762. dlg.downfilter.value = scheme.downfilter;
  1763. dlg.savedir.value = scheme.savedir;
  1764. dlg.savepath.value = scheme.savepath;
  1765. dlg.textout.value = scheme.textout;
  1766. dlg.loadMasklistFromArray(scheme.masklist);
  1767. }
  1768. };
  1769. dlg.addMask = function(name, logic, content, value) { //向掩码列表添加一个新的掩码
  1770. if (value == undefined)
  1771. value = dlg.masklist.options.length;
  1772. var text = name + " : " + logic + " : " + content;
  1773. var opt = new Option(text, value);
  1774. dlg.masklist.options.add(opt);
  1775. };
  1776. dlg.loadMask = function(mask) { //读取一个掩码到三个文本框,只是用来查看
  1777. dlg.mask_name.value = mask.name;
  1778. dlg.mask_logic.value = mask.logic;
  1779. dlg.mask_content.value = mask.content;
  1780. };
  1781. dlg.loadMasklistFromArray = function(masklist) { //从掩码数组重置掩码列表
  1782. dlg.masklist.length = 0;
  1783. masklist.forEach(function(item, index) {
  1784. dlg.addMask(item.name, item.logic, item.content, index);
  1785. });
  1786. };
  1787. //选择一个方案,同时读取设置
  1788. dlg.selectScheme = function(index) {
  1789. if (index == undefined) index = 0;
  1790. if (dlg.downSchemeDom.options.length < 1 || dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1791. var scheme = dlg.schemes[index];
  1792. dlg.loadScheme(scheme);
  1793. dlg.downSchemeDom.selectedIndex = index;
  1794. };
  1795. //选择一个掩码,同时读取设置
  1796. dlg.selectMask = function(index) {
  1797. if (dlg.downSchemeDom.options.length < 1 || dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1798. if (dlg.masklist.options.length < 1 || dlg.masklist.selectedOptions.length < 1) { return; }
  1799. var scheme = dlg.schemes[dlg.downSchemeDom.selectedIndex];
  1800. var mask = scheme.masklist[index];
  1801. dlg.loadMask(mask);
  1802. dlg.masklist.selectedIndex = index;
  1803. };
  1804.  
  1805. //配置方案选择
  1806. var dt = dl.appendChild(document.createElement("dt"));
  1807. dt.textContent = "默认下载方案";
  1808. var dd = dl.appendChild(document.createElement("dd"));
  1809. var slt = dlg.downSchemeDom = dd.appendChild(new Select("pubd-downscheme"));
  1810. slt.onchange = function() {
  1811. dlg.selectScheme(this.selectedIndex);
  1812. };
  1813.  
  1814. var ipt = dd.appendChild(document.createElement("input"));
  1815. ipt.type = "button";
  1816. ipt.className = "pubd-downscheme-new";
  1817. ipt.value = "新建";
  1818. ipt.onclick = function() {
  1819. var schemName = prompt("请输入方案名", "我的方案");
  1820. if (schemName)
  1821. {
  1822. var scheme = new DownScheme(schemName);
  1823. var length = dlg.schemes.push(scheme);
  1824. dlg.downSchemeDom.add(scheme.name, length - 1);
  1825. dlg.downSchemeDom.selectedIndex = length - 1;
  1826. dlg.loadScheme(scheme);
  1827. //dlg.reloadSchemes();
  1828. }
  1829. };
  1830.  
  1831. var ipt = dd.appendChild(document.createElement("input"));
  1832. ipt.type = "button";
  1833. ipt.className = "pubd-downscheme-remove";
  1834. ipt.value = "删除";
  1835. ipt.onclick = function() {
  1836. if (dlg.downSchemeDom.options.length < 1) { alert("已经没有方案了"); return; }
  1837. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  1838. var index = dlg.downSchemeDom.selectedIndex;
  1839. var c = confirm("你确定要删除“" + dlg.schemes[index].name + "”方案吗?");
  1840. if (c)
  1841. {
  1842. var x = dlg.schemes.splice(index, 1);
  1843. x = null;
  1844. dlg.downSchemeDom.remove(index);
  1845. var index = dlg.downSchemeDom.selectedIndex;
  1846. if (index < 0) dlg.reloadSchemes(); //没有选中的,重置
  1847. else dlg.loadScheme(dlg.schemes[index]);
  1848. }
  1849. };
  1850.  
  1851. //配置方案详情设置
  1852. var dt = dl.appendChild(document.createElement("dt"));
  1853. var dd = dl.appendChild(document.createElement("dd"));
  1854. dd.className = "pubd-selectscheme-bar";
  1855.  
  1856. var frm = dd.appendChild(new Frame("当前方案设置", "pubd-selectscheme"));
  1857.  
  1858. var dl_ss = frm.content.appendChild(document.createElement("dl"));
  1859.  
  1860.  
  1861. //Aria2 URL
  1862.  
  1863. var dt = dl_ss.appendChild(document.createElement("dt"));
  1864. dt.textContent = "Aria2 JSON-RPC 路径";
  1865. var rpcchk = dlg.rpcchk = dt.appendChild(document.createElement("span")); //显示检查状态用
  1866. rpcchk.className = "pubd-rpcchk-info";
  1867. rpcchk.runing = false;
  1868. var dd = dl_ss.appendChild(document.createElement("dd"));
  1869. var rpcurl = dlg.rpcurl = dd.appendChild(document.createElement("input"));
  1870. rpcurl.type = "url";
  1871. rpcurl.className = "pubd-rpcurl";
  1872. rpcurl.name = "pubd-rpcurl";
  1873. rpcurl.id = rpcurl.name;
  1874. rpcurl.placeholder = "Aria2的信息接收路径";
  1875. rpcurl.onchange = function() {
  1876. dlg.rpcchk.innerHTML = "";
  1877. dlg.rpcchk.runing = false;
  1878. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1879. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  1880. dlg.schemes[schemeIndex].rpcurl = rpcurl.value;
  1881. };
  1882.  
  1883. var ipt = dd.appendChild(document.createElement("input"));
  1884. ipt.type = "button";
  1885. ipt.className = "pubd-rpcchk";
  1886. ipt.value = "检查路径";
  1887. ipt.onclick = function() {
  1888. if (rpcchk.runing) return;
  1889. if (rpcurl.value.length < 1) {
  1890. rpcchk.textContent = "路径为空";
  1891. return;
  1892. }
  1893. rpcchk.textContent = "正在连接...";
  1894. rpcchk.runing = true;
  1895. var aria2 = new Aria2(rpcurl.value);
  1896. aria2.getVersion(function(rejo) {
  1897. if (rejo)
  1898. rpcchk.textContent = "发现Aria2 ver" + rejo.result.version;
  1899. else
  1900. rpcchk.textContent = "Aria2连接失败";
  1901. rpcchk.runing = false;
  1902. });
  1903. };
  1904. var dt = dl_ss.appendChild(document.createElement("dt"));
  1905. dt.textContent = "Aria2 代理服务器地址";
  1906. var dta = dt.appendChild(document.createElement("a"));
  1907. dta.className = "pubd-help-link";
  1908. dta.textContent = "(?)";
  1909. dta.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/Aria2%e9%80%9a%e8%bf%87%e4%bb%a3%e7%90%86%e4%b8%8b%e8%bd%bd";
  1910. dta.target = "_blank";
  1911. var dd = dl_ss.appendChild(document.createElement("dd"));
  1912. var proxyurl = dlg.proxyurl = dd.appendChild(document.createElement("input"));
  1913. proxyurl.type = "text";
  1914. proxyurl.className = "pubd-proxyurl";
  1915. proxyurl.name = "pubd-proxyurl";
  1916. proxyurl.id = proxyurl.name;
  1917. proxyurl.placeholder = "[http://][USER:PASSWORD@]HOST[:PORT]";
  1918. proxyurl.onchange = function() {
  1919. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1920. const schemeIndex = dlg.downSchemeDom.selectedIndex;
  1921. dlg.schemes[schemeIndex].proxyurl = this.value;
  1922. };
  1923.  
  1924. var dt = dl_ss.appendChild(document.createElement("dt"));
  1925. dt.textContent = "作品下载地址";
  1926. var dd = dl_ss.appendChild(document.createElement("dd"));
  1927. var downloadurl = dlg.downloadurl = dd.appendChild(document.createElement("input"));
  1928. downloadurl.type = "text";
  1929. downloadurl.className = "pubd-downloadurl";
  1930. downloadurl.name = "pubd-downloadurl";
  1931. downloadurl.readOnly = true;
  1932. downloadurl.id = downloadurl.name;
  1933. downloadurl.onclick = function() {
  1934. if (this.readOnly)
  1935. {
  1936. if (confirm("警告!\n修改下载地址可能导致无法下载图片,您确定要修改吗?\n\n若确需修改,建议先在文本输出模式测试。"))
  1937. {
  1938. this.readOnly = false;
  1939. }
  1940. }
  1941. };
  1942. downloadurl.onchange = function() {
  1943. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1944. const schemeIndex = dlg.downSchemeDom.selectedIndex;
  1945. dlg.schemes[schemeIndex].downloadurl = this.value;
  1946. };
  1947.  
  1948. //下载过滤
  1949. var dt = dl_ss.appendChild(document.createElement("dt"));
  1950. dt.textContent = "下载过滤器";
  1951. var dta = dt.appendChild(document.createElement("a"));
  1952. dta.className = "pubd-help-link";
  1953. dta.textContent = "(?)";
  1954. dta.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/%E4%B8%8B%E8%BD%BD%E8%BF%87%E6%BB%A4%E5%99%A8";
  1955. dta.target = "_blank";
  1956. var dd = document.createElement("dd");
  1957. var downfilter = document.createElement("input");
  1958. downfilter.type = "text";
  1959. downfilter.className = "pubd-downfilter";
  1960. downfilter.name = "pubd-downfilter";
  1961. downfilter.id = downfilter.name;
  1962. downfilter.placeholder = "符合条件的图片将不会被发送到Aria2";
  1963. downfilter.onchange = function() {
  1964. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1965. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  1966. dlg.schemes[schemeIndex].downfilter = downfilter.value;
  1967. };
  1968. dlg.downfilter = downfilter;
  1969. dd.appendChild(downfilter);
  1970. dl_ss.appendChild(dd);
  1971.  
  1972. //下载目录
  1973. var dt = document.createElement("dt");
  1974. dl_ss.appendChild(dt);
  1975. dt.textContent = "下载目录";
  1976. var dd = document.createElement("dd");
  1977. var savedir = document.createElement("input");
  1978. savedir.type = "text";
  1979. savedir.className = "pubd-savedir";
  1980. savedir.name = "pubd-savedir";
  1981. savedir.id = savedir.name;
  1982. savedir.placeholder = "文件下载到的目录";
  1983. savedir.onchange = function() {
  1984. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  1985. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  1986. dlg.schemes[schemeIndex].savedir = savedir.value;
  1987. };
  1988. dlg.savedir = savedir;
  1989. dd.appendChild(savedir);
  1990. dl_ss.appendChild(dd);
  1991.  
  1992. //保存路径
  1993. var dt = dl_ss.appendChild(document.createElement("dt"));
  1994. dt.textContent = "保存路径";
  1995. var dta = dt.appendChild(document.createElement("a"));
  1996. dta.className = "pubd-help-link";
  1997. dta.textContent = "(?)";
  1998. dta.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/%E6%8E%A9%E7%A0%81";
  1999. dta.target = "_blank";
  2000. var dd = document.createElement("dd");
  2001. var savepath = document.createElement("input");
  2002. savepath.type = "text";
  2003. savepath.className = "pubd-savepath";
  2004. savepath.name = "pubd-savepath";
  2005. savepath.id = savepath.name;
  2006. savepath.placeholder = "分组保存的文件夹和文件名";
  2007. savepath.onchange = function() {
  2008. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  2009. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  2010. dlg.schemes[schemeIndex].savepath = savepath.value;
  2011. };
  2012. dlg.savepath = savepath;
  2013. dd.appendChild(savepath);
  2014. dl_ss.appendChild(dd);
  2015.  
  2016. //输出文本
  2017. var dt = dl_ss.appendChild(document.createElement("dt"));
  2018. dt.textContent = "文本输出模式格式";
  2019. var dta = dt.appendChild(document.createElement("a"));
  2020. dta.className = "pubd-help-link";
  2021. dta.textContent = "(?)";
  2022. dta.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/%e9%80%89%e9%a1%b9%e7%aa%97%e5%8f%a3#%E6%96%87%E6%9C%AC%E8%BE%93%E5%87%BA%E6%A8%A1%E5%BC%8F%E6%A0%BC%E5%BC%8F";
  2023. dta.target = "_blank";
  2024. var dd = document.createElement("dd");
  2025. dd.className = "pubd-textout-bar";
  2026. var textout = document.createElement("textarea");
  2027. textout.className = "pubd-textout";
  2028. textout.name = "pubd-textout";
  2029. textout.id = textout.name;
  2030. textout.placeholder = "直接输出文本信息时的格式";
  2031. textout.wrap = "off";
  2032. textout.onchange = function() {
  2033. if (dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  2034. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  2035. dlg.schemes[schemeIndex].textout = textout.value;
  2036. };
  2037. dlg.textout = textout;
  2038. dd.appendChild(textout);
  2039. dl_ss.appendChild(dd);
  2040.  
  2041.  
  2042. //自定义掩码
  2043. var dt = dl_ss.appendChild(document.createElement("dt"));
  2044. dt.textContent = "自定义掩码";
  2045. var dta = dt.appendChild(document.createElement("a"));
  2046. dta.className = "pubd-help-link";
  2047. dta.textContent = "(?)";
  2048. dta.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/%E8%87%AA%E5%AE%9A%E4%B9%89%E6%8E%A9%E7%A0%81";
  2049. dta.target = "_blank";
  2050. var dd = document.createElement("dd");
  2051. dl_ss.appendChild(dd);
  2052. //▼掩码名
  2053. var ipt = document.createElement("input");
  2054. ipt.type = "text";
  2055. ipt.className = "pubd-mask-name";
  2056. ipt.name = "pubd-mask-name";
  2057. ipt.id = ipt.name;
  2058. ipt.placeholder = "自定义掩码名";
  2059. dlg.mask_name = ipt;
  2060. dd.appendChild(ipt);
  2061. //▲掩码名
  2062. //▼执行条件
  2063. var ipt = document.createElement("input");
  2064. ipt.type = "text";
  2065. ipt.className = "pubd-mask-logic";
  2066. ipt.name = "pubd-mask-logic";
  2067. ipt.id = ipt.name;
  2068. ipt.placeholder = "执行条件";
  2069. dlg.mask_logic = ipt;
  2070. dd.appendChild(ipt);
  2071. //▲执行条件
  2072. var ipt = document.createElement("input");
  2073. ipt.type = "button";
  2074. ipt.className = "pubd-mask-add";
  2075. ipt.value = "+";
  2076. ipt.onclick = function() { //增加自定义掩码
  2077. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中下载方案"); return; }
  2078. if (dlg.mask_name.value.length < 1) { alert("掩码名称为空"); return; }
  2079. if (dlg.mask_logic.value.length < 1) { alert("执行条件为空"); return; }
  2080. if (dlg.mask_content.value.includes("%{" + dlg.mask_logic.value + "}")) { alert("该掩码调用自身,会形成死循环。"); return; }
  2081. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  2082. dlg.schemes[schemeIndex].maskAdd(dlg.mask_name.value, dlg.mask_logic.value, dlg.mask_content.value);
  2083. dlg.addMask(dlg.mask_name.value, dlg.mask_logic.value, dlg.mask_content.value);
  2084. dlg.mask_name.value = dlg.mask_logic.value = dlg.mask_content.value = "";
  2085. };
  2086. dd.appendChild(ipt);
  2087. var mask_remove = document.createElement("input");
  2088. mask_remove.type = "button";
  2089. mask_remove.className = "pubd-mask-remove";
  2090. mask_remove.value = "-";
  2091. mask_remove.onclick = function() { //删除自定义掩码
  2092. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中下载方案"); return; }
  2093. if (dlg.masklist.options.length < 1) { alert("已经没有掩码了"); return; }
  2094. if (dlg.masklist.selectedOptions.length < 1) { alert("没有选中掩码"); return; }
  2095. var schemeIndex = dlg.downSchemeDom.selectedIndex;
  2096. var maskIndex = dlg.masklist.selectedIndex;
  2097. dlg.schemes[schemeIndex].maskRemove(maskIndex);
  2098. dlg.masklist.remove(maskIndex);
  2099. for (var mi = maskIndex; mi < dlg.masklist.options.length; mi++) {
  2100. dlg.masklist.options[mi].value = mi;
  2101. }
  2102. };
  2103. dd.appendChild(mask_remove);
  2104.  
  2105. //▼掩码内容
  2106. var ipt = document.createElement("input");
  2107. ipt.type = "text";
  2108. ipt.className = "pubd-mask-content";
  2109. ipt.name = "pubd-mask-content";
  2110. ipt.id = ipt.name;
  2111. ipt.placeholder = "掩码内容";
  2112. dlg.mask_content = ipt;
  2113. dd.appendChild(ipt);
  2114. //▲掩码内容
  2115. dl_ss.appendChild(dd);
  2116.  
  2117. //▼掩码列表
  2118. var dd = document.createElement("dd");
  2119. dd.className = "pubd-mask-list-bar";
  2120. var masklist = new Select("pubd-mask-list", "pubd-mask-list");
  2121. masklist.size = 5;
  2122. masklist.onchange = function() { //读取选中的掩码
  2123. dlg.selectMask(this.selectedIndex);
  2124. };
  2125. dlg.masklist = masklist;
  2126. dd.appendChild(masklist);
  2127. //▲掩码列表
  2128. dl_ss.appendChild(dd);
  2129.  
  2130. //保存按钮栏
  2131. var dt = document.createElement("dt");
  2132. dl.appendChild(dt);
  2133. var dd = document.createElement("dd");
  2134. dd.className = "pubd-config-savebar";
  2135. var ipt = document.createElement("input");
  2136. ipt.type = "button";
  2137. ipt.className = "pubd-reset";
  2138. ipt.value = "清空选项";
  2139. ipt.onclick = function() {
  2140. if (confirm("您确定要将PUBD保存的所有设置,以及方案全部删除吗?\n(⚠️不可恢复)")==true){
  2141. dlg.reset();
  2142. return true;
  2143. }else{
  2144. return false;
  2145. }
  2146. };
  2147. dd.appendChild(ipt);
  2148. var ipt = document.createElement("input");
  2149. ipt.type = "button";
  2150. ipt.className = "pubd-save";
  2151. ipt.value = "保存选项";
  2152. ipt.onclick = function() {
  2153. dlg.save();
  2154. };
  2155. dd.appendChild(ipt);
  2156. dl.appendChild(dd);
  2157.  
  2158. //保存设置函数
  2159. dlg.save = function() {
  2160.  
  2161. //作品发送完成后,如何处理通知
  2162. var noticeType = 0;
  2163. dlg.noticeType.some(function(item){
  2164. if (item.checked) noticeType = parseInt(item.value);
  2165. return item.checked;
  2166. });
  2167. //逐项发送模式
  2168. var termwiseType = 2;
  2169. dlg.termwiseType.some(function(item){
  2170. if (item.checked) termwiseType = parseInt(item.value);
  2171. return item.checked;
  2172. });
  2173.  
  2174. GM_setValue("pubd-getugoiraframe", dlg.getugoiraframe.checked); //获取动图帧数
  2175. GM_setValue("pubd-autoanalyse", dlg.autoanalyse.checked); //自动分析
  2176. GM_setValue("pubd-autodownload", dlg.autodownload.checked); //自动下载
  2177. GM_setValue("pubd-noticeType", noticeType); //处理通知
  2178. GM_setValue("pubd-termwiseType", termwiseType); //逐项发送
  2179. GM_setValue("pubd-downschemes", dlg.schemes); //下载方案
  2180. GM_setValue("pubd-defaultscheme", dlg.downSchemeDom.selectedIndex); //默认方案
  2181. GM_setValue("pubd-configversion", pubd.configVersion); //设置版本
  2182.  
  2183. GM_notification({text:"设置已保存", title:scriptName, image:scriptIcon});
  2184. pubd.downSchemes = NewDownSchemeArrayFromJson(dlg.schemes);
  2185. pubd.dialog.downthis.reloadSchemes();
  2186. pubd.dialog.downillust.reloadSchemes();
  2187. };
  2188. //重置设置函数
  2189. dlg.reset = function() {
  2190. GM_deleteValue("pubd-auth"); //登录相关信息
  2191. GM_deleteValue("pubd-getugoiraframe"); //获取动图帧数
  2192. GM_deleteValue("pubd-autoanalyse"); //自动分析
  2193. GM_deleteValue("pubd-autodownload"); //自动下载
  2194. GM_deleteValue("pubd-noticeType"); //处理通知
  2195. GM_deleteValue("pubd-termwiseType"); //逐项发送
  2196. GM_deleteValue("pubd-downschemes"); //下载方案
  2197. GM_deleteValue("pubd-defaultscheme"); //默认方案
  2198. GM_deleteValue("pubd-configversion"); //设置版本
  2199. GM_notification({text:"已清空重置设置", title:scriptName, image:scriptIcon});
  2200. };
  2201. //窗口关闭
  2202. dlg.close = function() {
  2203. progress.stop_token_animate();
  2204. };
  2205. //关闭窗口按钮
  2206. dlg.cptBtns.close.addEventListener("click", dlg.close);
  2207. //窗口初始化
  2208. dlg.initialise = function() {
  2209.  
  2210. dlg.getugoiraframe.checked = getValueDefault("pubd-getugoiraframe", true);
  2211. dlg.autoanalyse.checked = getValueDefault("pubd-autoanalyse", false);
  2212. dlg.autodownload.checked = getValueDefault("pubd-autodownload", false);
  2213. (dlg.noticeType[parseInt(getValueDefault("pubd-noticeType", 0))] || dlg.noticeType[0]).checked = true;
  2214. (dlg.termwiseType[parseInt(getValueDefault("pubd-termwiseType", 2))] || dlg.termwiseType[2]).checked = true;
  2215.  
  2216. dlg.schemes = NewDownSchemeArrayFromJson(pubd.downSchemes);
  2217. dlg.reloadSchemes();
  2218. dlg.selectScheme(getValueDefault("pubd-defaultscheme", 0));
  2219. dlg.refreshLoginState();
  2220. };
  2221. return dlg;
  2222. }
  2223.  
  2224. //构建登录对话框
  2225. function buildDlgLogin() {
  2226. const dlg = new Dialog("登录账户", "pubd-login", "pubd-login");
  2227. dlg.newAuth = null;
  2228.  
  2229. var frm = dlg.content.appendChild(new Frame("1.做好获取 APP 登录连接的准备", "pubd-auth-help"));
  2230. const aHelp = frm.content.appendChild(document.createElement("a"));
  2231. aHelp.appendChild(document.createTextNode("如何获取 APP 登录连接?"));
  2232. aHelp.target = "_blank";
  2233. aHelp.href = "https://github.com/Mapaler/PixivUserBatchDownload/wiki/%E8%8E%B7%E5%8F%96APP%E7%99%BB%E9%99%86%E9%93%BE%E6%8E%A5";
  2234.  
  2235. var frm = dlg.content.appendChild(new Frame("2.进行官方 APP 登录", "pubd-auth-weblogin"));
  2236. const aLogin = frm.content.appendChild(document.createElement("a"));
  2237. aLogin.appendChild(document.createTextNode("访问官方登录页面"));
  2238. aLogin.className = "pubd-login-official-link";
  2239. aLogin.target = "_blank";
  2240.  
  2241. var frm = dlg.content.appendChild(new Frame("3.填写 APP 登录连接", "pubd-auth-applogin"));
  2242. dlg.content.appendChild(frm);
  2243.  
  2244. var div = frm.content.appendChild(document.createElement("div"));
  2245. const pixivLink = div.appendChild(document.createElement("input"));
  2246. pixivLink.type = "url";
  2247. pixivLink.className = "pubd-pixiv-app-link";
  2248. pixivLink.placeholder = "例如:pixiv://account/login?code=xxxxxx&via=login";
  2249.  
  2250. const btnLogin = div.appendChild(document.createElement("button"));
  2251. btnLogin.className = "pubd-login-auth";
  2252. btnLogin.appendChild(document.createTextNode("登录"));
  2253. //登录按钮
  2254. btnLogin.onclick = function() {
  2255. if (/^pixiv:\/\//i.test(pixivLink.value))
  2256. {
  2257. const loginLink = new URL(pixivLink.value);
  2258. const authorization_code = loginLink.searchParams.get("code");
  2259. if (authorization_code)
  2260. {
  2261. //使用token登录
  2262. dlg.error.replace("登录中···");
  2263. const options = {
  2264. onload:function(jore) { //onload_suceess_Cb
  2265. dlg.error.replace("登录成功");
  2266. dlg.newOAuth.save(); //保存新的认证
  2267. pubd.oAuth = dlg.newOAuth; //使用新的认证替换原来的认证
  2268. pubd.dialog.config.refreshLoginState();
  2269. },
  2270. onload_hasError:function(jore) { //onload_haserror_Cb //返回错误消息
  2271. dlg.error.replace(["错误代码:" + jore.errors.system.code, jore.errors.system.message]);
  2272. },
  2273. onload_notJson:function(re) { //onload_notjson_Cb //返回不是JSON
  2274. dlg.error.replace(["服务器返回不是 JSON 格式", re]);
  2275. },
  2276. onerror:function(re) { //onerror_Cb //网络请求发生错误
  2277. dlg.error.replace("网络请求发生错误");
  2278. },
  2279. }
  2280. dlg.newOAuth.login(authorization_code, options);
  2281. }else
  2282. {
  2283. alert("PUBD:登录链接中未找到 code");
  2284. }
  2285. }else
  2286. {
  2287. alert("PUBD:输入的链接格式不正确");
  2288. }
  2289. };
  2290.  
  2291. //错误信息
  2292. dlg.error = dlg.content.appendChild(new ErrorMsg());
  2293.  
  2294. dlg.content.appendChild(document.createElement("hr"));
  2295.  
  2296. var frm = dlg.content.appendChild(new Frame("使用现有刷新许可证登录", "pubd-refresh_token-login"));
  2297. dlg.content.appendChild(frm);
  2298.  
  2299. var div = frm.content.appendChild(document.createElement("div"));
  2300. const iptRefreshToken = div.appendChild(document.createElement("input"));
  2301. iptRefreshToken.type = "text";
  2302. iptRefreshToken.className = "pubd-refresh-token";
  2303. iptRefreshToken.placeholder = "refresh_token";
  2304.  
  2305. const btnRefreshToken = div.appendChild(document.createElement("button"));
  2306. btnRefreshToken.className = "pubd-login-refresh_token";
  2307. btnRefreshToken.appendChild(document.createTextNode("登录"));
  2308. //登录按钮
  2309. btnRefreshToken.onclick = function() {
  2310. if (!pubd.oAuth.auth_data)
  2311. {
  2312. pubd.oAuth.auth_data = {};
  2313. }
  2314. pubd.oAuth.auth_data.refresh_token = iptRefreshToken.value;
  2315. //刷新许可
  2316. pubd.dialog.refresh_token.show(
  2317. (document.body.clientWidth - 370)/2,
  2318. window.scrollY+300
  2319. );
  2320. };
  2321.  
  2322. //窗口初始化
  2323. dlg.initialise = function() {
  2324. this.error.clear();
  2325.  
  2326. //每次打开这个窗口,都创建一个新的认证
  2327. this.newOAuth = new oAuth2();
  2328. aLogin.href = this.newOAuth.get_login_url();
  2329. };
  2330. return dlg;
  2331. }
  2332.  
  2333. //构建token刷新对话框
  2334. function buildDlgRefreshToken() {
  2335. const dlg = new Dialog("刷新许可", "pubd-refresh-token pubd-dialog-transparent", "pubd-refresh-token");
  2336.  
  2337. //Logo部分
  2338. const logo_box = dlg.content.appendChild(document.createElement("div"));
  2339. logo_box.className = "logo-box";
  2340. const logo = logo_box.appendChild(document.createElement("img"));
  2341. logo.className = "pixiv-logo";
  2342. logo.src = "https://s.pximg.net/accounts/assets/6bea8becc71d27cd20649ffbc047e456.svg";
  2343. logo.alt = "pixiv logo";
  2344.  
  2345. const progress = dlg.tokenExpires = dlg.content.appendChild(buildProgressToken());
  2346.  
  2347. const lblRefreshToken = dlg.content.appendChild(document.createElement("label"));
  2348. lblRefreshToken.textContent = "刷新用许可证代码(refresh_token)";
  2349. const iptRefreshToken = lblRefreshToken.appendChild(document.createElement("input"));
  2350. iptRefreshToken.className = "pubd-refresh-token";
  2351. iptRefreshToken.type = "text";
  2352. iptRefreshToken.readOnly = true;
  2353.  
  2354. //错误信息
  2355. dlg.error = dlg.content.appendChild(new ErrorMsg());
  2356.  
  2357. //窗口关闭
  2358. dlg.close = function() {
  2359. progress.stop_token_animate();
  2360. };
  2361. //关闭窗口按钮
  2362. dlg.cptBtns.close.addEventListener("click", dlg.close);
  2363.  
  2364. //窗口初始化
  2365. dlg.initialise = function(arg = {}) {
  2366. this.error.clear();
  2367. iptRefreshToken.value = pubd.oAuth.auth_data.refresh_token;
  2368. progress.start_token_animate();
  2369. dlg.error.replace("刷新许可中···");
  2370. const options = {
  2371. onload:function(jore) { //onload_suceess_Cb
  2372. pubd.oAuth.save();
  2373. dlg.error.replace("成功更新");
  2374. iptRefreshToken.value = jore.refresh_token;
  2375. progress.start_token_animate();
  2376. pubd.dialog.config.refreshLoginState();
  2377. if (arg.onload) arg.onload(jore);
  2378. },
  2379. onload_hasError:function(jore) { //onload_haserror_Cb //返回错误消息
  2380. dlg.error.replace(["错误代码:" + jore.errors.system.code, jore.errors.system.message]);
  2381. if (arg.onload_hasError) arg.onload_hasError(jore);
  2382. },
  2383. onload_notJson:function(re) { //onload_notjson_Cb //返回不是JSON
  2384. dlg.error.replace(["服务器返回不是 JSON 格式", re]);
  2385. if (arg.onload_notJson) arg.onload_notJson(re);
  2386. },
  2387. onerror:function(re) { //onerror_Cb //网络请求发生错误
  2388. dlg.error.replace("网络请求发生错误");
  2389. if (arg.onerror) arg.onerror(re);
  2390. },
  2391. }
  2392. pubd.oAuth.refresh_token(options);
  2393. };
  2394. return dlg;
  2395. }
  2396.  
  2397. //构建通用下载对话框
  2398. function buildDlgDown(caption, classname, id) {
  2399. var dlg = new Dialog(caption, classname, id);
  2400.  
  2401. var dl = dlg.content.appendChild(document.createElement("dl"));
  2402.  
  2403. var dt = document.createElement("dt");
  2404. dl.appendChild(dt);
  2405. dt.innerHTML = ""; //用户头像等信息
  2406. var dd = document.createElement("dd");
  2407. dlg.infoCard = new InfoCard(); //创建信息卡
  2408. dd.appendChild(dlg.infoCard.dom);
  2409. dl.appendChild(dd);
  2410.  
  2411. var dt = document.createElement("dt");
  2412. dl.appendChild(dt);
  2413. dt.innerHTML = "进程日志";
  2414.  
  2415. var dd = document.createElement("dd");
  2416. var ipt = document.createElement("textarea");
  2417. ipt.readOnly = true;
  2418. ipt.className = "pubd-down-log";
  2419. ipt.wrap = "off";
  2420. dlg.logTextarea = ipt;
  2421. dd.appendChild(ipt);
  2422. dl.appendChild(dd);
  2423.  
  2424. //下载方案
  2425. dlg.schemes = null;
  2426.  
  2427. dlg.reloadSchemes = function() { //重新读取所有下载方案
  2428. dlg.schemes = pubd.downSchemes;
  2429.  
  2430. dlg.downSchemeDom.options.length = 0;
  2431. dlg.schemes.forEach(function(item, index) {
  2432. dlg.downSchemeDom.add(item.name, index);
  2433. });
  2434. if (getValueDefault("pubd-defaultscheme",0) >= 0)
  2435. dlg.selectScheme(getValueDefault("pubd-defaultscheme",0));
  2436. else if (dlg.downSchemeDom.options.length > 0)
  2437. dlg.selectScheme(0);
  2438. };
  2439.  
  2440. //选择一个方案,同时读取设置
  2441. dlg.selectScheme = function(index) {
  2442. if (index == undefined) index = 0;
  2443. if (dlg.downSchemeDom.options.length < 1 || dlg.downSchemeDom.selectedOptions.length < 1) { return; }
  2444. dlg.downSchemeDom.selectedIndex = index;
  2445. };
  2446.  
  2447. var dt = document.createElement("dt");
  2448. dl.appendChild(dt);
  2449. dt.innerHTML = "选择下载方案";
  2450. var dd = document.createElement("dd");
  2451. var slt = new Select("pubd-downscheme");
  2452. dlg.downSchemeDom = slt;
  2453. dd.appendChild(slt);
  2454. dl.appendChild(dd);
  2455.  
  2456. //下载按钮栏
  2457. var dt = document.createElement("dt");
  2458. dl.appendChild(dt);
  2459. var dd = document.createElement("dd");
  2460. dd.className = "pubd-downthis-downbar";
  2461.  
  2462. var textdown = document.createElement("input");
  2463. textdown.type = "button";
  2464. textdown.className = "pubd-textdown";
  2465. textdown.value = "输出\n文本";
  2466. textdown.onclick = function(event) {
  2467. dlg.textdownload(event);
  2468. };
  2469. textdown.disabled = true;
  2470. dlg.textdown = textdown;
  2471. dd.appendChild(textdown);
  2472.  
  2473. var startdown = document.createElement("input");
  2474. startdown.type = "button";
  2475. startdown.className = "pubd-startdown";
  2476. startdown.value = "发送到Aria2";
  2477. startdown.onclick = function() {
  2478. dlg.startdownload();
  2479. };
  2480. startdown.disabled = true;
  2481. dlg.startdown = startdown;
  2482. dd.appendChild(startdown);
  2483. dl.appendChild(dd);
  2484.  
  2485. //文本输出栏
  2486. var dt = document.createElement("dt");
  2487. dl.appendChild(dt);
  2488. var dd = document.createElement("dd");
  2489. dd.className = "pubd-down-textout-bar";
  2490. dl.appendChild(dd);
  2491.  
  2492. var ipt = document.createElement("textarea");
  2493. ipt.readOnly = true;
  2494. ipt.className = "pubd-down-textout display-none";
  2495. ipt.wrap = "off";
  2496. dlg.textoutTextarea = ipt;
  2497. dd.appendChild(ipt);
  2498.  
  2499. //显示日志相关
  2500. dlg.logArr = []; //用于储存一行一行的日志信息。
  2501. dlg.logClear = function() {
  2502. dlg.logArr.length = 0;
  2503. this.logTextarea.value = "";
  2504. };
  2505. dlg.log = function(text) {
  2506. dlg.logArr.push(text);
  2507. this.logTextarea.value = this.logArr.join("\n");
  2508. this.logTextarea.scrollTop = this.logTextarea.scrollHeight;
  2509. };
  2510.  
  2511. return dlg;
  2512. }
  2513.  
  2514. //构建当前画师下载对话框
  2515. function buildDlgDownThis(userid) {
  2516. //一个用户的信息
  2517. var UserInfo = function() {
  2518. this.done = false; //是否已完成用户信息获取
  2519. this.info = {
  2520. profile: null,
  2521. user: null,
  2522. };
  2523. this.illusts = new Works();
  2524. this.bookmarks = new Works();
  2525. };
  2526.  
  2527. var dlg = new buildDlgDown("下载当前画师", "pubd-down pubd-downthis", "pubd-downthis");
  2528. dlg.infoCard.infos = {"ID":userid};
  2529.  
  2530. dlg.user = new UserInfo();
  2531. dlg.works = null; //当前处理对象
  2532.  
  2533. var dt = document.createElement("dt");
  2534. var dd = document.createElement("dd");
  2535. dlg.infoCard.dom.insertAdjacentElement("afterend",dt);
  2536. dt.insertAdjacentElement("afterend",dd);
  2537.  
  2538. var frm = dd.appendChild(new Frame("下载内容"));
  2539. var radio1 = frm.content.appendChild(new LabelInput("他的作品", "pubd-down-content", "pubd-down-content", "radio", "0", true));
  2540. var radio2 = frm.content.appendChild(new LabelInput("他的收藏", "pubd-down-content", "pubd-down-content", "radio", "1", true));
  2541. dlg.dcType = [radio1.input, radio2.input];
  2542. radio1.input.onclick = function() { reAnalyse(this); };
  2543. radio2.input.onclick = function() { reAnalyse(this); };
  2544.  
  2545. function reAnalyse(radio) {
  2546. if (radio.checked == true) {
  2547. if (radio.value == 0)
  2548. dlg.user.bookmarks.break = true; //radio值为0,使收藏中断
  2549. else
  2550. dlg.user.illusts.break = true; //radio值为1,使作品中断
  2551.  
  2552. dlg.analyse(radio.value, dlg.infoCard.infos.ID);
  2553. }
  2554. }
  2555.  
  2556. var dt = document.createElement("dt");
  2557. dd.insertAdjacentElement("afterend",dt);
  2558. dt.innerHTML = "信息获取进度";
  2559. var dd = document.createElement("dd");
  2560. dt.insertAdjacentElement("afterend",dd);
  2561. var progress = new Progress();
  2562. dlg.progress = progress;
  2563. dd.appendChild(progress);
  2564.  
  2565. var btnBreak = document.createElement("input");
  2566. btnBreak.type = "button";
  2567. btnBreak.className = "pubd-breakdown";
  2568. btnBreak.value = "中断操作";
  2569. btnBreak.onclick = function() {
  2570. dlg.user.illusts.break = true; //使作品中断
  2571. dlg.user.bookmarks.break = true; //使收藏中断
  2572. pubd.downbreak = true; //使下载中断
  2573. };
  2574. dlg.logTextarea.parentNode.previousElementSibling.appendChild(btnBreak);
  2575.  
  2576. //分析
  2577. dlg.analyse = function(contentType, userid, callbackAfterAnalyse) {
  2578. if (!userid) {dlg.log("错误:没有用户ID。"); return;}
  2579. contentType = contentType == undefined ? 0 : parseInt(contentType);
  2580. var works = contentType == 0 ? dlg.user.illusts : dlg.user.bookmarks; //将需要分析的数据储存到works里
  2581. dlg.works = works;
  2582.  
  2583. if (works.runing) {
  2584. dlg.log("已经在进行分析操作了");
  2585. return;
  2586. }
  2587. works.break = false; //暂停flag为false
  2588. works.runing = true; //运行状态为true
  2589. pubd.ajaxTimes = 0; //ajax提交次数恢复为0
  2590.  
  2591. dlg.textdown.disabled = true; //禁用下载按钮
  2592. dlg.startdown.disabled = true; //禁用输出文本按钮
  2593. dlg.progress.set(0); //进度条归零
  2594. dlg.logClear(); //清空日志
  2595.  
  2596. //根据用户信息是否存在,决定分析用户还是图像
  2597. if (!dlg.user.done) {
  2598. startAnalyseUser(userid, contentType);
  2599. } else {
  2600. dlg.log("ID:" + userid + " 用户信息已存在");
  2601. startAnalyseWorks(dlg.user, contentType); //开始获取第一页
  2602. }
  2603.  
  2604. function startAnalyseUser(userid, contentType) {
  2605.  
  2606. dlg.log("开始获取ID为 " + userid + " 的用户信息");
  2607. ++pubd.ajaxTimes;
  2608. xhrGenneral(
  2609. "https://app-api.pixiv.net/v1/user/detail?user_id=" + userid,
  2610. function(jore) { //onload_suceess_Cb
  2611. works.runing = true;
  2612. dlg.user.done = true;
  2613. dlg.user.info = Object.assign(dlg.user.info, jore);
  2614.  
  2615. if (mdev)
  2616. {
  2617. const usersStore = db.transaction("users", "readwrite").objectStore("users");
  2618. let usersStoreRequest = usersStore.get(jore.user.id);
  2619. usersStoreRequest.onsuccess = function(event) {
  2620. // 获取我们想要更新的数据
  2621. let data = event.target.result;
  2622. if (data)
  2623. console.log("上次的头像",data.user.profile_image_urls);
  2624. if (!data || //没有老数据
  2625. !data.avatarBlob || //没有头像
  2626. data.user.profile_image_urls.medium != jore.user.profile_image_urls.medium //换了头像
  2627. )
  2628. {
  2629. console.debug("需要更新头像图片",jore.user.profile_image_urls);
  2630. GM_xmlhttpRequest({
  2631. url: jore.user.profile_image_urls.medium,
  2632. method: "get",
  2633. responseType: "blob",
  2634. headers: new HeadersObject(),
  2635. onload: function(response) {
  2636. console.info("用户头像Blob结果", response.response);
  2637. var obj_url = URL.createObjectURL(response.response);
  2638. var newImg = new Image();
  2639. newImg.src = obj_url;
  2640. URL.revokeObjectURL(obj_url);
  2641. document.body.appendChild(newImg);
  2642.  
  2643. var newData = data ? Object.assign(data,jore) : jore;
  2644. newData.avatarBlob = response.response;
  2645. // 把更新过的对象放回数据库
  2646. const usersStore = db.transaction("users", "readwrite").objectStore("users");
  2647. var requestUpdate = usersStore.put(newData);
  2648. requestUpdate.onerror = function(event) {// 错误处理
  2649. console.error(`${newData.user.name} 更新数据库头像发生错误`,newData);
  2650. };
  2651. requestUpdate.onsuccess = function(event) {// 完成,数据已更新!
  2652. console.debug(`${newData.user.name} ${data?"更新":"添加"}到头像用户数据库`,newData);
  2653. };
  2654. return;
  2655. },
  2656. onerror: function(response) {
  2657. console.error("抓取头像失败", response);
  2658. return;
  2659. }
  2660. });
  2661. }else
  2662. {
  2663. var newData = data ? Object.assign(data,jore) : jore;
  2664. // 把更新过的对象放回数据库
  2665. var requestUpdate = usersStore.put(newData);
  2666. requestUpdate.onerror = function(event) {// 错误处理
  2667. console.error(`${newData.user.name} 发生错误`,newData);
  2668. };
  2669. requestUpdate.onsuccess = function(event) {// 完成,数据已更新!
  2670. console.debug(`${newData.user.name} ${data?"更新":"添加"}到用户数据库`,newData);
  2671. };
  2672. }
  2673. };
  2674. usersStoreRequest.onerror = function(event) {// 错误处理
  2675. console.error(`${jore.user.name} 数据库里没有?`,jore);
  2676. };
  2677. }
  2678.  
  2679. dlg.infoCard.thumbnail = jore.user.profile_image_urls.medium;
  2680. dlg.infoCard.infos = Object.assign(dlg.infoCard.infos, {
  2681. "昵称": jore.user.name,
  2682. "作品投稿数": jore.profile.total_illusts + jore.profile.total_manga,
  2683. "公开收藏数": jore.profile.total_illust_bookmarks_public,
  2684. });
  2685. startAnalyseWorks(dlg.user, contentType); //分析完成后开始获取第一页
  2686. },
  2687. function(jore) { //onload_haserror_Cb //返回错误消息
  2688. works.runing = false;
  2689. dlg.log("错误信息:" + (jore.error.message || jore.error.user_message));
  2690. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2691. dlg.startdown.disabled = false;
  2692. return;
  2693. },
  2694. function(re) { //onload_notjson_Cb //返回不是JSON
  2695. dlg.log("错误:返回不是JSON,或本程序异常");
  2696. works.runing = false;
  2697. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2698. dlg.startdown.disabled = false;
  2699. },
  2700. function(re) { //onerror_Cb //网络请求发生错误
  2701. dlg.log("错误:网络请求发生错误");
  2702. works.runing = false;
  2703. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2704. dlg.startdown.disabled = false;
  2705. },
  2706. function(str) { //dlog,推送错误消息
  2707. dlg.log(str);
  2708. return str;
  2709. }
  2710. );
  2711. }
  2712.  
  2713. //开始分析作品的前置操作
  2714. function startAnalyseWorks(user, contentType) {
  2715. var uInfo = user.info;
  2716. var works, total, contentName, apiurl;
  2717. //获取作品,contentType == 0,获取收藏,contentType == 1
  2718. if (contentType == 0) {
  2719. works = user.illusts;
  2720. total = uInfo.profile.total_illusts + uInfo.profile.total_manga;
  2721. contentName = "作品";
  2722. apiurl = "https://app-api.pixiv.net/v1/user/illusts?user_id=" + uInfo.user.id;
  2723. } else {
  2724. works = user.bookmarks;
  2725. total = uInfo.profile.total_illust_bookmarks_public;
  2726. contentName = "收藏";
  2727. apiurl = "https://app-api.pixiv.net/v1/user/bookmarks/illust?user_id=" + uInfo.user.id + "&restrict=public";
  2728. }
  2729. if (works.item.length > 0) { //断点续传
  2730. dlg.log(`${contentName} 断点续传进度 ${works.item.length}/${total}`);
  2731. dlg.progress.set(works.item.length / total); //设置当前下载进度
  2732. }
  2733. analyseWorks(user, contentType, apiurl); //开始获取第一页
  2734. }
  2735. //分析作品递归函数
  2736. function analyseWorks(user, contentType, apiurl) {
  2737. var uInfo = user.info;
  2738. var works, total, contentName;
  2739. if (contentType == 0) {
  2740. works = user.illusts;
  2741. total = uInfo.profile.total_illusts + uInfo.profile.total_manga;
  2742. contentName = "作品";
  2743. } else {
  2744. works = user.bookmarks;
  2745. total = uInfo.profile.total_illust_bookmarks_public;
  2746. contentName = "收藏";
  2747. }
  2748. if (works.done) {
  2749. //返回所有动图
  2750. var ugoiras = works.item.filter(function(item) {
  2751. return item.type == "ugoira";
  2752. });
  2753. dlg.log(`共存在 ${ugoiras.length} 件动图`);
  2754. if (ugoiras.some(function(item) { //如果有没有帧数据的动图
  2755. return item.ugoira_metadata == undefined;
  2756. })) {
  2757. if (!getValueDefault("pubd-getugoiraframe",true)) {
  2758. dlg.log("由于用户设置,跳过获取动图帧数。");
  2759. } else {
  2760. analyseUgoira(works, ugoiras, function() { //开始分析动图
  2761. analyseWorks(user, contentType, apiurl); //开始获取下一页
  2762. });
  2763. return;
  2764. }
  2765. }//没有动图则继续
  2766. if (works.item.length < total)
  2767. dlg.log("可能因为权限原因,无法获取到所有 " + contentName);
  2768.  
  2769. //计算一下总页数
  2770. works.picCount = works.item.reduce(function(pV,cItem){
  2771. var page = cItem.page_count;
  2772. if (cItem.type == "ugoira" && cItem.ugoira_metadata) //动图
  2773. {
  2774. page = cItem.ugoira_metadata.frames.length;
  2775. }
  2776. return pV+=page;
  2777. },0);
  2778.  
  2779. dlg.log(`${contentName} ${works.item.length} 件(约 ${works.picCount} 张图片)已获取完毕。`);
  2780. dlg.progress.set(1);
  2781. works.runing = false;
  2782. works.next_url = "";
  2783. dlg.textdown.disabled = false;
  2784. dlg.startdown.disabled = false;
  2785. if (callbackAfterAnalyse) callbackAfterAnalyse();
  2786. return;
  2787. }
  2788. if (works.break) {
  2789. dlg.log("检测到 " + contentName + " 中断进程命令");
  2790. works.break = false;
  2791. works.runing = false;
  2792. dlg.textdown.disabled = false; //启用按钮,中断暂停时,可以操作目前的进度。
  2793. dlg.startdown.disabled = false;
  2794. return;
  2795. }
  2796.  
  2797. setTimeout(()=>{
  2798. xhrGenneral(
  2799. apiurl,
  2800. function(jore) { //onload_suceess_Cb
  2801. works.runing = true;
  2802. var illusts = jore.illusts;
  2803. illusts.forEach(function(work) {
  2804. const original = work.page_count > 1 ?
  2805. work.meta_pages[0].image_urls.original : //漫画多图
  2806. work.meta_single_page.original_image_url; //单张图片或动图,含漫画单图
  2807.  
  2808. //取得解析后的网址
  2809. const parsedUrl = parseIllustUrl(original);
  2810. //合并到work里
  2811. Object.assign(work, parsedUrl);
  2812. if (parsedUrl.parsedURL.limited)
  2813. {
  2814. dlg.log(`${contentName} ${work.id} 非公开,无权获取下载地址。`);
  2815. }else if(parsedUrl.parsedURL.unknown)
  2816. {
  2817. dlg.log(`${contentName} ${work.id} 未知的原图网址格式。`);
  2818. }
  2819.  
  2820. works.item.push(work);
  2821.  
  2822. if (mdev)
  2823. {
  2824. const illustsStore = db.transaction("illusts", "readwrite").objectStore("illusts");
  2825. const illustsStoreRequest = illustsStore.put(work);
  2826. illustsStoreRequest.onsuccess = function(event) {
  2827. //console.debug(`${work.title} 已添加到作品数据库`);
  2828. };
  2829. }
  2830. });
  2831.  
  2832. dlg.log(`${contentName} 获取进度 ${works.item.length}/${total}`);
  2833. if (works == dlg.works) dlg.progress.set(works.item.length / total); //如果没有中断则设置当前下载进度
  2834. if (jore.next_url) { //还有下一页
  2835. works.next_url = jore.next_url;
  2836. } else { //没有下一页
  2837. works.done = true;
  2838. }
  2839. analyseWorks(user, contentType, jore.next_url); //开始获取下一页
  2840. },
  2841. function(jore) { //onload_haserror_Cb //返回错误消息
  2842. works.runing = false;
  2843. dlg.log("错误信息:" + (jore.error.message || jore.error.user_message));
  2844. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2845. dlg.startdown.disabled = false;
  2846. return;
  2847. },
  2848. function(re) { //onload_notjson_Cb //返回不是JSON
  2849. dlg.log("错误:返回不是JSON,或本程序异常");
  2850. works.runing = false;
  2851. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2852. dlg.startdown.disabled = false;
  2853. },
  2854. function(re) { //onerror_Cb //网络请求发生错误
  2855. dlg.log("错误:网络请求发生错误");
  2856. works.runing = false;
  2857. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2858. dlg.startdown.disabled = false;
  2859. }
  2860. );
  2861. },pubd.ajaxTimes++ > startDelayAjaxTimes ? ajaxDelayDuration : 0);
  2862. }
  2863.  
  2864. function analyseUgoira(works, ugoirasItems, callback) {
  2865. var dealItems = ugoirasItems.filter(function(item) {
  2866. return (item.type == "ugoira" && item.ugoira_metadata == undefined);
  2867. });
  2868. if (dealItems.length < 1) {
  2869. dlg.log("动图获取完毕");
  2870. dlg.progress.set(1); //设置当前下载进度
  2871. callback();
  2872. return;
  2873. }
  2874. if (works.break) {
  2875. dlg.log("检测到中断进程命令");
  2876. works.break = false;
  2877. works.runing = false;
  2878. dlg.textdown.disabled = false; //中断暂停时,可以操作目前的进度。
  2879. dlg.startdown.disabled = false;
  2880. return;
  2881. }
  2882.  
  2883. var work = dealItems[0]; //当前处理的图
  2884.  
  2885. setTimeout(()=>{
  2886. if (pubd.ajaxTimes == startDelayAjaxTimes) dlg.log(`已提交超过 ${startDelayAjaxTimes} 次请求,为避免被P站限流,现在开始每次请求将间隔 ${ajaxDelayDuration/1000} 秒。`);
  2887. getUgoiraMeta(
  2888. work.id,
  2889. function(jore) { //onload_suceess_Cb
  2890. works.runing = true;
  2891. //var illusts = jore.illusts;
  2892. work = Object.assign(work, jore);
  2893.  
  2894. if (mdev)
  2895. {
  2896. const illustsStore = db.transaction("illusts", "readwrite").objectStore("illusts");
  2897. const illustsStoreRequest = illustsStore.put(work);
  2898. illustsStoreRequest.onsuccess = function(event) {
  2899. console.debug(`${work.title} 已更新动画帧数据到数据库`);
  2900. };
  2901. }
  2902.  
  2903. dlg.log("动图信息 获取进度 " + (ugoirasItems.length - dealItems.length + 1) + "/" + ugoirasItems.length);
  2904. dlg.progress.set(1 - dealItems.length / ugoirasItems.length); //设置当前下载进度
  2905. analyseUgoira(works, ugoirasItems, callback); //开始获取下一项
  2906. },
  2907. function(jore) { //onload_haserror_Cb //返回错误消息
  2908. if(work.restrict > 0) //非公共权限
  2909. { //添加一条空信息
  2910. work.ugoira_metadata = {
  2911. frames: [],
  2912. zip_urls: {
  2913. medium: "",
  2914. },
  2915. };
  2916. dlg.log("无访问权限,跳过本条。");
  2917. analyseUgoira(works, ugoirasItems, callback); //开始获取下一项
  2918. }else
  2919. {
  2920. works.runing = false;
  2921. dlg.log("错误信息:" + (jore.error.message || jore.error.user_message));
  2922. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2923. dlg.startdown.disabled = false;
  2924. }
  2925. return;
  2926. },
  2927. function(re) { //onload_notjson_Cb //返回不是JSON
  2928. dlg.log("错误:返回不是JSON,或本程序异常");
  2929. works.runing = false;
  2930. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2931. dlg.startdown.disabled = false;
  2932. },
  2933. function(re) { //onerror_Cb //网络请求发生错误
  2934. dlg.log("错误:网络请求发生错误");
  2935. works.runing = false;
  2936. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  2937. dlg.startdown.disabled = false;
  2938. }
  2939. );
  2940. },pubd.ajaxTimes++ > startDelayAjaxTimes ? ajaxDelayDuration : 0);
  2941. }
  2942. };
  2943. //输出文本按钮
  2944. dlg.textdownload = function(event) {
  2945. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  2946. var scheme = dlg.schemes[dlg.downSchemeDom.selectedIndex];
  2947. var contentType = dlg.dcType[1].checked ? 1 : 0;
  2948. var userInfo = dlg.user.info;
  2949. var illustsItems = contentType == 0 ? dlg.user.illusts.item : dlg.user.bookmarks.item; //将需要分析的数据储存到works里
  2950. dlg.log("正在生成文本信息");
  2951.  
  2952. try {
  2953. var outTxtArr;
  2954. if (event.ctrlKey)
  2955. {
  2956. outTxtArr = showMask(scheme.textout, scheme.masklist, userInfo, null, 0);
  2957. }else
  2958. {
  2959. outTxtArr = illustsItems.map(function(illust) {
  2960. var page_count = illust.page_count;
  2961. if (illust.type == "ugoira" && illust.ugoira_metadata) //动图
  2962. {
  2963. page_count = illust.ugoira_metadata.frames.length;
  2964. }
  2965. var outArr = []; //输出内容
  2966. for (var pi = 0; pi < page_count; pi++) {
  2967. if (returnLogicValue(scheme.downfilter, userInfo, illust, pi) || limitingFilenameExp.test(illust.filename)) {
  2968. //跳过此次输出
  2969. continue;
  2970. }else{
  2971. outArr.push(showMask(scheme.textout, scheme.masklist, userInfo, illust, pi));
  2972. }
  2973. }
  2974. return outArr.join("");
  2975. }).join("");
  2976. }
  2977. dlg.textoutTextarea.value = outTxtArr;
  2978. dlg.textoutTextarea.classList.remove("display-none");
  2979. dlg.log("文本信息输出成功");
  2980. } catch (error) {
  2981. console.log(error);
  2982. }
  2983. };
  2984. //开始下载按钮
  2985. dlg.startdownload = function() {
  2986. dlg.textoutTextarea.classList.add("display-none");
  2987. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  2988. var scheme = dlg.schemes[dlg.downSchemeDom.selectedIndex];
  2989. var contentType = dlg.dcType[1].checked ? 1 : 0;
  2990. var userInfo = dlg.user.info;
  2991. var works = (contentType == 0 ? dlg.user.illusts : dlg.user.bookmarks);
  2992. var illustsItems = works.item.concat(); //为了不改变原数组,新建一个数组
  2993.  
  2994. let termwiseType = parseInt(getValueDefault("pubd-termwiseType", 2));
  2995. if (works.picCount > changeTermwiseCount && termwiseType ==2)
  2996. {
  2997. dlg.log(`图片总数超过${changeTermwiseCount}张,自动切换为使用按作品逐项发送模式。`);
  2998. termwiseType = 1;
  2999. }
  3000. if (termwiseType == 0)
  3001. dlg.log("开始按图片逐项发送(约 "+works.picCount+" 次请求),⏳请耐心等待。");
  3002. else if (termwiseType == 1)
  3003. dlg.log("开始按作品逐项发送(约 "+illustsItems.length+" 次请求),⏳请耐心等待。");
  3004. else if (termwiseType == 2)
  3005. dlg.log("开始按作者发送,数据量较大时有较高延迟。\n⏳请耐心等待完成通知,勿多次点击。");
  3006. else
  3007. {
  3008. alert("错误:未知的逐项模式" + termwiseType);
  3009. console.error("PUBD:错误:未知的逐项模式:", termwiseType);
  3010. return;
  3011. }
  3012. var downP = { progress: dlg.progress, current: 0, max: 0 };
  3013. downP.max = works.picCount; //获取总需要下载发送的页数
  3014.  
  3015. var aria2 = new Aria2(scheme.rpcurl); //生成一个aria2对象
  3016. sendToAria2_illust(aria2, termwiseType, illustsItems, userInfo, scheme, downP, function() {
  3017. aria2 = null;
  3018. dlg.log("😄 " + userInfo.user.name + " 下载信息发送完毕");
  3019. var ntype = parseInt(getValueDefault("pubd-noticeType", 0)); //获取结束后如何处理通知
  3020. var bodyText = "" + userInfo.user.name + " 的相关插画已全部发送到指定的Aria2";
  3021. if (ntype == 1)
  3022. bodyText += "\n\n点击此通知 🔙返回 页面。";
  3023. else if (ntype == 2)
  3024. bodyText += "\n\n点击此通知 ❌关闭 页面。";
  3025. else if (ntype == 3)
  3026. bodyText += "\n\n通知结束时页面将 🅰️自动❌关闭。";
  3027. GM_notification(
  3028. {
  3029. text:bodyText,
  3030. title:"下载信息发送完毕",
  3031. image:userInfo.user.profile_image_urls.medium
  3032. },
  3033. function(){ //点击了通知
  3034. var ntype = parseInt(getValueDefault("pubd-noticeType", 0));
  3035. if (ntype == 1)
  3036. window.focus();
  3037. else if (ntype == 2)
  3038. window.close();
  3039. },
  3040. function(){ //关闭了通知
  3041. var ntype = parseInt(getValueDefault("pubd-noticeType", 0));
  3042. if (ntype == 3)
  3043. window.close();
  3044. }
  3045. );
  3046. });
  3047. };
  3048. //启动初始化
  3049. dlg.initialise = function(arg) {
  3050. var dcType = 0;
  3051. if (dlg.user.bookmarks.runing) //如果有程序正在运行,则覆盖设置。
  3052. dcType = 1;
  3053. else if (dlg.user.illusts.runing)
  3054. dcType = 0;
  3055. dlg.dcType[dcType].checked = true;
  3056.  
  3057. let uid = arg.id;
  3058. if (arg && arg.id>0) //提供了ID
  3059. {
  3060. if (arg.id != dlg.infoCard.infos.ID)
  3061. { //更换新的id
  3062. dlg.infoCard.thumbnail = "";
  3063. dlg.infoCard.infos = {"ID":arg.id}; //初始化窗口id
  3064. dlg.user = new UserInfo(); //重置用户数据
  3065. }
  3066. }else if(!dlg.infoCard.infos.ID) //没有ID
  3067. {
  3068. uid = parseInt(prompt("没有用户ID,请手动输入。", "ID缺失"),10);
  3069. dlg.infoCard.infos = {"ID":uid}; //初始化窗口id
  3070. }
  3071. if (getValueDefault("pubd-autoanalyse",false)) {
  3072.  
  3073. //开始自动分析的话,也自动添加到快速收藏
  3074. if (!pubd.fastStarList.has(userid)) { //不存在,则添加
  3075. pubd.fastStarList.add(uid);
  3076. pubd.start.star.classList.add("stars");
  3077. GM_setValue("pubd-faststar-list",pubd.fastStarList.exportArray());
  3078. console.debug(`已将 ${uid} 添加到快速收藏`);
  3079. }else if (mdev)
  3080. {
  3081. console.debug(`快速收藏中已存在 ${uid}`);
  3082. }
  3083.  
  3084. dlg.analyse(dcType, uid, function(){
  3085. if (getValueDefault("pubd-autodownload",false)) { //自动开始
  3086. dlg.log("🅰️自动开始发送");
  3087. dlg.startdownload();
  3088. }
  3089. });
  3090. }
  3091. dlg.reloadSchemes();
  3092. };
  3093.  
  3094. return dlg;
  3095. }
  3096.  
  3097. //构建当前作品下载对话框
  3098. function buildDlgDownIllust(illustid) {
  3099. var dlg = new buildDlgDown("下载当前作品", "pubd-down pubd-downillust", "pubd-downillust");
  3100. dlg.infoCard.infos = {"ID":illustid};
  3101. dlg.work = null; //当前处理对象
  3102.  
  3103. //分析
  3104. dlg.analyse = function(illustid,callbackAfterAnalyse) {
  3105. if (!illustid) {dlg.log("错误:没有作品ID。"); return;}
  3106.  
  3107. dlg.textdown.disabled = true; //禁用下载按钮
  3108. dlg.startdown.disabled = true; //禁用输出文本按钮
  3109. dlg.logClear(); //清空日志
  3110.  
  3111. if (dlg.work != undefined)
  3112. {
  3113. dlg.textdown.disabled = false;
  3114. dlg.startdown.disabled = false;
  3115. console.log("当前作品JSON数据:",dlg.work);
  3116. dlg.log("图片信息获取完毕");
  3117. if (callbackAfterAnalyse) callbackAfterAnalyse();
  3118. }else
  3119. {
  3120. dlg.log("开始获取作品信息");
  3121. analyseWork(illustid); //开始获取第一页
  3122. }
  3123.  
  3124. //分析作品递归函数
  3125. function analyseWork(illustid) {
  3126. xhrGenneral(
  3127. "https://app-api.pixiv.net/v1/illust/detail?illust_id=" + illustid,
  3128. function(jore) { //onload_suceess_Cb
  3129. var work = dlg.work = jore.illust;
  3130. const original = work.page_count > 1 ?
  3131. work.meta_pages[0].image_urls.original : //漫画多图
  3132. work.meta_single_page.original_image_url; //单张图片或动图,含漫画单图
  3133.  
  3134. //取得解析后的网址
  3135. const parsedUrl = parseIllustUrl(original);
  3136. //合并到work里
  3137. Object.assign(work, parsedUrl);
  3138. if (parsedUrl.parsedURL.limited)
  3139. {
  3140. dlg.log(`${contentName} ${work.id} 非公开,无权获取下载地址。`);
  3141. }else if(parsedUrl.parsedURL.unknown)
  3142. {
  3143. dlg.log(`${contentName} ${work.id} 未知的原图网址格式。`);
  3144. }
  3145. if (mdev)
  3146. {
  3147. const illustsStoreRequest = db.transaction("illusts", "readwrite").objectStore("illusts").put(work);
  3148. illustsStoreRequest.onsuccess = function(event) {
  3149. console.debug(`${work.title} 已添加到作品数据库`);
  3150. };
  3151. }
  3152.  
  3153. dlg.infoCard.thumbnail = work.image_urls.square_medium;
  3154. var iType = "插画";
  3155. if (work.type == "ugoira")
  3156. iType = "动画";
  3157. else if (work.type == "manga")
  3158. iType = "漫画";
  3159. if (work.page_count>1)
  3160. iType += "(多图)";
  3161.  
  3162. dlg.infoCard.infos = Object.assign(dlg.infoCard.infos, {
  3163. "作品名称": work.title,
  3164. "作品类型": iType,
  3165. "作品页数": work.page_count,
  3166. });
  3167.  
  3168. if (work.type == "ugoira" && work.ugoira_metadata == undefined && getValueDefault("pubd-getugoiraframe",true))
  3169. {
  3170. analyseUgoira(work, function() { //开始分析动图
  3171. dlg.textdown.disabled = false;
  3172. dlg.startdown.disabled = false;
  3173. dlg.infoCard.infos["作品页数"] = work.ugoira_metadata.frames.length;
  3174. dlg.infoCard.reload(); //必须要reload
  3175. dlg.log("图片信息获取完毕");
  3176. console.log("当前作品JSON数据:",work);
  3177. if (callbackAfterAnalyse) callbackAfterAnalyse();
  3178. });
  3179. return;
  3180. }else
  3181. {
  3182. if (!getValueDefault("pubd-getugoiraframe",true)) {
  3183. dlg.log("由于用户设置,跳过获取动图帧数。");
  3184. }
  3185. dlg.textdown.disabled = false;
  3186. dlg.startdown.disabled = false;
  3187. dlg.log("图片信息获取完毕");
  3188. console.log("当前作品JSON数据:",work);
  3189. if (callbackAfterAnalyse) callbackAfterAnalyse();
  3190. }
  3191. },
  3192. function(jore) { //onload_haserror_Cb //返回错误消息
  3193. dlg.log("错误信息:" + (jore.error.message || jore.error.user_message));
  3194. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3195. dlg.startdown.disabled = false;
  3196. return;
  3197. },
  3198. function(re) { //onload_notjson_Cb //返回不是JSON
  3199. dlg.log("错误:返回不是JSON,或本程序异常");
  3200. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3201. dlg.startdown.disabled = false;
  3202. },
  3203. function(re) { //onerror_Cb //网络请求发生错误
  3204. dlg.log("错误:网络请求发生错误");
  3205. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3206. dlg.startdown.disabled = false;
  3207. }
  3208. );
  3209. }
  3210.  
  3211. function analyseUgoira(work, callback) {
  3212. getUgoiraMeta(
  3213. work.id,
  3214. function(jore) { //onload_suceess_Cb
  3215. work = Object.assign(work, jore);
  3216. if (mdev)
  3217. {
  3218. const illustsStoreRequest = db.transaction("illusts", "readwrite").objectStore("illusts").put(work);
  3219. illustsStoreRequest.onsuccess = function(event) {
  3220. console.debug(`${work.title} 已更新动画帧数据到数据库`);
  3221. };
  3222. }
  3223. dlg.log("动图信息获取完成");
  3224. callback(); //开始获取下一项
  3225. },
  3226. function(jore) { //onload_haserror_Cb //返回错误消息
  3227. if(work.restrict > 0) //非公共权限
  3228. { //添加一条空信息
  3229. work.ugoira_metadata = {
  3230. frames: [],
  3231. zip_urls: {
  3232. medium: "",
  3233. },
  3234. };
  3235. dlg.log("无访问权限,跳过本条。");
  3236. callback(); //开始获取下一项
  3237. }else
  3238. {
  3239. works.runing = false;
  3240. dlg.log("错误信息:" + (jore.error.message || jore.error.user_message));
  3241. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3242. dlg.startdown.disabled = false;
  3243. }
  3244. return;
  3245. },
  3246. function(re) { //onload_notjson_Cb //返回不是JSON
  3247. dlg.log("错误:返回不是JSON,或本程序异常");
  3248. works.runing = false;
  3249. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3250. dlg.startdown.disabled = false;
  3251. },
  3252. function(re) { //onerror_Cb //网络请求发生错误
  3253. dlg.log("错误:网络请求发生错误");
  3254. works.runing = false;
  3255. dlg.textdown.disabled = false; //错误暂停时,可以操作目前的进度。
  3256. dlg.startdown.disabled = false;
  3257. }
  3258. );
  3259. }
  3260. };
  3261. //输出文本按钮
  3262. dlg.textdownload = function(event) {
  3263. var illust = dlg.work;
  3264. if (illust == undefined) {dlg.log("没有获取作品数据。"); return;}
  3265. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  3266. var scheme = dlg.schemes[dlg.downSchemeDom.selectedIndex];
  3267. dlg.log("正在生成文本信息");
  3268. try {
  3269. var page_count = illust.page_count;
  3270. if (illust.type == "ugoira" && illust.ugoira_metadata) //动图
  3271. {
  3272. page_count = illust.ugoira_metadata.frames.length;
  3273. }
  3274. var outArr = []; //输出内容
  3275. for (var pi = 0; pi < page_count; pi++) {
  3276. if (returnLogicValue(scheme.downfilter, null, illust, pi) || limitingFilenameExp.test(illust.filename)) {
  3277. //跳过此次输出
  3278. continue;
  3279. }else{
  3280. outArr.push(showMask(scheme.textout, scheme.masklist, null, illust, pi));
  3281. }
  3282. }
  3283. var outTxt = outArr.join("");
  3284. dlg.textoutTextarea.value = outTxt;
  3285. dlg.textoutTextarea.classList.remove("display-none");
  3286. dlg.log("文本信息输出成功");
  3287. } catch (error) {
  3288. console.log(error);
  3289. }
  3290. };
  3291. //开始下载按钮
  3292. dlg.startdownload = function() {
  3293. dlg.textoutTextarea.classList.add("display-none");
  3294. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  3295. var scheme = dlg.schemes[dlg.downSchemeDom.selectedIndex];
  3296.  
  3297. var termwiseType = parseInt(getValueDefault("pubd-termwiseType", 2));
  3298. if (termwiseType == 0)
  3299. dlg.log("开始按图片逐项发送,⏳请耐心等待。");
  3300. else if (termwiseType == 1 || termwiseType == 2)
  3301. dlg.log("一次性发送整个作品,⏳请耐心等待。");
  3302. else
  3303. {
  3304. alert("错误:未知的逐项模式" + termwiseType);
  3305. console.error("PUBD:错误:未知的逐项模式:", termwiseType);
  3306. return;
  3307. }
  3308.  
  3309. var aria2 = new Aria2(scheme.rpcurl); //生成一个aria2对象
  3310. sendToAria2_illust(aria2, termwiseType, [dlg.work], null, scheme, null, function() {
  3311. aria2 = null;
  3312. dlg.log("😄 当前作品下载信息发送完毕");
  3313. });
  3314. };
  3315. //启动初始化
  3316. dlg.initialise = function(arg) {
  3317. if (arg && arg.id>0) //提供了ID
  3318. {
  3319. if (arg.id != dlg.infoCard.infos.ID)
  3320. { //更换新的id
  3321. dlg.infoCard.thumbnail = "";
  3322. dlg.infoCard.infos = {"ID":arg.id}; //初始化窗口id
  3323. dlg.work = null; //重置作品数据
  3324. }
  3325. }else if(!dlg.infoCard.infos.ID) //没有ID
  3326. {
  3327. dlg.infoCard.infos = {"ID":parseInt(prompt("没有作品ID,请手动输入。", "ID缺失"))}; //初始化窗口id
  3328. }
  3329. dlg.analyse(dlg.infoCard.infos.ID, function(){
  3330. if (getValueDefault("pubd-autodownload",false)) { //自动开始
  3331. dlg.log("🅰️自动开始发送");
  3332. dlg.startdownload();
  3333. }
  3334. });
  3335. dlg.reloadSchemes();
  3336. };
  3337.  
  3338. return dlg;
  3339. }
  3340.  
  3341. //构建导入数据对话框
  3342. function buildDlgImportData() {
  3343. var dlg = new Dialog("导入数据", "pubd-import", "pubd-import");
  3344. var dl = dlg.content.appendChild(document.createElement("dl"));
  3345.  
  3346. var dt = dl.appendChild(document.createElement("dt"));
  3347. dt.innerHTML = "导入内容";
  3348.  
  3349. var dd = dl.appendChild(document.createElement("dd"));
  3350. dd.className = "pubd-import-textarea-bar";
  3351. var ipt = dd.appendChild(document.createElement("textarea"));
  3352. ipt.className = "pubd-import-textarea";
  3353. dlg.importTxt = ipt;
  3354. var dd = dl.appendChild(document.createElement("dd"));
  3355. var btn = dd.appendChild(document.createElement("input"));
  3356. btn.type = "button";
  3357. btn.className = "pubd-import-done";
  3358. btn.value = "导入";
  3359.  
  3360. //启动初始化
  3361. dlg.initialise = function(arg) {
  3362. ipt.value = "";
  3363. if (arg)
  3364. {
  3365. btn.onclick = function()
  3366. {//返回文本框的内容
  3367. arg.callback(ipt.value);
  3368. dlg.hide();
  3369. };
  3370. }else
  3371. {
  3372. btn.onclick = function()
  3373. {
  3374. alert("窗口异常启动,未提供回调函数");
  3375. };
  3376. }
  3377. };
  3378. return dlg;
  3379. }
  3380.  
  3381. //构建多画师下载管理对话框
  3382. function buildDlgMultiple() {
  3383. var dlg = new Dialog("多画师下载管理", "pubd-multiple", "pubd-multiple");
  3384. var dl = dlg.content.appendChild(document.createElement("dl"));
  3385.  
  3386. var dt = dl.appendChild(document.createElement("dt"));
  3387. var dd = dl.appendChild(document.createElement("dd"));
  3388. var frm = dd.appendChild(new Frame("导出Pivix账号关注", "pubd-frm-userlist"));
  3389. var dl_input_frm = frm.content.appendChild(document.createElement("dl"));
  3390. var dt = dl_input_frm.appendChild(document.createElement("dt"));
  3391. var dd = dl_input_frm.appendChild(document.createElement("dd"));
  3392.  
  3393. var ipt = dd.appendChild(document.createElement("input"));
  3394. ipt.type = "button";
  3395. ipt.className = "pubd-userlist-inputstar-public";
  3396. ipt.value = "导出公开关注";
  3397. ipt.onclick = function() {
  3398. };
  3399.  
  3400. var ipt = dd.appendChild(document.createElement("input"));
  3401. ipt.type = "button";
  3402. ipt.className = "pubd-userlist-inputstar-public";
  3403. ipt.value = "导出非公开关注";
  3404. ipt.onclick = function() {
  3405. };
  3406.  
  3407. /*
  3408. var ipt = dd.appendChild(document.createElement("input"));
  3409. ipt.type = "button";
  3410. ipt.className = "pubd-userlist-backup";
  3411. ipt.value = "备份列表JSON"
  3412. ipt.onclick = function() {
  3413. }
  3414.  
  3415. var ipt = dd.appendChild(document.createElement("input"));
  3416. ipt.type = "button";
  3417. ipt.className = "pubd-userlist-restore";
  3418. ipt.value = "导入备份"
  3419. ipt.onclick = function() {
  3420. }
  3421. */
  3422.  
  3423. var dt = dl.appendChild(document.createElement("dt"));
  3424. dt.innerHTML = "选择收藏列表";
  3425. var dd = dl.appendChild(document.createElement("dd"));
  3426. var slt = dd.appendChild(new Select("pubd-staruserlists"));
  3427. slt.onchange = function() {
  3428. dlg.loadTheList(this.selectedIndex);
  3429. };
  3430. //每次脚本预加载的时候事先生成列表
  3431. slt.options.add(new Option('快速收藏',0));
  3432. //重新读取所有收藏列表
  3433. dlg.reloadStarList = function() {
  3434. while (slt.length>0)
  3435. {
  3436. const x = slt.options[0];
  3437. x.remove();
  3438. x = null;
  3439. }
  3440. slt.options.length = 0;
  3441. pubd.starUserlists.forEach((ulist,idx) => slt.options.add(new Option(ulist.title,idx)));
  3442. };
  3443. dlg.loadTheList = function(listIdx) {
  3444. const listArr = listIdx > 0 ? pubd.starUserlists[listIdx].exportArray() : pubd.fastStarList.exportArray();
  3445. const ulDom = dlg.ulDom;
  3446. ulDom.classList.add("display-none");
  3447. while (ulDom.childNodes.length)
  3448. {
  3449. const x = ulDom.childNodes[0];
  3450. if (x.nodeName == 'li')
  3451. {
  3452. const l = x.querySelector('label');
  3453. l.ipt.remove();
  3454. delete l.ipt;
  3455. l.card.dom.remove();
  3456. delete l.card.dom
  3457. delete l.card;
  3458. l.remove();
  3459. l = null;
  3460. }
  3461. x.remove();
  3462. x = null;
  3463. }
  3464. const fragment = document.createDocumentFragment();
  3465. console.log(listArr)
  3466. listArr.forEach(uid=>{ //添加每一个作者的信息
  3467. const uli = fragment.appendChild(document.createElement('li'));
  3468. uli.className = 'user-card-li';
  3469. uli.setAttribute('data-user-id',uid);
  3470. const lbl = uli.appendChild(new LabelInput(null,'user-card-lbl',`user-${uid}`,'checkbox',uid));
  3471. const card = lbl.card = new InfoCard({
  3472. "ID": uid,
  3473. "昵称": null,
  3474. "作品获取程度": null,
  3475. "数据更新时间": null,
  3476. });
  3477. lbl.appendChild(card.dom);
  3478. });
  3479. ulDom.appendChild(fragment);
  3480. ulDom.classList.remove("display-none");
  3481. };
  3482.  
  3483. dlg.userListDom = slt;
  3484.  
  3485. var dd = dl.appendChild(document.createElement("dd"));
  3486. var ipt = dd.appendChild(document.createElement("input"));
  3487. ipt.type = "button";
  3488. ipt.className = "pubd-userlist-new";
  3489. ipt.value = "新建";
  3490. ipt.onclick = function() {
  3491. var schemName = prompt("请输入方案名", "我的方案");
  3492. if (schemName)
  3493. {
  3494. var scheme = new DownScheme(schemName);
  3495. var length = dlg.schemes.push(scheme);
  3496. dlg.downSchemeDom.add(scheme.name, length - 1);
  3497. dlg.downSchemeDom.selectedIndex = length - 1;
  3498. dlg.loadScheme(scheme);
  3499. //dlg.reloadSchemes();
  3500. }
  3501. };
  3502.  
  3503. var ipt = dd.appendChild(document.createElement("input"));
  3504. ipt.type = "button";
  3505. ipt.className = "pubd-userlist-rename";
  3506. ipt.value = "重命名列表";
  3507. ipt.onclick = function() {
  3508. };
  3509.  
  3510. var ipt = dd.appendChild(document.createElement("input"));
  3511. ipt.type = "button";
  3512. ipt.className = "pubd-userlist-remove";
  3513. ipt.value = "删除";
  3514. ipt.onclick = function() {
  3515. if (dlg.downSchemeDom.options.length < 1) { alert("已经没有方案了"); return; }
  3516. if (dlg.downSchemeDom.selectedOptions.length < 1) { alert("没有选中方案"); return; }
  3517. var index = dlg.downSchemeDom.selectedIndex;
  3518. dlg.schemes.splice(index, 1);
  3519. dlg.downSchemeDom.remove(index);
  3520. var index = dlg.downSchemeDom.selectedIndex;
  3521. if (index < 0) dlg.reloadSchemes(); //没有选中的,重置
  3522. else dlg.loadScheme(dlg.schemes[index]);
  3523. };
  3524.  
  3525. var dd = dl.appendChild(document.createElement("dd"));
  3526. var frm = dd.appendChild(new Frame("当前列表", "pubd-frm-userlist"));
  3527. var dl_ul_frm = frm.content.appendChild(document.createElement("dl"));
  3528. var dt = dl_ul_frm.appendChild(document.createElement("dt"));
  3529. var dd = dl_ul_frm.appendChild(document.createElement("dd"));
  3530.  
  3531. var ipt = dd.appendChild(document.createElement("input"));
  3532. ipt.type = "button";
  3533. ipt.className = "pubd-userlist-this-add";
  3534. ipt.value = "添加画师ID";
  3535. ipt.onclick = function() {
  3536. };
  3537. var ipt = dd.appendChild(document.createElement("input"));
  3538. ipt.type = "button";
  3539. ipt.className = "pubd-userlist-this-remove";
  3540. ipt.value = "删除选中画师";
  3541. ipt.onclick = function() {
  3542. };
  3543. var ipt = dd.appendChild(document.createElement("input"));
  3544. ipt.type = "button";
  3545. ipt.className = "pubd-userlist-this-reset-getdata";
  3546. ipt.value = "重置数据获取状态";
  3547. ipt.onclick = function() {
  3548. };
  3549. var ipt = dd.appendChild(document.createElement("input"));
  3550. ipt.type = "button";
  3551. ipt.className = "pubd-userlist-this-reset-downloaded";
  3552. ipt.value = "重置下载状态";
  3553. ipt.onclick = function() {
  3554. };
  3555.  
  3556. var dt = dl_ul_frm.appendChild(document.createElement("dt"));
  3557. dt.innerHTML = "画师列表";
  3558. var ipt = dt.appendChild(document.createElement("input"));
  3559. ipt.type = "button";
  3560. ipt.className = "pubd-userlist-break";
  3561. ipt.value = "中断操作";
  3562. ipt.onclick = function() {
  3563. };
  3564. var dd = dl_ul_frm.appendChild(document.createElement("dd"));
  3565. var dl_ul = dd.appendChild(document.createElement("ul"));
  3566. dlg.ulDom = dl_ul;
  3567. dl_ul.className = "pubd-userlist-ul";
  3568.  
  3569. var dt = dl.appendChild(document.createElement("dt"));
  3570. var dd = dl.appendChild(document.createElement("dd"));
  3571. var ipt = dd.appendChild(document.createElement("input"));
  3572. ipt.type = "button";
  3573. ipt.className = "pubd-userlist-this-getdata";
  3574. ipt.value = "获取画师数据";
  3575. ipt.onclick = function() {
  3576. };
  3577.  
  3578. var ipt = dd.appendChild(document.createElement("input"));
  3579. ipt.type = "button";
  3580. ipt.className = "pubd-userlist-textdown";
  3581. ipt.value = "输出文本";
  3582. ipt.onclick = function() {
  3583. };
  3584. var ipt = dd.appendChild(document.createElement("input"));
  3585. ipt.type = "button";
  3586. ipt.className = "pubd-userlist-download";
  3587. ipt.value = "下载列表内画师作品";
  3588. ipt.onclick = function() {
  3589. };
  3590. //启动初始化
  3591. dlg.initialise = function(arg) {
  3592. dlg.loadTheList(0); //加载快速收藏列表
  3593. };
  3594. return dlg;
  3595. }
  3596.  
  3597. //作品循环递归输出
  3598. function sendToAria2_illust(aria2, termwiseType, illusts, userInfo, scheme, downP, callback) {
  3599. if (illusts.length < 1) //做完了
  3600. {
  3601. callback();
  3602. return;
  3603. }
  3604. if (pubd.downbreak)
  3605. {
  3606. GM_notification({text:"已中断向Aria2发送下载信息。但Aria2本身仍未停止下载已添加内容,请手动停止。", title:scriptName, image:scriptIcon});
  3607. pubd.downbreak = false;
  3608. return;
  3609. }
  3610. if (termwiseType == 0) //完全逐项
  3611. {
  3612. var illust = illusts.shift(); //读取首个作品
  3613. sendToAria2_Page(aria2, illust, 0, userInfo, scheme, downP, function() {
  3614. sendToAria2_illust(aria2, termwiseType, illusts, userInfo, scheme, downP, callback); //发送下一个作品
  3615. });
  3616. return; //不再继续执行
  3617. }else if (termwiseType == 1) //部分逐项(每作品合并)
  3618. {
  3619. var illust = illusts.shift(); //读取首个作品
  3620. var page_count = illust.page_count; //作品页数
  3621. if (illust.type == "ugoira" && illust.ugoira_metadata) //修改动图的页数
  3622. {
  3623. page_count = illust.ugoira_metadata.frames.length;
  3624. }
  3625. if (limitingFilenameExp.test(illust.filename)) //无权查看的文件
  3626. {
  3627. if (downP) downP.progress.set((downP.current += page_count) / downP.max); //直接加上一个作品所有页数
  3628. sendToAria2_illust(aria2, termwiseType, illusts, userInfo, scheme, downP, callback); //调用自身
  3629. return;
  3630. }
  3631. var aria2_params = [];
  3632. for (let page=0;page<page_count;page++)
  3633. {
  3634. if (returnLogicValue(scheme.downfilter, userInfo, illust, page)) {
  3635. //跳过此次下载
  3636. //console.info("符合下载过滤器定义,跳过下载:", illust);
  3637. continue;
  3638. } else {
  3639. var aria2_method = {'methodName':'aria2.addUri','params':[]};
  3640. var url = getIllustDownUrl(scheme, userInfo, illust, page);
  3641.  
  3642. aria2_method.params.push([url]); //添加下载链接
  3643. var options = {
  3644. "out": pathSafe(showMask(scheme.savepath, scheme.masklist, userInfo, illust, page), 'pathWithoutDriver'),
  3645. "referer": Referer,
  3646. "user-agent": UA,
  3647. };
  3648. if (scheme.savedir.length > 0) {
  3649. options.dir = pathSafe(showMask(scheme.savedir, scheme.masklist, userInfo, illust, page), 'path');
  3650. }
  3651. if (scheme.proxyurl.length > 0) {
  3652. options["all-proxy"] = scheme.proxyurl;
  3653. }
  3654. aria2_method.params.push(options);
  3655. aria2_params.push(aria2_method);
  3656. }
  3657. }
  3658. if (aria2_params.length>0)
  3659. {
  3660. aria2.system.multicall([aria2_params],function(res){
  3661. if (res === false) {
  3662. alert("发送到指定的Aria2失败,请检查到Aria2连接是否正常。");
  3663. return;
  3664. }
  3665. if (downP) downP.progress.set((downP.current += page_count) / downP.max); //直接加上一个作品所有页数
  3666. sendToAria2_illust(aria2, termwiseType, illusts, userInfo, scheme, downP, callback); //调用自身
  3667. });
  3668. }else
  3669. { //这个作品全部跳过的时候
  3670. if (downP) downP.progress.set((downP.current += page_count) / downP.max); //直接加上一个作品所有页数
  3671. sendToAria2_illust(aria2, termwiseType, illusts, userInfo, scheme, downP, callback); //调用自身
  3672. }
  3673. return;
  3674. }else if(termwiseType == 2) //不逐项,每作者合并
  3675. {
  3676. var aria2_params = [];
  3677. for (var illustIndex = 0; illustIndex < illusts.length; illustIndex++)
  3678. {
  3679. var illust = illusts[illustIndex];
  3680. if (limitingFilenameExp.test(illust.filename)) continue; //无权查看的文件,直接继续
  3681.  
  3682. var page_count = illust.page_count; //作品页数
  3683. if (illust.type == "ugoira" && illust.ugoira_metadata) //修改动图的页数
  3684. {
  3685. page_count = illust.ugoira_metadata.frames.length;
  3686. }
  3687. for (let page=0;page<page_count;page++)
  3688. {
  3689. if (returnLogicValue(scheme.downfilter, userInfo, illust, page)) {
  3690. //跳过此次下载
  3691. //console.info("符合下载过滤器定义,跳过下载:", illust);
  3692. continue;
  3693. } else {
  3694. var aria2_method = {'methodName':'aria2.addUri','params':[]};
  3695. var url = getIllustDownUrl(scheme, userInfo, illust, page);
  3696.  
  3697. aria2_method.params.push([url]); //添加下载链接
  3698. var options = {
  3699. "out": pathSafe(showMask(scheme.savepath, scheme.masklist, userInfo, illust, page), 'pathWithoutDriver'),
  3700. "referer": Referer,
  3701. "user-agent": UA,
  3702. };
  3703. if (scheme.savedir.length > 0) {
  3704. options.dir = pathSafe(showMask(scheme.savedir, scheme.masklist, userInfo, illust, page), 'path');
  3705. }
  3706. if (scheme.proxyurl.length > 0) {
  3707. options["all-proxy"] = scheme.proxyurl;
  3708. }
  3709. aria2_method.params.push(options);
  3710. aria2_params.push(aria2_method);
  3711. }
  3712. }
  3713. }
  3714. if (aria2_params.length>0)
  3715. {
  3716. aria2.system.multicall([aria2_params],function(res){
  3717. if (res === false) {
  3718. alert("发送到指定的Aria2失败,请检查到Aria2连接是否正常。不排除数据过大,可考虑临时使用逐项或半逐项模式。");
  3719. var l= JSON.stringify(aria2_params).length/1024;
  3720. console.error("Aria2接受失败。数据量在未添加token的情况下有" + (
  3721. (l>1024)?
  3722. ((l/1024)+"MB"):
  3723. (l+"KB")
  3724. ),aria2_params);
  3725. return;
  3726. }
  3727. if (downP) downP.progress.set((downP.current = downP.max) / downP.max); //直接加上所有页数
  3728. sendToAria2_illust(aria2, termwiseType, [], userInfo, scheme, downP, callback); //调用自身
  3729. });
  3730. }else
  3731. { //这个作品全部跳过的时候
  3732. if (downP) downP.progress.set((downP.current = downP.max) / downP.max); //直接加上所有页数
  3733. sendToAria2_illust(aria2, termwiseType, [], userInfo, scheme, downP, callback); //调用自身
  3734. }
  3735. return;
  3736. }
  3737. }
  3738. //作品每页循环递归输出
  3739. function sendToAria2_Page(aria2, illust, page, userInfo, scheme, downP, callback) {
  3740. if (pubd.downbreak) {
  3741. GM_notification({text:"已中断向Aria2发送下载信息。但Aria2本身仍未停止下载已添加内容,请手动停止。", title:scriptName, image:scriptIcon});
  3742. pubd.downbreak = false;
  3743. return;
  3744. }
  3745. var page_count = illust.page_count;
  3746. if (illust.type == "ugoira" && illust.ugoira_metadata) //动图的帧数当页数
  3747. {
  3748. page_count = illust.ugoira_metadata.frames.length;
  3749. }
  3750. if (limitingFilenameExp.test(illust.filename)) //无法查看的文件,直接把page加到顶
  3751. {
  3752. page = page_count;
  3753. downP.progress.set((downP.current += page_count) / downP.max); //直接加上所有页数
  3754. }
  3755. if (page >= page_count) //本作品页数已经完毕
  3756. {
  3757. callback();
  3758. return;
  3759. }
  3760. var url = getIllustDownUrl(scheme, userInfo, illust, page);
  3761.  
  3762. if (returnLogicValue(scheme.downfilter, userInfo, illust, page)) {
  3763. //跳过此次下载
  3764. downP.progress.set(++downP.current / downP.max); //设置进度
  3765. sendToAria2_Page(aria2, illust, ++page, userInfo, scheme, downP, callback); //递归调用自身
  3766. //console.info("符合下载过滤器定义,跳过下载:", illust);
  3767. } else {
  3768. var options = {
  3769. "out": pathSafe(showMask(scheme.savepath, scheme.masklist, userInfo, illust, page), 'pathWithoutDriver'),
  3770. "referer": Referer,
  3771. "user-agent": UA,
  3772. };
  3773.  
  3774. if (scheme.savedir.length > 0) {
  3775. options.dir = pathSafe(showMask(scheme.savedir, scheme.masklist, userInfo, illust, page), 'path');
  3776. }
  3777. if (scheme.proxyurl.length > 0) {
  3778. options["all-proxy"] = scheme.proxyurl;
  3779. }
  3780. aria2.addUri(url, options, function(res) {
  3781. if (res === false) {
  3782. alert("发送到指定的Aria2失败,请检查到Aria2连接是否正常。");
  3783. return;
  3784. }
  3785. downP.progress.set(++downP.current / downP.max); //设置进度
  3786. sendToAria2_Page(aria2, illust, ++page, userInfo, scheme, downP, callback); //递归调用自身
  3787. });
  3788. }
  3789. }
  3790. //返回掩码值
  3791. function showMask(oldStr, maskList, user, illust, page) {
  3792. //ES6原生模式,将来再启用
  3793. /*const cm = function(maskName) //customMask
  3794. {
  3795. const cusMask = maskList.find(mask=>mask.name == maskName);
  3796. if (cusMask) { //如果有对应的自定义掩码
  3797. if (returnLogicValue(cusMask.logic, user, illust, page)) //mask的逻辑判断
  3798. return eval("`" + cusMask.content +"`"); //递归
  3799. else
  3800. return "";
  3801. }
  3802. }
  3803. let newStr = eval("`" + oldStr +"`"); //需要解决旧有路径里\右斜杠的问题*/
  3804.  
  3805. //以下均为传统掩码
  3806. var newStr = oldStr;
  3807. //var pattern = "%{([^}]+)}"; //旧的,简单匹配
  3808. var regPattern = "%{(.*?(?:[^\\\\](?:\\\\{2})+|[^\\\\]))}"; //新的,支持转义符
  3809. var regResult = null;
  3810.  
  3811. /* jshint ignore:start */
  3812.  
  3813. //不断循环直到没有掩码
  3814. while ((regResult = new RegExp(regPattern).exec(newStr)) != null) {
  3815. var mskO = regResult[0], //包含括号的原始掩码
  3816. mskN = regResult[1]; //去掉掩码括号
  3817. if (mskN != undefined) {
  3818. //去掉转义符的掩码名
  3819. mskN = (mskN != undefined) ? mskN.replace(/\\{/ig, "{").replace(/\\}/ig, "}").replace(/\\\\/ig, "\\") : null;
  3820. //搜寻自定义掩码
  3821. var cusMask = maskList.find(mask=>mask.name == mskN);
  3822. if (cusMask) { //如果有对应的自定义掩码
  3823. try {
  3824. if (returnLogicValue(cusMask.logic, user, illust, page)) //mask的逻辑判断
  3825. newStr = newStr.replace(mskO, cusMask.content);
  3826. else
  3827. newStr = newStr.replace(mskO, "");
  3828. } catch (e) {
  3829. console.error(mskO + " 自定义掩码出现了异常情况", e);
  3830. }
  3831. } else { //普通掩码
  3832. try {
  3833. var evTemp = eval(mskN);
  3834. if (evTemp != undefined)
  3835. newStr = newStr.replace(mskO, evTemp.toString());
  3836. else
  3837. newStr = newStr.replace(mskO, "");
  3838. } catch (e) {
  3839. newStr = newStr.replace(mskO, "");
  3840. console.error(mskO + " 掩码出现了异常情况", e);
  3841. }
  3842. }
  3843. }
  3844. }
  3845. /* jshint ignore:end */
  3846.  
  3847. return newStr;
  3848. }
  3849. //返回逻辑值
  3850. function returnLogicValue(logic, user, illust, page) {
  3851. try {
  3852. if (logic.length == 0) return false;
  3853. /* jshint ignore:start */
  3854. const evTemp = Boolean(eval(logic));
  3855. /* jshint ignore:end */
  3856. return evTemp;
  3857. } catch (e) {
  3858. console.error("逻辑运算出现了异常情况,逻辑内容:","(" + logic + ")", e);
  3859. return false;
  3860. }
  3861. }
  3862. /**
  3863. * 去除不可用的字符,替换为可以使用的安全路径字符串
  3864. * @param {string} str 输入路径字符串
  3865. * @param {'basic' | 'path' | 'pathWithoutDriver' | 'filename' | 'fn'} type 去除不可用字符串的形式,是路径还是文件名
  3866. * @param {string} newChar 被替换为的字符
  3867. * @returns {string} 安全路径字符串
  3868. */
  3869. function pathSafe(str = "", type = "path", newChar = "") { //去除Windows下无法作为文件名的字符,目前为了支持Linux暂不替换两种斜杠吧。
  3870. let nstr = str.toString(); //新字符
  3871. nstr = nstr.replace(/\u0000-\u001F\u007F-\u00A0/ig, ""); //一定去除所有的控制字符,已包含\r \n
  3872. switch(type) {
  3873. case "path": { //只替换路径中不能出现的字符,包括除了第一个盘符以外的其他任何
  3874. nstr = nstr.replace(/["<>\|\*\?]|(?<!^\w):/ig, newChar);
  3875. break;
  3876. }
  3877. case "pathWithoutDriver": { //只替换路径中不能出现的字符,包括除了第一个盘符以外的其他任何
  3878. nstr = nstr.replace(/["<>\|\*\?:]/ig, newChar);
  3879. break;
  3880. }
  3881. case "fn": case "filename": { //替换所有Windows名内不能出现的字符
  3882. nstr = nstr.replace(/["<>\|:\*\?\\/]/ig, newChar); //只替换路径中完全不能出现的特殊字符
  3883. break;
  3884. }
  3885. }
  3886. return nstr;
  3887. }
  3888. //主引导程序
  3889. function Main(touch) {
  3890. if (!mdev) { //不是开发模式时加载CSS资源
  3891. let css = GM_getResourceText("pubd-style");
  3892. if (css.includes('@-moz-document')) {
  3893. let cssStart = css.indexOf("{", css.indexOf('domain("www.pixiv.net")'))+1,
  3894. cssEnd = css.lastIndexOf("}");
  3895. css = css.substring(cssStart, cssEnd);
  3896. }
  3897. GM_addStyle(css);
  3898. }
  3899.  
  3900. //删除以前储存的账号密码
  3901. let cfgVer = GM_getValue("pubd-configversion");
  3902. if (cfgVer && cfgVer < pubd.configVersion)
  3903. {
  3904. GM_deleteValue("pubd-auth");
  3905. }
  3906.  
  3907. //载入设置
  3908. pubd.oAuth = new oAuth2(GM_getValue("pubd-oauth"));
  3909.  
  3910. pubd.downSchemes = NewDownSchemeArrayFromJson(getValueDefault("pubd-downschemes",[]));
  3911. //对下载方案的修改添加监听
  3912. GM_addValueChangeListener("pubd-downschemes", function(name, old_value, new_value, remote) {
  3913. pubd.downSchemes = NewDownSchemeArrayFromJson(new_value); //重新读取下载方案(可能被其他页面修改的)
  3914. });
  3915. //快速收藏列表的监听修改
  3916. //pubd.fastStarList = getValueDefault("pubd-faststar-list",[]);
  3917. pubd.fastStarList = new UsersStarList("快速收藏",getValueDefault("pubd-faststar-list",[]));
  3918. GM_addValueChangeListener("pubd-faststar-list", function(name, old_value, new_value, remote) {
  3919. pubd.fastStarList = null;
  3920. pubd.fastStarList = new UsersStarList("快速收藏",getValueDefault("pubd-faststar-list",[]));
  3921. if (mdev) console.log('收藏有变化',pubd.fastStarList.users);
  3922. checkStar();
  3923.  
  3924. //更改推荐列表里的收藏显示状态
  3925. refreshRecommendListState();
  3926. //将来还需要在更改收藏时,就自动刷新所有的其他推荐列表
  3927. //put my code
  3928. });
  3929.  
  3930. //登录信息的监听修改
  3931. GM_addValueChangeListener("pubd-oauth", function(name, old_value, new_value, remote) {
  3932. pubd.oAuth = new oAuth2(new_value);
  3933. });
  3934.  
  3935. //预先添加所有视窗,即便没有操作按钮也能通过菜单打开
  3936. let fragment = document.createDocumentFragment();
  3937. pubd.dialog.config = fragment.appendChild(buildDlgConfig());
  3938. pubd.dialog.login = fragment.appendChild(buildDlgLogin());
  3939. pubd.dialog.refresh_token = fragment.appendChild(buildDlgRefreshToken());
  3940. pubd.dialog.downthis = fragment.appendChild(buildDlgDownThis(thisPageUserid));
  3941. pubd.dialog.downillust = fragment.appendChild(buildDlgDownIllust(thisPageIllustid));
  3942. pubd.dialog.importdata = fragment.appendChild(buildDlgImportData());
  3943. pubd.dialog.multiple = fragment.appendChild(buildDlgMultiple());
  3944.  
  3945. let btnDlgInsertPlace = document.body; //视窗插入点,直接插入到body就行
  3946. btnDlgInsertPlace.appendChild(fragment);
  3947. //添加Tampermonkey扩展菜单内的入口
  3948. GM_registerMenuCommand("PUBD-选项", function(){
  3949. pubd.dialog.config.show(
  3950. (document.body.clientWidth - 400)/2,
  3951. window.scrollY+50
  3952. );
  3953. });
  3954. GM_registerMenuCommand("PUBD-下载该画师", function(){
  3955. pubd.dialog.downthis.show(
  3956. (document.body.clientWidth - 440)/2,
  3957. window.scrollY+100,
  3958. {id:getCurrentUserId()}
  3959. );
  3960. });
  3961.  
  3962. if (mdev)
  3963. GM_registerMenuCommand("PUBD-导入窗口测试", function(){
  3964. pubd.dialog.importdata.show(
  3965. (document.body.clientWidth - 370)/2,
  3966. window.scrollY+200,
  3967. {callback:function(txt){
  3968. const importArr = txt.split("\n");
  3969. const needAddArr = importArr.map(str=>{
  3970. let res = null;
  3971. if (
  3972. Boolean(res = new RegExp("^(\\d+)$","ig").exec(str)) ||
  3973. Boolean(res = new RegExp("member.+?\\?id=(\\d+)","ig").exec(str)) ||
  3974. Boolean(res = new RegExp("users/(\\d+)","ig").exec(str))
  3975. )
  3976. {
  3977. return parseInt(res[1],10);
  3978. }else
  3979. {
  3980. if (str.length>0)
  3981. console.log("未知的字符串",str);
  3982. return null;
  3983. }
  3984. }).filter(Boolean);
  3985. console.log(needAddArr);
  3986. if (needAddArr.length>0)
  3987. {
  3988. console.log(`新增了${needAddArr.length}个收藏`);
  3989. pubd.fastStarList.importArray(needAddArr);
  3990. GM_setValue("pubd-faststar-list",pubd.fastStarList.exportArray());
  3991. }
  3992. }}
  3993. );
  3994. });
  3995.  
  3996.  
  3997. //建立开始按钮
  3998. const btnStartBox = document.createElement("div");
  3999. btnStartBox.className = "pubd-btnStartInsertPlace";
  4000. pubd.start = btnStartBox.appendChild(buildbtnStart());
  4001. pubd.menu = btnStartBox.appendChild(buildbtnMenu());
  4002. //添加开始按钮,开始按钮内容直接固定为 btnStartBox
  4003. function insertStartBtn(btnStartInsertPlace)
  4004. {
  4005. if (btnStartInsertPlace == undefined)
  4006. {
  4007. console.error("PUBD:未找到开始按钮插入点。");
  4008. return false;
  4009. }else
  4010. {
  4011. if (/^\/artworks\//i.test(location.pathname)) //如果是作品页面,显示下载当前作品按钮
  4012. {
  4013. pubd.menu.downillust.classList.remove("display-none");
  4014. downIllustMenuId = GM_registerMenuCommand("PUBD-下载该作品", function(){
  4015. pubd.dialog.downillust.show(
  4016. (document.body.clientWidth - 500)/2,
  4017. window.scrollY+150,
  4018. {id:getQueryString('illust_id',
  4019. pubd.touch ?
  4020. mainDiv.querySelector('.illust-details-content .work-stats>a') : //手机版
  4021. mainDiv.querySelector(artWorkStarCssPath) //新版Vue结构
  4022. )}
  4023. );
  4024. });
  4025. }else
  4026. {
  4027. pubd.menu.downillust.classList.add("display-none");
  4028. GM_unregisterMenuCommand(downIllustMenuId);
  4029. }
  4030. checkStar(); //检查是否有收藏
  4031. //插入开始操作按钮
  4032. btnStartInsertPlace.appendChild(btnStartBox);
  4033. console.log("PUBD:网页发生变动,已重新呈现开始按钮。 %o", btnStartBox);
  4034. return true;
  4035. }
  4036. }
  4037.  
  4038. /*
  4039. 手机版网页的root
  4040. #spa-contents 会被删掉重新添加,所以只能用更上一层
  4041. */
  4042. const vueRoot = document.querySelector("#root"); //vue框架的root div
  4043. const wrapper = document.querySelector("#wrapper"); //仍然少量存在的老板页面
  4044. const touchRoot = wrapper ? wrapper.querySelector("#contents") : null;
  4045. if (window.MutationObserver && (vueRoot || touch)) //如果支持MutationObserver,且是vue框架
  4046. {
  4047. let reInsertStart = true; //是否需要重新插入开始按钮
  4048. let changeIllustUser = new MutationObserver(function(mutationsList, observer) {
  4049. if (mdev) console.log("作者链接 href 改变了",mutationsList);
  4050. checkStar();
  4051. });
  4052. let observerLoop = new MutationObserver(function(mutationsList, observer) {
  4053. const removedNodes = mutationsList.flatMap(mutation=>[...mutation.removedNodes]);
  4054. //const addNodes = mutationsList.flatMap(mutation=>[...mutation.addNodes]);
  4055. //当在P站首页的时候,不需要生效
  4056. if (location.pathname.substring(1).length == 0) {
  4057. console.log("PUBD:P站首页不需要执行。");
  4058. return;
  4059. }
  4060.  
  4061. //如果被删除的节点里有我们的开始按钮,就重新插入;或者搜索列表被删除
  4062. if (removedNodes.some(node=>node.contains(btnStartBox)))
  4063. {
  4064. console.log('已经添加的开始按钮因为页面改动被删除了');
  4065. mainDiv = null;
  4066. reInsertStart = true;
  4067. }
  4068.  
  4069. //搜索新的主div并插入开始按钮
  4070. if (reInsertStart)
  4071. {
  4072. for (const node of (touch ? touchRoot : subRoot).children) {
  4073. if (recommendList = node.querySelector(searchListCssPath)) {//如果是搜索结果界面而非用户/作品界面
  4074. mainDiv = node; //重新选择主div
  4075. if (mdev) console.debug("mainDiv 为 %o,搜索列表为 %o,", mainDiv, recommendList);
  4076. reInsertStart = false;
  4077. break;
  4078. } else {
  4079. const foundStartBtn = mainDivSearchCssSelector.some(entry => {
  4080. let btnStartInsertPlace,
  4081. cssS = entry.selectors,
  4082. fallcack = entry.fallcack;
  4083. try {
  4084. btnStartInsertPlace = node.querySelector(cssS);
  4085. } catch (e) {
  4086. if (mdev) console.error(`${cssS} 获取开始按钮容器异常`, e);
  4087. if (typeof fallcack === 'function') {
  4088. if (mdev) console.debug('尝试使用配置的 fallcack 重新获取');
  4089. btnStartInsertPlace = fallcack(node);
  4090. } else {
  4091. if (mdev) console.debug('未配置 fallcack 无法获取');
  4092. }
  4093. }
  4094. if(btnStartInsertPlace) {
  4095. mainDiv = node; //重新选择主div
  4096. if (mdev) console.debug("mainDiv 为 %o ,始按钮插入点条目为 %o",mainDiv,entry);
  4097. reInsertStart = !insertStartBtn(btnStartInsertPlace); //插入开始按钮
  4098. const userHeadLink = mainDiv.querySelector(artWorkUserHeadCssPath);
  4099. if (userHeadLink) //如果是作品页面
  4100. {
  4101. changeIllustUser.observe(userHeadLink, {attributeFilter:["href"]});
  4102. }
  4103. return true;
  4104. }else return false;
  4105. })
  4106. if (foundStartBtn) break; //如果插入了开始按钮,就退出循环
  4107. }
  4108. }
  4109. }
  4110.  
  4111. //作品页面显示推荐的部分
  4112. let otherWorks;
  4113. if (!recommendList && (otherWorks = subRoot.querySelector(".gtm-illust-recommend-zone") || subRoot.querySelector("section h3")?.parentElement?.parentElement?.parentElement))
  4114. { //已发现推荐列表大部位
  4115. if (recommendList = otherWorks.querySelector(":scope ul"))
  4116. {
  4117. if (mdev) console.log("发现推荐列表 %o", recommendList);
  4118. refreshRecommendListState();
  4119. }
  4120. }
  4121. if (recommendList)
  4122. {
  4123. //如果有新增,就重新刷新已收藏选中状态
  4124. if (mutationsList.some(mutation=>mutation.target==recommendList && mutation.addedNodes.length))
  4125. refreshRecommendListState();
  4126. if (removedNodes.some(node=>node.contains(recommendList)))
  4127. { //如果被删除的节点里有推荐列表,重新标空
  4128. if (mdev) console.log('推荐列表被删除了');
  4129. recommendList = null;
  4130. }
  4131. }
  4132. });
  4133. //只执行一次的,插找P站新的根节点的位置
  4134. let observerFindSubRoot = new MutationObserver(function(mutationsList, observer) {
  4135. for (const mutation of mutationsList) {
  4136. for (const node of mutation.addedNodes) {
  4137. if(!node.id){ //如果 root 下新增没有 id 的 node,就开始处理
  4138. //一直循环到下面有多个 node 时,当作子root,否则继续往下。
  4139. subRoot = node;
  4140. while (subRoot.childNodes.length == 1) {
  4141. subRoot = subRoot.childNodes[0];
  4142. }
  4143. if (mdev) console.log("subRoot 为 %o", subRoot);
  4144. observer.disconnect();
  4145. observerLoop.observe(subRoot, {childList:true, subtree:true});
  4146. return;
  4147. }else continue;
  4148. }
  4149. }
  4150. });
  4151. if (vueRoot) {
  4152. observerFindSubRoot.observe(vueRoot, {childList:true, subtree:false});
  4153. } else {
  4154. observerLoop.observe(touchRoot, {childList:true, subtree:true});
  4155. }
  4156. }else if(vueRoot == undefined)
  4157. {
  4158. if (wrapper) //仍然少量存在的老板页面
  4159. {
  4160. console.log('PUBD:你访问的是仍然少量存在的老板页面。');
  4161. insertStartBtn(document.querySelector("._user-profile-card")) || //老版用户资料页
  4162. insertStartBtn(document.querySelector(".ui-layout-west aside")) || //老版作品页
  4163. insertStartBtn(document.querySelector(".introduction")) //老版未登录页面
  4164. ;
  4165. }else
  4166. {
  4167. console.log('PUBD:未找到 root div,可能P站又改版了,程序得修改。');
  4168. }
  4169. }else
  4170. {
  4171. alert('PUBD:您的浏览器不支持 MutationObserver,请使用最新浏览器。');
  4172. }
  4173. }
  4174.  
  4175. Main(pubd.touch); //开始主程序
  4176. })();