@soga/task 0.0.1 → 0.2.13

package/README.md

@@ -0,0 +1 @@
+# downloader

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+export * from './upload-task/create';
+export * from './upload-task/run';
+export * from './upload-task/create-affix';

package/dist/main.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./upload-task/create"), exports);
+__exportStar(require("./upload-task/run"), exports);
+__exportStar(require("./upload-task/create-affix"), exports);

package/dist/upload-task/create-affix.d.ts

@@ -0,0 +1,2 @@
+import { UploadFileParams } from './types';
+export declare const createUploadAffixTask: (params: UploadFileParams) => Promise<number>;

package/dist/upload-task/create-affix.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploadAffixTask = void 0;
+const types_1 = require("@soga/types");
+const fileinfo_1 = require("../utils/fileinfo");
+const path_1 = require("path");
+const sdk_1 = require("@soga/sdk");
+const entities_1 = require("@soga/entities");
+const createUploadAffixTask = async (params) => {
+    const sdk = (0, sdk_1.getSdk)(params.sdk_domain);
+    const userInfo = await sdk.getUserInfo({ refresh: false });
+    const { id: uid } = userInfo;
+    const { cloud_info, album } = await sdk.getRecordInfo({
+        space_id: params.space_id,
+        record_id: params.record_id,
+        refresh: true,
+    });
+    const config = {
+        file_keeps: album.config.file_keeps,
+    };
+    const { name: space_name } = await sdk.getSpaceInfo({
+        space_id: params.space_id,
+        refresh: true,
+    });
+    const aid = album.id;
+    let ali_host_id = 0;
+    let baidu_host_id = 0;
+    if (cloud_info[types_1.HostType.ALI]) {
+        ali_host_id = cloud_info[types_1.HostType.ALI].id;
+    }
+    if (cloud_info[types_1.HostType.BAIDU]) {
+        baidu_host_id = cloud_info[types_1.HostType.BAIDU].id;
+    }
+    const { paths } = params;
+    const { length } = paths;
+    const inputs = [];
+    for (let i = 0; i < length; i++) {
+        const filepath = paths[i];
+        const isValid = await (0, fileinfo_1.isValidPath)(filepath);
+        if (isValid) {
+            const fileinfo = await (0, fileinfo_1.getFileinfo)(filepath);
+            const { record_type } = fileinfo;
+            if (record_type == types_1.RecordType.FOLDER)
+                continue;
+            inputs.push({
+                filename: (0, path_1.basename)(filepath),
+                filepath,
+                filesize: fileinfo.size,
+                local_btime: fileinfo.local_btime,
+                local_ctime: fileinfo.local_ctime,
+                local_mtime: fileinfo.local_mtime,
+            });
+        }
+    }
+    const file = {
+        inputs,
+        space_id: params.space_id,
+        space_name,
+        filepath: '',
+        is_ready: true,
+        config,
+        uid,
+        aid,
+        baidu_host_id,
+        ali_host_id,
+        is_paused: false,
+        pid: 0,
+        root_id: 0,
+        total_count: 1,
+        type: types_1.RecordType.AFFIX,
+        task_record_id: params.record_id,
+        external_texts: [],
+    };
+    const fileRepository = params.dataSource.getRepository(entities_1.UploadFile);
+    const res = await fileRepository.save(fileRepository.create(file));
+    return res.id;
+};
+exports.createUploadAffixTask = createUploadAffixTask;

package/dist/upload-task/create.d.ts

@@ -0,0 +1,2 @@
+import { UploadFileParams } from './types';
+export declare const createUploadTask: (params: UploadFileParams) => Promise<void>;

