FTC Support

electron/helpers/ffmpegCommands.ts

@@ -14,7 +14,8 @@ export interface SplitBlock {
 export interface SplitFixedDetails {
   id: string;
   inputFile: string;
-  outputFile: string;
+  outputDirectory: string;
+  outputFileName: string;
   blocks: SplitBlock[];
 }
 
@@ -158,16 +159,20 @@ export async function splitFixedLength(
     )
   );
 
-  await concatVideoFiles(videoParts, details.outputFile, (progress) => {
-    const msSinceLastUpdate = Date.now() - lastProgressSent;
-    if (msSinceLastUpdate < progressReportRateMs) return;
-    lastProgressSent = Date.now();
-
-    event.sender.send('split-progress', {
-      id: details.id,
-      percent: 100,
-    });
-  });
+  await concatVideoFiles(
+    videoParts,
+    path.join(details.outputDirectory, details.outputFileName),
+    (progress) => {
+      const msSinceLastUpdate = Date.now() - lastProgressSent;
+      if (msSinceLastUpdate < progressReportRateMs) return;
+      lastProgressSent = Date.now();
+
+      event.sender.send('split-progress', {
+        id: details.id,
+        percent: 100,
+      });
+    }
+  );
 
   event.sender.send('split-end', { matchKey: details.id });
 }

package.json

@@ -56,6 +56,7 @@
     "fluent-ffmpeg": "^2.1.2",
     "luxon": "^3.4.3",
     "react-player": "^2.13.0",
+    "react-viewport-list": "^7.1.2",
     "tailwind-merge": "^2.0.0",
     "tailwindcss": "^3.3.5",
     "uuid": "^9.0.1",

src/api/FTCTypes.ts

@@ -0,0 +1,81 @@
+export interface EventList {
+  events: Event[];
+  eventCount: number;
+}
+
+export interface Event {
+  eventId: string;
+  code: string;
+  divisionCode: null | string;
+  name: string;
+  remote: boolean;
+  hybrid: boolean;
+  fieldCount: number;
+  published: boolean;
+  type: string;
+  typeName: string;
+  regionCode: string;
+  leagueCode: null | string;
+  districtCode: string;
+  venue: string;
+  address: string;
+  city: string;
+  stateprov: string;
+  country: string;
+  website: null | string;
+  liveStreamUrl: null | string;
+  timezone: string;
+  dateStart: string;
+  dateEnd: string;
+}
+
+export interface HybridSchedule {
+  schedule: FTCMatch[];
+}
+
+export interface FTCMatch {
+  description: string;
+  tournamentLevel: TournamentLevel;
+  series: number;
+  matchNumber: number;
+  startTime: string;
+  actualStartTime: string;
+  postResultTime: string;
+  scoreRedFinal: number;
+  scoreRedFoul: number;
+  scoreRedAuto: number;
+  scoreBlueFinal: number;
+  scoreBlueFoul: number;
+  scoreBlueAuto: number;
+  scoreBlueDriveControlled: number;
+  scoreBlueEndgame: number;
+  redWins: boolean;
+  blueWins: boolean;
+  teams: Team[];
+}
+
+export interface Team {
+  teamNumber: number;
+  displayTeamNumber: string;
+  station: Station;
+  surrogate: boolean;
+  noShow: boolean;
+  dq: boolean;
+  onField: boolean;
+  teamName: string;
+}
+
+export enum Station {
+  Blue1 = 'Blue1',
+  Blue2 = 'Blue2',
+  Blue3 = 'Blue3',
+  Red1 = 'Red1',
+  Red2 = 'Red2',
+  Red3 = 'Red3',
+}
+
+export enum TournamentLevel {
+  Qualification = 'QUALIFICATION',
+  Semifinal = 'SEMIFINAL',
+  Final = 'FINAL',
+}

src/api/ftcApi.ts

