Restore recipe selection + Run Recipe on beta

src/components/RoundActionButtons.tsx

@@ -1,5 +1,10 @@
 import { type ActivityWithParent } from '../lib/domain/types';
+import { Recipes } from '../lib/recipes';
 import Button from '@mui/material/Button';
+import MenuItem from '@mui/material/MenuItem';
+import Select from '@mui/material/Select';
+import FormControl from '@mui/material/FormControl';
+import InputLabel from '@mui/material/InputLabel';
 import { type Person } from '@wca/helpers';
 
 interface RoundActionButtonsProps {
@@ -9,6 +14,9 @@ interface RoundActionButtonsProps {
   activityCode: string;
   onConfigureAssignments: () => void;
   onGenerateAssignments: () => void;
+  recipeId: string;
+  onChangeRecipeId: (recipeId: string) => void;
+  onRunRecipe: () => void;
   onConfigureStationNumbers: (activityCode: string) => void;
   onConfigureGroups: () => void;
   onResetAll: () => void;
@@ -23,6 +31,9 @@ export const RoundActionButtons = ({
   activityCode,
   onConfigureAssignments,
   onGenerateAssignments,
+  recipeId,
+  onChangeRecipeId,
+  onRunRecipe,
   onConfigureStationNumbers,
   onConfigureGroups,
   onResetAll,
@@ -42,6 +53,22 @@ export const RoundActionButtons = ({
       <>
         <Button onClick={onConfigureAssignments}>Configure Assignments</Button>
         <Button onClick={onGenerateAssignments}>Assign Competitor and Judging Assignments</Button>
+        <FormControl size="small" sx={{ minWidth: 220, marginLeft: 2 }}>
+          <InputLabel id="recipe-select-label">Recipe</InputLabel>
+          <Select
+            labelId="recipe-select-label"
+            label="Recipe"
+            value={recipeId}
+            onChange={(e) => onChangeRecipeId(String(e.target.value))}
+          >
+            {Recipes.map((r) => (
+              <MenuItem key={r.id} value={r.id}>
+                {r.name}
+              </MenuItem>
+            ))}
+          </Select>
+        </FormControl>
+        <Button onClick={onRunRecipe}>Run Recipe</Button>
         <div style={{ display: 'flex', flex: 1 }} />
         <Button onClick={onConfigureGroups}>Configure Groups</Button>
         <Button color="error" onClick={onResetAll}>

src/lib/recipes/activities.ts

@@ -0,0 +1,62 @@
+import { Competition, parseActivityCode } from '@wca/helpers';
+import { findAllActivities } from 'wca-group-generators';
+import { activityCodeIsChild } from '../domain/activities/activityCode';
+import { AssignmentStep } from './types';
+
+const getBaseActivities = (
+  wcif: Competition,
+  base: AssignmentStep['props']['activities']['base'],
+  roundId: string
+) => {
+  const allActivities = findAllActivities(wcif);
+  const activitiesForRound = allActivities
+    .filter(
+      (activity) =>
+        activityCodeIsChild(roundId, activity.activityCode) && roundId !== activity.activityCode
+    )
+    .sort((a, b) => a.activityCode.localeCompare(b.activityCode));
+
+  switch (base) {
+    case 'all':
+      return activitiesForRound;
+    case 'even':
+      return activitiesForRound.filter(
+        ({ activityCode }) => (parseActivityCode(activityCode)?.groupNumber as number) % 2 === 0
+      );
+    case 'odd':
+      return activitiesForRound.filter(
+        ({ activityCode }) => (parseActivityCode(activityCode)?.groupNumber as number) % 2 === 1
+      );
+    default:
+      return activitiesForRound;
+  }
+};
+
+export const getActivities = (
+  wcif: Competition,
+  { base, activityIds, options = {} }: AssignmentStep['props']['activities'],
+  roundId: string
+) => {
+  const baseActivities = getBaseActivities(wcif, base, roundId);
+
+  if (activityIds) {
+    return baseActivities.filter((activity) => activityIds?.includes(activity.id));
+  }
+
+  let baseActivityCodes = [...new Set(baseActivities.map((activity) => activity.activityCode))];
+  let filteredBaseActivities = baseActivities;
+
+  if (options.tail) {
+    baseActivityCodes = baseActivityCodes.slice(0, -1);
+  }
+
+  if (options.head) {
+    baseActivityCodes = baseActivityCodes.slice(0, options.head);
+  }
+
+  filteredBaseActivities = filteredBaseActivities.filter((activity) =>
+    baseActivityCodes.includes(activity.activityCode)
+  );
+
+  return filteredBaseActivities;
+};

src/lib/recipes/clusters.ts

@@ -0,0 +1,145 @@
+import { Competition, Event, Person, Round, parseActivityCode } from '@wca/helpers';
+import Assignments from '../../config/assignments';
+import { findGroupActivitiesByRound } from '../wcif/activities';
+import { acceptedRegistrations, personsShouldBeInRound } from '../domain/persons';
+import { ClusterDefinition } from './types';
+import { byPROrResult } from 'wca-group-generators';
+
+export const Filters = [
+  {
+    key: 'hasAssignmentInRound',
+    name: 'Has Assignment In Round',
+    type: 'select',
+    options: [
+      {
+        id: 'staff-*',
+        name: 'Staff Any',
+      },
+      ...Assignments,
+    ],
+    filter: (assignmentCode: string, activityIds: number[]) => (person: Person) =>
+      person.assignments?.some((assignment) => {
+        if (!activityIds.includes(assignment.activityId)) {
+          return false;
+        }
+
+        if (assignmentCode === 'staff-*') {
+          return assignment.assignmentCode.startsWith('staff-');
+        }
+
+        return assignment.assignmentCode === assignmentCode;
+      }),
+  },
+  {
+    key: 'doesNotHaveAssignmentInRound',
+    name: 'Does Not Have Assignment In Round',
+    type: 'select',
+    options: [
+      {
+        id: 'staff-*',
+        name: 'Staff Any',
+      },
+      ...Assignments,
+    ],
+    filter: (assignmentCode: string, activityIds: number[]) => (person: Person) =>
+      !person.assignments?.some((assignment) => {
+        if (!activityIds.includes(assignment.activityId)) {
+          return false;
+        }
+
+        if (assignmentCode === 'staff-*') {
+          return assignment.assignmentCode.startsWith('staff-');
+        }
+
+        return assignment.assignmentCode === assignmentCode;
+      }),
+  },
+  {
+    key: 'hasRole',
+    name: 'Has Role',
+    type: 'select-multiple',
+    options: [
+      {
+        id: 'delegate',
+        name: 'Delegate',
+      },
+      {
+        id: 'trainee-delegate',
+        name: 'Delegate',
+      },
+      {
+        id: 'organizer',
+        name: 'Organizer',
+      },
+      {
+        id: 'staff-.*',
+        name: 'Staff',
+      },
+    ],
+    filter: (roles: string[]) => (person: Person) =>
+      roles.some((role) => person.roles?.some((r) => new RegExp(role).test(r))),
+  },
+  {
+    key: 'isFirstTimer',
+    name: 'Is First Timer',
+    type: 'boolean',
+    filter: (isFirstTimer: boolean) => (person: Person) =>
+      isFirstTimer ? !person.wcaId : !!person.wcaId,
+  },
+];
+
+export const getBaseCluster = (
+  wcif: Competition,
+  base: ClusterDefinition['base'],
+  roundId: string
+) => {
+  switch (base) {
+    case 'personsInRound': {
+      const round = wcif.events.flatMap((e) => e.rounds).find((r) => r.id === roundId) as Round;
+      return personsShouldBeInRound(round)(acceptedRegistrations(wcif.persons));
+    }
+    default:
+      return wcif.persons;
+  }
+};
+
+export const sortCluster = (wcif: Competition, cluster: ClusterDefinition, persons: Person[], roundId: string) => {
+  if (!cluster.sort) {
+    return persons;
+  }
+
+  if (cluster.sort.by === 'speed') {
+    const { eventId, roundNumber } = parseActivityCode(roundId) as {
+      eventId: string;
+      roundNumber: number;
+    };
+    const event = wcif.events.find((e) => e.id === eventId) as Event;
+    const sortedPersons = persons.sort(byPROrResult(event, roundNumber));
+    return cluster.sort.direction === 'asc' ? sortedPersons : sortedPersons.reverse();
+  }
+
+  return persons;
+}
+
+
+export const getCluster = (wcif: Competition, cluster: ClusterDefinition, roundId: string) => {
+  const activityIds = findGroupActivitiesByRound(wcif, roundId).map((a) => a.id);
+
+  const baseCluster = getBaseCluster(wcif, cluster.base, roundId);
+
+  if (!cluster.filters?.length) {
+    return baseCluster;
+  }
+
+  const filteredCluster = cluster.filters.reduce((acc, { key, value }) => {
+    const filter = Filters.find((f) => f.key === key)?.filter;
+    if (!filter) {
+      throw new Error(`Filter ${key} not found`);
+    }
+
+    // @ts-expect-error filter typing depends on filter key/value pair
+    return acc.filter(filter(value, activityIds));
+  }, baseCluster);
+
+  return sortCluster(wcif, cluster, filteredCluster, roundId);
+};

src/lib/recipes/index.ts

@@ -0,0 +1,5 @@
+export * from './activities';
+export * from './clusters';
+export * from './recipes';
+export * from './steps';
+export * from './types';

src/lib/recipes/recipes.ts

@@ -0,0 +1,71 @@
+import { ActivityCode, Competition, Event, EventId, Round, parseActivityCode } from '@wca/helpers';
+import { StepLibrary, fromDefaults } from './steps';
+import { RecipeConfig, RecipeDefinition, Step } from './types';
+
+export const Recipes: RecipeDefinition[] = [
+  {
+    id: 'balanced',
+    name: 'Balanced',
+    description: 'Balanced',
+    defaultSteps: [
+      StepLibrary.SpreadDelegates,
+      StepLibrary.BalancedCompetitorAssignmentsForEveryone,
+      StepLibrary.NoCompetitorAssignmentLeftBehind,
+      StepLibrary.GenerateJudgeAssignmentsForCompetitors,
+    ],
+  },
+  {
+    id: 'pnw',
+    name: 'PNW',
+    description: 'PNW',
+    defaultSteps: [
+      StepLibrary.GenerateCompetitorAssignmentsForStaff,
+      StepLibrary.GenerateCompetitorAssignmentsForFirstTimers,
+      StepLibrary.GenerateCompetitorAssignments,
+      StepLibrary.GenerateJudgeAssignmentsForCompetitors,
+    ],
+  },
+  {
+    id: '1-group-finals',
+    name: '1 group final',
+    description: 'Makes a single group of competitors for finals',
+    defaultSteps: [StepLibrary.GenerateSingleGroup, StepLibrary.GenerateCompetitorAssignments],
+  },
+  {
+    id: 'mca',
+    name: 'MCA',
+    description: 'MCA',
+    defaultSteps: [
+      StepLibrary.GenerateFirstTimersInSameGroup,
+      StepLibrary.SpreadDelegates,
+      StepLibrary.SpreadStaffAcrossGroups,
+      StepLibrary.BalancedCompetitorAssignmentsForEveryone,
+      StepLibrary.GenerateJudgeAssignmentsForCompetitors,
+    ],
+  },
+];
+
+export const fromRecipeDefinition = (
+  recipe: RecipeDefinition,
+  { wcif, activityCode }: { wcif: Competition; activityCode: ActivityCode }
+): RecipeConfig => ({
+  id: recipe.id,
+  name: recipe.name,
+  description: recipe.description,
+  steps: recipe.defaultSteps.map((step) => fromDefaults(step, { wcif, activityCode })) as Step[],
+});
+
+export const getPreferredDefaultRecipe = (wcif: Competition, round: Round) => {
+  const { eventId } = parseActivityCode(round.id) as { eventId: EventId; roundNumber: number };
+
+  const event = wcif.events.find((event) => event.id === eventId) as Event;
+
+  const rounds = event.rounds.map((round) => round.id).sort();
+
+  // Is last round?
+  if (rounds[rounds.length - 1] === round.id) {
+    return 'pnw-1-group-finals';
+  }
+
+  return 'pnw';
+};

src/lib/recipes/steps.ts

@@ -0,0 +1,41 @@
+import { ActivityCode, Competition } from '@wca/helpers';
+import { getActivities } from './activities';
+import { getCluster } from './clusters';
+import * as core from './steps/core';
+import * as mca from './steps/mca';
+import * as pnw from './steps/pnw';
+import { AssignmentStep, StepDefinition } from './types';
+
+export const StepLibrary: Record<string, StepDefinition> = {
+  GenerateSingleGroup: core.GenerateSingleGroup,
+  SpreadDelegates: core.SpreadDelegates,
+  BalancedCompetitorAssignmentsForEveryone: core.BalancedCompetitorAssignmentsForEveryone,
+  NoCompetitorAssignmentLeftBehind: core.NoCompetitorAssignmentLeftBehind,
+  GenerateCompetitorAssignmentsForStaff: pnw.GenerateCompetitorAssignmentsForStaff,
+  GenerateCompetitorAssignmentsForFirstTimers: pnw.GenerateCompetitorAssignmentsForFirstTimers,
+  GenerateCompetitorAssignments: pnw.GenerateCompetitorAssignments,
+  GenerateJudgeAssignmentsForCompetitors: pnw.GenerateJudgeAssignmentsForCompetitors,
+  GenerateFirstTimersInSameGroup: mca.GenerateFirstTimersInSameGroup,
+  SpreadStaffAcrossGroups: mca.SpreadStaffAcrossGroups,
+};
+
+export const Steps: StepDefinition[] = Object.keys(StepLibrary).map((key) => StepLibrary[key]);
+
+export const fromDefaults = (
+  step: StepDefinition,
+  { wcif, activityCode }: { wcif: Competition; activityCode: ActivityCode }
+) => ({
+  id: step.id,
+  ...step.defaults(wcif, activityCode),
+});
+
+export const hydrateStep = (wcif: Competition, roundId: string, step: AssignmentStep) => {
+  return {
+    ...step,
+    props: {
+      ...step.props,
+      cluster: getCluster(wcif, step.props.cluster, roundId),
+      activities: getActivities(wcif, step.props.activities, roundId),
+    },
+  };
+};