Send email when an issue is escalating

We want to let users know when an issue is escalating. To do that we'll
send an email to all the members of the workspaces that have activated
the notifications for escalating issues.

Author: andresgutgon

apps/web/public/latitude-logo.png

@@ -0,0 +1,24 @@
+'use server'
+
+import { MembershipsRepository } from '@latitude-data/core/repositories'
+import { updateEscalatingIssuesEmailPreference } from '@latitude-data/core/services/memberships/updateEscalatingIssuesEmailPreference'
+import { z } from 'zod'
+
+import { authProcedure } from '../procedures'
+
+export const updateEscalatingIssuesEmailPreferenceAction = authProcedure
+  .inputSchema(z.object({ wantToReceive: z.boolean() }))
+  .action(
+    async ({ parsedInput: { wantToReceive }, ctx: { workspace, user } }) => {
+      const membershipsScope = new MembershipsRepository(workspace.id)
+      const membership = await membershipsScope
+        .findByUserId(user.id)
+        .then((r) => r.unwrap())
+
+      return await updateEscalatingIssuesEmailPreference({
+        membership,
+        wantToReceive,
+        userEmail: user.email,
+      }).then((r) => r.unwrap())
+    },
+  )

apps/web/src/actions/memberships/updateEscalatingIssuesEmailPreference.ts

@@ -0,0 +1,24 @@
+'use server'
+
+import { MembershipsRepository } from '@latitude-data/core/repositories'
+import { updateWeeklyEmailPreference } from '@latitude-data/core/services/memberships/updateWeeklyEmailPreference'
+import { z } from 'zod'
+
+import { authProcedure } from '../procedures'
+
+export const updateWeeklyEmailPreferenceAction = authProcedure
+  .inputSchema(z.object({ wantToReceive: z.boolean() }))
+  .action(
+    async ({ parsedInput: { wantToReceive }, ctx: { workspace, user } }) => {
+      const membershipsScope = new MembershipsRepository(workspace.id)
+      const membership = await membershipsScope
+        .findByUserId(user.id)
+        .then((r) => r.unwrap())
+
+      return await updateWeeklyEmailPreference({
+        membership,
+        wantToReceive,
+        userEmail: user.email,
+      }).then((r) => r.unwrap())
+    },
+  )

apps/web/src/actions/memberships/updateWeeklyEmailPreference.ts

@@ -7,11 +7,13 @@ import { setSession } from '$/services/auth/setSession'
 import { authProcedure } from '../procedures'
 import { cookies } from 'next/headers'
 import { removeSession, Session } from '$/services/auth/removeSession'
+import { redirect } from 'next/navigation'
 
 export const switchWorkspaceAction = authProcedure
   .inputSchema(
     z.object({
       workspaceId: z.number(),
+      redirectTo: z.string().optional(),
     }),
   )
   .action(async ({ parsedInput, ctx }) => {
@@ -37,5 +39,9 @@ export const switchWorkspaceAction = authProcedure
       await cookies(),
     )
 
+    if (parsedInput.redirectTo) {
+      return redirect(parsedInput.redirectTo)
+    }
+
     return workspace
   })

apps/web/src/actions/workspaces/switch.ts

@@ -2,10 +2,10 @@ import { ReactNode } from 'react'
 
 import buildMetatags from '$/app/_lib/buildMetatags'
 import { getCurrentUserOrRedirect } from '$/services/auth/getCurrentUser'
-import { SessionProvider } from '@latitude-data/web-ui/providers'
 import { notFound } from 'next/navigation'
 
 import { BackofficeTabs } from './_components/BackofficeTabs'