package/dist/upload-task/create.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUploadTask = void 0;
+const fileinfo_1 = require("../utils/fileinfo");
+const types_1 = require("@soga/types");
+const path_1 = require("path");
+const sdk_1 = require("@soga/sdk");
+const entities_1 = require("@soga/entities");
+const utils_1 = require("./utils");
+const createUploadTask = async (params) => {
+    const sdk = (0, sdk_1.getSdk)(params.sdk_domain);
+    const userInfo = await sdk.getUserInfo({ refresh: false });
+    const { id: uid } = userInfo;
+    const { cloud_info, album } = await sdk.getRecordInfo({
+        space_id: params.space_id,
+        record_id: params.record_id,
+        refresh: true,
+    });
+    const config = {
+        file_keeps: album.config.file_keeps,
+    };
+    const keep_source = config.file_keeps == types_1.RecordFileKeep.SOURCE ||
+        config.file_keeps == types_1.RecordFileKeep.BOTH;
+    const { name: space_name } = await sdk.getSpaceInfo({
+        space_id: params.space_id,
+        refresh: true,
+    });
+    const aid = album.id;
+    let ali_host_id = 0;
+    let baidu_host_id = 0;
+    if (cloud_info[types_1.HostType.ALI]) {
+        ali_host_id = cloud_info[types_1.HostType.ALI].id;
+    }
+    if (cloud_info[types_1.HostType.BAIDU]) {
+        baidu_host_id = cloud_info[types_1.HostType.BAIDU].id;
+    }
+    const { paths } = params;
+    const files = [];
+    const folders = [];
+    const subtitles = [];
+    const medias = [];
+    const { length } = paths;
+    for (let i = 0; i < length; i++) {
+        const filepath = paths[i];
+        const isValid = await (0, fileinfo_1.isValidPath)(filepath);
+        if (isValid) {
+            const fileinfo = await (0, fileinfo_1.getFileinfo)(filepath);
+            const { record_type } = fileinfo;
+            const { dir, base, name } = (0, path_1.parse)(filepath);
+            const info = {
+                type: record_type,
+                title: name,
+                filename: base,
+                basepath: (0, path_1.join)(dir, name),
+                filepath: filepath,
+                filesize: fileinfo.size,
+                local_btime: fileinfo.local_btime,
+                local_ctime: fileinfo.local_ctime,
+                local_mtime: fileinfo.local_mtime,
+                parent_path: (0, path_1.dirname)(filepath),
+                file_type: 'file',
+            };
+            if (record_type == types_1.RecordType.FOLDER) {
+                folders.push(info);
+            }
+            else {
+                const is_media = record_type == types_1.RecordType.VIDEO || record_type == types_1.RecordType.AUDIO;
+                const is_subtitle = (0, fileinfo_1.isSubtitle)(filepath);
+                if (is_media) {
+                    const keywords = info.title
+                        .split(/[ _\-.{}[\]、,，。：:!?<>《》【】]+/g)
+                        .filter((k) => k.length >= 2);
+                    medias.push({
+                        ...info,
+                        file_type: 'media',
+                        keywords,
+                    });
+                }
+                else if (is_subtitle) {
+                    subtitles.push({
+                        ...info,
+                        file_type: 'subtitle',
+                    });
+                }
+                else {
+                    files.push(info);
+                }
+            }
+        }
+    }
+    const match_map = {};
+    let subs = [...subtitles];
+    medias.forEach((media) => {
+        const matched = (0, utils_1.matchSubtitles)(media, subs);
+        if (matched) {
+            media.external_texts = matched.map((item) => item.filepath);
+            matched.forEach((item) => (match_map[item.filepath] = true));
+            subs = subs.filter((item) => !match_map[item.filepath]);
+        }
+    });
+    let subtitle_queues = subtitles;
+    if (!keep_source) {
+        subtitle_queues = subtitles.filter((item) => !match_map[item.filepath]);
+    }
+    const queues = [...subtitle_queues, ...medias, ...files, ...folders].map((item) => {
+        const info = {
+            inputs: [
+                {
+                    filename: item.filename,
+                    filepath: item.filepath,
+                    filesize: item.filesize,
+                    local_btime: item.local_btime,
+                    local_ctime: item.local_ctime,
+                    local_mtime: item.local_mtime,
+                },
+            ],
+            filepath: item.filepath,
+            space_id: params.space_id,
+            space_name,
+            aid,
+            ali_host_id,
+            baidu_host_id,
+            config,
+            is_paused: false,
+            is_ready: item.type != types_1.RecordType.FOLDER,
+            type: item.type,
+            task_record_id: params.record_id,
+            uid,
+            total_count: item.type == types_1.RecordType.FOLDER ? undefined : 1,
+        };
+        if (item.file_type == 'media') {
+            info.external_texts = item.external_texts;
+        }
+        return info;
+    });
+    if (!queues.length) {
+        return;
+    }
+    const queryRunner = params.dataSource.createQueryRunner();
+    await queryRunner.connect();
+    await queryRunner.startTransaction();
+    try {
+        const fileRepository = queryRunner.manager.getRepository(entities_1.UploadFile);
+        const { length } = queues;
+        const size = 50;
+        for (let i = 0; i < length; i += size) {
+            const items = queues.slice(i, i + size);
+            await fileRepository
+                .createQueryBuilder()
+                .insert()
+                .into(entities_1.UploadFile)
+                .values(items)
+                .execute();
+        }
+        await queryRunner.commitTransaction();
+    }
+    catch (err) {
+        await queryRunner.rollbackTransaction();
+    }
+    finally {
+        await queryRunner.release();
+    }
+};
+exports.createUploadTask = createUploadTask;

