benchcoach/routes/index.js

var express = require("express");
var ensureLogIn = require("connect-ensure-login").ensureLoggedIn;
var papaparse = require("papaparse");

var ensureLoggedIn = ensureLogIn();

var router = express.Router();

function authTeamsnap(user) {
  if (!teamsnap.isAuthed()) {
    teamsnap.init(process.env["TEAMSNAP_CLIENT_ID"]);
    teamsnap.auth(user.accessToken);
  }
}

function availabilitiesSort(a, b) {
  status_code_sort = [
    teamsnap.AVAILABILITIES.YES,
    teamsnap.AVAILABILITIES.MAYBE,
    teamsnap.AVAILABILITIES.NO,
    teamsnap.AVAILABILITIES.NONE,
  ];
  a_sort = status_code_sort.indexOf(a.statusCode);
  b_sort = status_code_sort.indexOf(b.statusCode);
  if (a_sort > b_sort) {
    return 1;
  }
  if (a_sort < b_sort) {
    return -1;
  }
  if (a_sort == b_sort) {
    if (a.member.lastName < b.member.lastName) {
      return -1;
    }
    if (a.member.lastName > b.member.lastName) {
      return 1;
    }
  }
}

async function fetch_stats(resolve, reject) {
  url =
    "https://docs.google.com/spreadsheets/d/{sheet_id}/export?format=csv&gid={tab_id}";
  papaparse.Papa.parse(url, {
    download: true,
    complete: function (results) {
      results.data.forEach((row, i) => {
        if (i == 0 || row[2] == "Totals" || row[2] == "") {
          return;
        }
        d = {
          first_name: row[3],
          last_name: row[2],
          jersey_number: row[1],
          pa: row[5],
          ab: row[6],
          avg: row[20],
          obp: row[21],
          slg: row[22],
        };
      });
      resolve(d);
    },
  });
}

/* GET home page. */
router.get("/", ensureLoggedIn, function (req, res, next) {
  if (req.user) {
    authTeamsnap(req.user);
    teamsnap.loadCollections(function (err) {
      if (err) {
        alert("Error loading TeamSnap SDK");
        return;
      }
      teamsnap.loadTeams(function onTeamsLoad(err, teams) {
        teams = teams.sort((a, b) => b.seasonName - a.seasonName);
        res.render("home", { req: req, teams: teams });
      });
    });
  } else {
    res.render("home", { req: req });
  }
});

router.get(
  "/teams",
  ensureLoggedIn,
  function (req, res, next) {
    console.log("teamsnap authed?: ", teamsnap.isAuthed());
    console.log("user is", req.user);

    authTeamsnap(req.user);
    teamsnap.loadCollections(function (err) {
      if (err) {
        alert("Error loading TeamSnap SDK");
        return;
      }
      teamsnap.loadTeams(function onTeamsLoad(err, teams) {
        teams = teams.sort((a, b) => b.seasonName - a.seasonName);
        res.render("teams", { teams: teams });
      });
    });

    next();
  },
  function (req, res, next) {
    // res.send(`${me.firstName} ${me.lastName}`);
  }
);

router.get("/:team_id([0-9]+)", ensureLoggedIn, function (req, res, next) {
  authTeamsnap(req.user);
  team_id = req.params.team_id;
  console.log("team_id", team_id);
  teamsnap.loadCollections(function (err) {
    if (err) {
      alert("Error loading TeamSnap SDK");
      return;
    }
    teamsnap.enablePersistence();

    teamsnap.bulkLoad(
      team_id,
      ["team", "member", "event", "opponent", "availability_summary"],
      function onBulkLoad(err, items) {
        team = items.find((i) => (i.type == "team") & (i.id == team_id));
        console.log(team);
        res.set("Content-Type", "text/html");
        res.render("team", { team: team });
      }
    );
  });
});

router.get(
  "/:team_id/event/:event_id",
  ensureLoggedIn,
  function (req, res, next) {
    authTeamsnap(req.user);
    var team_id = req.params.team_id;
    var event_id = req.params.event_id;
    teamsnap.loadCollections(function (err) {
      console.log();
      teamsnap.enablePersistence();

      teamsnap.bulkLoad(
        team_id,
        ["team", "event", "availabilitySummary"],
        function (err, items) {
          if (err) {
            res.code = 500;
            res.send(err);
          }

          availabilitySummaries = items.filter(
            (i) => i.type == "availabilitySummary" && i.id == event_id
          );
          events = items.filter((i) => i.type == "event" && i.id == event_id);

          if (events) {
            event = events[0];
            availabilitySummary = availabilitySummaries[0];
            console.log("A_S", availabilitySummaries);
            res.render("event", {
              event: event,
              team_id: team_id,
              team: items.find((i) => i.type == "team" && i.id == team_id),
              availabilitySummary: availabilitySummary,
            });
          } else {
            res.code = 500;
            res.send("error");
          }
        }
      );
    });
  }
);

router.get(
  "/:team_id/event/:event_id/gamecard",
  ensureLoggedIn,
  function (req, res, next) {
    authTeamsnap(req.user);
    team_id = req.params.team_id;
    event_id = req.params.event_id;
    teamsnap.loadCollections((err) => {
      teamsnap.enablePersistence();
      var events;
      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 = {
            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(availabilitiesSort),
            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("gamecard", context);
        });
    });
  }
);

router.get(
  "/:team_id/event/:event_id/lineup",
  ensureLoggedIn,
  function (req, res, next) {
    authTeamsnap(req.user);
    team_id = req.params.team_id;
    event_id = req.params.event_id;
    teamsnap.loadCollections((err) => {
      teamsnap.enablePersistence();
      var events;
      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 = {
            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(availabilitiesSort),
            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("lineup", context);
        });
    });
  }
);

router.get("/:team_id/events", ensureLoggedIn, function (req, res, next) {
  authTeamsnap(req.user);
  team_id = req.params.team_id;
  event_id = req.params.event_id;
  teamsnap.loadCollections(function (err) {
    teamsnap
      .bulkLoad(team_id, ["team", "event", "availability_summary"])
      .then((items) => {
        res.set("Content-Type", "text/html");
        res.render("events", {
          team: items.find((i) => i.type == "team" && i.id == team_id),
          events: items.filter((i) => i.type == "event"),
          availabilitySummaries: items.filter(
            (i) => i.type == "availabilitySummary"
          ),
          team_id: team_id,
        });
      });
  });
});

module.exports = router;