@meith/plugin-awards 0.37.0

package/src/schema.ts

@@ -0,0 +1,38 @@
+import type { PluginMigration } from '@meith/plugin-kit'
+
+export const AWARDS_MIGRATIONS: readonly PluginMigration[] = [
+  {
+    id: '0001_awards',
+    statements: [
+      `create table plugin_awards_award (
+      id bigint generated by default as identity primary key,
+      name text not null, description text not null default '',
+      icon_kind text not null default 'emoji', icon text not null default '🏆',
+      display_order int not null default 0, allow_multiple bool not null default false,
+      listed bool not null default true, archived_at timestamptz,
+      created_at timestamptz not null default now(), updated_at timestamptz not null default now()
+    )`,
+      `create table plugin_awards_rule (
+      id bigint generated by default as identity primary key,
+      award_id bigint not null references plugin_awards_award(id) on delete cascade,
+      title text not null, enabled bool not null default true,
+      min_post_count int, min_thread_count int, min_reputation int, min_days_registered int,
+      created_at timestamptz not null default now(), updated_at timestamptz not null default now()
+    )`,
+      `create table plugin_awards_grant (
+      id bigint generated by default as identity primary key,
+      award_id bigint not null references plugin_awards_award(id) on delete cascade,
+      user_id int not null, rule_id bigint, granted_by_user_id int,
+      reason text not null default '', granted_at timestamptz not null default now()
+    )`,
+      `create index plugin_awards_grant_user on plugin_awards_grant (user_id, granted_at desc)`,
+      `create index plugin_awards_grant_award on plugin_awards_grant (award_id, granted_at desc)`,
+      `create unique index plugin_awards_grant_rule_user on plugin_awards_grant (rule_id, user_id) where rule_id is not null`,
+      `create table plugin_awards_dirty (user_id int primary key, queued_at timestamptz not null default now())`,
+      `create table plugin_awards_scan (
+      id smallint primary key default 1 check (id = 1), cursor int not null default 0, completed_at timestamptz
+    )`,
+      `insert into plugin_awards_scan (id) values (1)`,
+    ],
+  },
+]

package/src/store.ts

