Add video channels

5 files changed, 501 insertions, 81 deletions

diff --git a/server/controllers/api/remote/pods.ts b/server/controllers/api/remote/pods.ts
index 6f7b5f651..a62b9c684 100644
--- a/server/controllers/api/remote/pods.ts
+++ b/server/controllers/api/remote/pods.ts
@@ -7,7 +7,7 @@ import {
   setBodyHostPort,
   remotePodsAddValidator
 } from '../../../middlewares'
-import { sendOwnedVideosToPod } from '../../../lib'
+import { sendOwnedDataToPod } from '../../../lib'
 import { getMyPublicCert, getFormattedObjects } from '../../../helpers'
 import { CONFIG } from '../../../initializers'
 import { PodInstance } from '../../../models'
@@ -43,7 +43,7 @@ function addPods (req: express.Request, res: express.Response, next: express.Nex
   const pod = db.Pod.build(information)
   pod.save()
      .then(podCreated => {
-       return sendOwnedVideosToPod(podCreated.id)
+       return sendOwnedDataToPod(podCreated.id)
      })
      .then(() => {
        return getMyPublicCert()
diff --git a/server/controllers/api/remote/videos.ts b/server/controllers/api/remote/videos.ts
index 23023211f..c8f531490 100644
--- a/server/controllers/api/remote/videos.ts
+++ b/server/controllers/api/remote/videos.ts
@@ -1,5 +1,6 @@
 import * as express from 'express'
 import * as Promise from 'bluebird'
+import * as Sequelize from 'sequelize'
 
 import { database as db } from '../../../initializers/database'
 import {
@@ -27,17 +28,28 @@ import {
   RemoteQaduVideoRequest,
   RemoteQaduVideoData,
   RemoteVideoEventRequest,
-  RemoteVideoEventData
+  RemoteVideoEventData,
+  RemoteVideoChannelCreateData,
+  RemoteVideoChannelUpdateData,
+  RemoteVideoChannelRemoveData,
+  RemoteVideoAuthorRemoveData,
+  RemoteVideoAuthorCreateData
 } from '../../../../shared'
 
 const ENDPOINT_ACTIONS = REQUEST_ENDPOINT_ACTIONS[REQUEST_ENDPOINTS.VIDEOS]
 
 // Functions to call when processing a remote request
+// FIXME: use RemoteVideoRequestType as id type
 const functionsHash: { [ id: string ]: (...args) => Promise<any> } = {}
-functionsHash[ENDPOINT_ACTIONS.ADD] = addRemoteVideoRetryWrapper
-functionsHash[ENDPOINT_ACTIONS.UPDATE] = updateRemoteVideoRetryWrapper
-functionsHash[ENDPOINT_ACTIONS.REMOVE] = removeRemoteVideo
-functionsHash[ENDPOINT_ACTIONS.REPORT_ABUSE] = reportAbuseRemoteVideo
+functionsHash[ENDPOINT_ACTIONS.ADD_VIDEO] = addRemoteVideoRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.UPDATE_VIDEO] = updateRemoteVideoRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.REMOVE_VIDEO] = removeRemoteVideoRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.ADD_CHANNEL] = addRemoteVideoChannelRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.UPDATE_CHANNEL] = updateRemoteVideoChannelRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.REMOVE_CHANNEL] = removeRemoteVideoChannelRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.REPORT_ABUSE] = reportAbuseRemoteVideoRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.ADD_AUTHOR] = addRemoteVideoAuthorRetryWrapper
+functionsHash[ENDPOINT_ACTIONS.REMOVE_AUTHOR] = removeRemoteVideoAuthorRetryWrapper
 
 const remoteVideosRouter = express.Router()
 