package/dist/upload-task/run.d.ts

@@ -0,0 +1,7 @@
+import { DataSource } from 'typeorm';
+export declare const runUploadTask: (params: RunnerParams) => Promise<true>;
+type RunnerParams = {
+    dataSource: DataSource;
+    uid: number;
+};
+export {};

package/dist/upload-task/run.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runUploadTask = void 0;
+const entities_1 = require("@soga/entities");
+const single_runner_1 = require("./single-runner");
+const processMap = new Map();
+const runUploadTask = async (params) => {
+    const cache = processMap.get(params.uid);
+    if (cache)
+        return cache;
+    processMap.set(params.uid, true);
+    const fileRepository = params.dataSource.getRepository(entities_1.UploadFile);
+    const loop = async () => {
+        const fileitem = await fileRepository.findOneBy({
+            uid: params.uid,
+            root_id: 0,
+            is_ready: false,
+        });
+        if (!fileitem)
+            return;
+        const st = new single_runner_1.SingleRunner({
+            dataSource: params.dataSource,
+            file_id: fileitem.id,
+        });
+        await st.start();
+        await loop();
+    };
+    await loop();
+    processMap.delete(params.uid);
+};
+exports.runUploadTask = runUploadTask;

package/dist/upload-task/single-runner.d.ts

@@ -0,0 +1,23 @@
+import { FileCache } from '@soga/file-cache';
+import { DataSource } from 'typeorm';
+export declare class SingleRunner {
+    protected fc: FileCache;
+    private file_id;
+    private cache_file;
+    private dataSource;
+    private fileRepository;
+    private PARSED_FILES_KEY;
+    private INSERT_FOLDERS_KEY;
+    private INSERT_FILES_KEY;
+    constructor({ dataSource, file_id, }: {
+        dataSource: DataSource;
+        file_id: number;
+    });
+    start(): Promise<void>;
+    private end;
+    private insertFiles;
+    private insertFolders;
+    private parseRawFiles;
+    private destroy;
+    private init;
+}

