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

package/models/promotion.js

@@ -1,590 +0,0 @@
-'use strict'
-
-module.exports = (mongoose) => {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-  const _ = require('lodash')
-  const debug = require('debug')('model:promotion')
-
-  // Support license campaign types
-  const CAMPAIGN_TYPE = [
-    'free_upgrade'
-  ]
-
-  /**
-   * To make this collection fulfill any kinds of promotion events.
-   * We just put a type & detail, so it could be as flexible as possible.
-   * In our first sample, FX license upgrade, we'll use "free_upgrade" as type
-   * and detail would be "from" & "to".
-   */
-  const LicenseCampaignMetaSchema = new Schema({
-    campaign_type: { type: String, enum: CAMPAIGN_TYPE, required: true },
-    campaign_detail: { type: Schema.Types.Mixed, required: true },
-    status: { type: Number, default: 1, required: true },
-    start_date: { type: Date, default: null },
-    end_date: { type: Date, default: null },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'license_campaign_meta' })
-
-  const LicenseCampaignRecordSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'auth_user', required: true },
-    campaign_event_id: { type: ObjectId, ref: 'license_campaign_meta', required: true },
-    status: { type: Number, default: 1, required: true },
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'license_campaign_record' })
-
-  /**
-   * News announcement system will be used on our app.
-   * spec: https://docs.google.com/document/d/1nvcqzKCiEtZY3Vt7laC7BENzk6_ylWuCJ9QNdHzqfeE/edit#heading=h.h63h324getn9
-   */
-  const PublicAnnouncementSchema = new Schema({
-    title: { type: String, required: true },
-    content: { type: String, required: true },
-    type: { type: String, enum: ['announcement', 'freetrial'] },
-    country: [{ type: String }],
-    image: { type: String, default: null },
-    image_type: { type: String },
-    message_type: { type: String },
-    action_button: [{
-      type: { type: String, required: true },
-      text: { type: String, required: true },
-      // if type is free_trial the value would be object, with two special attributes:
-      // license_tier/days_after_activate/minutes_after_activate
-      // licenseTier: 1:elite/2:pro/3:std/4:lite
-      value: { type: Schema.Types.Mixed },
-      read: { type: Boolean, required: true }
-    }],
-    show_countdown: { type: Boolean, default: false, required: true },
-    // This field use to filter which product line the announcement will show.
-    // Follow the same name using on product name. e.g., bias/live/amp2/pedal
-    announce_for: [{ type: String, required: true }],
-    // This field use to filter by target audience device
-    // e.g, desktop/ios/hardware
-    target_audience_device: [{ type: String, required: true }],
-    device_os: { type: String },
-    device_list: [{ type: String }],
-    // If accouncement would be filtered by specific license users
-    // which would be the query condition to filter
-    // e.g., demo/lite/std/pro/elite
-    announce_license_tier: [{ type: String, required: true }],
-    announce_mobile_iap: [{ type: String, required: true }],
-    user_list_num: { type: Number, default: 0 },
-    user_list_status: { type: Number, default: 0 }, // 0:no/1:process/2:done
-    user_list_failure: { type: Number, default: 0 },
-    user_list_log: { type: String, default: null },
-    user_list_filename: { type: String, default: null },
-    start_time: { type: Date, default: null },
-    end_time: { type: Date, default: null },
-    locale: { type: String, required: true }, // Follow lang + country code: http://www.lingoes.net/en/translator/langcode.htm
-    order: { type: Number, default: 1 },
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'public_announcement' })
-
-  PublicAnnouncementSchema.static({
-    /**
-     * @param pname {string|array} - Product name used to filter on announce_for field.
-     **/
-    getAvailableAnnouncement: async function (params) {
-      try {
-        const nowTime = new Date()
-        const defaultQuery = {
-          '$and': [
-            { '$or': [{ 'start_time': null }, { 'start_time': { '$lt': nowTime } }] },
-            { '$or': [{ 'end_time': null }, { 'end_time': { '$gt': nowTime } }] },
-          ]
-        }
-
-        if (!_.isUndefined(params)) {
-          debug('getAvailableAnnouncement:querystring %o', params)
-          const {
-            pname,
-            locale,
-            ta_device,
-            country,
-            device_list,
-            device_os
-          } = params
-          if (!_.isUndefined(pname) && _.isString(pname)) {
-            defaultQuery['$and'].push({
-              announce_for: { '$in': _.concat([pname], 'all') }
-            })
-          }
-
-          if (!_.isUndefined(locale) && _.isString(locale)) {
-            defaultQuery['$and'].push({
-              'locale': locale
-            })
-          }
-
-          if (!_.isUndefined(ta_device) && _.isString(ta_device)) {
-            defaultQuery['$and'].push({
-              'target_audience_device': { '$in': _.concat(ta_device.split(','), 'all') }
-            })
-          }
-
-          if (!_.isUndefined(country) && _.isString(country)) {
-            defaultQuery['$and'].push({
-              '$or': [
-                { 'country': { '$all': country.split(',') } },
-                { 'country': { '$in': ['all'] } }
-              ]
-            })
-          } else {
-            defaultQuery['$and'].push({
-              '$or': [{
-                'country': { '$in': ['all'] }
-              }, {
-                'country': { '$exists': false }
-              }]
-            })
-          }
-
-          if (!_.isUndefined(device_list)) {
-            if (_.isString(device_list) && !_.isEmpty(device_list)) {
-              const tmpDeviceList = device_list.split(',')
-              let deviceList = []
-              const allTypeSet = new Set()
-              const uniqueProductLineSet = new Set()
-              tmpDeviceList.forEach(deviceItem => {
-                const optionItem = deviceItem.split('_')
-                uniqueProductLineSet.add(optionItem[0])
-                if (optionItem.length === 2 && optionItem[1] === 'all') {
-                  allTypeSet.add(optionItem[0])
-                } else {
-                  deviceList.push(deviceItem)
-                }
-              })
-              if (allTypeSet.size > 0) {
-                allTypeSet.forEach(item => {
-                  deviceList.push(new RegExp(`^${item}_`))
-                })
-              }
-              if (uniqueProductLineSet.size > 0) {
-                uniqueProductLineSet.forEach(item => {
-                  deviceList.push(`${item}_all`)
-                })
-              }
-              defaultQuery['$and'].push({
-                'device_list': { $in: deviceList }
-              })
-            } else {
-              defaultQuery['$and'].push({
-                'device_list': { $in: ['none'] }
-              })
-            }
-          }
-
-          if (!_.isUndefined(device_os) && _.isString(device_os)) {
-            defaultQuery['$and'].push({
-              '$or': [{
-                'device_os': 'all'
-              }, {
-                'device_os': device_os
-              }]
-            })
-          }
-        }
-
-        let ret
-        // Free trial PA only need to consider within query pass the auth
-        if (!_.has(params, 'email') || (_.has(params, 'email') && _.isUndefined(params.email))) {
-          defaultQuery['$and'].push({ 'user_list_num': 0 })
-          defaultQuery['$and'].push({ 'action_button': { '$elemMatch': { 'type': { '$ne': 'free_trial'} } } })
-
-          ret = await this.find(defaultQuery).lean().exec()
-        } else {
-          const noUserQuery = _.cloneDeep(defaultQuery)
-          noUserQuery['$and'].push({ 'user_list_num': 0 })
-          const hasUserQuery = _.cloneDeep(defaultQuery)
-          hasUserQuery['$and'].push({'user_list_num': {$gt: 0}})
-          debug('getAvailablePA:%j:%j', noUserQuery, hasUserQuery)
-
-          let [noUserData, hasUserData] = await Promise.all([
-            this.aggregate([
-              {
-                '$match': noUserQuery 
-              }
-            ]).exec(),
-            this.aggregate([
-              {
-                '$match': hasUserQuery
-              },
-              {
-                '$lookup': {
-                  'from': 'public_announcement_userlist',
-                  'localField': '_id',
-                  'foreignField': 'pa_id',
-                  'as': 'paUserList'
-                }
-              },
-              {
-                '$unwind': '$paUserList'
-              },
-              {
-                '$match': {
-                  'paUserList.email': String(params.email).toLowerCase(),
-                  'paUserList.status': 1
-                }
-              }
-            ]).exec()
-          ])
-          ret = _.concat(noUserData, hasUserData)
-        }
-
-        debug('INFO:getAvailableAnnouncement %j:%j', ret, defaultQuery)
-        return _.orderBy(ret, ['order', 'start_time'], ['desc', 'asc'])
-      } catch (err) {
-        debug('ERR:getAvailableAnnouncement %j', err)
-        throw err
-      }
-    }
-  })
-
-  const PublicAnnouncementFreeTrialSchema = new Schema({
-    pa_id: { type: ObjectId, ref: 'PublicAnnouncement', required: true },
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    product_id: { type: ObjectId, ref: 'Product', default: null },
-    expansion_id: { type: ObjectId, ref: 'Product', default: null },
-    status: { type: Number, default: 1 },
-    expire_on: { type: Date, required: true },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'public_announcement_free_trial'})
-  PublicAnnouncementFreeTrialSchema.index({ pa_id: 1, user_id: 1, product_id: 1, expansion_id: 1 }, { unique: true })
-
-  PublicAnnouncementFreeTrialSchema.static({
-    getCurrentActiveFreeTrial: async function (params) {
-      try {
-        const { userId } = params
-        if (!userId) {
-          throw new Error('Missing userId')
-        }
-
-        const nowTime = new Date()
-        const ret = await this.aggregate([
-          {
-            '$match': {
-              user_id: mongoose.Types.ObjectId(userId)
-            }
-          },
-          {
-            $lookup: {
-              from: 'public_announcement',
-              localField: 'pa_id',
-              foreignField: '_id',
-              as: 'pa'
-            }
-          },
-          {
-            $unwind: {
-              path: '$pa',
-              preserveNullAndEmptyArrays: false
-            }
-          },
-          {
-            $match: {
-              $and: [
-                { '$or': [{ 'pa.start_time': null }, { 'pa.start_time': { '$lt': nowTime } }] },
-                { '$or': [{ 'pa.end_time': null }, { 'pa.end_time': { '$gt': nowTime } }] },
-              ]
-            }
-          }
-        ]).exec()
-
-        debug('INFO:getCurrentActiveFreeTrial:%j:%j', ret, params)
-        return ret
-      } catch (err) {
-        debug('ERR:getAvailableFreeTrial %o', err)
-        throw err
-      }
-    }
-  })
-
-  const PublicAnnouncementUserListSchema = new Schema({
-    pa_id: { type: ObjectId, ref: 'PublicAnnouncement', required: true },
-    email: { type: String, required: true },
-    user_id: { type: ObjectId, ref: 'User' },
-    status: { type: Number, default: 1, required: true }, // 1:active/2:inactive/3:used
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'public_announcement_userlist' })
-
-  PublicAnnouncementUserListSchema.static({
-    getAvailableAnnouncementByEmail: async function (email) {
-      try {
-        const ret = this.aggregate([
-          {
-            '$match': {
-              'email': String(email).toLowerCase(),
-              'status': 1
-            }
-          },
-          {
-            '$lookup': {
-              'from': 'public_announcement',
-              'localField': 'pa_id',
-              'foreignField': '_id',
-              'as': 'pa'
-            }
-          },
-          {
-            '$match': {
-              '$and': [
-                { '$or': [{ '$pa.start_time': null }, { '$pa.start_time': { '$lt': nowTime } }] },
-                { '$or': [{ '$pa.end_time': null }, { '$pa.end_time': { '$gt': nowTime } }] },
-                { '$pa.user_list_num': { $gt: 0 } }
-              ]
-            }
-          }
-        ]).exec()
-        debug('INFO:getAvailableAnnouncementByEmail:%o', ret)
-        return ret
-      } catch (err) {
-        debug('ERR:getAnnouncementFromUserList:%o', err)
-        throw err
-      }
-    }
-  })
-
-  const PublicAnnouncementUserListLog = new Schema({
-    pa_id: { type: ObjectId, ref: 'PublicAnnouncement', required: true },
-    message: { type: Schema.Types.Mixed }
-  }, { collection: 'public_announcement_userlist_log' })
-
-  const IasBuyOptionSchema = new Schema({
-    type: { type: String, required: true },
-    sku: { type: String, required: true },
-    description: { type: String, required: true },
-    cta_name: { type: String, required: true },
-    created_on: { type: Date, default: Date.now, required: true },
-    locale: { type: String, required: true }
-  }, { collection: 'ias_buy_option' })
-
-  const IasStorePageMetaSchema = new Schema({
-    product: { type: String, required: true },
-    expansion: { type: Boolean, default: false },
-    license: { type: String, required: true },
-    buy_option: [{ type: ObjectId, ref: 'IasBuyOption', required: true }],
-    created_on: { type: Date, default: Date.now, required: true },
-    promotion_target_audiance: { type: String, required: true },
-    promotion_discount: { type: String, required: true },
-    product_description: { type: String, required: true },
-    quote_image: { type: String, required: true },
-    locale: { type: String, required: true },
-    cta_image: { type: String },
-    cta_button_text: { type: String },
-    cta_button_show_svg: { type: Boolean },
-    cta_button_action_url: { type: String }
-  }, { collection: 'ias_store_page_meta' })
-
-  const IasPromotionSchema = new Schema({
-    start_time: { type: Date, required: true },
-    end_time: { type: Date, required: true },
-    quote_image: { type: String, required: true },
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'ias_promotion' })
-
-  const SpecialOfferSchema = new Schema({
-    title: { type: String, required: true },
-    content: { type: String, required: true },
-    image: { type: String, default: null },
-    action_button: [{
-      type: { type: String, required: true },
-      text: { type: String, required: true },
-      value: { type: Schema.Types.Mixed },
-      read: { type: Boolean, required: true }
-    }],
-    announce_for: [{ type: String, required: true }],
-    target_audience_device: [{ type: String, required: true }],
-    start_time: { type: Date, default: null },
-    end_time: { type: Date, default: null },
-    created_on: { type: Date, default: Date.now, required: true },
-    locale: { type: String, required: true }
-  }, { collection: 'special_offer' })
-
-  const PromotionSchema = new Schema({
-    name: { type: String, required: true },
-    start_date: { type: Date, required: true },
-    end_date: { type: Date, required: true },
-    items: [{
-      sku: { type: String, required: true },
-      sale_price: { type: Number, required: true },
-      price: { type: Number, required: true },
-      name: { type: String, required: true }
-    }]
-  }, { collection: 'promotion' })
-
-  // Use for campaign event which will collect user information
-  const CampaignUserInfoSchema = new Schema({
-    campaign: { type: String, required: true },
-    email: { type: String, required: true },
-    name: { type: String },
-    redeem: { type: String },
-    metadata: { type: Schema.Types.Mixed },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'campaign_user_info' })
-  CampaignUserInfoSchema.index({ campaign: 1 })
-  CampaignUserInfoSchema.index({ campaign: 1, email: 1 }, { unique: true })
-  CampaignUserInfoSchema.index({ campaign: 1, email: 1, redeem: 1 })
-
-  const CouponPromotionSchema = new Schema({
-    email: { type: String, required: true },
-    code: { type: String, required: true },
-    referral: { type: String },
-    event: { type: String },
-    type: { type: String },
-    metadata: { type: Schema.Types.Mixed },
-    status: { type: Number, default: 1, required: true },
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'coupon_promotion' })
-  CouponPromotionSchema.index({ email: 1, event: 1 })
-  CouponPromotionSchema.index({ email: 1, event: 1, referral: 1 }, { unique: true })
-
-  const TierSalesMetaSchema = new Schema({
-    campaign_key: { type: String, required: true },
-    current_tier_sales_rule: {
-      type: ObjectId,
-      ref: 'TierSalesRules',
-    },
-    current_tier_startdate: { type: Date, default: null },
-    process_log: [
-      {
-        from_tier_id: {
-          type: ObjectId,
-          ref: 'TierSalesRules',
-          required: true,
-        },
-        to_tier_id: {
-          type: ObjectId,
-          ref: 'TierSalesRules',
-          required: true,
-        },
-        updated_on: { type: Date, required: true },
-      },
-    ],
-    status: { type: Number, default: 1 }, // 1:start/2:end/3:draft
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'tier_sales_meta' }) 
-
-	const TierSalesRulesSchema = new Schema({
-		campaign_key: { type: String, required: true },
-		tier_level: { type: Number, default: 1, required: true },
-		tier_type: { type: Number, default: 0 }, //0:no/1:reach_goal/2:not_reach
-		pre_rule_id: {
-			type: ObjectId,
-			ref: 'TierSalesRules',
-		},
-		price: { type: Number, required: true },
-		ta_sku: { type: String, required: true },
-		next_sku: { type: String, default: null },
-		goal: [
-			{
-				type: { type: String }, // sold/time
-				value: { type: Number }, // if the type is 'sold' then number, if 'time' then minute
-			},
-		],
-		force_switch_tier: { type: Date, default: null },
-		is_final_tier: { type: Boolean, default: false },
-		status: { type: Number, default: 1 },
-		created_on: { type: Date, default: Date.now }
-	}, { collection: 'tier_sales_rules' })
-
-  const GearTrialMetaSchema = new Schema({
-    title: { type: String, required: true },
-    // This field use to filter which product line the announcement will show.
-    // Follow the same name using on product name. e.g., amp2/fx2
-    announce_for: [{ type: String, required: true }],
-    // This field use to filter by target audience device
-    // e.g, desktop/ios/hardware
-    target_audience_device: [{ type: String, required: true }],
-    locale: { type: String, required: true }, // Follow lang + country code: http://www.lingoes.net/en/translator/langcode.htm
-    target_product_sku: [{ type: String, required: true }],
-    expires: { type: Number, required: true },
-    status: { type: Number, default: 1, required: true },	//inactive: 0/active: 1
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'gear_trial_meta' })
-  GearTrialMetaSchema.index({ status: 1 })
-
-  const GearTrialRecordSchema = new Schema({
-    gear_trial_id: { type: ObjectId, ref: 'gear_trial_meta', required: true },
-    user_id: { type: ObjectId, ref: 'auth_user', required: true },
-    expire_on: { type: Date, required: true },
-    created_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'gear_trial_record' })
-  GearTrialRecordSchema.index({ gear_trial_id: 1, user_id: 1 })
-  GearTrialRecordSchema.index({ user_id: 1, expire_on: 1 })
-
-  const YotpoLoyaltySchema = new Schema({
-    user_id: { type: ObjectId, ref: 'auth_user', required: true },
-    main_region: { type: String, required: true },
-    active_regions: [{
-      code: { type: String, required: true },
-      points_balance: { type: Number, default: 0, required: true },
-      points_earned: { type: Number, default: 0, required: true },
-    }],
-    history: [{
-      created_at: { type: String, required: true },
-      date: { type: String, required: true },
-      completed_on: { type: String, default: null },
-      action: { type: String, default: null },
-      points: { type: Number, default: 0 },
-      status: { type: String, default: null },
-      action_name: { type: String, default: null },
-      order_ids: [{ type: String }]
-    }],
-    created_on: { type: Date, default: Date.now, required: true },
-    updated_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'auth_yotpo_loyalty' })
-  YotpoLoyaltySchema.index({ user_id: 1 }, { unique: true })
-  YotpoLoyaltySchema.index({ user_id: 1, main_region: 1, 'active_regions.code': 1 })
-
-  const YotpoLoyaltyBackupSchema = new Schema({
-    email: { type: String, required: true },
-    store_code: { type: String, required: true },
-    status: { type: Number, default: 1, required: true }, // 1:wait for apply/2:applied/3:deleted
-    created_on: { type: Date, default: Date.now, required: true },
-  }, { collection: 'yotpo_loyalty_backup' })
-  YotpoLoyaltyBackupSchema.index({ email: 1, store_code: 1 }, { unique: true })
-
-  const FreeTrialSchema = new Schema({
-    campaign_name: { type: String, required: true },
-    campaign_code: { type: String, required: true },
-    content: { type: String, default: null },
-    products: [{ type: ObjectId, ref: 'Product', required: true }],
-    status: { type: Number, default: 1, required: true }, // 0:draft/1:actived/2:deactivated
-    start_time: { type: Date, required: true },
-    end_time: { type: Date, required: true },
-    trial_days: { type: Number, default: 0 },
-    not_allow_same_product: { type: Boolean, default: false },
-    created_by: { type: String, default: null },
-    terminate: {
-      reason: { type: String },
-      user: { type: String },
-      time: { type: Date },
-    },
-    metadata: { type: Schema.Types.Mixed, default: null },
-    created_on: { type: Date, default: Date.now, required: true },
-    updated_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'free_trial_campaign' })
-  FreeTrialSchema.index({ campaign_code: 1 }, { unique: true })
-
-
-  mongoose.model('LicenseCampaignMeta', LicenseCampaignMetaSchema)
-  mongoose.model('LicenseCampaignRecord', LicenseCampaignRecordSchema)
-  mongoose.model('PublicAnnouncement', PublicAnnouncementSchema)
-  mongoose.model('PublicAnnouncementUserList', PublicAnnouncementUserListSchema)
-  mongoose.model('PublicAnnouncementUserListLog', PublicAnnouncementUserListLog)
-  mongoose.model('PublicAnnouncementFreeTrial', PublicAnnouncementFreeTrialSchema)
-  mongoose.model('IasBuyOption', IasBuyOptionSchema)
-  mongoose.model('IasStorePageMeta', IasStorePageMetaSchema)
-  mongoose.model('IasPromotion', IasPromotionSchema)
-  mongoose.model('SpecialOffer', SpecialOfferSchema)
-  mongoose.model('Promotion', PromotionSchema)
-  mongoose.model('CampaignUserInfo', CampaignUserInfoSchema)
-  mongoose.model('CouponPromotion', CouponPromotionSchema)
-	mongoose.model('TierSalesMeta', TierSalesMetaSchema)
-	mongoose.model('TierSalesRules', TierSalesRulesSchema)
-  mongoose.model('GearTrialMeta', GearTrialMetaSchema)
-  mongoose.model('GearTrialRecord', GearTrialRecordSchema)
-  mongoose.model('YotpoLoyalty', YotpoLoyaltySchema)
-  mongoose.model('YotpoLoyaltyBackup', YotpoLoyaltyBackupSchema)
-  mongoose.model('FreeTrial', FreeTrialSchema)
-}