@@ -0,0 +1,47 @@
+import { EventList, HybridSchedule } from './FTCTypes';
+
+const ftcRoot = 'https://ftc-api.firstinspires.org/v2.0';
+function authHeader() {
+  const ftcUser = localStorage.getItem('ftcApiUsername')
+    ? JSON.parse(localStorage.getItem('ftcApiUsername')!)
+    : '';
+  const ftcPass = localStorage.getItem('ftcApiPassword')
+    ? JSON.parse(localStorage.getItem('ftcApiPassword')!)
+    : '';
+
+  return `Basic ${btoa(`${ftcUser}:${ftcPass}`)}`;
+}
+
+export async function getMatches(year: number, eventKey?: string) {
+  if (!eventKey) {
+    return Promise.reject('No event key provided');
+  }
+  const reqQual = await fetch(
+    `${ftcRoot}/${year}/schedule/${eventKey}/qual/hybrid`,
+    {
+      headers: { Authorization: authHeader() },
+    }
+  );
+  const resQual = (await reqQual.json()) as HybridSchedule;
+  const reqPlayoff = await fetch(
+    `${ftcRoot}/${year}/schedule/${eventKey}/playoff/hybrid`,
+    {
+      headers: { Authorization: authHeader() },
+    }
+  );
+  const resPlayoff = (await reqPlayoff.json()) as HybridSchedule;
+  return [...resQual.schedule, ...resPlayoff.schedule];
+}
+
+export async function getEvents(year: number) {
+  const res = await fetch(`${ftcRoot}/${encodeURIComponent(year)}/events`, {
+    headers: {
+      Authorization: authHeader(),
+    },
+  });
+  if (res.status === 401) {
+    throw new Error('Invalid FTC credentials');
+  }
+  const events = (await res.json()) as EventList;
+  return events.events.sort((a, b) => a.dateStart.localeCompare(b.dateEnd));
+}

src/api/index.ts

@@ -0,0 +1,4 @@
+export * from './TBATypes';
+export * from './tbaApi';
+export * from './useApiEvents';
+export * from './useApiMatches';

src/api/types.ts

@@ -0,0 +1,48 @@
+export type Program = 'frc' | 'ftc';
+
+export type ApiEvent = FrcApiEvent | FtcApiEvent;
+
+interface FrcApiEvent {
+  program: 'frc';
+  key: string;
+  name: string;
+  startDate: string;
+  endDate: string;
+  venue: string;
+  city: string;
+  stateProv: string;
+  country: string;
+}
+
+interface FtcApiEvent {
+  program: 'ftc';
+  key: { year: number; code: string };
+  name: string;
+  startDate: string;
+  endDate: string;
+  venue: string;
+  city: string;
+  stateProv: string;
+  country: string;
+}
+
+export interface ApiMatch {
+  id: string;
+  name: string;
+  series?: number;
+  number: number;
+  scheduledTime?: Date;
+  startTime?: Date;
+  resultsTime?: Date;
+  level: MatchLevel;
+  redAlliance: string[];
+  blueAlliance: string[];
+}
+
+export enum MatchLevel {
+  Qualification,
+  EighthFinal,
+  QuarterFinal,
+  SemiFinal,
+  Final,
+}

src/api/useApiEvents.tsx

@@ -0,0 +1,42 @@
+import { UseQueryResult, useQuery } from '@tanstack/react-query';
+import { getEvents as getFtcEvents } from './ftcApi';
+import { getEvents as getTbaEvents } from './tbaApi';
+import { ApiEvent, Program } from './types';
+
+export function useApiEvents(program: Program, year: number): UseQueryResult<ApiEvent[], Error> {
+  const events = useQuery({
+    queryKey: ['events', program, year],
+    retry: false,
+    queryFn: async () => {
+      if (program == 'frc') {
+        const events = await getTbaEvents(year);
+        return events.map((event) => ({
+          program: 'frc',
+          key: event.key,
+          name: event.name,
+          startDate: event.start_date,
+          endDate: event.end_date,
+          venue: event.location_name,
+          city: event.city,
+          stateProv: event.state_prov,
+          country: event.country,
+        } as ApiEvent))
+      } else {
+        const events = await getFtcEvents(year);
+        return events.map((event) => ({
+          program: 'ftc',
+          key: { year: year, code: event.code },
+          name: event.name,
+          startDate: event.dateStart.split('T')[0],
+          endDate: event.dateEnd.split('T')[0],
+          venue: event.venue,
+          city: event.city,
+          stateProv: event.stateprov,
+          country: event.country,
+        } as ApiEvent))
+      }
+    }
+  });
+
+  return events;
+}