package/dist/upload-task/single-runner.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleRunner = void 0;
+const entities_1 = require("@soga/entities");
+const file_cache_1 = require("@soga/file-cache");
+const types_1 = require("@soga/types");
+const fs_extra_1 = require("fs-extra");
+const glob_1 = require("glob");
+const os_1 = require("os");
+const path_1 = require("path");
+const typeorm_1 = require("typeorm");
+const fileinfo_1 = require("../utils/fileinfo");
+const utils_1 = require("./utils");
+class SingleRunner {
+    fc;
+    file_id;
+    cache_file;
+    dataSource;
+    fileRepository;
+    PARSED_FILES_KEY = 'parsed_files';
+    INSERT_FOLDERS_KEY = 'insert_folders';
+    INSERT_FILES_KEY = 'insert_files';
+    constructor({ dataSource, file_id, }) {
+        this.dataSource = dataSource;
+        this.fileRepository = dataSource.getRepository(entities_1.UploadFile);
+        this.file_id = file_id;
+    }
+    async start() {
+        await this.init();
+        await this.parseRawFiles();
+        await this.insertFolders();
+        await this.insertFiles();
+        await this.end();
+        await this.destroy();
+    }
+    async end() {
+        const fileitem = await this.fileRepository.findOneBy({
+            id: this.file_id,
+        });
+        if (!fileitem)
+            return;
+        const total = await this.fileRepository.countBy({
+            root_id: this.file_id,
+            type: (0, typeorm_1.Not)(types_1.RecordType.FOLDER),
+        });
+        fileitem.is_ready = true;
+        fileitem.total_count = total;
+        await this.fileRepository.save(fileitem);
+    }
+    async insertFiles() {
+        const key = this.INSERT_FILES_KEY;
+        const cache = await this.fc.get(key);
+        if (cache)
+            return cache;
+        const data = await this.fc.get(this.PARSED_FILES_KEY);
+        if (!data)
+            return;
+        const fileitem = await this.fileRepository.findOneBy({
+            id: this.file_id,
+        });
+        if (!fileitem)
+            return;
+        const { config } = fileitem;
+        const keep_source = config.file_keeps == types_1.RecordFileKeep.SOURCE ||
+            config.file_keeps == types_1.RecordFileKeep.BOTH;
+        const { subtitles, medias, files: normal_files } = data;
+        const match_map = {};
+        let subs = [...subtitles];
+        medias.forEach((media) => {
+            const matched = (0, utils_1.matchSubtitles)(media, subs);
+            if (matched) {
+                media.external_texts = matched.map((item) => item.filepath);
+                matched.forEach((item) => (match_map[item.filepath] = true));
+                subs = subs.filter((item) => !match_map[item.filepath]);
+            }
+        });
+        let subtitle_queues = subtitles;
+        if (!keep_source) {
+            subtitle_queues = subtitles.filter((item) => !match_map[item.filepath]);
+        }
+        const queues = [...subtitle_queues, ...normal_files, ...medias];
+        const { length } = queues;
+        if (!length)
+            return;
+        const items = [];
+        for (let i = 0; i < length; i++) {
+            const item = queues[i];
+            const { filepath } = item;
+            const isValid = await (0, fileinfo_1.isValidPath)(filepath);
+            if (!isValid)
+                continue;
+            const exist = await this.fileRepository.findOneBy({
+                root_id: this.file_id,
+                filepath,
+            });
+            if (exist)
+                continue;
+            const parentPath = (0, path_1.dirname)(filepath);
+            const parent = parentPath == fileitem.filepath
+                ? fileitem
+                : await this.fileRepository.findOneBy({
+                    root_id: this.file_id,
+                    filepath: parentPath,
+                });
+            if (!parent) {
+                continue;
+            }
+            const pid = parent.id;
+            const info = {
+                inputs: [
+                    {
+                        filename: item.filename,
+                        filepath: item.filepath,
+                        filesize: item.filesize,
+                        local_btime: item.local_btime,
+                        local_ctime: item.local_ctime,
+                        local_mtime: item.local_mtime,
+                    },
+                ],
+                filepath: item.filepath,
+                space_id: fileitem.space_id,
+                space_name: fileitem.space_name,
+                aid: fileitem.aid,
+                ali_host_id: fileitem.ali_host_id,
+                baidu_host_id: fileitem.baidu_host_id,
+                config,
+                is_paused: false,
+                is_ready: item.type != types_1.RecordType.FOLDER,
+                type: item.type,
+                task_record_id: fileitem.task_record_id,
+                uid: fileitem.uid,
+                root_id: fileitem.id,
+                pid,
+                total_count: 1,
+            };
+            if (item.file_type == 'media') {
+                info.external_texts = item.external_texts;
+            }
+            items.push(info);
+        }
+        const queryRunner = this.dataSource.createQueryRunner();
+        await queryRunner.connect();
+        await queryRunner.startTransaction();
+        try {
+            const fileRepository = queryRunner.manager.getRepository(entities_1.UploadFile);
+            const { length } = items;
+            const size = 50;
+            for (let i = 0; i < length; i += size) {
+                const chunks = items.slice(i, i + size);
+                await fileRepository
+                    .createQueryBuilder()
+                    .insert()
+                    .into(entities_1.UploadFile)
+                    .values(chunks)
+                    .execute();
+            }
+            await queryRunner.commitTransaction();
+        }
+        catch (err) {
+            await queryRunner.rollbackTransaction();
+        }
+        finally {
+            await queryRunner.release();
+        }
+        await this.fc.set(key, true);
+    }
+    async insertFolders() {
+        const key = this.INSERT_FOLDERS_KEY;
+        const cache = await this.fc.get(key);
+        if (cache)
+            return cache;
+        const data = await this.fc.get(this.PARSED_FILES_KEY);
+        if (!data)
+            return;
+        const { folders } = data;
+        const { length } = folders;
+        const fileitem = await this.fileRepository.findOneBy({
+            id: this.file_id,
+        });
+        if (!fileitem)
+            return;
+        for (let i = 0; i < length; i++) {
+            const folderPath = (0, path_1.resolve)(fileitem.filepath, folders[i]);
+            const isValid = await (0, fileinfo_1.isValidPath)(folderPath);
+            if (!isValid)
+                continue;
+            const exist = await this.fileRepository.findOneBy({
+                root_id: this.file_id,
+                filepath: folderPath,
+            });
+            if (exist)
+                continue;
+            const parentPath = (0, path_1.resolve)(folderPath, '..');
+            const parent = parentPath == fileitem.filepath
+                ? fileitem
+                : await this.fileRepository.findOneBy({
+                    root_id: this.file_id,
+                    filepath: parentPath,
+                });
+            if (!parent)
+                continue;
+            const pid = parent.id;
+            const root_id = this.file_id;
+            const info = {
+                inputs: [
+                    {
+                        filename: (0, path_1.basename)(folderPath),
+                        filepath: folderPath,
+                        filesize: 0,
+                        local_btime: 0,
+                        local_ctime: 0,
+                        local_mtime: 0,
+                    },
+                ],
+                aid: fileitem.aid,
+                ali_host_id: fileitem.ali_host_id,
+                baidu_host_id: fileitem.baidu_host_id,
+                config: fileitem.config,
+                filepath: folderPath,
+                is_ready: false,
+                uid: fileitem.uid,
+                type: types_1.RecordType.FOLDER,
+                task_record_id: fileitem.task_record_id,
+                space_name: fileitem.space_name,
+                space_id: fileitem.space_id,
+                is_paused: fileitem.is_paused,
+                external_texts: [],
+                pid,
+                root_id,
+            };
+            await this.fileRepository.save(this.fileRepository.create(info));
+        }
+        await this.fc.set(key, true);
+    }
+    async parseRawFiles() {
+        const key = this.PARSED_FILES_KEY;
+        const cache = await this.fc.get(key);
+        if (cache)
+            return cache;
+        const fileitem = await this.fileRepository.findOneBy({
+            id: this.file_id,
+        });
+        if (!fileitem)
+            return;
+        const paths = await (0, glob_1.glob)('**/*', {
+            nodir: true,
+            cwd: fileitem.filepath,
+        });
+        let folders = [];
+        paths.map((item) => {
+            let parentPath = (0, path_1.dirname)(item);
+            const arr = [];
+            while (parentPath != '.') {
+                if (!folders.includes(parentPath)) {
+                    arr.unshift(parentPath);
+                }
+                else {
+                    break;
+                }
+                parentPath = (0, path_1.dirname)(parentPath);
+            }
+            folders = [...folders, ...arr];
+        });
+        const files = [];
+        const subtitles = [];
+        const medias = [];
+        const { length } = paths;
+        for (let i = 0; i < length; i++) {
+            const filepath = (0, path_1.resolve)(fileitem.filepath, paths[i]);
+            const isValid = await (0, fileinfo_1.isValidPath)(filepath);
+            if (isValid) {
+                const fileinfo = await (0, fileinfo_1.getFileinfo)(filepath);
+                const { record_type } = fileinfo;
+                const { dir, base, name } = (0, path_1.parse)(filepath);
+                const info = {
+                    type: record_type,
+                    title: name,
+                    filename: base,
+                    basepath: (0, path_1.join)(dir, name),
+                    filepath: filepath,
+                    filesize: fileinfo.size,
+                    local_btime: fileinfo.local_btime,
+                    local_ctime: fileinfo.local_ctime,
+                    local_mtime: fileinfo.local_mtime,
+                    parent_path: (0, path_1.dirname)(filepath),
+                    file_type: 'file',
+                };
+                const is_media = record_type == types_1.RecordType.VIDEO || record_type == types_1.RecordType.AUDIO;
+                const is_subtitle = (0, fileinfo_1.isSubtitle)(filepath);
+                if (is_media) {
+                    const keywords = info.title
+                        .split(/[ _\-.{}[\]、,，。：:!?<>《》【】]+/g)
+                        .filter((k) => k.length >= 2);
+                    medias.push({
+                        ...info,
+                        file_type: 'media',
+                        keywords,
+                    });
+                }
+                else if (is_subtitle) {
+                    subtitles.push({
+                        ...info,
+                        file_type: 'subtitle',
+                    });
+                }
+                else {
+                    files.push(info);
+                }
+            }
+        }
+        await this.fc.set(key, {
+            files,
+            folders,
+            medias,
+            subtitles,
+        });
+        return {
+            files,
+            folders,
+        };
+    }
+    async destroy() {
+        await this.fc?.destroy();
+        await (0, fs_extra_1.remove)(this.cache_file);
+    }
+    async init() {
+        const fileitem = await this.fileRepository.findOneBy({
+            id: this.file_id,
+        });
+        if (!fileitem)
+            return;
+        const { id } = fileitem;
+        this.cache_file = (0, path_1.resolve)((0, os_1.homedir)(), '.dpan', 'desktop', 'json_files', `upload_task_single_${id}.json`);
+        this.fc = await (0, file_cache_1.getFileCache)(this.cache_file);
+    }
+}
+exports.SingleRunner = SingleRunner;

