diff --git a/docs/superpowers/plans/2026-03-19-async-tours.md b/docs/superpowers/plans/2026-03-19-async-tours.md
new file mode 100644
index 0000000..bc1b930
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-19-async-tours.md
@@ -0,0 +1,1366 @@
+# Async Tours Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add asynchronous tour functionality where players join via tour code, play courses within a date range, report scores, and compete on a live leaderboard.
+
+**Architecture:** Four new DB tables (tours, tour_courses, tour_players, tour_results) following existing SQLite patterns. New model/service/route/view layers matching existing conventions exactly. HTMX partials for live leaderboard updates. Tour code used as URL identifier.
+
+**Tech Stack:** Express, EJS, HTMX, SQLite3, Pino (all existing)
+
+---
+
+## File Structure
+
+| File | Responsibility |
+|------|---------------|
+| `src/db.js` | Add 4 new CREATE TABLE statements |
+| `src/models/tour.js` | CRUD operations for all tour tables |
+| `src/services/tour-service.js` | Tour code generation, scoring/leaderboard calculation |
+| `src/routes/tours.js` | API endpoints + partial renders |
+| `views/pages/tours.ejs` | Create tour page |
+| `views/pages/tour.ejs` | Tour view (leaderboard + join + register results) |
+| `views/partials/tour-leaderboard.ejs` | HTMX partial for leaderboard |
+| `views/partials/nav.ejs` | Add Tours nav link |
+| `src/routes/pages.js` | Add /tours page route |
+| `server.js` | Mount tour routes |
+| `public/js/tours.js` | Frontend interaction for tour creation |
+| `public/js/tour.js` | Frontend interaction for tour view |
+| `public/css/tours.css` | Tour-specific styling |
+
+---
+
+### Task 1: Database Schema
+
+**Files:**
+- Modify: `src/db.js`
+
+- [ ] **Step 1: Add tour tables to db.js**
+
+Add these four CREATE TABLE statements inside the `db.serialize()` block in `initializeDatabase()`, after the layouts table creation but before the callback that resolves the promise. The last table's callback should chain into the existing `ALTER TABLE layouts` block.
+
+```javascript
+db.run(`
+ CREATE TABLE IF NOT EXISTS tours (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ code TEXT NOT NULL UNIQUE,
+ start_date DATE NOT NULL,
+ end_date DATE NOT NULL,
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ )
+`);
+
+db.run(`
+ CREATE TABLE IF NOT EXISTS tour_courses (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ tour_id INTEGER NOT NULL,
+ course_id INTEGER NOT NULL,
+ layout_id INTEGER NOT NULL,
+ FOREIGN KEY (tour_id) REFERENCES tours(id),
+ FOREIGN KEY (course_id) REFERENCES courses(id),
+ FOREIGN KEY (layout_id) REFERENCES layouts(id)
+ )
+`);
+
+db.run(`
+ CREATE TABLE IF NOT EXISTS tour_players (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ tour_id INTEGER NOT NULL,
+ pdga_number TEXT NOT NULL,
+ player_name TEXT NOT NULL,
+ joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ UNIQUE(tour_id, pdga_number),
+ FOREIGN KEY (tour_id) REFERENCES tours(id)
+ )
+`);
+
+db.run(`
+ CREATE TABLE IF NOT EXISTS tour_results (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ tour_course_id INTEGER NOT NULL,
+ pdga_number TEXT NOT NULL,
+ total_strokes INTEGER NOT NULL,
+ recorded_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+ UNIQUE(tour_course_id, pdga_number),
+ FOREIGN KEY (tour_course_id) REFERENCES tour_courses(id)
+ )
+`);
+```
+
+- [ ] **Step 2: Verify server starts cleanly**
+
+Run: `npm start`
+Expected: "Database initialized successfully" in logs, no errors. Stop server.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/db.js
+git commit -m "feat: add tour database schema (tours, tour_courses, tour_players, tour_results)"
+```
+
+---
+
+### Task 2: Tour Model
+
+**Files:**
+- Create: `src/models/tour.js`
+
+- [ ] **Step 1: Create tour model**
+
+Follow the exact pattern from `src/models/course.js` — Promise wrappers around `db.run`/`db.get`/`db.all` with parameterized queries.
+
+```javascript
+const { db } = require('../db');
+
+function createTour(name, code, startDate, endDate) {
+ return new Promise((resolve, reject) => {
+ db.run(
+ `INSERT INTO tours (name, code, start_date, end_date) VALUES (?, ?, ?, ?)`,
+ [name, code, startDate, endDate],
+ function(err) {
+ if (err) reject(err);
+ else resolve(this.lastID);
+ }
+ );
+ });
+}
+
+function getTourByCode(code) {
+ return new Promise((resolve, reject) => {
+ db.get(
+ 'SELECT * FROM tours WHERE code = ?',
+ [code],
+ (err, row) => {
+ if (err) reject(err);
+ else resolve(row);
+ }
+ );
+ });
+}
+
+function addCourseToTour(tourId, courseId, layoutId) {
+ return new Promise((resolve, reject) => {
+ db.run(
+ `INSERT INTO tour_courses (tour_id, course_id, layout_id) VALUES (?, ?, ?)`,
+ [tourId, courseId, layoutId],
+ function(err) {
+ if (err) reject(err);
+ else resolve(this.lastID);
+ }
+ );
+ });
+}
+
+function getTourCourses(tourId) {
+ return new Promise((resolve, reject) => {
+ db.all(
+ `SELECT tc.id as tour_course_id, tc.course_id, tc.layout_id,
+ c.name as course_name, c.city,
+ l.name as layout_name, l.par
+ FROM tour_courses tc
+ JOIN courses c ON tc.course_id = c.id
+ JOIN layouts l ON tc.layout_id = l.id
+ WHERE tc.tour_id = ?
+ ORDER BY c.name ASC`,
+ [tourId],
+ (err, rows) => {
+ if (err) reject(err);
+ else resolve(rows);
+ }
+ );
+ });
+}
+
+function joinTour(tourId, pdgaNumber, playerName) {
+ return new Promise((resolve, reject) => {
+ db.run(
+ `INSERT OR IGNORE INTO tour_players (tour_id, pdga_number, player_name) VALUES (?, ?, ?)`,
+ [tourId, pdgaNumber, playerName],
+ function(err) {
+ if (err) reject(err);
+ else resolve(this.lastID);
+ }
+ );
+ });
+}
+
+function getTourPlayers(tourId) {
+ return new Promise((resolve, reject) => {
+ db.all(
+ `SELECT * FROM tour_players WHERE tour_id = ? ORDER BY joined_at ASC`,
+ [tourId],
+ (err, rows) => {
+ if (err) reject(err);
+ else resolve(rows);
+ }
+ );
+ });
+}
+
+function getPlayerInTour(tourId, pdgaNumber) {
+ return new Promise((resolve, reject) => {
+ db.get(
+ `SELECT * FROM tour_players WHERE tour_id = ? AND pdga_number = ?`,
+ [tourId, pdgaNumber],
+ (err, row) => {
+ if (err) reject(err);
+ else resolve(row);
+ }
+ );
+ });
+}
+
+function recordResult(tourCourseId, pdgaNumber, totalStrokes) {
+ return new Promise((resolve, reject) => {
+ db.run(
+ `INSERT OR REPLACE INTO tour_results (tour_course_id, pdga_number, total_strokes) VALUES (?, ?, ?)`,
+ [tourCourseId, pdgaNumber, totalStrokes],
+ function(err) {
+ if (err) reject(err);
+ else resolve(this.lastID);
+ }
+ );
+ });
+}
+
+function getResultsForTour(tourId) {
+ return new Promise((resolve, reject) => {
+ db.all(
+ `SELECT tr.tour_course_id, tr.pdga_number, tr.total_strokes, tr.recorded_at,
+ tc.course_id, tc.layout_id,
+ c.name as course_name,
+ l.name as layout_name, l.par,
+ tp.player_name
+ FROM tour_results tr
+ JOIN tour_courses tc ON tr.tour_course_id = tc.id
+ JOIN courses c ON tc.course_id = c.id
+ JOIN layouts l ON tc.layout_id = l.id
+ JOIN tour_players tp ON tp.tour_id = tc.tour_id AND tp.pdga_number = tr.pdga_number
+ WHERE tc.tour_id = ?
+ ORDER BY tc.id ASC, tr.total_strokes ASC`,
+ [tourId],
+ (err, rows) => {
+ if (err) reject(err);
+ else resolve(rows);
+ }
+ );
+ });
+}
+
+module.exports = {
+ createTour,
+ getTourByCode,
+ addCourseToTour,
+ getTourCourses,
+ joinTour,
+ getTourPlayers,
+ getPlayerInTour,
+ recordResult,
+ getResultsForTour
+};
+```
+
+- [ ] **Step 2: Verify no syntax errors**
+
+Run: `node -e "require('./src/models/tour')"`
+Expected: No output (clean require)
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/models/tour.js
+git commit -m "feat: add tour model with CRUD operations"
+```
+
+---
+
+### Task 3: Tour Service
+
+**Files:**
+- Create: `src/services/tour-service.js`
+
+- [ ] **Step 1: Create tour service**
+
+```javascript
+const crypto = require('crypto');
+const { getTourCourses, getResultsForTour, getTourPlayers } = require('../models/tour');
+
+function generateTourCode() {
+ return crypto.randomBytes(3).toString('hex').toUpperCase();
+}
+
+function isTourActive(tour) {
+ const now = new Date().toISOString().split('T')[0];
+ return now >= tour.start_date && now <= tour.end_date;
+}
+
+function isTourFinished(tour) {
+ const now = new Date().toISOString().split('T')[0];
+ return now > tour.end_date;
+}
+
+async function calculateLeaderboard(tourId) {
+ const courses = await getTourCourses(tourId);
+ const results = await getResultsForTour(tourId);
+ const players = await getTourPlayers(tourId);
+
+ // Group results by course
+ const resultsByCourse = {};
+ for (const course of courses) {
+ resultsByCourse[course.tour_course_id] = results
+ .filter(r => r.tour_course_id === course.tour_course_id)
+ .sort((a, b) => a.total_strokes - b.total_strokes);
+ }
+
+ // Calculate points per course
+ const playerPoints = {};
+ for (const player of players) {
+ playerPoints[player.pdga_number] = {
+ player_name: player.player_name,
+ pdga_number: player.pdga_number,
+ courses: {},
+ total_points: 0
+ };
+ }
+
+ for (const course of courses) {
+ const courseResults = resultsByCourse[course.tour_course_id] || [];
+ const numPlayers = courseResults.length;
+
+ let rank = 1;
+ for (let i = 0; i < courseResults.length; i++) {
+ // Check for ties with previous player
+ if (i > 0 && courseResults[i].total_strokes > courseResults[i - 1].total_strokes) {
+ rank = i + 1;
+ }
+
+ const points = Math.max(numPlayers - rank + 1, 1);
+ const r = courseResults[i];
+ const relativePar = r.total_strokes - course.par;
+
+ if (playerPoints[r.pdga_number]) {
+ playerPoints[r.pdga_number].courses[course.tour_course_id] = {
+ total_strokes: r.total_strokes,
+ relative_par: relativePar,
+ points: points,
+ rank: rank
+ };
+ playerPoints[r.pdga_number].total_points += points;
+ }
+ }
+ }
+
+ // Sort by total points descending
+ const leaderboard = Object.values(playerPoints)
+ .sort((a, b) => b.total_points - a.total_points);
+
+ return { courses, leaderboard };
+}
+
+module.exports = {
+ generateTourCode,
+ isTourActive,
+ isTourFinished,
+ calculateLeaderboard
+};
+```
+
+- [ ] **Step 2: Verify no syntax errors**
+
+Run: `node -e "require('./src/services/tour-service')"`
+Expected: No output (clean require)
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/services/tour-service.js
+git commit -m "feat: add tour service with code generation and leaderboard calculation"
+```
+
+---
+
+### Task 4: Tour Routes
+
+**Files:**
+- Create: `src/routes/tours.js`
+- Modify: `server.js`
+- Modify: `src/routes/pages.js`
+
+- [ ] **Step 1: Create tour routes**
+
+```javascript
+const express = require('express');
+const router = express.Router();
+const { getAllCoursesFromDB, getLayoutsForCourse } = require('../models/course');
+const {
+ createTour, getTourByCode, addCourseToTour, getTourCourses,
+ joinTour, getPlayerInTour, recordResult
+} = require('../models/tour');
+const { generateTourCode, isTourActive, isTourFinished, calculateLeaderboard } = require('../services/tour-service');
+const logger = require('../logger');
+
+// Create a new tour
+router.post('/api/tours', async (req, res) => {
+ try {
+ const { name, startDate, endDate, courses } = req.body;
+
+ if (!name || !startDate || !endDate || !courses || courses.length === 0) {
+ return res.status(400).json({ error: 'Name, dates, and at least one course are required' });
+ }
+
+ if (new Date(endDate) <= new Date(startDate)) {
+ return res.status(400).json({ error: 'End date must be after start date' });
+ }
+
+ const code = generateTourCode();
+ const tourId = await createTour(name, code, startDate, endDate);
+
+ for (const course of courses) {
+ await addCourseToTour(tourId, course.courseId, course.layoutId);
+ }
+
+ logger.info(`Tour created: "${name}" (${code}) with ${courses.length} courses`);
+ res.json({ success: true, code, message: `Tour "${name}" created` });
+ } catch (error) {
+ logger.error('Error creating tour:', error.message);
+ res.status(500).json({ error: 'Failed to create tour' });
+ }
+});
+
+// Join a tour
+router.post('/api/tours/:code/join', async (req, res) => {
+ try {
+ const { code } = req.params;
+ const { pdgaNumber, playerName } = req.body;
+
+ if (!pdgaNumber || !playerName) {
+ return res.status(400).json({ error: 'PDGA number and name are required' });
+ }
+
+ const tour = await getTourByCode(code);
+ if (!tour) {
+ return res.status(404).json({ error: 'Tour not found' });
+ }
+
+ await joinTour(tour.id, pdgaNumber, playerName);
+ logger.info(`Player ${playerName} (${pdgaNumber}) joined tour ${code}`);
+ res.json({ success: true, message: `Joined tour "${tour.name}"` });
+ } catch (error) {
+ logger.error('Error joining tour:', error.message);
+ res.status(500).json({ error: 'Failed to join tour' });
+ }
+});
+
+// Record a result
+router.post('/api/tours/:code/results', async (req, res) => {
+ try {
+ const { code } = req.params;
+ const { pdgaNumber, tourCourseId, totalStrokes } = req.body;
+
+ if (!pdgaNumber || !tourCourseId || !totalStrokes) {
+ return res.status(400).json({ error: 'PDGA number, course, and strokes are required' });
+ }
+
+ const tour = await getTourByCode(code);
+ if (!tour) {
+ return res.status(404).json({ error: 'Tour not found' });
+ }
+
+ if (!isTourActive(tour)) {
+ return res.status(400).json({ error: 'Tour is not active. Results can only be recorded during the tour period.' });
+ }
+
+ const player = await getPlayerInTour(tour.id, pdgaNumber);
+ if (!player) {
+ return res.status(403).json({ error: 'You must join the tour before recording results' });
+ }
+
+ await recordResult(tourCourseId, pdgaNumber, parseInt(totalStrokes));
+ logger.info(`Result recorded: ${pdgaNumber} scored ${totalStrokes} on course ${tourCourseId} in tour ${code}`);
+ res.json({ success: true, message: 'Result recorded' });
+ } catch (error) {
+ logger.error('Error recording result:', error.message);
+ res.status(500).json({ error: 'Failed to record result' });
+ }
+});
+
+// Get leaderboard partial (HTMX)
+router.get('/partials/tour-leaderboard/:code', async (req, res) => {
+ try {
+ const tour = await getTourByCode(req.params.code);
+ if (!tour) {
+ return res.status(404).send('Tour not found
');
+ }
+
+ const { courses, leaderboard } = await calculateLeaderboard(tour.id);
+ res.render('../partials/tour-leaderboard', {
+ tour,
+ courses,
+ leaderboard,
+ isActive: isTourActive(tour),
+ isFinished: isTourFinished(tour)
+ });
+ } catch (error) {
+ logger.error('Error loading leaderboard:', error.message);
+ res.status(500).send('Error loading leaderboard
');
+ }
+});
+
+// Get courses and layouts for tour creation form
+router.get('/api/tours/courses-with-layouts', async (req, res) => {
+ try {
+ const courses = await getAllCoursesFromDB();
+ const coursesWithLayouts = [];
+
+ for (const course of courses) {
+ const layouts = await getLayoutsForCourse(course.id);
+ if (layouts.length > 0) {
+ coursesWithLayouts.push({ ...course, layouts });
+ }
+ }
+
+ res.json(coursesWithLayouts);
+ } catch (error) {
+ logger.error('Error fetching courses with layouts:', error.message);
+ res.status(500).json({ error: 'Failed to fetch courses' });
+ }
+});
+
+// Tour page
+router.get('/tours/:code', async (req, res) => {
+ try {
+ const tour = await getTourByCode(req.params.code);
+ if (!tour) {
+ return res.status(404).render('tour', { tour: null });
+ }
+
+ const courses = await getTourCourses(tour.id);
+ res.render('tour', {
+ tour,
+ courses,
+ isActive: isTourActive(tour),
+ isFinished: isTourFinished(tour)
+ });
+ } catch (error) {
+ logger.error('Error loading tour page:', error.message);
+ res.status(500).send('Error loading tour');
+ }
+});
+
+module.exports = router;
+```
+
+- [ ] **Step 2: Add /tours page route to pages.js**
+
+Add before `module.exports`:
+
+```javascript
+router.get('/tours', (req, res) => {
+ res.render('tours');
+});
+```
+
+- [ ] **Step 3: Mount tour routes in server.js**
+
+Add after the existing route imports:
+
+```javascript
+const tourRoutes = require('./src/routes/tours');
+```
+
+Add after the existing `app.use()` calls:
+
+```javascript
+app.use(tourRoutes);
+```
+
+- [ ] **Step 4: Add Tours to nav**
+
+In `views/partials/nav.ejs`, add after the Courses link:
+
+```html
+Tours
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/routes/tours.js src/routes/pages.js server.js views/partials/nav.ejs
+git commit -m "feat: add tour routes, page route, and nav link"
+```
+
+---
+
+### Task 5: Create Tour Page
+
+**Files:**
+- Create: `views/pages/tours.ejs`
+- Create: `public/js/tours.js`
+
+- [ ] **Step 1: Create tours.ejs**
+
+Follow the exact pattern from `views/pages/courses.ejs` — define `body` variable, include layout partial.
+
+```ejs
+<% var body = `
+
+
+
+
Join a Tour
+
+
+
+
+
+
Tour Created!
+
Share this link with players:
+
+
+
Tour Not Found
+
The tour code is invalid or the tour has been removed.
+
Back to Tours
+
+
Record Result
+
+
+
+
+
+
+
Loading leaderboard...
+
+
No players have joined yet. Share the tour link to get started!
+
+
Leaderboard
+
+
+
+ | # |
+ Player |
+ <% courses.forEach(function(c) { %>
+ <%= c.course_name %>
<%= c.layout_name %> |
+ <% }); %>
+ Points |
+
+
+
+ <% var rank = 1; %>
+ <% leaderboard.forEach(function(player, i) { %>
+ <% if (i > 0 && player.total_points < leaderboard[i-1].total_points) rank = i + 1; %>
+
+ | <%= rank %> |
+
+ <%= player.player_name %>
+ <%= player.pdga_number %>
+ |
+ <% courses.forEach(function(c) { %>
+
+ <% var result = player.courses[c.tour_course_id]; %>
+ <% if (result) { %>
+ <%= result.total_strokes %>
+ <% if (result.relative_par > 0) { %>
+ (+<%= result.relative_par %>)
+ <% } else if (result.relative_par < 0) { %>
+ (<%= result.relative_par %>)
+ <% } else { %>
+ (E)
+ <% } %>
+ <% } else { %>
+ -
+ <% } %>
+ |
+ <% }); %>
+ <%= player.total_points %> |
+
+ <% }); %>
+
+
+
Tour not found
');
+ }
+
+ const { courses, leaderboard } = await calculateLeaderboard(tour.id);
+ res.render('../partials/tour-leaderboard', {
+ tour,
+ courses,
+ leaderboard,
+ isActive: isTourActive(tour),
+ isFinished: isTourFinished(tour)
+ });
+ } catch (error) {
+ logger.error('Error loading leaderboard:', error.message);
+ res.status(500).send('Error loading leaderboard
');
+ }
+});
+
+// Get all courses with their layouts (if any) for tour creation form
+router.get('/api/tours/courses-with-layouts', async (req, res) => {
+ try {
+ const courses = await getAllCoursesFromDB();
+ const result = [];
+
+ for (const course of courses) {
+ const layouts = await getLayoutsForCourse(course.id);
+ result.push({ ...course, layouts });
+ }
+
+ res.json(result);
+ } catch (error) {
+ logger.error('Error fetching courses with layouts:', error.message);
+ res.status(500).json({ error: 'Failed to fetch courses' });
+ }
+});
+
+// Tour page
+router.get('/tours/:code', async (req, res) => {
+ try {
+ const tour = await getTourByCode(req.params.code);
+ if (!tour) {
+ return res.status(404).render('tour', { tour: null });
+ }
+
+ const courses = await getTourCourses(tour.id);
+ res.render('tour', {
+ tour,
+ courses,
+ isActive: isTourActive(tour),
+ isFinished: isTourFinished(tour)
+ });
+ } catch (error) {
+ logger.error('Error loading tour page:', error.message);
+ res.status(500).send('Error loading tour');
+ }
+});
+
+module.exports = router;
diff --git a/src/services/tour-service.js b/src/services/tour-service.js
new file mode 100644
index 0000000..0624771
--- /dev/null
+++ b/src/services/tour-service.js
@@ -0,0 +1,82 @@
+const crypto = require('crypto');
+const { getTourCourses, getResultsForTour, getTourPlayers } = require('../models/tour');
+
+function generateTourCode() {
+ return crypto.randomBytes(3).toString('hex').toUpperCase();
+}
+
+function isTourActive(tour) {
+ const now = new Date().toISOString().split('T')[0];
+ return now >= tour.start_date && now <= tour.end_date;
+}
+
+function isTourFinished(tour) {
+ const now = new Date().toISOString().split('T')[0];
+ return now > tour.end_date;
+}
+
+async function calculateLeaderboard(tourId) {
+ const courses = await getTourCourses(tourId);
+ const results = await getResultsForTour(tourId);
+ const players = await getTourPlayers(tourId);
+
+ // Group results by course
+ const resultsByCourse = {};
+ for (const course of courses) {
+ resultsByCourse[course.tour_course_id] = results
+ .filter(r => r.tour_course_id === course.tour_course_id)
+ .sort((a, b) => a.total_strokes - b.total_strokes);
+ }
+
+ // Calculate points per course
+ const playerPoints = {};
+ for (const player of players) {
+ playerPoints[player.pdga_number] = {
+ player_name: player.player_name,
+ pdga_number: player.pdga_number,
+ courses: {},
+ total_points: 0
+ };
+ }
+
+ const pointsByRank = [10, 8, 6, 4, 3, 2, 1];
+
+ for (const course of courses) {
+ const courseResults = resultsByCourse[course.tour_course_id] || [];
+
+ let rank = 1;
+ for (let i = 0; i < courseResults.length; i++) {
+ // Check for ties with previous player
+ if (i > 0 && courseResults[i].total_strokes > courseResults[i - 1].total_strokes) {
+ rank = i + 1;
+ }
+
+ const points = rank <= pointsByRank.length ? pointsByRank[rank - 1] : 0;
+ const r = courseResults[i];
+ const relativePar = r.total_strokes - course.par;
+
+ if (playerPoints[r.pdga_number]) {
+ playerPoints[r.pdga_number].courses[course.tour_course_id] = {
+ total_strokes: r.total_strokes,
+ relative_par: relativePar,
+ points: points,
+ rank: rank
+ };
+ playerPoints[r.pdga_number].total_points += points;
+ }
+ }
+ }
+
+ // Sort by total points descending
+ const leaderboard = Object.values(playerPoints)
+ .sort((a, b) => b.total_points - a.total_points);
+
+ return { courses, leaderboard };
+}
+
+module.exports = {
+ generateTourCode,
+ isTourActive,
+ isTourFinished,
+ calculateLeaderboard
+};
diff --git a/views/pages/tour.ejs b/views/pages/tour.ejs
new file mode 100644
index 0000000..4344504
--- /dev/null
+++ b/views/pages/tour.ejs
@@ -0,0 +1,91 @@
+<% if (!tour) { %>
+ <% var body = `
+
+
Tour Not Found
+
The tour code is invalid or the tour has been removed.
+
Back to Tours
+
+
Record Result
+
+
+
+
+
+
+
Loading leaderboard...
+
+
Join a Tour
+
+
+
+
+
+
Tour Created!
+
Share this link with players:
+
+
+
No players have joined yet. Share the tour link to get started!
+
+
Leaderboard
+
+
+
+ | # |
+ Player |
+ <% courses.forEach(function(c) { %>
+ <%= c.course_name %>
<%= c.layout_name %> |
+ <% }); %>
+ Points |
+
+
+
+ <% var rank = 1; %>
+ <% leaderboard.forEach(function(player, i) { %>
+ <% if (i > 0 && player.total_points < leaderboard[i-1].total_points) rank = i + 1; %>
+
+ | <%= rank %> |
+
+ <%= player.player_name %>
+ <%= player.pdga_number %>
+ |
+ <% courses.forEach(function(c) { %>
+
+ <% var result = player.courses[c.tour_course_id]; %>
+ <% if (result) { %>
+ <%= result.total_strokes %>
+ <% if (result.relative_par > 0) { %>
+ (+<%= result.relative_par %>)
+ <% } else if (result.relative_par < 0) { %>
+ (<%= result.relative_par %>)
+ <% } else { %>
+ (E)
+ <% } %>
+ <% } else { %>
+ -
+ <% } %>
+ |
+ <% }); %>
+ <%= player.total_points %> |
+
+ <% }); %>
+
+
+