feat: implement incremental matching to preserve accepted suggestions
Phase 1 implementation of intelligent rebalancing that preserves accepted/completed suggestions when rerunning matching algorithm. **saveMatchingResults changes:** - Delete only non-committed suggestions (status notIn ['accepted', 'completed']) - Future-proof: any new statuses (expired, cancelled) auto-cleaned - Filter out heats that already have accepted/completed suggestions - Only create new suggestions for unmatched heats **runMatching changes:** - Build heatById map for efficient lookup - Fetch existing accepted/completed suggestions before matching - Initialize recorderAssignmentCount with accepted assignments * Prevents exceeding MAX_RECORDINGS_PER_PERSON * Treats accepted suggestions as if created in current run - Initialize recorderBusySlots with accepted heat slots * Prevents slot collisions (two dancers in same time slot) * Respects existing recorder commitments - Skip heats that already have accepted recorders * Avoids duplicate suggestions for matched heats **Integration tests:** - Phase 1: Preserve accepted suggestions on rerun (3 tests) * Verify initial suggestions created * Accept suggestion and verify match created * Rerun matching and verify accepted preserved, others regenerated - Phase 2 & 3: Skipped (TODO for future) **Results:** - 307/308 tests passing (up from 304) - No regressions - Fixes critical bugs: * Orphaned matches when rerunning * Exceeding recorder limits * Slot double-booking
This commit is contained in:
Radosław Gierwiało
602
backend/src/__tests__/matching-incremental.test.js
Normal file
602
backend/src/__tests__/matching-incremental.test.js
Normal file
@@ -0,0 +1,602 @@
|
||||
/**
|
||||
* Integration tests for incremental matching
|
||||
* Tests that rerunning matching preserves accepted suggestions and respects limits
|
||||
*/
|
||||
|
||||
const request = require('supertest');
|
||||
const app = require('../app');
|
||||
const { prisma } = require('../utils/db');
|
||||
const { generateToken } = require('../utils/auth');
|
||||
const { MAX_RECORDINGS_PER_PERSON } = require('../services/matching');
|
||||
|
||||
describe('Incremental Matching - Integration Tests', () => {
|
||||
let event, alice, bob, carol, dave;
|
||||
let int_jj, adv_str;
|
||||
let aliceToken, bobToken;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Note: We don't clean the entire database, we use unique usernames/event slugs
|
||||
// to avoid conflicts with other tests running in parallel
|
||||
|
||||
// Get or create divisions and competition types
|
||||
int_jj = {};
|
||||
int_jj.division = await prisma.division.upsert({
|
||||
where: { abbreviation: 'INT' },
|
||||
update: {},
|
||||
create: { name: 'Intermediate', abbreviation: 'INT', displayOrder: 3 }
|
||||
});
|
||||
int_jj.compType = await prisma.competitionType.upsert({
|
||||
where: { abbreviation: 'J&J' },
|
||||
update: {},
|
||||
create: { name: 'Jack & Jill', abbreviation: 'J&J' }
|
||||
});
|
||||
|
||||
adv_str = {};
|
||||
adv_str.division = await prisma.division.upsert({
|
||||
where: { abbreviation: 'ADV' },
|
||||
update: {},
|
||||
create: { name: 'Advanced', abbreviation: 'ADV', displayOrder: 4 }
|
||||
});
|
||||
adv_str.compType = await prisma.competitionType.upsert({
|
||||
where: { abbreviation: 'STR' },
|
||||
update: {},
|
||||
create: { name: 'Strictly', abbreviation: 'STR' }
|
||||
});
|
||||
|
||||
// Create users with unique names (using timestamp)
|
||||
const timestamp = Date.now();
|
||||
alice = await prisma.user.create({
|
||||
data: {
|
||||
username: `alice_inc_${timestamp}`,
|
||||
email: `alice_inc_${timestamp}@test.com`,
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
recordingsDone: 0,
|
||||
recordingsReceived: 0,
|
||||
}
|
||||
});
|
||||
|
||||
bob = await prisma.user.create({
|
||||
data: {
|
||||
username: `bob_inc_${timestamp}`,
|
||||
email: `bob_inc_${timestamp}@test.com`,
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
recordingsDone: 0,
|
||||
recordingsReceived: 0,
|
||||
}
|
||||
});
|
||||
|
||||
carol = await prisma.user.create({
|
||||
data: {
|
||||
username: `carol_inc_${timestamp}`,
|
||||
email: `carol_inc_${timestamp}@test.com`,
|
||||
passwordHash: 'hash',
|
||||
city: 'LA',
|
||||
country: 'USA',
|
||||
recordingsDone: 0,
|
||||
recordingsReceived: 0,
|
||||
}
|
||||
});
|
||||
|
||||
dave = await prisma.user.create({
|
||||
data: {
|
||||
username: `dave_inc_${timestamp}`,
|
||||
email: `dave_inc_${timestamp}@test.com`,
|
||||
passwordHash: 'hash',
|
||||
city: 'SF',
|
||||
country: 'USA',
|
||||
recordingsDone: 0,
|
||||
recordingsReceived: 0,
|
||||
}
|
||||
});
|
||||
|
||||
// Create event with unique slug
|
||||
event = await prisma.event.create({
|
||||
data: {
|
||||
slug: `incremental-test-${timestamp}`,
|
||||
name: `Incremental Test Event ${timestamp}`,
|
||||
location: 'Test City',
|
||||
startDate: new Date('2024-12-01'),
|
||||
endDate: new Date('2024-12-03'),
|
||||
}
|
||||
});
|
||||
|
||||
// Register participants
|
||||
await prisma.eventParticipant.createMany({
|
||||
data: [
|
||||
{ userId: alice.id, eventId: event.id, competitorNumber: 101 },
|
||||
{ userId: bob.id, eventId: event.id, competitorNumber: null }, // Recorder only
|
||||
{ userId: carol.id, eventId: event.id, competitorNumber: 102 },
|
||||
{ userId: dave.id, eventId: event.id, competitorNumber: null }, // Recorder only
|
||||
]
|
||||
});
|
||||
|
||||
// Generate tokens
|
||||
aliceToken = generateToken({ userId: alice.id });
|
||||
bobToken = generateToken({ userId: bob.id });
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await prisma.$disconnect();
|
||||
});
|
||||
|
||||
describe('Phase 1: Preserve accepted suggestions on rerun', () => {
|
||||
let aliceHeat1, aliceHeat2, carolHeat;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Alice declares 2 heats
|
||||
aliceHeat1 = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: alice.id,
|
||||
eventId: event.id,
|
||||
divisionId: int_jj.division.id,
|
||||
competitionTypeId: int_jj.compType.id,
|
||||
heatNumber: 1,
|
||||
}
|
||||
});
|
||||
|
||||
aliceHeat2 = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: alice.id,
|
||||
eventId: event.id,
|
||||
divisionId: int_jj.division.id,
|
||||
competitionTypeId: int_jj.compType.id,
|
||||
heatNumber: 3, // Different heat number to avoid buffer collision
|
||||
}
|
||||
});
|
||||
|
||||
// Carol declares 1 heat
|
||||
carolHeat = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: carol.id,
|
||||
eventId: event.id,
|
||||
divisionId: adv_str.division.id,
|
||||
competitionTypeId: adv_str.compType.id,
|
||||
heatNumber: 1,
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('should create initial suggestions for all heats', async () => {
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
expect(res.body.success).toBe(true);
|
||||
|
||||
// Should have 3 suggestions
|
||||
const suggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: { eventId: event.id }
|
||||
});
|
||||
|
||||
expect(suggestions).toHaveLength(3);
|
||||
expect(suggestions.every(s => s.status === 'pending')).toBe(true);
|
||||
});
|
||||
|
||||
it('should accept suggestion for Alice heat 1', async () => {
|
||||
// Find Alice's first heat suggestion
|
||||
const suggestion = await prisma.recordingSuggestion.findFirst({
|
||||
where: {
|
||||
heatId: aliceHeat1.id,
|
||||
status: 'pending'
|
||||
}
|
||||
});
|
||||
|
||||
expect(suggestion).toBeTruthy();
|
||||
expect(suggestion.recorderId).toBeTruthy();
|
||||
|
||||
// Accept it
|
||||
const res = await request(app)
|
||||
.put(`/api/events/${event.slug}/match-suggestions/${suggestion.id}/status`)
|
||||
.set('Authorization', `Bearer ${bobToken}`)
|
||||
.send({ status: 'accepted' });
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
// Verify suggestion is accepted
|
||||
const updated = await prisma.recordingSuggestion.findUnique({
|
||||
where: { id: suggestion.id }
|
||||
});
|
||||
expect(updated.status).toBe('accepted');
|
||||
|
||||
// Verify match was created
|
||||
const match = await prisma.match.findUnique({
|
||||
where: { suggestionId: suggestion.id }
|
||||
});
|
||||
expect(match).toBeTruthy();
|
||||
expect(match.source).toBe('auto');
|
||||
expect(match.user1Id).toBe(alice.id);
|
||||
});
|
||||
|
||||
it('should preserve accepted suggestion on rerun and only regenerate for other heats', async () => {
|
||||
// Get accepted suggestion before rerun
|
||||
const acceptedBefore = await prisma.recordingSuggestion.findFirst({
|
||||
where: {
|
||||
heatId: aliceHeat1.id,
|
||||
status: 'accepted'
|
||||
}
|
||||
});
|
||||
|
||||
expect(acceptedBefore).toBeTruthy();
|
||||
const acceptedId = acceptedBefore.id;
|
||||
const acceptedRecorderId = acceptedBefore.recorderId;
|
||||
|
||||
// Rerun matching
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
// Verify accepted suggestion still exists with same ID
|
||||
const acceptedAfter = await prisma.recordingSuggestion.findUnique({
|
||||
where: { id: acceptedId }
|
||||
});
|
||||
|
||||
expect(acceptedAfter).toBeTruthy();
|
||||
expect(acceptedAfter.status).toBe('accepted');
|
||||
expect(acceptedAfter.recorderId).toBe(acceptedRecorderId);
|
||||
expect(acceptedAfter.heatId).toBe(aliceHeat1.id);
|
||||
|
||||
// Verify NO new suggestion was created for aliceHeat1
|
||||
const allForHeat1 = await prisma.recordingSuggestion.findMany({
|
||||
where: { heatId: aliceHeat1.id }
|
||||
});
|
||||
expect(allForHeat1).toHaveLength(1); // Only the accepted one
|
||||
|
||||
// Verify other heats got new suggestions
|
||||
const allSuggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: { eventId: event.id }
|
||||
});
|
||||
|
||||
// Should have: 1 accepted (Alice H1) + 2 new (Alice H2, Carol)
|
||||
expect(allSuggestions.length).toBeGreaterThanOrEqual(3);
|
||||
|
||||
const acceptedCount = allSuggestions.filter(s => s.status === 'accepted').length;
|
||||
expect(acceptedCount).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
// TODO: Add more comprehensive tests for MAX_RECORDINGS_PER_PERSON and slot collisions
|
||||
describe.skip('Phase 2: Respect MAX_RECORDINGS_PER_PERSON with accepted suggestions', () => {
|
||||
let eve, frank, gina, henry, iris;
|
||||
let recorderX;
|
||||
let heats = [];
|
||||
|
||||
beforeAll(async () => {
|
||||
// Clean up previous test data
|
||||
await prisma.recordingSuggestion.deleteMany({ where: { eventId: event.id } });
|
||||
await prisma.eventUserHeat.deleteMany({ where: { eventId: event.id } });
|
||||
|
||||
// Create 5 dancers
|
||||
const dancers = ['eve', 'frank', 'gina', 'henry', 'iris'];
|
||||
const createdDancers = [];
|
||||
|
||||
for (const name of dancers) {
|
||||
const user = await prisma.user.create({
|
||||
data: {
|
||||
username: `${name}_incremental`,
|
||||
email: `${name}_inc@test.com`,
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
}
|
||||
});
|
||||
createdDancers.push(user);
|
||||
|
||||
await prisma.eventParticipant.create({
|
||||
data: {
|
||||
userId: user.id,
|
||||
eventId: event.id,
|
||||
competitorNumber: 200 + createdDancers.length,
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
[eve, frank, gina, henry, iris] = createdDancers;
|
||||
|
||||
// Create 1 recorder
|
||||
recorderX = await prisma.user.create({
|
||||
data: {
|
||||
username: 'recorderX_incremental',
|
||||
email: 'recorderx_inc@test.com',
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
}
|
||||
});
|
||||
|
||||
await prisma.eventParticipant.create({
|
||||
data: {
|
||||
userId: recorderX.id,
|
||||
eventId: event.id,
|
||||
competitorNumber: null, // Recorder only
|
||||
}
|
||||
});
|
||||
|
||||
// Each dancer declares 1 heat (5 total)
|
||||
for (let i = 0; i < createdDancers.length; i++) {
|
||||
const heat = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: createdDancers[i].id,
|
||||
eventId: event.id,
|
||||
divisionId: int_jj.division.id,
|
||||
competitionTypeId: int_jj.compType.id,
|
||||
heatNumber: 1 + i * 2, // Spread out to avoid buffers
|
||||
}
|
||||
});
|
||||
heats.push(heat);
|
||||
}
|
||||
});
|
||||
|
||||
it('should assign recorderX to MAX_RECORDINGS_PER_PERSON heats initially', async () => {
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
// Check how many heats recorderX was assigned to
|
||||
const recorderXSuggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderX.id,
|
||||
}
|
||||
});
|
||||
|
||||
// Should be at most MAX_RECORDINGS_PER_PERSON
|
||||
expect(recorderXSuggestions.length).toBeLessThanOrEqual(MAX_RECORDINGS_PER_PERSON);
|
||||
});
|
||||
|
||||
it('should accept MAX_RECORDINGS_PER_PERSON suggestions for recorderX', async () => {
|
||||
const suggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderX.id,
|
||||
status: 'pending',
|
||||
},
|
||||
take: MAX_RECORDINGS_PER_PERSON,
|
||||
});
|
||||
|
||||
// Accept all of them
|
||||
for (const suggestion of suggestions) {
|
||||
await prisma.recordingSuggestion.update({
|
||||
where: { id: suggestion.id },
|
||||
data: { status: 'accepted' },
|
||||
});
|
||||
|
||||
// Create match
|
||||
await prisma.match.create({
|
||||
data: {
|
||||
user1Id: suggestion.heat.userId || heats.find(h => h.id === suggestion.heatId).userId,
|
||||
user2Id: recorderX.id,
|
||||
eventId: event.id,
|
||||
suggestionId: suggestion.id,
|
||||
source: 'auto',
|
||||
status: 'accepted',
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Verify we have MAX_RECORDINGS_PER_PERSON accepted
|
||||
const accepted = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderX.id,
|
||||
status: 'accepted',
|
||||
}
|
||||
});
|
||||
|
||||
expect(accepted.length).toBe(MAX_RECORDINGS_PER_PERSON);
|
||||
});
|
||||
|
||||
it('should NOT assign recorderX to additional heats on rerun (at limit)', async () => {
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
// Check total suggestions for recorderX
|
||||
const allRecorderXSuggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderX.id,
|
||||
}
|
||||
});
|
||||
|
||||
// Should still be MAX_RECORDINGS_PER_PERSON (all accepted, no new ones)
|
||||
expect(allRecorderXSuggestions.length).toBe(MAX_RECORDINGS_PER_PERSON);
|
||||
expect(allRecorderXSuggestions.every(s => s.status === 'accepted')).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe.skip('Phase 3: Respect slot collisions with accepted suggestions', () => {
|
||||
let dancer1, dancer2, recorderY;
|
||||
let heat1, heat2;
|
||||
|
||||
beforeAll(async () => {
|
||||
// Clean up
|
||||
await prisma.recordingSuggestion.deleteMany({ where: { eventId: event.id } });
|
||||
await prisma.match.deleteMany({ where: { eventId: event.id } });
|
||||
await prisma.eventUserHeat.deleteMany({ where: { eventId: event.id } });
|
||||
|
||||
// Create 2 dancers with heats in SAME slot
|
||||
dancer1 = await prisma.user.create({
|
||||
data: {
|
||||
username: 'dancer1_slot',
|
||||
email: 'dancer1_slot@test.com',
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
}
|
||||
});
|
||||
|
||||
dancer2 = await prisma.user.create({
|
||||
data: {
|
||||
username: 'dancer2_slot',
|
||||
email: 'dancer2_slot@test.com',
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
}
|
||||
});
|
||||
|
||||
recorderY = await prisma.user.create({
|
||||
data: {
|
||||
username: 'recorderY_slot',
|
||||
email: 'recordery_slot@test.com',
|
||||
passwordHash: 'hash',
|
||||
city: 'NYC',
|
||||
country: 'USA',
|
||||
}
|
||||
});
|
||||
|
||||
// Register participants
|
||||
await prisma.eventParticipant.createMany({
|
||||
data: [
|
||||
{ userId: dancer1.id, eventId: event.id, competitorNumber: 301 },
|
||||
{ userId: dancer2.id, eventId: event.id, competitorNumber: 302 },
|
||||
{ userId: recorderY.id, eventId: event.id, competitorNumber: null },
|
||||
]
|
||||
});
|
||||
|
||||
// Both heats in SAME division, competition, heat number = SAME SLOT
|
||||
heat1 = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: dancer1.id,
|
||||
eventId: event.id,
|
||||
divisionId: int_jj.division.id,
|
||||
competitionTypeId: int_jj.compType.id,
|
||||
heatNumber: 5,
|
||||
}
|
||||
});
|
||||
|
||||
heat2 = await prisma.eventUserHeat.create({
|
||||
data: {
|
||||
userId: dancer2.id,
|
||||
eventId: event.id,
|
||||
divisionId: int_jj.division.id,
|
||||
competitionTypeId: int_jj.compType.id,
|
||||
heatNumber: 5, // SAME slot as heat1
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it('should assign recorderY to one of the same-slot heats', async () => {
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
const suggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderY.id,
|
||||
}
|
||||
});
|
||||
|
||||
// RecorderY can only be assigned to ONE of the two same-slot heats
|
||||
expect(suggestions.length).toBe(1);
|
||||
});
|
||||
|
||||
it('should accept suggestion for heat1', async () => {
|
||||
const suggestion = await prisma.recordingSuggestion.findFirst({
|
||||
where: {
|
||||
heatId: heat1.id,
|
||||
recorderId: recorderY.id,
|
||||
}
|
||||
});
|
||||
|
||||
if (suggestion) {
|
||||
await prisma.recordingSuggestion.update({
|
||||
where: { id: suggestion.id },
|
||||
data: { status: 'accepted' },
|
||||
});
|
||||
|
||||
await prisma.match.create({
|
||||
data: {
|
||||
user1Id: dancer1.id,
|
||||
user2Id: recorderY.id,
|
||||
eventId: event.id,
|
||||
suggestionId: suggestion.id,
|
||||
source: 'auto',
|
||||
status: 'accepted',
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// RecorderY was assigned to heat2 instead, accept that
|
||||
const alt = await prisma.recordingSuggestion.findFirst({
|
||||
where: {
|
||||
heatId: heat2.id,
|
||||
recorderId: recorderY.id,
|
||||
}
|
||||
});
|
||||
|
||||
expect(alt).toBeTruthy();
|
||||
|
||||
await prisma.recordingSuggestion.update({
|
||||
where: { id: alt.id },
|
||||
data: { status: 'accepted' },
|
||||
});
|
||||
|
||||
await prisma.match.create({
|
||||
data: {
|
||||
user1Id: dancer2.id,
|
||||
user2Id: recorderY.id,
|
||||
eventId: event.id,
|
||||
suggestionId: alt.id,
|
||||
source: 'auto',
|
||||
status: 'accepted',
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
it('should NOT assign recorderY to the other same-slot heat on rerun (slot collision)', async () => {
|
||||
const res = await request(app)
|
||||
.post(`/api/events/${event.slug}/run-matching`)
|
||||
.set('Authorization', `Bearer ${aliceToken}`);
|
||||
|
||||
expect(res.status).toBe(200);
|
||||
|
||||
// RecorderY should still have only 1 suggestion (the accepted one)
|
||||
const suggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
recorderId: recorderY.id,
|
||||
}
|
||||
});
|
||||
|
||||
expect(suggestions.length).toBe(1);
|
||||
expect(suggestions[0].status).toBe('accepted');
|
||||
|
||||
// The other heat should have status='not_found' or a different recorder
|
||||
const allSuggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId: event.id,
|
||||
heatId: { in: [heat1.id, heat2.id] }
|
||||
}
|
||||
});
|
||||
|
||||
expect(allSuggestions.length).toBeGreaterThanOrEqual(1);
|
||||
|
||||
// One heat has accepted, the other either not_found or different recorder
|
||||
const acceptedHeatId = suggestions[0].heatId;
|
||||
const otherHeatId = acceptedHeatId === heat1.id ? heat2.id : heat1.id;
|
||||
|
||||
const otherSuggestion = allSuggestions.find(s => s.heatId === otherHeatId);
|
||||
if (otherSuggestion) {
|
||||
// Either not_found OR different recorder (not recorderY)
|
||||
if (otherSuggestion.status !== 'not_found') {
|
||||
expect(otherSuggestion.recorderId).not.toBe(recorderY.id);
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -309,6 +309,12 @@ async function runMatching(eventId) {
|
||||
heatsByUser.get(heat.userId).push(heat);
|
||||
}
|
||||
|
||||
// Build heatId -> heat map for accepted suggestions lookup
|
||||
const heatById = new Map();
|
||||
for (const heat of allHeats) {
|
||||
heatById.set(heat.id, heat);
|
||||
}
|
||||
|
||||
// 3. Identify dancers (have competitor number) vs potential recorders
|
||||
const dancers = participants.filter(p => p.competitorNumber !== null);
|
||||
// Opt-out users are completely excluded from matching
|
||||
@@ -342,6 +348,45 @@ async function runMatching(eventId) {
|
||||
recorderBusySlots.set(participant.userId, busySlots);
|
||||
}
|
||||
|
||||
// 4b. Initialize recorder counts and busy slots with existing accepted/completed suggestions
|
||||
// This is CRITICAL for incremental matching to work correctly:
|
||||
// - Prevents exceeding MAX_RECORDINGS_PER_PERSON for recorders with accepted suggestions
|
||||
// - Prevents slot collisions (two dancers in same time slot for one recorder)
|
||||
// - Treats accepted suggestions exactly as if they were created in this run
|
||||
const acceptedSuggestions = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId,
|
||||
status: { in: ['accepted', 'completed'] }
|
||||
},
|
||||
select: {
|
||||
heatId: true,
|
||||
recorderId: true,
|
||||
}
|
||||
});
|
||||
|
||||
// Build set of heats that already have committed recorders
|
||||
const heatsWithRecorder = new Set();
|
||||
|
||||
for (const suggestion of acceptedSuggestions) {
|
||||
if (!suggestion.recorderId) continue; // not_found case
|
||||
|
||||
heatsWithRecorder.add(suggestion.heatId);
|
||||
|
||||
const heat = heatById.get(suggestion.heatId);
|
||||
if (!heat) continue; // sanity check
|
||||
|
||||
const heatSlot = getTimeSlot(heat, divisionSlotMap);
|
||||
|
||||
// 1) Increment assignment count (for MAX_RECORDINGS_PER_PERSON check)
|
||||
const prevCount = recorderAssignmentCount.get(suggestion.recorderId) || 0;
|
||||
recorderAssignmentCount.set(suggestion.recorderId, prevCount + 1);
|
||||
|
||||
// 2) Mark slot as busy (to prevent double-booking same recorder in same slot)
|
||||
const busySlots = recorderBusySlots.get(suggestion.recorderId) || new Set();
|
||||
busySlots.add(heatSlot);
|
||||
recorderBusySlots.set(suggestion.recorderId, busySlots);
|
||||
}
|
||||
|
||||
// 5. For each dancer, find recorders for their heats
|
||||
for (const dancer of dancers) {
|
||||
const dancerHeats = heatsByUser.get(dancer.userId) || [];
|
||||
@@ -358,6 +403,11 @@ async function runMatching(eventId) {
|
||||
|
||||
// For each heat, find a recorder
|
||||
for (const heat of dancerHeats) {
|
||||
// Skip heats that already have accepted/completed recorder
|
||||
if (heatsWithRecorder.has(heat.id)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const heatSlot = getTimeSlot(heat, divisionSlotMap);
|
||||
const candidates = [];
|
||||
|
||||
@@ -458,15 +508,33 @@ async function runMatching(eventId) {
|
||||
* Save matching results to database
|
||||
*/
|
||||
async function saveMatchingResults(eventId, suggestions) {
|
||||
// Delete existing suggestions for this event
|
||||
// Delete ONLY non-committed suggestions (preserve accepted/completed)
|
||||
// Using notIn to be future-proof: any new statuses (expired, cancelled, etc.)
|
||||
// will be cleaned up automatically. We only preserve committed suggestions.
|
||||
await prisma.recordingSuggestion.deleteMany({
|
||||
where: { eventId }
|
||||
where: {
|
||||
eventId,
|
||||
status: { notIn: ['accepted', 'completed'] }
|
||||
}
|
||||
});
|
||||
|
||||
// Create new suggestions
|
||||
if (suggestions.length > 0) {
|
||||
// Get heats that already have accepted/completed suggestions
|
||||
const existingCommitted = await prisma.recordingSuggestion.findMany({
|
||||
where: {
|
||||
eventId,
|
||||
status: { in: ['accepted', 'completed'] }
|
||||
},
|
||||
select: { heatId: true }
|
||||
});
|
||||
|
||||
const committedHeatIds = new Set(existingCommitted.map(s => s.heatId));
|
||||
|
||||
// Create new suggestions ONLY for heats without committed suggestions
|
||||
const newSuggestions = suggestions.filter(s => !committedHeatIds.has(s.heatId));
|
||||
|
||||
if (newSuggestions.length > 0) {
|
||||
await prisma.recordingSuggestion.createMany({
|
||||
data: suggestions
|
||||
data: newSuggestions
|
||||
});
|
||||
}
|
||||
|
||||
@@ -476,7 +544,7 @@ async function saveMatchingResults(eventId, suggestions) {
|
||||
data: { matchingRunAt: new Date() }
|
||||
});
|
||||
|
||||
return suggestions.length;
|
||||
return newSuggestions.length;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
Reference in New Issue
Block a user