@atproto/ozone 0.1.172 → 0.1.174

package/src/api/report/getLiveStats.ts

@@ -0,0 +1,26 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { viewLiveStats } from '../../report/views'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getLiveStats({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const { queueId, moderatorDid, reportTypes } = params
+
+      const reportStatsService = ctx.reportStatsService(ctx.db)
+      const row = await reportStatsService.getLiveStats({
+        queueId: queueId ?? null,
+        moderatorDid: moderatorDid ?? null,
+        reportTypes: reportTypes?.length ? reportTypes : null,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {
+          stats: viewLiveStats(row),
+        },
+      }
+    },
+  })
+}

package/src/api/report/getReport.ts

@@ -0,0 +1,55 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getReportById } from '../../mod-service/report'
+import { buildReportView, hydrateReportInfo } from '../../report/views'
+import { getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.getReport({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params, auth, req }) => {
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const labelers = ctx.reqLabelers(req)
+
+      const report = await getReportById(db, params.id)
+      if (!report) {
+        throw new InvalidRequestError(
+          `Report not found: ${params.id}`,
+          'NotFound',
+        )
+      }
+
+      const queueService = ctx.queueService(db)
+      const teamService = ctx.teamService(db)
+      const [hydrated, actionEvents] = await Promise.all([
+        hydrateReportInfo(
+          [report],
+          modService.views,
+          (dids) => getPdsAccountInfos(ctx, dids),
+          (queueIds) => queueService.getViewsByIds(queueIds),
+          (dids) => teamService.viewByDids(dids),
+          labelers,
+        ),
+        Array.isArray(report.actionEventIds) && report.actionEventIds.length
+          ? modService.getEventsByIds(report.actionEventIds as number[])
+          : Promise.resolve([]),
+      ])
+
+      const actions = actionEvents.map((evt) =>
+        modService.views.formatEvent(evt),
+      )
+
+      return {
+        encoding: 'application/json',
+        body: buildReportView(
+          report,
+          hydrated,
+          auth.credentials.isModerator,
+          actions,
+        ),
+      }
+    },
+  })
+}

package/src/api/report/listActivities.ts

@@ -0,0 +1,34 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { formatActivityView, listReportActivities } from '../../report/activity'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.listActivities({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params }) => {
+      const { reportId, limit, cursor } = params
+
+      const { activities, cursor: nextCursor } = await listReportActivities(
+        ctx.db,
+        { reportId, limit, cursor },
+      )
+
+      // Fetch team members for all createdBy DIDs
+      const createdByDids = Array.from(
+        new Set(activities.map((a) => a.createdBy)),
+      )
+      const teamService = ctx.teamService(ctx.db)
+      const memberViews = await teamService.viewByDids(createdByDids)
+
+      return {
+        encoding: 'application/json',
+        body: {
+          activities: activities.map((activity) =>
+            formatActivityView(activity, memberViews),
+          ),
+          cursor: nextCursor,
+        },
+      }
+    },
+  })
+}

package/src/api/report/queryReports.ts

@@ -0,0 +1,44 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { queryReports } from '../../mod-service/report'
+import { buildReportView, hydrateReportInfo } from '../../report/views'
+import { getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.queryReports({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ params, auth, req }) => {
+      const db = ctx.db
+      const modService = ctx.modService(db)
+      const labelers = ctx.reqLabelers(req)
+
+      const { reports: reportsToReturn, cursor } = await queryReports(
+        db,
+        params,
+      )
+
+      const queueService = ctx.queueService(db)
+      const teamService = ctx.teamService(db)
+      const hydrated = await hydrateReportInfo(
+        reportsToReturn,
+        modService.views,
+        (dids) => getPdsAccountInfos(ctx, dids),
+        (queueIds) => queueService.getViewsByIds(queueIds),
+        (dids) => teamService.viewByDids(dids),
+        labelers,
+      )
+
+      const reportViews = reportsToReturn.map((report) =>
+        buildReportView(report, hydrated, auth.credentials.isModerator),
+      )
+
+      return {
+        encoding: 'application/json',
+        body: {
+          cursor,
+          reports: reportViews,
+        },
+      }
+    },
+  })
+}