@@ -133,7 +145,7 @@ function processVideosEventsRetryWrapper (eventData: RemoteVideoEventData, fromP
 function processVideosEvents (eventData: RemoteVideoEventData, fromPod: PodInstance) {
 
   return db.sequelize.transaction(t => {
-    return fetchVideoByUUID(eventData.uuid)
+    return fetchVideoByUUID(eventData.uuid, t)
       .then(videoInstance => {
         const options = { transaction: t }
 
@@ -196,7 +208,7 @@ function quickAndDirtyUpdateVideo (videoData: RemoteQaduVideoData, fromPod: PodI
   let videoUUID = ''
 
   return db.sequelize.transaction(t => {
-    return fetchVideoByHostAndUUID(fromPod.host, videoData.uuid)
+    return fetchVideoByHostAndUUID(fromPod.host, videoData.uuid, t)
       .then(videoInstance => {
         const options = { transaction: t }
 
@@ -239,22 +251,16 @@ function addRemoteVideo (videoToCreateData: RemoteVideoCreateData, fromPod: PodI
       .then(video => {
         if (video) throw new Error('UUID already exists.')
 
-        return undefined
+        return db.VideoChannel.loadByHostAndUUID(fromPod.host, videoToCreateData.channelUUID, t)
       })
-      .then(() => {
-        const name = videoToCreateData.author
-        const podId = fromPod.id
-        // This author is from another pod so we do not associate a user
-        const userId = null
+      .then(videoChannel => {
+        if (!videoChannel) throw new Error('Video channel ' + videoToCreateData.channelUUID + ' not found.')
 
-        return db.Author.findOrCreateAuthor(name, podId, userId, t)
-      })
-      .then(author => {
         const tags = videoToCreateData.tags
 
-        return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
+        return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ videoChannel, tagInstances }))
       })
-      .then(({ author, tagInstances }) => {
+      .then(({ videoChannel, tagInstances }) => {
         const videoData = {
           name: videoToCreateData.name,
           uuid: videoToCreateData.uuid,
@@ -263,7 +269,7 @@ function addRemoteVideo (videoToCreateData: RemoteVideoCreateData, fromPod: PodI
           language: videoToCreateData.language,
           nsfw: videoToCreateData.nsfw,
           description: videoToCreateData.description,
-          authorId: author.id,
+          channelId: videoChannel.id,
           duration: videoToCreateData.duration,
           createdAt: videoToCreateData.createdAt,
           // FIXME: updatedAt does not seems to be considered by Sequelize
@@ -336,7 +342,7 @@ function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, from
   logger.debug('Updating remote video "%s".', videoAttributesToUpdate.uuid)
 
   return db.sequelize.transaction(t => {
-    return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid)
+    return fetchVideoByHostAndUUID(fromPod.host, videoAttributesToUpdate.uuid, t)
       .then(videoInstance => {
         const tags = videoAttributesToUpdate.tags
 
@@ -365,7 +371,7 @@ function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, from
 
         // Remove old video files
         videoInstance.VideoFiles.forEach(videoFile => {
-          tasks.push(videoFile.destroy())
+          tasks.push(videoFile.destroy({ transaction: t }))
         })
 
         return Promise.all(tasks).then(() => ({ tagInstances, videoInstance }))
@@ -404,37 +410,231 @@ function updateRemoteVideo (videoAttributesToUpdate: RemoteVideoUpdateData, from
   })
 }
 
+function removeRemoteVideoRetryWrapper (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ videoToRemoveData, fromPod ],
+    errorMessage: 'Cannot remove the remote video channel with many retries.'
+  }
+
+  return retryTransactionWrapper(removeRemoteVideo, options)
+}
+
 function removeRemoteVideo (videoToRemoveData: RemoteVideoRemoveData, fromPod: PodInstance) {
-  // We need the instance because we have to remove some other stuffs (thumbnail etc)
-  return fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid)
-    .then(video => {
-      logger.debug('Removing remote video with uuid %s.', video.uuid)
-      return video.destroy()
-    })
+  logger.debug('Removing remote video "%s".', videoToRemoveData.uuid)
+
+  return db.sequelize.transaction(t => {
+    // We need the instance because we have to remove some other stuffs (thumbnail etc)
+    return fetchVideoByHostAndUUID(fromPod.host, videoToRemoveData.uuid, t)
+      .then(video => video.destroy({ transaction: t }))
+  })
+  .then(() => logger.info('Remote video with uuid %s removed.', videoToRemoveData.uuid))
+  .catch(err => {
+    logger.debug('Cannot remove the remote video.', err)
+    throw err
+  })
+}
+
+function addRemoteVideoAuthorRetryWrapper (authorToCreateData: RemoteVideoAuthorCreateData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ authorToCreateData, fromPod ],
+    errorMessage: 'Cannot insert the remote video author with many retries.'
+  }
+
+  return retryTransactionWrapper(addRemoteVideoAuthor, options)
+}
+
+function addRemoteVideoAuthor (authorToCreateData: RemoteVideoAuthorCreateData, fromPod: PodInstance) {
+  logger.debug('Adding remote video author "%s".', authorToCreateData.uuid)
+
+  return db.sequelize.transaction(t => {
+    return db.Author.loadAuthorByPodAndUUID(authorToCreateData.uuid, fromPod.id, t)
+      .then(author => {
+        if (author) throw new Error('UUID already exists.')
+
+        return undefined
+      })
+      .then(() => {
+        const videoAuthorData = {
+          name: authorToCreateData.name,
+          uuid: authorToCreateData.uuid,
+          userId: null, // Not on our pod
+          podId: fromPod.id
+        }
+
+        const author = db.Author.build(videoAuthorData)
+        return author.save({ transaction: t })
+      })
+  })
+    .then(() => logger.info('Remote video author with uuid %s inserted.', authorToCreateData.uuid))
     .catch(err => {
-      logger.debug('Could not fetch remote video.', { host: fromPod.host, uuid: videoToRemoveData.uuid, error: err.stack })
+      logger.debug('Cannot insert the remote video author.', err)
+      throw err
     })
 }
 
+function removeRemoteVideoAuthorRetryWrapper (authorAttributesToRemove: RemoteVideoAuthorRemoveData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ authorAttributesToRemove, fromPod ],
+    errorMessage: 'Cannot remove the remote video author with many retries.'
+  }
+
+  return retryTransactionWrapper(removeRemoteVideoAuthor, options)
+}
+
+function removeRemoteVideoAuthor (authorAttributesToRemove: RemoteVideoAuthorRemoveData, fromPod: PodInstance) {
+  logger.debug('Removing remote video author "%s".', authorAttributesToRemove.uuid)
+
+  return db.sequelize.transaction(t => {
+    return db.Author.loadAuthorByPodAndUUID(authorAttributesToRemove.uuid, fromPod.id, t)
+      .then(videoAuthor => videoAuthor.destroy({ transaction: t }))
+  })
+  .then(() => logger.info('Remote video author with uuid %s removed.', authorAttributesToRemove.uuid))
+  .catch(err => {
+    logger.debug('Cannot remove the remote video author.', err)
+    throw err
+  })
+}
+
+function addRemoteVideoChannelRetryWrapper (videoChannelToCreateData: RemoteVideoChannelCreateData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ videoChannelToCreateData, fromPod ],
+    errorMessage: 'Cannot insert the remote video channel with many retries.'
+  }
+
+  return retryTransactionWrapper(addRemoteVideoChannel, options)
+}
+
+function addRemoteVideoChannel (videoChannelToCreateData: RemoteVideoChannelCreateData, fromPod: PodInstance) {
+  logger.debug('Adding remote video channel "%s".', videoChannelToCreateData.uuid)
+
+  return db.sequelize.transaction(t => {
+    return db.VideoChannel.loadByUUID(videoChannelToCreateData.uuid)
+      .then(videoChannel => {
+        if (videoChannel) throw new Error('UUID already exists.')
+
+        return undefined
+      })
+      .then(() => {
+        const authorUUID = videoChannelToCreateData.ownerUUID
+        const podId = fromPod.id
+
+        return db.Author.loadAuthorByPodAndUUID(authorUUID, podId, t)
+      })
+      .then(author => {
+        if (!author) throw new Error('Unknown author UUID.')
+
+        const videoChannelData = {
+          name: videoChannelToCreateData.name,
+          description: videoChannelToCreateData.description,
+          uuid: videoChannelToCreateData.uuid,
+          createdAt: videoChannelToCreateData.createdAt,
+          updatedAt: videoChannelToCreateData.updatedAt,
+          remote: true,
+          authorId: author.id
+        }
+
+        const videoChannel = db.VideoChannel.build(videoChannelData)
+        return videoChannel.save({ transaction: t })
+      })
+  })
+  .then(() => logger.info('Remote video channel with uuid %s inserted.', videoChannelToCreateData.uuid))
+  .catch(err => {
+    logger.debug('Cannot insert the remote video channel.', err)
+    throw err
+  })
+}
+
+function updateRemoteVideoChannelRetryWrapper (videoChannelAttributesToUpdate: RemoteVideoChannelUpdateData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ videoChannelAttributesToUpdate, fromPod ],
+    errorMessage: 'Cannot update the remote video channel with many retries.'
+  }
+
+  return retryTransactionWrapper(updateRemoteVideoChannel, options)
+}
+
+function updateRemoteVideoChannel (videoChannelAttributesToUpdate: RemoteVideoChannelUpdateData, fromPod: PodInstance) {
+  logger.debug('Updating remote video channel "%s".', videoChannelAttributesToUpdate.uuid)
+
+  return db.sequelize.transaction(t => {
+    return fetchVideoChannelByHostAndUUID(fromPod.host, videoChannelAttributesToUpdate.uuid, t)
+      .then(videoChannelInstance => {
+        const options = { transaction: t }
+
+        videoChannelInstance.set('name', videoChannelAttributesToUpdate.name)
+        videoChannelInstance.set('description', videoChannelAttributesToUpdate.description)
+        videoChannelInstance.set('createdAt', videoChannelAttributesToUpdate.createdAt)
+        videoChannelInstance.set('updatedAt', videoChannelAttributesToUpdate.updatedAt)
+
+        return videoChannelInstance.save(options)
+      })
+  })
+  .then(() => logger.info('Remote video channel with uuid %s updated', videoChannelAttributesToUpdate.uuid))
+  .catch(err => {
+    // This is just a debug because we will retry the insert
+    logger.debug('Cannot update the remote video channel.', err)
+    throw err
+  })
+}
+
+function removeRemoteVideoChannelRetryWrapper (videoChannelAttributesToRemove: RemoteVideoChannelRemoveData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ videoChannelAttributesToRemove, fromPod ],
+    errorMessage: 'Cannot remove the remote video channel with many retries.'
+  }
+
+  return retryTransactionWrapper(removeRemoteVideoChannel, options)
+}
+
+function removeRemoteVideoChannel (videoChannelAttributesToRemove: RemoteVideoChannelRemoveData, fromPod: PodInstance) {
+  logger.debug('Removing remote video channel "%s".', videoChannelAttributesToRemove.uuid)
+
+  return db.sequelize.transaction(t => {
+    return fetchVideoChannelByHostAndUUID(fromPod.host, videoChannelAttributesToRemove.uuid, t)
+      .then(videoChannel => videoChannel.destroy({ transaction: t }))
+  })
+  .then(() => logger.info('Remote video channel with uuid %s removed.', videoChannelAttributesToRemove.uuid))
+  .catch(err => {
+    logger.debug('Cannot remove the remote video channel.', err)
+    throw err
+  })
+}
+
+function reportAbuseRemoteVideoRetryWrapper (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
+  const options = {
+    arguments: [ reportData, fromPod ],
+    errorMessage: 'Cannot create remote abuse video with many retries.'
+  }
+
+  return retryTransactionWrapper(reportAbuseRemoteVideo, options)
+}
+
 function reportAbuseRemoteVideo (reportData: RemoteVideoReportAbuseData, fromPod: PodInstance) {
-  return fetchVideoByUUID(reportData.videoUUID)
-    .then(video => {
-      logger.debug('Reporting remote abuse for video %s.', video.id)
+  logger.debug('Reporting remote abuse for video %s.', reportData.videoUUID)
 
-      const videoAbuseData = {
-        reporterUsername: reportData.reporterUsername,
-        reason: reportData.reportReason,
-        reporterPodId: fromPod.id,
-        videoId: video.id
-      }
+  return db.sequelize.transaction(t => {
+    return fetchVideoByUUID(reportData.videoUUID, t)
+      .then(video => {
+        const videoAbuseData = {
+          reporterUsername: reportData.reporterUsername,
+          reason: reportData.reportReason,
+          reporterPodId: fromPod.id,
+          videoId: video.id
+        }
 
-      return db.VideoAbuse.create(videoAbuseData)
-    })
-    .catch(err => logger.error('Cannot create remote abuse video.', err))
+        return db.VideoAbuse.create(videoAbuseData)
+      })
+  })
+  .then(() => logger.info('Remote abuse for video uuid %s created', reportData.videoUUID))
+  .catch(err => {
+    // This is just a debug because we will retry the insert
+    logger.debug('Cannot create remote abuse video', err)
+    throw err
+  })
 }
 
-function fetchVideoByUUID (id: string) {
-  return db.Video.loadByUUID(id)
+function fetchVideoByUUID (id: string, t: Sequelize.Transaction) {
+  return db.Video.loadByUUID(id, t)
     .then(video => {
       if (!video) throw new Error('Video not found')
 
@@ -446,8 +646,8 @@ function fetchVideoByUUID (id: string) {
     })
 }
 
-function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
-  return db.Video.loadByHostAndUUID(podHost, uuid)
+function fetchVideoByHostAndUUID (podHost: string, uuid: string, t: Sequelize.Transaction) {
+  return db.Video.loadByHostAndUUID(podHost, uuid, t)
     .then(video => {
       if (!video) throw new Error('Video not found')
 
@@ -458,3 +658,16 @@ function fetchVideoByHostAndUUID (podHost: string, uuid: string) {
       throw err
     })
 }
+
+function fetchVideoChannelByHostAndUUID (podHost: string, uuid: string, t: Sequelize.Transaction) {
+  return db.VideoChannel.loadByHostAndUUID(podHost, uuid, t)
+    .then(videoChannel => {
+      if (!videoChannel) throw new Error('Video channel not found')
+
+      return videoChannel
+    })
+    .catch(err => {
+      logger.error('Cannot load video channel from host and uuid.', { error: err.stack, podHost, uuid })
+      throw err
+    })
+}
diff --git a/server/controllers/api/users.ts b/server/controllers/api/users.ts
index 1ecaaf93f..6576e4333 100644
--- a/server/controllers/api/users.ts
+++ b/server/controllers/api/users.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 
 import { database as db } from '../../initializers/database'
 import { USER_ROLES, CONFIG } from '../../initializers'
-import { logger, getFormattedObjects } from '../../helpers'
+import { logger, getFormattedObjects, retryTransactionWrapper } from '../../helpers'
 import {
   authenticate,
   ensureIsAdmin,
@@ -26,6 +26,7 @@ import {
   UserUpdate,
   UserUpdateMe
 } from '../../../shared'
+import { createUserAuthorAndChannel } from '../../lib'
 import { UserInstance } from '../../models'
 
 const usersRouter = express.Router()
@@ -58,7 +59,7 @@ usersRouter.post('/',
   authenticate,
   ensureIsAdmin,
   usersAddValidator,
-  createUser
+  createUserRetryWrapper
 )
 
 usersRouter.post('/register',
@@ -98,9 +99,22 @@ export {
 
 // ---------------------------------------------------------------------------
 
+function createUserRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const options = {
+    arguments: [ req, res ],
+    errorMessage: 'Cannot insert the user with many retries.'
+  }
+
+  retryTransactionWrapper(createUser, options)
+    .then(() => {
+      // TODO : include Location of the new user -> 201
+      res.type('json').status(204).end()
+    })
+    .catch(err => next(err))
+}
+
 function createUser (req: express.Request, res: express.Response, next: express.NextFunction) {
   const body: UserCreate = req.body
-
   const user = db.User.build({
     username: body.username,
     password: body.password,
@@ -110,9 +124,12 @@ function createUser (req: express.Request, res: express.Response, next: express.
     videoQuota: body.videoQuota
   })
 
-  user.save()
-    .then(() => res.type('json').status(204).end())
-    .catch(err => next(err))
+  return createUserAuthorAndChannel(user)
+    .then(() => logger.info('User %s with its channel and author created.', body.username))
+    .catch((err: Error) => {
+      logger.debug('Cannot insert the user.', err)
+      throw err
+    })
 }
 
 function registerUser (req: express.Request, res: express.Response, next: express.NextFunction) {
@@ -127,13 +144,13 @@ function registerUser (req: express.Request, res: express.Response, next: expres
     videoQuota: CONFIG.USER.VIDEO_QUOTA
   })
 
-  user.save()
+  return createUserAuthorAndChannel(user)
     .then(() => res.type('json').status(204).end())
     .catch(err => next(err))
 }
 
 function getUserInformation (req: express.Request, res: express.Response, next: express.NextFunction) {
-  db.User.loadByUsername(res.locals.oauth.token.user.username)
+  db.User.loadByUsernameAndPopulateChannels(res.locals.oauth.token.user.username)
     .then(user => res.json(user.toFormattedJSON()))
     .catch(err => next(err))
 }
diff --git a/server/controllers/api/videos/channel.ts b/server/controllers/api/videos/channel.ts
new file mode 100644
index 000000000..630fc4f53
--- /dev/null
+++ b/server/controllers/api/videos/channel.ts
@@ -0,0 +1,196 @@
+import * as express from 'express'
+
+import { database as db } from '../../../initializers'
+import {
+  logger,
+  getFormattedObjects,
+  retryTransactionWrapper
+} from '../../../helpers'
+import {
+  authenticate,
+  paginationValidator,
+  videoChannelsSortValidator,
+  videoChannelsAddValidator,
+  setVideoChannelsSort,
+  setPagination,
+  videoChannelsRemoveValidator,
+  videoChannelGetValidator,
+  videoChannelsUpdateValidator,
+  listVideoAuthorChannelsValidator
+} from '../../../middlewares'
+import {
+  createVideoChannel,
+  updateVideoChannelToFriends
+} from '../../../lib'
+import { VideoChannelInstance, AuthorInstance } from '../../../models'
+import { VideoChannelCreate, VideoChannelUpdate } from '../../../../shared'
+
+const videoChannelRouter = express.Router()
+
+videoChannelRouter.get('/channels',
+  paginationValidator,
+  videoChannelsSortValidator,
+  setVideoChannelsSort,
+  setPagination,
+  listVideoChannels
+)
+
+videoChannelRouter.get('/authors/:authorId/channels',
+  listVideoAuthorChannelsValidator,
+  listVideoAuthorChannels
+)
+
+videoChannelRouter.post('/channels',
+  authenticate,
+  videoChannelsAddValidator,
+  addVideoChannelRetryWrapper
+)
+
+videoChannelRouter.put('/channels/:id',
+  authenticate,
+  videoChannelsUpdateValidator,
+  updateVideoChannelRetryWrapper
+)
+
+videoChannelRouter.delete('/channels/:id',
+  authenticate,
+  videoChannelsRemoveValidator,
+  removeVideoChannelRetryWrapper
+)
+
+videoChannelRouter.get('/channels/:id',
+  videoChannelGetValidator,
+  getVideoChannel
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoChannelRouter
+}
+
+// ---------------------------------------------------------------------------
+
+function listVideoChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+  db.VideoChannel.listForApi(req.query.start, req.query.count, req.query.sort)
+    .then(result => res.json(getFormattedObjects(result.data, result.total)))
+    .catch(err => next(err))
+}
+
+function listVideoAuthorChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+  db.VideoChannel.listByAuthor(res.locals.author.id)
+    .then(result => res.json(getFormattedObjects(result.data, result.total)))
+    .catch(err => next(err))
+}
+
+// Wrapper to video channel add that retry the function if there is a database error
+// We need this because we run the transaction in SERIALIZABLE isolation that can fail
+function addVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const options = {
+    arguments: [ req, res ],
+    errorMessage: 'Cannot insert the video video channel with many retries.'
+  }
+
+  retryTransactionWrapper(addVideoChannel, options)
+    .then(() => {
+      // TODO : include Location of the new video channel -> 201
+      res.type('json').status(204).end()
+    })
+    .catch(err => next(err))
+}
+
+function addVideoChannel (req: express.Request, res: express.Response) {
+  const videoChannelInfo: VideoChannelCreate = req.body
+  const author: AuthorInstance = res.locals.oauth.token.User.Author
+
+  return db.sequelize.transaction(t => {
+    return createVideoChannel(videoChannelInfo, author, t)
+  })
+  .then(videoChannelUUID => logger.info('Video channel with uuid %s created.', videoChannelUUID))
+  .catch((err: Error) => {
+    logger.debug('Cannot insert the video channel.', err)
+    throw err
+  })
+}
+
+function updateVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const options = {
+    arguments: [ req, res ],
+    errorMessage: 'Cannot update the video with many retries.'
+  }
+
+  retryTransactionWrapper(updateVideoChannel, options)
+    .then(() => res.type('json').status(204).end())
+    .catch(err => next(err))
+}
+
+function updateVideoChannel (req: express.Request, res: express.Response) {
+  const videoChannelInstance: VideoChannelInstance = res.locals.videoChannel
+  const videoChannelFieldsSave = videoChannelInstance.toJSON()
+  const videoChannelInfoToUpdate: VideoChannelUpdate = req.body
+
+  return db.sequelize.transaction(t => {
+    const options = {
+      transaction: t
+    }
+
+    if (videoChannelInfoToUpdate.name !== undefined) videoChannelInstance.set('name', videoChannelInfoToUpdate.name)
+    if (videoChannelInfoToUpdate.description !== undefined) videoChannelInstance.set('description', videoChannelInfoToUpdate.description)
+
+    return videoChannelInstance.save(options)
+      .then(() => {
+        const json = videoChannelInstance.toUpdateRemoteJSON()
+
+        // Now we'll update the video channel's meta data to our friends
+        return updateVideoChannelToFriends(json, t)
+      })
+  })
+    .then(() => {
+      logger.info('Video channel with name %s and uuid %s updated.', videoChannelInstance.name, videoChannelInstance.uuid)
+    })
+    .catch(err => {
+      logger.debug('Cannot update the video channel.', err)
+
+      // Force fields we want to update
+      // If the transaction is retried, sequelize will think the object has not changed
+      // So it will skip the SQL request, even if the last one was ROLLBACKed!
+      Object.keys(videoChannelFieldsSave).forEach(key => {
+        const value = videoChannelFieldsSave[key]
+        videoChannelInstance.set(key, value)
+      })
+
+      throw err
+    })
+}
+
+function removeVideoChannelRetryWrapper (req: express.Request, res: express.Response, next: express.NextFunction) {
+  const options = {
+    arguments: [ req, res ],
+    errorMessage: 'Cannot remove the video channel with many retries.'
+  }
+
+  retryTransactionWrapper(removeVideoChannel, options)
+    .then(() => res.type('json').status(204).end())
+    .catch(err => next(err))
+}
+
+function removeVideoChannel (req: express.Request, res: express.Response) {
+  const videoChannelInstance: VideoChannelInstance = res.locals.videoChannel
+
+  return db.sequelize.transaction(t => {
+    return videoChannelInstance.destroy({ transaction: t })
+  })
+  .then(() => {
+    logger.info('Video channel with name %s and uuid %s deleted.', videoChannelInstance.name, videoChannelInstance.uuid)
+  })
+  .catch(err => {
+    logger.error('Errors when removed the video channel.', err)
+    throw err
+  })
+}
+
+function getVideoChannel (req: express.Request, res: express.Response, next: express.NextFunction) {
+  db.VideoChannel.loadAndPopulateAuthorAndVideos(res.locals.videoChannel.id)
+    .then(videoChannelWithVideos => res.json(videoChannelWithVideos.toFormattedJSON()))
+    .catch(err => next(err))
+}
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 2b7ead954..ec855ee8e 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -46,6 +46,7 @@ import { VideoCreate, VideoUpdate } from '../../../../shared'
 import { abuseVideoRouter } from './abuse'
 import { blacklistRouter } from './blacklist'
 import { rateVideoRouter } from './rate'
+import { videoChannelRouter } from './channel'
 
 const videosRouter = express.Router()
 
@@ -76,6 +77,7 @@ const reqFiles = multer({ storage: storage }).fields([{ name: 'videofile', maxCo
 videosRouter.use('/', abuseVideoRouter)
 videosRouter.use('/', blacklistRouter)
 videosRouter.use('/', rateVideoRouter)
+videosRouter.use('/', videoChannelRouter)
 
 videosRouter.get('/categories', listVideoCategories)
 videosRouter.get('/licences', listVideoLicences)
@@ -161,21 +163,13 @@ function addVideo (req: express.Request, res: express.Response, videoPhysicalFil
   let videoUUID = ''
 
   return db.sequelize.transaction(t => {
-    const user = res.locals.oauth.token.User
+    let p: Promise<TagInstance[]>
 
-    const name = user.username
-    // null because it is OUR pod
-    const podId = null
-    const userId = user.id
+    if (!videoInfo.tags) p = Promise.resolve(undefined)
+    else p = db.Tag.findOrCreateTags(videoInfo.tags, t)
 
-    return db.Author.findOrCreateAuthor(name, podId, userId, t)
-      .then(author => {
-        const tags = videoInfo.tags
-        if (!tags) return { author, tagInstances: undefined }
-
-        return db.Tag.findOrCreateTags(tags, t).then(tagInstances => ({ author, tagInstances }))
-      })
-      .then(({ author, tagInstances }) => {
+    return p
+      .then(tagInstances => {
         const videoData = {
           name: videoInfo.name,
           remote: false,
@@ -186,18 +180,18 @@ function addVideo (req: express.Request, res: express.Response, videoPhysicalFil
           nsfw: videoInfo.nsfw,
           description: videoInfo.description,
           duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
-          authorId: author.id
+          channelId: res.locals.videoChannel.id
         }
 
         const video = db.Video.build(videoData)
-        return { author, tagInstances, video }
+        return { tagInstances, video }
       })
-      .then(({ author, tagInstances, video }) => {
+      .then(({ tagInstances, video }) => {
         const videoFilePath = join(CONFIG.STORAGE.VIDEOS_DIR, videoPhysicalFile.filename)
         return getVideoFileHeight(videoFilePath)
-          .then(height => ({ author, tagInstances, video, videoFileHeight: height }))
+          .then(height => ({ tagInstances, video, videoFileHeight: height }))
       })
-      .then(({ author, tagInstances, video, videoFileHeight }) => {
+      .then(({ tagInstances, video, videoFileHeight }) => {
         const videoFileData = {
           extname: extname(videoPhysicalFile.filename),
           resolution: videoFileHeight,
@@ -205,9 +199,9 @@ function addVideo (req: express.Request, res: express.Response, videoPhysicalFil
         }
 
         const videoFile = db.VideoFile.build(videoFileData)
-        return { author, tagInstances, video, videoFile }
+        return { tagInstances, video, videoFile }
       })
-      .then(({ author, tagInstances, video, videoFile }) => {
+      .then(({ tagInstances, video, videoFile }) => {
         const videoDir = CONFIG.STORAGE.VIDEOS_DIR
         const source = join(videoDir, videoPhysicalFile.filename)
         const destination = join(videoDir, video.getVideoFilename(videoFile))
@@ -216,10 +210,10 @@ function addVideo (req: express.Request, res: express.Response, videoPhysicalFil
           .then(() => {
             // This is important in case if there is another attempt in the retry process
             videoPhysicalFile.filename = video.getVideoFilename(videoFile)
-            return { author, tagInstances, video, videoFile }
+            return { tagInstances, video, videoFile }
           })
       })
-      .then(({ author, tagInstances, video, videoFile }) => {
+      .then(({ tagInstances, video, videoFile }) => {
         const tasks = []
 
         tasks.push(
@@ -239,15 +233,15 @@ function addVideo (req: express.Request, res: express.Response, videoPhysicalFil
           )
         }
 
-        return Promise.all(tasks).then(() => ({ author, tagInstances, video, videoFile }))
+        return Promise.all(tasks).then(() => ({ tagInstances, video, videoFile }))
       })
-      .then(({ author, tagInstances, video, videoFile }) => {
+      .then(({ tagInstances, video, videoFile }) => {
         const options = { transaction: t }
 
         return video.save(options)
           .then(videoCreated => {
-            // Do not forget to add Author information to the created video
-            videoCreated.Author = author
+            // Do not forget to add video channel information to the created video
+            videoCreated.VideoChannel = res.locals.videoChannel
             videoUUID = videoCreated.uuid
 
             return { tagInstances, video: videoCreated, videoFile }
@@ -392,7 +386,7 @@ function getVideo (req: express.Request, res: express.Response) {
   }
 
   // Do not wait the view system
-  res.json(videoInstance.toFormattedJSON())
+  res.json(videoInstance.toFormattedDetailsJSON())
 }
 
 function listVideos (req: express.Request, res: express.Response, next: express.NextFunction) {