Eagle eye email digest

backend/config/custom-environment-variables.json

@@ -94,6 +94,7 @@
     "templateWeeklyAnalytics": "CROWD_SENDGRID_TEMPLATE_WEEKLY_ANALYTICS",
     "templateIntegrationDone": "CROWD_SENDGRID_TEMPLATE_INTEGRATION_DONE",
     "templateCsvExport": "CROWD_SENDGRID_TEMPLATE_CSV_EXPORT",
+    "templateEagleEyeDigest": "CROWD_SENDGRID_TEMPLATE_EAGLE_EYE_DIGEST",
     "weeklyAnalyticsUnsubscribeGroupId": "CROWD_SENDGRID_WEEKLY_ANALYTICS_UNSUBSCRIBE_GROUP_ID"
   },
   "plans": {

backend/src/bin/jobs/eagleEyeEmailDigestTicks.ts

@@ -0,0 +1,55 @@
+import { Op } from 'sequelize'
+import moment from 'moment'
+import SequelizeRepository from '../../database/repositories/sequelizeRepository'
+import { CrowdJob } from '../../types/jobTypes'
+import { sendNodeWorkerMessage } from '../../serverless/utils/nodeWorkerSQS'
+import { NodeWorkerMessageType } from '../../serverless/types/workerTypes'
+import { NodeWorkerMessageBase } from '../../types/mq/nodeWorkerMessageBase'
+
+const job: CrowdJob = {
+  name: 'Eagle Eye Email Digest Ticker',
+  // every half hour
+  cronTime: '*/30 * * * *',
+  onTrigger: async () => {
+    const options = await SequelizeRepository.getDefaultIRepositoryOptions()
+    const users = (
+      await options.database.user.findAll({
+        where: {
+          [Op.and]: [
+            {
+              'eagleEyeSettings.emailDigestActive': {
+                [Op.ne]: null,
+              },
+            },
+            {
+              'eagleEyeSettings.emailDigestActive': {
+                [Op.eq]: true,
+              },
+            },
+          ],
+        },
+        include: [
+          {
+            model: options.database.tenantUser,
+            as: 'tenants',
+          },
+        ],
+      })
+    ).filter(
+      (u) =>
+        u.eagleEyeSettings &&
+        u.eagleEyeSettings.emailDigestActive &&
+        moment() > moment(u.eagleEyeSettings.emailDigest.nextEmailAt),
+    )
+
+    for (const user of users) {
+      await sendNodeWorkerMessage(user.id, {
+        type: NodeWorkerMessageType.NODE_MICROSERVICE,
+        user: user.id,
+        service: 'eagle-eye-email-digest',
+      } as NodeWorkerMessageBase)
+    }
+  },
+}
+
+export default job

backend/src/bin/jobs/index.ts

@@ -5,6 +5,7 @@ import memberScoreCoordinator from './memberScoreCoordinator'
 import checkSqsQueues from './checkSqsQueues'
 import refreshMaterializedViews from './refreshMaterializedViews'
 import downgradeExpiredPlans from './downgradeExpiredPlans'
+import eagleEyeEmailDigestTicks from './eagleEyeEmailDigestTicks'
 
 const jobs: CrowdJob[] = [
   weeklyAnalyticsEmailsCoordinator,
@@ -13,6 +14,7 @@ const jobs: CrowdJob[] = [
   checkSqsQueues,
   refreshMaterializedViews,
   downgradeExpiredPlans,
+  eagleEyeEmailDigestTicks,
 ]
 
 export default jobs

backend/src/bin/scripts/send-weekly-analytics-email.ts

@@ -9,7 +9,8 @@ import { timeout } from '../../utils/timing'
 import { sendNodeWorkerMessage } from '../../serverless/utils/nodeWorkerSQS'
 import { NodeWorkerMessageType } from '../../serverless/types/workerTypes'
 import { NodeWorkerMessageBase } from '../../types/mq/nodeWorkerMessageBase'
-import WeeklyAnalyticsEmailsHistoryRepository from '../../database/repositories/weeklyAnalyticsEmailsHistoryRepository'
+import RecurringEmailsHistoryRepository from '../../database/repositories/recurringEmailsHistoryRepository'
+import { RecurringEmailType } from '../../types/recurringEmailsHistoryTypes'
 
 const banner = fs.readFileSync(path.join(__dirname, 'banner.txt'), 'utf8')
 
@@ -55,12 +56,16 @@ if (parameters.help || !parameters.tenant) {
     const options = await SequelizeRepository.getDefaultIRepositoryOptions()
     const tenantIds = parameters.tenant.split(',')
     const weekOfYear = moment().utc().startOf('isoWeek').subtract(7, 'days').isoWeek().toString()
-    const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(options)
+    const rehRepository = new RecurringEmailsHistoryRepository(options)
 
     for (const tenantId of tenantIds) {
       const tenant = await options.database.tenant.findByPk(tenantId)
       const isEmailAlreadySent =
-        (await waeRepository.findByWeekOfYear(tenantId, weekOfYear)) !== null
+        (await rehRepository.findByWeekOfYear(
+          tenantId,
+          weekOfYear,
+          RecurringEmailType.WEEKLY_ANALYTICS,
+        )) !== null
 
       if (!tenant) {
         log.error({ tenantId }, 'Tenant not found! Skipping.')

backend/src/config/configTypes.ts

@@ -156,6 +156,7 @@ export interface SendgridConfiguration {
   templateWeeklyAnalytics: string
   templateIntegrationDone: string
   templateCsvExport: string
+  templateEagleEyeDigest: string
   weeklyAnalyticsUnsubscribeGroupId: string
 }
 

backend/src/config/index.ts

@@ -204,6 +204,7 @@ export const SENDGRID_CONFIG: SendgridConfiguration = KUBE_MODE
       templateWeeklyAnalytics: process.env.SENDGRID_TEMPLATE_WEEKLY_ANALYTICS,
       templateIntegrationDone: process.env.SENDGRID_TEMPLATE_INTEGRATION_DONE,
       templateCsvExport: process.env.SENDGRID_TEMPLATE_CSV_EXPORT,
+      templateEagleEyeDigest: process.env.SENDGRID_TEMPLATE_EAGLE_EYE_DIGEST,
     }
 
 export const NETLIFY_CONFIG: NetlifyConfiguration = KUBE_MODE

backend/src/database/migrations/V1676555340__recurringEmailsHistory.sql

@@ -0,0 +1,12 @@
+ALTER TABLE public."weeklyAnalyticsEmailsHistory" RENAME TO "recurringEmailsHistory";
+
+CREATE TYPE public."recurringEmailTypes_type" AS ENUM ('weekly-analytics', 'eagle-eye-digest');
+
+ALTER TABLE "recurringEmailsHistory" ADD COLUMN "type"  public."recurringEmailTypes_type";
+
+UPDATE "recurringEmailsHistory" SET "type"='weekly-analytics';
+
+ALTER TABLE "recurringEmailsHistory" ALTER COLUMN "type" SET NOT NULL; 
+ALTER TABLE "recurringEmailsHistory" ALTER COLUMN "weekOfYear" DROP NOT NULL; 
+
+

backend/src/database/repositories/__tests__/weeklyAnalyticsEmailsHistoryRepository.test.ts → backend/src/database/repositories/__tests__/recurringEmailsHistoryRepository.test.ts

@@ -1,12 +1,15 @@
 import { randomUUID } from 'crypto'
 
 import SequelizeTestUtils from '../../utils/sequelizeTestUtils'
-import { WeeklyAnalyticsEmailsHistoryData } from '../../../types/weeklyAnalyticsEmailsHistoryTypes'
-import WeeklyAnalyticsEmailsHistoryRepository from '../weeklyAnalyticsEmailsHistoryRepository'
+import {
+  RecurringEmailsHistoryData,
+  RecurringEmailType,
+} from '../../../types/recurringEmailsHistoryTypes'
+import RecurringEmailsHistoryRepository from '../recurringEmailsHistoryRepository'
 
 const db = null
 
-describe('WeeklyAnalyticsEmailsHistory tests', () => {
+describe('RecurringEmailsHistory tests', () => {
   beforeEach(async () => {
     await SequelizeTestUtils.wipeDatabase(db)
   })
@@ -18,18 +21,19 @@ describe('WeeklyAnalyticsEmailsHistory tests', () => {
   })
 
   describe('create method', () => {
-    it('Should create weekly analytics email history with given values', async () => {
+    it('Should create recurring email history with given values', async () => {
       const mockIRepositoryOptions = await SequelizeTestUtils.getTestIRepositoryOptions(db)
 
-      const historyData: WeeklyAnalyticsEmailsHistoryData = {
+      const historyData: RecurringEmailsHistoryData = {
         emailSentAt: '2023-01-02T00:00:00Z',
+        type: RecurringEmailType.WEEKLY_ANALYTICS,
         emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
         tenantId: mockIRepositoryOptions.currentTenant.id,
         weekOfYear: '1',
       }
 
-      const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(mockIRepositoryOptions)
-      const history = await waeRepository.create(historyData)
+      const rehRepository = new RecurringEmailsHistoryRepository(mockIRepositoryOptions)
+      const history = await rehRepository.create(historyData)
 
       expect(new Date(historyData.emailSentAt)).toStrictEqual(history.emailSentAt)
       expect(historyData.emailSentTo).toStrictEqual(history.emailSentTo)
@@ -40,40 +44,43 @@ describe('WeeklyAnalyticsEmailsHistory tests', () => {
     it('Should throw an error when mandatory fields are missing', async () => {
       const mockIRepositoryOptions = await SequelizeTestUtils.getTestIRepositoryOptions(db)
 
-      const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(mockIRepositoryOptions)
+      const rehRepository = new RecurringEmailsHistoryRepository(mockIRepositoryOptions)
       await expect(() =>
-        waeRepository.create({
+        rehRepository.create({
           emailSentAt: '2023-01-02T00:00:00Z',
           emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
           tenantId: mockIRepositoryOptions.currentTenant.id,
-          weekOfYear: undefined,
+          type: undefined,
         }),
       ).rejects.toThrowError()
 
       await expect(() =>
-        waeRepository.create({
+        rehRepository.create({
           emailSentAt: undefined,
           emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
           tenantId: mockIRepositoryOptions.currentTenant.id,
           weekOfYear: '1',
+          type: RecurringEmailType.WEEKLY_ANALYTICS,
         }),
       ).rejects.toThrowError()
 
       await expect(() =>
-        waeRepository.create({
+        rehRepository.create({
           emailSentAt: '2023-01-02T00:00:00Z',
           emailSentTo: undefined,
           tenantId: mockIRepositoryOptions.currentTenant.id,
           weekOfYear: '1',
+          type: RecurringEmailType.WEEKLY_ANALYTICS,
         }),
       ).rejects.toThrowError()
 
       await expect(() =>
-        waeRepository.create({
+        rehRepository.create({
           emailSentAt: '2023-01-02T00:00:00Z',
           emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
           tenantId: undefined,
           weekOfYear: '1',
+          type: RecurringEmailType.WEEKLY_ANALYTICS,
         }),
       ).rejects.toThrowError()
     })
@@ -83,26 +90,27 @@ describe('WeeklyAnalyticsEmailsHistory tests', () => {
     it('Should find historical receipt by id', async () => {
       const mockIRepositoryOptions = await SequelizeTestUtils.getTestIRepositoryOptions(db)
 
-      const historyData: WeeklyAnalyticsEmailsHistoryData = {
+      const historyData: RecurringEmailsHistoryData = {
         emailSentAt: '2023-01-02T00:00:00Z',
         emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
         tenantId: mockIRepositoryOptions.currentTenant.id,
         weekOfYear: '1',
+        type: RecurringEmailType.WEEKLY_ANALYTICS,
       }
 
-      const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(mockIRepositoryOptions)
+      const rehRepository = new RecurringEmailsHistoryRepository(mockIRepositoryOptions)
 
-      const receiptCreated = await waeRepository.create(historyData)
-      const receiptFoundById = await waeRepository.findById(receiptCreated.id)
+      const receiptCreated = await rehRepository.create(historyData)
+      const receiptFoundById = await rehRepository.findById(receiptCreated.id)
 
       expect(receiptFoundById).toStrictEqual(receiptCreated)
     })
 
     it('Should return null for non-existing receipt entry', async () => {
       const mockIRepositoryOptions = await SequelizeTestUtils.getTestIRepositoryOptions(db)
-      const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(mockIRepositoryOptions)
+      const rehRepository = new RecurringEmailsHistoryRepository(mockIRepositoryOptions)
 
-      const cache = await waeRepository.findById(randomUUID())
+      const cache = await rehRepository.findById(randomUUID())
       expect(cache).toBeNull()
     })
   })
@@ -111,29 +119,32 @@ describe('WeeklyAnalyticsEmailsHistory tests', () => {
     it('Should find historical receipt by week of year', async () => {
       const mockIRepositoryOptions = await SequelizeTestUtils.getTestIRepositoryOptions(db)
 
-      const historyData: WeeklyAnalyticsEmailsHistoryData = {
+      const historyData: RecurringEmailsHistoryData = {
         emailSentAt: '2023-01-02T00:00:00Z',
         emailSentTo: ['anil@crowd.dev', 'uros@crowd.dev'],
         tenantId: mockIRepositoryOptions.currentTenant.id,
         weekOfYear: '1',
+        type: RecurringEmailType.EAGLE_EYE_DIGEST,
       }
 
-      const waeRepository = new WeeklyAnalyticsEmailsHistoryRepository(mockIRepositoryOptions)
+      const rehRepository = new RecurringEmailsHistoryRepository(mockIRepositoryOptions)
 
-      const receiptCreated = await waeRepository.create(historyData)
+      const receiptCreated = await rehRepository.create(historyData)
 
       // should find recently created receipt
-      let receiptFound = await waeRepository.findByWeekOfYear(
+      let receiptFound = await rehRepository.findByWeekOfYear(
         mockIRepositoryOptions.currentTenant.id,
         '1',
+        RecurringEmailType.EAGLE_EYE_DIGEST,
       )
 
       expect(receiptCreated).toStrictEqual(receiptFound)
 
       // shouldn't find any receipts
-      receiptFound = await waeRepository.findByWeekOfYear(
+      receiptFound = await rehRepository.findByWeekOfYear(
         mockIRepositoryOptions.currentTenant.id,
         '2',
+        RecurringEmailType.EAGLE_EYE_DIGEST,
       )
 
       expect(receiptFound).toBeNull()

backend/src/database/repositories/weeklyAnalyticsEmailsHistoryRepository.ts → backend/src/database/repositories/recurringEmailsHistoryRepository.ts

@@ -1,13 +1,16 @@
 import { v4 as uuid } from 'uuid'
 import { QueryTypes } from 'sequelize'
-import { WeeklyAnalyticsEmailsHistoryData } from '../../types/weeklyAnalyticsEmailsHistoryTypes'
+import {
+  RecurringEmailsHistoryData,
+  RecurringEmailType,
+} from '../../types/recurringEmailsHistoryTypes'
 import { IRepositoryOptions } from './IRepositoryOptions'
 import { RepositoryBase } from './repositoryBase'
 
-class WeeklyAnalyticsEmailsHistoryRepository extends RepositoryBase<
-  WeeklyAnalyticsEmailsHistoryData,
+class RecurringEmailsHistoryRepository extends RepositoryBase<
+  RecurringEmailsHistoryData,
   string,
-  WeeklyAnalyticsEmailsHistoryData,
+  RecurringEmailsHistoryData,
   unknown,
   unknown
 > {
@@ -16,23 +19,24 @@ class WeeklyAnalyticsEmailsHistoryRepository extends RepositoryBase<
   }
 
   /**
-   * Inserts weekly analytics email history.
-   * @param data weekly emails historical data
+   * Inserts recurring emails receipt history.
+   * @param data recurring emails historical data
    * @param options
    * @returns
    */
-  async create(data: WeeklyAnalyticsEmailsHistoryData): Promise<WeeklyAnalyticsEmailsHistoryData> {
+  async create(data: RecurringEmailsHistoryData): Promise<RecurringEmailsHistoryData> {
     const historyInserted = await this.options.database.sequelize.query(
-      `INSERT INTO "weeklyAnalyticsEmailsHistory" ("id", "tenantId", "weekOfYear", "emailSentAt", "emailSentTo")
+      `INSERT INTO "recurringEmailsHistory" ("id", "type", "tenantId", "weekOfYear", "emailSentAt", "emailSentTo")
           VALUES
-              (:id, :tenantId, :weekOfYear, :emailSentAt, ARRAY[:emailSentTo])
+              (:id, :type, :tenantId, :weekOfYear, :emailSentAt, ARRAY[:emailSentTo])
           RETURNING "id"
         `,
       {
         replacements: {
           id: uuid(),
+          type: data.type,
           tenantId: data.tenantId,
-          weekOfYear: data.weekOfYear,
+          weekOfYear: data.weekOfYear || null,
           emailSentAt: data.emailSentAt,
           emailSentTo: data.emailSentTo,
         },
@@ -55,17 +59,20 @@ class WeeklyAnalyticsEmailsHistoryRepository extends RepositoryBase<
   async findByWeekOfYear(
     tenantId: string,
     weekOfYear: string,
-  ): Promise<WeeklyAnalyticsEmailsHistoryData> {
+    type: RecurringEmailType,
+  ): Promise<RecurringEmailsHistoryData> {
     const records = await this.options.database.sequelize.query(
       `SELECT *
-             FROM "weeklyAnalyticsEmailsHistory"
+             FROM "recurringEmailsHistory"
              WHERE "tenantId" = :tenantId
-             AND "weekOfYear" = :weekOfYear;
+             AND "weekOfYear" = :weekOfYear
+             and "type" = :type;
             `,
       {
         replacements: {
           tenantId,
           weekOfYear,
+          type,
         },
         type: QueryTypes.SELECT,
       },
@@ -85,10 +92,10 @@ class WeeklyAnalyticsEmailsHistoryRepository extends RepositoryBase<
    * @param options
    * @returns
    */
-  async findById(id: string): Promise<WeeklyAnalyticsEmailsHistoryData> {
+  async findById(id: string): Promise<RecurringEmailsHistoryData> {
     const records = await this.options.database.sequelize.query(
       `SELECT *
-             FROM "weeklyAnalyticsEmailsHistory"
+             FROM "recurringEmailsHistory"
              WHERE id = :id;
             `,
       {
@@ -107,4 +114,4 @@ class WeeklyAnalyticsEmailsHistoryRepository extends RepositoryBase<
   }
 }
 
-export default WeeklyAnalyticsEmailsHistoryRepository
+export default RecurringEmailsHistoryRepository