package/src/api/report/reassignQueue.ts

@@ -0,0 +1,68 @@
+import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getReportById } from '../../mod-service/report'
+import { reassignReportQueue } from '../../report/reassign'
+import { buildReportView, hydrateReportInfo } from '../../report/views'
+import { getAuthDid, getPdsAccountInfos } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.reassignQueue({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth, req }) => {
+      const createdBy =
+        getAuthDid(auth, ctx.cfg.service.did) ?? ctx.cfg.service.did
+      const db = ctx.db
+      const queueService = ctx.queueService(db)
+
+      await reassignReportQueue(db, queueService, {
+        reportId: input.body.reportId,
+        toQueueId: input.body.queueId,
+        comment: input.body.comment,
+        createdBy,
+      })
+
+      const report = await getReportById(db, input.body.reportId)
+      if (!report) {
+        throw new InvalidRequestError(
+          `Report ${input.body.reportId} not found after reassignment`,
+          'ReportNotFound',
+        )
+      }
+
+      const modService = ctx.modService(db)
+      const teamService = ctx.teamService(db)
+      const labelers = ctx.reqLabelers(req)
+
+      const [hydrated, actionEvents] = await Promise.all([
+        hydrateReportInfo(
+          [report],
+          modService.views,
+          (dids) => getPdsAccountInfos(ctx, dids),
+          (queueIds) => queueService.getViewsByIds(queueIds),
+          (dids) => teamService.viewByDids(dids),
+          labelers,
+        ),
+        Array.isArray(report.actionEventIds) && report.actionEventIds.length
+          ? modService.getEventsByIds(report.actionEventIds as number[])
+          : Promise.resolve([]),
+      ])
+
+      const actions = actionEvents.map((evt) =>
+        modService.views.formatEvent(evt),
+      )
+
+      return {
+        encoding: 'application/json',
+        body: {
+          report: buildReportView(
+            report,
+            hydrated,
+            auth.credentials.isModerator,
+            actions,
+          ),
+        },
+      }
+    },
+  })
+}

package/src/api/report/refreshStats.ts

@@ -0,0 +1,27 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.refreshStats({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const access = auth.credentials
+      if (!access.isModerator) {
+        throw new Error('Must be a moderator to refresh stats')
+      }
+
+      const { startDate, endDate, queueIds } = input.body
+      const reportStatsService = ctx.reportStatsService(ctx.db)
+      await reportStatsService.refreshDateRange({
+        startDate,
+        endDate,
+        queueIds,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: {},
+      }
+    },
+  })
+}

package/src/api/report/unassignModerator.ts

@@ -0,0 +1,21 @@
+import { AppContext } from '../../context'
+import { Server } from '../../lexicon'
+import { getAuthDid } from '../util'
+
+export default function (server: Server, ctx: AppContext) {
+  server.tools.ozone.report.unassignModerator({
+    auth: ctx.authVerifier.modOrAdminToken,
+    handler: async ({ input, auth }) => {
+      const authDid = getAuthDid(auth, ctx.cfg.service.did)
+      const result = await ctx.assignmentService.unassignReport({
+        reportId: input.body.reportId,
+        createdBy: authDid,
+      })
+
+      return {
+        encoding: 'application/json',
+        body: result,
+      }
+    },
+  })
+}

package/src/api/util.ts

@@ -1,4 +1,5 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { AdminTokenOutput, ModeratorOutput } from '../auth-verifier'
 import { AppContext } from '../context'
 import { Member } from '../db/schema/member'
 import { ModerationEvent } from '../db/schema/moderation_event'
@@ -21,6 +22,17 @@ import {
 } from '../lexicon/types/tools/ozone/team/defs'
 import { ModerationSubjectStatusRow } from '../mod-service/types'
 
+export const getAuthDid = (
+  auth: ModeratorOutput | AdminTokenOutput,
+  serviceDid: string,
+): string | undefined => {
+  return auth.credentials.type === 'moderator'
+    ? auth.credentials.iss
+    : auth.credentials.type === 'admin_token'
+      ? serviceDid
+      : undefined
+}
+
 export const getPdsAccountInfos = async (
   ctx: AppContext,
   dids: string[],