server/models/request/request-video-event.ts

   1 /*
   2   Request Video events (likes, dislikes, views...)
   3 */
   4
   5 import { values } from 'lodash'
   6 import * as Sequelize from 'sequelize'
   7
   8 import { database as db } from '../../initializers/database'
   9 import { REQUEST_VIDEO_EVENT_TYPES } from '../../initializers'
  10 import { isVideoEventCountValid } from '../../helpers'
  11 import { addMethodsToModel } from '../utils'
  12 import {
  13   RequestVideoEventInstance,
  14   RequestVideoEventAttributes,
  15
  16   RequestVideoEventMethods,
  17   RequestsVideoEventGrouped
  18 } from './request-video-event-interface'
  19
  20 let RequestVideoEvent: Sequelize.Model<RequestVideoEventInstance, RequestVideoEventAttributes>
  21 let countTotalRequests: RequestVideoEventMethods.CountTotalRequests
  22 let listWithLimitAndRandom: RequestVideoEventMethods.ListWithLimitAndRandom
  23 let removeByRequestIdsAndPod: RequestVideoEventMethods.RemoveByRequestIdsAndPod
  24 let removeAll: RequestVideoEventMethods.RemoveAll
  25
  26 export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
  27   RequestVideoEvent = sequelize.define<RequestVideoEventInstance, RequestVideoEventAttributes>('RequestVideoEvent',
  28     {
  29       type: {
  30         type: DataTypes.ENUM(values(REQUEST_VIDEO_EVENT_TYPES)),
  31         allowNull: false
  32       },
  33       count: {
  34         type: DataTypes.INTEGER,
  35         allowNull: false,
  36         validate: {
  37           countValid: function (value) {
  38             const res = isVideoEventCountValid(value)
  39             if (res === false) throw new Error('Video event count is not valid.')
  40           }
  41         }
  42       }
  43     },
  44     {
  45       updatedAt: false,
  46       indexes: [
  47         {
  48           fields: [ 'videoId' ]
  49         }
  50       ]
  51     }
  52   )
  53
  54   const classMethods = [
  55     associate,
  56
  57     listWithLimitAndRandom,
  58     countTotalRequests,
  59     removeAll,
  60     removeByRequestIdsAndPod
  61   ]
  62   addMethodsToModel(RequestVideoEvent, classMethods)
  63
  64   return RequestVideoEvent
  65 }
  66
  67 // ------------------------------ STATICS ------------------------------
  68
  69 function associate (models) {
  70   RequestVideoEvent.belongsTo(models.Video, {
  71     foreignKey: {
  72       name: 'videoId',
  73       allowNull: false
  74     },
  75     onDelete: 'CASCADE'
  76   })
  77 }
  78
  79 countTotalRequests = function () {
  80   const query = {}
  81   return RequestVideoEvent.count(query)
  82 }
  83
  84 listWithLimitAndRandom = function (limitPods: number, limitRequestsPerPod: number) {
  85   const Pod = db.Pod
  86
  87   // We make a join between videos and authors to find the podId of our video event requests
  88   const podJoins = 'INNER JOIN "VideoChannels" ON "VideoChannels"."authorId" = "Authors"."id" ' +
  89                    'INNER JOIN "Videos" ON "Videos"."channelId" = "VideoChannels"."id" ' +
  90                    'INNER JOIN "RequestVideoEvents" ON "RequestVideoEvents"."videoId" = "Videos"."id"'
  91
  92   return Pod.listRandomPodIdsWithRequest(limitPods, 'Authors', podJoins).then(podIds => {
  93     // We don't have friends that have requests
  94     if (podIds.length === 0) return []
  95
  96     const query = {
  97       order: [
  98         [ 'id', 'ASC' ]
  99       ],
 100       include: [
 101         {
 102           model: RequestVideoEvent['sequelize'].models.Video,
 103           include: [
 104             {
 105               model: RequestVideoEvent['sequelize'].models.VideoChannel,
 106               include: [
 107                 {
 108                   model: RequestVideoEvent['sequelize'].models.Author,
 109                   include: [
 110                     {
 111                       model: RequestVideoEvent['sequelize'].models.Pod,
 112                       where: {
 113                         id: {
 114                           [Sequelize.Op.in]: podIds
 115                         }
 116                       }
 117                     }
 118                   ]
 119                 }
 120               ]
 121             }
 122           ]
 123         }
 124       ]
 125     }
 126
 127     return RequestVideoEvent.findAll(query).then(requests => {
 128       const requestsGrouped = groupAndTruncateRequests(requests, limitRequestsPerPod)
 129       return requestsGrouped
 130     })
 131   })
 132 }
 133
 134 removeByRequestIdsAndPod = function (ids: number[], podId: number) {
 135   const query = {
 136     where: {
 137       id: {
 138         [Sequelize.Op.in]: ids
 139       }
 140     },
 141     include: [
 142       {
 143         model: RequestVideoEvent['sequelize'].models.Video,
 144         include: [
 145           {
 146             model: RequestVideoEvent['sequelize'].models.VideoChannel,
 147             include: [
 148               {
 149                 model: RequestVideoEvent['sequelize'].models.Author,
 150                 where: {
 151                   podId
 152                 }
 153               }
 154             ]
 155           }
 156         ]
 157       }
 158     ]
 159   }
 160
 161   return RequestVideoEvent.destroy(query)
 162 }
 163
 164 removeAll = function () {
 165   // Delete all requests
 166   return RequestVideoEvent.truncate({ cascade: true })
 167 }
 168
 169 // ---------------------------------------------------------------------------
 170
 171 function groupAndTruncateRequests (events: RequestVideoEventInstance[], limitRequestsPerPod: number) {
 172   const eventsGrouped: RequestsVideoEventGrouped = {}
 173
 174   events.forEach(event => {
 175     const pod = event.Video.VideoChannel.Author.Pod
 176
 177     if (!eventsGrouped[pod.id]) eventsGrouped[pod.id] = []
 178
 179     if (eventsGrouped[pod.id].length < limitRequestsPerPod) {
 180       eventsGrouped[pod.id].push({
 181         id: event.id,
 182         type: event.type,
 183         count: event.count,
 184         video: event.Video,
 185         pod
 186       })
 187     }
 188   })
 189
 190   return eventsGrouped
 191 }