feat(posts): remove read articles from feed (#47)

Add filter to the generate feed function to remove read articles from the post

Author: prateek3255

migrations/20200324164902_add_read_setting.js

@@ -0,0 +1,9 @@
+exports.up = knex =>
+  knex.schema.table('settings', (table) => {
+    table.boolean('show_only_not_read_posts').defaultTo(false);
+  });
+
+exports.down = knex =>
+  knex.schema.table('settings', (table) => {
+    table.dropColumn('show_only_not_read_posts');
+  });

src/graphql/helpers/post.js

@@ -4,7 +4,7 @@ const getFeedParams =
 
     return {
       fields: userId ? [...post.defaultUserFields, 'read'] : post.defaultAnonymousFields,
-      filters: Object.assign({}, { before: args.latest }, filters),
+      filters: Object.assign({}, { before: args.latest }, filters, typeof args.read === 'boolean' && userId && { read: args.read }),
       rankBy,
       userId,
       ignoreUserFilters,

src/graphql/schema/post.js

@@ -63,6 +63,7 @@ export default `
     pubs: String
     tags: String
     sortBy: String
+    read: Boolean
   }
 
   input ToiletInput {

src/models/post.js

@@ -249,6 +249,7 @@ const filtersToQuery = async (query, filters = {}, rankBy, userId, ignoreUserFil
  * @param {?String[]} filters.postIds Retrieve a set of posts by id
  * @param {?Boolean} filters.bookmarks Whether to retrieve only bookmarked posts
  * @param {?String} filters.search Text query to filter posts
+ * @param {?Boolean} filters.read Whether to retrieve only read posts
  * @param {?'popularity'|'creation'} rankBy Order criteria
  * @param {?String} userId Id of the user who requested the feed
  * @param {?Boolean} ignoreUserFilters Whether to ignore the user's preferences
@@ -289,6 +290,20 @@ const generateFeed = async ({
     .from(table)
     .join('publications', `${table}.publication_id`, 'publications.id');
 
+  if (typeof newFilters.read === 'boolean') {
+    const args = [eventsTable, builder =>
+      builder.on(`${eventsTable}.post_id`, '=', `${table}.id`)
+        .andOn(`${eventsTable}.user_id`, '=', db.raw('?', [userId])),
+    ];
+    if (newFilters.read) {
+      query = query.join(...args);
+      query = query.where(`${eventsTable}.type`, '=', 'view');
+    } else {
+      query = query.leftJoin(...args);
+      query = query.whereNull(`${eventsTable}.type`);
+    }
+  }
+
   // Join bookmarks table if needed
   if (userId && (relevantFields.indexOf('bookmarked') > -1 || (newFilters && newFilters.bookmarks))) {
     const args = [bookmarksTable, builder =>

src/models/settings.js

@@ -13,6 +13,7 @@ const getByUserId = userId =>
       showTopSites: row.showTopSites === 1,
       insaneMode: row.insaneMode === 1,
       appInsaneMode: row.appInsaneMode === 1,
+      showOnlyNotReadPosts: row.showOnlyNotReadPosts === 1,
     }))
     .then((res) => {
       if (res.length) {

test/fixtures/posts.js

@@ -60,6 +60,10 @@ const input = [
   },
 ];
 
+const notReadInput = [{ ...input[2], userId: 'user1' }, { ...input[3], userId: 'user1' }, { ...input[4], userId: 'user2' }];
+
+const readInput = [{ ...input[0], userId: 'user1' }, { ...input[3], userId: 'user2' }, { ...input[4], userId: 'user1' }];
+
 const output = [
   {
     id: input[4].id,
@@ -146,6 +150,32 @@ const outputByCreation = [
   output[2],
 ];
 
+const readOutput = [
+  {
+    id: input[4].id,
+    read: true,
+  },
+  {
+    id: input[0].id,
+    read: true,
+  },
+];
+
+const notReadOutput = [
+  {
+    id: input[4].id,
+    read: false,
+  },
+  {
+    id: input[1].id,
+    read: false,
+  },
+  {
+    id: input[0].id,
+    read: false,
+  },
+];
+
 const bookmarks = [
   { userId: 'user1', postId: input[1].id },
   { userId: 'user1', postId: input[0].id },
@@ -154,10 +184,14 @@ const bookmarks = [
 
 export default {
   input,
+  readInput,
+  notReadInput,
   output,
   pubsOutput,
   tagsOutput,
   searchOutput,
   outputByCreation,
+  readOutput,
+  notReadOutput,
   bookmarks,
 };

test/fixtures/settings.js

@@ -4,6 +4,7 @@ const input = [
     theme: 'darcula',
     showTopSites: false,
     enableCardAnimations: false,
+    showOnlyNotReadPosts: true,
   },
   {
     userId: 'user2',
@@ -23,6 +24,7 @@ const output = [
     insaneMode: false,
     appInsaneMode: true,
     spaciness: 'eco',
+    showOnlyNotReadPosts: true,
   },
   {
     userId: 'user2',
@@ -32,6 +34,7 @@ const output = [
     insaneMode: false,
     appInsaneMode: true,
     spaciness: 'roomy',
+    showOnlyNotReadPosts: false,
   },
 ];
 

test/integration/graphql/post.js

@@ -9,6 +9,7 @@ import fixtureToilet from '../../fixtures/toilet';
 import * as algolia from '../../../src/algolia';
 import publication from '../../../src/models/publication';
 import post from '../../../src/models/post';
+import event from '../../../src/models/event';
 import config from '../../../src/config';
 import db, { migrate } from '../../../src/db';
 import app from '../../../src';
@@ -166,6 +167,70 @@ describe('graphql post', () => {
 
       expect(latest).to.deep.equal(fixture.outputByCreation.map(mapDate));
     });
+
+    it('should fetch latest not read posts', async () => {
+      await Promise.all(fixture.input.map(p => post.add(p)));
+      await Promise.all(fixture.notReadInput.map(p => event.add('view', p.userId, p.id)));
+      await request.post('/v1/tags/updateCount');
+
+      const params = `{
+        latest: ${JSON.stringify(latestDate)}
+        page: 0,
+        pageSize: 20,
+        read: false,
+      }`;
+
+      const result = await request
+        .get('/graphql')
+        .set('Authorization', `Service ${config.accessSecret}`)
+        .set('User-Id', fixture.notReadInput[0].userId)
+        .set('Logged-In', true)
+        .query({
+          query: `{
+            latest(params: ${params}) {
+              id
+              read
+            }
+          }`,
+        })
+        .expect(200);
+
+      const { latest } = result.body.data;
+
+      expect(latest).to.deep.equal(fixture.notReadOutput);
+    });
+
+    it('should fetch latest read posts', async () => {
+      await Promise.all(fixture.input.map(p => post.add(p)));
+      await Promise.all(fixture.readInput.map(p => event.add('view', p.userId, p.id)));
+      await request.post('/v1/tags/updateCount');
+
+      const params = `{
+        latest: ${JSON.stringify(latestDate)}
+        page: 0,
+        pageSize: 20,
+        read: true,
+      }`;
+
+      const result = await request
+        .get('/graphql')
+        .set('Authorization', `Service ${config.accessSecret}`)
+        .set('User-Id', fixture.readInput[0].userId)
+        .set('Logged-In', true)
+        .query({
+          query: `{
+            latest(params: ${params}) {
+              id
+              read
+            }
+          }`,
+        })
+        .expect(200);
+
+      const { latest } = result.body.data;
+
+      expect(latest).to.deep.equal(fixture.readOutput);
+    });
   });
 
   describe('get post query', () => {

test/integration/models/post.js

@@ -133,13 +133,16 @@ describe('post model', () => {
     it('should return posts with read field', async () => {
       await Promise.all([
         event.add('view', '1', feedFixture.posts[0].id),
-        event.add('view', '1', feedFixture.posts[2].id),
+        event.add('view', '2', feedFixture.posts[2].id),
         event.add('view', '2', feedFixture.posts[1].id),
+        event.add('view', '1', feedFixture.posts[3].id),
+        event.add('view', '1', feedFixture.posts[4].id),
       ]);
 
       const expected = feedFixture.posts.map(p => ({ id: p.id, read: false }));
       expected[0].read = true;
-      expected[2].read = true;
+      expected[3].read = true;
+      expected[4].read = true;
 
       const actual = await post.generateFeed({
         fields: ['id', 'read'],
@@ -149,6 +152,45 @@ describe('post model', () => {
       expect(actual).to.deep.equal(expected);
     });
 
+    it('should return only read posts', async () => {
+      await Promise.all([
+        event.add('view', '1', feedFixture.posts[0].id),
+        event.add('view', '1', feedFixture.posts[2].id),
+        event.add('view', '2', feedFixture.posts[1].id),
+      ]);
+
+      const expected = [feedFixture.posts[0], feedFixture.posts[2]].map(p => ({ id: p.id }));
+
+      const actual = await post.generateFeed({
+        fields: ['id'],
+        rankBy: 'creation',
+        userId: '1',
+        filters: { read: true },
+      });
+      expect(actual).to.deep.equal(expected);
+    });
+
+    it('should return only not read posts', async () => {
+      await Promise.all([
+        event.add('view', '1', feedFixture.posts[0].id),
+        event.add('view', '1', feedFixture.posts[2].id),
+        event.add('view', '2', feedFixture.posts[1].id),
+      ]);
+
+      const readPosts = [feedFixture.posts[0].id, feedFixture.posts[2].id];
+      const expected = feedFixture.posts
+        .map(p => ({ id: p.id }))
+        .filter(({ id }) => !readPosts.includes(id));
+
+      const actual = await post.generateFeed({
+        fields: ['id'],
+        rankBy: 'creation',
+        userId: '1',
+        filters: { read: false },
+      });
+      expect(actual).to.deep.equal(expected);
+    });
+
     it('should return posts within the given time', async () => {
       const actual = await post.generateFeed({
         fields: ['id'],