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

package/models/toneThemeFeaturedList.js

@@ -1,49 +0,0 @@
-'use strict'
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  const ToneThemeFeaturedListSchema = new Schema({
-    tone_theme_id: {
-      type: ObjectId,
-      ref: 'ToneTheme',
-      required: true
-    },
-    featured_list_id: {
-      type: ObjectId,
-      ref: 'FeaturedList',
-      required: true
-    },
-    order: {
-      type: Number,
-      default: 0
-    },
-    created_on: {
-      type: Date,
-      default: Date.now
-    }
-  }, {
-    collection: 'tone_theme_featured_list'
-  })
-
-  // 索引
-  ToneThemeFeaturedListSchema.index({
-    tone_theme_id: 1,
-    order: 1
-  })
-
-  ToneThemeFeaturedListSchema.index({
-    featured_list_id: 1
-  })
-
-  // 確保同一個 featured_list 不會被加入同一個 theme 兩次
-  ToneThemeFeaturedListSchema.index({
-    tone_theme_id: 1,
-    featured_list_id: 1
-  }, {
-    unique: true
-  })
-
-  mongoose.model('ToneThemeFeaturedList', ToneThemeFeaturedListSchema)
-}

package/models/user.js

@@ -1,639 +0,0 @@
-'use strict'
-
-const crypto = require('crypto')
-const randomString = require('random-string')
-const _ = require('lodash')
-const ApiErrorCode = require('@positivegrid/pg-error').ApiErrorCode
-const isEmail = require('is-email')
-const debug = require('debug')('model:user')
-
-module.exports = function (mongoose) {
-  const Schema = mongoose.Schema
-  const ObjectId = Schema.Types.ObjectId
-
-  function encryptPassword (pwd) {
-    if (!pwd) return ''
-
-    const encryptType = 'sha1'
-    const salt = randomString({ length: 5, numeric: true, letters: true }).toLowerCase()
-    const password = crypto.createHash(encryptType).update(String(salt) + String(pwd)).digest('hex')
-
-    return `${encryptType}$${salt}$${password}`
-  }
-
-  function verifyPassword (pwd, pwdArr) {
-    if (!pwd) return false
-
-    return (crypto.createHash(pwdArr[0]).update(String(pwdArr[1]) + String(pwd)).digest('hex') === pwdArr[2])
-  }
-
-  const FLAG_EMAIL_EVENTS = [
-    'bounce',
-    'complaint',
-    'reject'
-  ]
-  const UserEmailStatusSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    email_status: { type: String, enum: FLAG_EMAIL_EVENTS, required: true },
-    creted_on: { type: Date, default: Date.now, required: true }
-  }, { collection: 'user_email_status' })
-
-  let UserProfileSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    full_name: { type: String, default: null },
-    first_name: { type: String, default: null },
-    last_name: { type: String, default: null },
-    title: { type: String, default: null },
-    gender: { type: String, default: null },
-    country: { type: String, default: null },
-    postal: { type: String, default: null },
-    city: { type: String, default: null },
-    state: { type: String, default: null },
-    address: { type: String, default: null },
-    phone: { type: String, default: null },
-    description: { type: String },
-    bc_token: { type: String, default: null },
-    facebook_access_token: { type: String, default: null },
-    reset_password_token: { type: String, default: null },
-    profile_image_url: { type: String, default: null },
-    profile_thumb_url: { type: String, default: null },
-    facebook_image_url: { type: String, default: null },
-    facebook_thumb_url: { type: String, default: null },
-    reset_password_expire: { type: Date, default: null },
-    is_email_verified: { type: Boolean, default: false },
-    is_registered: { type: Boolean, default: true },
-    stripe_customer_id: { type: String, default: null },
-    selected_country: { type: String, default: null },
-    date_joined: { type: Date, default: Date.now },
-    search_mark: { type: Number, default: 0 } // control the order of search
-  }, { collection: 'jamup_userprofile', toJSON: { virtuals: true }, toObject: { virtuals: true } })
-  UserProfileSchema
-    .index({ user_id: 1 }, { unique: true })
-    .index({ reset_password_token: 1 })
-  UserProfileSchema.index({full_name: 'text', first_name: 'text', last_name: 'text'})
-
-  const UserAddressSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    country: { type: String, default: null },
-    zip: { type: String, default: null },
-    city: { type: String, default: null },
-    state: { type: String, default: null },
-    address: { type: String, default: null },
-    phone: { type: String, default: null },
-    default: { type: Boolean, default: false }
-  })
-
-  const emailFormat = [/^\S+@\S+\.\S+$/, 'Invalid Email Address']
-  let UserSchema = new Schema({
-    username: { type: String, trim: true, required: true },
-    email: { type: String, trim: true, unique: true, match: emailFormat, required: true },
-    password: { type: String, default: null, set: encryptPassword, required: true },
-    user_status: { type: Number, default: 1 }, // 1: active 2: delete 3: migration
-    user_role: { type: Number, default: 1 }, // 1: users, 2: member, 3: admin, 4: partner/dealer
-    is_active: { type: Boolean, default: false },
-    activate_token: { type: String, default: null },
-    activate_expire: { type: Date, default: null },
-    fb_access_token: { type: String, default: null },
-    facebook_id: { type: String, default: null },
-    shopify_id: { type: Schema.Types.Mixed, default: null },
-    bk_username: [{ type: String }],
-    auth: {
-      firebase_id: { type: String },
-      google_id: { type: String },
-      apple_id: { type: String },
-      wechat_id: { type: String }
-    },
-    metadata: {
-      gdpr: { type: Boolean, default: false },
-      country: { type: String, default: null },
-    },
-    date_joined: { type: Date, default: Date.now },
-    last_login: { type: Date, default: Date.now }
-  }, { collection: 'auth_user', toJSON: { virtuals: true }, toObject: { virtuals: true } })
-  UserSchema
-    .index({ shopify_id: 1 })
-    .index({ username: 1 })
-    .index({ email: 1 }, { unique: true })
-    .index({ 'auth.firebase_id': 1 })
-    .index({ 'auth.apple_id': 1 })
-    .index({ 'auth.facebook_id': 1 })
-
-  // Remove in the future?
-  const UserProductSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    product: { type: String, required: true },
-    platform: { type: 'String', required: true },
-    metadata: { type: Schema.Types.Mixed, default: null },
-    last_login: { type: Date, default: Date.now }
-  }, { collection: 'user_product_meta' })
-
-  /**
-   * Save user product status which will co-work with Listrak segmentation
-   * Hope to replace UserProductSchema after it works stable.
-   */
-  const UserProductTrackerSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    product: { type: String, required: true },
-    status: { type: Number, default: 1 },
-    created_on: { type: Date, default: Date.now }
-  }, { collection: 'user_product_tracker' })
-  UserProductTrackerSchema.index({ user_id: 1, product: 1 }, { unique: true })
-
-  let ApikeySchema = new Schema({
-    apikey: { type: String, required: true, unique: true },
-    permission: { type: Array, required: true },  // follow model - user, payment
-    description: { type: String, required: true },
-    status: { type: Boolean, required: true },
-    created_on: { type: Date, default: Date.now },
-    call_number: { type: Number },
-    partner_name: { type: String }, // Would be used when permission has 'partner'
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'auth_apikey' })
-
-  let UserReferralSchema = new Schema({
-    user_id: { type: ObjectId, ref: 'User', required: true },
-    referred_user_email: { type: 'String' },
-    created_on: { type: Date, default: Date.now },
-    updated_on: { type: Date, default: Date.now }
-  }, { collection: 'user_referral' })
-
-  const UserTokenSchema = new Schema({
-    tid: { type: String, trim: true, required: true },
-    expired_at: { type: Date, required: true },
-    created_on: { type: Date, default: Date.now }
-  }, {
-    collection: 'auth_token',
-    toJSON: { virtuals: true },
-    toObject: { virtuals: true }
-  })
-  UserTokenSchema.index({
-    tid: 1
-  }, {
-    unique: true
-  })
-  UserTokenSchema.index({
-    expired_at: 1
-  }, {
-    expireAfterSeconds: 0
-  })
-
-  const UserFollowSchema = new Schema(
-    {
-      user_id: { type: Schema.Types.ObjectId, ref: 'User', required: true, index: true },
-      follow_user_id: { type: Schema.Types.ObjectId, ref: 'User', required: true, index: true },
-      follow_platform: { type: String } // spark or bias ...
-    },
-    {
-      timestamps: { createdAt: true, updatedAt: false },
-      versionKey: false,
-      collection: 'jamup_userFollow',
-      toJSON: { virtuals: true },
-      toObject: { virtuals: true }
-    }
-  )
-  UserFollowSchema.index(
-    {
-      user_id: 1,
-      follow_platform: 1,
-      follow_user_id: 1
-    },
-    { unique: true }
-  )
-  UserFollowSchema.index({
-    follow_platform: 1
-  }, {
-    user_id: 1
-  }, {
-    createdAt: 1
-  })
-  UserFollowSchema.index({
-    follow_platform: 1
-  }, {
-    follow_user_id: 1
-  }, {
-    createdAt: 1
-  })
-
-  /**
-   * Methods
-   */
-  UserSchema.method({
-    authenticate: function (plainText) {
-      var passwordArr = this.password.split('$')
-      if (passwordArr.length !== 3) {
-        return false
-      } else {
-        return verifyPassword(plainText, passwordArr)
-      }
-    },
-    makeSalt: function () {
-      return Math.round((new Date().valueOf() * Math.random())) + ''
-    }
-  })
-
-  // Statics
-  UserTokenSchema.static({
-    createTokenMeta: async function () {
-      try {
-        const tid = crypto.randomUUID()
-        const nowDate = new Date()
-        const expiredAt = new Date().setDate(nowDate.getDate() + 14)
-        return await this.create({
-          tid,
-          expired_at: expiredAt,
-          created_on: nowDate
-        })
-      } catch (err) {
-        debug('ERR:createTokenMeta:%j', err)
-        throw err
-      }
-    },
-    isValid: async function (tid) {
-      const userTokenMeta = await this.findOne({ tid }).exec()
-      return (userTokenMeta) ? true : false
-    },
-    revokeToken: async function (tid) {
-      return await this.findOneAndRemove({
-        tid
-      })
-    }
-  })
-  UserSchema.static({
-    _async_auth: async function (username, password) {
-      username = String(username).toLowerCase().replace('@', '_')
-      let user
-      let bgUser
-      try {
-        user = await this.findOne({username}).exec()
-      } catch (err) {
-        throw new ApiErrorCode('internal_sysmtem_error', err.message)
-      }
-      if (!user) {
-        // Fallback
-        try {
-          bgUser = await this.findOne({ bk_username: { $in: [username] } }).exec()
-        } catch (err) {
-          throw new ApiErrorCode('INTERNAL_SYSMTEM_ERROR', err.message)
-        }
-        if (!bgUser) {
-          throw new ApiErrorCode('USER_NOT_EXIST', `Cannot find user ${username}`)
-        } else if (!bgUser.authenticate(password)) {
-          throw new ApiErrorCode('USER_UNAUTHORIZED', 'unauthorized')
-        }
-        return bgUser
-      }
-      if (user.user_status === 2) {
-        // Account deleted
-        throw new ApiErrorCode('ACCOUNT_WERE_DELETED', `Account ${user.email} already deleted`)
-      }
-      if (!user.authenticate(password)) {
-        if (user.facebook_id !== null) {
-          throw new ApiErrorCode('USER_OAUTH_LOGIN', 'Please use FB to login your account')
-        } else {
-          throw new ApiErrorCode('USER_UNAUTHORIZED', 'unauthorized')
-        }
-      }
-      return user
-    },
-    auth: function (uname, password, cb) {
-      if (!cb) {
-        return this._async_auth(uname, password)
-      }
-      let username = String(uname).toLowerCase().replace('@', '_')
-      let that = this
-
-      that.findOne({ username: username }, function (err, user) {
-        if (err) {
-          return cb(new ApiErrorCode('internal_sysmtem_error', err.message))
-        } else if (!user) {
-          that.findOne({ bk_username: { $in: [uname] } }, function (err, bgUser) {
-            if (err) {
-              return cb(new ApiErrorCode('INTERNAL_SYSMTEM_ERROR', err.message))
-            } else if (!bgUser) {
-              return cb(new ApiErrorCode('USER_NOT_EXIST', `Cannot find user ${uname}`))
-            }
-
-            return (!user.authenticate(password))
-              ? cb(new ApiErrorCode('USER_UNAUTHORIZED', 'unauthorized'))
-              : cb(null, bgUser)
-          })
-        } else {
-          if (user.user_status === 2) {
-            return cb(new ApiErrorCode('ACCOUNT_WERE_DELETED', `Account ${user.email} already deleted`))
-          } else if (!user.authenticate(password)) {
-            if (user.facebook_id !== null) {
-              return cb(new ApiErrorCode('USER_OAUTH_LOGIN', 'Please use FB to login your account'))
-            } else {
-              return cb(new ApiErrorCode('USER_UNAUTHORIZED', 'unauthorized'))
-            }
-          }
-          return cb(null, user)
-        }
-      })
-    },
-    login: function (query, cb) {
-      if (!_.isObject(query)) {
-        return cb(Error('Invalid login parameter'))
-      } else {
-        this.findOne(query, cb)
-      }
-    },
-    loginForPassport: function (query, cb) {
-      let self = this
-
-      if (!_.isObject(query)) {
-        return cb(Error('Invalid login parameter'))
-      }
-
-      if (_.has(query, 'username')) {
-        query['username'] = String(_.trim(query['username'])).toLowerCase()
-      }
-      if (_.has(query, 'email')) {
-        query['email'] = String(_.trim(query['email'])).toLowerCase()
-      }
-
-      debug('loginForPassport:%o', query)
-      self.findOne(query, function (err, user) {
-        if (err) {
-          return cb({ status: 500, errorMessage: err })
-        } else if (!user) {
-          return cb({ status: 404, errorMessage: `Cannot found target user` })
-        } else if (user['user_status'] === 2) {
-          return cb({ status: 410, errorMessage: `This account already deleted` })
-        } else {
-          return cb(null, user)
-        }
-      })
-    },
-    list: function (options, cb) {
-      var criteria = options.criteria || {}
-      var sort = options.sort || { createdAt: -1 }
-      var limit = options.limit === 0 ? 0 : (options.limit || 10)
-      var page = options.page || 0
-
-      this.find(criteria)
-        .select('name username email')
-        .sort(sort)
-        .skip(limit * page)
-        .limit(limit)
-        .exec(cb)
-    },
-    getUser: function (username, cb) {
-      this.findOne({ username: String(username).toLowerCase() })
-        .sort({ date_joined: -1 })
-        .select('email user_role user_status auth')
-        .exec(cb)
-    },
-    getUserPromise: async function (username) {
-      const userData = await this.findOne({ username: String(username).toLowerCase() })
-        .select('email user_role user_status auth')
-        .exec()
-      return userData
-    },
-    getUserById: function (id, cb) {
-      this.findById(id).exec(cb)
-    },
-    getUserFullData: function (username) {
-      const cursor = this.aggregate([
-        { '$match': { username: String(username).toLowerCase(), user_status: 1 } },
-        { '$lookup': { 'from': 'jamup_userprofile', 'localField': '_id', 'foreignField': 'user_id', 'as': 'userprofile' } },
-        { '$unwind': '$userprofile' }
-      ]).cursor({ batchSize: 100, useMongooseAggCursor: true }).exec()
-      return cursor.eachAsync()
-    },
-    // Promise rewrite getUserFullData
-    getUserDetail: async function (query, projectFields = {}) {
-      try {
-        if (!_.isObject(query)) {
-          throw new Error('Query need to be object!')
-        }
-
-        const queryCondition = _.assign({}, {
-          'user_status': 1
-        }, query)
-
-        const defaultProjectFields = _.assign({}, {
-          '_id': 1,
-          'email': 1,
-          'username': 1,
-          'date_joined': 1,
-          'last_login': 1,
-          'userprofile.first_name': 1,
-          'userprofile.last_name': 1,
-          'userprofile.full_name': 1
-        }, projectFields)
-        const ret = await this.aggregate([
-          { '$match': queryCondition },
-          {
-            '$lookup': {
-              'from': 'jamup_userprofile',
-              'localField': '_id',
-              'foreignField': 'user_id',
-              'as': 'userprofile'
-            }
-          },
-          { '$unwind': '$userprofile' },
-          { '$project': defaultProjectFields }
-        ]).exec()
-
-        debug('INFO:getUserDetail %o:%o', queryCondition, ret)
-        return ret
-      } catch (err) {
-        debug('ERR:getUserDetail %o', err)
-        throw err
-      }
-    },
-    getDealerDetail: async function (query) {
-      try {
-        if (!_.isObject(query)) {
-          throw new Error('Query need to be object!')
-        }
-
-        const queryCondition = _.assign({}, {
-          'user_status': 1
-        }, query)
-
-        const ret = await this.aggregate([
-          { '$match': queryCondition },
-          {
-            '$lookup': {
-              'from': 'jamup_userprofile',
-              'localField': '_id',
-              'foreignField': 'user_id',
-              'as': 'userprofile'
-            }
-          },
-          { '$unwind': '$userprofile' },
-          {
-            '$lookup': {
-              'from': 'b2b_dealer_profile',
-              'localField': '_id',
-              'foreignField': 'dealer_id',
-              'as': 'dealer'
-            }
-          },
-          { '$unwind': '$dealer' }
-        ]).exec()
-
-        debug('INFO:getDealerDetail %o:%o', queryCondition, ret)
-        return ret
-      } catch (err) {
-        debug('ERR:getDealerDetail %o', err)
-        throw err
-      }
-    },
-    createUser: function (userObj, cb) {
-      debug(userObj)
-      this.create(userObj, function (err, userObj) {
-        if (err) return cb(err)
-
-        return cb(null, userObj)
-      })
-    },
-    deleteUser: function (userId, cb) {
-      this.remove({ _id: userId }).exec(cb)
-    },
-    findUserByEmail: function (email, cb) {
-      this.find({ email: String(email).toLowerCase() }).exec(cb)
-    },
-    findByEmail: async function (email) {
-      try {
-        if (!isEmail(email)) {
-          throw new Error(`Invalid email format: ${email}`)
-        }
-
-        return await this.findOne({
-          email: String(email).toLowerCase(),
-          user_status: 1
-        }).exec()
-      } catch (err) {
-        debug('ERR:findByEmail:%o', email)
-        throw err
-      }
-    }
-  })
-
-  UserProfileSchema.static({
-    createProfile: function (profileObj, cb) {
-      debug('createProfile:%o', profileObj)
-      if (!profileObj['user_id']) {
-        return cb(new Error('Missing User Id'))
-      } else if (mongoose.Types.ObjectId.isValid(profileObj['user_id']) === false) {
-        return cb(new Error('Invalid User Id'))
-      }
-
-      this.create(profileObj, function (err, profileObj) {
-        if (err) return cb(err)
-
-        return cb(null, profileObj)
-      })
-    },
-    updateProfileByUserId: function (userId, updateData, cb) {
-      debug(updateData)
-      this.findOneAndUpdate(
-        { user_id: userId },
-        { $set: updateData },
-        { new: true }).exec(cb)
-    },
-    updateProfile: async function (userId, updateProfileData) {
-      try {
-        return await this.findOneAndUpdate({
-          user_id: mongoose.Types.ObjectId(userId)
-        }, {
-          '$set': updateProfileData
-        }, { new: true }).exec()
-      } catch (err) {
-        debug('ERR:updateProfile:%o', err)
-        throw err
-      }
-    },
-    getUserProfile: function (userId, cb) {
-      this.getUserProfilePromise(userId)
-        .then(userData => cb(null, userData))
-        .catch(err => cb(err))
-    },
-    getUserProfilePromise: async function (userId) {
-      let selectField = [
-        'full_name',
-        'profile_image_url',
-        'profile_thumb_url',
-        'first_name',
-        'last_name',
-        'title',
-        'gender',
-        'date_joined'
-      ].join(' ')
-
-      const profileData= await this.findOne({ user_id: userId })
-        .select(selectField)
-        .exec()
-      return profileData
-    },
-    getUserProfileDetail: function (userId, cb) {
-      if (!cb) {
-        return this.findOne({ user_id: userId }).exec()
-      }
-      this.findOne({ user_id: userId }).exec(cb)
-    },
-    getUserProfileByCondition: function (condition, cb) {
-      this.findOne(condition).exec(cb)
-    }
-  })
-
-  const jamupLitePattern = new RegExp('JamUp.+Lite\/([0-9.]+)')
-  const biasAmpPattern = new RegExp('Bias\/([0-9.]+)')
-  const biasAmpiPhonePattern = new RegExp('Bias.+iPhone\/([0-9.]+)')
-  const biasFxPattern = new RegExp('BIAS.+FX\/([0-9.]+).+iPad')
-  const biasPedalPattern = new RegExp('BIAS.+Pedal\/([0-9.]+).+iPad')
-  UserProductSchema.static({
-    detectUserProduct: function (userAgent) {
-      let userMeta = {}
-      const preUserAgent = String(userAgent)
-
-      if (preUserAgent.match(jamupLitePattern)) {
-        userMeta = {
-          product: 'jamup-lite',
-          platform: 'iOS'
-        }
-      } else if (preUserAgent.match(biasAmpPattern)) {
-        userMeta = {
-          product: 'biasamp',
-          platform: 'iOS'
-        }
-      } else if (preUserAgent.match(biasAmpiPhonePattern)) {
-        userMeta = {
-          product: 'biasamp',
-          platform: 'iOS'
-        }
-      } else if (preUserAgent.match(biasFxPattern)) {
-        userMeta = {
-          product: 'biasfx',
-          platform: 'iOS'
-        }
-      } else if (preUserAgent.match(biasPedalPattern)) {
-        userMeta = {
-          product: 'pedal',
-          platform: 'iOS'
-        }
-      }
-
-      return (_.isEmpty(userMeta)) ? false : userMeta
-    }
-  })
-
-  // Virtual
-  UserSchema.virtual('id')
-    .get(function () {
-      return this._id.toHexString()
-    })
-
-  mongoose.model('User', UserSchema)
-  mongoose.model('UserProfile', UserProfileSchema)
-  mongoose.model('ApiKey', ApikeySchema)
-  mongoose.model('UserProduct', UserProductSchema)
-  mongoose.model('UserProductTracker', UserProductTrackerSchema)
-  mongoose.model('UserReferral', UserReferralSchema)
-  mongoose.model('UserEmailStatus', UserEmailStatusSchema)
-  mongoose.model('UserToken', UserTokenSchema)
-  mongoose.model('UserFollow', UserFollowSchema)
-}