2023-03-04

src/controllers/event.js

@@ -0,0 +1,54 @@
+tsUtils = require("../lib/utils");
+const path = require('path')
+
+
+exports.helpers = {
+  availability_percentage: (availabilitySummary, status) => {
+    attribute = {
+      going: "playerGoingCount",
+      notgoing: "playerNotGoingCount",
+      maybe: "playerMaybeCount",
+      unknown: "playerUnknownCount"
+    }[status.toLowerCase()]
+    return (availabilitySummary[attribute]/availabilitySummary.team.playerMemberCount)*100.0
+  }
+}
+
+exports.partials = path.join(__dirname, "../views/event/partials")
+
+exports.getEvents = async (req, res, next) => {
+  const {user, team, layout} = req
+  const bulkLoadTypes = ["event", "availabilitySummary"]
+  req.promises.push(
+    teamsnap.bulkLoad(team.id, bulkLoadTypes , () => {tsUtils.teamsnapCallback;req.items = tsUtils.teamsnapLog('bulkLoad', types=bulkLoadTypes, team.id, req)})
+    .then(items=>tsUtils.groupTeamsnapItems(items))
+    .then(items=>{
+      items.events.forEach((event) => {
+        event.link('availabilitySummary', items.availabilitySummaries.find(a=>a.eventId==event.id))
+      }
+      )
+      req.events = items.events;
+    }
+  )
+  )
+  await Promise.all(req.promises)
+  const context = {
+    title: "Events",
+    user, team, layout,
+    events: req.events,
+  };
+  res.render("event/list", context);
+};
+
+exports.getEvent = async (req, res, next) => {
+  await Promise.all(req.promises)
+  const {user, team, event, layout} = req
+  lineups = await req.event.loadItem('eventLineups')
+  event.link('availabilitySummary', req.availabilitySummary)
+  context = {
+    title: "Event",
+    user, team, event, layout,
+    availabilitySummary: req.availabilitySummary,
+  };
+  res.render("event/show", context);
+};

src/controllers/eventlineup.js

