2023-03-04

src/routes/auth.js

@@ -1,11 +1,11 @@
 var express = require("express");
 var passport = require("passport");
 var TeamsnapStrategy = require("passport-teamsnap");
-
+// const {teamsnap} = require("../app");
 // Configure the TeamSnap strategy for use by Passport.
 //
 // OAuth 2.0-based strategies require a `verify` function which receives the
-// credential (`accessToken`) for accessing the Facebook API on the user's
+// credential (`accessToken`) for accessing the TeamSnap API on the user's
 // behalf, along with the user's profile.  The function must invoke `cb`
 // with a user object, which will be set at `req.user` in route handlers after
 // authentication.
@@ -19,23 +19,21 @@ passport.use(
       passReqToCallback: true,
       scope: ["read", "write"],
     },
-    function (req, accessToken, refreshToken, profile, done) {
+    async function (req, accessToken, refreshToken, profile, done) {
       json = JSON.parse(profile._raw);
-      new_profile = { access_token: accessToken };
-      new_profile["id"] = json.collection.items[0].data.filter(
-        (e) => e.name == "id"
-      )[0].value;
-      new_profile["email"] = json.collection.items[0].data.filter(
-        (e) => e.name == "email"
-      )[0].value;
-      new_profile["first_name"] = json.collection.items[0].data.filter(
-        (e) => e.name == "first_name"
-      )[0].value;
-
+      field_from_collection = (field_name) => {
+        return json.collection.items[0].data.filter(
+          (e) => e.name == field_name
+        )[0].value;
+      }
+      const new_profile = { access_token: accessToken };
+      new_profile["id"] = field_from_collection("id")
+      new_profile["email"] = field_from_collection("email")
+      new_profile["first_name"] = field_from_collection("first_name")
+      new_profile["last_name"] = field_from_collection("last_name")
+      
       req.session.teamsnap_access_token = accessToken;
-      teamsnap.init(process.env["TEAMSNAP_CLIENT_ID"]);
-      teamsnap.auth(accessToken);
-      // teamsnap.enablePersistence();
+      await initTeamsnap(process.env["TEAMSNAP_CLIENT_ID"], accessToken)
       return done(null, new_profile);
     }
   )