@@ -0,0 +1,259 @@
+import type { PluginData, PluginRuntimeContext } from '@meith/plugin-kit'
+
+import type { Award, AwardDraft, DisplayAward } from './awards'
+import { clearDisplay } from './display-cache'
+import type { AwardRule, AwardRuleInput } from './rules'
+
+type AwardRow = Award & Record<string, unknown>
+export interface GrantRow extends AwardRow {
+  readonly grant_id: number
+  readonly user_id: number
+  readonly rule_id: number | null
+  readonly reason: string
+  readonly granted_at: string | Date
+}
+
+export async function allAwards(
+  data: PluginData,
+  publicOnly = false,
+): Promise<readonly DisplayAward[]> {
+  return data.query<DisplayAward>(
+    `select a.*, count(distinct g.user_id)::int as count
+    from plugin_awards_award a left join plugin_awards_grant g on g.award_id = a.id
+    where ($1 = false or (a.listed and a.archived_at is null))
+    group by a.id order by a.display_order, a.id`,
+    [publicOnly],
+  )
+}
+
+export async function awardById(data: PluginData, id: number): Promise<AwardRow | null> {
+  return data.one<AwardRow>(`select * from plugin_awards_award where id = $1`, [id])
+}
+
+export async function saveAward(
+  data: PluginData,
+  draft: AwardDraft,
+  id: number | null,
+): Promise<'saved' | 'missing' | 'multiple'> {
+  const params = [
+    draft.name,
+    draft.description,
+    draft.icon_kind,
+    draft.icon,
+    draft.display_order,
+    draft.allow_multiple,
+    draft.listed,
+  ]
+  const result = await data.tx(async (tx) => {
+    if (id === null) {
+      await tx.query(
+        `insert into plugin_awards_award
+        (name, description, icon_kind, icon, display_order, allow_multiple, listed)
+        values ($1, $2, $3, $4, $5, $6, $7)`,
+        params,
+      )
+    } else {
+      if (
+        (await tx.one(`select id from plugin_awards_award where id = $1 for update`, [id])) === null
+      )
+        return 'missing'
+      if (
+        !draft.allow_multiple &&
+        (await tx.one(
+          `select user_id from plugin_awards_grant
+        where award_id = $1 group by user_id having count(*) > 1 limit 1`,
+          [id],
+        )) !== null
+      )
+        return 'multiple'
+      await tx.query(
+        `update plugin_awards_award set name = $1, description = $2,
+        icon_kind = $3, icon = $4, display_order = $5, allow_multiple = $6, listed = $7,
+        updated_at = now() where id = $8`,
+        [...params, id],
+      )
+    }
+    return 'saved'
+  })
+  clearDisplay()
+  return result
+}
+
+export async function deleteAward(data: PluginData, id: number): Promise<boolean> {
+  return data.tx(async (tx) => {
+    await tx.one(`select id from plugin_awards_award where id = $1 for update`, [id])
+    const row = await tx.one(
+      `delete from plugin_awards_award where id = $1
+      and not exists (select 1 from plugin_awards_grant where award_id = $1) returning id`,
+      [id],
+    )
+    clearDisplay()
+    return row !== null
+  })
+}
+
+export async function archiveAward(data: PluginData, id: number, archived: boolean): Promise<void> {
+  await data.query(
+    `update plugin_awards_award set archived_at = case when $2 then now() else null end, updated_at = now() where id = $1`,
+    [id, archived],
+  )
+  clearDisplay()
+}
+
+export async function grantAward(
+  context: PluginRuntimeContext,
+  input: {
+    awardId: number
+    userId: number
+    byUserId: number | null
+    reason: string
+    ruleId?: number
+  },
+): Promise<number | null> {
+  const row = await context.data.tx(async (tx) => {
+    const award = await tx.one<AwardRow>(
+      `select * from plugin_awards_award where id = $1 for update`,
+      [input.awardId],
+    )
+    if (award === null || award.archived_at !== null) return null
+    return tx.one<{ id: number }>(
+      `insert into plugin_awards_grant
+      (award_id, user_id, granted_by_user_id, reason, rule_id)
+      select $1, $2, $3, $4, $5 where $6 or not exists (
+        select 1 from plugin_awards_grant where award_id = $1 and user_id = $2
+      ) on conflict do nothing returning id`,
+      [
+        input.awardId,
+        input.userId,
+        input.byUserId,
+        input.reason,
+        input.ruleId ?? null,
+        award.allow_multiple,
+      ],
+    )
+  })
+  if (row === null) return null
+  clearDisplay(input.userId)
+  if (context.settings.notify_on_grant !== false) {
+    await context.notify.send({
+      userId: input.userId,
+      kind: 'award_received',
+      subjectKey: 'awards.notification.subject',
+      href: `/plugins/awards/member?id=${input.userId}`,
+      dedupeKey: `grant:${row.id}`,
+    })
+  }
+  return Number(row.id)
+}
+
+export async function revokeGrant(data: PluginData, id: number): Promise<void> {
+  const row = await data.one<{ user_id: number }>(
+    `delete from plugin_awards_grant where id = $1 returning user_id`,
+    [id],
+  )
+  if (row !== null) clearDisplay(Number(row.user_id))
+}
+
+export async function memberGrants(data: PluginData, userId: number): Promise<readonly GrantRow[]> {
+  return data.query<GrantRow>(
+    `select a.*, g.id as grant_id, g.user_id, g.rule_id, g.reason, g.granted_at
+    from plugin_awards_grant g join plugin_awards_award a on a.id = g.award_id
+    where g.user_id = $1 and a.archived_at is null order by a.display_order, a.id, g.granted_at desc`,
+    [userId],
+  )
+}
+
+export async function recentGrants(
+  data: PluginData,
+  userId: number | null,
+): Promise<readonly GrantRow[]> {
+  return data.query<GrantRow>(
+    `select a.*, g.id as grant_id, g.user_id, g.rule_id, g.reason, g.granted_at
+    from plugin_awards_grant g join plugin_awards_award a on a.id = g.award_id
+    where ($1::int is null or g.user_id = $1) order by g.granted_at desc, g.id desc limit 50`,
+    [userId],
+  )
+}
+
+export async function deleteMember(data: PluginData, userId: number): Promise<void> {
+  await data.tx(async (tx) => {
+    await tx.query(`delete from plugin_awards_grant where user_id = $1`, [userId])
+    await tx.query(`delete from plugin_awards_dirty where user_id = $1`, [userId])
+  })
+  clearDisplay(userId)
+}
+
+export async function mergeMember(data: PluginData, kept: number, merged: number): Promise<void> {
+  if (kept === merged) return
+  await data.tx(async (tx) => {
+    await tx.query(`select id from plugin_awards_award order by id for update`)
+    await tx.query(
+      `delete from plugin_awards_grant g using plugin_awards_grant other
+      where g.user_id = $2 and other.user_id = $1 and g.rule_id = other.rule_id`,
+      [kept, merged],
+    )
+    await tx.query(`update plugin_awards_grant set user_id = $1 where user_id = $2`, [kept, merged])
+    await tx.query(
+      `delete from plugin_awards_grant g using plugin_awards_award a
+      where g.award_id = a.id and not a.allow_multiple and g.user_id = $1
+      and exists (select 1 from plugin_awards_grant other
+        where other.award_id = g.award_id and other.user_id = $1 and other.id < g.id)`,
+      [kept],
+    )
+    await tx.query(`delete from plugin_awards_dirty where user_id = $1`, [merged])
+    await tx.query(`insert into plugin_awards_dirty (user_id) values ($1) on conflict do nothing`, [
+      kept,
+    ])
+  })
+  clearDisplay(kept)
+  clearDisplay(merged)
+}
+
+export async function awardRules(
+  data: PluginData,
+  enabledOnly = false,
+): Promise<readonly AwardRule[]> {
+  return data
+    .query<AwardRule & Record<string, unknown>>(
+      `select r.id, r.award_id as "awardId", r.title, r.enabled,
+    r.min_post_count as "minPostCount", r.min_thread_count as "minThreadCount",
+    r.min_reputation as "minReputation", r.min_days_registered as "minDaysRegistered"
+    from plugin_awards_rule r join plugin_awards_award a on a.id = r.award_id
+    where ($1 = false or (r.enabled and a.archived_at is null)) order by r.id`,
+      [enabledOnly],
+    )
+    .then((rows) =>
+      rows.map((row) => ({ ...row, id: Number(row.id), awardId: Number(row.awardId) })),
+    )
+}
+
+export async function saveRule(
+  data: PluginData,
+  rule: AwardRuleInput,
+  id: number | null,
+): Promise<void> {
+  const params = [
+    rule.awardId,
+    rule.title,
+    rule.enabled,
+    rule.minPostCount,
+    rule.minThreadCount,
+    rule.minReputation,
+    rule.minDaysRegistered,
+  ]
+  if (id === null) {
+    await data.query(
+      `insert into plugin_awards_rule
+      (award_id, title, enabled, min_post_count, min_thread_count, min_reputation, min_days_registered)
+      values ($1, $2, $3, $4, $5, $6, $7)`,
+      params,
+    )
+  } else {
+    await data.query(
+      `update plugin_awards_rule set award_id = $1, title = $2, enabled = $3,
+      min_post_count = $4, min_thread_count = $5, min_reputation = $6, min_days_registered = $7,
+      updated_at = now() where id = $8`,
+      [...params, id],
+    )
+  }
+}