@@ -0,0 +1,181 @@
+const path = require('path')
+const fs = require('fs')
+const {embeddedSvgFromPath, parsePositionLabel} = require("../lib/utils")
+const tsUtils = require('../lib/utils')
+const { loadEventLineupEntries } = require('teamsnap.js')
+
+exports.partials = path.join(__dirname, "../views/eventlineup/partials")
+
+const statusCodeIcons = {
+  1: embeddedSvgFromPath("/teamsnap-ui/assets/icons/check.svg"),
+  0: embeddedSvgFromPath("/teamsnap-ui/assets/icons/dismiss.svg"),
+  2: embeddedSvgFromPath("/bootstrap-icons/question-lg.svg"),
+  null: embeddedSvgFromPath("/bootstrap-icons/question.svg"),
+  undefined: embeddedSvgFromPath("/bootstrap-icons/question-lg.svg")
+}
+
+exports.helpers = {
+  plus1: (i) => Number(i)+1,
+  positions: () => ["P", "C", "1B", "2B", "3B", "SS", "LF", "CF", "RF", "EH", "DH"],
+  defense_positions: () => ["C", "1B", "2B", "3B", "SS", "LF", "CF", "RF", "P"],
+  avail_status_code_icon: (status_code) => {
+    const icon_classes = {
+      1: "u-colorPositive",
+      0: "u-colorNegative",
+      2: "u-colorPrimary",
+      null: "u-colorGrey",
+      undefined: "u-colorGrey"
+    }
+
+    const button_classes = {
+      1: "Button--yes",
+      0: "Button--no",
+      2: "Button--maybe",
+      null: "",
+      undefined: ""
+    }
+
+    return `<button class="Button Button--smallSquare ${button_classes[status_code]}" type="button"><span class="">${statusCodeIcons[status_code]}</span></button>`
+  },
+  positionLabelWithoutFlags: (label) => {
+    return label.replace(/(.*?)\s\[(.*?)\]/, "$1");
+  },
+  comparePositionWithFlags: (labelWithoutFlags, eventLineupEntry, options) => {
+    labelWithFlags = eventLineupEntry?.label
+    const {positionLabelWithoutFlags} = parsePositionLabel(labelWithFlags);
+    return positionLabelWithoutFlags == labelWithoutFlags;
+  },
+  isStarting: (member) => {
+    return (member.benchcoach?.eventLineupEntry != null);
+  },
+  isInStartingLineup: (member) => {
+    if (member.benchcoach.eventLineupEntry == null) return false;
+    const {positionFlags} = parsePositionLabel(member.benchcoach.eventLineupEntry?.label);
+    return (positionFlags != "PO")
+  },
+  isInPositionOnly: (member) => {
+    if (!member.benchcoach || member.benchcoach.eventLineupEntry == null) return false;
+    const {positionFlags} = parsePositionLabel(member.benchcoach.eventLineupEntry?.label);
+    return (member.benchcoach.eventLineupEntry != null && positionFlags == "PO")
+  },
+  isInBench: (member) => {
+    if (member.benchcoach.eventLineupEntry != null || member.isNonPlayer) return false;
+    return (member.benchcoach.availability?.statusCode != 0 && member.benchcoach.availability?.statusCode != null)
+  },
+  isInOut: (member) => {
+    if (member.benchcoach.eventLineupEntry != null || member.isNonPlayer) return false;
+    return (member.benchcoach.availability?.statusCode == 0 || member.benchcoach.availability?.statusCode == null)
+  },
+  availabilityStatusShort: (availability) => {
+    const {YES, MAYBE, NO, NONE} = teamsnap.AVAILABILITIES
+    const statusShortLookup = {}
+    statusShortLookup[YES] = "YES"
+    statusShortLookup[MAYBE] = "MAY"
+    statusShortLookup[NO] = "NO"
+    statusShortLookup[NONE] = "UNK"
+    statusShortLookup[undefined] = "UNK"
+    return (statusShortLookup[availability?.statusCode])
+  }
+}
+
+exports.getEventLineup = async (req, res)=>{
+  // res.send(req.event_lineup)
+  await Promise.all(req.promises)
+  const {user, team, members, event, layout, event_lineup, event_lineup_entries, availabilities, availabilitySummary, csrfToken} = req
+  attachBenchcoachPropertiesToMember(members, event_lineup_entries, availabilities)
+  members.sort(tsUtils.teamsnapMembersSortLineupAvailabilityLastName)
+  res.render("eventlineup/edit", {user, team, members, event, layout, event_lineup, event_lineup_entries, availabilitySummary, csrfToken})
+}
+
+attachBenchcoachPropertiesToMember = (members, event_lineup_entries, availabilities) => {
+  members.forEach((member)=> {
+  // I *think* this can be done with linking https://github.com/teamsnap/teamsnap-javascript-sdk/wiki/Persistence#linking
+  // here's an example:
+  // member.link('eventLineupEntry', event_lineup_entries.find(i=>i.id=members[1].id))
+    member.benchcoach = {}
+    // I don't really like this, but the member_id changes once a season is archived.
+    // as far as I can tell, member_name should consistently be formulated from first and last name
+    // perhaps could have some edge cases if first or last names change, but this *should be* exceedingly rare.
+    const member_name = `${member.firstName} ${member.lastName}`
+    const event_lineup_entry = event_lineup_entries.find(e=> e.memberId == member.id || e.memberName == member_name)
+    const availability = availabilities.find(e=>e.memberId == member.id)
+    member.benchcoach.availability = availability
+    if (event_lineup_entry != null) {
+      // member.link('eventLineupEntry', event_lineup_entry)
+      member.benchcoach.eventLineupEntry = event_lineup_entry
+      const {positionLabelWithoutFlag} = parsePositionLabel(event_lineup_entry.label);
+      member.benchcoach.eventLineupEntry.positionLabelWithoutFlag = positionLabelWithoutFlag
+    }
+    else {
+      member.benchcoach.eventLineupEntry = null
+    }
+  }
+  )
+}
+exports.attachBenchcoachPropertiesToMember = attachBenchcoachPropertiesToMember
+
+exports.getEventLineupEmail = async (req, res)=>{
+  const {body} = req
+  if (body.memberId == null) {res.status(400).end();return}
+  await Promise.all(req.promises)
+  const {user, team, members, event, layout, event_lineup, event_lineup_entries, availabilities, availabilitySummary} = req
+  const eventLineupEntries = req.event_lineup.eventLineupEntries
+  const {newEventLineupEntries} = processPostedEventLineupEntries(body, eventLineupEntries, event_lineup)
+  attachBenchcoachPropertiesToMember(members, newEventLineupEntries, availabilities)
+  members.sort(tsUtils.teamsnapMembersSortLineupAvailabilityLastName)
+  // eventLineup = await teamsnap.loadEventLineups(req.params.event_id)
+  res.status(200).render("eventlineup/email", {user, team, members, event, event_lineup, event_lineup_entries: newEventLineupEntries, availabilities, availabilitySummary})
+}
+
+exports.getEventLineupEntries = async (req, res)=>{
+  const {event_lineup, event_lineup_entries} = req
+  res.setHeader('Content-Type', 'application/json').send(JSON.stringify(req.event_lineup_entries))
+}
+
+exports.getEventLineupEntriesData = async (req, res)=>{
+  const {event_lineup, event_lineup_entries} = req
+  res.setHeader('Content-Type', 'application/json').send(JSON.stringify(req.event_lineup_entries))
+}
+
+exports.postEventLineup = async (req,res) => {
+  const {body} = req
+  if (body.memberId == null) {res.status(400).end();return}
+  await Promise.all(req.promises);
+  const eventLineupEntries = req.event_lineup.eventLineupEntries
+  const {newEventLineupEntries} = processPostedEventLineupEntries(body, eventLineupEntries, req.event_lineup)
+  newEventLineupEntries.forEach(e=>{
+    teamsnap.saveEventLineupEntry(e)
+  })
+  eventLineup = await teamsnap.loadEventLineups(req.params.event_id)
+  res.status(201).end()
+}
+
+const processPostedEventLineupEntries = (body, eventLineupEntries, eventLineup) => {
+  const newEventLineupEntries = []
+
+  body.memberId.forEach((memberId, i)=>{
+    const lineupEntryId = body.eventLineupEntryId[i]
+    const lineupEntryLabel = body.label[i]
+    const lineupEntrySequence = body.sequence[i]
+    if (lineupEntryId != '') {
+      // Update lineup entry
+      const eventLineupEntry = eventLineupEntries.find((e)=>e.id==Number(lineupEntryId))
+      eventLineupEntry.sequence = lineupEntrySequence
+      eventLineupEntry.label = lineupEntryLabel
+      newEventLineupEntries.push(eventLineupEntry)
+    }
+    else if (lineupEntryLabel != '') {
+      // Create lineup entry
+      const eventLineupEntry = teamsnap.createEventLineupEntry()
+      eventLineupEntry.eventLineupId = eventLineup.id
+      eventLineupEntry.memberId = memberId
+      eventLineupEntry.sequence = lineupEntrySequence
+      eventLineupEntry.label = lineupEntryLabel
+      newEventLineupEntries.push(eventLineupEntry)
+    }
+    else {
+      // Skip lineup entry
+    }
+  })
+  return {newEventLineupEntries, eventLineupEntries}
+}