@@ -52,18 +50,24 @@ passport.use(
 // and deserialized.
 passport.serializeUser(function (user, cb) {
   process.nextTick(function () {
-    console.log("L#51 serializing user id", user.id);
+    console.log("L#56 serializing user id", user.id);
     cb(null, {
       id: user.id,
       username: user.email,
-      name: user.firstName,
+      email: user.email,
+      first_name: user.first_name,
+      last_name: user.last_name,
       accessToken: user.access_token,
     });
   });
 });
 
 passport.deserializeUser(function (user, cb) {
-  process.nextTick(function () {
+  process.nextTick(async function () {
+    console.log("L#68 deserializing user id", user.id);
+    if (!teamsnap.isAuthed()){
+      await initTeamsnap(process.env["TEAMSNAP_CLIENT_ID"], user.accessToken)
+    }
     return cb(null, user);
   });
 });
@@ -83,7 +87,7 @@ router.get("/login", function (req, res, next) {
   returnTo = req.session.returnTo;
   // req.session.regenerate(); // this is not working right as of now...
   req.session.returnTo = returnTo;
-  res.render("login");
+  res.render("login", {layout:"layouts/main"});
 });
 
 /* GET /login/federated/teamsnap
@@ -120,4 +124,28 @@ router.get(
   })
 );
 
-module.exports = router;
+const initTeamsnap = async (clientID, accessToken) => {
+  teamsnap.init(clientID);
+  teamsnap.auth(accessToken);
+  await teamsnap.loadCollections();
+  await teamsnap.enablePersistence();
+}
+
+const ensureLoggedIn = (req, res, next) => {
+  if (!req.isAuthenticated()){
+    req.session.returnTo = req.originalUrl
+    res.redirect("/login");
+    // return next();
+  }
+  else{
+    req.user = req.session.passport.user
+    next();
+  }
+}
+
+router.get('/auth/teamsnap/session_storage', ensureLoggedIn, (req,res)=>{
+  res.status(200).json({"teamsnap.authToken":req.user.accessToken})
+}
+)
+
+module.exports = {router, ensureLoggedIn};

src/routes/event.js

@@ -0,0 +1,30 @@
+const express = require("express");
+const eventsController = require("../controllers/event");
+const router = express.Router();
+const tsUtils = require("../lib/utils")
+
+// Middleware
+const loadEvent = (req,res,next) => {
+  const {team_id, event_id} = req.params;
+  const bulkLoadTypes = ["event", "availabilitySummary"]
+  tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team_id, req);
+  req.promises.push(teamsnap.bulkLoad({teamId: team_id, types: bulkLoadTypes, scopeTo:'event', event__id:event_id}, null,  tsUtils.teamsnapCallback)
+  .then(bulkLoadItems=>{
+    const items = tsUtils.groupTeamsnapItems(bulkLoadItems, bulkLoadTypes);
+    tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team_id, req);
+    req.availabilitySummary = items.availabilitySummaries.find(e=>e.eventId==event_id);
+    req.event = items.events.find(e=>e.id==event_id);
+  }
+  ))
+  next();
+}
+
+router.use("/:team_id([0-9]+)/event/:event_id([0-9]+)", loadEvent)
+
+// Routes
+router.get("/:team_id([0-9]+)/schedule", eventsController.getEvents);
+router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)", eventsController.getEvent);
+// router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup", eventsController.getLineup);
+// router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup_card", eventsController.getLineupCard);
+
+module.exports = {router, loadEvent}

src/routes/eventlineup.js

@@ -0,0 +1,51 @@
+const express = require("express");
+const eventsLineupController = require("../controllers/eventlineup");
+const router = express.Router();
+const tsUtils = require('../lib/utils')
+const multer = require("multer");
+const upload = multer()
+const { doubleCsrfProtection } = require('../middlewares/csrf');
+
+
+// Middleware
+const loadEventLineup = (req,res,next) => {
+  const {team_id, event_id} = req.params
+  if (!req.event_lineup){
+    bulkLoadTypes = ['eventLineup', 'eventLineupEntry']
+    req.promises.push(teamsnap.bulkLoad({teamId: team_id, types: bulkLoadTypes, scopeTo:'event', event__id:event_id}, null, tsUtils.teamsnapCallback)
+    .then(items => tsUtils.groupTeamsnapItems(items, bulkLoadTypes))
+    .then(items => {
+                    tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team_id, req);
+                    req.event_lineup = items.eventLineups.pop();
+                    req.event_lineup_entries = items.eventLineupEntries?.sort((a,b)=>a.sequence-b.sequence);
+                    })
+                    )
+    tsUtils.teamsnapLog('loadAvailabilites', types=['availabilities'], team_id, req);
+    req.promises.push(teamsnap.loadAvailabilities({eventId: event_id}).then(availabilities => req.availabilities = availabilities))
+  }
+  else {
+    // const {event_lineup} = req
+  }
+  const {event_lineup} = req
+  // req.availabilitySummary = items.find((i) => i.type == "availabilitySummary" && i.id == event.id),
+  // req.event = items.find((i) => i.type == "event" && i.id == event_id)
+  next();
+}
+
+router.use("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup", loadEventLineup)
+
+// Routes
+router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup", async (req,res) => {
+  await Promise.all(req.promises);
+  const {event_lineup} = req
+  res.redirect(`lineup/${event_lineup.id}`);
+}
+)
+
+router.post("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)/email", upload.none(), doubleCsrfProtection, eventsLineupController.getEventLineupEmail )
+router.get ("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)", upload.none(), doubleCsrfProtection, eventsLineupController.getEventLineup);
+router.post("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)", upload.none(), doubleCsrfProtection, eventsLineupController.postEventLineup);
+// router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup_card", eventsController.getLineupCard);
+router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)/entries", eventsLineupController.getEventLineupEntries)
+
+module.exports = {router, loadEventLineup}

src/routes/eventsheet.js

@@ -0,0 +1,68 @@
+const express = require("express");
+const eventsSheetController = require("../controllers/eventsheet");
+const {loadEventLineup} = require("./eventlineup");
+const {loadEvent} = require("./event");
+const {loadRecentAndUpcomingEvents} = require("../middlewares/bulkload")
+const router = express.Router();
+const tsUtils = require('../lib/utils')
+const multer = require("multer");
+const upload = multer()
+
+
+// Middleware
+const loadEvents = async (req,res,next) => {
+  const {team_id, event_id} = req.params
+  req.timeline = {}
+  await Promise.all(req.promises)
+  const {recent_events, upcoming_events} = req
+  const eventIds = [...recent_events.map(e=>e.id), event_id, ...upcoming_events.map(e=>e.id)]
+  // if (!req.event_lineup){
+    bulkLoadTypes = ['event','eventLineup', 'eventLineupEntry']
+    req.promises.push(teamsnap.bulkLoad({teamId: team_id, types: bulkLoadTypes, scopeTo:'event', event__id:eventIds}, null, tsUtils.teamsnapCallback)
+    .then(items => tsUtils.groupTeamsnapItems(items, bulkLoadTypes))
+    .then(items => {
+                    tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team_id, req);
+                    req.timeline.events = items.events;
+                    req.timeline.event_lineups = items.eventLineups;
+                    req.timeline.event_lineup_entries = items.eventLineupEntries;
+                    })
+                    )
+    tsUtils.teamsnapLog('loadAvailabilites', types=['availabilities'], team_id, req);
+    
+    req.promises.push(
+      teamsnap.loadAvailabilities({eventId: eventIds}).then(availabilities => {
+        req.timeline.availabilities = availabilities
+      }
+      )
+      )
+  // }
+  // else {
+  //   // const {event_lineup} = req
+  // }
+  const {event_lineup} = req
+  next();
+}
+
+const linksForEventSheet = async (req, res, next) => {
+  await Promise.all(req.promises)
+  const events = [...req.recent_events, req.event, ...req.upcoming_events] 
+  events.forEach((event) => {
+    console.log()
+  })
+  next();
+}
+
+router.use("/:team_id([0-9]+)/event/:event_id([0-9]+)/sheet", loadEventLineup)
+router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)/sheet", loadEventLineup, loadRecentAndUpcomingEvents, loadEvents, eventsSheetController.getEventSheet)
+
+// Routes
+router.get("/:team_id([0-9]+)/event/:event_id([0-9]+)/sheet", async (req,res) => {
+  await Promise.all(req.promises);
+  const {event_lineup} = req
+  res.redirect(`lineup/${event_lineup.id}/sheet`);
+}
+)
+
+router.post("/:team_id([0-9]+)/event/:event_id([0-9]+)/lineup/:event_lineup_id([0-9]+)/sheet", upload.none(), eventsSheetController.getEventSheet )
+
+module.exports = {router}

src/routes/index.js

@@ -1,28 +1,30 @@
-var express = require("express");
-var ensureLogIn = require("connect-ensure-login").ensureLoggedIn;
-var papaparse = require("papaparse");
-
-var ensureLoggedIn = ensureLogIn();
+const express = require("express");
+const {ensureLoggedIn} = require("./auth")
 
 var router = express.Router();
 
 var multer = require("multer");
 const storage = multer.memoryStorage();
 const upload = multer({ storage: storage });
-const teamsController = require("../controllers/teams");
-const eventsController = require("../controllers/events");
-const membersController = require("../controllers/members");
-const opponentsController = require("../controllers/opponents");
+const path = require("path")
 
-router.get("/", ensureLoggedIn, teamsController.getTeams);
-router.get("/:team_id/home", ensureLoggedIn, teamsController.getTeamHome);
-router.get("/:team_id/events", ensureLoggedIn, eventsController.getEvents);
-router.get("/:team_id/event/:event_id", ensureLoggedIn, eventsController.getEvent);
-router.get("/:team_id/event/:event_id/lineup", ensureLoggedIn, eventsController.getLineup);
-router.get("/:team_id/event/:event_id/lineup_card", ensureLoggedIn, eventsController.getLineupCard);
-router.get("/:team_id/members", ensureLoggedIn, membersController.getMembers);
-router.get("/:team_id/opponents", ensureLoggedIn, opponentsController.getOpponents);
-router.get("/:team_id/opponent/:opponent_id", ensureLoggedIn, opponentsController.getOpponent);
-// router.get("/:team_id/opponent/:opponent_id/logo", ensureLoggedIn, opponentsController.getOpponentLogo);
+partials = path.join(__dirname, "../views/partials")
 
-module.exports = router;
+const membersController = require("../controllers/member");
+
+router.use("/", ensureLoggedIn, (req,res,next) => {req.layout="layouts/main";req.promises=[];next();})
+
+router.get("/", (req,res,next) => {
+  if (!req.session.current_team){
+    res.redirect(`/user/${req.session.passport.user.id}/teams`)
+    next();
+  }
+  else {
+    res.redirect(`/${req.session.current_team}/home`)
+    next();
+  }
+});
+
+router.get("/:team_id([0-9]+)/members", membersController.getMembers);
+
+module.exports = {router, partials};

src/routes/opponent.js

@@ -0,0 +1,38 @@
+const express = require("express");
+const opponentsController = require("../controllers/opponent");
+const {loadTeam} = require("./team")
+var router = express.Router();
+const multer = require("multer");
+const upload = multer()
+const { doubleCsrfProtection } = require('../middlewares/csrf');
+
+// Middleware
+const loadOpponent = (req,res,next) => {
+  const {opponent_id} = req.params;
+  const {team} = req
+  req.promises.push(
+    teamsnap.loadOpponents(team.id, (err, opponents)=>{
+      if (err) console.log("error in route/opponent.js", err);
+    }).then(opponents => {req.opponent=opponents.find(o=>o.id==opponent_id);})
+  )
+
+  req.promises.push(
+    teamsnap.loadTeamMedia(team.id, (err, team_media)=>{
+      if (err) console.log("error in route/opponent.js", err);
+    })
+    .then(team_media => {
+      req.opponent_logo = team_media.find(tm=>tm.description==`opponent-logo-${opponent_id}.png`)
+    }
+    ) 
+  )
+ 
+  next();
+}
+
+router.use("/:team_id([0-9]+)/opponent/:opponent_id([0-9]+)", loadOpponent)
+router.get("/:team_id([0-9]+)/opponents", opponentsController.getOpponents);
+router.get("/:team_id([0-9]+)/opponent/:opponent_id([0-9]+)", doubleCsrfProtection, opponentsController.getOpponent);
+router.post("/:team_id([0-9]+)/opponent/:opponent_id([0-9]+)/upload_logo", upload.single('file'), doubleCsrfProtection, opponentsController.postOpponentLogo);
+// router.get("/:team_id([0-9]+)/opponent/:opponent_id/logo", ensureLoggedIn, opponentsController.getOpponentLogo);
+
+module.exports = {router}

src/routes/team.js

@@ -0,0 +1,45 @@
+const express = require("express");
+const teamsController = require("../controllers/team");
+const {loadRecentAndUpcomingEvents} = require("../middlewares/bulkload")
+const { load } = require("dotenv");
+const router = express.Router();
+const tsUtils = require('../lib/utils')
+
+// Middleware
+const loadTeam = async (req,res,next) => {
+  const {team_id} = req.params;
+  req.team = await teamsnap.loadTeam(team_id)
+  tsUtils.teamsnapLog('loadTeam', types=["team"], team_id, req);
+  const bulkLoadTypes = ['teamMediaGroup', 'teamPreferences', 'member'];
+  const items = tsUtils.groupTeamsnapItems(teamsnap.getAllItems(), bulkLoadTypes)
+  if (req.session.current_team_id == null || req.session.current_team_id != team_id || bulkLoadTypes.filter(t=> !items[t] || items[t].length==0).length > 0){
+    req.promises.push(teamsnap.bulkLoad(
+      team_id, 
+      bulkLoadTypes,
+      tsUtils.teamsnapCallback
+      ).then(bulkLoadItems=>{
+        const items = tsUtils.groupTeamsnapItems(bulkLoadItems, bulkLoadTypes)
+        tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team_id, req);
+        req.members = items.members;
+        req.team_media_group = items.teamMediaGroups?.pop();
+        req.team_preferences = items.teamsPreferences.pop();
+        req.session.current_team_id = req.team.id
+      }
+      )
+    )
+    }
+  else {
+    req.members = items.member;
+    req.team_media_group = items.teamMediaGroup.pop();
+    req.team_preferences = items.teamPreferences.pop();
+  }
+  next();
+}
+
+router.use("/:team_id([0-9]+)", loadTeam)
+
+// Routes
+router.get('/user/:user_id/teams',  teamsController.getTeams)
+router.get("/:team_id([0-9]+)/home", loadRecentAndUpcomingEvents, teamsController.getTeamHome);
+
+module.exports = {router, loadTeam}