package/src/tasks.ts

@@ -0,0 +1,65 @@
+import type { PluginRuntimeContext, PluginUserStanding } from '@meith/plugin-kit'
+
+import { evaluateAwardRules } from './rules'
+import { awardRules, grantAward } from './store'
+
+export async function queueMember(context: PluginRuntimeContext, userId: number): Promise<void> {
+  await context.data.query(
+    `insert into plugin_awards_dirty (user_id) values ($1) on conflict do nothing`,
+    [userId],
+  )
+}
+
+export async function evaluateAwards(context: PluginRuntimeContext): Promise<void> {
+  const rules = await awardRules(context.data, true)
+  const now = new Date()
+  const evaluate = async (members: readonly PluginUserStanding[]) => {
+    for (const outcome of evaluateAwardRules(rules, members, now)) {
+      await grantAward(context, { ...outcome, byUserId: null, reason: '' })
+    }
+  }
+
+  for (let drained = 0; drained < 500; ) {
+    const limit = Math.min(200, 500 - drained)
+    const rows = await context.data.query<{ user_id: number }>(
+      `delete from plugin_awards_dirty
+      where user_id in (select user_id from plugin_awards_dirty order by queued_at, user_id limit $1 for update skip locked)
+      returning user_id`,
+      [limit],
+    )
+    const ids = rows.map((row) => Number(row.user_id))
+    if (ids.length === 0) break
+    try {
+      await evaluate(await context.users.standing(ids))
+    } catch (error) {
+      await context.data.query(
+        `insert into plugin_awards_dirty (user_id)
+        select unnest($1::int[]) on conflict do nothing`,
+        [ids],
+      )
+      throw error
+    }
+    drained += ids.length
+    if (ids.length < limit) break
+  }
+
+  const state = await context.data.one<{ cursor: number }>(
+    `select cursor from plugin_awards_scan where id = 1`,
+  )
+  let cursor = Number(state?.cursor ?? 0)
+  for (let scanned = 0; scanned < 1000; ) {
+    const members = await context.users.scan({ afterUserId: cursor, limit: 200 })
+    await evaluate(members)
+    const complete = members.length < 200
+    const next = complete ? 0 : members[members.length - 1]!.userId
+    const advanced = await context.data.one(
+      `update plugin_awards_scan set cursor = $1,
+      completed_at = case when $2 then now() else completed_at end
+      where id = 1 and cursor = $3 returning cursor`,
+      [next, complete, cursor],
+    )
+    if (advanced === null || complete) break
+    cursor = next
+    scanned += members.length
+  }
+}