src/controllers/events.js

@@ -1,169 +0,0 @@
-utils = require("../lib/utils");
-
-exports.getEvents = (req, res, next) => {
-  team_id = req.params.team_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.bulkLoad(team_id, ["team", "event", "availabilitySummary"]).then(() => {
-      items = teamsnap.getAllItems();
-      context = {
-        title: "Events",
-        team: items.find((i) => i.type == "team" && i.id == team_id),
-        availabilitySummaries: items.filter((i) => i.type == "availabilitySummary"),
-        events: items.filter((i) => i.type == "event"),
-      };
-      res.render("events", context);
-    });
-  });
-};
-
-exports.getEvent = (req, res, next) => {
-  team_id = req.params.team_id;
-  event_id = req.params.event_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.bulkLoad(team_id, ["team", "event", "availabilitySummary"]).then(() => {
-      items = teamsnap.getAllItems();
-      context = {
-        title: "Event",
-        team: items.find((i) => i.type == "team" && i.id == team_id),
-        availabilitySummary: items.find((i) => i.type == "availabilitySummary" && i.id == event_id),
-        event: items.find((i) => i.type == "event" && i.id == event_id),
-      };
-      res.render("event", context);
-    });
-  });
-};
-
-exports.getLineup = (req, res, next) => {
-  team_id = req.params.team_id;
-  event_id = req.params.event_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap
-      .bulkLoad(team_id, [
-        "team",
-        "member",
-        // "member_photos",
-        "event",
-        "opponent",
-        "availability_summary",
-      ])
-      .then((items) => {
-        events = items.filter((i) => i.type == "event").sort((a, b) => a.startDate - b.startDate);
-        event = events.find((i) => i.id == event_id);
-        events_past = events.slice(
-          events.findIndex((e) => e == event) - 4,
-          events.findIndex((e) => e == event)
-        );
-        events_future = events.slice(events.findIndex((e) => e == event) + 1, events.findIndex((e) => e == event) + 5);
-        events = events_past.concat(event).concat(events_future);
-      })
-      .then((items) => {
-        return teamsnap.loadAvailabilities({
-          eventId: events.map((e) => e.id),
-        });
-      })
-      .then(() => {
-        return teamsnap.collections["eventLineups"]
-          .queryItems("search", {
-            eventId: events.map((e) => e.id),
-          })
-          .then((event_lineups) => {
-            return Promise.all(event_lineups.map((elu) => elu.loadItem("eventLineupEntries")));
-          });
-      })
-      .then(() => {
-        items = teamsnap.getAllItems();
-        events = items.filter((i) => i.type == "event");
-        current_event_index = events.findIndex((e) => e.id == event_id);
-
-        context = {
-          title: "Lineup",
-          team: items.find((e) => e.type == "team" && e.id == team_id),
-          team_id: req.params.team_id,
-          event_id: req.params.event_id,
-          current_event_index: current_event_index,
-          events: items.filter((a) => a.type == "event"),
-          availabilitySummaries: items.filter((i) => i.type == "availabilitySummary"),
-          availabilitySummary: items.filter((i) => i.type == "availabilitySummary" && i.eventId == event_id),
-          event: items.find((e) => e.type == "event" && e.id == event_id),
-          events_past: events_past,
-          events_future: events_future,
-          members: items.filter((a) => a.type == "member"),
-          availabilities: items.filter((i) => i.type == "availability").sort(utils.teamsnapAvailabilitiesSort),
-          all_lineup_entries: items.filter((i) => i.type == "eventLineupEntry"),
-          event_lineup_entries: items
-            .filter((i) => i.type == "eventLineupEntry" && i.eventId == event_id)
-            .sort((a, b) => a.sequence - b.sequence),
-        };
-
-        res.render("event-lineup", context);
-      });
-  });
-};
-
-exports.getLineupCard = (req, res, next) => {
-  team_id = req.params.team_id;
-  event_id = req.params.event_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap
-      .bulkLoad(team_id, [
-        "team",
-        "member",
-        // "member_photos",
-        "event",
-        "opponent",
-        "availability_summary",
-      ])
-      .then((items) => {
-        events = items.filter((i) => i.type == "event").sort((a, b) => a.startDate - b.startDate);
-        event = events.find((i) => i.id == event_id);
-        events_past = events.slice(
-          events.findIndex((e) => e == event) - 4,
-          events.findIndex((e) => e == event)
-        );
-        events_future = events.slice(events.findIndex((e) => e == event) + 1, events.findIndex((e) => e == event) + 5);
-        events = events_past.concat(event).concat(events_future);
-      })
-      .then((items) => {
-        return teamsnap.loadAvailabilities({
-          eventId: events.map((e) => e.id),
-        });
-      })
-      .then(() => {
-        return teamsnap.collections["eventLineups"]
-          .queryItems("search", {
-            eventId: events.map((e) => e.id),
-          })
-          .then((event_lineups) => {
-            return Promise.all(event_lineups.map((elu) => elu.loadItem("eventLineupEntries")));
-          });
-      })
-      .then(() => {
-        items = teamsnap.getAllItems();
-        events = items.filter((i) => i.type == "event");
-        current_event_index = events.findIndex((e) => e.id == event_id);
-
-        context = {
-          title: "Gamecard",
-          team_id: req.params.team_id,
-          event_id: req.params.event_id,
-          current_event_index: current_event_index,
-          events: items.filter((a) => a.type == "event"),
-          availabilitySummaries: items.filter((i) => i.type == "availabilitySummary"),
-          event: items.find((e) => e.type == "event" && e.id == event_id),
-          events_past: events_past,
-          events_future: events_future,
-          members: items.filter((a) => a.type == "member"),
-          availabilities: items.filter((i) => i.type == "availability").sort(utils.teamsnapAvailabilitiesSort),
-          all_lineup_entries: items.filter((i) => i.type == "eventLineupEntry"),
-          event_lineup_entries_offense: items
-            .filter((i) => i.type == "eventLineupEntry" && i.eventId == event_id && !i.label.includes("[PO]"))
-            .sort((a, b) => a.sequence - b.sequence),
-          event_lineup_entries: items
-            .filter((i) => i.type == "eventLineupEntry" && i.eventId == event_id)
-            .sort((a, b) => a.sequence - b.sequence),
-        };
-
-        res.render("event-lineupcard", context);
-      });
-  });
-};