package/dist/upload-task/types.d.ts

@@ -0,0 +1,53 @@
+import { RecordType, UploadInputItem } from '@soga/types';
+import { DataSource } from 'typeorm';
+export type UploadFileParams = {
+    dataSource: DataSource;
+    sdk_domain: string;
+    paths: string[];
+    space_id: number;
+    record_id: number;
+};
+interface CommonMeta {
+    type: RecordType;
+    filename: string;
+    filepath: string;
+    filesize: number;
+    local_btime: number;
+    local_ctime: number;
+    local_mtime: number;
+    parent_path: string;
+    title: string;
+    basepath: string;
+    file_type: 'media' | 'subtitle' | 'folder' | 'file';
+}
+export interface FileMeta extends CommonMeta {
+    file_type: 'file';
+}
+export interface MediaMeta extends CommonMeta {
+    keywords: string[];
+    external_texts?: string[];
+    file_type: 'media';
+}
+export interface SubtitleMeta extends CommonMeta {
+    file_type: 'subtitle';
+}
+export interface FileItem {
+    inputs: UploadInputItem[];
+    space_id: number;
+    space_name: string;
+    filepath: string;
+    is_ready: boolean;
+    config: object;
+    uid: number;
+    aid: number;
+    baidu_host_id: number;
+    ali_host_id: number;
+    is_paused: boolean;
+    type: RecordType;
+    task_record_id: number;
+    external_texts: string[];
+    root_id?: number;
+    pid?: number;
+    total_count?: number;
+}
+export {};

