@positivegrid/pg-mongoose-schema 27.8.5 → 28.0.0-beta.3

package/models/preset.js

@@ -1,845 +0,0 @@
-'use strict'
-
-const _ = require('lodash')
-const moment = require('moment')
-const debug = require('debug')('model:preset')
-
-/**
- * Internal method - _parsePresetForm
- * All query should gothrough this handler before search for compatible issue
- */
-function _queryCompatibilityHandler(query) {
-  let formatQuery = {}
-  if (_.has(query, 'preset_for') && query['preset_for'] === 'amp2') {
-    formatQuery = _.assign({}, query, { preset_for: { $in: ['amp2', 'bias'] } })
-  } else if (!_.has(query, 'preset_for') || query['preset_for'] === '') {
-    formatQuery = _.assign({}, query, { preset_for: 'jamup' })
-  }
-
-  if (_.isEmpty(formatQuery)) {
-    formatQuery = _.clone(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 (!_.has(req.query, 'preset_for') || (_.has(req.query, 'preset_for') && req.query['preset_for'] !== 'live')) {
-    return _.clone(queryObj)
-  } else if (_.has(req.query, 'preset_version') && _.has(req.query, 'version_comparison')) {
-    if (_.indexOf(supportVersionComparison, req.query['version_comparison']) !== -1) {
-      const tmpVersionQuery = _.clone(queryObj)
-      const versionQuery = _buildPresetVersionQuery(req.query['preset_version'], req.query['version_comparison'])
-      if (versionQuery) {
-        return _.merge(tmpVersionQuery, versionQuery)
-      }
-    }
-  }
-
-  return _.clone(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.
- * @param {String} licenseTierParams
- */
-function _buildLicenseTierQuery(licenseTierParam) {
-  const tmpLicenseTier = String(licenseTierParam).split(',')
-
-  let tmpData = new Set()
-  let expansionData = new Set()
-  let allExpansion = new Set(['celestion', 'classic'])
-  _.forEach(tmpLicenseTier, 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': _.concat(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
-}
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-  const deepPopulate = require('mongoose-deep-populate')(mongoose)
-
-  const filterKeyword = (keyword) => {
-    return String(keyword).replace(/[/\\@%&]+/g, '')
-  }
-
-  const parsePageParams = function (data) {
-    debug('parsePageParams', data)
-    let pageParams = {
-      page_size: 12,
-      page: 1
-    }
-
-    if (data && _.has(data, 'page_size')) {
-      let pageSize = Array.isArray(data['page_size'])
-        ? parseInt(data['page_size'].pop(), 10)
-        : parseInt(data['page_size'], 10)
-
-      if (pageSize >= 1) {
-        pageParams = _.merge(pageParams, { page_size: pageSize })
-      }
-    }
-
-    if (data && _.has(data, 'page')) {
-      let page = (Array.isArray(data['page']))
-        ? parseInt(data['page'].pop(), 10)
-        : parseInt(data['page'], 10)
-
-      if (page > 1) {
-        pageParams = _.merge(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
-  })
-
-  var PresetUserComment = 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' })
-
-  var PresetUserLike = 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' })
-
-  let PresetUserDownload = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    preset_id: { type: ObjectId, ref: 'Preset', required: true },
-    preset_for: { type: String, reqired: true },
-    date_download: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'jamup_userpresetdownload' })
-
-  let PopularPresetList = 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' })
-
-  /**
-   * Plugin
-   */
-  PresetSchema.plugin(deepPopulate, {})
-  PresetUserLike.plugin(deepPopulate, {})
-  PresetUserComment.plugin(deepPopulate, {})
-
-  PresetSchema.static({
-    getPresetByUserId: function (userId, cb) {
-      this.find({ creator_id: userId })
-        .sort({ created_on: -1 })
-        .exec(cb)
-    },
-    getPresetByQuery: async function (req, opts = {}) {
-      let pageParams = {}
-      let searchCondition = []
-      let shouldCondition = []
-
-      debug('getPresetByQuery:input:%j', req.query)
-      if (!_.has(req.query, 'keyword') || !_.isString(req.query.keyword)) {
-        throw new Error('missing the searching term')
-      }
-
-      pageParams = parsePageParams(req.query)
-      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 (_.has(req.query, 'license_tier')) {
-        const tmpQuery = _.clone(searchCondition)
-        searchCondition = _.merge(tmpQuery, _buildLicenseTierQuery(req.query['license_tier']))
-      }
-
-      if (_.has(req.query, 'order') && req.query.order === 'hot') {
-        searchCondition = _.assign({}, searchCondition, { created_on: { $gte: moment().subtract(1, 'month').toDate() } })
-      }
-
-      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 (!_.has(opts, 'full')) {
-        aggregatePipeline.push({
-          $project: {
-            preset_data: 0
-          }
-        })
-      }
-
-      const result = await this.aggregate(aggregatePipeline)
-      return result
-    },
-    getPresetsBySearch: async function (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 (!_.has(req.query, 'detail') || req.query.detail !== 'yes') {
-        // selectOps = '-preset_data'
-        selectOps = { preset_data: 0 }
-      }
-
-      if (_.has(req.query, 'pids')) {
-        const pids = req.query.pids.split(',')
-        searchCondition['_id'] = {
-          '$in': pids
-        }
-      }
-
-      if (_.has(req.query, 'category')) {
-        const categories = String(req.query['category']).split(',')
-        searchCondition['category'] = {
-          '$in': categories
-        }
-      } else if (_.has(req.query, 'except_cateogry')) {
-        const exceptCategories = String(req.query['except_cateogry']).split(',')
-        searchCondition['category'] = {
-          '$nin': exceptCategories
-        }
-      }
-
-      if (_.has(req.query, 'pedal_type')) {
-        searchCondition['preset_meta.pedal_type'] = req.query['pedal_type']
-      }
-
-      // featureKey1:Val1,featureKey2:Val2
-      if (_.has(req.query, 'preset_features')) {
-        let params = req.query['preset_features'].split(',')
-        let featureQuery = {}
-        _.forEach(params, (param) => {
-          let 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
-      let createQuery = {}
-      if (_.has(req.query, 'create_after')) {
-        let verifyDate = moment(req.query['create_after'])
-        if (verifyDate.isValid()) {
-          createQuery['$gte'] = verifyDate.toDate()
-        }
-      }
-
-      if (_.has(req.query, 'create_before')) {
-        let verifyDate = moment(req.query['create_before'])
-        if (verifyDate.isValid()) {
-          createQuery['$lte'] = verifyDate.toDate()
-        }
-      }
-      if (!_.isEmpty(createQuery)) {
-        searchCondition['created_on'] = createQuery
-      }
-
-      // updated_after/updated_before - assign preset updated_on date
-      let updateQuery = {}
-      if (_.has(req.query, 'update_after')) {
-        let verifyDate = moment(req.query['update_after'])
-        if (verifyDate.isValid()) {
-          updateQuery['$gte'] = verifyDate.toDate()
-        }
-      }
-      if (_.has(req.query, 'update_before')) {
-        let verifyDate = moment(req.query['update_before'])
-        if (verifyDate.isValid()) {
-          updateQuery['$lte'] = verifyDate.toDate()
-        }
-      }
-      if (!_.isEmpty(updateQuery)) {
-        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 (_.has(req.query, 'license_tier')) {
-        const tmpQuery = _.clone(searchCondition)
-        searchCondition = _.merge(tmpQuery, _buildLicenseTierQuery(req.query['license_tier']))
-      }
-
-      if (_.has(req.query, 'order') && req.query.order === 'hot') {
-        searchCondition = _.assign({}, searchCondition, { created_on: { $gte: moment().subtract(1, 'month').toDate() } })
-      }
-
-      // signal_chain_type query only works in Spark for now
-      if (searchCondition.preset_for === 'spark') {
-        if (_.has(req.query, 'signal_chain_type')) {
-          searchCondition.signal_chain_type = req.query.signal_chain_type
-        }
-        if (_.has(req.query, 'no_dspid')) {
-          searchCondition['preset_meta.dspId'] = { $nin: String(req.query.no_dspid).split(',') }
-        }
-      }
-
-      searchCondition = _handlePresetVersion(searchCondition, req)
-
-      debug('getPresetsBySearch:full_text %j %j', searchCondition, sortCondition)
-      if (
-        _.has(req, 'query.keyword') &&
-        !_.isEmpty(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 (_.has(process.env, 'IS_CHINA')) {
-          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
-      }
-    },
-    getPresetsList: function (query, sort, req, cb) {
-      let pageParams = parsePageParams(req.query)
-
-      // only select preset status == 0
-      if (_.isObject(query)) {
-        query['status'] = 0
-      }
-
-      if (_.has(query, 'preset_for') && query['preset_for'] !== 'jamup') {
-        query['image_url'] = { $ne: null }
-        query['thumb_url'] = { $ne: null }
-      }
-
-      if (_.has(req.query, 'license_tier')) {
-        const tmpQuery = _.clone(query)
-        query = _.merge(tmpQuery, _buildLicenseTierQuery(req.query['license_tier']))
-      }
-      if (_.has(req.query, 'order')) {
-        sort = _buildSortQuery(req.query.order)
-      }
-
-      query = _handlePresetVersion(query, req)
-      debug('getPresetsList:%j', query)
-      this.find(_queryCompatibilityHandler(query))
-        .sort(sort)
-        .select('-preset_data')
-        .skip((pageParams['page'] - 1) * pageParams['page_size'])
-        .limit(pageParams['page_size'])
-        .exec(cb)
-    },
-    getPresetsListPromise: function (query, sort, req) {
-      const self = this
-      return new Promise((resolve, reject) => {
-        this.getPresetsList(query, sort, req, (err, likes) => {
-          return (err) ? reject(err) : resolve(likes)
-        })
-      })
-    },
-    getMyPresets: function (query, sort, req, cb) {
-      let pageParams = parsePageParams(req.query)
-
-      if (_.isObject(query)) {
-        query['status'] = { $in: [0, 2] }
-      }
-
-      if (_.has(query, 'preset_for') && query['preset_for'] !== 'jamup') {
-        query['image_url'] = { $ne: null }
-        query['thumb_url'] = { $ne: null }
-      }
-
-      query = _handlePresetVersion(query, req)
-      debug('getMyPresets:%o', query)
-      this.find(_queryCompatibilityHandler(query))
-        .sort(sort)
-        .select('-preset_data')
-        .skip((pageParams['page'] - 1) * pageParams['page_size'])
-        .limit(pageParams['page_size'])
-        .exec(cb)
-    },
-    getOnePresetByCondition: function (query, opts, cb) {
-      let defaultSort = (_.has(opts, 'sort') && _.isObject(opts.sort)) ? opts.sort : { created_on: -1 }
-      let defaultSelect = (_.has(opts, 'select') && _.isString(opts.select)) ? opts.select : ''
-
-      this.findOne(_queryCompatibilityHandler(query))
-        .sort(defaultSort)
-        .select(defaultSelect)
-        .exec(cb)
-    },
-    getSinglePreset: function (id, cb) {
-      this.findOne({ '_id': id, 'status': 0 }).exec(cb)
-    },
-    getValidSinglePreset: function (id, cb) {
-      this.findOne({ '_id': id, 'status': { $in: [0, 2, 3] } }).exec(cb)
-    }
-  })
-
-  PresetUserComment.static({
-    getPresetComments: async function (presetId, req) {
-      try {
-        const pageParams = parsePageParams(req.query)
-        const ret = await this.aggregate([
-          { $match: { preset_id: 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: 'user_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
-      }
-    }
-  })
-
-  PresetUserLike.static({
-    getCountByPresetCondition: function (query, condition, cb) {
-      this.find(query)
-        .populate('preset_id')
-        .exec((err, result) => {
-          debug('getCountByPresetCondition', query, condition, result, result.length)
-          if (err) {
-            return cb(err)
-          } else {
-            let filterVal = _.filter(result, (item) => {
-              let tmpObj = item.toObject()
-              return _.has(tmpObj['preset_id'], condition)
-            })
-            return cb(null, filterVal.length)
-          }
-        })
-    },
-    getPresetLikeList: function (query, sort, req, cb) {
-      const pageParams = parsePageParams(req.query)
-      const defaultPresetCondition = {
-        'preset.status': { '$eq': 0 }
-      }
-      let filterQuery = {}
-      if (_.has(query, 'no_dspid')) {
-        defaultPresetCondition['preset.preset_meta.dspId'] = { '$nin': String(query.no_dspid).split(',') }
-        filterQuery = _.omit(query, ['no_dspid'])
-      } else {
-        filterQuery = _.clone(query)
-      }
-
-      const aggregateQuery = [{
-        '$match': _.assign({}, _queryCompatibilityHandler(filterQuery), { user_id: 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 (_.isEmpty(presetQuery)) {
-        debug('getPresetLikeList:%j:%o', aggregateQuery, sort)
-        this.aggregate(aggregateQuery)
-          .sort({ date_like: -1 })
-          .skip((pageParams['page'] - 1) * pageParams['page_size'])
-          .limit(pageParams['page_size'])
-          .exec(cb)
-      } else {
-        if (_.has(presetQuery, '$and') && _.isArray(presetQuery['$and'])) {
-          _.forEach(presetQuery['$and'], item => {
-            let newQuery = { '$match': {} }
-            const objKey = _.keys(item)
-            const objVal = _.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)
-        this.aggregate(aggregateQuery)
-          .sort({ date_like: -1 })
-          .skip((pageParams['page'] - 1) * pageParams['page_size'])
-          .limit(pageParams['page_size'])
-          .exec(cb)
-      }
-    },
-    getPresetLikeListPromise: function (query, sort, req) {
-      const self = this
-      return new Promise((resolve, reject) => {
-        this.getPresetLikeList(query, sort, req, (err, likes) => {
-          return (err) ? reject(err) : resolve(likes)
-        })
-      })
-    }
-  })
-
-  PresetSchema.virtual('id').get(function () {
-    return this._id.toHexString()
-  })
-  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) {
-      this._versionDetail = presetVersion.split('.')
-      const major = this._versionDetail[0]
-      const minor = this._versionDetail[1]
-
-      this.set('version.major', parseInt(major, 10))
-      this.set('version.minor', parseInt(minor, 10))
-    })
-
-  mongoose.model('Preset', PresetSchema)
-  mongoose.model('PresetComment', PresetUserComment)
-  mongoose.model('PresetLike', PresetUserLike)
-  mongoose.model('PresetDownload', PresetUserDownload)
-  mongoose.model('PopularPresetList', PopularPresetList)
-  mongoose.model('FakePresetLike', FakePresetLikeSchema)
-  mongoose.model('PresetTagsMeta', PresetTagsMetaSchema)
-  mongoose.model('PresetSongMapping', PresetSongMappingSchema)
-}