src/controllers/eventsheet.js

@@ -0,0 +1,73 @@
+const tsUtils = require('../lib/utils')
+
+exports.getEventSheet = async (req,res) =>{
+  await Promise.all(req.promises)
+  const {user, team, team_preferences, members, event, event_lineup, event_lineup_entries, availabilities, availabilitySummary, timeline, recent_events, upcoming_events} = req
+  res.render('eventsheet/sheet', {user, team, team_preferences, members, event, event_lineup, event_lineup_entries, availabilities, availabilitySummary, timeline, recent_events, upcoming_events})
+}
+
+exports.getLineupCard = (req, res, next) => {
+  team_id = req.params.team_id;
+  event_id = req.params.event_id;
+  teamsnap
+      .bulkLoad(team_id, [
+        "team",
+        "member",
+        // "member_photos",
+        "event",
+        "opponent",
+        "availabilitySummary",
+      ])
+      .then((items) => {
+        events = items.filter((i) => i.type == "event").sort((a, b) => a.startDate - b.startDate);
+        event = events.find((i) => i.id == event_id);
+        events_past = events.slice(
+          events.findIndex((e) => e == event) - 4,
+          events.findIndex((e) => e == event)
+        );
+        events_future = events.slice(events.findIndex((e) => e == event) + 1, events.findIndex((e) => e == event) + 5);
+        events = events_past.concat(event).concat(events_future);
+      })
+      .then((items) => {
+        return teamsnap.loadAvailabilities({
+          eventId: events.map((e) => e.id),
+        }).catch(error => console.log("error in event.js"));
+      })
+      .then(() => {
+        return teamsnap.collections["eventLineups"]
+          .queryItems("search", {
+            eventId: events.map((e) => e.id),
+          })
+          .then((event_lineups) => {
+            return Promise.all(event_lineups.map((elu) => elu.loadItem("eventLineupEntries")));
+          });
+      })
+      .then(() => {
+        items = teamsnap.getAllItems();
+        events = items.filter((i) => i.type == "event");
+        current_event_index = events.findIndex((e) => e.id == event_id);
+
+        context = {
+          title: "Gamecard",
+          team_id: req.params.team_id,
+          event_id: req.params.event_id,
+          current_event_index: current_event_index,
+          events: items.filter((a) => a.type == "event"),
+          availabilitySummaries: items.filter((i) => i.type == "availabilitySummary"),
+          event: items.find((e) => e.type == "event" && e.id == event_id),
+          events_past: events_past,
+          events_future: events_future,
+          members: items.filter((a) => a.type == "member"),
+          availabilities: items.filter((i) => i.type == "availability").sort(tsUtils.teamsnapMembersSortLineupAvailabilityLastName),
+          all_lineup_entries: items.filter((i) => i.type == "eventLineupEntry"),
+          event_lineup_entries_offense: items
+            .filter((i) => i.type == "eventLineupEntry" && i.eventId == event_id && !i.label.includes("[PO]"))
+            .sort((a, b) => a.sequence - b.sequence),
+          event_lineup_entries: items
+            .filter((i) => i.type == "eventLineupEntry" && i.eventId == event_id)
+            .sort((a, b) => a.sequence - b.sequence),
+        };
+
+        res.render("event-lineupcard", context);
+      });
+};

