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

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

当前为 2023-08-09 提交的版本,查看 最新版本

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

QingJ © 2025

镜像随时可能失效,请加Q群300939539或关注我们的公众号极客氢云获取最新地址