@positivegrid/pg-mongoose-schema 28.0.0-beta.1 → 28.0.0-beta.4

package/dist/models/preset.js

@@ -1,802 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const debug_1 = __importDefault(require("debug"));
-const debug = (0, debug_1.default)("model:preset");
-/**
- * Internal method - _parsePresetForm
- * All query should gothrough this handler before search for compatible issue
- */
-function _queryCompatibilityHandler(query) {
-    let formatQuery = {};
-    if ("preset_for" in query && query["preset_for"] === "amp2") {
-        formatQuery = { ...query, preset_for: { $in: ["amp2", "bias"] } };
-    }
-    else if (!("preset_for" in query) || query["preset_for"] === "") {
-        formatQuery = { ...query, preset_for: "jamup" };
-    }
-    if (Object.keys(formatQuery).length === 0) {
-        formatQuery = { ...query };
-    }
-    debug("_queryCompatibilityHandler %o", formatQuery);
-    return formatQuery;
-}
-// version_comparison follow the same format as mongodb query comparsion:
-// https://docs.mongodb.com/manual/reference/operator/query-comparison/
-// only support BIAS FX preset for now
-//
-// HardCode: useragent == iPad then only show preset_version <= 1.7
-function _handlePresetVersion(queryObj, req) {
-    const supportVersionComparison = ["eq", "gt", "gte", "lt", "lte", "ne"];
-    if (!("preset_for" in req.query) ||
-        ("preset_for" in req.query && req.query["preset_for"] !== "live")) {
-        return { ...queryObj };
-    }
-    else if ("preset_version" in req.query && "version_comparison" in req.query) {
-        if (supportVersionComparison.includes(req.query["version_comparison"])) {
-            const tmpVersionQuery = { ...queryObj };
-            const versionQuery = _buildPresetVersionQuery(req.query["preset_version"], req.query["version_comparison"]);
-            if (versionQuery) {
-                return { ...tmpVersionQuery, ...versionQuery };
-            }
-        }
-    }
-    return { ...queryObj };
-}
-function _buildPresetVersionQuery(version, comparison) {
-    const tmpAttrs = String(version).split(".");
-    let major = 0;
-    let minor = 0;
-    if (tmpAttrs.length !== 2) {
-        debug("ERROR:_buildPresetVersionQuery:Incorrect version %s", version);
-        return false;
-    }
-    else {
-        major = parseInt(tmpAttrs[0], 10);
-        minor = parseInt(tmpAttrs[1], 10);
-    }
-    switch (comparison) {
-        case "eq":
-            return {
-                $and: [{ "version.major": major }, { "version.minor": minor }],
-            };
-        case "gt":
-        case "gte":
-        case "lt":
-        case "lte": {
-            const compareOper = "$" + comparison;
-            const minorQuery = {};
-            minorQuery[compareOper] = minor;
-            return {
-                $and: [{ "version.major": major }, { "version.minor": minorQuery }],
-            };
-        }
-        default:
-            debug("ERROR:_buildPresetVersionQuery:Not support format %s %s", version, comparison);
-            return false;
-    }
-}
-function _buildSortQuery(orderParam) {
-    let sortQuery = {};
-    switch (orderParam) {
-        case "popular":
-            sortQuery = { num_likes: -1 };
-            break;
-        case "alphabet":
-            sortQuery = { name: 1 };
-            break;
-        case "hot":
-            sortQuery = { num_downloads: -1 };
-            break;
-        case "latest":
-        default:
-            sortQuery = { created_on: -1 };
-    }
-    return sortQuery;
-}
-/**
- * Filter presets with license_tier parameter, but need to consider backward compatibility.
- * e.g., license_tier == 'elite' then need to get elite/pro/std and all others presets
- * However, expansion need to be considered out of normal license tier,
- * so we use expansionData/allExpansion to controll it.
- */
-function _buildLicenseTierQuery(licenseTierParam) {
-    const tmpLicenseTier = String(licenseTierParam).split(",");
-    const tmpData = new Set();
-    const expansionData = new Set();
-    const allExpansion = new Set(["celestion", "classic"]);
-    tmpLicenseTier.forEach((lic) => {
-        switch (lic) {
-            case "celestion":
-            case "classic":
-                expansionData.add(lic);
-                allExpansion.delete(lic);
-                break;
-            case "elite":
-                tmpData.add("elite");
-                tmpData.add("pro");
-                tmpData.add("std");
-                tmpData.add(null);
-                break;
-            case "pro":
-                tmpData.add("pro");
-                tmpData.add("std");
-                tmpData.add(null);
-                break;
-            case "std":
-                tmpData.add("std");
-                tmpData.add(null);
-                break;
-            case "lite":
-            case "demo":
-                tmpData.add(null);
-                break;
-            default:
-                debug("ERROR:_buildLicenseTierQuery %s", licenseTierParam);
-        }
-    });
-    const output = expansionData.size > 0
-        ? {
-            $and: [
-                {
-                    license_tier: { $in: Array.from(tmpData) },
-                },
-                {
-                    license_tier: { $in: [...Array.from(tmpData), ...Array.from(expansionData)] },
-                },
-                {
-                    license_tier: { $nin: Array.from(allExpansion) },
-                },
-            ],
-        }
-        : {
-            $and: [
-                {
-                    license_tier: { $in: Array.from(tmpData) },
-                },
-                {
-                    license_tier: { $nin: Array.from(allExpansion) },
-                },
-            ],
-        };
-    debug("_buildLicenseTierQuery:%j", output);
-    return output;
-}
-function default_1(mongoose) {
-    const { Schema } = mongoose;
-    const { ObjectId } = Schema.Types;
-    const filterKeyword = (keyword) => {
-        return String(keyword).replace(/[/\\@%&]+/g, "");
-    };
-    const parsePageParams = (data) => {
-        debug("parsePageParams", data);
-        let pageParams = {
-            page_size: 12,
-            page: 1,
-        };
-        if (data && "page_size" in data) {
-            const pageSize = Array.isArray(data["page_size"])
-                ? parseInt(data["page_size"].pop(), 10)
-                : parseInt(data["page_size"], 10);
-            if (pageSize >= 1) {
-                pageParams = { ...pageParams, page_size: pageSize };
-            }
-        }
-        if (data && "page" in data) {
-            const page = Array.isArray(data["page"])
-                ? parseInt(data["page"].pop(), 10)
-                : parseInt(data["page"], 10);
-            if (page > 1) {
-                pageParams = { ...pageParams, page: page };
-            }
-        }
-        debug("parsePageParams:output", pageParams);
-        return pageParams;
-    };
-    const PresetSchema = new Schema({
-        name: { type: String, index: true, required: true },
-        creator_id: { type: ObjectId, ref: "User", required: true },
-        preset_for: { type: String, required: true },
-        status: { type: Number, default: 0, required: true }, // 0:alive, 1:delete, 2: offline, 3: special(limited), 4: processing (Spark: PVN)
-        description: { type: String },
-        tags: { type: [{ type: String }], default: () => null },
-        is_featured: { type: Boolean, default: false },
-        category: { type: String, index: true },
-        active_effects: { type: String },
-        preset_data: { type: String },
-        preset_features: { type: Schema.Types.Mixed, default: null }, // match (1:enable, 2:disable)
-        version: {
-            major: { type: Number },
-            minor: { type: Number },
-        },
-        preset_meta: { type: Schema.Types.Mixed },
-        preset_scene: { type: Array }, // fx2
-        license_tier: { type: [{ type: String }], index: true, default: () => null }, // amp2: std/pro/elite pack:celestion
-        // only () => null can set empty array as null: https://github.com/Automattic/mongoose/issues/1335#issuecomment-321817528
-        num_comments: { type: Number, default: 0 },
-        num_downloads: { type: Number, default: 0 },
-        num_likes: { type: Number, default: 0 },
-        rating_sum: { type: Number, default: 0 },
-        rating_avg: { type: Number, default: 0 },
-        rating_count: { type: Number, default: 0 },
-        image_url: { type: String },
-        thumb_url: { type: String },
-        signal_chain_type: {
-            type: String,
-            enum: ["in1", "in2"],
-        },
-        created_on: { type: Date, default: Date.now },
-        updated_on: { type: Date, default: Date.now },
-    }, { collection: "jamup_preset", toJSON: { virtuals: true }, toObject: { virtuals: true } });
-    PresetSchema.index({
-        name: 1,
-        description: 1,
-        category: 1,
-    });
-    PresetSchema.index({
-        preset_for: 1,
-        status: 1,
-    });
-    PresetSchema.index({
-        preset_for: 1,
-        signal_chain_type: 1,
-        status: 1,
-    });
-    const PresetSongMappingSchema = new Schema({
-        preset_id: { type: ObjectId, ref: "Preset", required: true },
-        song_id: { type: String, required: true },
-        created_on: { type: Date, default: Date.now },
-    }, { collection: "preset_song_mapping" });
-    PresetSongMappingSchema.index({
-        song_id: 1,
-    });
-    PresetSongMappingSchema.index({
-        preset_id: 1,
-        song_id: 1,
-    }, { unique: true });
-    const PresetTagsMetaSchema = new Schema({
-        name: { type: String, required: true },
-        count: { type: Number, default: 0, required: true },
-        preset_for: { type: String, required: true },
-        created_on: { type: Date, default: Date.now },
-    }, { collection: "preset_tags_meta" });
-    PresetTagsMetaSchema.index({
-        name: 1,
-        preset_for: 1,
-    }, { unique: true });
-    PresetTagsMetaSchema.index({
-        count: -1,
-    });
-    const PresetUserCommentSchema = new Schema({
-        user_id: { type: ObjectId, ref: "User", required: true },
-        preset_id: { type: ObjectId, ref: "Preset", required: true },
-        comment_text: { type: String, required: true },
-        preset_for: { type: String },
-        status: { type: Number, default: 1, required: true }, // 1:Active 2:Delete
-        date_comment: { type: Date, default: Date.now },
-    }, { collection: "jamup_userpresetcomment" });
-    const PresetUserLikeSchema = new Schema({
-        user_id: { type: ObjectId, ref: "User", required: true },
-        preset_id: { type: ObjectId, ref: "Preset", required: true },
-        preset_for: { type: String },
-        date_like: { type: Date, default: Date.now },
-    }, { collection: "jamup_userpresetlike" });
-    const FakePresetLikeSchema = new Schema({
-        preset_id: { type: ObjectId, ref: "Preset", required: true },
-        likes: { type: Number, default: 0 },
-    }, { collection: "fake_userpresetlike" });
-    const PresetUserDownloadSchema = new Schema({
-        user_id: { type: ObjectId, ref: "User", required: true },
-        preset_id: { type: ObjectId, ref: "Preset", required: true },
-        preset_for: { type: String, required: true },
-        date_download: { type: Date, default: Date.now },
-        updated_on: { type: Date, default: Date.now },
-    }, { collection: "jamup_userpresetdownload" });
-    const PopularPresetListSchema = new Schema({
-        preset_for: { type: String, required: true },
-        popular_range: { type: String, required: true },
-        popular_preset_list: [{ type: ObjectId, ref: "Preset", required: true }],
-        created_on: { type: Date, default: Date.now, required: true },
-    }, { collection: "jamup_popularpresetlist" });
-    PresetSchema.static({
-        async getPresetByUserId(userId) {
-            return this.find({ creator_id: userId }).sort({ created_on: -1 }).exec();
-        },
-        async getPresetByQuery(req, opts = {}) {
-            let pageParams;
-            const shouldCondition = [];
-            debug("getPresetByQuery:input:%j", req.query);
-            if (!("keyword" in req.query) || typeof req.query.keyword !== "string") {
-                throw new Error("missing the searching term");
-            }
-            pageParams = parsePageParams(req.query);
-            let searchCondition = {
-                preset_for: req.query.preset_for ? req.query.preset_for : "jamup",
-                status: 0,
-            };
-            // Build license_tier query rule, default would be license_tier: null
-            // The detail of the rule can jump to _buildLicenseTierQuery
-            if ("license_tier" in req.query) {
-                const tmpQuery = { ...searchCondition };
-                searchCondition = { ...tmpQuery, ..._buildLicenseTierQuery(req.query["license_tier"]) };
-            }
-            if ("order" in req.query && req.query.order === "hot") {
-                searchCondition = {
-                    ...searchCondition,
-                    created_on: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
-                };
-            }
-            searchCondition = _handlePresetVersion(searchCondition, req);
-            shouldCondition.push({
-                text: {
-                    path: "name",
-                    query: req.query.keyword,
-                    fuzzy: {
-                        maxEdits: 1,
-                        prefixLength: 1,
-                        maxExpansions: 30,
-                    },
-                    score: {
-                        boost: {
-                            value: 3,
-                        },
-                    },
-                },
-            }, {
-                text: {
-                    path: ["description", "category"],
-                    query: req.query.keyword,
-                    fuzzy: {
-                        maxEdits: 2,
-                        prefixLength: 0,
-                        maxExpansions: 50,
-                    },
-                },
-            });
-            debug("INFO:getPresetByQuery:%j:%j", searchCondition, shouldCondition);
-            const aggregatePipeline = [
-                {
-                    $search: {
-                        index: "default",
-                        compound: {
-                            should: shouldCondition,
-                        },
-                    },
-                },
-                {
-                    $match: searchCondition,
-                },
-                {
-                    $skip: (pageParams.page - 1) * pageParams.page_size,
-                },
-                {
-                    $limit: pageParams.page_size,
-                },
-            ];
-            if (!("full" in opts)) {
-                aggregatePipeline.push({
-                    $project: {
-                        preset_data: 0,
-                    },
-                });
-            }
-            const result = await this.aggregate(aggregatePipeline);
-            return result;
-        },
-        async getPresetsBySearch(req) {
-            let pageParams;
-            let searchCondition;
-            let sortCondition = _buildSortQuery(req.query.order);
-            let selectOps = {};
-            debug("getPresetsBySearch:input", req.query);
-            pageParams = parsePageParams(req.query);
-            searchCondition = {
-                preset_for: req.query["preset_for"] ? req.query["preset_for"] : "jamup",
-                status: 0,
-            };
-            if (!("detail" in req.query) || req.query.detail !== "yes") {
-                selectOps = { preset_data: 0 };
-            }
-            if ("pids" in req.query) {
-                const pids = req.query.pids.split(",");
-                searchCondition["_id"] = {
-                    $in: pids,
-                };
-            }
-            if ("category" in req.query) {
-                const categories = String(req.query["category"]).split(",");
-                searchCondition["category"] = {
-                    $in: categories,
-                };
-            }
-            else if ("except_cateogry" in req.query) {
-                const exceptCategories = String(req.query["except_cateogry"]).split(",");
-                searchCondition["category"] = {
-                    $nin: exceptCategories,
-                };
-            }
-            if ("pedal_type" in req.query) {
-                searchCondition["preset_meta.pedal_type"] = req.query["pedal_type"];
-            }
-            // featureKey1:Val1,featureKey2:Val2
-            if ("preset_features" in req.query) {
-                const params = req.query["preset_features"].split(",");
-                const featureQuery = {};
-                params.forEach((param) => {
-                    const tmpParams = param.split(":");
-                    if (tmpParams.length === 2) {
-                        featureQuery[tmpParams[0]] = parseInt(tmpParams[1], 10);
-                    }
-                });
-                searchCondition["preset_features"] = featureQuery;
-            }
-            // created_after/created_before - assign preset created_on date
-            const createQuery = {};
-            if ("create_after" in req.query) {
-                const verifyDate = new Date(req.query["create_after"]);
-                if (!isNaN(verifyDate.getTime())) {
-                    createQuery["$gte"] = verifyDate;
-                }
-            }
-            if ("create_before" in req.query) {
-                const verifyDate = new Date(req.query["create_before"]);
-                if (!isNaN(verifyDate.getTime())) {
-                    createQuery["$lte"] = verifyDate;
-                }
-            }
-            if (Object.keys(createQuery).length > 0) {
-                searchCondition["created_on"] = createQuery;
-            }
-            // updated_after/updated_before - assign preset updated_on date
-            const updateQuery = {};
-            if ("update_after" in req.query) {
-                const verifyDate = new Date(req.query["update_after"]);
-                if (!isNaN(verifyDate.getTime())) {
-                    updateQuery["$gte"] = verifyDate;
-                }
-            }
-            if ("update_before" in req.query) {
-                const verifyDate = new Date(req.query["update_before"]);
-                if (!isNaN(verifyDate.getTime())) {
-                    updateQuery["$lte"] = verifyDate;
-                }
-            }
-            if (Object.keys(updateQuery).length > 0) {
-                searchCondition["updated_on"] = updateQuery;
-            }
-            // Build license_tier query rule, default would be license_tier: null
-            // The detail of the rule can jump to _buildLicenseTierQuery
-            if ("license_tier" in req.query) {
-                const tmpQuery = { ...searchCondition };
-                searchCondition = { ...tmpQuery, ..._buildLicenseTierQuery(req.query["license_tier"]) };
-            }
-            if ("order" in req.query && req.query.order === "hot") {
-                searchCondition = {
-                    ...searchCondition,
-                    created_on: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) },
-                };
-            }
-            // signal_chain_type query only works in Spark for now
-            if (searchCondition.preset_for === "spark") {
-                if ("signal_chain_type" in req.query) {
-                    searchCondition.signal_chain_type = req.query.signal_chain_type;
-                }
-                if ("no_dspid" in req.query) {
-                    searchCondition["preset_meta.dspId"] = { $nin: String(req.query.no_dspid).split(",") };
-                }
-            }
-            searchCondition = _handlePresetVersion(searchCondition, req);
-            debug("getPresetsBySearch:full_text %j %j", searchCondition, sortCondition);
-            if ("keyword" in req.query && req.query.keyword) {
-                let result;
-                // China cannot use Atlas Search, so we need to keep it used the old solution before find an alternative on Aliyun
-                if (globalThis.process?.env?.IS_CHINA !== undefined) {
-                    searchCondition["$or"] = [
-                        { name: new RegExp(`^${filterKeyword(req.query["keyword"])}`, "i") },
-                        { description: new RegExp(`${filterKeyword(req.query["keyword"])}`, "i") },
-                    ];
-                    result = await this.aggregate([
-                        {
-                            $match: _queryCompatibilityHandler(searchCondition),
-                        },
-                        {
-                            $sort: sortCondition,
-                        },
-                        {
-                            $project: selectOps,
-                        },
-                        {
-                            $skip: (pageParams.page - 1) * pageParams.page_size,
-                        },
-                        {
-                            $limit: pageParams.page_size,
-                        },
-                        {
-                            $addFields: {
-                                id: "$_id",
-                            },
-                        },
-                    ]);
-                }
-                else {
-                    result = await this.aggregate([
-                        {
-                            $search: {
-                                text: {
-                                    path: ["name", "description"],
-                                    query: req.query.keyword,
-                                },
-                            },
-                        },
-                        {
-                            $match: _queryCompatibilityHandler(searchCondition),
-                        },
-                        {
-                            $sort: sortCondition,
-                        },
-                        {
-                            $project: selectOps,
-                        },
-                        {
-                            $skip: (pageParams.page - 1) * pageParams.page_size,
-                        },
-                        {
-                            $limit: pageParams.page_size,
-                        },
-                        {
-                            $addFields: {
-                                id: "$_id",
-                            },
-                        },
-                    ]);
-                }
-                return result;
-            }
-            else {
-                const result = await this.aggregate([
-                    {
-                        $match: _queryCompatibilityHandler(searchCondition),
-                    },
-                    {
-                        $sort: sortCondition,
-                    },
-                    {
-                        $project: selectOps,
-                    },
-                    {
-                        $skip: (pageParams.page - 1) * pageParams.page_size,
-                    },
-                    {
-                        $limit: pageParams.page_size,
-                    },
-                    {
-                        $addFields: {
-                            id: "$_id",
-                        },
-                    },
-                ]);
-                return result;
-            }
-        },
-        async getPresetsList(query, sort, req) {
-            const pageParams = parsePageParams(req.query);
-            // only select preset status == 0
-            if (typeof query === "object" && query !== null) {
-                query["status"] = 0;
-            }
-            if ("preset_for" in query && query["preset_for"] !== "jamup") {
-                query["image_url"] = { $ne: null };
-                query["thumb_url"] = { $ne: null };
-            }
-            if ("license_tier" in req.query) {
-                const tmpQuery = { ...query };
-                query = { ...tmpQuery, ..._buildLicenseTierQuery(req.query["license_tier"]) };
-            }
-            if ("order" in req.query) {
-                sort = _buildSortQuery(req.query.order);
-            }
-            query = _handlePresetVersion(query, req);
-            debug("getPresetsList:%j", query);
-            return this.find(_queryCompatibilityHandler(query))
-                .sort(sort)
-                .select("-preset_data")
-                .skip((pageParams["page"] - 1) * pageParams["page_size"])
-                .limit(pageParams["page_size"])
-                .exec();
-        },
-        async getPresetsListPromise(query, sort, req) {
-            return this.getPresetsList(query, sort, req);
-        },
-        async getMyPresets(query, sort, req) {
-            const pageParams = parsePageParams(req.query);
-            if (typeof query === "object" && query !== null) {
-                query["status"] = { $in: [0, 2] };
-            }
-            if ("preset_for" in query && query["preset_for"] !== "jamup") {
-                query["image_url"] = { $ne: null };
-                query["thumb_url"] = { $ne: null };
-            }
-            query = _handlePresetVersion(query, req);
-            debug("getMyPresets:%o", query);
-            return this.find(_queryCompatibilityHandler(query))
-                .sort(sort)
-                .select("-preset_data")
-                .skip((pageParams["page"] - 1) * pageParams["page_size"])
-                .limit(pageParams["page_size"])
-                .exec();
-        },
-        async getOnePresetByCondition(query, opts) {
-            const defaultSort = "sort" in opts && typeof opts.sort === "object" ? opts.sort : { created_on: -1 };
-            const defaultSelect = "select" in opts && typeof opts.select === "string" ? opts.select : "";
-            return this.findOne(_queryCompatibilityHandler(query))
-                .sort(defaultSort)
-                .select(defaultSelect)
-                .exec();
-        },
-        async getSinglePreset(id) {
-            return this.findOne({ _id: id, status: 0 }).exec();
-        },
-        async getValidSinglePreset(id) {
-            return this.findOne({ _id: id, status: { $in: [0, 2, 3] } }).exec();
-        },
-    });
-    PresetUserCommentSchema.static({
-        async getPresetComments(presetId, req) {
-            try {
-                const pageParams = parsePageParams(req.query);
-                const ret = await this.aggregate([
-                    { $match: { preset_id: new mongoose.Types.ObjectId(presetId), status: 1 } },
-                    { $sort: { date_comment: -1 } },
-                    { $skip: (pageParams["page"] - 1) * pageParams["page_size"] },
-                    { $limit: pageParams["page_size"] },
-                    {
-                        $lookup: {
-                            from: "auth_user",
-                            localField: "user_id",
-                            foreignField: "_id",
-                            as: "tmpUser",
-                        },
-                    },
-                    {
-                        $lookup: {
-                            from: "jamup_userprofile",
-                            localField: "user_id",
-                            foreignField: "_id",
-                            as: "tmpProfile",
-                        },
-                    },
-                    { $unwind: "$tmpUser" },
-                    { $unwind: "$tmpProfile" },
-                    {
-                        $project: {
-                            preset_id: 1,
-                            comment_text: 1,
-                            date_comment: 1,
-                            user: {
-                                _id: "$tmpUser._id",
-                                email: "$tmpUser.email",
-                                date_joined: "$tmpUser.date_joined",
-                                full_name: "$tmpProfile.full_name",
-                                first_name: "$tmpProfile.first_name",
-                                last_name: "$tmpProfile.last_name",
-                                profile_image_url: "$tmpProfile.profile_image_url",
-                                profile_thumb_url: "$tmpProfile.profile_thumb_url",
-                            },
-                        },
-                    },
-                ]).exec();
-                return ret;
-            }
-            catch (err) {
-                debug("ERR:getPresetComment:%o", err);
-                throw err;
-            }
-        },
-    });
-    PresetUserLikeSchema.static({
-        async getCountByPresetCondition(query, condition) {
-            const result = await this.find(query).populate("preset_id").exec();
-            debug("getCountByPresetCondition", query, condition, result, result.length);
-            const filterVal = result.filter((item) => {
-                const tmpObj = item.toObject();
-                return condition in tmpObj["preset_id"];
-            });
-            return filterVal.length;
-        },
-        async getPresetLikeList(query, sort, req) {
-            const pageParams = parsePageParams(req.query);
-            const defaultPresetCondition = {
-                "preset.status": { $eq: 0 },
-            };
-            let filterQuery;
-            if ("no_dspid" in query) {
-                defaultPresetCondition["preset.preset_meta.dspId"] = {
-                    $nin: String(query.no_dspid).split(","),
-                };
-                const { no_dspid: _no_dspid, ...rest } = query;
-                filterQuery = rest;
-            }
-            else {
-                filterQuery = { ...query };
-            }
-            const aggregateQuery = [
-                {
-                    $match: {
-                        ..._queryCompatibilityHandler(filterQuery),
-                        user_id: new mongoose.Types.ObjectId(filterQuery["user_id"]),
-                    },
-                },
-                {
-                    $lookup: {
-                        from: "jamup_preset",
-                        localField: "preset_id",
-                        foreignField: "_id",
-                        as: "preset",
-                    },
-                },
-                {
-                    $unwind: "$preset",
-                },
-                {
-                    $match: defaultPresetCondition,
-                },
-            ];
-            const presetQuery = _handlePresetVersion({}, req);
-            if (Object.keys(presetQuery).length === 0) {
-                debug("getPresetLikeList:%j:%o", aggregateQuery, sort);
-                return this.aggregate(aggregateQuery)
-                    .sort({ date_like: -1 })
-                    .skip((pageParams["page"] - 1) * pageParams["page_size"])
-                    .limit(pageParams["page_size"])
-                    .exec();
-            }
-            else {
-                if ("$and" in presetQuery && Array.isArray(presetQuery["$and"])) {
-                    presetQuery["$and"].forEach((item) => {
-                        const newQuery = { $match: {} };
-                        const objKey = Object.keys(item);
-                        const objVal = Object.values(item);
-                        if (objKey.length === 1 && objVal.length === 1) {
-                            newQuery["$match"][`preset.${objKey[0]}`] = objVal[0];
-                            aggregateQuery.push(newQuery);
-                        }
-                    });
-                }
-                debug("getPresetLikeListAggregate:%j:%o:%j", query, sort, aggregateQuery);
-                return this.aggregate(aggregateQuery)
-                    .sort({ date_like: -1 })
-                    .skip((pageParams["page"] - 1) * pageParams["page_size"])
-                    .limit(pageParams["page_size"])
-                    .exec();
-            }
-        },
-        async getPresetLikeListPromise(query, sort, req) {
-            return this.getPresetLikeList(query, sort, req);
-        },
-    });
-    PresetSchema.virtual("preset_version")
-        .get(function () {
-        return Number.isInteger(this.version.major) && Number.isInteger(this.version.minor)
-            ? `${this.version.major}.${this.version.minor}`
-            : "1.0";
-    })
-        .set(function (presetVersion) {
-        const versionDetail = presetVersion.split(".");
-        const major = versionDetail[0];
-        const minor = versionDetail[1];
-        this.set("version.major", parseInt(major, 10));
-        this.set("version.minor", parseInt(minor, 10));
-    });
-    mongoose.model("Preset", PresetSchema);
-    mongoose.model("PresetComment", PresetUserCommentSchema);
-    mongoose.model("PresetLike", PresetUserLikeSchema);
-    mongoose.model("PresetDownload", PresetUserDownloadSchema);
-    mongoose.model("PopularPresetList", PopularPresetListSchema);
-    mongoose.model("FakePresetLike", FakePresetLikeSchema);
-    mongoose.model("PresetTagsMeta", PresetTagsMetaSchema);
-    mongoose.model("PresetSongMapping", PresetSongMappingSchema);
-}
-//# sourceMappingURL=preset.js.map