src/controllers/member.js

@@ -0,0 +1,9 @@
+exports.getMembers = (req, res, next) => {
+  const {members, team} = req
+  context = {
+    title: `Roster`,
+    team_id: team.id,
+    team, members,
+  };
+  res.render("members", context);
+};

src/controllers/members.js

@@ -1,18 +0,0 @@
-utils = require("../lib/utils");
-
-exports.getMembers = (req, res, next) => {
-  team_id = req.params.team_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.bulkLoad(team_id, ["team", "member"]).then(() => {
-      items = teamsnap.getAllItems();
-      context = {
-        title: `Roster`,
-        team_id: team_id,
-        team: items.find((i) => i.type == "team" && i.id == team_id),
-        members: items.filter((i) => i.type == "member" && i.teamId == team_id),
-      };
-      res.set("Content-Type", "text/html");
-      res.render("members", context);
-    });
-  });
-};

src/controllers/opponent.js

@@ -0,0 +1,109 @@
+
+
+exports.getOpponents = async (req, res, next) => {
+  const {user, team, layout, csrfToken} = req
+  opponents = await teamsnap.loadOpponents(team.id, ["event", "availabilitySummary"], (err, opponents)=>{
+    if (err) console.log('err in controllers/opponent.js')
+    
+    else return opponents;
+  })
+  context = {
+    title: "Opponents",
+    user, team, layout, csrfToken,
+    opponents: opponents,
+  };
+  res.render("opponent/list", context);
+};
+
+exports.uploadOpponentLogoForm = (req, res, next) => {
+  opponent_id = req.params.opponent_id;
+  team_id = req.params.team_id;
+  res.set("Content-Type", "text/html");
+  res.render("upload-logo", {
+    title: "Upload Logo",
+    csrf_token: req.csrfToken(),
+    team_id: team_id,
+    opponent_id: opponent_id,
+  });
+};
+
+exports.uploadOpponentLogo = (req, res, next) => {
+  opponent_id = req.body.opponent_id;
+  team_id = req.body.team_id;
+  member_id = req.user.id;
+  file = new File(req.file.buffer, `team-logo-${opponent_id}.png`, {
+    type: "image/png",
+  });
+  authTeamsnap(req.user);
+  teamsnap
+    .loadCollections()
+    .then(() => {
+      return teamsnap.createTeamMedium({
+        file: file,
+        mediaFormat: "file",
+        memberId: member_id,
+        teamId: team_id,
+        teamMediaGroupId: "4927028",
+        description: `team-logo-${opponent_id}.png`,
+      });
+    })
+    .then((item) => {
+      return teamsnap.uploadTeamMedium(item);
+    })
+    .then((item) => {
+      res.send("Data Received: " + JSON.stringify(item));
+    })
+    .fail((err) => console.log(err));
+};
+
+exports.getOpponent = async (req, res) => {
+  await Promise.all(req.promises)
+  const {team, team_media_group, opponent, layout, opponent_logo, user, csrfToken} = req
+  context = {
+    team, team_media_group, opponent, layout, opponent_logo, user, csrfToken
+    // opponent_logo: items.find(
+    //   (i) => i.type == "teamMedium" && i.description == `opponent-logo-${opponent_id}.png`
+    // ),
+  };
+  res.set("Content-Type", "text/html");
+  res.render("opponent/show", context);
+};
+
+exports.postOpponentLogo = async (req, res, next) => {
+  res.status('501').send('Not Implemented')
+  // await Promise.all(req.promises)
+  // const {team, opponent, user, body} = req
+  // const filename = `team-logo-${opponent.id}.png`
+  // file = new File(req.file.buffer, filename, {
+  //   type: "image/png",
+  // });
+
+  // const team_medium = await teamsnap.createTeamMedium(
+  //   {
+  //     file: file,
+  //     memberId: user.id,
+  //     teamId: team.id,
+  //     teamMediaGroupId: body.teamMediaGroupId,
+  //     description: filename,
+  //   }
+  // )
+  // await teamsnap.saveTeamMedium(team_medium)
+  // // await teamsnap.uploadTeamMedium(team_medium)
+
+  // const headers={'Authorization': `Bearer ${user.accessToken}`}
+  // // const url = teamsnap.collections.teamMedia.commands.uploadTeamMedium.href
+  // const url = teamsnap.collections.teamMedia.queries.search.href
+  // const response = await fetch(url+`?team_id=${team.id}`, {
+  //     headers,
+  //     method: 'get',
+  //     // body:{team_id:team.id}
+  //     // body: {
+  //     //   file: file,
+  //     //   member_id: user.id,
+  //     //   team_id: team.id,
+  //     //   team_media_group_id: body.teamMediaGroupId,
+  //     //   description: filename,
+  //     // }
+  //   })
+  // // await teamsnap
+}

