paradigm endpoint updates

Author: ryantullis

api/controllers/rest/paradigmsController.js

@@ -1,21 +1,24 @@
 import personRepo from '../../repos/personRepo.js';
-import { BadRequest } from '../../helpers/problem.js';
+import { BadRequest, NotFound } from '../../helpers/problem.js';
 
 async function getParadigms(req, res) {
 	//get the search query from the query params
 	const { search } = req.query;
 	if (!search) {
 		throw new BadRequest(req, res, 'Search query is required');
 	}
+
 	const paradigms = await personRepo.personSearch(search, {
 		excludeBanned: true,
 		excludeUnconfirmedEmail: true,
 		hasValidParadigm: true,
+		hasJudged: true,
+		limit: 50,
 		include: {
-			chapterJudges: {
+			judges: {
 				fields: ['id'],
 				include: {
-					chapter: {
+					school: {
 						fields: ['id','name'],
 					},
 				},
@@ -25,17 +28,26 @@ async function getParadigms(req, res) {
 
 	const results = paradigms.map(p => {
 		const nameParts = [p.firstName, p.middleName, p.lastName].filter(Boolean);
+		// Get all schools from Judges
+		const schools = p.Judges
+			? p.Judges
+				.filter(j => j && j.School)
+				.map(j => ({
+					id: j.School.id,
+					name: j.School.name,
+				}))
+			: [];
+
+		// Deduplicate schools by id
+		const distinctSchools = Array.from(
+			new Map(schools.map(s => [s.name, s])).values()
+		);
+
 		return {
 			id: p.id,
 			name: nameParts.join(' '),
-			chapters: p.ChapterJudges
-				? p.ChapterJudges
-					.filter(cj => cj && cj.Chapter)
-					.map(cj => ({
-						id: cj.Chapter.id,
-						name: cj.Chapter.name,
-					}))
-				: [],
+			tournJudged: p.Judges ? p.Judges.length : 0,
+			schools: distinctSchools,
 		};
 	});
 	res.json(results);
@@ -50,16 +62,16 @@ async function getParadigmByPersonId(req, res) {
 		excludeBanned: true,
 		excludeUnconfirmedEmail: true,
 		hasValidParadigm: true,
-		settings: ['paradigm'],
+		settings: ['paradigm', 'paradigm_timestamp'],
 	});
 
 	if (!person) {
-		res.status(404).json({ message: 'Person not found or does not have a valid paradigm' });
-		return;
+		return NotFound(req, res, 'Person not found or does not have a valid paradigm');
 	}
 	res.json({
 		id: person.id,
 		name: [person.firstName, person.middleName, person.lastName].filter(Boolean).join(' '),
+		lastReviewed: person.settings['paradigm_timestamp'] || null,
 		paradigm: person.settings['paradigm'] || null,
 
 	});

api/controllers/user/chapter/school.test.js

@@ -15,7 +15,7 @@ import {
 describe ('getMySchoolsByTourn', () => {
 
 	beforeEach(async () => {
-		await db.permission.create(testUserChapterPerm);
+		await db.permission.upsert(testUserChapterPerm);
 		await db.contact.create(testUserSchoolContact);
 	});
 	afterEach(async () => {

api/data/db.js

@@ -23,6 +23,12 @@ db.timeslot.hasMany(db.round, { as: 'rounds', foreignKey: 'timeslot' });
 // Ensure chapterJudge <-> person association exists
 db.chapterJudge.belongsTo(db.person, { as: 'person_person', foreignKey: 'person' });
 db.person.hasMany(db.chapterJudge, { as: 'chapter_judges', foreignKey: 'person' });
+// judge to school
+db.judge.belongsTo(db.school, { as: 'school_school', foreignKey: 'school' });
+db.school.hasMany(db.judge, { as: 'judges', foreignKey: 'school' });
+// person to judge
+db.person.hasMany(db.judge, { as: 'judges', foreignKey: 'person' });
+db.judge.belongsTo(db.person, { as: 'person_person', foreignKey: 'person' });
 
 // By default Sequelize wants you to try...catch every single database call
 // for Reasons?  Otherwise all your database errors just go unprinted and you

api/repos/judgeRepo.js

@@ -1,4 +1,5 @@
 import db from '../data/db.js';
+import { schoolInclude } from './schoolRepo.js';
 import { toDomain, toPersistence, FIELD_MAP } from './mappers/judgeMapper.js';
 import { resolveAttributesFromFields } from './utils/repoUtils.js';
 import { withSettingsInclude } from './utils/settings.js';
@@ -10,6 +11,14 @@ function buildJudgeQuery(opts = {}) {
 		include: [],
 	};
 
+	if (opts.include?.school) {
+		query.include.push({
+			...schoolInclude(opts.include.school),
+			as: 'school_school',
+			required: false,
+		});
+	}
+
 	// Judge settings (same pattern as category)
 	query.include.push(
 		...withSettingsInclude({

api/repos/mappers/judgeMapper.js

@@ -1,5 +1,5 @@
 import { toDomain as genericToDomain, toPersistence as genericToPersistence, toBool, fromBool } from './mapperUtils.js';
-
+import { toDomain as schoolToDomain } from './schoolMapper.js';
 export const FIELD_MAP = {
 	id: 'id',
 	code: 'code',
@@ -24,7 +24,14 @@ export const FIELD_MAP = {
 	createdAt: { db: 'created_at', toDb: () => undefined },
 };
 
-export const toDomain = dbRow => genericToDomain(dbRow, FIELD_MAP);
+export const toDomain = dbRow => {
+	if (!dbRow) return null;
+	const judge = genericToDomain(dbRow, FIELD_MAP);
+	if (dbRow.school_school) {
+		judge.School = schoolToDomain(dbRow.school_school);
+	}
+	return judge;
+};
 export const toPersistence = domainObj => genericToPersistence(domainObj, FIELD_MAP);
 
 export default {

api/repos/mappers/personMapper.js

@@ -1,5 +1,6 @@
 import { toDomain as genericToDomain, toPersistence as genericToPersistence, toBool, fromBool } from './mapperUtils.js';
 import { toDomain as chapterJudgeToDomain } from './chapterJudgeMapper.js';
+import { toDomain as judgeToDomain } from './judgeMapper.js';
 
 export const FIELD_MAP = {
 	id            : 'id',
@@ -31,6 +32,9 @@ export const toDomain = dbRow => {
 	if (dbRow.chapter_judges && Array.isArray(dbRow.chapter_judges)) {
 		person.ChapterJudges = dbRow.chapter_judges.map(chapterJudgeToDomain);
 	}
+	if (dbRow.judges && Array.isArray(dbRow.judges)) {
+		person.Judges = dbRow.judges.map(judgeToDomain);
+	}
 
 	return person;
 };

api/repos/personRepo.js

@@ -1,8 +1,10 @@
+
 import db from '../data/db.js';
 import { FIELD_MAP,toDomain,toPersistence } from './mappers/personMapper.js';
 import { withSettingsInclude, saveSettings } from './utils/settings.js';
 import { resolveAttributesFromFields } from './utils/repoUtils.js';
 import { chapterJudgeInclude } from './chapterJudge.js';
+import { judgeInclude } from './judgeRepo.js';
 
 async function buildPersonQuery(opts = {}) {
 
@@ -16,95 +18,68 @@ async function buildPersonQuery(opts = {}) {
 			attributes.exclude.push('password');
 		}
 	}
+
 	const query = {
 		where: {},
 		attributes,
 		include: [],
 	};
 
-	// Exclude banned persons
+	// Build tag filters for settings include
+	let settingsTags = [];
+	if (opts.settings === true) {
+		settingsTags = true;
+	} else if (Array.isArray(opts.settings)) {
+		settingsTags = [...opts.settings];
+	}
+
+	const settingsInclude = withSettingsInclude({
+		model: db.personSetting,
+		as: 'person_settings',
+		settings: settingsTags,
+	})[0];
+
 	if (opts.excludeBanned) {
-		if (!query.where[db.Sequelize.Op.and]) {
-			query.where[db.Sequelize.Op.and] = [];
-		}
+		query.where[db.Sequelize.Op.and] = query.where[db.Sequelize.Op.and] || [];
 		query.where[db.Sequelize.Op.and].push(
-			db.sequelize.where(
-				db.sequelize.literal(`NOT EXISTS (
-					SELECT 1 FROM person_setting banned
-					WHERE banned.person = person.id
-					AND banned.tag = 'banned'
-				)`),
-				db.Sequelize.Op.eq,
-				db.sequelize.literal('1')
-			)
+			db.Sequelize.literal(`NOT EXISTS (SELECT 1 FROM person_setting ps WHERE ps.person = person.id AND ps.tag = 'banned')`)
 		);
 	}
 
-	// Exclude persons with unconfirmed emails
 	if (opts.excludeUnconfirmedEmail) {
-		if (!query.where[db.Sequelize.Op.and]) {
-			query.where[db.Sequelize.Op.and] = [];
-		}
+		query.where[db.Sequelize.Op.and] = query.where[db.Sequelize.Op.and] || [];
 		query.where[db.Sequelize.Op.and].push(
-			db.sequelize.where(
-				db.sequelize.literal(`NOT EXISTS (
-					SELECT 1 FROM person_setting email_unconfirmed
-					WHERE email_unconfirmed.person = person.id
-					AND email_unconfirmed.tag = 'email_unconfirmed'
-					AND email_unconfirmed.value = '1'
-				)`),
-				db.Sequelize.Op.eq,
-				db.sequelize.literal('1')
-			)
+			db.Sequelize.literal(`NOT EXISTS (SELECT 1 FROM person_setting ps WHERE ps.person = person.id AND ps.tag = 'email_unconfirmed')`)
 		);
 	}
-
-	// Require a person to have a valid paradigm setting, and have been updated since the last paradigm review cutoff
-	if (opts.hasValidParadigm) {
-		const now = opts.now || new Date();
-		const reviewSettings = await db.tabroomSetting.findAll({
-			where: {
-				tag: {
-					[db.Sequelize.Op.in]: ['paradigm_review_cutoff', 'paradigm_review_start'],
-				},
-			},
-		});
-		const reviewCutoff = reviewSettings.find(setting => setting.tag === 'paradigm_review_cutoff');
-		const reviewStart = reviewSettings.find(setting => setting.tag === 'paradigm_review_start');
-		const reviewClause = (reviewCutoff?.value_date
-			&& reviewStart?.value_date
-			&& reviewCutoff.value_date < now)
-			? ` AND paradigm.timestamp > ${db.sequelize.escape(reviewStart.value_date)}`
-			: '';
-		if (!query.where[db.Sequelize.Op.and]) {
-			query.where[db.Sequelize.Op.and] = [];
-		}
+	if(opts.hasValidParadigm) {
+		query.where[db.Sequelize.Op.and] = query.where[db.Sequelize.Op.and] || [];
+		query.where[db.Sequelize.Op.and].push(
+			db.Sequelize.literal(`EXISTS (SELECT 1 FROM person_setting ps WHERE ps.person = person.id AND ps.tag = 'paradigm')`)
+		);
+	}
+	if(opts.hasJudged) {
+		query.where[db.Sequelize.Op.and] = query.where[db.Sequelize.Op.and] || [];
 		query.where[db.Sequelize.Op.and].push(
-			db.sequelize.where(
-				db.sequelize.literal(`EXISTS (
-					SELECT 1 FROM person_setting paradigm
-					WHERE paradigm.person = person.id
-					AND paradigm.tag = 'paradigm'
-					${reviewClause}
-				)`),
-				db.Sequelize.Op.eq,
-				db.sequelize.literal('1')
-			)
+			db.Sequelize.literal(`EXISTS (SELECT 1 FROM judge j WHERE j.person = person.id)`)
 		);
 	}
 
-	query.include.push(
-		...withSettingsInclude({
-			model: db.personSetting,
-			as: 'person_settings',
-			settings: opts.settings,
-		})
-	);
+	if (settingsInclude) {
+		query.include.push(settingsInclude);
+	}
 
 	// Add chapter join when requested
 	if (opts.include?.chapterJudges) {
 		query.include.push(chapterJudgeInclude(opts.include.chapterJudges));
 	}
+	if (opts.include?.judges){
+		query.include.push({
+			...judgeInclude(opts.include.judges),
+			as: 'judges',
+			required: false,
+		});
+	}
 
 	if (Number.isInteger(opts.limit)) {
 		query.limit = opts.limit;
@@ -152,32 +127,28 @@ async function personSearch(searchTerm = '', opts = {}) {
 	const cleanTerm = sanitize(searchTerm);
 	const words = cleanTerm.split(/\s+/).filter(w => w.length > 0);
 
+	if (words.length === 0) {
+		return [];
+	}
+
+	// Use buildPersonQuery for all filters and includes
 	const query = await buildPersonQuery(opts);
-	query.order = [['last', 'ASC'], ['first', 'ASC']];
-	query.attributes = [
-		'id',
-		'first',
-		'last',
-	];
-
-	// Build name search conditions that handle multi-word search
-	// "john smith", "smith john", "john", "smith" should all match person with firstName=john, lastName=smith
-	if (words.length > 0) {
-		const nameConditions = words.map(word => ({
+
+	// Add name search to where clause
+	query.where = query.where || {};
+	query.where[db.Sequelize.Op.and] = query.where[db.Sequelize.Op.and] || [];
+	for (const word of words) {
+		query.where[db.Sequelize.Op.and].push({
 			[db.Sequelize.Op.or]: [
 				{ first: { [db.Sequelize.Op.like]: `${word}%` } },
 				{ last: { [db.Sequelize.Op.like]: `${word}%` } },
 			],
-		}));
-
-		query.where = {
-			...query.where,
-			[db.Sequelize.Op.and]: nameConditions,
-		};
+		});
 	}
 
-	query.limit = opts.limit || 75;
-	query.subQuery = false;
+	query.order = [['last', 'ASC'], ['first', 'ASC']];
+	//query.subQuery = false;
+	//query.distinct = true;
 
 	const results = await db.person.findAll(query);
 	return results.map(toDomain);