@nger/fk-upload 1.0.32 → 1.0.35

package/dist/templates/tasks/actions.d.ts

@@ -0,0 +1,38 @@
+import { StringToken } from "@nger/core";
+export interface IDownloadTask {
+    filename: string;
+    path: string;
+    url: string;
+    topicId: number;
+    loginId: number;
+}
+export declare const DOWNLOAD_ACTION: StringToken<IDownloadTask>;
+export interface IScheduleTask {
+    name: string;
+    rule: string;
+}
+export declare const SCHEDULE_ACTION: StringToken<IScheduleTask>;
+export interface IUploadTask {
+    filename: string;
+    path: string;
+    uploadUrl: string;
+    total: number;
+    cookies: string;
+    aid: number;
+    folderId: number;
+    fileMd5: string;
+    splitSize: number;
+    totalChunks: number;
+    topicId: number;
+    token: string;
+    start: number;
+    loginId: number;
+    index: number;
+}
+export declare const UPLOAD_ACTION: StringToken<IUploadTask>;
+export interface IEffectTask {
+    filename: string;
+    uploadUrl: string;
+    topicId: number;
+}
+export declare const EFFECT_ACTION: StringToken<IEffectTask>;

package/dist/templates/tasks/actions.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EFFECT_ACTION = exports.UPLOAD_ACTION = exports.SCHEDULE_ACTION = exports.DOWNLOAD_ACTION = void 0;
+exports.DOWNLOAD_ACTION = `@nger/fk-upload/download-task`;
+exports.SCHEDULE_ACTION = `@nger/fk-upload/schedule-task`;
+exports.UPLOAD_ACTION = `@nger/fk-upload/upload-task`;
+exports.EFFECT_ACTION = `@nger/fk-upload/effect-task`;

package/dist/templates/tasks/create-download-task.d.ts

@@ -0,0 +1,12 @@
+import { Injector } from '@nger/core';
+import { Db } from '@nger/typeorm';
+import { DownloadTask } from '../task-types';
+import { RabbitMqService } from '@nger/rabbitmq';
+export declare class CreateDownloadTask {
+    private injector;
+    private db;
+    private rabbit;
+    constructor(injector: Injector, db: Db, rabbit: RabbitMqService);
+    createDownLoadTask(url: string, fkLoginId: number, topicId: number): Promise<void>;
+    addDownloadTask(task: DownloadTask): Promise<void>;
+}

package/dist/templates/tasks/create-download-task.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateDownloadTask = void 0;
+const core_1 = require("@nger/core");
+const cids_1 = __importDefault(require("cids"));
+const fs_extra_1 = require("fs-extra");
+const multihashing_async_1 = __importDefault(require("multihashing-async"));
+const path_1 = require("path");
+const entities_1 = require("../../entities");
+const typeorm_1 = require("@nger/typeorm");
+const rabbitmq_1 = require("@nger/rabbitmq");
+let CreateDownloadTask = class CreateDownloadTask {
+    injector;
+    db;
+    rabbit;
+    constructor(injector, db, rabbit) {
+        this.injector = injector;
+        this.db = db;
+        this.rabbit = rabbit;
+    }
+    async createDownLoadTask(url, fkLoginId, topicId) {
+        const hash = await (0, multihashing_async_1.default)(Buffer.from(url), 'sha1', 16);
+        const cid = new cids_1.default(1, 'raw', hash, 'base64');
+        let filename = encodeURIComponent(cid.toString('base64'));
+        const _url = new URL(url);
+        const filePath = _url.pathname;
+        let ext = (0, path_1.extname)(filePath);
+        filename += ext === '.' ? '.mp4' : ext;
+        const task = new entities_1.FkDownloadTaskEntity();
+        const root = this.injector.get(core_1.APP_ROOT);
+        (0, fs_extra_1.ensureDirSync)((0, path_1.join)(root, 'attachments/fk-upload'));
+        const path = (0, path_1.join)(root, 'attachments/fk-upload', filename);
+        task.filename = filename;
+        task.url = url;
+        task.loginId = fkLoginId;
+        task.totalSize = 0;
+        task.path = path;
+        task.status = 0;
+        task.size = 0;
+        task.topicId = topicId;
+        await this.db.manager.save(task);
+        return this.addDownloadTask(task);
+    }
+    async addDownloadTask(task) {
+        const content = Buffer.from(JSON.stringify(task));
+        await this.rabbit.send('@nger/fk-upload/download-task', content);
+    }
+};
+CreateDownloadTask = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.Injector, typeorm_1.Db, rabbitmq_1.RabbitMqService])
+], CreateDownloadTask);
+exports.CreateDownloadTask = CreateDownloadTask;