package/src/ui/admin.tsx

@@ -0,0 +1,165 @@
+import type { PluginAdminPageContext } from '@meith/plugin-kit'
+import { controlVariants, surfaceVariants, textLinkVariants } from '@meith/ui'
+
+import { asId, ICON_PATHS } from '../awards'
+import { allAwards, awardById, recentGrants } from '../store'
+import { action, button, checkbox, date, field, icon, notice, translated } from './shared'
+
+export async function AwardsAdmin(context: PluginAdminPageContext) {
+  const awards = await allAwards(context.data)
+  const editId = asId(context.query.edit)
+  const edit = editId === null ? null : await awardById(context.data, editId)
+  return (
+    <div className="flex flex-col gap-4">
+      {notice(context, context.query.notice)}
+      <section className={surfaceVariants({ padded: true })}>
+        <h2 className="mb-4 font-semibold">
+          {translated(context, edit === null ? 'awards.create' : 'awards.edit')}
+        </h2>
+        <form
+          method="post"
+          action="/admin/api/plugins/awards/awards"
+          className="grid gap-3 sm:grid-cols-2"
+        >
+          {edit !== null && <input type="hidden" name="id" value={edit.id} />}
+          {field(context, 'name', 'awards.name', edit?.name ?? '', 'text', true)}
+          {field(context, 'icon', 'awards.icon', edit?.icon ?? '🏆', 'text', true)}
+          <p className="text-sm text-muted-foreground sm:col-span-2">
+            {translated(context, 'awards.icon.help')} {Object.keys(ICON_PATHS).join(', ')}
+          </p>
+          <label className="flex flex-col gap-1 sm:col-span-2">
+            {translated(context, 'awards.description')}
+            <textarea
+              name="description"
+              maxLength={2000}
+              defaultValue={edit?.description ?? ''}
+              className={controlVariants()}
+            />
+          </label>
+          {field(context, 'display_order', 'awards.order', edit?.display_order ?? 0, 'number')}
+          {checkbox(context, 'allow_multiple', 'awards.multiple', edit?.allow_multiple ?? false)}
+          {checkbox(context, 'listed', 'awards.listed', edit?.listed ?? true)}
+          <div>{button(context, 'awards.save')}</div>
+        </form>
+      </section>
+      <ul className="flex flex-col gap-3">
+        {awards.map((award) => (
+          <li
+            key={award.id}
+            className={surfaceVariants({
+              padded: true,
+              className: 'flex flex-wrap items-center gap-3',
+            })}
+          >
+            {icon(award)}
+            <a
+              href={`/admin/plugins/awards/awards?edit=${award.id}`}
+              className={textLinkVariants()}
+            >
+              {award.name}
+            </a>
+            <span>
+              {translated(context, 'awards.order')}: {award.display_order}
+            </span>
+            <span>
+              {translated(context, 'awards.holders')}: {award.count}
+            </span>
+            {action(
+              context,
+              'awards',
+              award.id,
+              award.archived_at === null ? 'archive' : 'restore',
+              award.archived_at === null ? 'awards.archive' : 'awards.restore',
+            )}
+            {action(context, 'awards', award.id, 'delete', 'awards.delete')}
+          </li>
+        ))}
+      </ul>
+    </div>
+  )
+}
+
+export async function GrantAdmin(context: PluginAdminPageContext) {
+  const awards = (await allAwards(context.data)).filter((award) => award.archived_at === null)
+  const filter = context.query.user?.trim() ?? ''
+  const member = filter === '' ? null : await context.users.byUsername(filter)
+  const grants =
+    filter !== '' && member === null ? [] : await recentGrants(context.data, member?.userId ?? null)
+  const users = await context.users.standing([
+    ...new Set(grants.map((grant) => Number(grant.user_id))),
+  ])
+  const names = new Map(users.map((user) => [user.userId, user.username]))
+  return (
+    <div className="flex flex-col gap-4">
+      {notice(context, context.query.notice)}
+      <form
+        method="post"
+        action="/admin/api/plugins/awards/grant"
+        className={surfaceVariants({ padded: true, className: 'grid gap-3 sm:grid-cols-2' })}
+      >
+        <label className="flex flex-col gap-1">
+          {translated(context, 'awards.award')}
+          <select name="award_id" required className={controlVariants()}>
+            {awards.map((award) => (
+              <option key={award.id} value={award.id}>
+                {award.name}
+              </option>
+            ))}
+          </select>
+        </label>
+        {field(context, 'usernames', 'awards.usernames', '', 'text', true)}
+        <label className="flex flex-col gap-1">
+          {translated(context, 'awards.reason')}
+          <textarea name="reason" maxLength={2000} className={controlVariants()} />
+        </label>
+        <div>{button(context, 'awards.grant')}</div>
+      </form>
+      <form method="get" className="flex flex-wrap items-end gap-3">
+        {field(context, 'user', 'awards.filter', filter)}
+        {button(context, 'awards.filter.apply')}
+      </form>
+      <div className="overflow-x-auto">
+        <table className="w-full text-left text-sm">
+          <caption className="text-left font-semibold">
+            {translated(context, 'awards.recent')}
+          </caption>
+          <thead>
+            <tr>
+              {(
+                [
+                  'awards.member',
+                  'awards.award',
+                  'awards.reason',
+                  'awards.date',
+                  'awards.actions',
+                ] as const
+              ).map((key) => (
+                <th key={key} className="p-2">
+                  {translated(context, key)}
+                </th>
+              ))}
+            </tr>
+          </thead>
+          <tbody>
+            {grants.map((grant) => (
+              <tr key={grant.grant_id} className="border-t">
+                <td className="p-2">
+                  <a href={`/plugins/awards/member?id=${grant.user_id}`}>
+                    {names.get(Number(grant.user_id)) ??
+                      translated(context, 'awards.deletedMember')}
+                  </a>
+                </td>
+                <td className="p-2">{grant.name}</td>
+                <td className="p-2">{grant.reason}</td>
+                <td className="p-2">{date(context, grant.granted_at)}</td>
+                <td className="p-2">
+                  {action(context, 'grant', grant.grant_id, 'revoke', 'awards.revoke')}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      </div>
+    </div>
+  )
+}