package/models/redeem.js

@@ -1,26 +0,0 @@
-'use strict'
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  const RedeemCodeSchema = new Schema({
-    code: { type: String, required: true },
-    product_id: { type: ObjectId, ref: 'Product', default: null },
-    bundle_id: { type: ObjectId, ref: 'Bundle', default: null },
-    user_id: { type: ObjectId, ref: 'User', default: null },
-    status: { type: Number, default: 1, required: true }, //1:active/2:used/3:invalid/4:refunded
-    expire_on: { type: Date, default: null },
-    trial_due_date: { type: Date, default: null },
-    tracker: { type: String, required: true },
-    metadata: { type: Schema.Types.Mixed },
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'pg_redeem_code' })
-  RedeemCodeSchema.index({ code: 1, status: 1 }, { unique: true })
-  RedeemCodeSchema.index({ code: 1, product_id: 1, status: 1 })
-  RedeemCodeSchema.index({ code: 1, bundle_id: 1, status: 1 })
-  RedeemCodeSchema.index({ tracker: 1 })
-
-  mongoose.model('RedeemCode', RedeemCodeSchema)
-}

package/models/toneTheme.js

@@ -1,78 +0,0 @@
-'use strict'
-
-const mongooseLeanVirtuals = require('mongoose-lean-virtuals')
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-
-  const ToneThemeSchema = new Schema({
-    title: {
-      type: String,
-      required: true,
-      trim: true
-    },
-    description: {
-      type: String,
-      trim: true,
-      default: null
-    },
-    cover_image_url: {
-      type: String,
-      default: null
-    },
-    thumb_url: {
-      type: String,
-      default: null
-    },
-    order: {
-      type: Number,
-      default: 0
-    },
-    is_shown: {
-      type: Boolean,
-      default: false
-    },
-    list_for: {
-      type: String,
-      required: true
-    },
-    category: {
-      type: String,
-      default: null
-    },
-    tags: [{
-      type: String
-    }],
-    created_on: {
-      type: Date,
-      default: Date.now
-    },
-    updated_on: {
-      type: Date,
-      default: Date.now
-    }
-  }, {
-    collection: 'tone_theme',
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-  })
-
-  // 索引
-  ToneThemeSchema.index({
-    list_for: 1,
-    is_shown: 1,
-    order: 1,
-    created_on: -1
-  })
-  ToneThemeSchema.index({ category: 1 })
-  ToneThemeSchema.index({ tags: 1 })
-
-  ToneThemeSchema.plugin(mongooseLeanVirtuals)
-
-  ToneThemeSchema.virtual('id')
-    .get(function () {
-      return this._id.toHexString()
-    })
-
-  mongoose.model('ToneTheme', ToneThemeSchema)
-}