package/dist/templates/tasks/download-task.d.ts

@@ -0,0 +1,10 @@
+import { Task } from "@nger/rabbitmq";
+import { Injector, Next } from "@nger/core";
+/**
+ * upload and task
+ */
+export declare class DownloadTask extends Task {
+    constructor();
+    handle(injector: Injector, next?: Next): Promise<void>;
+    private createUploadTask;
+}

package/dist/templates/tasks/download-task.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadTask = void 0;
+const rabbitmq_1 = require("@nger/rabbitmq");
+const actions_1 = require("./actions");
+const request_1 = require("request");
+const fs_1 = require("fs");
+const fk_service_1 = require("./fk.service");
+const md5_file_1 = __importDefault(require("md5-file"));
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const typeorm_1 = require("@nger/typeorm");
+const entities_1 = require("../../entities");
+/**
+ * upload and task
+ */
+class DownloadTask extends rabbitmq_1.Task {
+    constructor() {
+        super(actions_1.DOWNLOAD_ACTION);
+    }
+    async handle(injector, next) {
+        const task = injector.get(rabbitmq_1.DATA);
+        const complete = injector.get(rabbitmq_1.COMPLETE);
+        const fail = injector.get(rabbitmq_1.FAIL);
+        (0, fs_extra_1.ensureDir)((0, path_1.dirname)(task.path));
+        const writeStream = (0, fs_1.createWriteStream)(task.path);
+        const manager = injector.get(rabbitmq_1.TaskManager);
+        const url = task.url.startsWith('http') ? task.url : `https://${task.url}`;
+        const req = (0, request_1.get)(url, {
+            headers: {
+                'Content-Type': 'application/octet-stream'
+            }
+        });
+        let length = 0;
+        let total = 0;
+        let md5 = ``;
+        // get split size
+        req.on('data', (buf) => {
+            length += buf.length;
+            writeStream.write(buf, (err) => {
+                if (err)
+                    fail();
+            });
+        });
+        req.on('end', async () => {
+            writeStream.end();
+            const fileMd5 = await (0, md5_file_1.default)(task.path);
+            const isEqual = md5 === fileMd5;
+            console.log(`file download success ${task.filename}, check result is ${isEqual}`);
+            const uploadTask = await this.createUploadTask(task, total, fileMd5, injector);
+            await manager.send(uploadTask);
+            complete();
+        });
+        req.on('response', async (resp) => {
+            const headers = resp.headers;
+            total = Number(headers["content-length"]);
+            md5 = headers.etag;
+            md5 = md5.replaceAll('"', '');
+        });
+        if (next)
+            await next();
+    }
+    async createUploadTask(download, total, md5, injector) {
+        const db = injector.get(typeorm_1.Db);
+        await db.manager.update(entities_1.FkDownloadTaskEntity, download.filename, { status: 1, size: total });
+        const fk = injector.get(fk_service_1.FkService);
+        const info = await fk.getUploadInfo(download.loginId, download.filename, md5, total);
+        if (info) {
+            const totalChunks = Math.ceil(total / info.splitSize) - 1;
+            const uploadTask = new rabbitmq_1.TaskEntity();
+            uploadTask.topic = actions_1.UPLOAD_ACTION;
+            const data = {
+                filename: download.filename,
+                path: download.path,
+                total: total,
+                splitSize: info.splitSize,
+                totalChunks,
+                uploadUrl: info.uploadUrl,
+                cookies: info.cookies,
+                topicId: download.topicId,
+                token: info.token,
+                aid: info.aid,
+                folderId: info.uploadGroupId,
+                fileMd5: md5,
+                start: info.uploadedSize,
+                loginId: download.loginId,
+                index: Math.ceil(info.uploadedSize / info.splitSize)
+            };
+            uploadTask.data = data;
+            return uploadTask;
+        }
+        throw new Error(`get upload info fail`);
+    }
+}
+exports.DownloadTask = DownloadTask;

