40 files changed, 1379 insertions, 417 deletions

diff --git a/server/controllers/activitypub/client.ts b/server/controllers/activitypub/client.ts
index 1a4e28dc8..d36d10de1 100644
--- a/server/controllers/activitypub/client.ts
+++ b/server/controllers/activitypub/client.ts
@@ -2,28 +2,23 @@
 import * as express from 'express'
 import { VideoPrivacy, VideoRateType } from '../../../shared/models/videos'
 import { activityPubCollectionPagination, activityPubContextify } from '../../helpers/activitypub'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../../initializers'
-import { buildAnnounceWithVideoAudience, buildDislikeActivity, buildLikeActivity } from '../../lib/activitypub/send'
+import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../../initializers/constants'
+import { buildAnnounceWithVideoAudience, buildLikeActivity } from '../../lib/activitypub/send'
 import { audiencify, getAudience } from '../../lib/activitypub/audience'
 import { buildCreateActivity } from '../../lib/activitypub/send/send-create'
 import {
   asyncMiddleware,
-  videosShareValidator,
   executeIfActivityPub,
   localAccountValidator,
   localVideoChannelValidator,
-  videosCustomGetValidator
+  videosCustomGetValidator,
+  videosShareValidator
 } from '../../middlewares'
-import {
-  getAccountVideoRateValidator,
-  videoCommentGetValidator,
-  videosGetValidator
-} from '../../middlewares/validators'
+import { getAccountVideoRateValidator, videoCommentGetValidator } from '../../middlewares/validators'
 import { AccountModel } from '../../models/account/account'
 import { ActorModel } from '../../models/activitypub/actor'
 import { ActorFollowModel } from '../../models/activitypub/actor-follow'
 import { VideoModel } from '../../models/video/video'
-import { VideoChannelModel } from '../../models/video/video-channel'
 import { VideoCommentModel } from '../../models/video/video-comment'
 import { VideoShareModel } from '../../models/video/video-share'
 import { cacheRoute } from '../../middlewares/cache'
@@ -37,87 +32,129 @@ import {
   getVideoSharesActivityPubUrl
 } from '../../lib/activitypub'
 import { VideoCaptionModel } from '../../models/video/video-caption'
-import { videoRedundancyGetValidator } from '../../middlewares/validators/redundancy'
+import { videoFileRedundancyGetValidator, videoPlaylistRedundancyGetValidator } from '../../middlewares/validators/redundancy'
 import { getServerActor } from '../../helpers/utils'
-import { VideoRedundancyModel } from '../../models/redundancy/video-redundancy'
+import { buildDislikeActivity } from '../../lib/activitypub/send/send-dislike'
+import { videoPlaylistElementAPGetValidator, videoPlaylistsGetValidator } from '../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
 
 const activityPubClientRouter = express.Router()
 
 activityPubClientRouter.get('/accounts?/:name',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(accountController)
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  accountController
 )
 activityPubClientRouter.get('/accounts?/:name/followers',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(asyncMiddleware(accountFollowersController))
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountFollowersController)
 )
 activityPubClientRouter.get('/accounts?/:name/following',
-  executeIfActivityPub(asyncMiddleware(localAccountValidator)),
-  executeIfActivityPub(asyncMiddleware(accountFollowingController))
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountFollowingController)
+)
+activityPubClientRouter.get('/accounts?/:name/playlists',
+  executeIfActivityPub,
+  asyncMiddleware(localAccountValidator),
+  asyncMiddleware(accountPlaylistsController)
 )
 activityPubClientRouter.get('/accounts?/:name/likes/:videoId',
-  executeIfActivityPub(asyncMiddleware(getAccountVideoRateValidator('like'))),
-  executeIfActivityPub(getAccountVideoRate('like'))
+  executeIfActivityPub,
+  asyncMiddleware(getAccountVideoRateValidator('like')),
+  getAccountVideoRate('like')
 )
 activityPubClientRouter.get('/accounts?/:name/dislikes/:videoId',
-  executeIfActivityPub(asyncMiddleware(getAccountVideoRateValidator('dislike'))),
-  executeIfActivityPub(getAccountVideoRate('dislike'))
+  executeIfActivityPub,
+  asyncMiddleware(getAccountVideoRateValidator('dislike')),
+  getAccountVideoRate('dislike')
 )
 
 activityPubClientRouter.get('/videos/watch/:id',
-  executeIfActivityPub(asyncMiddleware(cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS))),
-  executeIfActivityPub(asyncMiddleware(videosGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoController))
+  executeIfActivityPub,
+  asyncMiddleware(cacheRoute(ROUTE_CACHE_LIFETIME.ACTIVITY_PUB.VIDEOS)),
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
+  asyncMiddleware(videoController)
 )
 activityPubClientRouter.get('/videos/watch/:id/activity',
-  executeIfActivityPub(asyncMiddleware(videosGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
+  asyncMiddleware(videoController)
 )
 activityPubClientRouter.get('/videos/watch/:id/announces',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoAnnouncesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoAnnouncesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/announces/:actorId',
-  executeIfActivityPub(asyncMiddleware(videosShareValidator)),
-  executeIfActivityPub(asyncMiddleware(videoAnnounceController))
+  executeIfActivityPub,
+  asyncMiddleware(videosShareValidator),
+  asyncMiddleware(videoAnnounceController)
 )
 activityPubClientRouter.get('/videos/watch/:id/likes',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoLikesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoLikesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/dislikes',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoDislikesController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoDislikesController)
 )
 activityPubClientRouter.get('/videos/watch/:id/comments',
-  executeIfActivityPub(asyncMiddleware(videosCustomGetValidator('only-video'))),
-  executeIfActivityPub(asyncMiddleware(videoCommentsController))
+  executeIfActivityPub,
+  asyncMiddleware(videosCustomGetValidator('only-video')),
+  asyncMiddleware(videoCommentsController)
 )
 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId',
-  executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoCommentController))
+  executeIfActivityPub,
+  asyncMiddleware(videoCommentGetValidator),
+  asyncMiddleware(videoCommentController)
 )
 activityPubClientRouter.get('/videos/watch/:videoId/comments/:commentId/activity',
-  executeIfActivityPub(asyncMiddleware(videoCommentGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoCommentController))
+  executeIfActivityPub,
+  asyncMiddleware(videoCommentGetValidator),
+  asyncMiddleware(videoCommentController)
 )
 
 activityPubClientRouter.get('/video-channels/:name',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelController)
 )
 activityPubClientRouter.get('/video-channels/:name/followers',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelFollowersController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelFollowersController)
 )
 activityPubClientRouter.get('/video-channels/:name/following',
-  executeIfActivityPub(asyncMiddleware(localVideoChannelValidator)),
-  executeIfActivityPub(asyncMiddleware(videoChannelFollowingController))
+  executeIfActivityPub,
+  asyncMiddleware(localVideoChannelValidator),
+  asyncMiddleware(videoChannelFollowingController)
 )
 
 activityPubClientRouter.get('/redundancy/videos/:videoId/:resolution([0-9]+)(-:fps([0-9]+))?',
-  executeIfActivityPub(asyncMiddleware(videoRedundancyGetValidator)),
-  executeIfActivityPub(asyncMiddleware(videoRedundancyController))
+  executeIfActivityPub,
+  asyncMiddleware(videoFileRedundancyGetValidator),
+  asyncMiddleware(videoRedundancyController)
+)
+activityPubClientRouter.get('/redundancy/streaming-playlists/:streamingPlaylistType/:videoId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistRedundancyGetValidator),
+  asyncMiddleware(videoRedundancyController)
+)
+
+activityPubClientRouter.get('/video-playlists/:playlistId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistsGetValidator),
+  asyncMiddleware(videoPlaylistController)
+)
+activityPubClientRouter.get('/video-playlists/:playlistId/:videoId',
+  executeIfActivityPub,
+  asyncMiddleware(videoPlaylistElementAPGetValidator),
+  asyncMiddleware(videoPlaylistElementController)
 )
 
 // ---------------------------------------------------------------------------
@@ -128,44 +165,52 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function accountController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+function accountController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
 
   return activityPubResponse(activityPubContextify(account.toActivityPubObject()), res)
 }
 
