Implement community board (user queries/mutations) [5/7]

src/app.ts

@@ -8,14 +8,15 @@ import { ApolloServer } from 'apollo-server-express';
 import ArticleResolver from './resolvers/ArticleResolver';
 import ArticleRepo from './repos/ArticleRepo';
 import { dbConnection } from './db/DBConnection';
+import FlyerRepo from './repos/FlyerRepo';
 import FlyerResolver from './resolvers/FlyerResolver';
 import MagazineRepo from './repos/MagazineRepo';
 import MagazineResolver from './resolvers/MagazineResolver';
 import NotificationRepo from './repos/NotificationRepo';
 import OrganizationResolver from './resolvers/OrganizationResolver';
 import PublicationResolver from './resolvers/PublicationResolver';
-import WeeklyDebriefRepo from './repos/WeeklyDebriefRepo';
 import UserResolver from './resolvers/UserResolver';
+import WeeklyDebriefRepo from './repos/WeeklyDebriefRepo';
 
 const main = async () => {
   const schema = await buildSchema({
@@ -76,13 +77,15 @@ const main = async () => {
   }
 
   async function setupTrendingArticleRefreshCron() {
-    // Refresh trending articles once
+    // Refresh trending articles, magazines, and flyers once
     ArticleRepo.refreshTrendingArticles();
     MagazineRepo.refreshFeaturedMagazines();
-    // Refresh trending articles 12 hours
+    FlyerRepo.refreshTrendingFlyers();
+    // Refresh trending articles, magazines, and flyers every 12 hours
     cron.schedule('0 */12 * * *', async () => {
       ArticleRepo.refreshTrendingArticles();
       MagazineRepo.refreshFeaturedMagazines();
+      FlyerRepo.refreshTrendingFlyers();
     });
   }
 

src/common/types.ts

@@ -30,3 +30,21 @@ export class PublicationSlug {
     this.slug = slug;
   }
 }
+
+@ObjectType({ description: 'ID of an Organization' })
+export class OrganizationID {
+  @Field()
+  @Property()
+  id: string;
+}
+
+@ObjectType({ description: 'Slug of an Organization' })
+export class OrganizationSlug {
+  @Field()
+  @Property()
+  slug: string;
+
+  constructor(slug: string) {
+    this.slug = slug;
+  }
+}

src/repos/UserRepo.ts

@@ -1,11 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 import { Article } from '../entities/Article';
 import ArticleRepo from './ArticleRepo';
-import { PublicationSlug } from '../common/types';
+import { OrganizationSlug, PublicationSlug } from '../common/types';
 import { User, UserModel } from '../entities/User';
 import { Magazine } from '../entities/Magazine';
 import MagazineRepo from './MagazineRepo';
-
+import { Flyer } from '../entities/Flyer';
+import FlyerRepo from './FlyerRepo';
 /**
  * Create new user associated with deviceToken and followedPublicationsSlugs of deviceType.
  */
@@ -65,6 +66,37 @@ const unfollowPublication = async (uuid: string, pubSlug: string): Promise<User>
   return user;
 };
 
+/**
+ * Adds organization slug to user's followedOrganizations.
+ * Requires: the user is not already following the organization.
+ */
+const followOrganization = async (uuid: string, slug: string): Promise<User> => {
+  const user = await UserModel.findOne({ uuid });
+
+  if (user) {
+    user.followedOrganizations.push(new OrganizationSlug(slug));
+    return user.save();
+  }
+  return user;
+};
+
+/**
+ * Deletes organization slug from user's followedOrganizations.
+ */
+const unfollowOrganization = async (uuid: string, orgSlug: string): Promise<User> => {
+  const user = await UserModel.findOne({ uuid });
+  if (user) {
+    const orgSlugs = user.followedOrganizations.map((orgSlugObj) => orgSlugObj.slug);
+    const orgIndex = orgSlugs.indexOf(orgSlug);
+
+    if (orgIndex === -1) return user;
+
+    user.followedOrganizations.splice(orgIndex, 1);
+    return user.save();
+  }
+  return user;
+};
+
 const getUserByUUID = async (uuid: string): Promise<User> => {
   return UserModel.findOne({ uuid });
 };
@@ -79,41 +111,70 @@ const getUsersFollowingPublication = async (pubSlug: string): Promise<User[]> =>
   return matchedUsers;
 };
 