package/dist/templates/tasks/effect-task.d.ts

@@ -0,0 +1,6 @@
+import { Task } from "@nger/rabbitmq";
+import { Next, Injector } from "@nger/core";
+export declare class EffectTask extends Task {
+    constructor();
+    handle(injector: Injector, next?: Next): Promise<void>;
+}

package/dist/templates/tasks/effect-task.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectTask = void 0;
+const rabbitmq_1 = require("@nger/rabbitmq");
+const actions_1 = require("./actions");
+const typeorm_1 = require("@nger/typeorm");
+const w7_1 = require("@nger/w7");
+const entities_1 = require("../../entities");
+class EffectTask extends rabbitmq_1.Task {
+    constructor() {
+        super(actions_1.EFFECT_ACTION);
+    }
+    async handle(injector, next) {
+        const task = injector.get(rabbitmq_1.DATA);
+        const complete = injector.get(rabbitmq_1.COMPLETE);
+        const fail = injector.get(rabbitmq_1.FAIL);
+        const w7 = injector.get(w7_1.W7DataSource);
+        const db = injector.get(typeorm_1.Db);
+        if (task.topicId) {
+            await db.manager.update(entities_1.FkDownloadTaskEntity, task.filename, { status: 3, uploadUrl: task.uploadUrl });
+            await w7.manager.update(w7_1.W7ChatTopicEntity, task.topicId, { thirdUrl: task.uploadUrl }).then(() => complete()).catch(() => fail());
+        }
+        else {
+            complete();
+        }
+        if (next)
+            await next();
+    }
+}
+exports.EffectTask = EffectTask;

package/dist/templates/tasks/fk.service.d.ts

@@ -0,0 +1,26 @@
+import { Db } from "@nger/typeorm";
+import { FkLoginCookieEntity, FkLoginEntity } from "../../entities";
+import { IUploadTask } from "./actions";
+export declare class FkService {
+    private db;
+    constructor(db: Db);
+    getFkLogin(loginId: number): Promise<FkLoginEntity>;
+    getFkLoginCookie(loginId: number): Promise<FkLoginCookieEntity[]>;
+    createCookieStr(cookies: FkLoginCookieEntity[]): string;
+    getCookieStr(loginId: number): Promise<string>;
+    getToken(cookie: string): Promise<string>;
+    getAccessToken(token: string): Promise<any>;
+    private encodeURIComponent;
+    getUploadUrl(token: any, forceDirect?: boolean): string;
+    getUploadInfo(loginId: number, filename: string, fileMd5: string, totalSize: number): Promise<any>;
+    startUploadFile(task: IUploadTask): Promise<IUploadTask>;
+    uploadFile(task: IUploadTask): Promise<IUploadTask>;
+    getBssInfo(): {
+        fromSite: boolean;
+        siteId: number;
+        groupId: number;
+        fileSizeLimit: number;
+    };
+    getUploadInfourl(accessToken: any): string;
+    private decode;
+}

package/dist/templates/tasks/fk.service.js