src/controllers/opponents.js

@@ -1,80 +0,0 @@
-exports.getOpponents = (req, res, next) => {
-  team_id = req.params.team_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.bulkLoad(team_id, ["team", "opponent"]).then((items) => {
-      res.set("Content-Type", "text/html");
-      res.render("opponents", {
-        title: "Opponents",
-        team: items.find((i) => i.type == "team" && i.id == team_id),
-        opponents: items.filter((i) => i.type == "opponent"),
-        team_id: team_id,
-      });
-    });
-  });
-};
-
-exports.uploadOpponentLogoForm = (req, res, next) => {
-  opponent_id = req.params.opponent_id;
-  team_id = req.params.team_id;
-  res.set("Content-Type", "text/html");
-  res.render("upload-logo", {
-    title: "Upload Logo",
-    csrf_token: req.csrfToken(),
-    team_id: team_id,
-    opponent_id: opponent_id,
-  });
-};
-
-exports.uploadOpponentLogo = (req, res, next) => {
-  opponent_id = req.body.opponent_id;
-  team_id = req.body.team_id;
-  member_id = req.user.id;
-  file = new File(req.file.buffer, `team-logo-${opponent_id}.png`, {
-    type: "image/png",
-  });
-  authTeamsnap(req.user);
-  teamsnap
-    .loadCollections()
-    .then(() => {
-      return teamsnap.createTeamMedium({
-        file: file,
-        mediaFormat: "file",
-        memberId: member_id,
-        teamId: team_id,
-        teamMediaGroupId: "4927028",
-        description: `team-logo-${opponent_id}.png`,
-      });
-    })
-    .then((item) => {
-      return teamsnap.uploadTeamMedium(item);
-    })
-    .then((item) => {
-      res.send("Data Received: " + JSON.stringify(item));
-    })
-    .fail((err) => console.log(err));
-};
-
-exports.getOpponent = (req, res, next) => {
-  team_id = req.params.team_id;
-  opponent_id = req.params.opponent_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap
-      .bulkLoad(team_id, ["team", "opponent"])
-      .then(() => {
-        teamsnap.loadTeamMedia(team_id);
-      })
-      .then(() => {
-        items = teamsnap.getAllItems();
-        context = {
-          team: items.find((i) => i.type == "team" && i.id == team_id),
-          opponent: items.find((i) => i.type == "opponent" && i.id == opponent_id),
-          opponent_logo: items.find(
-            (i) => i.type == "teamMedium" && i.description == `opponent-logo-${opponent_id}.png`
-          ),
-          team_id: team_id,
-        };
-        res.set("Content-Type", "text/html");
-        res.render("opponent", context);
-      });
-  });
-};

