feat: add vordr slack worker for posts

.infra/common.ts

@@ -277,6 +277,10 @@ export const workers: Worker[] = [
     topic: 'api.v1.post-visible',
     subscription: 'api.post-added-slack-channel-send',
   },
+  {
+    topic: 'api.v1.post-visible',
+    subscription: 'api.vordr-post-prevented',
+  }
 ];
 
 export const personalizedDigestWorkers: Worker[] = [

__tests__/workers/vordrPostCommentPrevented.ts

@@ -1,7 +1,7 @@
 import { DataSource } from 'typeorm';
 import createOrGetConnection from '../../src/db';
 import { Comment, Post, Source, User } from '../../src/entity';
-import worker from '../../src/workers/vordrPostCommentPrevented';
+import { vordrPostCommentPrevented as worker } from '../../src/workers/vordrPostCommentPrevented';
 import { badUsersFixture, sourcesFixture, usersFixture } from '../fixture';
 import { postsFixture } from '../fixture/post';
 import { typedWorkers } from '../../src/workers';

__tests__/workers/vordrPostPrevented.ts

@@ -0,0 +1,95 @@
+import { DataSource } from 'typeorm';
+import createOrGetConnection from '../../src/db';
+import { ArticlePost, Post, PostType, Source, User } from '../../src/entity';
+import { vordrPostPrevented as worker } from '../../src/workers/vordrPostPrevented';
+import { badUsersFixture, sourcesFixture, usersFixture } from '../fixture';
+import { postsFixture } from '../fixture/post';
+import { typedWorkers } from '../../src/workers';
+import { expectSuccessfulTypedBackground, saveFixtures } from '../helpers';
+import { notifyNewVordrPost } from '../../src/common';
+import { ChangeObject } from '../../src/types';
+
+let con: DataSource;
+
+jest.mock('../../src/common', () => ({
+  ...jest.requireActual<Record<string, unknown>>('../../src/common'),
+  notifyNewVordrPost: jest.fn(),
+}));
+
+beforeAll(async () => {
+  con = await createOrGetConnection();
+});
+
+beforeEach(async () => {
+  jest.resetAllMocks();
+  await saveFixtures(con, User, usersFixture);
+  await saveFixtures(con, User, badUsersFixture);
+  await saveFixtures(con, Source, sourcesFixture);
+  await saveFixtures(con, Post, postsFixture);
+  await saveFixtures(con, ArticlePost, [
+    {
+      id: 'vordr1',
+      shortId: 'svordr1',
+      title: 'vordr1',
+      url: 'http://vordr1.com',
+      image: 'https://daily.dev/image.jpg',
+      score: 10,
+      sourceId: 'b',
+      createdAt: new Date(new Date().getTime() - 4000),
+      tagsStr: 'html,javascript',
+      type: PostType.Article,
+      contentCuration: ['c1', 'c2'],
+      authorId: '2',
+      flags: { vordr: true },
+    },
+    {
+      id: 'vordr2',
+      shortId: 'svordr2',
+      title: 'vordr2',
+      url: 'http://vordr2.com',
+      image: 'https://daily.dev/image.jpg',
+      score: 10,
+      sourceId: 'b',
+      createdAt: new Date(new Date().getTime() - 4000),
+      tagsStr: 'html,javascript',
+      type: PostType.Article,
+      contentCuration: ['c1', 'c2'],
+      authorId: '2',
+      flags: { vordr: true },
+    },
+  ]);
+});
+
+describe('vordrPostPrevented', () => {
+  it('should be registered', () => {
+    const registeredWorker = typedWorkers.find(
+      (item) => item.subscription === worker.subscription,
+    );
+
+    expect(registeredWorker).toBeDefined();
+  });
+
+  it('should send slack message when vordr prevented a post', async () => {
+    const post = await con.getRepository(ArticlePost).findOneByOrFail({
+      id: 'vordr1',
+    });
+
+    await expectSuccessfulTypedBackground(worker, {
+      post: post as unknown as ChangeObject<ArticlePost>,
+    });
+
+    expect(notifyNewVordrPost).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not send slack message when vordr did not prevented a post', async () => {
+    const post = await con.getRepository(ArticlePost).findOneByOrFail({
+      id: 'p1',
+    });
+
+    await expectSuccessfulTypedBackground(worker, {
+      post: post as unknown as ChangeObject<ArticlePost>,
+    });
+
+    expect(notifyNewVordrPost).toHaveBeenCalledTimes(0);
+  });
+});

src/common/slack.ts

@@ -62,7 +62,7 @@ export const notifyNewVordrComment = async (
         fields: [
           {
             title: 'User',
-            value: user.id,
+            value: `${user.username} [${user.id}]`,
           },
           {
             title: 'Post title',
@@ -91,6 +91,53 @@ export const notifyNewVordrComment = async (
   });
 };
 
+export const notifyNewVordrPost = async (
+  post: Post,
+  author?: User,
+  scout?: User,
+): Promise<void> => {
+  const getUser = (title: string, user?: User) =>
+    user
+      ? [
+          {
+            title,
+            value: `${user.username} [${user.id}]`,
+          },
+          {
+            title: `${title} Vordr status`,
+            value: user.flags?.vordr?.toString() ?? '',
+          },
+          {
+            title: `${title} Trust score`,
+            value: user.flags?.trustScore?.toString() ?? '',
+          },
+          {
+            title: `${title} Reputation`,
+            value: user.reputation.toString() ?? '',
+          },
+        ]
+      : [];
+
+  await webhooks.vordr.send({
+    text: 'New post prevented by vordr',
+    attachments: [
+      {
+        title: post.title,
+        title_link: `${process.env.COMMENTS_PREFIX}/posts/${post.id}`,
+        fields: [
+          {
+            title: 'Post type',
+            value: post.type,
+          },
+          ...getUser('Scout', scout),
+          ...getUser('Author', author),
+        ],
+        color: '#1DDC6F',
+      },
+    ],
+  });
+};
+
 export const notifyPostReport = async (
   userId: string,
   post: Post,

src/workers/index.ts

@@ -49,7 +49,8 @@ import userUpdatedCio from './userUpdatedCio';
 import userDeletedCio from './userDeletedCio';
 import userCreatedCio from './userCreatedCio';
 import userStreakUpdatedCio from './userStreakUpdatedCio';
-import vordrPostCommentPrevented from './vordrPostCommentPrevented';
+import { vordrPostCommentPrevented } from './vordrPostCommentPrevented';
+import { vordrPostPrevented } from './vordrPostPrevented';
 import { postAddedSlackChannelSendWorker } from './postAddedSlackChannelSend';
 
 export { Worker } from './worker';
@@ -104,6 +105,7 @@ export const typedWorkers: BaseTypedWorker<any>[] = [
   userCreatedCio,
   userStreakUpdatedCio,
   vordrPostCommentPrevented,
+  vordrPostPrevented,
   postAddedSlackChannelSendWorker,
 ];
 

src/workers/vordrPostCommentPrevented.ts

@@ -4,7 +4,7 @@ import { notifyNewVordrComment } from '../common';
 import { TypeORMQueryFailedError } from '../errors';
 import { logger } from '../logger';
 
-const worker: TypedWorker<'post-commented'> = {
+export const vordrPostCommentPrevented: TypedWorker<'post-commented'> = {
   subscription: 'api.vordr-post-comment-prevented',
   handler: async ({ data }, con): Promise<void> => {
     try {
@@ -37,5 +37,3 @@ const worker: TypedWorker<'post-commented'> = {
     }
   },
 };
-
-export default worker;

src/workers/vordrPostPrevented.ts

@@ -0,0 +1,44 @@
+import { TypedWorker } from './worker';
+import { Post } from '../entity';
+import { notifyNewVordrPost } from '../common';
+import { TypeORMQueryFailedError } from '../errors';
+import { logger } from '../logger';
+
+export const vordrPostPrevented: TypedWorker<'api.v1.post-visible'> = {
+  subscription: 'api.vordr-post-prevented',
+  handler: async ({ data }, con): Promise<void> => {
+    try {
+      const post = await con.getRepository(Post).findOne({
+        where: { id: data.post.id },
+        relations: {
+          author: true,
+          scout: true,
+        },
+      });
+
+      const author = await post.author;
+      const scout = await post.scout;
+
+      if (!post.flags?.vordr) {
+        return;
+      }
+
+      if (post.private) {
+        return;
+      }
+
+      await notifyNewVordrPost(post, author, scout);
+    } catch (originalError) {
+      const err = originalError as TypeORMQueryFailedError;
+
+      logger.error(
+        {
+          data,
+          err,
+        },
+        'failed to notify vordr post comment prevented',
+      );
+      throw err;
+    }
+  },
+};