@@ -0,0 +1,228 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FkService = void 0;
+const typeorm_1 = require("@nger/typeorm");
+const entities_1 = require("../../entities");
+const axios_1 = __importDefault(require("axios"));
+const core_1 = require("@nger/core");
+const fs_extra_1 = require("fs-extra");
+const form_data_1 = __importDefault(require("form-data"));
+let FkService = class FkService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getFkLogin(loginId) {
+        return await this.db.manager.findOneOrFail(entities_1.FkLoginEntity, { where: { fkLoginId: loginId } });
+    }
+    async getFkLoginCookie(loginId) {
+        return await this.db.manager.find(entities_1.FkLoginCookieEntity, { where: { fkLoginId: loginId } });
+    }
+    createCookieStr(cookies) {
+        return cookies.map(cookie => `${cookie.key}=${cookie.value}`).join(';');
+    }
+    async getCookieStr(loginId) {
+        const cookies = await this.getFkLoginCookie(loginId);
+        const cookie = this.createCookieStr(cookies);
+        return cookie;
+    }
+    async getToken(cookie) {
+        const url = `https://i.vip.webportal.top/`;
+        const iVipWebPortal = await axios_1.default.get(url, {
+            headers: {
+                Cookie: cookie
+            }
+        }).then(res => res.data);
+        const items = iVipWebPortal.match(/<meta id='_TOKEN' value='(.*?)'\/>/);
+        let token = ``;
+        if (items && items.length === 2) {
+            token = items[1];
+        }
+        return token;
+    }
+    async getAccessToken(token) {
+        const url = `https://smr00.vip.webportal.top/cn/api/manage/advanceUpload/genAccessKey?_v=${new Date().getTime()}&_TOKEN=${token}`;
+        const accessKey = await axios_1.default.get(url).then(res => res.data);
+        if (accessKey.success) {
+            const accessTokenString = this.decode(accessKey.accessKey);
+            if (accessTokenString) {
+                const accessToken = JSON.parse(accessTokenString);
+                return accessToken;
+            }
+        }
+    }
+    encodeURIComponent(data) {
+        if ((0, core_1.isPrimitive)(data)) {
+            return encodeURIComponent(data);
+        }
+        return Object.keys(data).map(key => {
+            const value = Reflect.get(data, key);
+            return `${key}=${encodeURIComponent(value)}`;
+        }).join('&');
+    }
+    getUploadUrl(token, forceDirect = true) {
+        if (forceDirect) {
+            return `https://${token.url}/${token.visitType}/${token.app}/upload?cmd=${token.cmd}&token=${token.token}`;
+        }
+        else {
+            return `https://${token.url}/${token.visitType}/${token.app}/advance?cmd=${token.cmd}&token=${token.token}`;
+        }
+    }
+    async getUploadInfo(loginId, filename, fileMd5, totalSize) {
+        // TODO: from redis cache
+        const login = await this.getFkLogin(loginId);
+        const cookies = await this.getCookieStr(loginId);
+        const bssInfo = this.getBssInfo();
+        const token = await this.getToken(cookies);
+        const accessToken = await this.getAccessToken(token);
+        const uploadInfoUrl = this.getUploadInfourl(accessToken);
+        const uploadUrl = this.getUploadUrl(accessToken, false);
+        const info = await axios_1.default.post(uploadInfoUrl, this.encodeURIComponent({
+            fileMd5: fileMd5,
+            fileSize: totalSize,
+            isFreeVer: false,
+            aid: login.aid,
+            folderId: login.uploadGroupId,
+            bssInfo: JSON.stringify(bssInfo),
+            fileName: filename
+        }), { headers: { cookie: cookies } }).then(res => res.data);
+        if (info.code === 200) {
+            return { ...info.data, uploadUrl, cookies, token, aid: login.aid, uploadGroupId: login.uploadGroupId };
+        }
+    }
+    async startUploadFile(task) {
+        const info = await this.getUploadInfo(task.loginId, task.filename, task.fileMd5, task.total);
+        task.cookies = info.cookies;
+        task.splitSize = info.splitSize;
+        task.start = info.uploadedSize;
+        task.uploadUrl = info.uploadUrl;
+        task.index = Math.ceil(info.uploadedSize / info.splitSize);
+        return await this.uploadFile(task);
+    }
+    async uploadFile(task) {
+        let complete = false;
+        const max = task.total - 1;
+        let index = task.index || 0;
+        do {
+            let start = index * task.splitSize;
+            if (start >= max) {
+                break;
+            }
+            let _end = start + task.splitSize - 1;
+            let end = _end > max ? max : _end;
+            if (end >= max) {
+                complete = true;
+            }
+            const fileStream = (0, fs_extra_1.createReadStream)(task.path, { start: start, end: end });
+            const formdata = new form_data_1.default();
+            formdata.append('ctrl', fileStream);
+            formdata.append('isFreeVer', this.encodeURIComponent(false));
+            formdata.append('aid', this.encodeURIComponent(task.aid));
+            formdata.append('folderId', this.encodeURIComponent(task.folderId));
+            formdata.append('fileName', task.filename);
+            formdata.append(`totalSize`, this.encodeURIComponent(task.total));
+            formdata.append(`fileMd5`, task.fileMd5);
+            formdata.append('index', this.encodeURIComponent(index));
+            formdata.append('chunkSize', this.encodeURIComponent(task.splitSize));
+            formdata.append('totalChunks', this.encodeURIComponent(task.totalChunks));
+            formdata.append(`complete`, this.encodeURIComponent(complete));
+            const bssInfo = {
+                fromSite: true, siteId: 0, groupId: 0, fileSizeLimit: 1024
+            };
+            formdata.append('bssInfo', JSON.stringify(bssInfo));
+            const headers = formdata.getHeaders();
+            const uploadResult = await axios_1.default.post(task.uploadUrl, formdata, {
+                headers: {
+                    ...headers,
+                    Cookie: task.cookies
+                },
+                timeout: 8000
+            }).then(res => {
+                // console.log(`upload success`, { data: res.data, start, end, index, total: task.totalChunks })
+                return res.data;
+            }).catch(async (e) => {
+                const info = await this.getUploadInfo(task.loginId, task.filename, task.fileMd5, task.total);
+                task.cookies = info.cookies;
+                task.splitSize = info.splitSize;
+                task.start = info.uploadedSize;
+                task.uploadUrl = info.uploadUrl;
+                task.index = Math.ceil(info.uploadedSize / info.splitSize);
+                await this.uploadFile(task);
+                return;
+            });
+            if (!uploadResult) {
+                complete = true;
+                break;
+            }
+            if (uploadResult) {
+                const data = uploadResult.data;
+                const downUrl = data.path;
+                if (downUrl) {
+                    const fullUrl = downUrl.startsWith('http') ? downUrl : `https:` + downUrl;
+                    task.uploadUrl = fullUrl;
+                }
+            }
+            index = index + 1;
+        } while (!complete);
+        // upload complete
+        axios_1.default.post(`https://smr00.vip.webportal.top/ajax/advanceUpload.jsp?cmd=_report&_TOKEN=${task.token}`, this.encodeURIComponent({
+            type: 1,
+            size: task.total,
+            time: NaN,
+            flag: true,
+            name: task.filename
+        }), {
+            headers: {
+                [`Content-Type`]: `application/x-www-form-urlencoded; charset=UTF-8`,
+                Cookie: task.cookies
+            }
+        });
+        return task;
+    }
+    getBssInfo() {
+        return {
+            fromSite: true, siteId: 0, groupId: 0, fileSizeLimit: 1024
+        };
+    }
+    getUploadInfourl(accessToken) {
+        return `https://${accessToken.url}/${accessToken.visitType}/${accessToken.app}/advance/info?cmd=${accessToken.cmd}&token=${accessToken.token}`;
+    }
+    decode(base64Str) {
+        if (!base64Str)
+            return;
+        const t = base64Str.replace(/_/g, "/").replace(/-/g, "+");
+        const f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+        let l = 0;
+        let p = 0;
+        let h = [];
+        do {
+            const o = f.indexOf(t.charAt(l++));
+            const u = f.indexOf(t.charAt(l++));
+            const a = f.indexOf(t.charAt(l++));
+            const c = f.indexOf(t.charAt(l++));
+            const s = o << 18 | u << 12 | a << 6 | c;
+            const e = s >> 16 & 255;
+            const r = s >> 8 & 255;
+            const n = 255 & s;
+            h[p++] = 64 === a ? String.fromCharCode(e) : 64 === c ? String.fromCharCode(e, r) : String.fromCharCode(e, r, n);
+        } while (l < t.length);
+        return h.join('');
+    }
+};
+FkService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.Db])
+], FkService);
+exports.FkService = FkService;