package/dist/upload-task/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/upload-task/utils.d.ts

@@ -0,0 +1,2 @@
+import { MediaMeta, SubtitleMeta } from './types';
+export declare const matchSubtitles: (media: MediaMeta, subtitles: SubtitleMeta[]) => SubtitleMeta[];

package/dist/upload-task/utils.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchSubtitles = void 0;
+const path_1 = require("path");
+const matchSubtitles = (media, subtitles) => {
+    const first_match = subtitles.filter((item) => item.parent_path.includes(media.parent_path));
+    if (!first_match.length)
+        return null;
+    const { keywords } = media;
+    const matched = [];
+    first_match.forEach((item) => {
+        if (item.basepath == media.basepath) {
+            matched.unshift(item);
+        }
+        else {
+            const relative_uri = (0, path_1.relative)(media.parent_path, item.parent_path);
+            const level = relative_uri.split(path_1.sep).filter((i) => !!i).length;
+            if (level < 2) {
+                const matched_keywords = keywords.filter((keyword) => item.title.includes(keyword));
+                if (matched_keywords.length &&
+                    matched_keywords.join('').length / keywords.length > 0.15) {
+                    matched.push(item);
+                }
+            }
+        }
+    });
+    return matched;
+};
+exports.matchSubtitles = matchSubtitles;

