Add video channels

7 files changed, 675 insertions, 67 deletions

diff --git a/server/models/video/author-interface.ts b/server/models/video/author-interface.ts
index 52a00a1d3..fc69ff3c2 100644
--- a/server/models/video/author-interface.ts
+++ b/server/models/video/author-interface.ts
@@ -2,31 +2,44 @@ import * as Sequelize from 'sequelize'
 import * as Promise from 'bluebird'
 
 import { PodInstance } from '../pod/pod-interface'
+import { RemoteVideoAuthorCreateData } from '../../../shared/models/pods/remote-video/remote-video-author-create-request.model'
+import { VideoChannelInstance } from './video-channel-interface'
 
 export namespace AuthorMethods {
-  export type FindOrCreateAuthor = (
-    name: string,
-    podId: number,
-    userId: number,
-    transaction: Sequelize.Transaction
-  ) => Promise<AuthorInstance>
+  export type Load = (id: number) => Promise<AuthorInstance>
+  export type LoadByUUID = (uuid: string) => Promise<AuthorInstance>
+  export type LoadAuthorByPodAndUUID = (uuid: string, podId: number, transaction: Sequelize.Transaction) => Promise<AuthorInstance>
+  export type ListOwned = () => Promise<AuthorInstance[]>
+
+  export type ToAddRemoteJSON = (this: AuthorInstance) => RemoteVideoAuthorCreateData
+  export type IsOwned = (this: AuthorInstance) => boolean
 }
 
 export interface AuthorClass {
-  findOrCreateAuthor: AuthorMethods.FindOrCreateAuthor
+  loadAuthorByPodAndUUID: AuthorMethods.LoadAuthorByPodAndUUID
+  load: AuthorMethods.Load
+  loadByUUID: AuthorMethods.LoadByUUID
+  listOwned: AuthorMethods.ListOwned
 }
 
 export interface AuthorAttributes {
   name: string
+  uuid?: string
+
+  podId?: number
+  userId?: number
 }
 
 export interface AuthorInstance extends AuthorClass, AuthorAttributes, Sequelize.Instance<AuthorAttributes> {
+  isOwned: AuthorMethods.IsOwned
+  toAddRemoteJSON: AuthorMethods.ToAddRemoteJSON
+
   id: number
   createdAt: Date
   updatedAt: Date
 
-  podId: number
   Pod: PodInstance
+  VideoChannels: VideoChannelInstance[]
 }
 
 export interface AuthorModel extends AuthorClass, Sequelize.Model<AuthorInstance, AuthorAttributes> {}
diff --git a/server/models/video/author.ts b/server/models/video/author.ts
index fd0f44f6b..6f27ea7bd 100644
--- a/server/models/video/author.ts
+++ b/server/models/video/author.ts
@@ -1,6 +1,7 @@
 import * as Sequelize from 'sequelize'
 
 import { isUserUsernameValid } from '../../helpers'
+import { removeVideoAuthorToFriends } from '../../lib'
 
 import { addMethodsToModel } from '../utils'
 import {
@@ -11,11 +12,24 @@ import {
 } from './author-interface'
 
 let Author: Sequelize.Model<AuthorInstance, AuthorAttributes>
-let findOrCreateAuthor: AuthorMethods.FindOrCreateAuthor
+let loadAuthorByPodAndUUID: AuthorMethods.LoadAuthorByPodAndUUID
+let load: AuthorMethods.Load
+let loadByUUID: AuthorMethods.LoadByUUID
+let listOwned: AuthorMethods.ListOwned
+let isOwned: AuthorMethods.IsOwned
+let toAddRemoteJSON: AuthorMethods.ToAddRemoteJSON
 
 export default function defineAuthor (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
   Author = sequelize.define<AuthorInstance, AuthorAttributes>('Author',
     {
+      uuid: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        validate: {
+          isUUID: 4
+        }
+      },
       name: {
         type: DataTypes.STRING,
         allowNull: false,
@@ -43,12 +57,23 @@ export default function defineAuthor (sequelize: Sequelize.Sequelize, DataTypes:
           fields: [ 'name', 'podId' ],
           unique: true
         }
-      ]
+      ],
+      hooks: { afterDestroy }
     }
   )
 
-  const classMethods = [ associate, findOrCreateAuthor ]
-  addMethodsToModel(Author, classMethods)
+  const classMethods = [
+    associate,
+    loadAuthorByPodAndUUID,
+    load,
+    loadByUUID,
+    listOwned
+  ]
+  const instanceMethods = [
+    isOwned,
+    toAddRemoteJSON
+  ]
+  addMethodsToModel(Author, classMethods, instanceMethods)
 
   return Author
 }
