dont send email after manual recalculation, sensible default noti preferences

Author: Tschonti

packages/functions/src/functions/auth/login.ts

@@ -25,9 +25,8 @@ export const login = async (req: HttpRequest, context: InvocationContext): Promi
       const emailRecord = new EmailRecipient()
       emailRecord.userId = user.szemely_id
       emailRecord.email = user.email
-      // TODO only temporary
-      emailRecord.eventImportedNotifications = EventImportedNotificationOptions.ALL
-      emailRecord.resultNotifications = ResultNotificationOptions.ALL
+      emailRecord.eventImportedNotifications = EventImportedNotificationOptions.ONLY_NATIONAL
+      emailRecord.resultNotifications = ResultNotificationOptions.ONLY_RATED
       await emailRepo.save(emailRecord)
     } else if (userEmail.email !== user.email) {
       userEmail.email = user.email

packages/functions/src/functions/events/closeRating/closeRatingOrchestrator.ts

@@ -11,6 +11,10 @@ import { validateRatingsActivityName } from './validateRatingsActivity'
 export const orchestratorName = 'closeRatingOrchestrator'
 export type ActivityOutput = { eventId: number; success: boolean }
 export type CalculateRatingsActivityOutput = ActivityOutput & { actualResults: boolean }
+export type OrchestratorParams = {
+  sendNotification: boolean
+  events: { eventId: number; state: EventState }[]
+}
 
 /**
  * Durable Functions orchestrator function that executes the activies that validate and accumulate the ratings of finished events.
@@ -29,12 +33,14 @@ export type CalculateRatingsActivityOutput = ActivityOutput & { actualResults: b
  *    Called in parallel for all events whose ratings were successfully validated and events that are in the ACCUMULATING phase (because previous accumulation failed)
  * 4. SendNotifications
  *    Activity to send notifications to subscribed users about the newly published rating results.
- *    Only called if at least event has been closed with meaningful results (more than one rating). Called just once with the events that have meaningful results.
+ *    Only called if at least event has been closed with meaningful results (more than one rating),
+ *    the app is running in production mode and the orchestration was initiated by the close rating starter (called automatically at night), not the manual recalculate function.
+ *    Called just once with the events that have meaningful results.
  * 5. PublishOrchestrationResults
  *    If the accumulation succeeded for at least one event, this activity is called once to save the Alert to the DB to notify the admins that the accumulation has finished.
  */
 const orchestrator: OrchestrationHandler = function* (context: OrchestrationContext) {
-  const events: { eventId: number; state: EventState }[] = context.df.getInput()
+  const { events, sendNotification }: OrchestratorParams = context.df.getInput()
   context.log(`Orchestrator function started, starting the validation of ratings for ${events.length} event(s).`)
 
   const eventsToRedo = events.filter((e) => e.state !== EventState.VALIDATING)
@@ -67,7 +73,7 @@ const orchestrator: OrchestrationHandler = function* (context: OrchestrationCont
   const accumulationSuccess = accumulationResults.filter((r) => r.success)
   if (accumulationSuccess.length > 0) {
     const eventsWithMeaningfulResults = accumulationSuccess.filter((r) => r.actualResults).map((r) => r.eventId)
-    if (eventsWithMeaningfulResults.length > 0 && ENV === 'production') {
+    if (eventsWithMeaningfulResults.length > 0 && ENV === 'production' && sendNotification) {
       yield context.df.callActivity(sendNotificationsActivityName, eventsWithMeaningfulResults)
     }
     yield context.df.callActivity(publishOrchestrationResultsActivityName, accumulationSuccess.length)

packages/functions/src/functions/events/closeRating/closeRatingStarter.ts

@@ -34,7 +34,9 @@ const closeRatingStarter = async (myTimer: Timer, context: InvocationContext): P
     const toClose = [...toArchive, ...eventsWithoutResults.filter((e) => e.state !== EventState.RATEABLE)]
     if (toClose.length > 0) {
       const client = df.getClient(context)
-      const instanceId = await client.startNew(orchestratorName, { input: toClose.map((e) => ({ eventId: e.id, state: e.state })) })
+      const instanceId = await client.startNew(orchestratorName, {
+        input: { sendNotification: true, events: toClose.map((e) => ({ eventId: e.id, state: e.state })) },
+      })
       context.log(`Started orchestration with ID = '${instanceId}'.`)
     }
   } catch (error) {

packages/functions/src/functions/seasons/recalculate.ts

@@ -42,7 +42,7 @@ const recalculateRatingsInSeason = async (req: HttpRequest, context: InvocationC
       await ads.getRepository(Event).save(invalidatedEvents)
       const client = df.getClient(context)
       const instanceId = await client.startNew(orchestratorName, {
-        input: invalidatedEvents.map((e) => ({ eventId: e.id, state: e.state })),
+        input: { sendNotification: false, events: invalidatedEvents.map((e) => ({ eventId: e.id, state: e.state })) },
       })
       context.log(`Started orchestration with ID = '${instanceId}'.`)
     } else {