@atproto/ozone 0.1.173 → 0.1.174

package/src/report/views.ts

@@ -0,0 +1,241 @@
+import { Selectable } from 'kysely'
+import {
+  AppBskyActorDefs,
+  ToolsOzoneModerationDefs,
+  ToolsOzoneQueueDefs,
+  ToolsOzoneReportDefs,
+} from '@atproto/api'
+import { addAccountInfoToRepoViewDetail } from '../api/util'
+import { ReportStat } from '../db/schema/report_stat'
+import { AccountView } from '../lexicon/types/com/atproto/admin/defs'
+import {
+  RecordViewDetail,
+  RepoView,
+} from '../lexicon/types/tools/ozone/moderation/defs'
+import { Member as TeamMember } from '../lexicon/types/tools/ozone/team/defs'
+import { ReportWithEvent } from '../mod-service/report'
+import { ParsedLabelers } from '../util'
+
+type ReportViews = {
+  repoDetails(
+    dids: string[],
+    labelers?: ParsedLabelers,
+  ): Promise<Map<string, RepoView>>
+  recordDetails(
+    subjects: { uri: string }[],
+    labelers?: ParsedLabelers,
+  ): Promise<Map<string, RecordViewDetail>>
+  getProfiles(
+    dids: string[],
+  ): Promise<Map<string, AppBskyActorDefs.ProfileViewDetailed>>
+}
+
+export type HydratedReport = {
+  partialRepos: Map<string, RepoView>
+  accountInfo: Map<string, AccountView | null>
+  recordInfo: Map<string, RecordViewDetail>
+  profiles: Map<string, AppBskyActorDefs.ProfileViewDetailed>
+  queues: Map<number, ToolsOzoneQueueDefs.QueueView>
+  memberViews: Map<string, TeamMember>
+}
+
+export async function hydrateReportInfo(
+  reports: ReportWithEvent[],
+  views: ReportViews,
+  getAccountInfos: (dids: string[]) => Promise<Map<string, AccountView | null>>,
+  getQueues: (
+    queueIds: number[],
+  ) => Promise<Map<number, ToolsOzoneQueueDefs.QueueView>>,
+  getTeamMembers: (dids: string[]) => Promise<Map<string, TeamMember>>,
+  labelers: ParsedLabelers,
+): Promise<HydratedReport> {
+  const dids = new Set<string>()
+  const uris = new Set<string>()
+  const queueIds = new Set<number>()
+  const assignmentDids: string[] = []
+
+  for (const report of reports) {
+    dids.add(report.subjectDid)
+    dids.add(report.reportedBy)
+    if (report.subjectUri) uris.add(report.subjectUri)
+    if (report.queueId && report.queueId > 0) queueIds.add(report.queueId)
+    if (report.assignedTo) {
+      dids.add(report.assignedTo)
+      assignmentDids.push(report.assignedTo)
+    }
+  }
+
+  const didsArray = Array.from(dids)
+  const [partialRepos, accountInfo, recordInfo, profiles, queues, memberViews] =
+    await Promise.all([
+      views.repoDetails(didsArray, labelers),
+      getAccountInfos(didsArray),
+      views.recordDetails(
+        Array.from(uris).map((uri) => ({ uri })),
+        labelers,
+      ),
+      views.getProfiles(didsArray),
+      getQueues(Array.from(queueIds)),
+      getTeamMembers(assignmentDids),
+    ])
+
+  return {
+    partialRepos,
+    accountInfo,
+    recordInfo,
+    profiles,
+    queues,
+    memberViews,
+  }
+}
+
+export function buildReportView(
+  report: ReportWithEvent,
+  hydrated: HydratedReport,
+  isModerator: boolean,
+  actions?: ToolsOzoneModerationDefs.ModEventView[],
+) {
+  const {
+    partialRepos,
+    accountInfo,
+    recordInfo,
+    profiles,
+    queues,
+    memberViews,
+  } = hydrated
+  const isRecord = !!report.subjectUri
+  const did = report.subjectDid
+  const partialRepo = partialRepos.get(did)
+  const repo = partialRepo
+    ? addAccountInfoToRepoViewDetail(
+        partialRepo,
+        accountInfo.get(did) || null,
+        isModerator,
+      )
+    : undefined
+  const profile = profiles.get(did)
+  const record = isRecord ? recordInfo.get(report.subjectUri!) : undefined
+  const status = isRecord
+    ? record?.moderation.subjectStatus
+    : repo?.moderation.subjectStatus
+
+  const reportType = report.meta?.reportType as string
+
+  const subject = isRecord ? report.subjectUri! : report.subjectDid
+  const subjectView = {
+    type: isRecord ? 'record' : 'account',
+    subject,
+    repo,
+    record,
+    profile: profile
+      ? {
+          $type: 'app.bsky.actor.defs#profileViewDetailed' as const,
+          ...profile,
+        }
+      : undefined,
+    status,
+  }
+
+  const reporterDid = report.reportedBy
+  const reporterPartialRepo = partialRepos.get(reporterDid)
+  const reporterRepo = reporterPartialRepo
+    ? addAccountInfoToRepoViewDetail(
+        reporterPartialRepo,
+        accountInfo.get(reporterDid) || null,
+        isModerator,
+      )
+    : undefined
+  const reporterProfile = profiles.get(reporterDid)
+  const reporterStatus = reporterRepo?.moderation.subjectStatus
+
+  const reporterView = {
+    type: 'account',
+    subject: reporterDid,
+    repo: reporterRepo,
+    profile: reporterProfile
+      ? {
+          $type: 'app.bsky.actor.defs#profileViewDetailed' as const,
+          ...reporterProfile,
+        }
+      : undefined,
+    status: reporterStatus,
+  }
+
+  const assignmentView =
+    report.assignedTo && report.assignedAt
+      ? {
+          did: report.assignedTo,
+          moderator: memberViews.get(report.assignedTo),
+          assignedAt: report.assignedAt,
+        }
+      : undefined
+
+  return {
+    id: report.id,
+    eventId: report.eventId,
+    status: report.status,
+    subject: subjectView,
+    reportType,
+    reportedBy: report.reportedBy,
+    reporter: reporterView,
+    comment: report.comment ?? undefined,
+    createdAt: report.createdAt,
+    updatedAt: report.updatedAt,
+    queuedAt: report.queuedAt ?? undefined,
+    actionEventIds:
+      report.actionEventIds && Array.isArray(report.actionEventIds)
+        ? (report.actionEventIds as number[])
+        : undefined,
+    actions: actions && actions.length ? actions : undefined,
+    actionNote: report.actionNote ?? undefined,
+    assignment: assignmentView,
+    queue:
+      report.queueId && report.queueId > 0
+        ? queues.get(report.queueId)
+        : undefined,
+    isMuted: report.isMuted,
+  }
+}
+
+export function viewQueueStats(
+  row?: Selectable<ReportStat>,
+): ToolsOzoneQueueDefs.QueueStats {
+  return {
+    pendingCount: row?.pendingCount ?? undefined,
+    actionedCount: row?.actionedCount ?? undefined,
+    escalatedCount: row?.escalatedCount ?? undefined,
+    inboundCount: row?.inboundCount ?? undefined,
+    actionRate: row?.actionRate ?? undefined,
+    avgHandlingTimeSec: row?.avgHandlingTimeSec ?? undefined,
+    lastUpdated: row?.computedAt,
+  }
+}
+
+export function viewLiveStats(
+  row?: Selectable<ReportStat>,
+): ToolsOzoneReportDefs.LiveStats {
+  return {
+    pendingCount: row?.pendingCount ?? undefined,
+    actionedCount: row?.actionedCount ?? undefined,
+    escalatedCount: row?.escalatedCount ?? undefined,
+    inboundCount: row?.inboundCount ?? undefined,
+    actionRate: row?.actionRate ?? undefined,
+    avgHandlingTimeSec: row?.avgHandlingTimeSec ?? undefined,
+    lastUpdated: row?.computedAt,
+  }
+}
+
+export function viewHistoricalStats(
+  row: Selectable<ReportStat>,
+): ToolsOzoneReportDefs.HistoricalStats {
+  return {
+    date: row.date,
+    computedAt: row.computedAt,
+    pendingCount: row.pendingCount ?? undefined,
+    actionedCount: row.actionedCount ?? undefined,
+    escalatedCount: row.escalatedCount ?? undefined,
+    inboundCount: row.inboundCount ?? undefined,
+    actionRate: row.actionRate ?? undefined,
+    avgHandlingTimeSec: row.avgHandlingTimeSec ?? undefined,
+  }
+}