@@ -72,27 +97,75 @@ function associate (models) {
     onDelete: 'cascade'
   })
 
-  Author.hasMany(models.Video, {
+  Author.hasMany(models.VideoChannel, {
     foreignKey: {
       name: 'authorId',
       allowNull: false
     },
-    onDelete: 'cascade'
+    onDelete: 'cascade',
+    hooks: true
   })
 }
 
-findOrCreateAuthor = function (name: string, podId: number, userId: number, transaction: Sequelize.Transaction) {
-  const author = {
-    name,
-    podId,
-    userId
+function afterDestroy (author: AuthorInstance, options: { transaction: Sequelize.Transaction }) {
+  if (author.isOwned()) {
+    const removeVideoAuthorToFriendsParams = {
+      uuid: author.uuid
+    }
+
+    return removeVideoAuthorToFriends(removeVideoAuthorToFriendsParams, options.transaction)
+  }
+
+  return undefined
+}
+
+toAddRemoteJSON = function (this: AuthorInstance) {
+  const json = {
+    uuid: this.uuid,
+    name: this.name
+  }
+
+  return json
+}
+
+isOwned = function (this: AuthorInstance) {
+  return this.podId === null
+}
+
+// ------------------------------ STATICS ------------------------------
+
+listOwned = function () {
+  const query: Sequelize.FindOptions<AuthorAttributes> = {
+    where: {
+      podId: null
+    }
+  }
+
+  return Author.findAll(query)
+}
+
+load = function (id: number) {
+  return Author.findById(id)
+}
+
+loadByUUID = function (uuid: string) {
+  const query: Sequelize.FindOptions<AuthorAttributes> = {
+    where: {
+      uuid
+    }
   }
 
-  const query: Sequelize.FindOrInitializeOptions<AuthorAttributes> = {
-    where: author,
-    defaults: author,
+  return Author.findOne(query)
+}
+
+loadAuthorByPodAndUUID = function (uuid: string, podId: number, transaction: Sequelize.Transaction) {
+  const query: Sequelize.FindOptions<AuthorAttributes> = {
+    where: {
+      podId,
+      uuid
+    },
     transaction
   }
 
-  return Author.findOrCreate(query).then(([ authorInstance ]) => authorInstance)
+  return Author.find(query)
 }
diff --git a/server/models/video/index.ts b/server/models/video/index.ts
index 08b360376..dba6a5590 100644
--- a/server/models/video/index.ts
+++ b/server/models/video/index.ts
@@ -2,6 +2,7 @@ export * from './author-interface'
 export * from './tag-interface'
 export * from './video-abuse-interface'
 export * from './video-blacklist-interface'
+export * from './video-channel-interface'
 export * from './video-tag-interface'
 export * from './video-file-interface'
 export * from './video-interface'
diff --git a/server/models/video/video-channel-interface.ts b/server/models/video/video-channel-interface.ts
new file mode 100644
index 000000000..b8d3e0f42
--- /dev/null
+++ b/server/models/video/video-channel-interface.ts
@@ -0,0 +1,64 @@
+import * as Sequelize from 'sequelize'
+import * as Promise from 'bluebird'
+
+import { ResultList, RemoteVideoChannelCreateData, RemoteVideoChannelUpdateData } from '../../../shared'
+
+// Don't use barrel, import just what we need
+import { VideoChannel as FormattedVideoChannel } from '../../../shared/models/videos/video-channel.model'
+import { AuthorInstance } from './author-interface'
+import { VideoInstance } from './video-interface'
+
+export namespace VideoChannelMethods {
+  export type ToFormattedJSON = (this: VideoChannelInstance) => FormattedVideoChannel
+  export type ToAddRemoteJSON = (this: VideoChannelInstance) => RemoteVideoChannelCreateData
+  export type ToUpdateRemoteJSON = (this: VideoChannelInstance) => RemoteVideoChannelUpdateData
+  export type IsOwned = (this: VideoChannelInstance) => boolean
+
+  export type CountByAuthor = (authorId: number) => Promise<number>
+  export type ListOwned = () => Promise<VideoChannelInstance[]>
+  export type ListForApi = (start: number, count: number, sort: string) => Promise< ResultList<VideoChannelInstance> >
+  export type LoadByIdAndAuthor = (id: number, authorId: number) => Promise<VideoChannelInstance>
+  export type ListByAuthor = (authorId: number) => Promise< ResultList<VideoChannelInstance> >
+  export type LoadAndPopulateAuthor = (id: number) => Promise<VideoChannelInstance>
+  export type LoadByUUIDAndPopulateAuthor = (uuid: string) => Promise<VideoChannelInstance>
+  export type LoadByUUID = (uuid: string, t?: Sequelize.Transaction) => Promise<VideoChannelInstance>
+  export type LoadByHostAndUUID = (uuid: string, podHost: string, t?: Sequelize.Transaction) => Promise<VideoChannelInstance>
+  export type LoadAndPopulateAuthorAndVideos = (id: number) => Promise<VideoChannelInstance>
+}
+
+export interface VideoChannelClass {
+  countByAuthor: VideoChannelMethods.CountByAuthor
+  listForApi: VideoChannelMethods.ListForApi
+  listByAuthor: VideoChannelMethods.ListByAuthor
+  listOwned: VideoChannelMethods.ListOwned
+  loadByIdAndAuthor: VideoChannelMethods.LoadByIdAndAuthor
+  loadByUUID: VideoChannelMethods.LoadByUUID
+  loadByHostAndUUID: VideoChannelMethods.LoadByHostAndUUID
+  loadAndPopulateAuthor: VideoChannelMethods.LoadAndPopulateAuthor
+  loadByUUIDAndPopulateAuthor: VideoChannelMethods.LoadByUUIDAndPopulateAuthor
+  loadAndPopulateAuthorAndVideos: VideoChannelMethods.LoadAndPopulateAuthorAndVideos
+}
+
+export interface VideoChannelAttributes {
+  id?: number
+  uuid?: string
+  name: string
+  description: string
+  remote: boolean
+
+  Author?: AuthorInstance
+  Videos?: VideoInstance[]
+}
+
+export interface VideoChannelInstance extends VideoChannelClass, VideoChannelAttributes, Sequelize.Instance<VideoChannelAttributes> {
+  id: number
+  createdAt: Date
+  updatedAt: Date
+
+  isOwned: VideoChannelMethods.IsOwned
+  toFormattedJSON: VideoChannelMethods.ToFormattedJSON
+  toAddRemoteJSON: VideoChannelMethods.ToAddRemoteJSON
+  toUpdateRemoteJSON: VideoChannelMethods.ToUpdateRemoteJSON
+}
+
+export interface VideoChannelModel extends VideoChannelClass, Sequelize.Model<VideoChannelInstance, VideoChannelAttributes> {}
diff --git a/server/models/video/video-channel.ts b/server/models/video/video-channel.ts
new file mode 100644
index 000000000..e469383e9
--- /dev/null
+++ b/server/models/video/video-channel.ts
@@ -0,0 +1,349 @@
+import * as Sequelize from 'sequelize'
+
+import { isVideoChannelNameValid, isVideoChannelDescriptionValid } from '../../helpers'
+import { removeVideoChannelToFriends } from '../../lib'
+
+import { addMethodsToModel, getSort } from '../utils'
+import {
+  VideoChannelInstance,
+  VideoChannelAttributes,
+
+  VideoChannelMethods
+} from './video-channel-interface'
+
+let VideoChannel: Sequelize.Model<VideoChannelInstance, VideoChannelAttributes>
+let toFormattedJSON: VideoChannelMethods.ToFormattedJSON
+let toAddRemoteJSON: VideoChannelMethods.ToAddRemoteJSON
+let toUpdateRemoteJSON: VideoChannelMethods.ToUpdateRemoteJSON
+let isOwned: VideoChannelMethods.IsOwned
+let countByAuthor: VideoChannelMethods.CountByAuthor
+let listOwned: VideoChannelMethods.ListOwned
+let listForApi: VideoChannelMethods.ListForApi
+let listByAuthor: VideoChannelMethods.ListByAuthor
+let loadByIdAndAuthor: VideoChannelMethods.LoadByIdAndAuthor
+let loadByUUID: VideoChannelMethods.LoadByUUID
+let loadAndPopulateAuthor: VideoChannelMethods.LoadAndPopulateAuthor
+let loadByUUIDAndPopulateAuthor: VideoChannelMethods.LoadByUUIDAndPopulateAuthor
+let loadByHostAndUUID: VideoChannelMethods.LoadByHostAndUUID
+let loadAndPopulateAuthorAndVideos: VideoChannelMethods.LoadAndPopulateAuthorAndVideos
+
+export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
+  VideoChannel = sequelize.define<VideoChannelInstance, VideoChannelAttributes>('VideoChannel',
+    {
+      uuid: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        allowNull: false,
+        validate: {
+          isUUID: 4
+        }
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          nameValid: value => {
+            const res = isVideoChannelNameValid(value)
+            if (res === false) throw new Error('Video channel name is not valid.')
+          }
+        }
+      },
+      description: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        validate: {
+          descriptionValid: value => {
+            const res = isVideoChannelDescriptionValid(value)
+            if (res === false) throw new Error('Video channel description is not valid.')
+          }
+        }
+      },
+      remote: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      }
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'authorId' ]
+        }
+      ],
+      hooks: {
+        afterDestroy
+      }
+    }
+  )
+
+  const classMethods = [
+    associate,
+
+    listForApi,
+    listByAuthor,
+    listOwned,
+    loadByIdAndAuthor,
+    loadAndPopulateAuthor,
+    loadByUUIDAndPopulateAuthor,
+    loadByUUID,
+    loadByHostAndUUID,
+    loadAndPopulateAuthorAndVideos,
+    countByAuthor
+  ]
+  const instanceMethods = [
+    isOwned,
+    toFormattedJSON,
+    toAddRemoteJSON,
+    toUpdateRemoteJSON
+  ]
+  addMethodsToModel(VideoChannel, classMethods, instanceMethods)
+
+  return VideoChannel
+}
+
+// ------------------------------ METHODS ------------------------------
+
+isOwned = function (this: VideoChannelInstance) {
+  return this.remote === false
+}
+
+toFormattedJSON = function (this: VideoChannelInstance) {
+  const json = {
+    id: this.id,
+    uuid: this.uuid,
+    name: this.name,
+    description: this.description,
+    isLocal: this.isOwned(),
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt
+  }
+
+  if (this.Author !== undefined) {
+    json['owner'] = {
+      name: this.Author.name,
+      uuid: this.Author.uuid
+    }
+  }
+
+  if (Array.isArray(this.Videos)) {
+    json['videos'] = this.Videos.map(v => v.toFormattedJSON())
+  }
+
+  return json
+}
+
+toAddRemoteJSON = function (this: VideoChannelInstance) {
+  const json = {
+    uuid: this.uuid,
+    name: this.name,
+    description: this.description,
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt,
+    ownerUUID: this.Author.uuid
+  }
+
+  return json
+}
+
+toUpdateRemoteJSON = function (this: VideoChannelInstance) {
+  const json = {
+    uuid: this.uuid,
+    name: this.name,
+    description: this.description,
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt,
+    ownerUUID: this.Author.uuid
+  }
+
+  return json
+}
+
+// ------------------------------ STATICS ------------------------------
+
+function associate (models) {
+  VideoChannel.belongsTo(models.Author, {
+    foreignKey: {
+      name: 'authorId',
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+
+  VideoChannel.hasMany(models.Video, {
+    foreignKey: {
+      name: 'channelId',
+      allowNull: false
+    },
+    onDelete: 'CASCADE'
+  })
+}
+
+function afterDestroy (videoChannel: VideoChannelInstance, options: { transaction: Sequelize.Transaction }) {
+  if (videoChannel.isOwned()) {
+    const removeVideoChannelToFriendsParams = {
+      uuid: videoChannel.uuid
+    }
+
+    return removeVideoChannelToFriends(removeVideoChannelToFriendsParams, options.transaction)
+  }
+
+  return undefined
+}
+
+countByAuthor = function (authorId: number) {
+  const query = {
+    where: {
+      authorId
+    }
+  }
+
+  return VideoChannel.count(query)
+}
+
+listOwned = function () {
+  const query = {
+    where: {
+      remote: false
+    },
+    include: [ VideoChannel['sequelize'].models.Author ]
+  }
+
+  return VideoChannel.findAll(query)
+}
+
+listForApi = function (start: number, count: number, sort: string) {
+  const query = {
+    offset: start,
+    limit: count,
+    order: [ getSort(sort) ],
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        required: true,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      }
+    ]
+  }
+
+  return VideoChannel.findAndCountAll(query).then(({ rows, count }) => {
+    return { total: count, data: rows }
+  })
+}
+
+listByAuthor = function (authorId: number) {
+  const query = {
+    order: [ getSort('createdAt') ],
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        where: {
+          id: authorId
+        },
+        required: true,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      }
+    ]
+  }
+
+  return VideoChannel.findAndCountAll(query).then(({ rows, count }) => {
+    return { total: count, data: rows }
+  })
+}
+
+loadByUUID = function (uuid: string, t?: Sequelize.Transaction) {
+  const query: Sequelize.FindOptions<VideoChannelAttributes> = {
+    where: {
+      uuid
+    }
+  }
+
+  if (t !== undefined) query.transaction = t
+
+  return VideoChannel.findOne(query)
+}
+
+loadByHostAndUUID = function (fromHost: string, uuid: string, t?: Sequelize.Transaction) {
+  const query: Sequelize.FindOptions<VideoChannelAttributes> = {
+    where: {
+      uuid
+    },
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        include: [
+          {
+            model: VideoChannel['sequelize'].models.Pod,
+            required: true,
+            where: {
+              host: fromHost
+            }
+          }
+        ]
+      }
+    ]
+  }
+
+  if (t !== undefined) query.transaction = t
+
+  return VideoChannel.findOne(query)
+}
+
+loadByIdAndAuthor = function (id: number, authorId: number) {
+  const options = {
+    where: {
+      id,
+      authorId
+    },
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      }
+    ]
+  }
+
+  return VideoChannel.findOne(options)
+}
+
+loadAndPopulateAuthor = function (id: number) {
+  const options = {
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      }
+    ]
+  }
+
+  return VideoChannel.findById(id, options)
+}
+
+loadByUUIDAndPopulateAuthor = function (uuid: string) {
+  const options = {
+    where: {
+      uuid
+    },
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      }
+    ]
+  }
+
+  return VideoChannel.findOne(options)
+}
+
+loadAndPopulateAuthorAndVideos = function (id: number) {
+  const options = {
+    include: [
+      {
+        model: VideoChannel['sequelize'].models.Author,
+        include: [ { model: VideoChannel['sequelize'].models.Pod, required: false } ]
+      },
+      VideoChannel['sequelize'].models.Video
+    ]
+  }
+
+  return VideoChannel.findById(id, options)
+}
diff --git a/server/models/video/video-interface.ts b/server/models/video/video-interface.ts
index 86ce84dd9..4b5ae08c2 100644
--- a/server/models/video/video-interface.ts
+++ b/server/models/video/video-interface.ts
@@ -6,16 +6,21 @@ import { TagAttributes, TagInstance } from './tag-interface'
 import { VideoFileAttributes, VideoFileInstance } from './video-file-interface'
 
 // Don't use barrel, import just what we need
