Merge branch 'main' of github.com:speechanddebate/indexcards

Author: palmertab

api/controllers/rest/paradigmsController.js

@@ -1,21 +1,26 @@
 import personRepo from '../../repos/personRepo.js';
 import { BadRequest, NotFound } from '../../helpers/problem.js';
+import config from '../../../config/config.js';
 
 async function getParadigms(req, res) {
 	//get the search query from the query params
-	const { search } = req.query;
+	const { search, limit = 50, offset = 0 } = req.query;
 	if (!search) {
 		throw new BadRequest(req, res, 'Search query is required');
 	}
+	if (limit > 100) {
+		throw new BadRequest(req, res, 'Limit cannot exceed 100');
+	}
 
 	const paradigms = await personRepo.personSearch(search, {
 		excludeBanned: true,
 		excludeUnconfirmedEmail: true,
 		hasValidParadigm: true,
 		hasJudged: true,
-		limit: 50,
+		limit,
+		offset,
 		include: {
-			judges: {
+			Judges: {
 				fields: ['id'],
 				include: {
 					school: {
@@ -25,7 +30,6 @@ 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
@@ -52,30 +56,188 @@ async function getParadigms(req, res) {
 	});
 	res.json(results);
 };
+
+//NOTE, I also hate this and will fix it, I was just seeing if it would work well. it didn't. RCT
 async function getParadigmByPersonId(req, res) {
 	const { personId } = req.params;
 	if (!personId) {
 		throw new BadRequest(req, res, 'Person ID is required');
 	}
 
+	const certInclude = {
+		PersonQuizzes: {
+			isValid: true,
+			fields: ['id', 'updatedAt'],
+			include: {
+				Quiz: {
+					fields: ['id', 'label', 'description', 'badgeDescription', 'badge', 'badgeLink'],
+				},
+			},
+		},
+	};
+	const sectionRecordInclude = {
+		Section: {
+			required: true,
+			fields: ['id'],
+			include: {
+				Round: {
+					required: true,
+					publicPrimaryResults: true,
+					fields: ['id','name','label'],
+					include: {
+						Event: {
+							fields: ['id','abbr'],
+							settings: ['aff_label','neg_label'],
+						},
+					},
+				},
+				Ballots: {
+					fields: ['id', 'judgeId', 'side'],
+					include: {
+						Scores: {
+							winloss: true,
+							fields: ['id','tag','value'],
+						},
+						Entry: {
+							fields: ['id','code'],
+						},
+					},
+				},
+			},
+		},
+	};
+
 	const person = await personRepo.getPerson(personId, {
 		excludeBanned: true,
 		excludeUnconfirmedEmail: true,
 		hasValidParadigm: true,
-		settings: ['paradigm', 'paradigm_timestamp'],
+		settings: ['paradigm'],
+		include: {
+			...certInclude,
+			Judges: {
+				fields: ['id'],
+				include: {
+					Category: {
+						required: true,
+						fields: ['id'],
+						include: {
+							Tourn: {
+								required: true,
+								fields: ['id','name','start', 'hidden'],
+							},
+						},
+					},
+					Ballots : {
+						fields: ['id','side'],
+						winnerBallot: true,
+						include: {
+							...sectionRecordInclude,
+							Scores: {
+								winloss: true,
+								fields: ['id','tag','value'],
+							},
+						},
+					},
+				},
+			},
+		},
 	});
-
 	if (!person) {
 		return NotFound(req, res, 'Person not found or does not have a valid paradigm');
 	}
+	// Build record array: one element per ballot on each judge
+	const record = [];
+
+	for (const judge of person.Judges || []) {
+		for (const judgeBallot of judge.Ballots || []) {
+			// Skip non winner ballots
+
+			const section = judgeBallot.Section;
+			if (!section) continue;
+			let affLabel = section.Round?.Event?.settings?.aff_label || 'Aff';
+			let negLabel = section.Round?.Event?.settings?.neg_label || 'Neg';
+
+			let affTeam = null;
+			let negTeam = null;
+
+			let affWins = 0;
+			let negWins = 0;
+
+			let judgeVote = null;
+
+			for (const ballot of section.Ballots || []) {
+				const entryName = ballot.Entry?.code;
+				// Identify entries (will repeat, but safe)
+				if (ballot.side == 1 && !affTeam) {
+					affTeam = entryName;
+				}
+
+				if (ballot.side == 2 && !negTeam) {
+					negTeam = entryName;
+				}
+				const winScore = ballot.Scores?.find(
+					s => s.tag === 'winloss'
+				);
+
+				// Count panel votes
+				if (winScore?.value === 1) {
+					if (ballot.side == 1) affWins++;
+					if (ballot.side == 2) negWins++;
+				}
+
+				// Detect THIS judge's vote
+				if (
+					ballot.judgeId === judge.id &&
+					winScore?.value === 1
+				) {
+					judgeVote = ballot.side == 1 ? affLabel : negLabel;
+				}
+			}
+
+			// Determine panel majority winner
+			let panelVote = null;
+
+			if (affWins > negWins) panelVote = affLabel;
+			else if (negWins > affWins) panelVote = negLabel;
+			else panelVote = 'Tie'; // optional handling
+
+			let roundLabel = section?.Round?.label;
+			if (!roundLabel && section?.Round?.name) {
+				roundLabel = `R${section.Round.name}`;
+			}
+			record.push({
+				tournName: judge.Category?.Tourn?.name || 'Unknown Tournament',
+				roundDate: judge.Category?.Tourn?.start || null,
+				roundLabel,
+				eventAbbr: section?.Round?.Event?.abbr || null,
+				affTeam,
+				affLabel,
+				negTeam,
+				negLabel,
+				vote: judgeVote,   // this judge's vote
+				panelVote,         // overall result
+				record: `${affWins}-${negWins}`, // optional
+			});
+		}
+	}
 	res.json({
 		id: person.id,
 		name: [person.firstName, person.middleName, person.lastName].filter(Boolean).join(' '),
-		lastReviewed: person.settings['paradigm_timestamp'] || null,
+		lastReviewed: person.settingsTimestamps['paradigm']?.updatedAt || null,
 		paradigm: person.settings['paradigm'] || null,
-
+		record,
+		certifications: person.PersonQuizzes?.map(pq => ({
+			title: pq.Quiz?.label,
+			description: pq.Quiz?.description,
+			updatedAt: pq.updatedAt,
+			badge: {
+				altText: pq.Quiz?.badgeDescription || null,
+				imageUrl: (pq.Quiz?.id && pq.Quiz?.badge) ? `${config.S3_URL}/badges/${pq.Quiz.id}/${pq.Quiz.badge}`
+					: null,
+				link: pq.Quiz?.badgeLink || null,
+			},
+		})),
 	});
-
 };
 
 export default {

api/controllers/rest/roundController.js

@@ -34,7 +34,7 @@ export async function getPublishedRounds(req, res){
 		tournId: req.params.tournId,
 	},{
 		include: {
-			event: {
+			Event: {
 				fields: ['id', 'name', 'abbr','type', 'level'],
 				settings: ['min_entry'],
 			},

api/data/db.js

@@ -7,7 +7,9 @@ const sequelize = new Sequelize(
 	config.DB_DATABASE,
 	config.DB_USER,
 	config.DB_PASS,
-	config.sequelizeOptions
+	{
+		...config.sequelizeOptions,
+	}
 );
 
 // initalize all models created by sequelize-auto
@@ -29,6 +31,17 @@ 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' });
+// personQuiz to person and quiz
+db.personQuiz.belongsTo(db.person, { as: 'person_quiz', foreignKey: 'person' });
+db.person.hasMany(db.personQuiz, { as: 'personQuizzes', foreignKey: 'person' });
+db.personQuiz.belongsTo(db.quiz, { as: 'personQuiz_quiz', foreignKey: 'quiz' });
+db.quiz.hasMany(db.personQuiz, { as: 'personQuizzes', foreignKey: 'quiz' });
+// ballot to entry
+db.ballot.belongsTo(db.entry, { as: 'entry_entry', foreignKey: 'entry' });
+db.entry.hasMany(db.ballot, { as: 'ballots', foreignKey: 'entry' });
+// ballot to score
+db.ballot.hasMany(db.score, { as: 'ballot_scores', foreignKey: 'ballot' });
+// score to ballot in init-models
 
 // 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/middleware/authorization/authorization.js

@@ -1,6 +1,13 @@
 import personRepo from '../../repos/personRepo.js';
 import { buildTarget } from './buildTarget.js';
 import { Unauthorized, Forbidden } from '../../helpers/problem.js';
+//requires login - use before any route that needs authentication
+export function requireLogin(req, res, next) {
+	if (!req.person) {
+		return Unauthorized(req, res,'User not Authenticated');
+	}
+	next();
+}
 // used for ext routes
 export async function requireAreaAccess(req, res, next) {
 	if (!req.person) {

api/repos/ballotRepo.js

@@ -2,6 +2,7 @@ import db from '../data/db.js';
 import { judgeInclude } from './judgeRepo.js';
 import { sectionInclude } from './sectionRepo.js';
 import { scoreInclude } from './scoreRepo.js';
+import { entryInclude } from './entryRepo.js';
 import { FIELD_MAP, toDomain, toPersistence } from './mappers/ballotMapper.js';
 import { resolveAttributesFromFields } from './utils/repoUtils.js';
 
@@ -11,27 +12,63 @@ function buildBallotQuery(opts = {}){
 		attributes: resolveAttributesFromFields(opts.fields,FIELD_MAP),
 		include: [],
 	};
+	if(opts.winnerBallot){
+
+		//only ballots with a score.tag = 'winloss' and score.value = ballot.side should be included
+	}
 	if(opts.include?.judge) {
 		query.include.push({
 			...judgeInclude(opts.include.judge),
 			as: 'judge_judge',
 			required: false,
 		});
 	}
-	if(opts.include?.section) {
+	if(opts.include?.Entry) {
+		query.include.push({
+			...entryInclude(opts.include.Entry),
+			as: 'entry_entry',
+			required: opts.include.Entry.required ?? false,
+		});
+	}
+	if(opts.include?.Section) {
 		query.include.push({
-			...sectionInclude(opts.include.section),
+			...sectionInclude(opts.include.Section),
 			as: 'panel_panel',
 			required: false,
 		});
 	}
-	if(opts.include?.scores){
+	if(opts.include?.Scores){
 		query.include.push({
-			...scoreInclude(opts.include.scores),
-			as: 'scores',
-			required: false,
+			...scoreInclude(opts.include.Scores),
+			as: 'ballot_scores',
+			required: opts.include.Scores.required ?? false,
 		});
 	}
+	if (opts.winnerBallot) {
+
+		const existing = query.include.find(i => i.as === 'ballot_scores');
+
+		if (existing) {
+			existing.required = true;
+			existing.where = {
+				...(existing.where || {}),
+				tag: 'winloss',
+				value: 1,
+			};
+		} else {
+			query.include.push({
+				model: db.score,
+				as: 'ballot_scores',
+				attributes: [],
+				required: true,
+				where: {
+					tag: 'winloss',
+					value: 1,
+				},
+			});
+		}
+	}
+
 	return query;
 }
 

api/repos/ballotRepo.test.js

@@ -38,24 +38,24 @@ describe('ballotRepo', async () => {
 
 			const ballot = await ballotRepo.getBallot(
 				ballotId,
-				{ include: { scores: true } }
+				{ include: { Scores: true } }
 			);
 
 			expect(ballot).toBeDefined();
-			expect(ballot.scores).toBeDefined();
-			expect(Array.isArray(ballot.scores)).toBe(true);
+			expect(ballot.Scores).toBeDefined();
+			expect(Array.isArray(ballot.Scores)).toBe(true);
 		});
 		it('includes section when requested', async () => {
 			const ballotId = await ballotRepo.createBallot({sectionId});
 
 			const ballot = await ballotRepo.getBallot(
 				ballotId,
-				{ include: { section: true } }
+				{ include: { Section: true } }
 			);
 
 			expect(ballot).toBeDefined();
-			expect(ballot.section).toBeDefined();
-			expect(ballot.section.id).toBeDefined();
+			expect(ballot.Section).toBeDefined();
+			expect(ballot.Section.id).toBeDefined();
 		});
 	});
 	describe('ballotInclude', () => {