-async function accountFollowersController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function accountFollowersController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const activityPubResult = await actorFollowers(req, account.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
-async function accountFollowingController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function accountFollowingController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const activityPubResult = await actorFollowing(req, account.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
+async function accountPlaylistsController (req: express.Request, res: express.Response) {
+  const account = res.locals.account
+  const activityPubResult = await actorPlaylists(req, account)
+
+  return activityPubResponse(activityPubContextify(activityPubResult), res)
+}
+
 function getAccountVideoRate (rateType: VideoRateType) {
   return (req: express.Request, res: express.Response) => {
-    const accountVideoRate: AccountVideoRateModel = res.locals.accountVideoRate
+    const accountVideoRate = res.locals.accountVideoRate
 
     const byActor = accountVideoRate.Account.Actor
     const url = getRateUrl(rateType, byActor, accountVideoRate.Video)
     const APObject = rateType === 'like'
       ? buildLikeActivity(url, byActor, accountVideoRate.Video)
-      : buildCreateActivity(url, byActor, buildDislikeActivity(url, byActor, accountVideoRate.Video))
+      : buildDislikeActivity(url, byActor, accountVideoRate.Video)
 
     return activityPubResponse(activityPubContextify(APObject), res)
   }
 }
 
 async function videoController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  // We need more attributes
+  const video = await VideoModel.loadForGetAPI(res.locals.video.id)
 
-  if (video.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(video.url)
+  if (video.url.startsWith(WEBSERVER.URL) === false) return res.redirect(video.url)
 
   // We need captions to render AP object
   video.VideoCaptions = await VideoCaptionModel.listVideoCaptions(video.id)
@@ -182,9 +227,9 @@ async function videoController (req: express.Request, res: express.Response) {
 }
 
 async function videoAnnounceController (req: express.Request, res: express.Response) {
-  const share = res.locals.videoShare as VideoShareModel
+  const share = res.locals.videoShare
 
-  if (share.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(share.url)
+  if (share.url.startsWith(WEBSERVER.URL) === false) return res.redirect(share.url)
 
   const { activity } = await buildAnnounceWithVideoAudience(share.Actor, share, res.locals.video, undefined)
 
@@ -192,7 +237,7 @@ async function videoAnnounceController (req: express.Request, res: express.Respo
 }
 
 async function videoAnnouncesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const handler = async (start: number, count: number) => {
     const result = await VideoShareModel.listAndCountByVideoId(video.id, start, count)
@@ -207,21 +252,21 @@ async function videoAnnouncesController (req: express.Request, res: express.Resp
 }
 
 async function videoLikesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
   const json = await videoRates(req, 'like', video, getVideoLikesActivityPubUrl(video))
 
   return activityPubResponse(activityPubContextify(json), res)
 }
 
 async function videoDislikesController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
   const json = await videoRates(req, 'dislike', video, getVideoDislikesActivityPubUrl(video))
 
   return activityPubResponse(activityPubContextify(json), res)
 }
 
 async function videoCommentsController (req: express.Request, res: express.Response) {
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const handler = async (start: number, count: number) => {
     const result = await VideoCommentModel.listAndCountByVideoId(video.id, start, count)
@@ -236,29 +281,29 @@ async function videoCommentsController (req: express.Request, res: express.Respo
 }
 
 async function videoChannelController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
 
   return activityPubResponse(activityPubContextify(videoChannel.toActivityPubObject()), res)
 }
 
 async function videoChannelFollowersController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
   const activityPubResult = await actorFollowers(req, videoChannel.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
 async function videoChannelFollowingController (req: express.Request, res: express.Response) {
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const videoChannel = res.locals.videoChannel
   const activityPubResult = await actorFollowing(req, videoChannel.Actor)
 
   return activityPubResponse(activityPubContextify(activityPubResult), res)
 }
 
 async function videoCommentController (req: express.Request, res: express.Response) {
-  const videoComment: VideoCommentModel = res.locals.videoComment
+  const videoComment = res.locals.videoComment
 
-  if (videoComment.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(videoComment.url)
+  if (videoComment.url.startsWith(WEBSERVER.URL) === false) return res.redirect(videoComment.url)
 
   const threadParentComments = await VideoCommentModel.listThreadParentComments(videoComment, undefined)
   const isPublic = true // Comments are always public
@@ -275,8 +320,8 @@ async function videoCommentController (req: express.Request, res: express.Respon
 }
 
 async function videoRedundancyController (req: express.Request, res: express.Response) {
-  const videoRedundancy: VideoRedundancyModel = res.locals.videoRedundancy
-  if (videoRedundancy.url.startsWith(CONFIG.WEBSERVER.URL) === false) return res.redirect(videoRedundancy.url)
+  const videoRedundancy = res.locals.videoRedundancy
+  if (videoRedundancy.url.startsWith(WEBSERVER.URL) === false) return res.redirect(videoRedundancy.url)
 
   const serverActor = await getServerActor()
 
@@ -291,6 +336,26 @@ async function videoRedundancyController (req: express.Request, res: express.Res
   return activityPubResponse(activityPubContextify(object), res)
 }
 
+async function videoPlaylistController (req: express.Request, res: express.Response) {
+  const playlist = res.locals.videoPlaylist
+
+  // We need more attributes
+  playlist.OwnerAccount = await AccountModel.load(playlist.ownerAccountId)
+
+  const json = await playlist.toActivityPubObject(req.query.page, null)
+  const audience = getAudience(playlist.OwnerAccount.Actor, playlist.privacy === VideoPlaylistPrivacy.PUBLIC)
+  const object = audiencify(json, audience)
+
+  return activityPubResponse(activityPubContextify(object), res)
+}
+
+async function videoPlaylistElementController (req: express.Request, res: express.Response) {
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+
+  const json = videoPlaylistElement.toActivityPubObject()
+  return activityPubResponse(activityPubContextify(json), res)
+}
+
 // ---------------------------------------------------------------------------
 
 async function actorFollowing (req: express.Request, actor: ActorModel) {
@@ -298,15 +363,23 @@ async function actorFollowing (req: express.Request, actor: ActorModel) {
     return ActorFollowModel.listAcceptedFollowingUrlsForApi([ actor.id ], undefined, start, count)
   }
 
-  return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.path, handler, req.query.page)
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
 }
 
 async function actorFollowers (req: express.Request, actor: ActorModel) {
   const handler = (start: number, count: number) => {
-    return ActorFollowModel.listAcceptedFollowerUrlsForApi([ actor.id ], undefined, start, count)
+    return ActorFollowModel.listAcceptedFollowerUrlsForAP([ actor.id ], undefined, start, count)
+  }
+
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
+}
+
+async function actorPlaylists (req: express.Request, account: AccountModel) {
+  const handler = (start: number, count: number) => {
+    return VideoPlaylistModel.listPublicUrlsOfForAP(account.id, start, count)
   }
 
-  return activityPubCollectionPagination(CONFIG.WEBSERVER.URL + req.path, handler, req.query.page)
+  return activityPubCollectionPagination(WEBSERVER.URL + req.path, handler, req.query.page)
 }
 
 function videoRates (req: express.Request, rateType: VideoRateType, video: VideoModel, url: string) {
diff --git a/server/controllers/activitypub/inbox.ts b/server/controllers/activitypub/inbox.ts
index f0e65015b..38d5c51df 100644
--- a/server/controllers/activitypub/inbox.ts
+++ b/server/controllers/activitypub/inbox.ts
@@ -5,8 +5,6 @@ import { logger } from '../../helpers/logger'
 import { processActivities } from '../../lib/activitypub/process/process'
 import { asyncMiddleware, checkSignature, localAccountValidator, localVideoChannelValidator, signatureValidator } from '../../middlewares'
 import { activityPubValidator } from '../../middlewares/validators/activitypub/activity'
-import { VideoChannelModel } from '../../models/video/video-channel'
-import { AccountModel } from '../../models/account/account'
 import { queue } from 'async'
 import { ActorModel } from '../../models/activitypub/actor'
 
@@ -66,12 +64,7 @@ function inboxController (req: express.Request, res: express.Response) {
   activities = activities.filter(a => isActivityValid(a))
   logger.debug('We keep %d activities.', activities.length, { activities })
 
-  let accountOrChannel: VideoChannelModel | AccountModel
-  if (res.locals.account) {
-    accountOrChannel = res.locals.account
-  } else if (res.locals.videoChannel) {
-    accountOrChannel = res.locals.videoChannel
-  }
+  const accountOrChannel = res.locals.account || res.locals.videoChannel
 
   logger.info('Receiving inbox requests for %d activities by %s.', activities.length, res.locals.signature.actor.url)
 
diff --git a/server/controllers/activitypub/outbox.ts b/server/controllers/activitypub/outbox.ts
index bd0e4fe9d..38b6ec976 100644
--- a/server/controllers/activitypub/outbox.ts
+++ b/server/controllers/activitypub/outbox.ts
@@ -32,8 +32,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function outboxController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const accountOrVideoChannel: AccountModel | VideoChannelModel = res.locals.account || res.locals.videoChannel
+async function outboxController (req: express.Request, res: express.Response) {
+  const accountOrVideoChannel = res.locals.account || res.locals.videoChannel
   const actor = accountOrVideoChannel.Actor
   const actorOutboxUrl = actor.url + '/outbox'
 
diff --git a/server/controllers/api/accounts.ts b/server/controllers/api/accounts.ts
index 8c0237203..8d4db1e75 100644
--- a/server/controllers/api/accounts.ts
+++ b/server/controllers/api/accounts.ts
@@ -1,21 +1,32 @@
 import * as express from 'express'
-import { getFormattedObjects } from '../../helpers/utils'
+import { getFormattedObjects, getServerActor } from '../../helpers/utils'
 import {
   asyncMiddleware,
+  authenticate,
   commonVideosFiltersValidator,
-  listVideoAccountChannelsValidator,
   optionalAuthenticate,
   paginationValidator,
   setDefaultPagination,
-  setDefaultSort
+  setDefaultSort,
+  videoPlaylistsSortValidator,
+  videoRatesSortValidator,
+  videoRatingValidator
 } from '../../middlewares'
-import { accountsNameWithHostGetValidator, accountsSortValidator, videosSortValidator } from '../../middlewares/validators'
+import {
+  accountNameWithHostGetValidator,
+  accountsSortValidator,
+  ensureAuthUserOwnsAccountValidator,
+  videosSortValidator
+} from '../../middlewares/validators'
 import { AccountModel } from '../../models/account/account'
+import { AccountVideoRateModel } from '../../models/account/account-video-rate'
 import { VideoModel } from '../../models/video/video'
 import { buildNSFWFilter, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { JobQueue } from '../../lib/job-queue'
 import { logger } from '../../helpers/logger'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { commonVideoPlaylistFiltersValidator } from '../../middlewares/validators/videos/video-playlists'
 
 const accountsRouter = express.Router()
 
@@ -28,12 +39,12 @@ accountsRouter.get('/',
 )
 
 accountsRouter.get('/:accountName',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   getAccount
 )
 
 accountsRouter.get('/:accountName/videos',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   paginationValidator,
   videosSortValidator,
   setDefaultSort,
@@ -44,8 +55,31 @@ accountsRouter.get('/:accountName/videos',
 )
 
 accountsRouter.get('/:accountName/video-channels',
-  asyncMiddleware(listVideoAccountChannelsValidator),
-  asyncMiddleware(listVideoAccountChannels)
+  asyncMiddleware(accountNameWithHostGetValidator),
+  asyncMiddleware(listAccountChannels)
+)
+
+accountsRouter.get('/:accountName/video-playlists',
+  optionalAuthenticate,
+  asyncMiddleware(accountNameWithHostGetValidator),
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listAccountPlaylists)
+)
+
+accountsRouter.get('/:accountName/ratings',
+  authenticate,
+  asyncMiddleware(accountNameWithHostGetValidator),
+  ensureAuthUserOwnsAccountValidator,
+  paginationValidator,
+  videoRatesSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  videoRatingValidator,
+  asyncMiddleware(listAccountRatings)
 )
 
 // ---------------------------------------------------------------------------
@@ -56,8 +90,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function getAccount (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+function getAccount (req: express.Request, res: express.Response) {
+  const account = res.locals.account
 
   if (account.isOutdated()) {
     JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'actor', url: account.Actor.url } })
@@ -67,20 +101,42 @@ function getAccount (req: express.Request, res: express.Response, next: express.
   return res.json(account.toFormattedJSON())
 }
 
-async function listAccounts (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listAccounts (req: express.Request, res: express.Response) {
   const resultList = await AccountModel.listForApi(req.query.start, req.query.count, req.query.sort)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listVideoAccountChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listAccountChannels (req: express.Request, res: express.Response) {
   const resultList = await VideoChannelModel.listByAccount(res.locals.account.id)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listAccountVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const account: AccountModel = res.locals.account
+async function listAccountPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+
+  // Allow users to see their private/unlisted video playlists
+  let privateAndUnlisted = false
+  if (res.locals.oauth && res.locals.oauth.token.User.Account.id === res.locals.account.id) {
+    privateAndUnlisted = true
+  }
+
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    accountId: res.locals.account.id,
+    privateAndUnlisted,
+    type: req.query.playlistType
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function listAccountVideos (req: express.Request, res: express.Response) {
+  const account = res.locals.account
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
 
   const resultList = await VideoModel.listForApi({
@@ -103,3 +159,16 @@ async function listAccountVideos (req: express.Request, res: express.Response, n
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
+
+async function listAccountRatings (req: express.Request, res: express.Response) {
+  const account = res.locals.account
+
+  const resultList = await AccountVideoRateModel.listByAccountForApi({
+    accountId: account.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    type: req.query.rating
+  })
+  return res.json(getFormattedObjects(resultList.rows, resultList.count))
+}
diff --git a/server/controllers/api/config.ts b/server/controllers/api/config.ts
index 255026f46..40012c03b 100644
--- a/server/controllers/api/config.ts
+++ b/server/controllers/api/config.ts
@@ -1,10 +1,10 @@
 import * as express from 'express'
-import { omit, snakeCase } from 'lodash'
+import { snakeCase } from 'lodash'
 import { ServerConfig, UserRight } from '../../../shared'
 import { About } from '../../../shared/models/server/about.model'
 import { CustomConfig } from '../../../shared/models/server/custom-config.model'
 import { isSignupAllowed, isSignupAllowedForCurrentIP } from '../../helpers/signup'
-import { CONFIG, CONSTRAINTS_FIELDS, reloadConfig } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../middlewares'
 import { customConfigUpdateValidator } from '../../middlewares/validators/config'
 import { ClientHtml } from '../../lib/client-html'
@@ -14,6 +14,7 @@ import { getServerCommit } from '../../helpers/utils'
 import { Emailer } from '../../lib/emailer'
 import { isNumeric } from 'validator'
 import { objectConverter } from '../../helpers/core-utils'
+import { CONFIG, reloadConfig } from '../../initializers/config'
 
 const packageJSON = require('../../../../package.json')
 const configRouter = express.Router()
@@ -58,6 +59,7 @@ async function getConfig (req: express.Request, res: express.Response) {
       name: CONFIG.INSTANCE.NAME,
       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
+      isNSFW: CONFIG.INSTANCE.IS_NSFW,
       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
       customizations: {
         javascript: CONFIG.INSTANCE.CUSTOMIZATIONS.JAVASCRIPT,
@@ -78,6 +80,9 @@ async function getConfig (req: express.Request, res: express.Response) {
       requiresEmailVerification: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION
     },
     transcoding: {
+      hls: {
+        enabled: CONFIG.TRANSCODING.HLS.ENABLED
+      },
       enabledResolutions
     },
     import: {
@@ -90,6 +95,13 @@ async function getConfig (req: express.Request, res: express.Response) {
         }
       }
     },
+    autoBlacklist: {
+      videos: {
+        ofUsers: {
+          enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
+        }
+      }
+    },
     avatar: {
       file: {
         size: {
@@ -125,13 +137,16 @@ async function getConfig (req: express.Request, res: express.Response) {
       videos: {
         intervalDays: CONFIG.TRENDING.VIDEOS.INTERVAL_DAYS
       }
+    },
+    tracker: {
+      enabled: CONFIG.TRACKER.ENABLED
     }
   }
 
   return res.json(json)
 }
 
-function getAbout (req: express.Request, res: express.Response, next: express.NextFunction) {
+function getAbout (req: express.Request, res: express.Response) {
   const about: About = {
     instance: {
       name: CONFIG.INSTANCE.NAME,
@@ -144,13 +159,13 @@ function getAbout (req: express.Request, res: express.Response, next: express.Ne
   return res.json(about).end()
 }
 
-async function getCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getCustomConfig (req: express.Request, res: express.Response) {
   const data = customConfig()
 
   return res.json(data).end()
 }
 
-async function deleteCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function deleteCustomConfig (req: express.Request, res: express.Response) {
   await remove(CONFIG.CUSTOM_FILE)
 
   auditLogger.delete(getAuditIdFromRes(res), new CustomConfigAuditView(customConfig()))
@@ -163,7 +178,7 @@ async function deleteCustomConfig (req: express.Request, res: express.Response,
   return res.json(data).end()
 }
 
-async function updateCustomConfig (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateCustomConfig (req: express.Request, res: express.Response) {
   const oldCustomConfigAuditKeys = new CustomConfigAuditView(customConfig())
 
   // camelCase to snake_case key + Force number conversion
@@ -200,6 +215,7 @@ function customConfig (): CustomConfig {
       shortDescription: CONFIG.INSTANCE.SHORT_DESCRIPTION,
       description: CONFIG.INSTANCE.DESCRIPTION,
       terms: CONFIG.INSTANCE.TERMS,
+      isNSFW: CONFIG.INSTANCE.IS_NSFW,
       defaultClientRoute: CONFIG.INSTANCE.DEFAULT_CLIENT_ROUTE,
       defaultNSFWPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
       customizations: {
@@ -246,6 +262,9 @@ function customConfig (): CustomConfig {
         '480p': CONFIG.TRANSCODING.RESOLUTIONS[ '480p' ],
         '720p': CONFIG.TRANSCODING.RESOLUTIONS[ '720p' ],
         '1080p': CONFIG.TRANSCODING.RESOLUTIONS[ '1080p' ]
+      },
+      hls: {
+        enabled: CONFIG.TRANSCODING.HLS.ENABLED
       }
     },
     import: {
@@ -257,6 +276,19 @@ function customConfig (): CustomConfig {
           enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
         }
       }
+    },
+    autoBlacklist: {
+      videos: {
+        ofUsers: {
+          enabled: CONFIG.AUTO_BLACKLIST.VIDEOS.OF_USERS.ENABLED
+        }
+      }
+    },
+    followers: {
+      instance: {
+        enabled: CONFIG.FOLLOWERS.INSTANCE.ENABLED,
+        manualApproval: CONFIG.FOLLOWERS.INSTANCE.MANUAL_APPROVAL
+      }
     }
   }
 }
diff --git a/server/controllers/api/index.ts b/server/controllers/api/index.ts
index 8a58b5466..60a84036e 100644
--- a/server/controllers/api/index.ts
+++ b/server/controllers/api/index.ts
@@ -11,6 +11,7 @@ import { videoChannelRouter } from './video-channel'
 import * as cors from 'cors'
 import { searchRouter } from './search'
 import { overviewsRouter } from './overviews'
+import { videoPlaylistRouter } from './video-playlist'
 
 const apiRouter = express.Router()
 
@@ -26,6 +27,7 @@ apiRouter.use('/config', configRouter)
 apiRouter.use('/users', usersRouter)
 apiRouter.use('/accounts', accountsRouter)
 apiRouter.use('/video-channels', videoChannelRouter)
+apiRouter.use('/video-playlists', videoPlaylistRouter)
 apiRouter.use('/videos', videosRouter)
 apiRouter.use('/jobs', jobsRouter)
 apiRouter.use('/search', searchRouter)
@@ -39,6 +41,6 @@ export { apiRouter }
 
 // ---------------------------------------------------------------------------
 
-function pong (req: express.Request, res: express.Response, next: express.NextFunction) {
+function pong (req: express.Request, res: express.Response) {
   return res.send('pong').status(200).end()
 }
diff --git a/server/controllers/api/oauth-clients.ts b/server/controllers/api/oauth-clients.ts
index 3dcc023e6..b2de8bcf5 100644
--- a/server/controllers/api/oauth-clients.ts
+++ b/server/controllers/api/oauth-clients.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { OAuthClientLocal } from '../../../shared'
 import { logger } from '../../helpers/logger'
-import { CONFIG } from '../../initializers'
+import { CONFIG } from '../../initializers/config'
 import { asyncMiddleware } from '../../middlewares'
 import { OAuthClientModel } from '../../models/oauth/oauth-client'
 
diff --git a/server/controllers/api/overviews.ts b/server/controllers/api/overviews.ts
index 8b6773056..37ac152db 100644
--- a/server/controllers/api/overviews.ts
+++ b/server/controllers/api/overviews.ts
@@ -4,7 +4,7 @@ import { VideoModel } from '../../models/video/video'
 import { asyncMiddleware } from '../../middlewares'
 import { TagModel } from '../../models/video/tag'
 import { VideosOverview } from '../../../shared/models/overviews'
-import { MEMOIZE_TTL, OVERVIEWS, ROUTE_CACHE_LIFETIME } from '../../initializers'
+import { MEMOIZE_TTL, OVERVIEWS, ROUTE_CACHE_LIFETIME } from '../../initializers/constants'
 import { cacheRoute } from '../../middlewares/cache'
 import * as memoizee from 'memoizee'
 
@@ -94,7 +94,7 @@ async function getVideos (
 ) {
   const query = Object.assign({
     start: 0,
-    count: 10,
+    count: 12,
     sort: '-createdAt',
     includeLocalVideos: true,
     nsfw: buildNSFWFilter(res),
diff --git a/server/controllers/api/server/debug.ts b/server/controllers/api/server/debug.ts
new file mode 100644
index 000000000..4450038f6
--- /dev/null
+++ b/server/controllers/api/server/debug.ts
@@ -0,0 +1,25 @@
+import * as express from 'express'
+import { UserRight } from '../../../../shared/models/users'
+import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
+
+const debugRouter = express.Router()
+
+debugRouter.get('/debug',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_DEBUG),
+  asyncMiddleware(getDebug)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  debugRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function getDebug (req: express.Request, res: express.Response) {
+  return res.json({
+    ip: req.ip
+  }).end()
+}
diff --git a/server/controllers/api/server/follows.ts b/server/controllers/api/server/follows.ts
index 9fa6c34ba..d38ce91de 100644
--- a/server/controllers/api/server/follows.ts
+++ b/server/controllers/api/server/follows.ts
@@ -2,22 +2,29 @@ import * as express from 'express'
 import { UserRight } from '../../../../shared/models/users'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
-import { sequelizeTypescript, SERVER_ACTOR_NAME } from '../../../initializers'
-import { sendUndoFollow } from '../../../lib/activitypub/send'
+import { SERVER_ACTOR_NAME } from '../../../initializers/constants'
+import { sendAccept, sendReject, sendUndoFollow } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
   authenticate,
   ensureUserHasRight,
   paginationValidator,
-  removeFollowingValidator,
   setBodyHostsPort,
   setDefaultPagination,
   setDefaultSort
 } from '../../../middlewares'
-import { followersSortValidator, followingSortValidator, followValidator } from '../../../middlewares/validators'
+import {
+  acceptOrRejectFollowerValidator,
+  followersSortValidator,
+  followingSortValidator,
+  followValidator,
+  getFollowerValidator,
+  removeFollowingValidator
+} from '../../../middlewares/validators'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { JobQueue } from '../../../lib/job-queue'
 import { removeRedundancyOf } from '../../../lib/redundancy'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const serverFollowsRouter = express.Router()
 serverFollowsRouter.get('/following',
@@ -40,7 +47,7 @@ serverFollowsRouter.delete('/following/:host',
   authenticate,
   ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
   asyncMiddleware(removeFollowingValidator),
-  asyncMiddleware(removeFollow)
+  asyncMiddleware(removeFollowing)
 )
 
 serverFollowsRouter.get('/followers',
@@ -51,6 +58,29 @@ serverFollowsRouter.get('/followers',
   asyncMiddleware(listFollowers)
 )
 
+serverFollowsRouter.delete('/followers/:nameWithHost',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/reject',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  acceptOrRejectFollowerValidator,
+  asyncMiddleware(removeOrRejectFollower)
+)
+
+serverFollowsRouter.post('/followers/:nameWithHost/accept',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_SERVER_FOLLOW),
+  asyncMiddleware(getFollowerValidator),
+  acceptOrRejectFollowerValidator,
+  asyncMiddleware(acceptFollower)
+)
+
 // ---------------------------------------------------------------------------
 
 export {
@@ -59,7 +89,7 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowing (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await ActorFollowModel.listFollowingForApi(
     serverActor.id,
@@ -72,7 +102,7 @@ async function listFollowing (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listFollowers (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await ActorFollowModel.listFollowersForApi(
     serverActor.id,
@@ -85,7 +115,7 @@ async function listFollowers (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function followInstance (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function followInstance (req: express.Request, res: express.Response) {
   const hosts = req.body.hosts as string[]
   const follower = await getServerActor()
 
@@ -103,8 +133,8 @@ async function followInstance (req: express.Request, res: express.Response, next
   return res.status(204).end()
 }
 
-async function removeFollow (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const follow: ActorFollowModel = res.locals.follow
+async function removeFollowing (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
 
   await sequelizeTypescript.transaction(async t => {
     if (follow.state === 'accepted') await sendUndoFollow(follow, t)
@@ -123,3 +153,24 @@ async function removeFollow (req: express.Request, res: express.Response, next:
 
   return res.status(204).end()
 }
+
+async function removeOrRejectFollower (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
+
+  await sendReject(follow.ActorFollower, follow.ActorFollowing)
+
+  await follow.destroy()
+
+  return res.status(204).end()
+}
+
+async function acceptFollower (req: express.Request, res: express.Response) {
+  const follow = res.locals.follow
+
+  await sendAccept(follow)
+
+  follow.state = 'accepted'
+  await follow.save()
+
+  return res.status(204).end()
+}
diff --git a/server/controllers/api/server/index.ts b/server/controllers/api/server/index.ts
index 814248e5f..6b8793a19 100644
--- a/server/controllers/api/server/index.ts
+++ b/server/controllers/api/server/index.ts
@@ -4,6 +4,8 @@ import { statsRouter } from './stats'
 import { serverRedundancyRouter } from './redundancy'
 import { serverBlocklistRouter } from './server-blocklist'
 import { contactRouter } from './contact'
+import { logsRouter } from './logs'
+import { debugRouter } from './debug'
 
 const serverRouter = express.Router()
 
@@ -12,6 +14,8 @@ serverRouter.use('/', serverRedundancyRouter)
 serverRouter.use('/', statsRouter)
 serverRouter.use('/', serverBlocklistRouter)
 serverRouter.use('/', contactRouter)
+serverRouter.use('/', logsRouter)
+serverRouter.use('/', debugRouter)
 
 // ---------------------------------------------------------------------------
 
diff --git a/server/controllers/api/server/logs.ts b/server/controllers/api/server/logs.ts
new file mode 100644
index 000000000..e9d1f2efd
--- /dev/null
+++ b/server/controllers/api/server/logs.ts
@@ -0,0 +1,95 @@
+import * as express from 'express'
+import { UserRight } from '../../../../shared/models/users'
+import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
+import { mtimeSortFilesDesc } from '../../../../shared/core-utils/logs/logs'
+import { readdir, readFile } from 'fs-extra'
+import { MAX_LOGS_OUTPUT_CHARACTERS } from '../../../initializers/constants'
+import { join } from 'path'
+import { getLogsValidator } from '../../../middlewares/validators/logs'
+import { LogLevel } from '../../../../shared/models/server/log-level.type'
+import { CONFIG } from '../../../initializers/config'
+
+const logsRouter = express.Router()
+
+logsRouter.get('/logs',
+  authenticate,
+  ensureUserHasRight(UserRight.MANAGE_LOGS),
+  getLogsValidator,
+  asyncMiddleware(getLogs)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  logsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function getLogs (req: express.Request, res: express.Response) {
+  const logFiles = await readdir(CONFIG.STORAGE.LOG_DIR)
+  const sortedLogFiles = await mtimeSortFilesDesc(logFiles, CONFIG.STORAGE.LOG_DIR)
+  let currentSize = 0
+
+  const startDate = new Date(req.query.startDate)
+  const endDate = req.query.endDate ? new Date(req.query.endDate) : new Date()
+  const level: LogLevel = req.query.level || 'info'
+
+  let output: string[] = []
+
+  for (const meta of sortedLogFiles) {
+    const path = join(CONFIG.STORAGE.LOG_DIR, meta.file)
+
+    const result = await getOutputFromFile(path, startDate, endDate, level, currentSize)
+    if (!result.output) break
+
+    output = result.output.concat(output)
+    currentSize = result.currentSize
+
+    if (currentSize > MAX_LOGS_OUTPUT_CHARACTERS || (result.logTime && result.logTime < startDate.getTime())) break
+  }
+
+  return res.json(output).end()
+}
+
+async function getOutputFromFile (path: string, startDate: Date, endDate: Date, level: LogLevel, currentSize: number) {
+  const startTime = startDate.getTime()
+  const endTime = endDate.getTime()
+  let logTime: number
+
+  const logsLevel: { [ id in LogLevel ]: number } = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  }
+
+  const content = await readFile(path)
+  const lines = content.toString().split('\n')
+  const output: any[] = []
+
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[ i ]
+    let log: any
+
+    try {
+      log = JSON.parse(line)
+    } catch {
+      // Maybe there a multiple \n at the end of the file
+      continue
+    }
+
+    logTime = new Date(log.timestamp).getTime()
+    if (logTime >= startTime && logTime <= endTime && logsLevel[ log.level ] >= logsLevel[ level ]) {
+      output.push(log)
+
+      currentSize += line.length
+
+      if (currentSize > MAX_LOGS_OUTPUT_CHARACTERS) break
+    } else if (logTime < startTime) {
+      break
+    }
+  }
+
+  return { currentSize, output: output.reverse(), logTime }
+}
diff --git a/server/controllers/api/server/redundancy.ts b/server/controllers/api/server/redundancy.ts
index 4140c4991..f8109070d 100644
--- a/server/controllers/api/server/redundancy.ts
+++ b/server/controllers/api/server/redundancy.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import { UserRight } from '../../../../shared/models/users'
 import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../../middlewares'
 import { updateServerRedundancyValidator } from '../../../middlewares/validators/redundancy'
-import { ServerModel } from '../../../models/server/server'
 import { removeRedundancyOf } from '../../../lib/redundancy'
 import { logger } from '../../../helpers/logger'
 
@@ -23,8 +22,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function updateRedundancy (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const server = res.locals.server as ServerModel
+async function updateRedundancy (req: express.Request, res: express.Response) {
+  const server = res.locals.server
 
   server.redundancyAllowed = req.body.redundancyAllowed
 
diff --git a/server/controllers/api/server/server-blocklist.ts b/server/controllers/api/server/server-blocklist.ts
index 3cb3a96e2..d165db191 100644
--- a/server/controllers/api/server/server-blocklist.ts
+++ b/server/controllers/api/server/server-blocklist.ts
@@ -18,11 +18,9 @@ import {
   unblockAccountByServerValidator,
   unblockServerByServerValidator
 } from '../../../middlewares/validators'
-import { AccountModel } from '../../../models/account/account'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { ServerModel } from '../../../models/server/server'
 import { UserRight } from '../../../../shared/models/users'
 
 const serverBlocklistRouter = express.Router()
@@ -91,7 +89,7 @@ async function listBlockedAccounts (req: express.Request, res: express.Response)
 
 async function blockAccount (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
-  const accountToBlock: AccountModel = res.locals.account
+  const accountToBlock = res.locals.account
 
   await addAccountInBlocklist(serverActor.Account.id, accountToBlock.id)
 
@@ -99,7 +97,7 @@ async function blockAccount (req: express.Request, res: express.Response) {
 }
 
 async function unblockAccount (req: express.Request, res: express.Response) {
-  const accountBlock: AccountBlocklistModel = res.locals.accountBlock
+  const accountBlock = res.locals.accountBlock
 
   await removeAccountFromBlocklist(accountBlock)
 
@@ -116,7 +114,7 @@ async function listBlockedServers (req: express.Request, res: express.Response)
 
 async function blockServer (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
-  const serverToBlock: ServerModel = res.locals.server
+  const serverToBlock = res.locals.server
 
   await addServerInBlocklist(serverActor.Account.id, serverToBlock.id)
 
@@ -124,7 +122,7 @@ async function blockServer (req: express.Request, res: express.Response) {
 }
 
 async function unblockServer (req: express.Request, res: express.Response) {
-  const serverBlock: ServerBlocklistModel = res.locals.serverBlock
+  const serverBlock = res.locals.serverBlock
 
   await removeServerFromBlocklist(serverBlock)
 
diff --git a/server/controllers/api/server/stats.ts b/server/controllers/api/server/stats.ts
index 89ffd1717..951b98209 100644
--- a/server/controllers/api/server/stats.ts
+++ b/server/controllers/api/server/stats.ts
@@ -6,9 +6,10 @@ import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { VideoRedundancyModel } from '../../../models/redundancy/video-redundancy'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../../../initializers/constants'
+import { ROUTE_CACHE_LIFETIME } from '../../../initializers/constants'
 import { cacheRoute } from '../../../middlewares/cache'
 import { VideoFileModel } from '../../../models/video/video-file'
+import { CONFIG } from '../../../initializers/config'
 
 const statsRouter = express.Router()
 
diff --git a/server/controllers/api/users/index.ts b/server/controllers/api/users/index.ts
index dbe0718d4..0aafba66e 100644
--- a/server/controllers/api/users/index.ts
+++ b/server/controllers/api/users/index.ts
@@ -3,10 +3,10 @@ import * as RateLimit from 'express-rate-limit'
 import { UserCreate, UserRight, UserRole, UserUpdate } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, RATES_LIMIT, sequelizeTypescript } from '../../../initializers'
+import { RATES_LIMIT, WEBSERVER } from '../../../initializers/constants'
 import { Emailer } from '../../../lib/emailer'
 import { Redis } from '../../../lib/redis'
-import { createUserAccountAndChannel } from '../../../lib/user'
+import { createUserAccountAndChannelAndPlaylist } from '../../../lib/user'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -38,23 +38,25 @@ import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../h
 import { meRouter } from './me'
 import { deleteUserToken } from '../../../lib/oauth-model'
 import { myBlocklistRouter } from './my-blocklist'
+import { myVideoPlaylistsRouter } from './my-video-playlists'
 import { myVideosHistoryRouter } from './my-history'
 import { myNotificationsRouter } from './my-notifications'
 import { Notifier } from '../../../lib/notifier'
 import { mySubscriptionsRouter } from './my-subscriptions'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { UserAdminFlag } from '../../../../shared/models/users/user-flag.model'
 
 const auditLogger = auditLoggerFactory('users')
 
 const loginRateLimiter = new RateLimit({
   windowMs: RATES_LIMIT.LOGIN.WINDOW_MS,
-  max: RATES_LIMIT.LOGIN.MAX,
-  delayMs: 0
+  max: RATES_LIMIT.LOGIN.MAX
 })
 
 const askSendEmailLimiter = new RateLimit({
   windowMs: RATES_LIMIT.ASK_SEND_EMAIL.WINDOW_MS,
-  max: RATES_LIMIT.ASK_SEND_EMAIL.MAX,
-  delayMs: 0
+  max: RATES_LIMIT.ASK_SEND_EMAIL.MAX
 })
 
 const usersRouter = express.Router()
@@ -62,6 +64,7 @@ usersRouter.use('/', myNotificationsRouter)
 usersRouter.use('/', mySubscriptionsRouter)
 usersRouter.use('/', myBlocklistRouter)
 usersRouter.use('/', myVideosHistoryRouter)
+usersRouter.use('/', myVideoPlaylistsRouter)
 usersRouter.use('/', meRouter)
 
 usersRouter.get('/autocomplete',
@@ -173,10 +176,11 @@ async function createUser (req: express.Request, res: express.Response) {
     autoPlayVideo: true,
     role: body.role,
     videoQuota: body.videoQuota,
-    videoQuotaDaily: body.videoQuotaDaily
+    videoQuotaDaily: body.videoQuotaDaily,
+    adminFlags: body.adminFlags || UserAdminFlag.NONE
   })
 
-  const { user, account } = await createUserAccountAndChannel(userToCreate)
+  const { user, account } = await createUserAccountAndChannelAndPlaylist(userToCreate)
 
   auditLogger.create(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()))
   logger.info('User %s with its channel and account created.', body.username)
@@ -207,7 +211,7 @@ async function registerUser (req: express.Request, res: express.Response) {
     emailVerified: CONFIG.SIGNUP.REQUIRES_EMAIL_VERIFICATION ? false : null
   })
 
-  const { user } = await createUserAccountAndChannel(userToCreate)
+  const { user } = await createUserAccountAndChannelAndPlaylist(userToCreate)
 
   auditLogger.create(body.username, new UserAuditView(user.toFormattedJSON()))
   logger.info('User %s with its channel and account registered.', body.username)
@@ -221,16 +225,16 @@ async function registerUser (req: express.Request, res: express.Response) {
   return res.type('json').status(204).end()
 }
 
-async function unblockUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function unblockUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await changeUserBlock(res, user, false)
 
   return res.status(204).end()
 }
 
-async function blockUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function blockUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   const reason = req.body.reason
 
   await changeUserBlock(res, user, true, reason)
@@ -238,24 +242,24 @@ async function blockUser (req: express.Request, res: express.Response, next: exp
   return res.status(204).end()
 }
 
-function getUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  return res.json((res.locals.user as UserModel).toFormattedJSON())
+function getUser (req: express.Request, res: express.Response) {
+  return res.json(res.locals.user.toFormattedJSON({ withAdminFlags: true }))
 }
 
-async function autocompleteUsers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function autocompleteUsers (req: express.Request, res: express.Response) {
   const resultList = await UserModel.autoComplete(req.query.search as string)
 
   return res.json(resultList)
 }
 
-async function listUsers (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listUsers (req: express.Request, res: express.Response) {
   const resultList = await UserModel.listForApi(req.query.start, req.query.count, req.query.sort, req.query.search)
 
-  return res.json(getFormattedObjects(resultList.data, resultList.total))
+  return res.json(getFormattedObjects(resultList.data, resultList.total, { withAdminFlags: true }))
 }
 
-async function removeUser (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user: UserModel = res.locals.user
+async function removeUser (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await user.destroy()
 
@@ -264,42 +268,44 @@ async function removeUser (req: express.Request, res: express.Response, next: ex
   return res.sendStatus(204)
 }
 
-async function updateUser (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateUser (req: express.Request, res: express.Response) {
   const body: UserUpdate = req.body
-  const userToUpdate = res.locals.user as UserModel
+  const userToUpdate = res.locals.user
   const oldUserAuditView = new UserAuditView(userToUpdate.toFormattedJSON())
   const roleChanged = body.role !== undefined && body.role !== userToUpdate.role
 
+  if (body.password !== undefined) userToUpdate.password = body.password
   if (body.email !== undefined) userToUpdate.email = body.email
   if (body.emailVerified !== undefined) userToUpdate.emailVerified = body.emailVerified
   if (body.videoQuota !== undefined) userToUpdate.videoQuota = body.videoQuota
   if (body.videoQuotaDaily !== undefined) userToUpdate.videoQuotaDaily = body.videoQuotaDaily
   if (body.role !== undefined) userToUpdate.role = body.role
+  if (body.adminFlags !== undefined) userToUpdate.adminFlags = body.adminFlags
 
   const user = await userToUpdate.save()
 
   // Destroy user token to refresh rights
-  if (roleChanged) await deleteUserToken(userToUpdate.id)
+  if (roleChanged || body.password !== undefined) await deleteUserToken(userToUpdate.id)
 
   auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
 
-  // Don't need to send this update to followers, these attributes are not propagated
+  // Don't need to send this update to followers, these attributes are not federated
 
   return res.sendStatus(204)
 }
 
-async function askResetUserPassword (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function askResetUserPassword (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   const verificationString = await Redis.Instance.setResetPasswordVerificationString(user.id)
-  const url = CONFIG.WEBSERVER.URL + '/reset-password?userId=' + user.id + '&verificationString=' + verificationString
-  await Emailer.Instance.addForgetPasswordEmailJob(user.email, url)
+  const url = WEBSERVER.URL + '/reset-password?userId=' + user.id + '&verificationString=' + verificationString
+  await Emailer.Instance.addPasswordResetEmailJob(user.email, url)
 
   return res.status(204).end()
 }
 
-async function resetUserPassword (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function resetUserPassword (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   user.password = req.body.password
 
   await user.save()
@@ -309,21 +315,21 @@ async function resetUserPassword (req: express.Request, res: express.Response, n
 
 async function sendVerifyUserEmail (user: UserModel) {
   const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id)
-  const url = CONFIG.WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
+  const url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
   await Emailer.Instance.addVerifyEmailJob(user.email, url)
   return
 }
 
-async function askSendVerifyUserEmail (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function askSendVerifyUserEmail (req: express.Request, res: express.Response) {
+  const user = res.locals.user
 
   await sendVerifyUserEmail(user)
 
   return res.status(204).end()
 }
 
-async function verifyUserEmail (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.user as UserModel
+async function verifyUserEmail (req: express.Request, res: express.Response) {
+  const user = res.locals.user
   user.emailVerified = true
 
   await user.save()
@@ -331,7 +337,7 @@ async function verifyUserEmail (req: express.Request, res: express.Response, nex
   return res.status(204).end()
 }
 
-function success (req: express.Request, res: express.Response, next: express.NextFunction) {
+function success (req: express.Request, res: express.Response) {
   res.end()
 }
 
diff --git a/server/controllers/api/users/me.ts b/server/controllers/api/users/me.ts
index 94a2b8732..ddb239e7b 100644
--- a/server/controllers/api/users/me.ts
+++ b/server/controllers/api/users/me.ts
@@ -2,7 +2,7 @@ import * as express from 'express'
 import 'multer'
 import { UserUpdateMe, UserVideoRate as FormattedUserVideoRate } from '../../../../shared'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { sendUpdateActor } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
@@ -26,6 +26,8 @@ import { updateActorAvatarFile } from '../../../lib/avatar'
 import { auditLoggerFactory, getAuditIdFromRes, UserAuditView } from '../../../helpers/audit-logger'
 import { VideoImportModel } from '../../../models/video/video-import'
 import { AccountModel } from '../../../models/account/account'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const auditLogger = auditLoggerFactory('users-me')
 
@@ -93,8 +95,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function getUserVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserVideos (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoModel.listUserVideosForApi(
     user.Account.id,
     req.query.start as number,
@@ -111,8 +113,8 @@ async function getUserVideos (req: express.Request, res: express.Response, next:
   return res.json(getFormattedObjects(resultList.data, resultList.total, { additionalAttributes }))
 }
 
-async function getUserVideoImports (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserVideoImports (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoImportModel.listUserVideoImportsForApi(
     user.id,
     req.query.start as number,
@@ -123,14 +125,14 @@ async function getUserVideoImports (req: express.Request, res: express.Response,
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function getUserInformation (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserInformation (req: express.Request, res: express.Response) {
   // We did not load channels in res.locals.user
   const user = await UserModel.loadByUsernameAndPopulateChannels(res.locals.oauth.token.user.username)
 
-  return res.json(user.toFormattedJSON())
+  return res.json(user.toFormattedJSON({}))
 }
 
-async function getUserVideoQuotaUsed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserVideoQuotaUsed (req: express.Request, res: express.Response) {
   // We did not load channels in res.locals.user
   const user = await UserModel.loadByUsernameAndPopulateChannels(res.locals.oauth.token.user.username)
   const videoQuotaUsed = await UserModel.getOriginalVideoFileTotalFromUser(user)
@@ -143,7 +145,7 @@ async function getUserVideoQuotaUsed (req: express.Request, res: express.Respons
   return res.json(data)
 }
 
-async function getUserVideoRating (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getUserVideoRating (req: express.Request, res: express.Response) {
   const videoId = res.locals.video.id
   const accountId = +res.locals.oauth.token.User.Account.id
 
@@ -158,20 +160,20 @@ async function getUserVideoRating (req: express.Request, res: express.Response,
 }
 
 async function deleteMe (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await user.destroy()
 
-  auditLogger.delete(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()))
+  auditLogger.delete(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})))
 
   return res.sendStatus(204)
 }
 
-async function updateMe (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateMe (req: express.Request, res: express.Response) {
   const body: UserUpdateMe = req.body
 
-  const user: UserModel = res.locals.oauth.token.user
-  const oldUserAuditView = new UserAuditView(user.toFormattedJSON())
+  const user = res.locals.oauth.token.user
+  const oldUserAuditView = new UserAuditView(user.toFormattedJSON({}))
 
   if (body.password !== undefined) user.password = body.password
   if (body.email !== undefined) user.email = body.email
@@ -191,7 +193,7 @@ async function updateMe (req: express.Request, res: express.Response, next: expr
 
     await sendUpdateActor(userAccount, t)
 
-    auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
+    auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})), oldUserAuditView)
   })
 
   return res.sendStatus(204)
@@ -199,14 +201,14 @@ async function updateMe (req: express.Request, res: express.Response, next: expr
 
 async function updateMyAvatar (req: express.Request, res: express.Response) {
   const avatarPhysicalFile = req.files[ 'avatarfile' ][ 0 ]
-  const user: UserModel = res.locals.oauth.token.user
-  const oldUserAuditView = new UserAuditView(user.toFormattedJSON())
+  const user = res.locals.oauth.token.user
+  const oldUserAuditView = new UserAuditView(user.toFormattedJSON({}))
 
   const userAccount = await AccountModel.load(user.Account.id)
 
   const avatar = await updateActorAvatarFile(avatarPhysicalFile, userAccount)
 
-  auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON()), oldUserAuditView)
+  auditLogger.update(getAuditIdFromRes(res), new UserAuditView(user.toFormattedJSON({})), oldUserAuditView)
 
   return res.json({ avatar: avatar.toFormattedJSON() })
 }
diff --git a/server/controllers/api/users/my-blocklist.ts b/server/controllers/api/users/my-blocklist.ts
index 9575eab46..713c16022 100644
--- a/server/controllers/api/users/my-blocklist.ts
+++ b/server/controllers/api/users/my-blocklist.ts
@@ -17,12 +17,9 @@ import {
   serversBlocklistSortValidator,
   unblockServerByAccountValidator
 } from '../../../middlewares/validators'
-import { UserModel } from '../../../models/account/user'
-import { AccountModel } from '../../../models/account/account'
 import { AccountBlocklistModel } from '../../../models/account/account-blocklist'
 import { addAccountInBlocklist, addServerInBlocklist, removeAccountFromBlocklist, removeServerFromBlocklist } from '../../../lib/blocklist'
 import { ServerBlocklistModel } from '../../../models/server/server-blocklist'
-import { ServerModel } from '../../../models/server/server'
 
 const myBlocklistRouter = express.Router()
 
@@ -75,7 +72,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function listBlockedAccounts (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await AccountBlocklistModel.listForApi(user.Account.id, req.query.start, req.query.count, req.query.sort)
 
@@ -83,8 +80,8 @@ async function listBlockedAccounts (req: express.Request, res: express.Response)
 }
 
 async function blockAccount (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const accountToBlock: AccountModel = res.locals.account
+  const user = res.locals.oauth.token.User
+  const accountToBlock = res.locals.account
 
   await addAccountInBlocklist(user.Account.id, accountToBlock.id)
 
@@ -92,7 +89,7 @@ async function blockAccount (req: express.Request, res: express.Response) {
 }
 
 async function unblockAccount (req: express.Request, res: express.Response) {
-  const accountBlock: AccountBlocklistModel = res.locals.accountBlock
+  const accountBlock = res.locals.accountBlock
 
   await removeAccountFromBlocklist(accountBlock)
 
@@ -100,7 +97,7 @@ async function unblockAccount (req: express.Request, res: express.Response) {
 }
 
 async function listBlockedServers (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await ServerBlocklistModel.listForApi(user.Account.id, req.query.start, req.query.count, req.query.sort)
 
@@ -108,8 +105,8 @@ async function listBlockedServers (req: express.Request, res: express.Response)
 }
 
 async function blockServer (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const serverToBlock: ServerModel = res.locals.server
+  const user = res.locals.oauth.token.User
+  const serverToBlock = res.locals.server
 
   await addServerInBlocklist(user.Account.id, serverToBlock.id)
 
@@ -117,7 +114,7 @@ async function blockServer (req: express.Request, res: express.Response) {
 }
 
 async function unblockServer (req: express.Request, res: express.Response) {
-  const serverBlock: ServerBlocklistModel = res.locals.serverBlock
+  const serverBlock = res.locals.serverBlock
 
   await removeServerFromBlocklist(serverBlock)
 
diff --git a/server/controllers/api/users/my-history.ts b/server/controllers/api/users/my-history.ts
index 6cd782c47..7025c0ff1 100644
--- a/server/controllers/api/users/my-history.ts
+++ b/server/controllers/api/users/my-history.ts
@@ -36,7 +36,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function listMyVideosHistory (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await UserVideoHistoryModel.listForApi(user, req.query.start, req.query.count)
 
@@ -44,11 +44,11 @@ async function listMyVideosHistory (req: express.Request, res: express.Response)
 }
 
 async function removeUserHistory (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
   const beforeDate = req.body.beforeDate || null
 
   await sequelizeTypescript.transaction(t => {
-    return UserVideoHistoryModel.removeHistoryBefore(user, beforeDate, t)
+    return UserVideoHistoryModel.removeUserHistoryBefore(user, beforeDate, t)
   })
 
   // Do not send the delete to other instances, we delete OUR copy of this video abuse
diff --git a/server/controllers/api/users/my-notifications.ts b/server/controllers/api/users/my-notifications.ts
index 76cf97587..f146284e4 100644
--- a/server/controllers/api/users/my-notifications.ts
+++ b/server/controllers/api/users/my-notifications.ts
@@ -9,7 +9,6 @@ import {
   setDefaultSort,
   userNotificationsSortValidator
 } from '../../../middlewares'
-import { UserModel } from '../../../models/account/user'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { UserNotificationModel } from '../../../models/account/user-notification'
 import { meRouter } from './me'
@@ -57,8 +56,8 @@ export {
 // ---------------------------------------------------------------------------
 
 async function updateNotificationSettings (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
-  const body = req.body
+  const user = res.locals.oauth.token.User
+  const body = req.body as UserNotificationSetting
 
   const query = {
     where: {
@@ -70,12 +69,14 @@ async function updateNotificationSettings (req: express.Request, res: express.Re
     newVideoFromSubscription: body.newVideoFromSubscription,
     newCommentOnMyVideo: body.newCommentOnMyVideo,
     videoAbuseAsModerator: body.videoAbuseAsModerator,
+    videoAutoBlacklistAsModerator: body.videoAutoBlacklistAsModerator,
     blacklistOnMyVideo: body.blacklistOnMyVideo,
     myVideoPublished: body.myVideoPublished,
     myVideoImportFinished: body.myVideoImportFinished,
     newFollow: body.newFollow,
     newUserRegistration: body.newUserRegistration,
-    commentMention: body.commentMention
+    commentMention: body.commentMention,
+    newInstanceFollower: body.newInstanceFollower
   }
 
   await UserNotificationSettingModel.update(values, query)
@@ -84,7 +85,7 @@ async function updateNotificationSettings (req: express.Request, res: express.Re
 }
 
 async function listUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   const resultList = await UserNotificationModel.listForApi(user.id, req.query.start, req.query.count, req.query.sort, req.query.unread)
 
@@ -92,7 +93,7 @@ async function listUserNotifications (req: express.Request, res: express.Respons
 }
 
 async function markAsReadUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await UserNotificationModel.markAsRead(user.id, req.body.ids)
 
@@ -100,7 +101,7 @@ async function markAsReadUserNotifications (req: express.Request, res: express.R
 }
 
 async function markAsReadAllUserNotifications (req: express.Request, res: express.Response) {
-  const user: UserModel = res.locals.oauth.token.User
+  const user = res.locals.oauth.token.User
 
   await UserNotificationModel.markAllAsRead(user.id)
 
diff --git a/server/controllers/api/users/my-subscriptions.ts b/server/controllers/api/users/my-subscriptions.ts
index accca6d52..c52df3154 100644
--- a/server/controllers/api/users/my-subscriptions.ts
+++ b/server/controllers/api/users/my-subscriptions.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import 'multer'
 import { getFormattedObjects } from '../../../helpers/utils'
-import { CONFIG, sequelizeTypescript } from '../../../initializers'
+import { WEBSERVER } from '../../../initializers/constants'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -14,13 +14,13 @@ import {
   userSubscriptionGetValidator
 } from '../../../middlewares'
 import { areSubscriptionsExistValidator, userSubscriptionsSortValidator, videosSortValidator } from '../../../middlewares/validators'
-import { UserModel } from '../../../models/account/user'
 import { VideoModel } from '../../../models/video/video'
 import { buildNSFWFilter } from '../../../helpers/express-utils'
 import { VideoFilter } from '../../../../shared/models/videos/video-query.type'
 import { ActorFollowModel } from '../../../models/activitypub/actor-follow'
 import { JobQueue } from '../../../lib/job-queue'
 import { logger } from '../../../helpers/logger'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const mySubscriptionsRouter = express.Router()
 
@@ -77,11 +77,11 @@ export {
 
 async function areSubscriptionsExist (req: express.Request, res: express.Response) {
   const uris = req.query.uris as string[]
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
 
   const handles = uris.map(u => {
     let [ name, host ] = u.split('@')
-    if (host === CONFIG.WEBSERVER.HOST) host = null
+    if (host === WEBSERVER.HOST) host = null
 
     return { name, host, uri: u }
   })
@@ -107,7 +107,7 @@ async function areSubscriptionsExist (req: express.Request, res: express.Respons
 }
 
 async function addUserSubscription (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
   const [ name, host ] = req.body.uri.split('@')
 
   const payload = {
@@ -123,13 +123,13 @@ async function addUserSubscription (req: express.Request, res: express.Response)
 }
 
 function getUserSubscription (req: express.Request, res: express.Response) {
-  const subscription: ActorFollowModel = res.locals.subscription
+  const subscription = res.locals.subscription
 
   return res.json(subscription.ActorFollowing.VideoChannel.toFormattedJSON())
 }
 
 async function deleteUserSubscription (req: express.Request, res: express.Response) {
-  const subscription: ActorFollowModel = res.locals.subscription
+  const subscription = res.locals.subscription
 
   await sequelizeTypescript.transaction(async t => {
     return subscription.destroy({ transaction: t })
@@ -139,7 +139,7 @@ async function deleteUserSubscription (req: express.Request, res: express.Respon
 }
 
 async function getUserSubscriptions (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
   const actorId = user.Account.Actor.id
 
   const resultList = await ActorFollowModel.listSubscriptionsForApi(actorId, req.query.start, req.query.count, req.query.sort)
@@ -147,8 +147,8 @@ async function getUserSubscriptions (req: express.Request, res: express.Response
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function getUserSubscriptionVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const user = res.locals.oauth.token.User as UserModel
+async function getUserSubscriptionVideos (req: express.Request, res: express.Response) {
+  const user = res.locals.oauth.token.User
   const resultList = await VideoModel.listForApi({
     start: req.query.start,
     count: req.query.count,
diff --git a/server/controllers/api/users/my-video-playlists.ts b/server/controllers/api/users/my-video-playlists.ts
new file mode 100644
index 000000000..15e92f4f3
--- /dev/null
+++ b/server/controllers/api/users/my-video-playlists.ts
@@ -0,0 +1,46 @@
+import * as express from 'express'
+import { asyncMiddleware, authenticate } from '../../../middlewares'
+import { doVideosInPlaylistExistValidator } from '../../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistModel } from '../../../models/video/video-playlist'
+import { VideoExistInPlaylist } from '../../../../shared/models/videos/playlist/video-exist-in-playlist.model'
+
+const myVideoPlaylistsRouter = express.Router()
+
+myVideoPlaylistsRouter.get('/me/video-playlists/videos-exist',
+  authenticate,
+  doVideosInPlaylistExistValidator,
+  asyncMiddleware(doVideosInPlaylistExist)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  myVideoPlaylistsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function doVideosInPlaylistExist (req: express.Request, res: express.Response) {
+  const videoIds = req.query.videoIds.map(i => parseInt(i + '', 10))
+  const user = res.locals.oauth.token.User
+
+  const results = await VideoPlaylistModel.listPlaylistIdsOf(user.Account.id, videoIds)
+
+  const existObject: VideoExistInPlaylist = {}
+
+  for (const videoId of videoIds) {
+    existObject[videoId] = []
+  }
+
+  for (const result of results) {
+    for (const element of result.VideoPlaylistElements) {
+      existObject[element.videoId].push({
+        playlistId: result.id,
+        startTimestamp: element.startTimestamp,
+        stopTimestamp: element.stopTimestamp
+      })
+    }
+  }
+
+  return res.json(existObject)
+}
diff --git a/server/controllers/api/video-channel.ts b/server/controllers/api/video-channel.ts
index db7602139..3d6dbfe70 100644
--- a/server/controllers/api/video-channel.ts
+++ b/server/controllers/api/video-channel.ts
@@ -12,7 +12,8 @@ import {
   videoChannelsAddValidator,
   videoChannelsRemoveValidator,
   videoChannelsSortValidator,
-  videoChannelsUpdateValidator
+  videoChannelsUpdateValidator,
+  videoPlaylistsSortValidator
 } from '../../middlewares'
 import { VideoChannelModel } from '../../models/video/video-channel'
 import { videoChannelsNameWithHostValidator, videosSortValidator } from '../../middlewares/validators'
@@ -22,15 +23,18 @@ import { createVideoChannel } from '../../lib/video-channel'
 import { buildNSFWFilter, createReqFiles, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
 import { setAsyncActorKeys } from '../../lib/activitypub'
 import { AccountModel } from '../../models/account/account'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../initializers'
+import { MIMETYPES } from '../../initializers/constants'
 import { logger } from '../../helpers/logger'
 import { VideoModel } from '../../models/video/video'
 import { updateAvatarValidator } from '../../middlewares/validators/avatar'
 import { updateActorAvatarFile } from '../../lib/avatar'
 import { auditLoggerFactory, getAuditIdFromRes, VideoChannelAuditView } from '../../helpers/audit-logger'
 import { resetSequelizeInstance } from '../../helpers/database-utils'
-import { UserModel } from '../../models/account/user'
 import { JobQueue } from '../../lib/job-queue'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import { commonVideoPlaylistFiltersValidator } from '../../middlewares/validators/videos/video-playlists'
+import { CONFIG } from '../../initializers/config'
+import { sequelizeTypescript } from '../../initializers/database'
 
 const auditLogger = auditLoggerFactory('channels')
 const reqAvatarFile = createReqFiles([ 'avatarfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { avatarfile: CONFIG.STORAGE.TMP_DIR })
@@ -77,6 +81,16 @@ videoChannelRouter.get('/:nameWithHost',
   asyncMiddleware(getVideoChannel)
 )
 
+videoChannelRouter.get('/:nameWithHost/video-playlists',
+  asyncMiddleware(videoChannelsNameWithHostValidator),
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listVideoChannelPlaylists)
+)
+
 videoChannelRouter.get('/:nameWithHost/videos',
   asyncMiddleware(videoChannelsNameWithHostValidator),
   paginationValidator,
@@ -96,16 +110,16 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listVideoChannels (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function listVideoChannels (req: express.Request, res: express.Response) {
   const serverActor = await getServerActor()
   const resultList = await VideoChannelModel.listForApi(serverActor.id, req.query.start, req.query.count, req.query.sort)
 
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function updateVideoChannelAvatar (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function updateVideoChannelAvatar (req: express.Request, res: express.Response) {
   const avatarPhysicalFile = req.files[ 'avatarfile' ][ 0 ]
-  const videoChannel = res.locals.videoChannel as VideoChannelModel
+  const videoChannel = res.locals.videoChannel
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannel.toFormattedJSON())
 
   const avatar = await updateActorAvatarFile(avatarPhysicalFile, videoChannel)
@@ -123,7 +137,7 @@ async function addVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelInfo: VideoChannelCreate = req.body
 
   const videoChannelCreated: VideoChannelModel = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoChannel(videoChannelInfo, account, t)
   })
@@ -143,7 +157,7 @@ async function addVideoChannel (req: express.Request, res: express.Response) {
 }
 
 async function updateVideoChannel (req: express.Request, res: express.Response) {
-  const videoChannelInstance = res.locals.videoChannel as VideoChannelModel
+  const videoChannelInstance = res.locals.videoChannel
   const videoChannelFieldsSave = videoChannelInstance.toJSON()
   const oldVideoChannelAuditKeys = new VideoChannelAuditView(videoChannelInstance.toFormattedJSON())
   const videoChannelInfoToUpdate = req.body as VideoChannelUpdate
@@ -183,9 +197,11 @@ async function updateVideoChannel (req: express.Request, res: express.Response)
 }
 
 async function removeVideoChannel (req: express.Request, res: express.Response) {
-  const videoChannelInstance: VideoChannelModel = res.locals.videoChannel
+  const videoChannelInstance = res.locals.videoChannel
 
   await sequelizeTypescript.transaction(async t => {
+    await VideoPlaylistModel.resetPlaylistsOfChannel(videoChannelInstance.id, t)
+
     await videoChannelInstance.destroy({ transaction: t })
 
     auditLogger.delete(getAuditIdFromRes(res), new VideoChannelAuditView(videoChannelInstance.toFormattedJSON()))
@@ -195,7 +211,7 @@ async function removeVideoChannel (req: express.Request, res: express.Response)
   return res.type('json').status(204).end()
 }
 
-async function getVideoChannel (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function getVideoChannel (req: express.Request, res: express.Response) {
   const videoChannelWithVideos = await VideoChannelModel.loadAndPopulateAccountAndVideos(res.locals.videoChannel.id)
 
   if (videoChannelWithVideos.isOutdated()) {
@@ -206,8 +222,23 @@ async function getVideoChannel (req: express.Request, res: express.Response, nex
   return res.json(videoChannelWithVideos.toFormattedJSON())
 }
 
-async function listVideoChannelVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const videoChannelInstance: VideoChannelModel = res.locals.videoChannel
+async function listVideoChannelPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    videoChannelId: res.locals.videoChannel.id,
+    type: req.query.playlistType
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function listVideoChannelVideos (req: express.Request, res: express.Response) {
+  const videoChannelInstance = res.locals.videoChannel
   const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
 
   const resultList = await VideoModel.listForApi({
diff --git a/server/controllers/api/video-playlist.ts b/server/controllers/api/video-playlist.ts
new file mode 100644
index 000000000..a17136401
--- /dev/null
+++ b/server/controllers/api/video-playlist.ts
@@ -0,0 +1,445 @@
+import * as express from 'express'
+import { getFormattedObjects, getServerActor } from '../../helpers/utils'
+import {
+  asyncMiddleware,
+  asyncRetryTransactionMiddleware,
+  authenticate,
+  commonVideosFiltersValidator,
+  optionalAuthenticate,
+  paginationValidator,
+  setDefaultPagination,
+  setDefaultSort
+} from '../../middlewares'
+import { videoPlaylistsSortValidator } from '../../middlewares/validators'
+import { buildNSFWFilter, createReqFiles, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
+import { MIMETYPES, VIDEO_PLAYLIST_PRIVACIES } from '../../initializers/constants'
+import { logger } from '../../helpers/logger'
+import { resetSequelizeInstance } from '../../helpers/database-utils'
+import { VideoPlaylistModel } from '../../models/video/video-playlist'
+import {
+  commonVideoPlaylistFiltersValidator,
+  videoPlaylistsAddValidator,
+  videoPlaylistsAddVideoValidator,
+  videoPlaylistsDeleteValidator,
+  videoPlaylistsGetValidator,
+  videoPlaylistsReorderVideosValidator,
+  videoPlaylistsUpdateOrRemoveVideoValidator,
+  videoPlaylistsUpdateValidator
+} from '../../middlewares/validators/videos/video-playlists'
+import { VideoPlaylistCreate } from '../../../shared/models/videos/playlist/video-playlist-create.model'
+import { VideoPlaylistPrivacy } from '../../../shared/models/videos/playlist/video-playlist-privacy.model'
+import { join } from 'path'
+import { sendCreateVideoPlaylist, sendDeleteVideoPlaylist, sendUpdateVideoPlaylist } from '../../lib/activitypub/send'
+import { getVideoPlaylistActivityPubUrl, getVideoPlaylistElementActivityPubUrl } from '../../lib/activitypub/url'
+import { VideoPlaylistUpdate } from '../../../shared/models/videos/playlist/video-playlist-update.model'
+import { VideoModel } from '../../models/video/video'
+import { VideoPlaylistElementModel } from '../../models/video/video-playlist-element'
+import { VideoPlaylistElementCreate } from '../../../shared/models/videos/playlist/video-playlist-element-create.model'
+import { VideoPlaylistElementUpdate } from '../../../shared/models/videos/playlist/video-playlist-element-update.model'
+import { AccountModel } from '../../models/account/account'
+import { VideoPlaylistReorder } from '../../../shared/models/videos/playlist/video-playlist-reorder.model'
+import { JobQueue } from '../../lib/job-queue'
+import { CONFIG } from '../../initializers/config'
+import { sequelizeTypescript } from '../../initializers/database'
+import { createPlaylistMiniatureFromExisting } from '../../lib/thumbnail'
+
+const reqThumbnailFile = createReqFiles([ 'thumbnailfile' ], MIMETYPES.IMAGE.MIMETYPE_EXT, { thumbnailfile: CONFIG.STORAGE.TMP_DIR })
+
+const videoPlaylistRouter = express.Router()
+
+videoPlaylistRouter.get('/privacies', listVideoPlaylistPrivacies)
+
+videoPlaylistRouter.get('/',
+  paginationValidator,
+  videoPlaylistsSortValidator,
+  setDefaultSort,
+  setDefaultPagination,
+  commonVideoPlaylistFiltersValidator,
+  asyncMiddleware(listVideoPlaylists)
+)
+
+videoPlaylistRouter.get('/:playlistId',
+  asyncMiddleware(videoPlaylistsGetValidator),
+  getVideoPlaylist
+)
+
+videoPlaylistRouter.post('/',
+  authenticate,
+  reqThumbnailFile,
+  asyncMiddleware(videoPlaylistsAddValidator),
+  asyncRetryTransactionMiddleware(addVideoPlaylist)
+)
+
+videoPlaylistRouter.put('/:playlistId',
+  authenticate,
+  reqThumbnailFile,
+  asyncMiddleware(videoPlaylistsUpdateValidator),
+  asyncRetryTransactionMiddleware(updateVideoPlaylist)
+)
+
+videoPlaylistRouter.delete('/:playlistId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsDeleteValidator),
+  asyncRetryTransactionMiddleware(removeVideoPlaylist)
+)
+
+videoPlaylistRouter.get('/:playlistId/videos',
+  asyncMiddleware(videoPlaylistsGetValidator),
+  paginationValidator,
+  setDefaultPagination,
+  optionalAuthenticate,
+  commonVideosFiltersValidator,
+  asyncMiddleware(getVideoPlaylistVideos)
+)
+
+videoPlaylistRouter.post('/:playlistId/videos',
+  authenticate,
+  asyncMiddleware(videoPlaylistsAddVideoValidator),
+  asyncRetryTransactionMiddleware(addVideoInPlaylist)
+)
+
+videoPlaylistRouter.post('/:playlistId/videos/reorder',
+  authenticate,
+  asyncMiddleware(videoPlaylistsReorderVideosValidator),
+  asyncRetryTransactionMiddleware(reorderVideosPlaylist)
+)
+
+videoPlaylistRouter.put('/:playlistId/videos/:videoId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
+  asyncRetryTransactionMiddleware(updateVideoPlaylistElement)
+)
+
+videoPlaylistRouter.delete('/:playlistId/videos/:videoId',
+  authenticate,
+  asyncMiddleware(videoPlaylistsUpdateOrRemoveVideoValidator),
+  asyncRetryTransactionMiddleware(removeVideoFromPlaylist)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+  videoPlaylistRouter
+}
+
+// ---------------------------------------------------------------------------
+
+function listVideoPlaylistPrivacies (req: express.Request, res: express.Response) {
+  res.json(VIDEO_PLAYLIST_PRIVACIES)
+}
+
+async function listVideoPlaylists (req: express.Request, res: express.Response) {
+  const serverActor = await getServerActor()
+  const resultList = await VideoPlaylistModel.listForApi({
+    followerActorId: serverActor.id,
+    start: req.query.start,
+    count: req.query.count,
+    sort: req.query.sort,
+    type: req.query.type
+  })
+
+  return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+function getVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylist = res.locals.videoPlaylist
+
+  if (videoPlaylist.isOutdated()) {
+    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video-playlist', url: videoPlaylist.url } })
+            .catch(err => logger.error('Cannot create AP refresher job for playlist %s.', videoPlaylist.url, { err }))
+  }
+
+  return res.json(videoPlaylist.toFormattedJSON())
+}
+
+async function addVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInfo: VideoPlaylistCreate = req.body
+  const user = res.locals.oauth.token.User
+
+  const videoPlaylist = new VideoPlaylistModel({
+    name: videoPlaylistInfo.displayName,
+    description: videoPlaylistInfo.description,
+    privacy: videoPlaylistInfo.privacy || VideoPlaylistPrivacy.PRIVATE,
+    ownerAccountId: user.Account.id
+  })
+
+  videoPlaylist.url = getVideoPlaylistActivityPubUrl(videoPlaylist) // We use the UUID, so set the URL after building the object
+
+  if (videoPlaylistInfo.videoChannelId) {
+    const videoChannel = res.locals.videoChannel
+
+    videoPlaylist.videoChannelId = videoChannel.id
+    videoPlaylist.VideoChannel = videoChannel
+  }
+
+  const thumbnailField = req.files['thumbnailfile']
+  const thumbnailModel = thumbnailField
+    ? await createPlaylistMiniatureFromExisting(thumbnailField[0].path, videoPlaylist)
+    : undefined
+
+  const videoPlaylistCreated: VideoPlaylistModel = await sequelizeTypescript.transaction(async t => {
+    const videoPlaylistCreated = await videoPlaylist.save({ transaction: t })
+
+    if (thumbnailModel) await videoPlaylistCreated.setAndSaveThumbnail(thumbnailModel, t)
+
+    // We need more attributes for the federation
+    videoPlaylistCreated.OwnerAccount = await AccountModel.load(user.Account.id, t)
+    await sendCreateVideoPlaylist(videoPlaylistCreated, t)
+
+    return videoPlaylistCreated
+  })
+
+  logger.info('Video playlist with uuid %s created.', videoPlaylist.uuid)
+
+  return res.json({
+    videoPlaylist: {
+      id: videoPlaylistCreated.id,
+      uuid: videoPlaylistCreated.uuid
+    }
+  }).end()
+}
+
+async function updateVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+  const videoPlaylistFieldsSave = videoPlaylistInstance.toJSON()
+  const videoPlaylistInfoToUpdate = req.body as VideoPlaylistUpdate
+  const wasPrivatePlaylist = videoPlaylistInstance.privacy === VideoPlaylistPrivacy.PRIVATE
+
+  const thumbnailField = req.files['thumbnailfile']
+  const thumbnailModel = thumbnailField
+    ? await createPlaylistMiniatureFromExisting(thumbnailField[0].path, videoPlaylistInstance)
+    : undefined
+
+  try {
+    await sequelizeTypescript.transaction(async t => {
+      const sequelizeOptions = {
+        transaction: t
+      }
+
+      if (videoPlaylistInfoToUpdate.videoChannelId !== undefined) {
+        if (videoPlaylistInfoToUpdate.videoChannelId === null) {
+          videoPlaylistInstance.videoChannelId = null
+        } else {
+          const videoChannel = res.locals.videoChannel
+
+          videoPlaylistInstance.videoChannelId = videoChannel.id
+          videoPlaylistInstance.VideoChannel = videoChannel
+        }
+      }
+
+      if (videoPlaylistInfoToUpdate.displayName !== undefined) videoPlaylistInstance.name = videoPlaylistInfoToUpdate.displayName
+      if (videoPlaylistInfoToUpdate.description !== undefined) videoPlaylistInstance.description = videoPlaylistInfoToUpdate.description
+
+      if (videoPlaylistInfoToUpdate.privacy !== undefined) {
+        videoPlaylistInstance.privacy = parseInt(videoPlaylistInfoToUpdate.privacy.toString(), 10)
+      }
+
+      const playlistUpdated = await videoPlaylistInstance.save(sequelizeOptions)
+
+      if (thumbnailModel) await playlistUpdated.setAndSaveThumbnail(thumbnailModel, t)
+
+      const isNewPlaylist = wasPrivatePlaylist && playlistUpdated.privacy !== VideoPlaylistPrivacy.PRIVATE
+
+      if (isNewPlaylist) {
+        await sendCreateVideoPlaylist(playlistUpdated, t)
+      } else {
+        await sendUpdateVideoPlaylist(playlistUpdated, t)
+      }
+
+      logger.info('Video playlist %s updated.', videoPlaylistInstance.uuid)
+
+      return playlistUpdated
+    })
+  } catch (err) {
+    logger.debug('Cannot update the video playlist.', { 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!
+    resetSequelizeInstance(videoPlaylistInstance, videoPlaylistFieldsSave)
+
+    throw err
+  }
+
+  return res.type('json').status(204).end()
+}
+
+async function removeVideoPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+
+  await sequelizeTypescript.transaction(async t => {
+    await videoPlaylistInstance.destroy({ transaction: t })
+
+    await sendDeleteVideoPlaylist(videoPlaylistInstance, t)
+
+    logger.info('Video playlist %s deleted.', videoPlaylistInstance.uuid)
+  })
+
+  return res.type('json').status(204).end()
+}
+
+async function addVideoInPlaylist (req: express.Request, res: express.Response) {
+  const body: VideoPlaylistElementCreate = req.body
+  const videoPlaylist = res.locals.videoPlaylist
+  const video = res.locals.video
+
+  const playlistElement: VideoPlaylistElementModel = await sequelizeTypescript.transaction(async t => {
+    const position = await VideoPlaylistElementModel.getNextPositionOf(videoPlaylist.id, t)
+
+    const playlistElement = await VideoPlaylistElementModel.create({
+      url: getVideoPlaylistElementActivityPubUrl(videoPlaylist, video),
+      position,
+      startTimestamp: body.startTimestamp || null,
+      stopTimestamp: body.stopTimestamp || null,
+      videoPlaylistId: videoPlaylist.id,
+      videoId: video.id
+    }, { transaction: t })
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    return playlistElement
+  })
+
+  // If the user did not set a thumbnail, automatically take the video thumbnail
+  if (videoPlaylist.hasThumbnail() === false) {
+    logger.info('Generating default thumbnail to playlist %s.', videoPlaylist.url)
+
+    const inputPath = join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getMiniature().filename)
+    const thumbnailModel = await createPlaylistMiniatureFromExisting(inputPath, videoPlaylist, true)
+
+    thumbnailModel.videoPlaylistId = videoPlaylist.id
+
+    await thumbnailModel.save()
+  }
+
+  logger.info('Video added in playlist %s at position %d.', videoPlaylist.uuid, playlistElement.position)
+
+  return res.json({
+    videoPlaylistElement: {
+      id: playlistElement.id
+    }
+  }).end()
+}
+
+async function updateVideoPlaylistElement (req: express.Request, res: express.Response) {
+  const body: VideoPlaylistElementUpdate = req.body
+  const videoPlaylist = res.locals.videoPlaylist
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+
+  const playlistElement: VideoPlaylistElementModel = await sequelizeTypescript.transaction(async t => {
+    if (body.startTimestamp !== undefined) videoPlaylistElement.startTimestamp = body.startTimestamp
+    if (body.stopTimestamp !== undefined) videoPlaylistElement.stopTimestamp = body.stopTimestamp
+
+    const element = await videoPlaylistElement.save({ transaction: t })
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    return element
+  })
+
+  logger.info('Element of position %d of playlist %s updated.', playlistElement.position, videoPlaylist.uuid)
+
+  return res.type('json').status(204).end()
+}
+
+async function removeVideoFromPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylistElement = res.locals.videoPlaylistElement
+  const videoPlaylist = res.locals.videoPlaylist
+  const positionToDelete = videoPlaylistElement.position
+
+  await sequelizeTypescript.transaction(async t => {
+    await videoPlaylistElement.destroy({ transaction: t })
+
+    // Decrease position of the next elements
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, positionToDelete, null, -1, t)
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+
+    logger.info('Video playlist element %d of playlist %s deleted.', videoPlaylistElement.position, videoPlaylist.uuid)
+  })
+
+  return res.type('json').status(204).end()
+}
+
+async function reorderVideosPlaylist (req: express.Request, res: express.Response) {
+  const videoPlaylist = res.locals.videoPlaylist
+  const body: VideoPlaylistReorder = req.body
+
+  const start: number = body.startPosition
+  const insertAfter: number = body.insertAfterPosition
+  const reorderLength: number = body.reorderLength || 1
+
+  if (start === insertAfter) {
+    return res.status(204).end()
+  }
+
+  // Example: if we reorder position 2 and insert after position 5 (so at position 6): # 1 2 3 4 5 6 7 8 9
+  //  * increase position when position > 5 # 1 2 3 4 5 7 8 9 10
+  //  * update position 2 -> position 6 # 1 3 4 5 6 7 8 9 10
+  //  * decrease position when position position > 2 # 1 2 3 4 5 6 7 8 9
+  await sequelizeTypescript.transaction(async t => {
+    const newPosition = insertAfter + 1
+
+    // Add space after the position when we want to insert our reordered elements (increase)
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, newPosition, null, reorderLength, t)
+
+    let oldPosition = start
+
+    // We incremented the position of the elements we want to reorder
+    if (start >= newPosition) oldPosition += reorderLength
+
+    const endOldPosition = oldPosition + reorderLength - 1
+    // Insert our reordered elements in their place (update)
+    await VideoPlaylistElementModel.reassignPositionOf(videoPlaylist.id, oldPosition, endOldPosition, newPosition, t)
+
+    // Decrease positions of elements after the old position of our ordered elements (decrease)
+    await VideoPlaylistElementModel.increasePositionOf(videoPlaylist.id, oldPosition, null, -reorderLength, t)
+
+    videoPlaylist.changed('updatedAt', true)
+    await videoPlaylist.save({ transaction: t })
+
+    await sendUpdateVideoPlaylist(videoPlaylist, t)
+  })
+
+  logger.info(
+    'Reordered playlist %s (inserted after %d elements %d - %d).',
+    videoPlaylist.uuid, insertAfter, start, start + reorderLength - 1
+  )
+
+  return res.type('json').status(204).end()
+}
+
+async function getVideoPlaylistVideos (req: express.Request, res: express.Response) {
+  const videoPlaylistInstance = res.locals.videoPlaylist
+  const followerActorId = isUserAbleToSearchRemoteURI(res) ? null : undefined
+
+  const resultList = await VideoModel.listForApi({
+    followerActorId,
+    start: req.query.start,
+    count: req.query.count,
+    sort: 'VideoPlaylistElements.position',
+    includeLocalVideos: true,
+    categoryOneOf: req.query.categoryOneOf,
+    licenceOneOf: req.query.licenceOneOf,
+    languageOneOf: req.query.languageOneOf,
+    tagsOneOf: req.query.tagsOneOf,
+    tagsAllOf: req.query.tagsAllOf,
+    filter: req.query.filter,
+    nsfw: buildNSFWFilter(res, req.query.nsfw),
+    withFiles: false,
+    videoPlaylistId: videoPlaylistInstance.id,
+    user: res.locals.oauth ? res.locals.oauth.token.User : undefined
+  })
+
+  const additionalAttributes = { playlistInfo: true }
+  return res.json(getFormattedObjects(resultList.data, resultList.total, { additionalAttributes }))
+}
diff --git a/server/controllers/api/videos/abuse.ts b/server/controllers/api/videos/abuse.ts
index fe0a95cd5..ca70230a2 100644
--- a/server/controllers/api/videos/abuse.ts
+++ b/server/controllers/api/videos/abuse.ts
@@ -3,7 +3,6 @@ import { UserRight, VideoAbuseCreate, VideoAbuseState } from '../../../../shared
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { sequelizeTypescript } from '../../../initializers'
-import { sendVideoAbuse } from '../../../lib/activitypub/send'
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
@@ -18,11 +17,10 @@ import {
   videoAbuseUpdateValidator
 } from '../../../middlewares'
 import { AccountModel } from '../../../models/account/account'
-import { VideoModel } from '../../../models/video/video'
 import { VideoAbuseModel } from '../../../models/video/video-abuse'
 import { auditLoggerFactory, VideoAbuseAuditView } from '../../../helpers/audit-logger'
-import { UserModel } from '../../../models/account/user'
 import { Notifier } from '../../../lib/notifier'
+import { sendVideoAbuse } from '../../../lib/activitypub/send/send-flag'
 
 const auditLogger = auditLoggerFactory('abuse')
 const abuseVideoRouter = express.Router()
@@ -69,7 +67,7 @@ async function listVideoAbuses (req: express.Request, res: express.Response) {
 }
 
 async function updateVideoAbuse (req: express.Request, res: express.Response) {
-  const videoAbuse: VideoAbuseModel = res.locals.videoAbuse
+  const videoAbuse = res.locals.videoAbuse
 
   if (req.body.moderationComment !== undefined) videoAbuse.moderationComment = req.body.moderationComment
   if (req.body.state !== undefined) videoAbuse.state = req.body.state
@@ -84,7 +82,7 @@ async function updateVideoAbuse (req: express.Request, res: express.Response) {
 }
 
 async function deleteVideoAbuse (req: express.Request, res: express.Response) {
-  const videoAbuse: VideoAbuseModel = res.locals.videoAbuse
+  const videoAbuse = res.locals.videoAbuse
 
   await sequelizeTypescript.transaction(t => {
     return videoAbuse.destroy({ transaction: t })
@@ -96,11 +94,11 @@ async function deleteVideoAbuse (req: express.Request, res: express.Response) {
 }
 
 async function reportVideoAbuse (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video as VideoModel
+  const videoInstance = res.locals.video
   const body: VideoAbuseCreate = req.body
 
   const videoAbuse: VideoAbuseModel = await sequelizeTypescript.transaction(async t => {
-    const reporterAccount = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const reporterAccount = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     const abuseToCreate = {
       reporterAccountId: reporterAccount.id,
diff --git a/server/controllers/api/videos/blacklist.ts b/server/controllers/api/videos/blacklist.ts
index 43b0516e7..27dcfb761 100644
--- a/server/controllers/api/videos/blacklist.ts
+++ b/server/controllers/api/videos/blacklist.ts
@@ -1,5 +1,5 @@
 import * as express from 'express'
-import { VideoBlacklist, UserRight, VideoBlacklistCreate } from '../../../../shared'
+import { VideoBlacklist, UserRight, VideoBlacklistCreate, VideoBlacklistType } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
 import { getFormattedObjects } from '../../../helpers/utils'
 import {
@@ -12,13 +12,13 @@ import {
   setDefaultPagination,
   videosBlacklistAddValidator,
   videosBlacklistRemoveValidator,
-  videosBlacklistUpdateValidator
+  videosBlacklistUpdateValidator,
+  videosBlacklistFiltersValidator
 } from '../../../middlewares'
 import { VideoBlacklistModel } from '../../../models/video/video-blacklist'
 import { sequelizeTypescript } from '../../../initializers'
 import { Notifier } from '../../../lib/notifier'
-import { VideoModel } from '../../../models/video/video'
-import { sendCreateVideo, sendDeleteVideo, sendUpdateVideo } from '../../../lib/activitypub/send'
+import { sendDeleteVideo } from '../../../lib/activitypub/send'
 import { federateVideoIfNeeded } from '../../../lib/activitypub'
 
 const blacklistRouter = express.Router()
@@ -37,6 +37,7 @@ blacklistRouter.get('/blacklist',
   blacklistSortValidator,
   setBlacklistSort,
   setDefaultPagination,
+  videosBlacklistFiltersValidator,
   asyncMiddleware(listBlacklist)
 )
 
@@ -69,7 +70,8 @@ async function addVideoToBlacklist (req: express.Request, res: express.Response)
   const toCreate = {
     videoId: videoInstance.id,
     unfederated: body.unfederate === true,
-    reason: body.reason
+    reason: body.reason,
+    type: VideoBlacklistType.MANUAL
   }
 
   const blacklist = await VideoBlacklistModel.create(toCreate)
@@ -87,7 +89,7 @@ async function addVideoToBlacklist (req: express.Request, res: express.Response)
 }
 
 async function updateVideoBlacklistController (req: express.Request, res: express.Response) {
-  const videoBlacklist = res.locals.videoBlacklist as VideoBlacklistModel
+  const videoBlacklist = res.locals.videoBlacklist
 
   if (req.body.reason !== undefined) videoBlacklist.reason = req.body.reason
 
@@ -99,27 +101,39 @@ async function updateVideoBlacklistController (req: express.Request, res: expres
 }
 
 async function listBlacklist (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const resultList = await VideoBlacklistModel.listForApi(req.query.start, req.query.count, req.query.sort)
+  const resultList = await VideoBlacklistModel.listForApi(req.query.start, req.query.count, req.query.sort, req.query.type)
 
   return res.json(getFormattedObjects<VideoBlacklist, VideoBlacklistModel>(resultList.data, resultList.total))
 }
 
 async function removeVideoFromBlacklistController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const videoBlacklist = res.locals.videoBlacklist as VideoBlacklistModel
-  const video: VideoModel = res.locals.video
+  const videoBlacklist = res.locals.videoBlacklist
+  const video = res.locals.video
 
-  await sequelizeTypescript.transaction(async t => {
+  const videoBlacklistType = await sequelizeTypescript.transaction(async t => {
     const unfederated = videoBlacklist.unfederated
+    const videoBlacklistType = videoBlacklist.type
+
     await videoBlacklist.destroy({ transaction: t })
 
     // Re federate the video
     if (unfederated === true) {
       await federateVideoIfNeeded(video, true, t)
     }
+
+    return videoBlacklistType
   })
 
   Notifier.Instance.notifyOnVideoUnblacklist(video)
 
+  if (videoBlacklistType === VideoBlacklistType.AUTO_BEFORE_PUBLISHED) {
+    Notifier.Instance.notifyOnVideoPublishedAfterRemovedFromAutoBlacklist(video)
+
+    // Delete on object so new video notifications will send
+    delete video.VideoBlacklist
+    Notifier.Instance.notifyOnNewVideo(video)
+  }
+
   logger.info('Video %s removed from blacklist.', res.locals.video.uuid)
 
   return res.type('json').status(204).end()
diff --git a/server/controllers/api/videos/captions.ts b/server/controllers/api/videos/captions.ts
index 9b3661368..44c255232 100644
--- a/server/controllers/api/videos/captions.ts
+++ b/server/controllers/api/videos/captions.ts
@@ -2,13 +2,14 @@ import * as express from 'express'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate } from '../../../middlewares'
 import { addVideoCaptionValidator, deleteVideoCaptionValidator, listVideoCaptionsValidator } from '../../../middlewares/validators'
 import { createReqFiles } from '../../../helpers/express-utils'
-import { CONFIG, MIMETYPES, sequelizeTypescript } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { VideoCaptionModel } from '../../../models/video/video-caption'
-import { VideoModel } from '../../../models/video/video'
 import { logger } from '../../../helpers/logger'
 import { federateVideoIfNeeded } from '../../../lib/activitypub'
 import { moveAndProcessCaptionFile } from '../../../helpers/captions-utils'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const reqVideoCaptionAdd = createReqFiles(
   [ 'captionfile' ],
@@ -52,7 +53,7 @@ async function listVideoCaptions (req: express.Request, res: express.Response) {
 
 async function addVideoCaption (req: express.Request, res: express.Response) {
   const videoCaptionPhysicalFile = req.files['captionfile'][0]
-  const video = res.locals.video as VideoModel
+  const video = res.locals.video
 
   const videoCaption = new VideoCaptionModel({
     videoId: video.id,
@@ -74,8 +75,8 @@ async function addVideoCaption (req: express.Request, res: express.Response) {
 }
 
 async function deleteVideoCaption (req: express.Request, res: express.Response) {
-  const video = res.locals.video as VideoModel
-  const videoCaption = res.locals.videoCaption as VideoCaptionModel
+  const video = res.locals.video
+  const videoCaption = res.locals.videoCaption
 
   await sequelizeTypescript.transaction(async t => {
     await videoCaption.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/comment.ts b/server/controllers/api/videos/comment.ts
index 70c1148ba..176ee8bd4 100644
--- a/server/controllers/api/videos/comment.ts
+++ b/server/controllers/api/videos/comment.ts
@@ -8,7 +8,8 @@ import { buildFormattedCommentTree, createVideoComment } from '../../../lib/vide
 import {
   asyncMiddleware,
   asyncRetryTransactionMiddleware,
-  authenticate, optionalAuthenticate,
+  authenticate,
+  optionalAuthenticate,
   paginationValidator,
   setDefaultPagination,
   setDefaultSort
@@ -21,11 +22,9 @@ import {
   removeVideoCommentValidator,
   videoCommentThreadsSortValidator
 } from '../../../middlewares/validators'
-import { VideoModel } from '../../../models/video/video'
 import { VideoCommentModel } from '../../../models/video/video-comment'
 import { auditLoggerFactory, CommentAuditView, getAuditIdFromRes } from '../../../helpers/audit-logger'
 import { AccountModel } from '../../../models/account/account'
-import { UserModel } from '../../../models/account/user'
 import { Notifier } from '../../../lib/notifier'
 
 const auditLogger = auditLoggerFactory('comments')
@@ -70,9 +69,9 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function listVideoThreads (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+async function listVideoThreads (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   let resultList: ResultList<VideoCommentModel>
 
@@ -88,9 +87,9 @@ async function listVideoThreads (req: express.Request, res: express.Response, ne
   return res.json(getFormattedObjects(resultList.data, resultList.total))
 }
 
-async function listVideoThreadComments (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const user: UserModel = res.locals.oauth ? res.locals.oauth.token.User : undefined
+async function listVideoThreadComments (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const user = res.locals.oauth ? res.locals.oauth.token.User : undefined
 
   let resultList: ResultList<VideoCommentModel>
 
@@ -110,7 +109,7 @@ async function addVideoCommentThread (req: express.Request, res: express.Respons
   const videoCommentInfo: VideoCommentCreate = req.body
 
   const comment = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoComment({
       text: videoCommentInfo.text,
@@ -132,7 +131,7 @@ async function addVideoCommentReply (req: express.Request, res: express.Response
   const videoCommentInfo: VideoCommentCreate = req.body
 
   const comment = await sequelizeTypescript.transaction(async t => {
-    const account = await AccountModel.load((res.locals.oauth.token.User as UserModel).Account.id, t)
+    const account = await AccountModel.load(res.locals.oauth.token.User.Account.id, t)
 
     return createVideoComment({
       text: videoCommentInfo.text,
@@ -149,7 +148,7 @@ async function addVideoCommentReply (req: express.Request, res: express.Response
 }
 
 async function removeVideoComment (req: express.Request, res: express.Response) {
-  const videoCommentInstance: VideoCommentModel = res.locals.videoComment
+  const videoCommentInstance = res.locals.videoComment
 
   await sequelizeTypescript.transaction(async t => {
     await videoCommentInstance.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/import.ts b/server/controllers/api/videos/import.ts
index 98366cd82..bfb690906 100644
--- a/server/controllers/api/videos/import.ts
+++ b/server/controllers/api/videos/import.ts
@@ -3,7 +3,7 @@ import * as magnetUtil from 'magnet-uri'
 import 'multer'
 import { auditLoggerFactory, getAuditIdFromRes, VideoImportAuditView } from '../../../helpers/audit-logger'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoImportAddValidator } from '../../../middlewares'
-import { CONFIG, MIMETYPES, PREVIEWS_SIZE, sequelizeTypescript, THUMBNAILS_SIZE } from '../../../initializers'
+import { MIMETYPES } from '../../../initializers/constants'
 import { getYoutubeDLInfo, YoutubeDLInfo } from '../../../helpers/youtube-dl'
 import { createReqFiles } from '../../../helpers/express-utils'
 import { logger } from '../../../helpers/logger'
@@ -13,15 +13,19 @@ import { getVideoActivityPubUrl } from '../../../lib/activitypub'
 import { TagModel } from '../../../models/video/tag'
 import { VideoImportModel } from '../../../models/video/video-import'
 import { JobQueue } from '../../../lib/job-queue/job-queue'
-import { processImage } from '../../../helpers/image-utils'
 import { join } from 'path'
 import { isArray } from '../../../helpers/custom-validators/misc'
-import { FilteredModelAttributes } from 'sequelize-typescript/lib/models/Model'
 import { VideoChannelModel } from '../../../models/video/video-channel'
 import * as Bluebird from 'bluebird'
 import * as parseTorrent from 'parse-torrent'
 import { getSecureTorrentName } from '../../../helpers/utils'
-import { readFile, move } from 'fs-extra'
+import { move, readFile } from 'fs-extra'
+import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { createVideoMiniatureFromExisting } from '../../../lib/thumbnail'
+import { ThumbnailType } from '../../../../shared/models/videos/thumbnail.type'
+import { ThumbnailModel } from '../../../models/video/thumbnail'
 
 const auditLogger = auditLoggerFactory('video-imports')
 const videoImportsRouter = express.Router()
@@ -87,8 +91,8 @@ async function addTorrentImport (req: express.Request, res: express.Response, to
 
   const video = buildVideo(res.locals.videoChannel.id, body, { name: videoName })
 
-  await processThumbnail(req, video)
-  await processPreview(req, video)
+  const thumbnailModel = await processThumbnail(req, video)
+  const previewModel = await processPreview(req, video)
 
   const tags = body.tags || undefined
   const videoImportAttributes = {
@@ -97,7 +101,14 @@ async function addTorrentImport (req: express.Request, res: express.Response, to
     state: VideoImportState.PENDING,
     userId: user.id
   }
-  const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
+  const videoImport = await insertIntoDB({
+    video,
+    thumbnailModel,
+    previewModel,
+    videoChannel: res.locals.videoChannel,
+    tags,
+    videoImportAttributes
+  })
 
   // Create job to import the video
   const payload = {
@@ -130,8 +141,8 @@ async function addYoutubeDLImport (req: express.Request, res: express.Response)
 
   const video = buildVideo(res.locals.videoChannel.id, body, youtubeDLInfo)
 
-  const downloadThumbnail = !await processThumbnail(req, video)
-  const downloadPreview = !await processPreview(req, video)
+  const thumbnailModel = await processThumbnail(req, video)
+  const previewModel = await processPreview(req, video)
 
   const tags = body.tags || youtubeDLInfo.tags
   const videoImportAttributes = {
@@ -139,15 +150,22 @@ async function addYoutubeDLImport (req: express.Request, res: express.Response)
     state: VideoImportState.PENDING,
     userId: user.id
   }
-  const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
+  const videoImport = await insertIntoDB({
+    video: video,
+    thumbnailModel,
+    previewModel,
+    videoChannel: res.locals.videoChannel,
+    tags,
+    videoImportAttributes
+  })
 
   // Create job to import the video
   const payload = {
     type: 'youtube-dl' as 'youtube-dl',
     videoImportId: videoImport.id,
     thumbnailUrl: youtubeDLInfo.thumbnailUrl,
-    downloadThumbnail,
-    downloadPreview
+    downloadThumbnail: !thumbnailModel,
+    downloadPreview: !previewModel
   }
   await JobQueue.Instance.createJob({ type: 'video-import', payload })
 
@@ -164,6 +182,7 @@ function buildVideo (channelId: number, body: VideoImportCreate, importData: You
     licence: body.licence || importData.licence,
     language: body.language || undefined,
     commentsEnabled: body.commentsEnabled || true,
+    downloadEnabled: body.downloadEnabled || true,
     waitTranscoding: body.waitTranscoding || false,
     state: VideoState.TO_IMPORT,
     nsfw: body.nsfw || importData.nsfw || false,
@@ -171,7 +190,8 @@ function buildVideo (channelId: number, body: VideoImportCreate, importData: You
     support: body.support || null,
     privacy: body.privacy || VideoPrivacy.PRIVATE,
     duration: 0, // duration will be set by the import job
-    channelId: channelId
+    channelId: channelId,
+    originallyPublishedAt: importData.originallyPublishedAt
   }
   const video = new VideoModel(videoData)
   video.url = getVideoActivityPubUrl(video)
@@ -183,32 +203,34 @@ async function processThumbnail (req: express.Request, video: VideoModel) {
   const thumbnailField = req.files ? req.files['thumbnailfile'] : undefined
   if (thumbnailField) {
     const thumbnailPhysicalFile = thumbnailField[ 0 ]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName()), THUMBNAILS_SIZE)
 
-    return true
+    return createVideoMiniatureFromExisting(thumbnailPhysicalFile.path, video, ThumbnailType.MINIATURE)
   }
 
-  return false
+  return undefined
 }
 
 async function processPreview (req: express.Request, video: VideoModel) {
   const previewField = req.files ? req.files['previewfile'] : undefined
   if (previewField) {
     const previewPhysicalFile = previewField[0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName()), PREVIEWS_SIZE)
 
-    return true
+    return createVideoMiniatureFromExisting(previewPhysicalFile.path, video, ThumbnailType.PREVIEW)
   }
 
-  return false
+  return undefined
 }
 
-function insertIntoDB (
+function insertIntoDB (parameters: {
   video: VideoModel,
+  thumbnailModel: ThumbnailModel,
+  previewModel: ThumbnailModel,
   videoChannel: VideoChannelModel,
   tags: string[],
-  videoImportAttributes: FilteredModelAttributes<VideoImportModel>
-): Bluebird<VideoImportModel> {
+  videoImportAttributes: Partial<VideoImportModel>
+}): Bluebird<VideoImportModel> {
+  let { video, thumbnailModel, previewModel, videoChannel, tags, videoImportAttributes } = parameters
+
   return sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
 
@@ -216,6 +238,11 @@ function insertIntoDB (
     const videoCreated = await video.save(sequelizeOptions)
     videoCreated.VideoChannel = videoChannel
 
+    if (thumbnailModel) await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+    if (previewModel) await videoCreated.addAndSaveThumbnail(previewModel, t)
+
+    await autoBlacklistVideoIfNeeded(video, videoChannel.Account.User, t)
+
     // Set tags to the video
     if (tags) {
       const tagInstances = await TagModel.findOrCreateTags(tags, t)
diff --git a/server/controllers/api/videos/index.ts b/server/controllers/api/videos/index.ts
index 2b2dfa7ca..1a18a8ae8 100644
--- a/server/controllers/api/videos/index.ts
+++ b/server/controllers/api/videos/index.ts
@@ -2,28 +2,17 @@ import * as express from 'express'
 import { extname, join } from 'path'
 import { VideoCreate, VideoPrivacy, VideoState, VideoUpdate } from '../../../../shared'
 import { getVideoFileFPS, getVideoFileResolution } from '../../../helpers/ffmpeg-utils'
-import { processImage } from '../../../helpers/image-utils'
 import { logger } from '../../../helpers/logger'
 import { auditLoggerFactory, getAuditIdFromRes, VideoAuditView } from '../../../helpers/audit-logger'
 import { getFormattedObjects, getServerActor } from '../../../helpers/utils'
-import {
-  CONFIG,
-  MIMETYPES,
-  PREVIEWS_SIZE,
-  sequelizeTypescript,
-  THUMBNAILS_SIZE,
-  VIDEO_CATEGORIES,
-  VIDEO_LANGUAGES,
-  VIDEO_LICENCES,
-  VIDEO_PRIVACIES
-} from '../../../initializers'
+import { autoBlacklistVideoIfNeeded } from '../../../lib/video-blacklist'
+import { MIMETYPES, VIDEO_CATEGORIES, VIDEO_LANGUAGES, VIDEO_LICENCES, VIDEO_PRIVACIES } from '../../../initializers/constants'
 import {
   changeVideoChannelShare,
   federateVideoIfNeeded,
   fetchRemoteVideoDescription,
   getVideoActivityPubUrl
 } from '../../../lib/activitypub'
-import { sendCreateView } from '../../../lib/activitypub/send'
 import { JobQueue } from '../../../lib/job-queue'
 import { Redis } from '../../../lib/redis'
 import {
@@ -37,6 +26,7 @@ import {
   setDefaultPagination,
   setDefaultSort,
   videosAddValidator,
+  videosCustomGetValidator,
   videosGetValidator,
   videosRemoveValidator,
   videosSortValidator,
@@ -59,6 +49,11 @@ import { resetSequelizeInstance } from '../../../helpers/database-utils'
 import { move } from 'fs-extra'
 import { watchingRouter } from './watching'
 import { Notifier } from '../../../lib/notifier'
+import { sendView } from '../../../lib/activitypub/send/send-view'
+import { CONFIG } from '../../../initializers/config'
+import { sequelizeTypescript } from '../../../initializers/database'
+import { createVideoMiniatureFromExisting, generateVideoMiniature } from '../../../lib/thumbnail'
+import { ThumbnailType } from '../../../../shared/models/videos/thumbnail.type'
 
 const auditLogger = auditLoggerFactory('videos')
 const videosRouter = express.Router()
@@ -123,9 +118,9 @@ videosRouter.get('/:id/description',
 )
 videosRouter.get('/:id',
   optionalAuthenticate,
-  asyncMiddleware(videosGetValidator),
+  asyncMiddleware(videosCustomGetValidator('only-video-with-rights')),
   asyncMiddleware(checkVideoFollowConstraints),
-  getVideo
+  asyncMiddleware(getVideo)
 )
 videosRouter.post('/:id/views',
   asyncMiddleware(videosGetValidator),
@@ -181,15 +176,18 @@ async function addVideo (req: express.Request, res: express.Response) {
     licence: videoInfo.licence,
     language: videoInfo.language,
     commentsEnabled: videoInfo.commentsEnabled || false,
+    downloadEnabled: videoInfo.downloadEnabled || true,
     waitTranscoding: videoInfo.waitTranscoding || false,
     state: CONFIG.TRANSCODING.ENABLED ? VideoState.TO_TRANSCODE : VideoState.PUBLISHED,
     nsfw: videoInfo.nsfw || false,
     description: videoInfo.description,
     support: videoInfo.support,
-    privacy: videoInfo.privacy,
+    privacy: videoInfo.privacy || VideoPrivacy.PRIVATE,
     duration: videoPhysicalFile['duration'], // duration was added by a previous middleware
-    channelId: res.locals.videoChannel.id
+    channelId: res.locals.videoChannel.id,
+    originallyPublishedAt: videoInfo.originallyPublishedAt
   }
+
   const video = new VideoModel(videoData)
   video.url = getVideoActivityPubUrl(video) // We use the UUID, so set the URL after building the object
 
@@ -215,29 +213,27 @@ async function addVideo (req: express.Request, res: express.Response) {
 
   // Process thumbnail or create it from the video
   const thumbnailField = req.files['thumbnailfile']
-  if (thumbnailField) {
-    const thumbnailPhysicalFile = thumbnailField[0]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, video.getThumbnailName()), THUMBNAILS_SIZE)
-  } else {
-    await video.createThumbnail(videoFile)
-  }
+  const thumbnailModel = thumbnailField
+    ? await createVideoMiniatureFromExisting(thumbnailField[0].path, video, ThumbnailType.MINIATURE)
+    : await generateVideoMiniature(video, videoFile, ThumbnailType.MINIATURE)
 
   // Process preview or create it from the video
   const previewField = req.files['previewfile']
-  if (previewField) {
-    const previewPhysicalFile = previewField[0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, video.getPreviewName()), PREVIEWS_SIZE)
-  } else {
-    await video.createPreview(videoFile)
-  }
+  const previewModel = previewField
+    ? await createVideoMiniatureFromExisting(previewField[0].path, video, ThumbnailType.PREVIEW)
+    : await generateVideoMiniature(video, videoFile, ThumbnailType.PREVIEW)
 
   // Create the torrent file
   await video.createTorrentAndSetInfoHash(videoFile)
 
-  const videoCreated = await sequelizeTypescript.transaction(async t => {
+  const { videoCreated, videoWasAutoBlacklisted } = await sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
 
     const videoCreated = await video.save(sequelizeOptions)
+
+    await videoCreated.addAndSaveThumbnail(thumbnailModel, t)
+    await videoCreated.addAndSaveThumbnail(previewModel, t)
+
     // Do not forget to add video channel information to the created video
     videoCreated.VideoChannel = res.locals.videoChannel
 
@@ -263,15 +259,23 @@ async function addVideo (req: express.Request, res: express.Response) {
       }, { transaction: t })
     }
 
-    await federateVideoIfNeeded(video, true, t)
+    const videoWasAutoBlacklisted = await autoBlacklistVideoIfNeeded(video, res.locals.oauth.token.User, t)
+
+    if (!videoWasAutoBlacklisted) {
+      await federateVideoIfNeeded(video, true, t)
+    }
 
     auditLogger.create(getAuditIdFromRes(res), new VideoAuditView(videoCreated.toFormattedDetailsJSON()))
     logger.info('Video with name %s and uuid %s created.', videoInfo.name, videoCreated.uuid)
 
-    return videoCreated
+    return { videoCreated, videoWasAutoBlacklisted }
   })
 
-  Notifier.Instance.notifyOnNewVideo(videoCreated)
+  if (videoWasAutoBlacklisted) {
+    Notifier.Instance.notifyOnVideoAutoBlacklist(videoCreated)
+  } else {
+    Notifier.Instance.notifyOnNewVideo(videoCreated)
+  }
 
   if (video.state === VideoState.TO_TRANSCODE) {
     // Put uuid because we don't have id auto incremented for now
@@ -280,7 +284,7 @@ async function addVideo (req: express.Request, res: express.Response) {
       isNewVideo: true
     }
 
-    await JobQueue.Instance.createJob({ type: 'video-file', payload: dataInput })
+    await JobQueue.Instance.createJob({ type: 'video-transcoding', payload: dataInput })
   }
 
   return res.json({
@@ -292,7 +296,7 @@ async function addVideo (req: express.Request, res: express.Response) {
 }
 
 async function updateVideo (req: express.Request, res: express.Response) {
-  const videoInstance: VideoModel = res.locals.video
+  const videoInstance = res.locals.video
   const videoFieldsSave = videoInstance.toJSON()
   const oldVideoAuditView = new VideoAuditView(videoInstance.toFormattedDetailsJSON())
   const videoInfoToUpdate: VideoUpdate = req.body
@@ -300,16 +304,13 @@ async function updateVideo (req: express.Request, res: express.Response) {
   const wasUnlistedVideo = videoInstance.privacy === VideoPrivacy.UNLISTED
 
   // Process thumbnail or create it from the video
-  if (req.files && req.files['thumbnailfile']) {
-    const thumbnailPhysicalFile = req.files['thumbnailfile'][0]
-    await processImage(thumbnailPhysicalFile, join(CONFIG.STORAGE.THUMBNAILS_DIR, videoInstance.getThumbnailName()), THUMBNAILS_SIZE)
-  }
+  const thumbnailModel = req.files && req.files['thumbnailfile']
+    ? await createVideoMiniatureFromExisting(req.files['thumbnailfile'][0].path, videoInstance, ThumbnailType.MINIATURE)
+    : undefined
 
-  // Process preview or create it from the video
-  if (req.files && req.files['previewfile']) {
-    const previewPhysicalFile = req.files['previewfile'][0]
-    await processImage(previewPhysicalFile, join(CONFIG.STORAGE.PREVIEWS_DIR, videoInstance.getPreviewName()), PREVIEWS_SIZE)
-  }
+  const previewModel = req.files && req.files['previewfile']
+    ? await createVideoMiniatureFromExisting(req.files['previewfile'][0].path, videoInstance, ThumbnailType.PREVIEW)
+    : undefined
 
   try {
     const videoInstanceUpdated = await sequelizeTypescript.transaction(async t => {
@@ -325,17 +326,26 @@ async function updateVideo (req: express.Request, res: express.Response) {
       if (videoInfoToUpdate.support !== undefined) videoInstance.set('support', videoInfoToUpdate.support)
       if (videoInfoToUpdate.description !== undefined) videoInstance.set('description', videoInfoToUpdate.description)
       if (videoInfoToUpdate.commentsEnabled !== undefined) videoInstance.set('commentsEnabled', videoInfoToUpdate.commentsEnabled)
+      if (videoInfoToUpdate.downloadEnabled !== undefined) videoInstance.set('downloadEnabled', videoInfoToUpdate.downloadEnabled)
+
+      if (videoInfoToUpdate.originallyPublishedAt !== undefined && videoInfoToUpdate.originallyPublishedAt !== null) {
+        videoInstance.originallyPublishedAt = new Date(videoInfoToUpdate.originallyPublishedAt)
+      }
+
       if (videoInfoToUpdate.privacy !== undefined) {
         const newPrivacy = parseInt(videoInfoToUpdate.privacy.toString(), 10)
-        videoInstance.set('privacy', newPrivacy)
+        videoInstance.privacy = newPrivacy
 
         if (wasPrivateVideo === true && newPrivacy !== VideoPrivacy.PRIVATE) {
-          videoInstance.set('publishedAt', new Date())
+          videoInstance.publishedAt = new Date()
         }
       }
 
       const videoInstanceUpdated = await videoInstance.save(sequelizeOptions)
 
+      if (thumbnailModel) await videoInstanceUpdated.addAndSaveThumbnail(thumbnailModel, t)
+      if (previewModel) await videoInstanceUpdated.addAndSaveThumbnail(previewModel, t)
+
       // Video tags update?
       if (videoInfoToUpdate.tags !== undefined) {
         const tagInstances = await TagModel.findOrCreateTags(videoInfoToUpdate.tags, t)
@@ -395,22 +405,24 @@ async function updateVideo (req: express.Request, res: express.Response) {
   return res.type('json').status(204).end()
 }
 
-function getVideo (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video
+async function getVideo (req: express.Request, res: express.Response) {
+  // We need more attributes
+  const userId: number = res.locals.oauth ? res.locals.oauth.token.User.id : null
+  const video = await VideoModel.loadForGetAPI(res.locals.video.id, undefined, userId)
 
-  if (videoInstance.isOutdated()) {
-    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', url: videoInstance.url } })
-      .catch(err => logger.error('Cannot create AP refresher job for video %s.', videoInstance.url, { err }))
+  if (video.isOutdated()) {
+    JobQueue.Instance.createJob({ type: 'activitypub-refresher', payload: { type: 'video', url: video.url } })
+      .catch(err => logger.error('Cannot create AP refresher job for video %s.', video.url, { err }))
   }
 
-  return res.json(videoInstance.toFormattedDetailsJSON())
+  return res.json(video.toFormattedDetailsJSON())
 }
 
 async function viewVideo (req: express.Request, res: express.Response) {
   const videoInstance = res.locals.video
 
   const ip = req.ip
-  const exists = await Redis.Instance.isVideoIPViewExists(ip, videoInstance.uuid)
+  const exists = await Redis.Instance.doesVideoIPViewExist(ip, videoInstance.uuid)
   if (exists) {
     logger.debug('View for ip %s and video %s already exists.', ip, videoInstance.uuid)
     return res.status(204).end()
@@ -422,7 +434,7 @@ async function viewVideo (req: express.Request, res: express.Response) {
   ])
 
   const serverActor = await getServerActor()
-  await sendCreateView(serverActor, videoInstance, undefined)
+  await sendView(serverActor, videoInstance, undefined)
 
   return res.status(204).end()
 }
@@ -461,7 +473,7 @@ async function listVideos (req: express.Request, res: express.Response) {
 }
 
 async function removeVideo (req: express.Request, res: express.Response) {
-  const videoInstance: VideoModel = res.locals.video
+  const videoInstance = res.locals.video
 
   await sequelizeTypescript.transaction(async t => {
     await videoInstance.destroy({ transaction: t })
diff --git a/server/controllers/api/videos/ownership.ts b/server/controllers/api/videos/ownership.ts
index 5ea7d7c6a..5272c1385 100644
--- a/server/controllers/api/videos/ownership.ts
+++ b/server/controllers/api/videos/ownership.ts
@@ -11,15 +11,13 @@ import {
   videosChangeOwnershipValidator,
   videosTerminateChangeOwnershipValidator
 } from '../../../middlewares'
-import { AccountModel } from '../../../models/account/account'
-import { VideoModel } from '../../../models/video/video'
 import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
 import { VideoChangeOwnershipStatus, VideoPrivacy, VideoState } from '../../../../shared/models/videos'
 import { VideoChannelModel } from '../../../models/video/video-channel'
 import { getFormattedObjects } from '../../../helpers/utils'
 import { changeVideoChannelShare } from '../../../lib/activitypub'
 import { sendUpdateVideo } from '../../../lib/activitypub/send'
-import { UserModel } from '../../../models/account/user'
+import { VideoModel } from '../../../models/video/video'
 
 const ownershipVideoRouter = express.Router()
 
@@ -58,9 +56,9 @@ export {
 // ---------------------------------------------------------------------------
 
 async function giveVideoOwnership (req: express.Request, res: express.Response) {
-  const videoInstance = res.locals.video as VideoModel
-  const initiatorAccountId = (res.locals.oauth.token.User as UserModel).Account.id
-  const nextOwner = res.locals.nextOwner as AccountModel
+  const videoInstance = res.locals.video
+  const initiatorAccountId = res.locals.oauth.token.User.Account.id
+  const nextOwner = res.locals.nextOwner
 
   await sequelizeTypescript.transaction(t => {
     return VideoChangeOwnershipModel.findOrCreate({
@@ -85,7 +83,7 @@ async function giveVideoOwnership (req: express.Request, res: express.Response)
 }
 
 async function listVideoOwnership (req: express.Request, res: express.Response) {
-  const currentAccountId = (res.locals.oauth.token.User as UserModel).Account.id
+  const currentAccountId = res.locals.oauth.token.User.Account.id
 
   const resultList = await VideoChangeOwnershipModel.listForApi(
     currentAccountId,
@@ -99,13 +97,16 @@ async function listVideoOwnership (req: express.Request, res: express.Response)
 
 async function acceptOwnership (req: express.Request, res: express.Response) {
   return sequelizeTypescript.transaction(async t => {
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
-    const targetVideo = videoChangeOwnership.Video
-    const channel = res.locals.videoChannel as VideoChannelModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
+    const channel = res.locals.videoChannel
+
+    // We need more attributes for federation
+    const targetVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoChangeOwnership.Video.id)
 
     const oldVideoChannel = await VideoChannelModel.loadByIdAndPopulateAccount(targetVideo.channelId)
 
-    targetVideo.set('channelId', channel.id)
+    targetVideo.channelId = channel.id
+
     const targetVideoUpdated = await targetVideo.save({ transaction: t })
     targetVideoUpdated.VideoChannel = channel
 
@@ -114,7 +115,7 @@ async function acceptOwnership (req: express.Request, res: express.Response) {
       await sendUpdateVideo(targetVideoUpdated, t, oldVideoChannel.Account.Actor)
     }
 
-    videoChangeOwnership.set('status', VideoChangeOwnershipStatus.ACCEPTED)
+    videoChangeOwnership.status = VideoChangeOwnershipStatus.ACCEPTED
     await videoChangeOwnership.save({ transaction: t })
 
     return res.sendStatus(204)
@@ -123,9 +124,9 @@ async function acceptOwnership (req: express.Request, res: express.Response) {
 
 async function refuseOwnership (req: express.Request, res: express.Response) {
   return sequelizeTypescript.transaction(async t => {
-    const videoChangeOwnership = res.locals.videoChangeOwnership as VideoChangeOwnershipModel
+    const videoChangeOwnership = res.locals.videoChangeOwnership
 
-    videoChangeOwnership.set('status', VideoChangeOwnershipStatus.REFUSED)
+    videoChangeOwnership.status = VideoChangeOwnershipStatus.REFUSED
     await videoChangeOwnership.save({ transaction: t })
 
     return res.sendStatus(204)
diff --git a/server/controllers/api/videos/rate.ts b/server/controllers/api/videos/rate.ts
index 53952a0a2..b65babedf 100644
--- a/server/controllers/api/videos/rate.ts
+++ b/server/controllers/api/videos/rate.ts
@@ -1,12 +1,12 @@
 import * as express from 'express'
 import { UserVideoRateUpdate } from '../../../../shared'
 import { logger } from '../../../helpers/logger'
-import { sequelizeTypescript, VIDEO_RATE_TYPES } from '../../../initializers'
+import { VIDEO_RATE_TYPES } from '../../../initializers/constants'
 import { getRateUrl, sendVideoRateChange } from '../../../lib/activitypub'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoUpdateRateValidator } from '../../../middlewares'
 import { AccountModel } from '../../../models/account/account'
 import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
-import { VideoModel } from '../../../models/video/video'
+import { sequelizeTypescript } from '../../../initializers/database'
 
 const rateVideoRouter = express.Router()
 
@@ -27,8 +27,8 @@ export {
 async function rateVideo (req: express.Request, res: express.Response) {
   const body: UserVideoRateUpdate = req.body
   const rateType = body.rating
-  const videoInstance: VideoModel = res.locals.video
-  const userAccount: AccountModel = res.locals.oauth.token.User.Account
+  const videoInstance = res.locals.video
+  const userAccount = res.locals.oauth.token.User.Account
 
   await sequelizeTypescript.transaction(async t => {
     const sequelizeOptions = { transaction: t }
diff --git a/server/controllers/api/videos/watching.ts b/server/controllers/api/videos/watching.ts
index e8876b47a..dcd1f070d 100644
--- a/server/controllers/api/videos/watching.ts
+++ b/server/controllers/api/videos/watching.ts
@@ -2,7 +2,6 @@ import * as express from 'express'
 import { UserWatchingVideo } from '../../../../shared'
 import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoWatchingValidator } from '../../../middlewares'
 import { UserVideoHistoryModel } from '../../../models/account/user-video-history'
-import { UserModel } from '../../../models/account/user'
 
 const watchingRouter = express.Router()
 
@@ -21,7 +20,7 @@ export {
 // ---------------------------------------------------------------------------
 
 async function userWatchVideo (req: express.Request, res: express.Response) {
-  const user = res.locals.oauth.token.User as UserModel
+  const user = res.locals.oauth.token.User
 
   const body: UserWatchingVideo = req.body
   const { id: videoId } = res.locals.video as { id: number }
diff --git a/server/controllers/bots.ts b/server/controllers/bots.ts
index 2db86a2d8..e25d9c21b 100644
--- a/server/controllers/bots.ts
+++ b/server/controllers/bots.ts
@@ -1,6 +1,6 @@
 import * as express from 'express'
 import { asyncMiddleware } from '../middlewares'
-import { CONFIG, ROUTE_CACHE_LIFETIME } from '../initializers'
+import { ROUTE_CACHE_LIFETIME, WEBSERVER } from '../initializers/constants'
 import * as sitemapModule from 'sitemap'
 import { logger } from '../helpers/logger'
 import { VideoModel } from '../models/video/video'
@@ -35,7 +35,7 @@ async function getSitemap (req: express.Request, res: express.Response) {
   urls = urls.concat(await getSitemapAccountUrls())
 
   const sitemap = sitemapModule.createSitemap({
-    hostname: CONFIG.WEBSERVER.URL,
+    hostname: WEBSERVER.URL,
     urls: urls
   })
 
@@ -54,7 +54,7 @@ async function getSitemapVideoChannelUrls () {
   const rows = await VideoChannelModel.listLocalsForSitemap('createdAt')
 
   return rows.map(channel => ({
-    url: CONFIG.WEBSERVER.URL + '/video-channels/' + channel.Actor.preferredUsername
+    url: WEBSERVER.URL + '/video-channels/' + channel.Actor.preferredUsername
   }))
 }
 
@@ -62,7 +62,7 @@ async function getSitemapAccountUrls () {
   const rows = await AccountModel.listLocalsForSitemap('createdAt')
 
   return rows.map(channel => ({
-    url: CONFIG.WEBSERVER.URL + '/accounts/' + channel.Actor.preferredUsername
+    url: WEBSERVER.URL + '/accounts/' + channel.Actor.preferredUsername
   }))
 }
 
@@ -78,14 +78,14 @@ async function getSitemapLocalVideoUrls () {
   })
 
   return resultList.data.map(v => ({
-    url: CONFIG.WEBSERVER.URL + '/videos/watch/' + v.uuid,
+    url: WEBSERVER.URL + '/videos/watch/' + v.uuid,
     video: [
       {
         title: v.name,
         // Sitemap description should be < 2000 characters
         description: truncate(v.description || v.name, { length: 2000, omission: '...' }),
-        player_loc: CONFIG.WEBSERVER.URL + '/videos/embed/' + v.uuid,
-        thumbnail_loc: CONFIG.WEBSERVER.URL + v.getThumbnailStaticPath()
+        player_loc: WEBSERVER.URL + '/videos/embed/' + v.uuid,
+        thumbnail_loc: WEBSERVER.URL + v.getMiniatureStaticPath()
       }
     ]
   }))
@@ -97,5 +97,5 @@ function getSitemapBasicUrls () {
     '/videos/local'
   ]
 
-  return paths.map(p => ({ url: CONFIG.WEBSERVER.URL + p }))
+  return paths.map(p => ({ url: WEBSERVER.URL + p }))
 }
diff --git a/server/controllers/client.ts b/server/controllers/client.ts
index f17f2a5d2..f51470b41 100644
--- a/server/controllers/client.ts
+++ b/server/controllers/client.ts
@@ -1,7 +1,7 @@
 import * as express from 'express'
 import { join } from 'path'
 import { root } from '../helpers/core-utils'
-import { ACCEPT_HEADERS, STATIC_MAX_AGE } from '../initializers'
+import { ACCEPT_HEADERS, STATIC_MAX_AGE } from '../initializers/constants'
 import { asyncMiddleware, embedCSP } from '../middlewares'
 import { buildFileLocale, getCompleteLocale, is18nLocale, LOCALE_FILES } from '../../shared/models/i18n/i18n'
 import { ClientHtml } from '../lib/client-html'
@@ -17,6 +17,8 @@ const testEmbedPath = join(distPath, 'standalone', 'videos', 'test-embed.html')
 // Special route that add OpenGraph and oEmbed tags
 // Do not use a template engine for a so little thing
 clientsRouter.use('/videos/watch/:id', asyncMiddleware(generateWatchHtmlPage))
+clientsRouter.use('/accounts/:nameWithHost', asyncMiddleware(generateAccountHtmlPage))
+clientsRouter.use('/video-channels/:nameWithHost', asyncMiddleware(generateVideoChannelHtmlPage))
 
 clientsRouter.use(
   '/videos/embed',
@@ -99,6 +101,18 @@ async function generateWatchHtmlPage (req: express.Request, res: express.Respons
   return sendHTML(html, res)
 }
 
+async function generateAccountHtmlPage (req: express.Request, res: express.Response) {
+  const html = await ClientHtml.getAccountHTMLPage(req.params.nameWithHost, req, res)
+
+  return sendHTML(html, res)
+}
+
+async function generateVideoChannelHtmlPage (req: express.Request, res: express.Response) {
+  const html = await ClientHtml.getVideoChannelHTMLPage(req.params.nameWithHost, req, res)
+
+  return sendHTML(html, res)
+}
+
 function sendHTML (html: string, res: express.Response) {
   res.set('Content-Type', 'text/html; charset=UTF-8')
 
diff --git a/server/controllers/feeds.ts b/server/controllers/feeds.ts
index 960085af1..d3f581615 100644
--- a/server/controllers/feeds.ts
+++ b/server/controllers/feeds.ts
@@ -1,6 +1,5 @@
 import * as express from 'express'
-import { CONFIG, FEEDS, ROUTE_CACHE_LIFETIME } from '../initializers/constants'
-import { THUMBNAILS_SIZE } from '../initializers'
+import { FEEDS, ROUTE_CACHE_LIFETIME, THUMBNAILS_SIZE, WEBSERVER } from '../initializers/constants'
 import {
   asyncMiddleware,
   commonVideosFiltersValidator,
@@ -11,11 +10,10 @@ import {
 } from '../middlewares'
 import { VideoModel } from '../models/video/video'
 import * as Feed from 'pfeed'
-import { AccountModel } from '../models/account/account'
 import { cacheRoute } from '../middlewares/cache'
-import { VideoChannelModel } from '../models/video/video-channel'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { buildNSFWFilter } from '../helpers/express-utils'
+import { CONFIG } from '../initializers/config'
 
 const feedsRouter = express.Router()
 
@@ -42,10 +40,10 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function generateVideoCommentsFeed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function generateVideoCommentsFeed (req: express.Request, res: express.Response) {
   const start = 0
 
-  const video = res.locals.video as VideoModel
+  const video = res.locals.video
   const videoId: number = video ? video.id : undefined
 
   const comments = await VideoCommentModel.listForFeed(start, FEEDS.COUNT, videoId)
@@ -56,7 +54,7 @@ async function generateVideoCommentsFeed (req: express.Request, res: express.Res
 
   // Adding video items to the feed, one at a time
   comments.forEach(comment => {
-    const link = CONFIG.WEBSERVER.URL + comment.getCommentStaticPath()
+    const link = WEBSERVER.URL + comment.getCommentStaticPath()
 
     feed.addItem({
       title: `${comment.Video.name} - ${comment.Account.getDisplayName()}`,
@@ -77,11 +75,11 @@ async function generateVideoCommentsFeed (req: express.Request, res: express.Res
   return sendFeed(feed, req, res)
 }
 
-async function generateVideoFeed (req: express.Request, res: express.Response, next: express.NextFunction) {
+async function generateVideoFeed (req: express.Request, res: express.Response) {
   const start = 0
 
-  const account: AccountModel = res.locals.account
-  const videoChannel: VideoChannelModel = res.locals.videoChannel
+  const account = res.locals.account
+  const videoChannel = res.locals.videoChannel
   const nsfw = buildNSFWFilter(res, req.query.nsfw)
 
   let name: string
@@ -124,7 +122,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
     feed.addItem({
       title: video.name,
       id: video.url,
-      link: CONFIG.WEBSERVER.URL + '/videos/watch/' + video.uuid,
+      link: WEBSERVER.URL + '/videos/watch/' + video.uuid,
       description: video.getTruncatedDescription(),
       content: video.description,
       author: [
@@ -139,7 +137,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
       torrent: torrents,
       thumbnail: [
         {
-          url: CONFIG.WEBSERVER.URL + video.getThumbnailStaticPath(),
+          url: WEBSERVER.URL + video.getMiniatureStaticPath(),
           height: THUMBNAILS_SIZE.height,
           width: THUMBNAILS_SIZE.width
         }
@@ -152,7 +150,7 @@ async function generateVideoFeed (req: express.Request, res: express.Response, n
 }
 
 function initFeed (name: string, description: string) {
-  const webserverUrl = CONFIG.WEBSERVER.URL
+  const webserverUrl = WEBSERVER.URL
 
   return new Feed({
     title: name,
diff --git a/server/controllers/services.ts b/server/controllers/services.ts
index 352d0b19a..c1c53c3fc 100644
--- a/server/controllers/services.ts
+++ b/server/controllers/services.ts
@@ -1,8 +1,7 @@
 import * as express from 'express'
-import { CONFIG, EMBED_SIZE, PREVIEWS_SIZE } from '../initializers'
+import { EMBED_SIZE, PREVIEWS_SIZE, WEBSERVER } from '../initializers/constants'
 import { asyncMiddleware, oembedValidator } from '../middlewares'
-import { accountsNameWithHostGetValidator } from '../middlewares/validators'
-import { VideoModel } from '../models/video/video'
+import { accountNameWithHostGetValidator } from '../middlewares/validators'
 
 const servicesRouter = express.Router()
 
@@ -11,7 +10,7 @@ servicesRouter.use('/oembed',
   generateOEmbed
 )
 servicesRouter.use('/redirect/accounts/:accountName',
-  asyncMiddleware(accountsNameWithHostGetValidator),
+  asyncMiddleware(accountNameWithHostGetValidator),
   redirectToAccountUrl
 )
 
@@ -23,9 +22,9 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function generateOEmbed (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const video = res.locals.video as VideoModel
-  const webserverUrl = CONFIG.WEBSERVER.URL
+function generateOEmbed (req: express.Request, res: express.Response) {
+  const video = res.locals.video
+  const webserverUrl = WEBSERVER.URL
   const maxHeight = parseInt(req.query.maxheight, 10)
   const maxWidth = parseInt(req.query.maxwidth, 10)
 
diff --git a/server/controllers/static.ts b/server/controllers/static.ts
index 4fd58f70c..05019fcc2 100644
--- a/server/controllers/static.ts
+++ b/server/controllers/static.ts
@@ -1,16 +1,23 @@
 import * as cors from 'cors'
 import * as express from 'express'
-import { CONFIG, ROUTE_CACHE_LIFETIME, STATIC_DOWNLOAD_PATHS, STATIC_MAX_AGE, STATIC_PATHS } from '../initializers'
-import { VideosPreviewCache } from '../lib/cache'
+import {
+  HLS_STREAMING_PLAYLIST_DIRECTORY,
+  ROUTE_CACHE_LIFETIME,
+  STATIC_DOWNLOAD_PATHS,
+  STATIC_MAX_AGE,
+  STATIC_PATHS,
+  WEBSERVER
+} from '../initializers/constants'
+import { VideosCaptionCache, VideosPreviewCache } from '../lib/files-cache'
 import { cacheRoute } from '../middlewares/cache'
 import { asyncMiddleware, videosGetValidator } from '../middlewares'
 import { VideoModel } from '../models/video/video'
-import { VideosCaptionCache } from '../lib/cache/videos-caption-cache'
 import { UserModel } from '../models/account/user'
 import { VideoCommentModel } from '../models/video/video-comment'
 import { HttpNodeinfoDiasporaSoftwareNsSchema20 } from '../../shared/models/nodeinfo'
 import { join } from 'path'
 import { root } from '../helpers/core-utils'
+import { CONFIG } from '../initializers/config'
 
 const packageJSON = require('../../../package.json')
 const staticRouter = express.Router()
@@ -51,6 +58,13 @@ staticRouter.use(
   asyncMiddleware(downloadVideoFile)
 )
 
+// HLS
+staticRouter.use(
+  STATIC_PATHS.STREAMING_PLAYLISTS.HLS,
+  cors(),
+  express.static(HLS_STREAMING_PLAYLIST_DIRECTORY, { fallthrough: false }) // 404 if the file does not exist
+)
+
 // Thumbnails path for express
 const thumbnailsPhysicalPath = CONFIG.STORAGE.THUMBNAILS_DIR
 staticRouter.use(
@@ -108,7 +122,7 @@ staticRouter.use('/.well-known/nodeinfo',
       links: [
         {
           rel: 'http://nodeinfo.diaspora.software/ns/schema/2.0',
-          href: CONFIG.WEBSERVER.URL + '/nodeinfo/2.0.json'
+          href: WEBSERVER.URL + '/nodeinfo/2.0.json'
         }
       ]
     })
@@ -150,21 +164,21 @@ export {
 
 // ---------------------------------------------------------------------------
 
-async function getPreview (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const path = await VideosPreviewCache.Instance.getFilePath(req.params.uuid)
-  if (!path) return res.sendStatus(404)
+async function getPreview (req: express.Request, res: express.Response) {
+  const result = await VideosPreviewCache.Instance.getFilePath(req.params.uuid)
+  if (!result) return res.sendStatus(404)
 
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE })
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE })
 }
 
 async function getVideoCaption (req: express.Request, res: express.Response) {
-  const path = await VideosCaptionCache.Instance.getFilePath({
+  const result = await VideosCaptionCache.Instance.getFilePath({
     videoId: req.params.videoId,
     language: req.params.captionLanguage
   })
-  if (!path) return res.sendStatus(404)
+  if (!result) return res.sendStatus(404)
 
-  return res.sendFile(path, { maxAge: STATIC_MAX_AGE })
+  return res.sendFile(result.path, { maxAge: STATIC_MAX_AGE })
 }
 
 async function generateNodeinfo (req: express.Request, res: express.Response, next: express.NextFunction) {
@@ -231,7 +245,7 @@ async function downloadVideoFile (req: express.Request, res: express.Response, n
 
 function getVideoAndFile (req: express.Request, res: express.Response) {
   const resolution = parseInt(req.params.resolution, 10)
-  const video: VideoModel = res.locals.video
+  const video = res.locals.video
 
   const videoFile = video.VideoFiles.find(f => f.resolution === resolution)
 
diff --git a/server/controllers/tracker.ts b/server/controllers/tracker.ts
index 1deb8c402..912f82b86 100644
--- a/server/controllers/tracker.ts
+++ b/server/controllers/tracker.ts
@@ -4,9 +4,11 @@ import * as http from 'http'
 import * as bitTorrentTracker from 'bittorrent-tracker'
 import * as proxyAddr from 'proxy-addr'
 import { Server as WebSocketServer } from 'ws'
-import { CONFIG, TRACKER_RATE_LIMITS } from '../initializers/constants'
+import { TRACKER_RATE_LIMITS } from '../initializers/constants'
 import { VideoFileModel } from '../models/video/video-file'
 import { parse } from 'url'
+import { VideoStreamingPlaylistModel } from '../models/video/video-streaming-playlist'
+import { CONFIG } from '../initializers/config'
 
 const TrackerServer = bitTorrentTracker.Server
 
@@ -21,7 +23,11 @@ const trackerServer = new TrackerServer({
   udp: false,
   ws: false,
   dht: false,
-  filter: function (infoHash, params, cb) {
+  filter: async function (infoHash, params, cb) {
+    if (CONFIG.TRACKER.ENABLED === false) {
+      return cb(new Error('Tracker is disabled on this instance.'))
+    }
+
     let ip: string
 
     if (params.type === 'ws') {
@@ -32,29 +38,40 @@ const trackerServer = new TrackerServer({
 
     const key = ip + '-' + infoHash
 
-    peersIps[ip] = peersIps[ip] ? peersIps[ip] + 1 : 1
-    peersIpInfoHash[key] = peersIpInfoHash[key] ? peersIpInfoHash[key] + 1 : 1
+    peersIps[ ip ] = peersIps[ ip ] ? peersIps[ ip ] + 1 : 1
+    peersIpInfoHash[ key ] = peersIpInfoHash[ key ] ? peersIpInfoHash[ key ] + 1 : 1
 
-    if (peersIpInfoHash[key] > TRACKER_RATE_LIMITS.ANNOUNCES_PER_IP_PER_INFOHASH) {
+    if (CONFIG.TRACKER.REJECT_TOO_MANY_ANNOUNCES && peersIpInfoHash[ key ] > TRACKER_RATE_LIMITS.ANNOUNCES_PER_IP_PER_INFOHASH) {
       return cb(new Error(`Too many requests (${peersIpInfoHash[ key ]} of ip ${ip} for torrent ${infoHash}`))
     }
 
-    VideoFileModel.isInfohashExists(infoHash)
-      .then(exists => {
-        if (exists === false) return cb(new Error(`Unknown infoHash ${infoHash}`))
+    try {
+      if (CONFIG.TRACKER.PRIVATE === false) return cb()
+
+      const videoFileExists = await VideoFileModel.doesInfohashExist(infoHash)
+      if (videoFileExists === true) return cb()
 
-        return cb()
-      })
+      const playlistExists = await VideoStreamingPlaylistModel.doesInfohashExist(infoHash)
+      if (playlistExists === true) return cb()
+
+      return cb(new Error(`Unknown infoHash ${infoHash}`))
+    } catch (err) {
+      logger.error('Error in tracker filter.', { err })
+      return cb(err)
+    }
   }
 })
 
-trackerServer.on('error', function (err) {
-  logger.error('Error in tracker.', { err })
-})
+if (CONFIG.TRACKER.ENABLED !== false) {
 
-trackerServer.on('warning', function (err) {
-  logger.warn('Warning in tracker.', { err })
-})
+  trackerServer.on('error', function (err) {
+    logger.error('Error in tracker.', { err })
+  })
+
+  trackerServer.on('warning', function (err) {
+    logger.warn('Warning in tracker.', { err })
+  })
+}
 
 const onHttpRequest = trackerServer.onHttpRequest.bind(trackerServer)
 trackerRouter.get('/tracker/announce', (req, res) => onHttpRequest(req, res, { action: 'announce' }))
diff --git a/server/controllers/webfinger.ts b/server/controllers/webfinger.ts
index ed781c21b..f2ba3c826 100644
--- a/server/controllers/webfinger.ts
+++ b/server/controllers/webfinger.ts
@@ -1,7 +1,6 @@
 import * as express from 'express'
 import { asyncMiddleware } from '../middlewares'
 import { webfingerValidator } from '../middlewares/validators'
-import { ActorModel } from '../models/activitypub/actor'
 
 const webfingerRouter = express.Router()
 
@@ -18,8 +17,8 @@ export {
 
 // ---------------------------------------------------------------------------
 
-function webfingerController (req: express.Request, res: express.Response, next: express.NextFunction) {
-  const actor = res.locals.actor as ActorModel
+function webfingerController (req: express.Request, res: express.Response) {
+  const actor = res.locals.actor
 
   const json = {
     subject: req.query.resource,