package/dist/templates/tasks/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/templates/tasks/providers.d.ts

@@ -0,0 +1,2 @@
+import { StaticProvider } from "@nger/core";
+export declare const tasksProviders: StaticProvider<any>[];

package/dist/templates/tasks/providers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tasksProviders = void 0;
+const rabbitmq_1 = require("@nger/rabbitmq");
+const download_task_1 = require("./download-task");
+const effect_task_1 = require("./effect-task");
+const schedule_task_1 = require("./schedule-task");
+const upload_task_1 = require("./upload-task");
+exports.tasksProviders = [{
+        provide: rabbitmq_1.Task,
+        useFactory: () => new download_task_1.DownloadTask(),
+        multi: true
+    }, {
+        provide: rabbitmq_1.Task,
+        useFactory: () => new schedule_task_1.ScheduleTask(),
+        multi: true
+    }, {
+        provide: rabbitmq_1.Task,
+        useFactory: () => new upload_task_1.UploadTask(),
+        multi: true
+    }, {
+        provide: rabbitmq_1.Task,
+        useFactory: () => new effect_task_1.EffectTask(),
+        multi: true
+    }];

package/dist/templates/tasks/receive-shedule-task.d.ts

@@ -0,0 +1,16 @@
+import { RabbitMqService } from "@nger/rabbitmq";
+import { RedisService } from "@nger/redis";
+import { ScheduleService } from "@nger/schedule";
+import { Db } from "@nger/typeorm";
+import { W7DataSource } from "@nger/w7";
+import { CreateDownloadTask } from "./create-download-task";
+export declare class ReceiveScheduleTask {
+    private rabbit;
+    private redis;
+    private schedule;
+    private db;
+    private w7;
+    private createDownloadTask;
+    constructor(rabbit: RabbitMqService, redis: RedisService, schedule: ScheduleService, db: Db, w7: W7DataSource, createDownloadTask: CreateDownloadTask);
+    receiveScheduleTask(runner: Function): Promise<void>;
+}