-import { Video as FormattedVideo } from '../../../shared/models/videos/video.model'
+import {
+  Video as FormattedVideo,
+  VideoDetails as FormattedDetailsVideo
+} from '../../../shared/models/videos/video.model'
 import { RemoteVideoUpdateData } from '../../../shared/models/pods/remote-video/remote-video-update-request.model'
 import { RemoteVideoCreateData } from '../../../shared/models/pods/remote-video/remote-video-create-request.model'
 import { ResultList } from '../../../shared/models/result-list.model'
+import { VideoChannelInstance } from './video-channel-interface'
 
 export namespace VideoMethods {
   export type GetThumbnailName = (this: VideoInstance) => string
   export type GetPreviewName = (this: VideoInstance) => string
   export type IsOwned = (this: VideoInstance) => boolean
   export type ToFormattedJSON = (this: VideoInstance) => FormattedVideo
+  export type ToFormattedDetailsJSON = (this: VideoInstance) => FormattedDetailsVideo
 
   export type GetOriginalFile = (this: VideoInstance) => VideoFileInstance
   export type GetTorrentFileName = (this: VideoInstance, videoFile: VideoFileInstance) => string
@@ -52,8 +57,8 @@ export namespace VideoMethods {
   ) => Promise< ResultList<VideoInstance> >
 
   export type Load = (id: number) => Promise<VideoInstance>
-  export type LoadByUUID = (uuid: string) => Promise<VideoInstance>
-  export type LoadByHostAndUUID = (fromHost: string, uuid: string) => Promise<VideoInstance>
+  export type LoadByUUID = (uuid: string, t?: Sequelize.Transaction) => Promise<VideoInstance>
+  export type LoadByHostAndUUID = (fromHost: string, uuid: string, t?: Sequelize.Transaction) => Promise<VideoInstance>
   export type LoadAndPopulateAuthor = (id: number) => Promise<VideoInstance>
   export type LoadAndPopulateAuthorAndPodAndTags = (id: number) => Promise<VideoInstance>
   export type LoadByUUIDAndPopulateAuthorAndPodAndTags = (uuid: string) => Promise<VideoInstance>
@@ -94,7 +99,9 @@ export interface VideoAttributes {
   dislikes?: number
   remote: boolean
 
-  Author?: AuthorInstance
+  channelId?: number
+
+  VideoChannel?: VideoChannelInstance
   Tags?: TagInstance[]
   VideoFiles?: VideoFileInstance[]
 }
@@ -121,6 +128,7 @@ export interface VideoInstance extends VideoClass, VideoAttributes, Sequelize.In
   removeTorrent: VideoMethods.RemoveTorrent
   toAddRemoteJSON: VideoMethods.ToAddRemoteJSON
   toFormattedJSON: VideoMethods.ToFormattedJSON
+  toFormattedDetailsJSON: VideoMethods.ToFormattedDetailsJSON
   toUpdateRemoteJSON: VideoMethods.ToUpdateRemoteJSON
   optimizeOriginalVideofile: VideoMethods.OptimizeOriginalVideofile
   transcodeOriginalVideofile: VideoMethods.TranscodeOriginalVideofile
diff --git a/server/models/video/video.ts b/server/models/video/video.ts
index 0b1af4d21..d9b976404 100644
--- a/server/models/video/video.ts
+++ b/server/models/video/video.ts
@@ -60,6 +60,7 @@ let getPreviewPath: VideoMethods.GetPreviewPath
 let getTorrentFileName: VideoMethods.GetTorrentFileName
 let isOwned: VideoMethods.IsOwned
 let toFormattedJSON: VideoMethods.ToFormattedJSON
+let toFormattedDetailsJSON: VideoMethods.ToFormattedDetailsJSON
 let toAddRemoteJSON: VideoMethods.ToAddRemoteJSON
 let toUpdateRemoteJSON: VideoMethods.ToUpdateRemoteJSON
 let optimizeOriginalVideofile: VideoMethods.OptimizeOriginalVideofile
@@ -206,9 +207,6 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
     {
       indexes: [
         {
-          fields: [ 'authorId' ]
-        },
-        {
           fields: [ 'name' ]
         },
         {
@@ -225,6 +223,9 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
         },
         {
           fields: [ 'uuid' ]
+        },
+        {
+          fields: [ 'channelId' ]
         }
       ],
       hooks: {
@@ -268,6 +269,7 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
     removeTorrent,
     toAddRemoteJSON,
     toFormattedJSON,
+    toFormattedDetailsJSON,
     toUpdateRemoteJSON,
     optimizeOriginalVideofile,
     transcodeOriginalVideofile,
@@ -282,9 +284,9 @@ export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.Da
 // ------------------------------ METHODS ------------------------------
 
 function associate (models) {
-  Video.belongsTo(models.Author, {
+  Video.belongsTo(models.VideoChannel, {
     foreignKey: {
-      name: 'authorId',
+      name: 'channelId',
       allowNull: false
     },
     onDelete: 'cascade'
@@ -439,8 +441,8 @@ getPreviewPath = function (this: VideoInstance) {
 toFormattedJSON = function (this: VideoInstance) {
   let podHost
 
-  if (this.Author.Pod) {
-    podHost = this.Author.Pod.host
+  if (this.VideoChannel.Author.Pod) {
+    podHost = this.VideoChannel.Author.Pod.host
   } else {
     // It means it's our video
     podHost = CONFIG.WEBSERVER.HOST
@@ -472,7 +474,59 @@ toFormattedJSON = function (this: VideoInstance) {
     description: this.description,
     podHost,
     isLocal: this.isOwned(),
-    author: this.Author.name,
+    author: this.VideoChannel.Author.name,
+    duration: this.duration,
+    views: this.views,
+    likes: this.likes,
+    dislikes: this.dislikes,
+    tags: map<TagInstance, string>(this.Tags, 'name'),
+    thumbnailPath: this.getThumbnailPath(),
+    previewPath: this.getPreviewPath(),
+    embedPath: this.getEmbedPath(),
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt
+  }
+
+  return json
+}
+
+toFormattedDetailsJSON = function (this: VideoInstance) {
+  let podHost
+
+  if (this.VideoChannel.Author.Pod) {
+    podHost = this.VideoChannel.Author.Pod.host
+  } else {
+    // It means it's our video
+    podHost = CONFIG.WEBSERVER.HOST
+  }
+
+  // Maybe our pod is not up to date and there are new categories since our version
+  let categoryLabel = VIDEO_CATEGORIES[this.category]
+  if (!categoryLabel) categoryLabel = 'Misc'
+
+  // Maybe our pod is not up to date and there are new licences since our version
+  let licenceLabel = VIDEO_LICENCES[this.licence]
+  if (!licenceLabel) licenceLabel = 'Unknown'
+
+  // Language is an optional attribute
+  let languageLabel = VIDEO_LANGUAGES[this.language]
+  if (!languageLabel) languageLabel = 'Unknown'
+
+  const json = {
+    id: this.id,
+    uuid: this.uuid,
+    name: this.name,
+    category: this.category,
+    categoryLabel,
+    licence: this.licence,
+    licenceLabel,
+    language: this.language,
+    languageLabel,
+    nsfw: this.nsfw,
+    description: this.description,
+    podHost,
+    isLocal: this.isOwned(),
+    author: this.VideoChannel.Author.name,
     duration: this.duration,
     views: this.views,
     likes: this.likes,
@@ -483,6 +537,7 @@ toFormattedJSON = function (this: VideoInstance) {
     embedPath: this.getEmbedPath(),
     createdAt: this.createdAt,
     updatedAt: this.updatedAt,
+    channel: this.VideoChannel.toFormattedJSON(),
     files: []
   }
 
@@ -525,7 +580,7 @@ toAddRemoteJSON = function (this: VideoInstance) {
       language: this.language,
       nsfw: this.nsfw,
       description: this.description,
-      author: this.Author.name,
+      channelUUID: this.VideoChannel.uuid,
       duration: this.duration,
       thumbnailData: thumbnailData.toString('binary'),
       tags: map<TagInstance, string>(this.Tags, 'name'),
@@ -559,7 +614,6 @@ toUpdateRemoteJSON = function (this: VideoInstance) {
     language: this.language,
     nsfw: this.nsfw,
     description: this.description,
-    author: this.Author.name,
     duration: this.duration,
     tags: map<TagInstance, string>(this.Tags, 'name'),
     createdAt: this.createdAt,
@@ -723,8 +777,18 @@ listForApi = function (start: number, count: number, sort: string) {
     order: [ getSort(sort), [ Video['sequelize'].models.Tag, 'name', 'ASC' ] ],
     include: [
       {
-        model: Video['sequelize'].models.Author,
-        include: [ { model: Video['sequelize'].models.Pod, required: false } ]
+        model: Video['sequelize'].models.VideoChannel,
+        include: [
+          {
+            model: Video['sequelize'].models.Author,
+            include: [
+              {
+                model: Video['sequelize'].models.Pod,
+                required: false
+              }
+            ]
+          }
+        ]
       },
       Video['sequelize'].models.Tag,
       Video['sequelize'].models.VideoFile
@@ -740,8 +804,8 @@ listForApi = function (start: number, count: number, sort: string) {
   })
 }
 
-loadByHostAndUUID = function (fromHost: string, uuid: string) {
-  const query = {
+loadByHostAndUUID = function (fromHost: string, uuid: string, t?: Sequelize.Transaction) {
+  const query: Sequelize.FindOptions<VideoAttributes> = {
     where: {
       uuid
     },
@@ -750,20 +814,27 @@ loadByHostAndUUID = function (fromHost: string, uuid: string) {
         model: Video['sequelize'].models.VideoFile
       },
       {
-        model: Video['sequelize'].models.Author,
+        model: Video['sequelize'].models.VideoChannel,
         include: [
           {
-            model: Video['sequelize'].models.Pod,
-            required: true,
-            where: {
-              host: fromHost
-            }
+            model: Video['sequelize'].models.Author,
+            include: [
+              {
+                model: Video['sequelize'].models.Pod,
+                required: true,
+                where: {
+                  host: fromHost
+                }
+              }
+            ]
           }
         ]
       }
     ]
   }
 
+  if (t !== undefined) query.transaction = t
+
   return Video.findOne(query)
 }
 
@@ -774,7 +845,10 @@ listOwnedAndPopulateAuthorAndTags = function () {
     },
     include: [
       Video['sequelize'].models.VideoFile,
-      Video['sequelize'].models.Author,
+      {
+        model: Video['sequelize'].models.VideoChannel,
+        include: [ Video['sequelize'].models.Author ]
+      },
       Video['sequelize'].models.Tag
     ]
   }
@@ -792,10 +866,15 @@ listOwnedByAuthor = function (author: string) {
         model: Video['sequelize'].models.VideoFile
       },
       {
-        model: Video['sequelize'].models.Author,
-        where: {
-          name: author
-        }
+        model: Video['sequelize'].models.VideoChannel,
+        include: [
+          {
+            model: Video['sequelize'].models.Author,
+            where: {
+              name: author
+            }
+          }
+        ]
       }
     ]
   }
@@ -807,19 +886,28 @@ load = function (id: number) {
   return Video.findById(id)
 }
 
-loadByUUID = function (uuid: string) {
-  const query = {
+loadByUUID = function (uuid: string, t?: Sequelize.Transaction) {
+  const query: Sequelize.FindOptions<VideoAttributes> = {
     where: {
       uuid
     },
     include: [ Video['sequelize'].models.VideoFile ]
   }
+
+  if (t !== undefined) query.transaction = t
+
   return Video.findOne(query)
 }
 
 loadAndPopulateAuthor = function (id: number) {
   const options = {
-    include: [ Video['sequelize'].models.VideoFile, Video['sequelize'].models.Author ]
+    include: [
+      Video['sequelize'].models.VideoFile,
+      {
+        model: Video['sequelize'].models.VideoChannel,
+        include: [ Video['sequelize'].models.Author ]
+      }
+    ]
   }
 
   return Video.findById(id, options)
@@ -829,8 +917,13 @@ loadAndPopulateAuthorAndPodAndTags = function (id: number) {
   const options = {
     include: [
       {
-        model: Video['sequelize'].models.Author,
-        include: [ { model: Video['sequelize'].models.Pod, required: false } ]
+        model: Video['sequelize'].models.VideoChannel,
+        include: [
+          {
+            model: Video['sequelize'].models.Author,
+            include: [ { model: Video['sequelize'].models.Pod, required: false } ]
+          }
+        ]
       },
       Video['sequelize'].models.Tag,
       Video['sequelize'].models.VideoFile
@@ -847,8 +940,13 @@ loadByUUIDAndPopulateAuthorAndPodAndTags = function (uuid: string) {
     },
     include: [
       {
-        model: Video['sequelize'].models.Author,
-        include: [ { model: Video['sequelize'].models.Pod, required: false } ]
+        model: Video['sequelize'].models.VideoChannel,
+        include: [
+          {
+            model: Video['sequelize'].models.Author,
+            include: [ { model: Video['sequelize'].models.Pod, required: false } ]
+          }
+        ]
       },
       Video['sequelize'].models.Tag,
       Video['sequelize'].models.VideoFile
@@ -866,9 +964,13 @@ searchAndPopulateAuthorAndPodAndTags = function (value: string, field: string, s
 
   const authorInclude: Sequelize.IncludeOptions = {
     model: Video['sequelize'].models.Author,
-    include: [
-      podInclude
-    ]
+    include: [ podInclude ]
+  }
+
+  const videoChannelInclude: Sequelize.IncludeOptions = {
+    model: Video['sequelize'].models.VideoChannel,
+    include: [ authorInclude ],
+    required: true
   }
 
   const tagInclude: Sequelize.IncludeOptions = {
@@ -915,8 +1017,6 @@ searchAndPopulateAuthorAndPodAndTags = function (value: string, field: string, s
         $iLike: '%' + value + '%'
       }
     }
-
-    // authorInclude.or = true
   } else {
     query.where[field] = {
       $iLike: '%' + value + '%'
@@ -924,7 +1024,7 @@ searchAndPopulateAuthorAndPodAndTags = function (value: string, field: string, s
   }
 
   query.include = [
-    authorInclude, tagInclude, videoFileInclude
+    videoChannelInclude, tagInclude, videoFileInclude
   ]
 
   return Video.findAndCountAll(query).then(({ rows, count }) => {
@@ -955,8 +1055,8 @@ function getBaseUrls (video: VideoInstance) {
     baseUrlHttp = CONFIG.WEBSERVER.URL
     baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
   } else {
-    baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + video.Author.Pod.host
-    baseUrlWs = REMOTE_SCHEME.WS + '://' + video.Author.Pod.host
+    baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + video.VideoChannel.Author.Pod.host
+    baseUrlWs = REMOTE_SCHEME.WS + '://' + video.VideoChannel.Author.Pod.host
   }
 
   return { baseUrlHttp, baseUrlWs }