package/dist/utils/fileinfo.d.ts

@@ -0,0 +1,10 @@
+import { RecordType } from '@soga/types';
+export declare const getFileinfo: (filepath: string) => Promise<{
+    local_ctime: number;
+    local_mtime: number;
+    local_btime: number;
+    record_type: RecordType;
+    size: number;
+}>;
+export declare const isSubtitle: (filepath: string) => boolean;
+export declare const isValidPath: (filepath: string) => Promise<boolean>;

package/dist/utils/fileinfo.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidPath = exports.isSubtitle = exports.getFileinfo = void 0;
+const types_1 = require("@soga/types");
+const mime_1 = __importDefault(require("mime"));
+const fs_extra_1 = require("fs-extra");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const isTextFile = async (filepath, length = 1024 * 5) => {
+    const fd = await (0, promises_1.open)(filepath, 'r');
+    for (let i = 0; i < length; i++) {
+        const buf = Buffer.alloc(1);
+        const { bytesRead } = await fd.read(buf, 0, 1, i);
+        const char = buf.toString().charCodeAt(0);
+        if (bytesRead === 0) {
+            await fd.close();
+            return true;
+        }
+        else if (bytesRead === 1 && char === 0) {
+            await fd.close();
+            return false;
+        }
+    }
+    await fd.close();
+    return true;
+};
+const getRecordType = async (filepath) => {
+    const mimetype = mime_1.default.getType(filepath);
+    if (!mimetype) {
+        return types_1.RecordType.OTHER;
+    }
+    if (mimetype.startsWith('video/')) {
+        if (filepath.endsWith('.ts')) {
+            if (await isTextFile(filepath)) {
+                return types_1.RecordType.OTHER;
+            }
+            else {
+                return types_1.RecordType.VIDEO;
+            }
+        }
+        else {
+            return types_1.RecordType.VIDEO;
+        }
+    }
+    else if (mimetype.startsWith('audio/')) {
+        return types_1.RecordType.AUDIO;
+    }
+    else if (mimetype.startsWith('image/')) {
+        return types_1.RecordType.IMAGE;
+    }
+    else if (mimetype.startsWith('text/')) {
+        return types_1.RecordType.TXT;
+    }
+    else if (mimetype.startsWith('application/vnd.rn-realmedia')) {
+        return types_1.RecordType.VIDEO;
+    }
+    return types_1.RecordType.OTHER;
+};
+const getFileinfo = async (filepath) => {
+    try {
+        const stats = await (0, fs_extra_1.stat)(filepath);
+        const isFolder = stats.isDirectory();
+        const record_type = isFolder
+            ? types_1.RecordType.FOLDER
+            : await getRecordType(filepath);
+        return {
+            local_ctime: Math.floor(stats.ctimeMs),
+            local_mtime: Math.floor(stats.mtimeMs),
+            local_btime: Math.floor(stats.birthtimeMs),
+            record_type,
+            size: isFolder ? 0 : stats.size,
+        };
+    }
+    catch (err) {
+        const now = Date.now();
+        return {
+            local_ctime: now,
+            local_mtime: now,
+            local_btime: now,
+            record_type: types_1.RecordType.OTHER,
+            size: 0,
+        };
+    }
+};
+exports.getFileinfo = getFileinfo;
+const isSubtitle = (filepath) => {
+    const parsed = (0, path_1.parse)(filepath);
+    const ext = parsed.ext;
+    const types = ['.srt', '.vtt', '.ass', '.ssa', '.sbv', '.lrc'];
+    if (types.includes(ext)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+};
+exports.isSubtitle = isSubtitle;
+const isValidPath = async (filepath) => {
+    const exists = await (0, fs_extra_1.pathExists)(filepath);
+    if (!exists) {
+        return false;
+    }
+    return true;
+};
+exports.isValidPath = isValidPath;

package/package.json

@@ -1,15 +1,64 @@
 {
   "name": "@soga/task",
-  "version": "0.0.1",
-  "main": "index.js",
+  "version": "0.2.13",
   "publishConfig": {
     "access": "public"
   },
+  "description": "",
+  "main": "dist/main.js",
+  "types": "dist/main.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "rimraf dist && tsc && ts-node ./scripts/minify",
+    "minify": "ts-node ./scripts/minify",
+    "demo_backup": "ts-node ./demo/demo.ts",
+    "demo": "ts-node ./demo/demo.ts",
+    "worker": "tsc && ts-node ./demo/worker.ts",
+    "test": "jest",
+    "dev": "ts-node ./src/main.ts",
+    "lint": "eslint . --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@soga/types": "file:../types",
+    "@types/fs-extra": "^11.0.4",
+    "@types/glob": "^8.1.0",
+    "@types/jest": "^29.5.14",
+    "@types/mime": "^3.0.4",
+    "@types/node": "^20.8.7",
+    "@typescript-eslint/eslint-plugin": "^6.4.1",
+    "@typescript-eslint/parser": "^6.4.1",
+    "eslint": "^8.47.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-jest": "^27.9.0",
+    "eslint-plugin-prettier": "^5.2.3",
+    "glob": "^10.4.5",
+    "jest": "^29.7.0",
+    "prettier": "^3.0.2",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^6.0.1",
+    "terser": "^5.19.2",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "description": ""
+  "peerDependencies": {
+    "level": "*",
+    "typeorm": "*"
+  },
+  "dependencies": {
+    "@soga/entities": "^0.2.8",
+    "@soga/file-cache": "^0.2.13",
+    "@soga/sdk": "^0.2.13",
+    "@soga/types": "^0.2.8",
+    "@soga/utils": "^0.2.8",
+    "axios": "^1.8.4",
+    "mime": "^3.0.0"
+  },
+  "gitHead": "6835bf7d5150fe9805b2a66b3c4cb608e408234d"
 }

package/index.js

@@ -1 +0,0 @@
-console.log("cache");