src/controllers/team.js

@@ -0,0 +1,21 @@
+utils = require("../lib/utils");
+
+exports.getTeams = async (req, res, next) => {
+  const {layout, user} = req
+  teams = await teamsnap.loadTeams((err, teams) => {
+      if (err) console.log("error in team.js", err);
+    })
+  context = { layout, title: "Teams", teams: teams.filter(t=>!t.isRetired), user };
+  res.render("team/list", context);
+};
+
+exports.getTeamHome = async (req, res, next) => {
+  await Promise.all(req.promises)
+  const {user, team, team_preferences, upcoming_events, recent_events, layout} = req
+  context = { 
+    title: "Home", 
+    layout, team, user, team_preferences, upcoming_events, recent_events
+  };
+
+  res.render("team/home", context);
+};

src/controllers/teams.js

@@ -1,20 +0,0 @@
-utils = require("../lib/utils");
-
-exports.getTeams = (req, res, next) => {
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.loadTeams().then((teams) => {
-      context = { title: "Teams", teams: teams };
-      res.render("teams", context);
-    });
-  });
-};
-
-exports.getTeamHome = (req, res, next) => {
-  team_id = req.params.team_id;
-  utils.initTeamsnap(req, res, () => {
-    teamsnap.loadTeam(team_id).then((team) => {
-      context = { title: "Home", team: team };
-      res.render("team", context);
-    });
-  });
-};