+/**
+ * Return all users who follow an organization
+ */
+const getUsersFollowingOrganization = async (orgSlug: string): Promise<User[]> => {
+  const matchedUsers = await UserModel.find({
+    followedOrganizations: { $elemMatch: { slug: orgSlug } },
+  });
+  return matchedUsers;
+};
+
 /**
  * Add article to a user's readArticles
  */
 const appendReadArticle = async (uuid: string, articleID: string): Promise<User> => {
   const user = await UserModel.findOne({ uuid });
 
-  if (!user) return user;
+  if (user) {
+    const article = await ArticleRepo.getArticleByID(articleID);
+    const checkDuplicates = (prev: boolean, cur: Article) => prev || cur.id === articleID;
 
-  const article = await ArticleRepo.getArticleByID(articleID);
-  const checkDuplicates = (prev: boolean, cur: Article) => prev || cur.id === articleID;
+    if (article && !user.readArticles.reduce(checkDuplicates, false)) {
+      user.readArticles.push(article);
+    }
 
-  if (article && !user.readArticles.reduce(checkDuplicates, false)) {
-    user.readArticles.push(article);
+    user.save();
   }
+  return user;
+};
+
+/**
+ * Add a flyer to a user's readFlyers
+ */
+const appendReadFlyer = async (uuid: string, flyerID: string): Promise<User> => {
+  const user = await UserModel.findOne({ uuid });
+
+  if (user) {
+    const flyer = await FlyerRepo.getFlyerByID(flyerID);
+    const checkDuplicates = (prev: boolean, cur: Flyer) => prev || cur.id === flyerID;
+
+    if (flyer && !user.readFlyers.reduce(checkDuplicates, false)) {
+      user.readFlyers.push(flyer);
+    }
 
-  user.save();
+    user.save();
+  }
   return user;
 };
 
 /**
- * Add a magazine to a user's readMagazines
+ * Add a magazine to a user's read
  */
 const appendReadMagazine = async (uuid: string, magazineID: string): Promise<User> => {
   const user = await UserModel.findOne({ uuid });
 
-  if (!user) return user;
+  if (user) {
+    const magazine = await MagazineRepo.getMagazineByID(magazineID);
+    const checkDuplicates = (prev: boolean, cur: Magazine) => prev || cur.id === magazineID;
 
-  const magazine = await MagazineRepo.getMagazineByID(magazineID);
-  const checkDuplicates = (prev: boolean, cur: Magazine) => prev || cur.id === magazineID;
+    if (magazine && !user.readMagazines.reduce(checkDuplicates, false)) {
+      user.readMagazines.push(magazine);
+    }
 
-  if (magazine && !user.readMagazines.reduce(checkDuplicates, false)) {
-    user.readMagazines.push(magazine);
+    user.save();
   }
-
-  user.save();
   return user;
 };
 
@@ -148,10 +209,14 @@ const incrementBookmarks = async (uuid: string): Promise<User> => {
 export default {
   appendReadArticle,
   appendReadMagazine,
+  appendReadFlyer,
   createUser,
   followPublication,
+  unfollowOrganization,
+  followOrganization,
   getUserByUUID,
   getUsersFollowingPublication,
+  getUsersFollowingOrganization,
   incrementBookmarks,
   incrementShoutouts,
   unfollowPublication,

src/resolvers/UserResolver.ts

@@ -26,6 +26,14 @@ class UserResolver {
     return await UserRepo.createUser(deviceToken, followedPublicationsSlugs, deviceType);
   }
 
+  @Mutation((_returns) => User, {
+    nullable: true,
+    description: 'User with id <uuid> follows the <Organization> referenced by <slug>',
+  })
+  async followOrganization(@Arg('uuid') uuid: string, @Arg('slug') slug: string) {
+    return await UserRepo.followOrganization(uuid, slug);
+  }
+
   @Mutation((_returns) => User, {
     nullable: true,
     description: 'User with id <uuid> follows the <Publication> referenced by <slug>',
@@ -34,6 +42,14 @@ class UserResolver {
     return await UserRepo.followPublication(uuid, slug);
   }
 
+  @Mutation((_returns) => User, {
+    nullable: true,
+    description: 'User with id <uuid> unfollows the <Organization> referenced by <slug>',
+  })
+  async unfollowOrganization(@Arg('uuid') uuid: string, @Arg('slug') slug: string) {
+    return await UserRepo.unfollowOrganization(uuid, slug);
+  }
+
   @Mutation((_returns) => User, {
     nullable: true,
     description: 'User with id <uuid> unfollows the <Publication> referenced by <slug>',
@@ -58,6 +74,14 @@ class UserResolver {
     return await UserRepo.appendReadMagazine(uuid, magazineID);
   }
 
+  @Mutation((_returns) => User, {
+    nullable: true,
+    description: "Adds the <Flyer> given by the <flyerID> to the <User's> read flyers",
+  })
+  async readFlyer(@Arg('uuid') uuid: string, @Arg('flyerID') flyerID: string) {
+    return await UserRepo.appendReadFlyer(uuid, flyerID);
+  }
+
   @Mutation((_returns) => User, {
     nullable: true,
     description: 'Increments the number of bookmarks for the <User> given by <uuid>',

src/tests/user.test.ts

@@ -13,24 +13,30 @@ import { dbConnection, disconnectDB } from './data/TestingDBConnection';
 import PublicationFactory from './data/PublicationFactory';
 import MagazineFactory from './data/MagazineFactory';
 import ArticleFactory from './data/ArticleFactory';
+import { FlyerModel } from '../entities/Flyer';
+import FlyerFactory from './data/FlyerFactory';
+import OrganizationFactory from './data/OrganizationFactory';
 
 beforeAll(async () => {
   await dbConnection();
   await PublicationRepo.addPublicationsToDB();
   await MagazineModel.createCollection();
   await UserModel.createCollection();
   await ArticleModel.createCollection();
+  await FlyerModel.createCollection();
 });
 
 beforeEach(async () => {
   await UserModel.deleteMany({});
   await MagazineModel.deleteMany({});
   await ArticleModel.deleteMany({});
+  await FlyerModel.deleteMany({});
 });
 
 afterAll(async () => {
   UserModel.deleteMany({});
   ArticleModel.deleteMany({});
+  FlyerModel.deleteMany({});
   MagazineModel.deleteMany({}).then(disconnectDB);
 });
 
@@ -95,6 +101,57 @@ describe('(un)followPublication tests:', () => {
   });
 });
 
+describe('(un)followOrganization tests:', () => {
+  test('followOrganization - 1 user, 1 organization', async () => {
+    const organization = await OrganizationFactory.getRandomOrganization();
+    const users = await UserFactory.create(1);
+    await UserModel.insertMany(users);
+    await UserRepo.followOrganization(users[0].uuid, organization.slug);
+
+    const getUserResponse = await UserRepo.getUsersFollowingOrganization(organization.slug);
+    expect(FactoryUtils.mapToValue(getUserResponse, 'uuid')).toEqual(
+      FactoryUtils.mapToValue(users, 'uuid'),
+    );
+  });
+
+  test('followOrganization - 3 users, 1 organization', async () => {
+    const organization = await OrganizationFactory.getRandomOrganization();
+    const users = await UserFactory.create(3);
+    await UserModel.insertMany(users);
+    for (let i = 0; i < 3; i++) await UserRepo.followOrganization(users[i].uuid, organization.slug);
+
+    const getUsersResponse = await UserRepo.getUsersFollowingOrganization(organization.slug);
+    expect(FactoryUtils.mapToValue(getUsersResponse, 'uuid')).toEqual(
+      FactoryUtils.mapToValue(users, 'uuid'),
+    );
+  });
+
+  test('unfollowOrganization - 1 user, 1 organization', async () => {
+    const organization = await OrganizationFactory.getRandomOrganization();
+    const users = await UserFactory.create(1);
+    await UserModel.insertMany(users);
+
+    await UserRepo.followOrganization(users[0].uuid, organization.slug);
+    await UserRepo.unfollowOrganization(users[0].uuid, organization.slug);
+
+    const getUsersResponse = await UserRepo.getUsersFollowingOrganization(organization.slug);
+    expect(getUsersResponse).toHaveLength(0);
+  });
+
+  test('unfollowOrganization - 3 users, 1 organization', async () => {
+    const organization = await OrganizationFactory.getRandomOrganization();
+    const users = await UserFactory.create(3);
+    await UserModel.insertMany(users);
+
+    for (let i = 0; i < 3; i++) await UserRepo.followOrganization(users[i].uuid, organization.slug);
+    for (let i = 0; i < 2; i++)
+      await UserRepo.unfollowOrganization(users[i].uuid, organization.slug);
+
+    const getUsersResponse = await UserRepo.getUsersFollowingOrganization(organization.slug);
+    expect(getUsersResponse).toHaveLength(1);
+  });
+});
+
 // testing with user.test.ts instead of a separate weekly debrief file because
 // mutations are done with UserRepo, also because testing WeeklyDebrief requires
 // mocking which isn't a priority as of right now
@@ -125,6 +182,21 @@ describe('weekly debrief tests:', () => {
     expect(getUsersResponse.numBookmarkedArticles).toEqual(1);
   });
 
+  test('appendReadFlyer', async () => {
+    const users = await UserFactory.create(1);
+    const flyers = await FlyerFactory.create(1);
+    await UserModel.insertMany(users);
+    const insertOutput = await FlyerModel.insertMany(flyers);
+    await UserRepo.appendReadFlyer(users[0].uuid, insertOutput[0].id);
+
+    // update database
+    const pub = await PublicationFactory.getRandomPublication();
+    await UserRepo.followPublication(users[0].uuid, pub.slug);
+
+    const getUsersResponse = await UserRepo.getUserByUUID(users[0].uuid);
+    expect(getUsersResponse.readFlyers).toHaveLength(1);
+  });
+
   test('appendReadMagazine', async () => {
     const users = await UserFactory.create(1);
     const magazines = await MagazineFactory.create(1);