package/dist/templates/tasks/receive-shedule-task.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiveScheduleTask = void 0;
+const w7_1 = require("@nger/w7");
+const entities_1 = require("../../entities");
+const typeorm_1 = require("typeorm");
+class ReceiveScheduleTask {
+    rabbit;
+    redis;
+    schedule;
+    db;
+    w7;
+    createDownloadTask;
+    constructor(rabbit, redis, schedule, db, w7, createDownloadTask) {
+        this.rabbit = rabbit;
+        this.redis = redis;
+        this.schedule = schedule;
+        this.db = db;
+        this.w7 = w7;
+        this.createDownloadTask = createDownloadTask;
+    }
+    async receiveScheduleTask(runner) {
+        const obs = await this.rabbit.receive(`@nger/fk-upload/schedule-task`);
+        obs.subscribe({
+            next: async ([data, complete, fail]) => {
+                try {
+                    const task = JSON.parse(data);
+                    const setting = await this.redis.get(`setting`);
+                    if (!setting) {
+                        return complete();
+                    }
+                    if (task.name === setting.name) {
+                        console.log(`shedule job regist ${task.name}`);
+                        this.schedule.scheduleJob(task.name, task.rule, async (time) => {
+                            const accounts = await this.db.manager.find(entities_1.FkLoginEntity, {});
+                            const w7Usernames = accounts.map(account => account.w7Username);
+                            const users = await this.w7.manager.find(w7_1.W7UsersEntity, { where: { username: (0, typeorm_1.In)(w7Usernames) } });
+                            const uids = users.map(user => user.uid);
+                            const uniAccounts = await this.w7.manager.find(w7_1.W7UniAccountEntity, { where: { createUid: (0, typeorm_1.In)(uids) } });
+                            const uniacids = uniAccounts.map(a => a.uniacid);
+                            const tasks = await this.db.manager.find(entities_1.FkDownloadTaskEntity, { select: ['topicId'] });
+                            const ids = tasks.map(task => task.topicId);
+                            const topics = await this.w7.manager.find(w7_1.W7ChatTopicEntity, { where: { uniacid: (0, typeorm_1.In)(uniacids), id: (0, typeorm_1.Not)((0, typeorm_1.In)(ids)) } });
+                            topics.map(topic => {
+                                if (topic.thirdUrl) {
+                                    const uniacid = topic.uniacid;
+                                    const account = uniAccounts.find(a => a.uniacid === uniacid);
+                                    const user = users.find(u => u.uid === account.createUid);
+                                    const login = accounts.find(a => a.w7Username === user.username);
+                                    this.createDownloadTask.createDownLoadTask(topic.thirdUrl, login.fkLoginId, topic.id);
+                                }
+                            });
+                        });
+                    }
+                    else {
+                        complete();
+                    }
+                }
+                catch (e) {
+                    fail();
+                }
+            }
+        });
+    }
+}
+exports.ReceiveScheduleTask = ReceiveScheduleTask;

package/dist/templates/tasks/schedule-task.d.ts

@@ -0,0 +1,9 @@
+import { Task } from "@nger/rabbitmq";
+import { Injector, Next } from "@nger/core";
+/**
+ * finish
+ */
+export declare class ScheduleTask extends Task {
+    constructor();
+    handle(injector: Injector, next?: Next): Promise<void>;
+}