+import { SessionProvider } from '$/components/Providers/SessionProvider'
 
 export const metadata = buildMetatags({
   title: 'Backoffice',

apps/web/src/app/(admin)/backoffice/layout.tsx

@@ -0,0 +1,12 @@
+import { Metadata } from 'next'
+import buildMetatags from '$/app/_lib/buildMetatags'
+import NotificationsModal from '$/components/Notifications/Modal'
+
+export const metadata: Promise<Metadata> = buildMetatags({
+  title: 'Notifications',
+  locationDescription: 'Email Notifications',
+})
+
+export default function NotificationsModalPage() {
+  return <NotificationsModal />
+}

apps/web/src/app/(private)/@modal/(.)notifications/page.tsx

@@ -0,0 +1,3 @@
+export default function Default() {
+  return null
+}

apps/web/src/app/(private)/@modal/default.tsx

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react'
+import { Metadata } from 'next'
 
 import { Container } from '@latitude-data/web-ui/atoms/Container'
 import { TableBlankSlate } from '@latitude-data/web-ui/molecules/TableBlankSlate'
@@ -12,15 +13,17 @@ import Link from 'next/link'
 import { getActiveProjectsCached } from '../_data-access'
 import { ProjectsTable } from './_components/ProjectsTable'
 
-export const metadata = buildMetatags({
+export const metadata: Promise<Metadata> = buildMetatags({
   title: 'Dashboard',
   locationDescription: 'Projects List',
 })
 
 export default async function DashboardLayout({
   children,
+  modal,
 }: Readonly<{
   children: ReactNode
+  modal: ReactNode
 }>) {
   const { workspace } = await getCurrentUserOrRedirect()
 
@@ -30,6 +33,7 @@ export default async function DashboardLayout({
     <Container>
       <AppTabs />
       {children}
+      {modal}
       <TableWithHeader
         title='Projects'
         actions={

apps/web/src/app/(private)/dashboard/layout.tsx

@@ -0,0 +1,56 @@
+'use client'
+
+import { ROUTES } from '$/services/routes'
+import { Text } from '@latitude-data/web-ui/atoms/Text'
+import { useOnce } from '$/hooks/useMount'
+import { switchWorkspaceAction } from '$/actions/workspaces/switch'
+import useLatitudeAction from '$/hooks/useLatitudeAction'
+import { useToast } from '@latitude-data/web-ui/atoms/Toast'
+
+/**
+ * We do this here because next.js page can't change server cookies on the fly
+ * so we need to have a client component that calls the action to switch workspace
+ * and then redirect to the notifications page.
+ */
+export function WorkspaceSwitcherRedirect({
+  targetWorkspaceId,
+}: {
+  targetWorkspaceId: number
+}) {
+  const { toast } = useToast()
+  const { execute: switchWorkspace, isPending: isSwitching } =
+    useLatitudeAction(switchWorkspaceAction)
+
+  useOnce(() => {
+    async function performSwitch() {
+      const [, error] = await switchWorkspace({
+        workspaceId: targetWorkspaceId,
+        redirectTo: ROUTES.dashboard.notifications.root,
+      })
+
+      if (error) {
+        toast({
+          title: 'Failed to switch workspace',
+          description: error.message,
+          variant: 'destructive',
+        })
+
+        return
+      }
+    }
+
+    performSwitch()
+  })
+
+  return (
+    <div className='flex items-center justify-center min-h-screen'>
+      <div className='flex flex-col items-center gap-4'>
+        <Text.H4>
+          {isSwitching
+            ? 'Switching workspace...'
+            : 'Redirecting to notifications...'}
+        </Text.H4>
+      </div>
+    </div>
+  )
+}

apps/web/src/app/(private)/dashboard/notifications/[workspaceId]/_components/WorkspaceSwitcherRedirect.tsx

@@ -0,0 +1,44 @@
+import { notFound, redirect } from 'next/navigation'
+import { getCurrentUserOrRedirect } from '$/services/auth/getCurrentUser'
+import { WorkspaceSwitcherRedirect } from './_components/WorkspaceSwitcherRedirect'
+import { ROUTES } from '$/services/routes'
+import { WorkspacesRepository } from '@latitude-data/core/repositories'
+import { Result } from '@latitude-data/core/lib/Result'
+
+/**
+ * Handle notifications page by workspace id
+ *
+ * 1. If this workspace is valid we find if the user in the current session
+ * (if any) has a membership in that workspace. If not current session we
+ * redirect to login page with `redirectTo` param set to this page.
+ *
+ * 2. If the user has a membership in that workspace but is not the current
+ * workspace we render workspace switcher redirect component to switch to that
+ * so frontend can set the right session in cookies.
+ *
+ * 3. If the user has membership to that workspace and it's the current workspace
+ * we redirect to the default notifications page
+ *
+ */
+export default async function NotificationsByWorkspacePage({
+  params,
+}: {
+  params: Promise<{ workspaceId: string }>
+}) {
+  const { user: currentUser, workspace: currentWorkspace } =
+    await getCurrentUserOrRedirect()
+
+  const paramsResolved = await params
+  const workspaceId = parseInt(paramsResolved.workspaceId, 10)
+  const workspaceRepo = new WorkspacesRepository(currentUser.id)
+  const workspaceResult = await workspaceRepo.find(workspaceId)
+
+  if (!Result.isOk(workspaceResult)) return notFound()
+
+  const workspace = workspaceResult.value
+  if (workspace.id === currentWorkspace.id) {
+    return redirect(ROUTES.dashboard.notifications.root)
+  }
+
+  return <WorkspaceSwitcherRedirect targetWorkspaceId={workspace.id} />
+}