Support video views/viewers stats in server

 * Add "currentTime" and "event" body params to view endpoint
 * Merge watching and view endpoints
 * Introduce WatchAction AP activity
 * Add tables to store viewer information of local videos
 * Add endpoints to fetch video views/viewers stats of local videos
 * Refactor views/viewers handlers
 * Support "views" and "viewers" counters for both VOD and live videos

3 files changed, 163 insertions, 41 deletions

diff --git a/server/tests/api/check-params/index.ts b/server/tests/api/check-params/index.ts
index c9adeef4a..259d7e783 100644
--- a/server/tests/api/check-params/index.ts
+++ b/server/tests/api/check-params/index.ts
@@ -33,3 +33,4 @@ import './videos-common-filters'
 import './video-files'
 import './videos-history'
 import './videos-overviews'
+import './views'
diff --git a/server/tests/api/check-params/videos-history.ts b/server/tests/api/check-params/videos-history.ts
index 82f38b7b4..c1b2d8bf3 100644
--- a/server/tests/api/check-params/videos-history.ts
+++ b/server/tests/api/check-params/videos-history.ts
@@ -17,7 +17,7 @@ import {
 describe('Test videos history API validator', function () {
   const myHistoryPath = '/api/v1/users/me/history/videos'
   const myHistoryRemove = myHistoryPath + '/remove'
-  let watchingPath: string
+  let viewPath: string
   let server: PeerTubeServer
   let videoId: number
 
@@ -31,51 +31,15 @@ describe('Test videos history API validator', function () {
     await setAccessTokensToServers([ server ])
 
     const { id, uuid } = await server.videos.upload()
-    watchingPath = '/api/v1/videos/' + uuid + '/watching'
+    viewPath = '/api/v1/videos/' + uuid + '/views'
     videoId = id
   })
 
   describe('When notifying a user is watching a video', function () {
 
-    it('Should fail with an unauthenticated user', async function () {
-      const fields = { currentTime: 5 }
-      await makePutBodyRequest({ url: server.url, path: watchingPath, fields, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
-    })
-
-    it('Should fail with an incorrect video id', async function () {
+    it('Should fail with a bad token', async function () {
       const fields = { currentTime: 5 }
-      const path = '/api/v1/videos/blabla/watching'
-      await makePutBodyRequest({
-        url: server.url,
-        path,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
-    })
-
-    it('Should fail with an unknown video', async function () {
-      const fields = { currentTime: 5 }
-      const path = '/api/v1/videos/d91fff41-c24d-4508-8e13-3bd5902c3b02/watching'
-
-      await makePutBodyRequest({
-        url: server.url,
-        path,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.NOT_FOUND_404
-      })
-    })
-
-    it('Should fail with a bad current time', async function () {
-      const fields = { currentTime: 'hello' }
-      await makePutBodyRequest({
-        url: server.url,
-        path: watchingPath,
-        fields,
-        token: server.accessToken,
-        expectedStatus: HttpStatusCode.BAD_REQUEST_400
-      })
+      await makePutBodyRequest({ url: server.url, path: viewPath, fields, token: 'bad', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
     })
 
     it('Should succeed with the correct parameters', async function () {
@@ -83,7 +47,7 @@ describe('Test videos history API validator', function () {
 
       await makePutBodyRequest({
         url: server.url,
-        path: watchingPath,
+        path: viewPath,
         fields,
         token: server.accessToken,
         expectedStatus: HttpStatusCode.NO_CONTENT_204
diff --git a/server/tests/api/check-params/views.ts b/server/tests/api/check-params/views.ts
new file mode 100644
index 000000000..185b04af1
--- /dev/null
+++ b/server/tests/api/check-params/views.ts
@@ -0,0 +1,157 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import { HttpStatusCode, VideoPrivacy } from '@shared/models'
+import {
+  cleanupTests,
+  createMultipleServers,
+  doubleFollow,
+  PeerTubeServer,
+  setAccessTokensToServers,
+  setDefaultVideoChannel
+} from '@shared/server-commands'
+
+describe('Test videos views', function () {
+  let servers: PeerTubeServer[]
+  let liveVideoId: string
+  let videoId: string
+  let remoteVideoId: string
+  let userAccessToken: string
+
+  before(async function () {
+    this.timeout(30000)
+
+    servers = await createMultipleServers(2)
+    await setAccessTokensToServers(servers)
+    await setDefaultVideoChannel(servers)
+
+    await servers[0].config.enableLive({ allowReplay: false, transcoding: false });
+
+    ({ uuid: videoId } = await servers[0].videos.quickUpload({ name: 'video' }));
+    ({ uuid: remoteVideoId } = await servers[1].videos.quickUpload({ name: 'video' }));
+    ({ uuid: liveVideoId } = await servers[0].live.create({
+      fields: {
+        name: 'live',
+        privacy: VideoPrivacy.PUBLIC,
+        channelId: servers[0].store.channel.id
+      }
+    }))
+
+    userAccessToken = await servers[0].users.generateUserAndToken('user')
+
+    await doubleFollow(servers[0], servers[1])
+  })
+
+  describe('When viewing a video', async function () {
+
+    // TODO: implement it when we'll remove backward compatibility in REST API
+    it('Should fail without current time')
+
+    it('Should fail with an invalid current time', async function () {
+      await servers[0].views.view({ id: videoId, currentTime: -1, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+      await servers[0].views.view({ id: videoId, currentTime: 10, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with correct parameters', async function () {
+      await servers[0].views.view({ id: videoId, currentTime: 1 })
+    })
+  })
+
+  describe('When getting overall stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId: remoteVideoId, expectedStatus: HttpStatusCode.FORBIDDEN_403 })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId: videoId, token: null, expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getOverallStats({
+        videoId: videoId,
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getOverallStats({ videoId })
+    })
+  })
+
+  describe('When getting timeserie stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: remoteVideoId,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: videoId,
+        token: null,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getTimeserieStats({
+        videoId: videoId,
+        token: userAccessToken,
+        metric: 'viewers',
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail with an invalid metric', async function () {
+      await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'hello' as any, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getTimeserieStats({ videoId, metric: 'viewers' })
+    })
+  })
+
+  describe('When getting retention stats', function () {
+
+    it('Should fail with a remote video', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: remoteVideoId,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail without token', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: videoId,
+        token: null,
+        expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+      })
+    })
+
+    it('Should fail with another token', async function () {
+      await servers[0].videoStats.getRetentionStats({
+        videoId: videoId,
+        token: userAccessToken,
+        expectedStatus: HttpStatusCode.FORBIDDEN_403
+      })
+    })
+
+    it('Should fail on live video', async function () {
+      await servers[0].videoStats.getRetentionStats({ videoId: liveVideoId, expectedStatus: HttpStatusCode.BAD_REQUEST_400 })
+    })
+
+    it('Should succeed with the correct parameters', async function () {
+      await servers[0].videoStats.getRetentionStats({ videoId })
+    })
+  })
+
+  after(async function () {
+    await cleanupTests(servers)
+  })
+})