Reorganize model files

5 files changed, 388 insertions, 0 deletions

diff --git a/server/models/user/index.ts b/server/models/user/index.ts
new file mode 100644
index 000000000..ed3689518
--- /dev/null
+++ b/server/models/user/index.ts
@@ -0,0 +1,2 @@
+export * from './user-video-rate-interface'
+export * from './user-interface'
diff --git a/server/models/user/user-interface.ts b/server/models/user/user-interface.ts
new file mode 100644
index 000000000..1ba4bd800
--- /dev/null
+++ b/server/models/user/user-interface.ts
@@ -0,0 +1,63 @@
+import * as Sequelize from 'sequelize'
+import * as Bluebird from 'bluebird'
+
+// Don't use barrel, import just what we need
+import { User as FormatedUser } from '../../../shared/models/user.model'
+
+export namespace UserMethods {
+  export type IsPasswordMatchCallback = (err: Error, same: boolean) => void
+  export type IsPasswordMatch = (password: string, callback: IsPasswordMatchCallback) => void
+
+  export type ToFormatedJSON = () => FormatedUser
+  export type IsAdmin = () => boolean
+
+  export type CountTotalCallback = (err: Error, total: number) => void
+  export type CountTotal = (callback: CountTotalCallback) => void
+
+  export type GetByUsername = (username: string) => Bluebird<UserInstance>
+
+  export type ListCallback = (err: Error, userInstances: UserInstance[]) => void
+  export type List = (callback: ListCallback) => void
+
+  export type ListForApiCallback = (err: Error, userInstances?: UserInstance[], total?: number) => void
+  export type ListForApi = (start: number, count: number, sort: string, callback: ListForApiCallback) => void
+
+  export type LoadByIdCallback = (err: Error, userInstance: UserInstance) => void
+  export type LoadById = (id: number, callback: LoadByIdCallback) => void
+
+  export type LoadByUsernameCallback = (err: Error, userInstance: UserInstance) => void
+  export type LoadByUsername = (username: string, callback: LoadByUsernameCallback) => void
+
+  export type LoadByUsernameOrEmailCallback = (err: Error, userInstance: UserInstance) => void
+  export type LoadByUsernameOrEmail = (username: string, email: string, callback: LoadByUsernameOrEmailCallback) => void
+}
+
+export interface UserClass {
+  isPasswordMatch: UserMethods.IsPasswordMatch,
+  toFormatedJSON: UserMethods.ToFormatedJSON,
+  isAdmin: UserMethods.IsAdmin,
+
+  countTotal: UserMethods.CountTotal,
+  getByUsername: UserMethods.GetByUsername,
+  list: UserMethods.List,
+  listForApi: UserMethods.ListForApi,
+  loadById: UserMethods.LoadById,
+  loadByUsername: UserMethods.LoadByUsername,
+  loadByUsernameOrEmail: UserMethods.LoadByUsernameOrEmail
+}
+
+export interface UserAttributes {
+  password: string
+  username: string
+  email: string
+  displayNSFW?: boolean
+  role: string
+}
+
+export interface UserInstance extends UserClass, UserAttributes, Sequelize.Instance<UserAttributes> {
+  id: number
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface UserModel extends UserClass, Sequelize.Model<UserInstance, UserAttributes> {}
diff --git a/server/models/user/user-video-rate-interface.ts b/server/models/user/user-video-rate-interface.ts
new file mode 100644
index 000000000..e48869fd2
--- /dev/null
+++ b/server/models/user/user-video-rate-interface.ts
@@ -0,0 +1,22 @@
+import * as Sequelize from 'sequelize'
+
+export namespace UserVideoRateMethods {
+  export type LoadCallback = (err: Error, userVideoRateInstance: UserVideoRateInstance) => void
+  export type Load = (userId, videoId, transaction, callback) => void
+}
+
+export interface UserVideoRateClass {
+  load: UserVideoRateMethods.Load
+}
+
+export interface UserVideoRateAttributes {
+  type: string
+}
+
+export interface UserVideoRateInstance extends UserVideoRateClass, UserVideoRateAttributes, Sequelize.Instance<UserVideoRateAttributes> {
+  id: number
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface UserVideoRateModel extends UserVideoRateClass, Sequelize.Model<UserVideoRateInstance, UserVideoRateAttributes> {}
diff --git a/server/models/user/user-video-rate.ts b/server/models/user/user-video-rate.ts
new file mode 100644
index 000000000..68be62fc2
--- /dev/null
+++ b/server/models/user/user-video-rate.ts
@@ -0,0 +1,80 @@
+/*
+  User rates per video.
+
+*/
+import { values } from 'lodash'
+import * as Sequelize from 'sequelize'
+
+import { VIDEO_RATE_TYPES } from '../../initializers'
+
+import { addMethodsToModel } from '../utils'
+import {
+  UserVideoRateClass,
+  UserVideoRateInstance,
+  UserVideoRateAttributes,
+
+  UserVideoRateMethods
+} from './user-video-rate-interface'
+
+let UserVideoRate: Sequelize.Model<UserVideoRateInstance, UserVideoRateAttributes>
+let load: UserVideoRateMethods.Load
+
+export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
+  UserVideoRate = sequelize.define<UserVideoRateInstance, UserVideoRateAttributes>('UserVideoRate',
+    {
+      type: {
+        type: DataTypes.ENUM(values(VIDEO_RATE_TYPES)),
+        allowNull: false
+      }
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'videoId', 'userId', 'type' ],
+          unique: true
+        }
+      ]
+    }
+  )
+
+  const classMethods = [
+    associate,
+
+    load
+  ]
+  addMethodsToModel(UserVideoRate, classMethods)
+
+  return UserVideoRate
+}
+
+// ------------------------------ STATICS ------------------------------
+
+function associate (models) {
+  UserVideoRate.belongsTo(models.Video, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+
+  UserVideoRate.belongsTo(models.User, {
+    foreignKey: {
+      name: 'userId',
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+}
+
+load = function (userId: number, videoId: number, transaction: Sequelize.Transaction, callback: UserVideoRateMethods.LoadCallback) {
+  const options: Sequelize.FindOptions = {
+    where: {
+      userId,
+      videoId
+    }
+  }
+  if (transaction) options.transaction = transaction
+
+  return UserVideoRate.findOne(options).asCallback(callback)
+}
diff --git a/server/models/user/user.ts b/server/models/user/user.ts
new file mode 100644
index 000000000..d78f5f845
--- /dev/null
+++ b/server/models/user/user.ts
@@ -0,0 +1,221 @@
+import { values } from 'lodash'
+import * as Sequelize from 'sequelize'
+
+import { getSort } from '../utils'
+import { USER_ROLES } from '../../initializers'
+import {
+  cryptPassword,
+  comparePassword,
+  isUserPasswordValid,
+  isUserUsernameValid,
+  isUserDisplayNSFWValid
+} from '../../helpers'
+
+import { addMethodsToModel } from '../utils'
+import {
+  UserClass,
+  UserInstance,
+  UserAttributes,
+
+  UserMethods
+} from './user-interface'
+
+let User: Sequelize.Model<UserInstance, UserAttributes>
+let isPasswordMatch: UserMethods.IsPasswordMatch
+let toFormatedJSON: UserMethods.ToFormatedJSON
+let isAdmin: UserMethods.IsAdmin
+let countTotal: UserMethods.CountTotal
+let getByUsername: UserMethods.GetByUsername
+let list: UserMethods.List
+let listForApi: UserMethods.ListForApi
+let loadById: UserMethods.LoadById
+let loadByUsername: UserMethods.LoadByUsername
+let loadByUsernameOrEmail: UserMethods.LoadByUsernameOrEmail
+
+export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
+  User = sequelize.define<UserInstance, UserAttributes>('User',
+    {
+      password: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          passwordValid: function (value) {
+            const res = isUserPasswordValid(value)
+            if (res === false) throw new Error('Password not valid.')
+          }
+        }
+      },
+      username: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          usernameValid: function (value) {
+            const res = isUserUsernameValid(value)
+            if (res === false) throw new Error('Username not valid.')
+          }
+        }
+      },
+      email: {
+        type: DataTypes.STRING(400),
+        allowNull: false,
+        validate: {
+          isEmail: true
+        }
+      },
+      displayNSFW: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        validate: {
+          nsfwValid: function (value) {
+            const res = isUserDisplayNSFWValid(value)
+            if (res === false) throw new Error('Display NSFW is not valid.')
+          }
+        }
+      },
+      role: {
+        type: DataTypes.ENUM(values(USER_ROLES)),
+        allowNull: false
+      }
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'username' ],
+          unique: true
+        },
+        {
+          fields: [ 'email' ],
+          unique: true
+        }
+      ],
+      hooks: {
+        beforeCreate: beforeCreateOrUpdate,
+        beforeUpdate: beforeCreateOrUpdate
+      }
+    }
+  )
+
+  const classMethods = [
+    associate,
+
+    countTotal,
+    getByUsername,
+    list,
+    listForApi,
+    loadById,
+    loadByUsername,
+    loadByUsernameOrEmail
+  ]
+  const instanceMethods = [
+    isPasswordMatch,
+    toFormatedJSON,
+    isAdmin
+  ]
+  addMethodsToModel(User, classMethods, instanceMethods)
+
+  return User
+}
+
+function beforeCreateOrUpdate (user: UserInstance) {
+  return new Promise(function (resolve, reject) {
+    cryptPassword(user.password, function (err, hash) {
+      if (err) return reject(err)
+
+      user.password = hash
+
+      return resolve()
+    })
+  })
+}
+
+// ------------------------------ METHODS ------------------------------
+
+isPasswordMatch = function (password: string, callback: UserMethods.IsPasswordMatchCallback) {
+  return comparePassword(password, this.password, callback)
+}
+
+toFormatedJSON = function (this: UserInstance) {
+  return {
+    id: this.id,
+    username: this.username,
+    email: this.email,
+    displayNSFW: this.displayNSFW,
+    role: this.role,
+    createdAt: this.createdAt
+  }
+}
+
+isAdmin = function () {
+  return this.role === USER_ROLES.ADMIN
+}
+
+// ------------------------------ STATICS ------------------------------
+
+function associate (models) {
+  User.hasOne(models.Author, {
+    foreignKey: 'userId',
+    onDelete: 'cascade'
+  })
+
+  User.hasMany(models.OAuthToken, {
+    foreignKey: 'userId',
+    onDelete: 'cascade'
+  })
+}
+
+countTotal = function (callback: UserMethods.CountTotalCallback) {
+  return this.count().asCallback(callback)
+}
+
+getByUsername = function (username: string) {
+  const query = {
+    where: {
+      username: username
+    }
+  }
+
+  return User.findOne(query)
+}
+
+list = function (callback: UserMethods.ListCallback) {
+  return User.find().asCallback(callback)
+}
+
+listForApi = function (start: number, count: number, sort: string, callback: UserMethods.ListForApiCallback) {
+  const query = {
+    offset: start,
+    limit: count,
+    order: [ getSort(sort) ]
+  }
+
+  return User.findAndCountAll(query).asCallback(function (err, result) {
+    if (err) return callback(err)
+
+    return callback(null, result.rows, result.count)
+  })
+}
+
+loadById = function (id: number, callback: UserMethods.LoadByIdCallback) {
+  return User.findById(id).asCallback(callback)
+}
+
+loadByUsername = function (username: string, callback: UserMethods.LoadByUsernameCallback) {
+  const query = {
+    where: {
+      username: username
+    }
+  }
+
+  return User.findOne(query).asCallback(callback)
+}
+
+loadByUsernameOrEmail = function (username: string, email: string, callback: UserMethods.LoadByUsernameOrEmailCallback) {
+  const query = {
+    where: {
+      $or: [ { username }, { email } ]
+    }
+  }
+
+  return User.findOne(query).asCallback(callback)
+}