package/src/team/index.ts

@@ -267,6 +267,17 @@ export class TeamService {
     } while (lastDid)
   }
 
+  async viewByDids(dids: string[]): Promise<Map<string, TeamMember>> {
+    if (!dids.length) return new Map()
+    const members = await this.db.db
+      .selectFrom('member')
+      .selectAll()
+      .where('did', 'in', dids)
+      .execute()
+    const memberViews = await this.view(members)
+    return new Map(memberViews.map((m) => [m.did, m]))
+  }
+
   async view(members: Selectable<Member>[]): Promise<TeamMember[]> {
     const profiles = await this.getProfiles(members.map(({ did }) => did))
     return members.map((member) => {

package/tests/get-report.test.ts

@@ -0,0 +1,136 @@
+import AtpAgent from '@atproto/api'
+import {
+  ModeratorClient,
+  SeedClient,
+  TestNetwork,
+  basicSeed,
+} from '@atproto/dev-env'
+import { ids } from '../src/lexicon/lexicons'
+import { REASONSPAM } from '../src/lexicon/types/com/atproto/moderation/defs'
+
+describe('ozone-get-report', () => {
+  let network: TestNetwork
+  let agent: AtpAgent
+  let sc: SeedClient
+  let modClient: ModeratorClient
+
+  const modHeaders = async (nsid: string) =>
+    network.ozone.modHeaders(nsid, 'admin')
+
+  beforeAll(async () => {
+    network = await TestNetwork.create({
+      dbPostgresSchema: 'ozone_get_report',
+    })
+    agent = network.ozone.getAgent()
+    sc = network.getSeedClient()
+    modClient = network.ozone.getModClient()
+    await basicSeed(sc)
+    await network.processAll()
+  })
+
+  afterAll(async () => {
+    await network.close()
+  })
+
+  it('returns a single report by id', async () => {
+    // Create a report on Alice's account
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.alice,
+      },
+      reportedBy: sc.dids.bob,
+    })
+    await network.processAll()
+
+    // Fetch the report list to get the report ID
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.alice },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    expect(list.reports.length).toBeGreaterThan(0)
+    const reportId = list.reports[0].id
+
+    // Fetch the single report by ID
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.id).toBe(reportId)
+    expect(report.subject.type).toBe('account')
+    expect(report.subject.subject).toBe(sc.dids.alice)
+    expect(report.reportType).toBe('com.atproto.moderation.defs#reasonSpam')
+    expect(report.status).toBe('open')
+  })
+
+  it('hydrates actions for reports that have been actioned', async () => {
+    const bobsAccount = {
+      $type: 'com.atproto.admin.defs#repoRef' as const,
+      did: sc.dids.bob,
+    }
+
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: bobsAccount,
+      reportedBy: sc.dids.alice,
+    })
+    await network.processAll()
+
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.bob },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    const reportId = list.reports[0].id
+
+    const event = await modClient.emitEvent({
+      event: { $type: 'tools.ozone.moderation.defs#modEventAcknowledge' },
+      subject: bobsAccount,
+      reportAction: {
+        ids: [reportId],
+        note: 'Reviewed',
+      },
+    })
+
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.status).toBe('closed')
+    expect(report.actionEventIds).toEqual([event.id])
+    expect(report.actions).toBeDefined()
+    expect(report.actions).toHaveLength(1)
+    expect(report.actions![0].id).toBe(event.id)
+    expect(report.actions![0].event.$type).toBe(
+      'tools.ozone.moderation.defs#modEventAcknowledge',
+    )
+  })
+
+  it('omits actions when the report has not been actioned', async () => {
+    await sc.createReport({
+      reasonType: REASONSPAM,
+      subject: {
+        $type: 'com.atproto.admin.defs#repoRef',
+        did: sc.dids.carol,
+      },
+      reportedBy: sc.dids.alice,
+    })
+    await network.processAll()
+
+    const { data: list } = await agent.tools.ozone.report.queryReports(
+      { status: 'open', subject: sc.dids.carol },
+      { headers: await modHeaders(ids.ToolsOzoneReportQueryReports) },
+    )
+    const reportId = list.reports[0].id
+
+    const { data: report } = await agent.tools.ozone.report.getReport(
+      { id: reportId },
+      { headers: await modHeaders(ids.ToolsOzoneReportGetReport) },
+    )
+
+    expect(report.actionEventIds).toBeFalsy()
+    expect(report.actions).toBeUndefined()
+  })
+})