Fix/homepage scoring

src/mappings/content/commentsAndReactions.ts

@@ -43,7 +43,6 @@ import {
   genericEventFields,
   metaprotocolTransactionFailure,
   commentCountersManager,
-  videoRelevanceManager,
 } from '../utils'
 import { getChannelOwnerMemberByChannelId } from './utils'
 
@@ -257,8 +256,6 @@ export async function processReactVideoMessage(
 
   await processVideoReaction(overlay, block, memberId, video, reactionType, existingReaction)
 
-  videoRelevanceManager.scheduleRecalcForVideo(video.id)
-
   return new MetaprotocolTransactionResultOK()
 }
 
@@ -403,7 +400,6 @@ export async function processCreateCommentMessage(
   // schedule comment counters update
   commentCountersManager.scheduleRecalcForComment(comment.parentCommentId)
   commentCountersManager.scheduleRecalcForVideo(comment.videoId)
-  videoRelevanceManager.scheduleRecalcForVideo(comment.videoId)
 
   // add CommentCreated event
   const event = overlay.getRepository(Event).new({
@@ -537,7 +533,6 @@ export async function processDeleteCommentMessage(
   // schedule comment counters update
   commentCountersManager.scheduleRecalcForComment(comment.parentCommentId)
   commentCountersManager.scheduleRecalcForVideo(comment.videoId)
-  videoRelevanceManager.scheduleRecalcForVideo(comment.videoId)
 
   // update the comment
   comment.text = ''

src/mappings/content/metadata.ts

@@ -63,7 +63,6 @@ import {
   genericEventFields,
   invalidMetadata,
   metaprotocolTransactionFailure,
-  videoRelevanceManager,
 } from '../utils'
 import { AsDecoded, ASSETS_MAP, EntityAssetProps, EntityAssetsMap, MetaNumberProps } from './utils'
 
@@ -572,7 +571,6 @@ export async function processModerateCommentMessage(
   // schedule comment counters updates
   commentCountersManager.scheduleRecalcForComment(comment.parentCommentId)
   commentCountersManager.scheduleRecalcForVideo(comment.videoId)
-  videoRelevanceManager.scheduleRecalcForVideo(comment.videoId)
 
   comment.text = ''
   comment.status = CommentStatus.MODERATED

src/mappings/content/video.ts

@@ -8,7 +8,7 @@ import { DecodedMetadataObject } from '@joystream/metadata-protobuf/types'
 import { integrateMeta } from '@joystream/metadata-protobuf/utils'
 import { Channel, Video, VideoViewEvent } from '../../model'
 import { EventHandlerContext } from '../../utils/events'
-import { deserializeMetadata, u8aToBytes, videoRelevanceManager } from '../utils'
+import { deserializeMetadata, u8aToBytes } from '../utils'
 import { processVideoMetadata } from './metadata'
 import { deleteVideo, encodeAssets, processAppActionMetadata, processNft } from './utils'
 import { generateAppActionCommitment } from '@joystream/js/utils'
@@ -43,8 +43,6 @@ export async function processVideoCreatedEvent({
     videoRelevance: 0,
   })
 
-  videoRelevanceManager.scheduleRecalcForVideo(videoId)
-
   // fetch related channel and owner
   const channel = await overlay.getRepository(Channel).getByIdOrFail(channelId.toString())
 

src/mappings/utils.ts

@@ -19,7 +19,7 @@ import { VideoRelevanceManager } from '../utils/VideoRelevanceManager'
 
 export const commentCountersManager = new CommentCountersManager()
 export const videoRelevanceManager = new VideoRelevanceManager()
-videoRelevanceManager.init(1000 * 60 * 60)
+videoRelevanceManager.init(1000 * 60 * 10)
 
 export const JOYSTREAM_SS58_PREFIX = 126
 

src/processor.ts

@@ -322,7 +322,7 @@ processor.run(new TypeormDatabase({ isolationLevel: 'READ COMMITTED' }), async (
       await offchainState.import(em)
       await commentCountersManager.updateVideoCommentsCounters(em, true)
       await commentCountersManager.updateParentRepliesCounters(em, true)
-      await videoRelevanceManager.updateVideoRelevanceValue(em, true)
+      await videoRelevanceManager.updateVideoRelevanceValue(em)
       ctx.log.info(`Offchain state successfully imported!`)
     }
   }

src/server-extension/resolvers/AdminResolver/index.ts

@@ -112,7 +112,7 @@ export class AdminResolver {
       ],
       em
     )
-    await videoRelevanceManager.updateVideoRelevanceValue(em, true)
+    await videoRelevanceManager.updateVideoRelevanceValue(em)
     return { isApplied: true }
   }
 

src/server-extension/resolvers/AdminResolver/utils.ts

@@ -1,18 +1,14 @@
 import { EntityManager, In } from 'typeorm'
 import { CommentCountersManager } from '../../../utils/CommentsCountersManager'
 import { Comment } from '../../../model'
-import { VideoRelevanceManager } from '../../../utils/VideoRelevanceManager'
 
 export async function processCommentsCensorshipStatusUpdate(em: EntityManager, ids: string[]) {
   const manager = new CommentCountersManager()
-  const videoRelevanceManager = new VideoRelevanceManager()
   const comments = await em.getRepository(Comment).find({ where: { id: In(ids) } })
   comments.forEach((c) => {
     manager.scheduleRecalcForComment(c.parentCommentId)
     manager.scheduleRecalcForVideo(c.videoId)
-    videoRelevanceManager.scheduleRecalcForVideo(c.videoId)
   })
   await manager.updateVideoCommentsCounters(em)
   await manager.updateParentRepliesCounters(em)
-  await videoRelevanceManager.updateVideoRelevanceValue(em)
 }

src/server-extension/resolvers/VideosResolver/index.ts

@@ -34,7 +34,6 @@ import { config, ConfigVariable } from '../../../utils/config'
 import { Context } from '../../check'
 import { isObject } from 'lodash'
 import { has } from '../../../utils/misc'
-import { videoRelevanceManager } from '../../../mappings/utils'
 import { uniqueId } from '../../../utils/crypto'
 import { UserOnly } from '../middleware'
 
@@ -237,12 +236,7 @@ export class VideosResolver {
         videoId,
       })
 
-      const tick = await config.get(ConfigVariable.VideoRelevanceViewsTick, em)
-      if (video.viewsNum % tick === 0) {
-        videoRelevanceManager.scheduleRecalcForVideo(videoId)
-      }
       await em.save([video, video.channel, newView])
-      await videoRelevanceManager.updateVideoRelevanceValue(em)
       return {
         videoId,
         viewsNum: video.viewsNum,

src/utils/VideoRelevanceManager.ts

@@ -6,8 +6,6 @@ import { globalEm } from './globalEm'
 export const NEWNESS_SECONDS_DIVIDER = 60 * 60 * 24
 
 export class VideoRelevanceManager {
-  private videosToUpdate: Set<string> = new Set()
-
   init(intervalMs: number): void {
     this.updateLoop(intervalMs)
       .then(() => {
@@ -19,66 +17,56 @@ export class VideoRelevanceManager {
       })
   }
 
-  scheduleRecalcForVideo(id: string | null | undefined) {
-    id && this.videosToUpdate.add(id)
-  }
-
-  async updateVideoRelevanceValue(em: EntityManager, forceUpdateAll?: boolean) {
-    if (this.videosToUpdate.size || forceUpdateAll) {
-      const [
-        newnessWeight,
-        viewsWeight,
-        commentsWeight,
-        reactionsWeight,
-        [joystreamTimestampWeight, ytTimestampWeight] = [7, 3],
-        defaultChannelWeight,
-      ] = await config.get(ConfigVariable.RelevanceWeights, em)
-      const channelWeight = defaultChannelWeight ?? 1
-      await em.query(`
-        WITH weighted_timestamp AS (
-    SELECT 
-        "video"."id",
-        (
+  async updateVideoRelevanceValue(em: EntityManager) {
+    const [
+      newnessWeight,
+      viewsWeight,
+      commentsWeight,
+      reactionsWeight,
+      [joystreamTimestampWeight, ytTimestampWeight] = [7, 3],
+      defaultChannelWeight,
+    ] = await config.get(ConfigVariable.RelevanceWeights, em)
+    const channelWeight = defaultChannelWeight ?? 1
+    const wtEpoch = `((
           extract(epoch from video.created_at)*${joystreamTimestampWeight} +
           COALESCE(extract(epoch from video.published_before_joystream), extract(epoch from video.created_at))*${ytTimestampWeight}
-        ) / ${joystreamTimestampWeight} + ${ytTimestampWeight} as wtEpoch,
-        "channel"."channel_weight" as CW
-    FROM 
-        "video" 
-        INNER JOIN
-          "channel" ON "video"."channel_id" = "channel"."id"
-        ${
-          forceUpdateAll
-            ? ''
-            : `WHERE "video"."id" IN (${[...this.videosToUpdate.values()]
-                .map((id) => `'${id}'`)
-                .join(', ')})`
-        }
-        )
-    UPDATE 
-        "video"
-    SET
-        "video_relevance" = ROUND(
-      (
-        (extract(epoch from now()) - wtEpoch) / ${NEWNESS_SECONDS_DIVIDER} * ${newnessWeight * -1} +
-        (views_num * ${viewsWeight}) +
-        (comments_count * ${commentsWeight}) +
-        (reactions_count * ${reactionsWeight})
-      ) * COALESCE(CW, ${channelWeight}),
-            2)
-    FROM
-        weighted_timestamp
-    WHERE
-        "video".id = weighted_timestamp.id;
+        ) / ${joystreamTimestampWeight} + ${ytTimestampWeight})`
+
+    await em.query(`
+        WITH videos_with_weight AS (
+        SELECT 
+        video.id as videoId,
+        channel.id as channelId,
+        (ROUND((
+        (extract(epoch from now()) - ${wtEpoch})
+        / ${NEWNESS_SECONDS_DIVIDER} * ${newnessWeight * -1} 
+        + (views_num * ${viewsWeight}) 
+        + (comments_count * ${commentsWeight}) 
+        + (reactions_count * ${reactionsWeight})) 
+        * COALESCE(channel.channel_weight, ${channelWeight}),2)) as videoRelevance
+        FROM video
+        INNER JOIN channel  ON video.channel_id = channel.id),
+
+        top_channel_score as (
+        SELECT 
+        channel.id as channelId,
+        MAX(videoCte.videoRelevance) as maxChannelRelevance
+        FROM channel
+        INNER JOIN videos_with_weight as videoCte on videoCte.channelId = channel.id
+        GROUP BY channel.id)
+
+        UPDATE video
+        SET video_relevance = COALESCE(topChannelVideo.maxChannelRelevance, 1) 
+        FROM videos_with_weight as videoCte
+        LEFT JOIN top_channel_score as topChannelVideo on topChannelVideo.channelId = videoCte.channelId and topChannelVideo.maxChannelRelevance = videoCte.videoRelevance
+        WHERE video.id = videoCte.videoId;
         `)
-      this.videosToUpdate.clear()
-    }
   }
 
   private async updateLoop(intervalMs: number): Promise<void> {
     const em = await globalEm
     while (true) {
-      await this.updateVideoRelevanceValue(em, true)
+      await this.updateVideoRelevanceValue(em)
       await new Promise((resolve) => setTimeout(resolve, intervalMs))
     }
   }