remove console.log

apps/client/src/common/api/apiConstants.ts

@@ -9,6 +9,7 @@ export const HTTP_SETTINGS = ['httpSettings'];
 export const APP_SETTINGS = ['appSettings'];
 export const VIEW_SETTINGS = ['viewSettings'];
 export const RUNTIME = ['runtimeStore'];
+export const SHEET_STATE = ['sheetState'];
 
 const location = window.location;
 const socketProtocol = location.protocol === 'https:' ? 'wss' : 'ws';

apps/client/src/common/api/ontimeApi.ts

@@ -245,3 +245,76 @@ export async function getLatestVersion(): Promise<HasUpdate> {
 export async function postNew(initialData: Partial<ProjectData>) {
   return axios.post(`${ontimeURL}/new`, initialData);
 }
+
+/**
+ * @description STEP 1
+ */
+export const uploadSheetClientFile = async (file: File) => {
+  const formData = new FormData();
+  formData.append('userFile', file);
+  const res = await axios
+    .post(`${ontimeURL}/sheet/clientsecrect`, formData, {
+      headers: {
+        'Content-Type': 'multipart/form-data',
+      },
+    })
+    .then((response) => response.data.id);
+  return res;
+};
+
+/**
+ * @description STEP 1 test
+ */
+export const getClientSecrect = async () => {
+  const response = await axios.get(`${ontimeURL}/sheet/clientsecrect`);
+  return response.data;
+};
+
+/**
+ * @description STEP 2
+ */
+export const getSheetsAuthUrl = async () => {
+  const response = await axios.get(`${ontimeURL}/sheet/authentication/url`);
+  return response.data;
+};
+
+/**
+ * @description STEP 2 test
+ */
+export const getAuthentication = async () => {
+  const response = await axios.get(`${ontimeURL}/sheet/authentication`);
+  return response.data;
+};
+
+/**
+ * @description STEP 3
+ * @returns worksheetOptions
+ */
+export const postId = async (id: string) => {
+  const response = await axios.post(`${ontimeURL}/sheet/id`, { id });
+  return response.data;
+};
+
+/**
+ * @description STEP 4
+ */
+export const postWorksheet = async (id: string, worksheet: string) => {
+  const response = await axios.post(`${ontimeURL}/sheet/worksheet`, { id, worksheet });
+  return response.data;
+};
+
+/**
+ * @description STEP 5
+ */
+export const postPreviewSheet = async (id: string, options: ExcelImportMap) => {
+  const response = await axios.post(`${ontimeURL}/sheet/pull`, { id, options });
+  return response.data.data;
+};
+
+/**
+ * @description STEP 5
+ */
+export const postPushSheet = async (id: string, options: ExcelImportMap) => {
+  const response = await axios.post(`${ontimeURL}/sheet-push`, { id, options });
+  return response.data.data;
+};

apps/client/src/features/editors/Editor.tsx

@@ -5,6 +5,7 @@ import ErrorBoundary from '../../common/components/error-boundary/ErrorBoundary'
 import MenuBar from '../menu/MenuBar';
 import AboutModal from '../modals/about-modal/AboutModal';
 import QuickStart from '../modals/quick-start/QuickStart';
+import SheetsModal from '../modals/sheets-modal/SheetsModal';
 import UploadModal from '../modals/upload-modal/UploadModal';
 
 import styles from './Editor.module.scss';
@@ -28,6 +29,7 @@ export default function Editor() {
   } = useDisclosure();
   const { isOpen: isAboutModalOpen, onOpen: onAboutModalOpen, onClose: onAboutModalClose } = useDisclosure();
   const { isOpen: isQuickStartOpen, onOpen: onQuickStartOpen, onClose: onQuickStartClose } = useDisclosure();
+  const { isOpen: isSheetsOpen, onOpen: onSheetsOpen, onClose: onSheetsClose } = useDisclosure();
 
   // Set window title
   useEffect(() => {
@@ -42,6 +44,7 @@ export default function Editor() {
         <IntegrationModal onClose={onIntegrationModalClose} isOpen={isIntegrationModalOpen} />
         <AboutModal onClose={onAboutModalClose} isOpen={isAboutModalOpen} />
         <SettingsModal isOpen={isSettingsOpen} onClose={onSettingsClose} />
+        <SheetsModal onClose={onSheetsClose} isOpen={isSheetsOpen} />
       </ErrorBoundary>
       <div className={styles.mainContainer} data-testid='event-editor'>
         <div id='settings' className={styles.settings}>
@@ -58,6 +61,8 @@ export default function Editor() {
               onAboutOpen={onAboutModalOpen}
               isQuickStartOpen={isQuickStartOpen}
               onQuickStartOpen={onQuickStartOpen}
+              isSheetsOpen={isSheetsOpen}
+              onSheetsOpen={onSheetsOpen}
             />
           </ErrorBoundary>
         </div>

apps/client/src/features/menu/MenuBar.tsx

@@ -1,5 +1,6 @@
 import { memo, useCallback, useEffect, useState } from 'react';
 import { VStack } from '@chakra-ui/react';
+import { IoCalendarOutline } from '@react-icons/all-files/io5/IoCalendarOutline';
 import { IoColorWand } from '@react-icons/all-files/io5/IoColorWand';
 import { IoExtensionPuzzle } from '@react-icons/all-files/io5/IoExtensionPuzzle';
 import { IoExtensionPuzzleOutline } from '@react-icons/all-files/io5/IoExtensionPuzzleOutline';
@@ -31,6 +32,8 @@ interface MenuBarProps {
   onAboutOpen: () => void;
   isQuickStartOpen: boolean;
   onQuickStartOpen: () => void;
+  isSheetsOpen: boolean;
+  onSheetsOpen: () => void;
 }
 
 const buttonStyle = {
@@ -58,6 +61,8 @@ const MenuBar = (props: MenuBarProps) => {
     onAboutOpen,
     isQuickStartOpen,
     onQuickStartOpen,
+    isSheetsOpen,
+    onSheetsOpen,
   } = props;
   const { isElectron, sendToElectron } = useElectronEvent();
 
@@ -174,6 +179,16 @@ const MenuBar = (props: MenuBarProps) => {
       />
 
       <div className={style.gap} />
+      <TooltipActionBtn
+        {...buttonStyle}
+        isDisabled={appMode === AppMode.Run}
+        icon={<IoCalendarOutline />}
+        className={isSheetsOpen ? style.open : ''}
+        clickHandler={onSheetsOpen}
+        tooltip='Sheets'
+        aria-label='Sheets'
+        size='sm'
+      />
       <TooltipActionBtn
         {...buttonStyle}
         isDisabled={appMode === AppMode.Run}

apps/client/src/features/modals/sheets-modal/SheetsModal.tsx

@@ -0,0 +1,460 @@
+import { ChangeEvent, useEffect, useRef, useState } from 'react';
+import {
+  Alert,
+  AlertDescription,
+  AlertIcon,
+  AlertTitle,
+  Button,
+  HStack,
+  Input,
+  Modal,
+  ModalBody,
+  ModalCloseButton,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalOverlay,
+  Select,
+} from '@chakra-ui/react';
+import { useQueryClient } from '@tanstack/react-query';
+import { OntimeRundown, ProjectData, UserFields } from 'ontime-types';
+import { defaultExcelImportMap, ExcelImportMap } from 'ontime-utils';
+
+import { PROJECT_DATA, RUNDOWN, USERFIELDS } from '../../../common/api/apiConstants';
+import { maybeAxiosError } from '../../../common/api/apiUtils';
+import {
+  getAuthentication,
+  getClientSecrect,
+  getSheetsAuthUrl,
+  patchData,
+  postId,
+  postPreviewSheet,
+  postPushSheet,
+  postWorksheet,
+  uploadSheetClientFile,
+} from '../../../common/api/ontimeApi';
+import { projectDataPlaceholder } from '../../../common/models/ProjectData';
+import { userFieldsPlaceholder } from '../../../common/models/UserFields';
+import { openLink } from '../../../common/utils/linkUtils';
+import ModalLink from '../ModalLink';
+import PreviewExcel from '../upload-modal/preview/PreviewExcel';
+import ExcelFileOptions from '../upload-modal/upload-options/ExcelFileOptions';
+
+import Step from './Step';
+
+interface SheetsModalProps {
+  onClose: () => void;
+  isOpen: boolean;
+}
+
+export default function SheetsModal(props: SheetsModalProps) {
+  const { isOpen, onClose } = props;
+
+  const queryClient = useQueryClient();
+
+  const [rundown, setRundown] = useState<OntimeRundown | null>(null);
+  const [userFields, setUserFields] = useState<UserFields | null>(null);
+  const [project, setProject] = useState<ProjectData | null>(null);
+
+  const [id, setSheetId] = useState('');
+  const [worksheet, setWorksheet] = useState('');
+  const [worksheetOptions, setWorksheetOptions] = useState(new Array<string>());
+
+  const [direction, setDirection] = useState('none');
+  const excelFileOptions = useRef<ExcelImportMap>(defaultExcelImportMap);
+
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  const [state, setState] = useState({
+    clientSecret: { complet: false, message: '' },
+    authenticate: { complet: false, message: '' },
+    id: { complet: false, message: '' },
+    worksheet: { complet: false, message: '' },
+    pullPush: { complet: false, message: '' },
+  });
+
+  useEffect(() => {
+    if (isOpen) {
+      setDirection('none');
+      testClientSecrect();
+      if (state.clientSecret.complet) testAuthentication();
+      if (state.authenticate.complet) testSheetId();
+    }
+  }, [isOpen]);
+
+  const handleClose = () => {
+    setRundown(null);
+    setProject(null);
+    setUserFields(null);
+    onClose();
+  };
+
+  //SETP-1 Upload Client ID
+  const handleClick = () => {
+    fileInputRef.current?.click();
+  };
+
+  const handleFile = (event: ChangeEvent<HTMLInputElement>) => {
+    if (!event.target.files?.length) {
+      setState({
+        clientSecret: { complet: false, message: 'Missing file' },
+        authenticate: { complet: false, message: '' },
+        id: { complet: false, message: '' },
+        worksheet: { complet: false, message: '' },
+        pullPush: { complet: false, message: '' },
+      });
+      return;
+    }
+    const selectedFile = event.target.files[0];
+    uploadSheetClientFile(selectedFile)
+      .then(() => {
+        setState({ ...state, clientSecret: { complet: true, message: '' } });
+      })
+      .catch((err) => {
+        const message = maybeAxiosError(err);
+        setState({
+          clientSecret: { complet: false, message },
+          authenticate: { complet: false, message: '' },
+          id: { complet: false, message: '' },
+          worksheet: { complet: false, message: '' },
+          pullPush: { complet: false, message: '' },
+        });
+      });
+  };
+
+  const testClientSecrect = () => {
+    getClientSecrect()
+      .then(() => {
+        setState({ ...state, clientSecret: { complet: true, message: '' } });
+      })
+      .catch((err) => {
+        const message = maybeAxiosError(err);
+        setState({
+          clientSecret: { complet: false, message },
+          authenticate: { complet: false, message: '' },
+          id: { complet: false, message: '' },
+          worksheet: { complet: false, message: '' },
+          pullPush: { complet: false, message: '' },
+        });
+      });
+  };
+
+  //SETP-2 Authenticate
+  const handleAuthenticate = () => {
+    getSheetsAuthUrl()
+      .then((data) => {
+        openLink(data);
+        window.addEventListener('focus', () => testAuthentication(), { once: true });
+      })
+      .catch((err) => {
+        const message = maybeAxiosError(err);
+        setState({
+          ...state,
+          authenticate: { complet: false, message },
+          id: { complet: false, message: '' },
+          worksheet: { complet: false, message: '' },
+          pullPush: { complet: false, message: '' },
+        });
+      });
+  };
+
+  const testAuthentication = () => {
+    getAuthentication()
+      .then(() => {
+        setState({ ...state, authenticate: { complet: true, message: '' } });
+      })
+      .catch((error) => {
+        const message = maybeAxiosError(error);
+        setState({
+          ...state,
+          authenticate: { complet: false, message },
+          id: { complet: false, message: '' },
+          worksheet: { complet: false, message: '' },
+          pullPush: { complet: false, message: '' },
+        });
+      });
+  };
+
+  //SETP-3 set sheet ID
+  const testSheetId = () => {
+    postId(id)
+      .then((data) => {
+        setState({ ...state, id: { complet: true, message: '' } });
+        setWorksheetOptions(data.worksheetOptions);
+      })
+      .catch((err) => {
+        const message = maybeAxiosError(err);
+        setState({
+          ...state,
+          id: { complet: false, message },
+          worksheet: { complet: false, message: '' },
+          pullPush: { complet: false, message: '' },
+        });
+        setWorksheetOptions([]);
+      });
+  };
+
+  //SETP-4 Select Worksheet
+  const testWorksheet = (value: string) => {
+    excelFileOptions.current.worksheet = value;
+    setWorksheet(value);
+    postWorksheet(id, worksheet)
+      .then(() => {
+        setState({ ...state, worksheet: { complet: true, message: '' } });
+      })
+      .catch((err) => {
+        const message = maybeAxiosError(err);
+        setState({ ...state, worksheet: { complet: false, message }, pullPush: { complet: false, message: '' } });
+      });
+  };
+
+  //SETP-5 Upload / Download
+  const updateExcelFileOptions = <T extends keyof ExcelImportMap>(field: T, value: ExcelImportMap[T]) => {
+    if (excelFileOptions.current[field] !== value) {
+      excelFileOptions.current = { ...excelFileOptions.current, [field]: value };
+    }
+  };
+
+  const handlePullData = () => {
+    postPreviewSheet(id, excelFileOptions.current)
+      .then((data) => {
+        setProject(data.project);
+        setRundown(data.rundown);
+        setUserFields(data.userFields);
+      })
+      .catch((error) => {
+        const message = maybeAxiosError(error);
+        setDirection('none');
+        setState({ ...state, pullPush: { complet: false, message } });
+      });
+  };
+
+  const handlePushData = () => {
+    postPushSheet(id, excelFileOptions.current).catch((error) => {
+      const message = maybeAxiosError(error);
+      setDirection('none');
+      setState({ ...state, pullPush: { complet: false, message } });
+    });
+  };
+
+  //GET preview
+  const handleFinalise = async () => {
+    if (rundown && userFields && project) {
+      let doClose = false;
+      try {
+        await patchData({ rundown, userFields, project });
+        queryClient.setQueryData(RUNDOWN, rundown);
+        queryClient.setQueryData(USERFIELDS, userFields);
+        queryClient.setQueryData(PROJECT_DATA, project);
+        await queryClient.invalidateQueries({
+          queryKey: [...RUNDOWN, ...USERFIELDS, ...PROJECT_DATA],
+        });
+        doClose = true;
+      } catch (error) {
+        const message = maybeAxiosError(error);
+        console.error(message);
+      } finally {
+        if (doClose) {
+          handleClose();
+        }
+      }
+    }
+  };
+
+  return (
+    <Modal
+      onClose={handleClose}
+      isOpen={isOpen}
+      closeOnOverlayClick={false}
+      motionPreset='slideInBottom'
+      size='xl'
+      scrollBehavior='inside'
+      preserveScrollBarGap
+      variant='ontime-upload'
+    >
+      <ModalOverlay />
+      <ModalContent>
+        <ModalHeader>Rundown from sheets</ModalHeader>
+        <ModalCloseButton />
+        <ModalBody>
+          <Alert status='info' variant='ontime-on-light-info'>
+            <AlertIcon />
+            <div style={{ display: 'flex', flexDirection: 'column' }}>
+              <AlertTitle>Sync with Google Sheets</AlertTitle>
+              <AlertDescription>
+                <ModalLink href='https://ontime.gitbook.io/v2/features/google-sheet-experimental'>
+                  For more information, see the docs
+                </ModalLink>
+              </AlertDescription>
+            </div>
+          </Alert>
+          {!rundown ? (
+            direction === 'up' ? (
+              <div>{direction}</div>
+            ) : direction === 'down' ? (
+              <ExcelFileOptions optionsRef={excelFileOptions} updateOptions={updateExcelFileOptions} />
+            ) : (
+              <>
+                <Step
+                  title='1 - Upload OAuth 2.0 Client ID'
+                  completed={state.clientSecret.complet}
+                  disabled={false}
+                  error={state.clientSecret.message}
+                >
+                  <Input
+                    ref={fileInputRef}
+                    style={{ display: 'none' }}
+                    type='file'
+                    onChange={handleFile}
+                    accept='.json'
+                    data-testid='file-input'
+                  />
+                  <div style={{ display: 'flex', gap: '1em' }}>
+                    <Button size='sm' variant='ontime-subtle-on-light' onClick={handleClick}>
+                      {state.clientSecret.complet ? 'Reupload Client ID' : 'Upload Client ID'}
+                    </Button>
+                    <Button size='sm' variant='ontime-ghosted-on-light' onClick={testClientSecrect}>
+                      Retry Client ID
+                    </Button>
+                  </div>
+                </Step>
+
+                <Step
+                  title='2 - Authenticate with Google'
+                  completed={state.authenticate.complet}
+                  disabled={!state.clientSecret.complet}
+                  error={state.authenticate.message}
+                >
+                  <div style={{ display: 'flex', gap: '1em' }}>
+                    <Button
+                      size='sm'
+                      variant='ontime-subtle-on-light'
+                      onClick={handleAuthenticate}
+                      isDisabled={!state.clientSecret.complet}
+                    >
+                      Authenticate
+                    </Button>
+                    <Button
+                      size='sm'
+                      variant='ontime-ghosted-on-light'
+                      onClick={testAuthentication}
+                      isDisabled={!state.clientSecret.complet}
+                    >
+                      Retry Connection
+                    </Button>
+                  </div>
+                </Step>
+
+                <Step
+                  title='3 - Add Document ID'
+                  completed={state.id.complet}
+                  disabled={!state.authenticate.complet}
+                  error={state.id.message}
+                >
+                  <HStack>
+                    <Input
+                      type='text'
+                      size='sm'
+                      variant='ontime-filled-on-light'
+                      disabled={!state.authenticate.complet}
+                      value={id}
+                      onChange={(event) => setSheetId(event.target.value)}
+                    />
+                    <Button size='sm' variant='ontime-subtle-on-light' padding='0 2em' onClick={testSheetId}>
+                      Connect
+                    </Button>
+                  </HStack>
+                </Step>
+
+                <Step
+                  title='4 - Select Worksheet to import'
+                  completed={state.worksheet.complet}
+                  disabled={worksheetOptions.length == 0}
+                >
+                  <Select
+                    size='sm'
+                    disabled={worksheetOptions.length == 0}
+                    placeholder='Select a worksheet'
+                    onChange={(event) => testWorksheet(event.target.value)}
+                    value={worksheet}
+                  >
+                    {worksheetOptions.map((value) => (
+                      <option key={value} value={value}>
+                        {value}
+                      </option>
+                    ))}
+                  </Select>
+                </Step>
+
+                <Step title='5 - Upload / Download rundown' completed={false} disabled={!state.worksheet.complet}>
+                  <div style={{ display: 'flex', gap: '1em' }}>
+                    <Button
+                      disabled={!state.worksheet.complet}
+                      variant='ontime-subtle-on-light'
+                      padding='0 2em'
+                      onClick={() => setDirection('up')}
+                    >
+                      Upload
+                    </Button>
+                    <Button
+                      disabled={!state.worksheet.complet}
+                      variant='ontime-subtle-on-light'
+                      padding='0 2em'
+                      onClick={() => setDirection('down')}
+                    >
+                      Download
+                    </Button>
+                  </div>
+                </Step>
+              </>
+            )
+          ) : (
+            <PreviewExcel
+              rundown={rundown ?? []}
+              project={project ?? projectDataPlaceholder}
+              userFields={userFields ?? userFieldsPlaceholder}
+            />
+          )}
+        </ModalBody>
+        <ModalFooter>
+          {rundown ? (
+            <div style={{ display: 'flex', gap: '1em' }}>
+              <Button
+                onClick={() => {
+                  setRundown(null);
+                  setDirection('none');
+                }}
+                variant='ontime-ghost-on-light'
+              >
+                Go Back
+              </Button>
+              <Button variant='ontime-filled' padding='0 2em' onClick={handleFinalise}>
+                Import
+              </Button>
+            </div>
+          ) : direction === 'up' ? (
+            <div style={{ display: 'flex', gap: '1em' }}>
+              <Button onClick={() => setDirection('none')} variant='ontime-ghost-on-light'>
+                Go Back
+              </Button>
+              <Button variant='ontime-filled' padding='0 2em' onClick={handlePushData}>
+                Upload
+              </Button>
+            </div>
+          ) : direction === 'down' ? (
+            <div style={{ display: 'flex', gap: '1em' }}>
+              <Button onClick={() => setDirection('none')} variant='ontime-ghost-on-light'>
+                Go Back
+              </Button>
+              <Button variant='ontime-filled' padding='0 2em' onClick={handlePullData}>
+                Review
+              </Button>
+            </div>
+          ) : (
+            <></>
+          )}
+        </ModalFooter>
+      </ModalContent>
+    </Modal>
+  );
+}

apps/client/src/features/modals/sheets-modal/Step.module.scss

@@ -0,0 +1,41 @@
+@use '../../../theme/ontimeColours' as *;
+
+.wrapper {
+  padding: 0.5rem;
+}
+
+.header {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 1rem;
+  padding-bottom: 1rem;
+}
+
+.step {
+  width: 1.25rem;
+  height: 1.25rem;
+  font-size: 0.75rem;
+  display: grid;
+  place-content: center;
+}
+
+.title {
+  display: inline;
+  color: $gray-500;
+  text-transform: uppercase;
+}
+
+.check {
+  color: $green-700;
+}
+
+.errorIcon {
+  color: $red-700;
+}
+
+.errorText {
+  color: $red-700;
+  font-size: 0.75rem;
+}

apps/client/src/features/modals/sheets-modal/Step.tsx

@@ -0,0 +1,47 @@
+import { PropsWithChildren, useEffect, useMemo, useState } from 'react';
+import { IoCheckmarkCircle } from '@react-icons/all-files/io5/IoCheckmarkCircle';
+import { IoCloseCircle } from '@react-icons/all-files/io5/IoCloseCircle';
+import { IoRadioButtonOffOutline } from '@react-icons/all-files/io5/IoRadioButtonOffOutline';
+
+import style from './Step.module.scss';
+
+interface StepProps {
+  title: string;
+  disabled: boolean;
+  completed: boolean;
+  error?: string;
+}
+
+export default function Step(props: PropsWithChildren<StepProps>) {
+  const { title, disabled, completed, error, children } = props;
+  const [collapsed, setCollapsed] = useState(disabled);
+
+  const handleCollapse = () => setCollapsed((prev) => !prev);
+
+  const icon = useMemo(() => {
+    if (completed) return <IoCheckmarkCircle className={style.step} style={{ color: 'green' }} />;
+    if (error) return <IoCloseCircle className={style.step} style={{ color: 'red' }} />;
+    return <IoRadioButtonOffOutline className={style.step} />;
+  }, [completed, error]);
+
+  useEffect(() => {
+    if (completed) {
+      setCollapsed(true);
+    }
+  }, [completed]);
+
+  return (
+    <div className={style.wrapper}>
+      <div className={style.header} onClick={handleCollapse}>
+        {icon}
+        <span className={style.title}>{title}</span>
+      </div>
+      {!collapsed && (
+        <>
+          {error && <div className={style.errorText}>{error}</div>}
+          {children}
+        </>
+      )}
+    </div>
+  );
+}

apps/server/package.json

@@ -5,6 +5,7 @@
   "version": "2.21.3",
   "exports": "./src/index.js",
   "dependencies": {
+    "@googleapis/sheets": "^5.0.5",
     "body-parser": "^1.20.0",
     "cors": "^2.8.5",
     "dotenv": "^16.0.1",
@@ -13,6 +14,7 @@
     "express-static-gzip": "^2.1.7",
     "express-validator": "^6.14.2",
     "got": "^14.0.0",
+    "google-auth-library": "^9.2.0",
     "lowdb": "^5.0.5",
     "multer": "^1.4.5-lts.1",
     "node-osc": "^9.0.2",

apps/server/src/classes/data-provider/__test__/DataProvider.test.ts

@@ -97,7 +97,6 @@ describe('safeMerge', () => {
       language: 'pt',
     });
   });
-
   it('merges the osc key', () => {
     const newData = {
       osc: {

apps/server/src/controllers/ontimeController.ts

@@ -20,6 +20,8 @@ import { runtimeCacheStore } from '../stores/cachingStore.js';
 import { delayedRundownCacheKey } from '../services/rundown-service/delayedRundown.utils.js';
 import { integrationService } from '../services/integration-service/IntegrationService.js';
 
+import { sheet } from '../utils/sheetsAuth.js';
+
 // Create controller for GET request to '/ontime/poll'
 // Returns data for current state
 export const poll = async (req, res) => {
@@ -455,3 +457,122 @@ export const postNew: RequestHandler = async (req, res) => {
     res.status(400).send({ message: error.toString() });
   }
 };
+
+//SHEET Functions
+/**
+ * @description SETP-1 POST Client Secrect
+ * @returns parsed result
+ */
+export async function uploadSheetClientFile(req, res) {
+  if (!req.file.path) {
+    res.status(400).send({ message: 'File not found' });
+    return;
+  }
+  try {
+    const client = JSON.parse(fs.readFileSync(req.file.path as string, 'utf-8'));
+    await sheet.saveClientSecrets(client);
+    res.status(200).send('OK');
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+  fs.unlink(req.file.path, (err) => {
+    if (err) logger.error(LogOrigin.Server, err.message);
+  });
+}
+
+/**
+ * @description SETP-1 GET Client Secrect status
+ */
+export const getClientSecrect = async (req, res) => {
+  try {
+    const clientSecrectExists = await sheet.testClientSecrect();
+    if (clientSecrectExists) {
+      res.status(200).send();
+    } else {
+      res.status(500).send({ message: 'The Client ID does not exist' });
+    }
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+};
+
+/**
+ * @description SETP-2 GET sheet authentication url
+ */
+export async function getAuthenticationUrl(req, res) {
+  try {
+    const authUrl = await sheet.openAuthServer();
+    res.status(200).send(authUrl);
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+}
+
+/**
+ * @description SETP-2 GET sheet authentication status
+ */
+export const getAuthentication = async (req, res) => {
+  try {
+    await sheet.testAuthentication();
+    res.status(200).send();
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+};
+
+/**
+ * @description SETP-3 POST sheet id
+ * @returns list of worksheets
+ */
+export const postId = async (req, res) => {
+  try {
+    const { id } = req.body;
+    if (id.lenght < 40) {
+      res.status(400).send({ message: 'ID is usualy 44 characters long' });
+    }
+    const state = await sheet.testSheetId(id);
+    res.status(200).send(state);
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+};
+
+/**
+ * @description SETP-4 POST worksheet
+ */
+export const postWorksheet = async (req, res) => {
+  try {
+    const { worksheet, id } = req.body;
+    const state = await sheet.testWorksheet(worksheet, id);
+    res.status(200).send(state);
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+};
+
+/**
+ * @description STEP-5 POST download undown to sheet
+ * @returns parsed result
+ */
+export async function pullSheet(req, res) {
+  try {
+    const { id, options } = req.body;
+    const data = await sheet.pull(id, options);
+    res.status(200).send(data);
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+}
+
+/**
+ * @description STEP-5 POST upload rundown to sheet
+ */
+export async function pushSheet(req, res) {
+  try {
+    const { id, options } = req.body;
+    await sheet.push(id, options);
+    res.status(200).send();
+  } catch (error) {
+    res.status(500).send({ message: error.toString() });
+  }
+}

apps/server/src/controllers/ontimeController.validate.ts

@@ -152,3 +152,32 @@ export const validatePatchProjectFile = [
     next();
   },
 ];
+
+export const validateSheetid = [
+  body('id').exists().isString(),
+  (req, res, next) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
+    next();
+  },
+];
+
+export const validateWorksheet = [
+  body('id').exists().isString(),
+  body('worksheet').exists().isString(),
+  (req, res, next) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
+    next();
+  },
+];
+
+export const validateSheetOptions = [
+  body('id').exists().isString(),
+  // body('options').exists().isObject(), TODO:
+  (req, res, next) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) return res.status(422).json({ errors: errors.array() });
+    next();
+  },
+];

apps/server/src/routes/ontimeRouter.ts

@@ -21,6 +21,13 @@ import {
   postViewSettings,
   previewExcel,
   postHTTP,
+  getAuthenticationUrl,
+  uploadSheetClientFile,
+  pullSheet,
+  pushSheet,
+  postId,
+  getAuthentication,
+  getClientSecrect,
 } from '../controllers/ontimeController.js';
 
 import {
@@ -32,6 +39,9 @@ import {
   viewValidator,
   validateHTTP,
   validateOscSubscription,
+  validateSheetid,
+  validateWorksheet,
+  validateSheetOptions,
 } from '../controllers/ontimeController.validate.js';
 import { projectSanitiser } from '../controllers/projectController.validate.js';
 
@@ -96,3 +106,23 @@ router.post('/http', validateHTTP, postHTTP);
 
 // create route between controller and '/ontime/new' endpoint
 router.post('/new', projectSanitiser, postNew);
+
+//SETP-1
+router.post('/sheet/clientsecrect', uploadFile, uploadSheetClientFile);
+router.get('/sheet/clientsecrect', uploadFile, getClientSecrect);
+
+//SETP-2
+router.get('/sheet/authentication/url', getAuthenticationUrl);
+router.get('/sheet/authentication', getAuthentication);
+
+//STEP-3
+router.post('/sheet/id', validateSheetid, postId);
+
+//STEP-4
+router.post('/sheet/worksheet', validateWorksheet, postId);
+
+//STEP-5 download and generate preview
+router.post('/sheet/pull', validateSheetOptions, pullSheet);
+
+//STEP-5 upload
+router.post('/sheet-push', validateSheetOptions, pushSheet);

apps/server/src/utils/__tests__/sheetUtils.test.ts

@@ -0,0 +1,433 @@
+import { millisToString } from 'ontime-utils';
+import { getA1Notation, cellRequenstFromEvent, cellRequenstFromProjectData } from '../sheetUtils.js';
+import { EndAction, OntimeRundownEntry, ProjectData, SupportedEvent, TimerType } from 'ontime-types';
+
+describe('getA1Notation()', () => {
+  test('A1', () => {
+    expect(getA1Notation(0, 0)).toStrictEqual('A1');
+  });
+  test('E3', () => {
+    expect(getA1Notation(2, 4)).toStrictEqual('E3');
+  });
+  test('AA100', () => {
+    expect(getA1Notation(99, 26)).toStrictEqual('AA100');
+  });
+  test('can not be negative', () => {
+    expect(() => getA1Notation(-1, 1)).toThrowError('Index can not be less than 0');
+  });
+});
+
+describe('cellRequenstFromEvent()', () => {
+  test('string to string', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: false,
+      skip: false,
+      colour: 'red',
+      user0: '',
+      user1: '',
+      user2: '',
+      user3: '',
+      user4: '',
+      user5: '',
+      user6: '',
+      user7: '',
+      user8: '',
+      user9: '',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      type: { row: 1, col: 14 },
+      cue: { row: 1, col: 15 },
+      title: { row: 1, col: 16 },
+      subtitle: { row: 1, col: 17 },
+      presenter: { row: 1, col: 18 },
+      note: { row: 1, col: 19 },
+      timeStart: { row: 1, col: 20 },
+      timeEnd: { row: 1, col: 21 },
+      endAction: { row: 1, col: 22 },
+      timerType: { row: 1, col: 23 },
+      duration: { row: 1, col: 24 },
+      isPublic: { row: 1, col: 25 },
+      skip: { row: 1, col: 26 },
+      colour: { row: 1, col: 27 },
+      user0: { row: 1, col: 28 },
+      user1: { row: 1, col: 29 },
+      user2: { row: 1, col: 30 },
+      user3: { row: 1, col: 31 },
+      user4: { row: 1, col: 32 },
+      user5: { row: 1, col: 33 },
+      user6: { row: 1, col: 34 },
+      user7: { row: 1, col: 35 },
+      user8: { row: 1, col: 36 },
+      user9: { row: 1, col: 37 },
+      revision: { row: 1, col: 38 },
+      id: { row: 1, col: 39 },
+    };
+    const result = cellRequenstFromEvent(event, 1, 1234, metadata);
+    expect(result.updateCells.rows[0].values[5].userEnteredValue.stringValue).toStrictEqual(event.note);
+  });
+
+  test('numer to timer', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: false,
+      skip: false,
+      colour: 'red',
+      user0: '',
+      user1: '',
+      user2: '',
+      user3: '',
+      user4: '',
+      user5: '',
+      user6: '',
+      user7: '',
+      user8: '',
+      user9: '',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      type: { row: 1, col: 14 },
+      cue: { row: 1, col: 15 },
+      title: { row: 1, col: 16 },
+      subtitle: { row: 1, col: 17 },
+      presenter: { row: 1, col: 18 },
+      note: { row: 1, col: 19 },
+      timeStart: { row: 1, col: 20 },
+      timeEnd: { row: 1, col: 21 },
+      endAction: { row: 1, col: 22 },
+      timerType: { row: 1, col: 23 },
+      duration: { row: 1, col: 24 },
+      isPublic: { row: 1, col: 25 },
+      skip: { row: 1, col: 26 },
+      colour: { row: 1, col: 27 },
+      user0: { row: 1, col: 28 },
+      user1: { row: 1, col: 29 },
+      user2: { row: 1, col: 30 },
+      user3: { row: 1, col: 31 },
+      user4: { row: 1, col: 32 },
+      user5: { row: 1, col: 33 },
+      user6: { row: 1, col: 34 },
+      user7: { row: 1, col: 35 },
+      user8: { row: 1, col: 36 },
+      user9: { row: 1, col: 37 },
+      revision: { row: 1, col: 38 },
+      id: { row: 1, col: 39 },
+    };
+    const result = cellRequenstFromEvent(event, 1, 1234, metadata).updateCells.rows[0].values[10].userEnteredValue
+      .stringValue;
+    expect(result).toStrictEqual(millisToString(event.duration));
+  });
+
+  test('boolean to x', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: true,
+      skip: false,
+      colour: 'red',
+      user0: 'u',
+      user1: 'u',
+      user2: 'u',
+      user3: 'u',
+      user4: 'u',
+      user5: 'u',
+      user6: 'u',
+      user7: 'u',
+      user8: 'u',
+      user9: 'u',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      type: { row: 1, col: 14 },
+      cue: { row: 1, col: 15 },
+      title: { row: 1, col: 16 },
+      subtitle: { row: 1, col: 17 },
+      presenter: { row: 1, col: 18 },
+      note: { row: 1, col: 19 },
+      timeStart: { row: 1, col: 20 },
+      timeEnd: { row: 1, col: 21 },
+      endAction: { row: 1, col: 22 },
+      timerType: { row: 1, col: 23 },
+      duration: { row: 1, col: 24 },
+      isPublic: { row: 1, col: 25 },
+      skip: { row: 1, col: 26 },
+      colour: { row: 1, col: 27 },
+      user0: { row: 1, col: 28 },
+      user1: { row: 1, col: 29 },
+      user2: { row: 1, col: 30 },
+      user3: { row: 1, col: 31 },
+      user4: { row: 1, col: 32 },
+      user5: { row: 1, col: 33 },
+      user6: { row: 1, col: 34 },
+      user7: { row: 1, col: 35 },
+      user8: { row: 1, col: 36 },
+      user9: { row: 1, col: 37 },
+      revision: { row: 1, col: 38 },
+      id: { row: 1, col: 39 },
+    };
+    const result = cellRequenstFromEvent(event, 1, 1234, metadata);
+    expect(result.updateCells.rows[0].values[11].userEnteredValue.stringValue).toStrictEqual('x');
+    expect(result.updateCells.rows[0].values[12].userEnteredValue.stringValue).toStrictEqual('');
+  });
+
+  test('spacing in metadata', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: true,
+      skip: false,
+      colour: 'red',
+      user0: 'u',
+      user1: 'u',
+      user2: 'u',
+      user3: 'u',
+      user4: 'u',
+      user5: 'u',
+      user6: 'u',
+      user7: 'u',
+      user8: 'u',
+      user9: 'u',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      cue: { row: 1, col: 0 },
+      title: { row: 1, col: 6 },
+      subtitle: { row: 1, col: 10 },
+      user0: { row: 1, col: 16 },
+    };
+    const result = cellRequenstFromEvent(event, 1, 1234, metadata);
+    expect(result.updateCells.rows[0].values[0].userEnteredValue.stringValue).toStrictEqual(event.cue);
+    expect(result.updateCells.rows[0].values[6].userEnteredValue.stringValue).toStrictEqual(event.title);
+    expect(result.updateCells.rows[0].values[10].userEnteredValue.stringValue).toStrictEqual(event.subtitle);
+  });
+
+  test('metadata offset from zero', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: true,
+      skip: false,
+      colour: 'red',
+      user0: 'u',
+      user1: 'u',
+      user2: 'u',
+      user3: 'u',
+      user4: 'u',
+      user5: 'u',
+      user6: 'u',
+      user7: 'u',
+      user8: 'u',
+      user9: 'u',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      cue: { row: 1, col: 5 },
+      title: { row: 1, col: 6 },
+      subtitle: { row: 1, col: 10 },
+      user0: { row: 1, col: 16 },
+    };
+    const result = cellRequenstFromEvent(event, 1, 1234, metadata);
+    expect(result.updateCells.rows[0].values[0].userEnteredValue.stringValue).toStrictEqual(event.cue);
+    expect(result.updateCells.rows[0].values[1].userEnteredValue.stringValue).toStrictEqual(event.title);
+    expect(result.updateCells.rows[0].values[5].userEnteredValue.stringValue).toStrictEqual(event.subtitle);
+  });
+
+  test('sheet setup', () => {
+    const event: OntimeRundownEntry = {
+      type: SupportedEvent.Event,
+      cue: '1',
+      title: 'Fancy',
+      subtitle: 'Wow',
+      presenter: 'Mr. Presenter',
+      note: 'Blue button on the right',
+      timeStart: 46800000,
+      timeEnd: 57600000,
+      endAction: EndAction.None,
+      timerType: TimerType.CountDown,
+      duration: 10800000,
+      isPublic: true,
+      skip: false,
+      colour: 'red',
+      user0: 'u',
+      user1: 'u',
+      user2: 'u',
+      user3: 'u',
+      user4: 'u',
+      user5: 'u',
+      user6: 'u',
+      user7: 'u',
+      user8: 'u',
+      user9: 'u',
+      revision: 0,
+      id: '1358',
+    };
+    const metadata = {
+      cue: { row: 10, col: 5 },
+      title: { row: 10, col: 6 },
+      subtitle: { row: 1, col: 10 },
+      user0: { row: 10, col: 16 },
+    };
+    const result1 = cellRequenstFromEvent(event, 1, 1234, metadata);
+    expect(result1.updateCells.start.sheetId).toStrictEqual(1234);
+    const result2 = cellRequenstFromEvent(event, 10, 1234, metadata);
+    expect(result2.updateCells.start.rowIndex).toStrictEqual(21);
+    expect(result2.updateCells.start.columnIndex).toStrictEqual(5);
+    expect(result2.updateCells.fields).toStrictEqual('userEnteredValue');
+  });
+});
+
+describe('cellRequenstFromProjectData()', () => {
+  test('string to string', () => {
+    const projectData: ProjectData = {
+      title: 'Title',
+      description: 'Description',
+      publicUrl: 'Public Url',
+      backstageUrl: 'Backstage Url',
+      publicInfo: 'Public Info',
+      backstageInfo: 'Backstage Info',
+    };
+    const metadata = {
+      title: { row: 0, col: 1 },
+      description: { row: 1, col: 1 },
+      publicUrl: { row: 2, col: 1 },
+      backstageUrl: { row: 3, col: 1 },
+      publicInfo: { row: 4, col: 1 },
+      backstageInfo: { row: 5, col: 1 },
+    };
+    const result = cellRequenstFromProjectData(projectData, 1234, metadata);
+    expect(result.updateCells.rows[0].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.title);
+    expect(result.updateCells.rows[1].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.description);
+    expect(result.updateCells.rows[2].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicUrl);
+    expect(result.updateCells.rows[3].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageUrl);
+    expect(result.updateCells.rows[4].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicInfo);
+    expect(result.updateCells.rows[5].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageInfo);
+  });
+
+  test('metadata offset from zero', () => {
+    const projectData: ProjectData = {
+      title: 'Title',
+      description: 'Description',
+      publicUrl: 'Public Url',
+      backstageUrl: 'Backstage Url',
+      publicInfo: 'Public Info',
+      backstageInfo: 'Backstage Info',
+    };
+    const metadata = {
+      title: { row: 5, col: 10 },
+      description: { row: 6, col: 10 },
+      publicUrl: { row: 7, col: 10 },
+      backstageUrl: { row: 9, col: 10 },
+      publicInfo: { row: 10, col: 10 },
+      backstageInfo: { row: 11, col: 10 },
+    };
+    const result = cellRequenstFromProjectData(projectData, 1234, metadata);
+    expect(result.updateCells.rows[0].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.title);
+    expect(result.updateCells.rows[1].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.description);
+    expect(result.updateCells.rows[2].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicUrl);
+    expect(result.updateCells.rows[4].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageUrl);
+    expect(result.updateCells.rows[5].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicInfo);
+    expect(result.updateCells.rows[6].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageInfo);
+  });
+
+  test('spacing in metadata', () => {
+    const projectData: ProjectData = {
+      title: 'Title',
+      description: 'Description',
+      publicUrl: 'Public Url',
+      backstageUrl: 'Backstage Url',
+      publicInfo: 'Public Info',
+      backstageInfo: 'Backstage Info',
+    };
+    const metadata = {
+      title: { row: 0, col: 1 },
+      description: { row: 1, col: 1 },
+      publicUrl: { row: 2, col: 1 },
+      backstageUrl: { row: 9, col: 1 },
+      publicInfo: { row: 15, col: 1 },
+      backstageInfo: { row: 50, col: 1 },
+    };
+    const result = cellRequenstFromProjectData(projectData, 1234, metadata);
+    expect(result.updateCells.rows[0].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.title);
+    expect(result.updateCells.rows[1].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.description);
+    expect(result.updateCells.rows[2].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicUrl);
+    expect(result.updateCells.rows[9].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageUrl);
+    expect(result.updateCells.rows[15].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.publicInfo);
+    expect(result.updateCells.rows[50].values[0].userEnteredValue.stringValue).toStrictEqual(projectData.backstageInfo);
+  });
+
+  test('sheet setup', () => {
+    const projectData: ProjectData = {
+      title: 'Title',
+      description: 'Description',
+      publicUrl: 'Public Url',
+      backstageUrl: 'Backstage Url',
+      publicInfo: 'Public Info',
+      backstageInfo: 'Backstage Info',
+    };
+    const metadata = {
+      title: { row: 0, col: 10 },
+      description: { row: 1, col: 10 },
+      publicUrl: { row: 2, col: 10 },
+      backstageUrl: { row: 3, col: 10 },
+      publicInfo: { row: 4, col: 10 },
+      backstageInfo: { row: 5, col: 10 },
+    };
+    const result = cellRequenstFromProjectData(projectData, 1234, metadata);
+    expect(result.updateCells.start.rowIndex).toStrictEqual(0);
+    expect(result.updateCells.start.columnIndex).toStrictEqual(11);
+    expect(result.updateCells.fields).toStrictEqual('userEnteredValue');
+  });
+});

apps/server/src/utils/parser.ts

@@ -36,6 +36,7 @@ import {
   parseViewSettings,
 } from './parserFunctions.js';
 import { parseExcelDate } from './time.js';
+import { coerceBoolean } from './coerceType.js';
 
 export const EXCEL_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
 export const JSON_MIME = 'application/json';
@@ -47,6 +48,8 @@ export const JSON_MIME = 'application/json';
  * @returns {object} - parsed object
  */
 export const parseExcel = (excelData: unknown[][], options?: Partial<ExcelImportMap>) => {
+  const projectMetadata = {};
+  const rundownMetadata = {};
   const importMap: ExcelImportMap = { ...defaultExcelImportMap, ...options };
   const projectData: Partial<ProjectData> = {
     title: '',
@@ -103,140 +106,228 @@ export const parseExcel = (excelData: unknown[][], options?: Partial<ExcelImport
   let user8Index: number | null = null;
   let user9Index: number | null = null;
 
-  excelData
-    .filter((e) => e.length > 0)
-    .forEach((row) => {
-      // these fields contain the data to its right
-      let projectTitleNext = false;
-      let projectDescriptionNext = false;
-      let publicUrlNext = false;
-      let publicInfoNext = false;
-      let backstageUrlNext = false;
-      let backstageInfoNext = false;
+  excelData.forEach((row, rowIndex) => {
+    if (row.length === 0) {
+      return;
+    }
+    // these fields contain the data to its right
+    let projectTitleNext = false;
+    let projectDescriptionNext = false;
+    let publicUrlNext = false;
+    let publicInfoNext = false;
+    let backstageUrlNext = false;
+    let backstageInfoNext = false;
 
-      const event: Partial<OntimeEvent> = {};
-      const handlers = {
-        [importMap.projectName]: () => (projectTitleNext = true),
-        [importMap.projectDescription]: () => (projectDescriptionNext = true),
-        [importMap.publicUrl]: () => (publicUrlNext = true),
-        [importMap.publicInfo]: () => (publicInfoNext = true),
-        [importMap.backstageUrl]: () => (backstageUrlNext = true),
-        [importMap.backstageInfo]: () => (backstageInfoNext = true),
+    const event: Partial<OntimeEvent> = {};
+    const handlers = {
+      [importMap.projectName]: (row: number, col: number) => {
+        projectTitleNext = true;
+        projectMetadata['title'] = { row, col };
+      },
+      [importMap.projectDescription]: (row: number, col: number) => {
+        projectDescriptionNext = true;
+        projectMetadata['description'] = { row, col };
+      },
+      [importMap.publicUrl]: (row: number, col: number) => {
+        publicUrlNext = true;
+        projectMetadata['publicUrl'] = { row, col };
+      },
+      [importMap.publicInfo]: (row: number, col: number) => {
+        publicInfoNext = true;
+        projectMetadata['publicInfo'] = { row, col };
+      },
+      [importMap.backstageUrl]: (row: number, col: number) => {
+        backstageUrlNext = true;
+        projectMetadata['backstageUrl'] = { row, col };
+      },
+      [importMap.backstageInfo]: (row: number, col: number) => {
+        backstageInfoNext = true;
+        projectMetadata['backstageInfo'] = { row, col };
+      },
 
-        [importMap.timeStart]: (index: number) => (timeStartIndex = index),
-        [importMap.timeEnd]: (index: number) => (timeEndIndex = index),
-        [importMap.duration]: (index: number) => (durationIndex = index),
+      [importMap.timeStart]: (row: number, col: number) => {
+        timeStartIndex = col;
+        rundownMetadata['timeStart'] = { row, col };
+      },
+      [importMap.timeEnd]: (row: number, col: number) => {
+        timeEndIndex = col;
+        rundownMetadata['timeEnd'] = { row, col };
+      },
+      [importMap.duration]: (row: number, col: number) => {
+        durationIndex = col;
+        rundownMetadata['duration'] = { row, col };
+      },
 
-        [importMap.cue]: (index: number) => (cueIndex = index),
-        [importMap.title]: (index: number) => (titleIndex = index),
-        [importMap.presenter]: (index: number) => (presenterIndex = index),
-        [importMap.subtitle]: (index: number) => (subtitleIndex = index),
-        [importMap.isPublic]: (index: number) => (isPublicIndex = index),
-        [importMap.skip]: (index: number) => (skipIndex = index),
-        [importMap.note]: (index: number) => (notesIndex = index),
-        [importMap.colour]: (index: number) => (colourIndex = index),
+      [importMap.cue]: (row: number, col: number) => {
+        cueIndex = col;
+        rundownMetadata['cue'] = { row, col };
+      },
+      [importMap.title]: (row: number, col: number) => {
+        titleIndex = col;
+        rundownMetadata['title'] = { row, col };
+      },
+      [importMap.presenter]: (row: number, col: number) => {
+        presenterIndex = col;
+        rundownMetadata['presenter'] = { row, col };
+      },
+      [importMap.subtitle]: (row: number, col: number) => {
+        subtitleIndex = col;
+        rundownMetadata['subtitle'] = { row, col };
+      },
+      [importMap.isPublic]: (row: number, col: number) => {
+        isPublicIndex = col;
+        rundownMetadata['isPublic'] = { row, col };
+      },
+      [importMap.skip]: (row: number, col: number) => {
+        skipIndex = col;
+        rundownMetadata['skip'] = { row, col };
+      },
+      [importMap.note]: (row: number, col: number) => {
+        notesIndex = col;
+        rundownMetadata['note'] = { row, col };
+      },
+      [importMap.colour]: (row: number, col: number) => {
+        colourIndex = col;
+        rundownMetadata['colour'] = { row, col };
+      },
 
-        [importMap.endAction]: (index: number) => (endActionIndex = index),
-        [importMap.timerType]: (index: number) => (timerTypeIndex = index),
+      [importMap.endAction]: (row: number, col: number) => {
+        endActionIndex = col;
+        rundownMetadata['endAction'] = { row, col };
+      },
+      [importMap.timerType]: (row: number, col: number) => {
+        timerTypeIndex = col;
+        rundownMetadata['timerType'] = { row, col };
+      },
 
-        [importMap.user0]: (index: number) => (user0Index = index),
-        [importMap.user1]: (index: number) => (user1Index = index),
-        [importMap.user2]: (index: number) => (user2Index = index),
-        [importMap.user3]: (index: number) => (user3Index = index),
-        [importMap.user4]: (index: number) => (user4Index = index),
-        [importMap.user5]: (index: number) => (user5Index = index),
-        [importMap.user6]: (index: number) => (user6Index = index),
-        [importMap.user7]: (index: number) => (user7Index = index),
-        [importMap.user8]: (index: number) => (user8Index = index),
-        [importMap.user9]: (index: number) => (user9Index = index),
-      } as const;
+      [importMap.user0]: (row: number, col: number) => {
+        user0Index = col;
+        rundownMetadata['user0'] = { row, col };
+      },
+      [importMap.user1]: (row: number, col: number) => {
+        user1Index = col;
+        rundownMetadata['user1'] = { row, col };
+      },
+      [importMap.user2]: (row: number, col: number) => {
+        user2Index = col;
+        rundownMetadata['user2'] = { row, col };
+      },
+      [importMap.user3]: (row: number, col: number) => {
+        user3Index = col;
+        rundownMetadata['user3'] = { row, col };
+      },
+      [importMap.user4]: (row: number, col: number) => {
+        user4Index = col;
+        rundownMetadata['user4'] = { row, col };
+      },
+      [importMap.user5]: (row: number, col: number) => {
+        user5Index = col;
+        rundownMetadata['user5'] = { row, col };
+      },
+      [importMap.user6]: (row: number, col: number) => {
+        user6Index = col;
+        rundownMetadata['user6'] = { row, col };
+      },
+      [importMap.user7]: (row: number, col: number) => {
+        user7Index = col;
+        rundownMetadata['user7'] = { row, col };
+      },
+      [importMap.user8]: (row: number, col: number) => {
+        user8Index = col;
+        rundownMetadata['user8'] = { row, col };
+      },
+      [importMap.user9]: (row: number, col: number) => {
+        user9Index = col;
+        rundownMetadata['user9'] = { row, col };
+      },
+    } as const;
 
-      row.forEach((column, j) => {
-        // 1. we check if we have set a flag for a known field
-        if (projectTitleNext) {
-          projectData.title = makeString(column, '');
-          projectTitleNext = false;
-        } else if (projectDescriptionNext) {
-          projectData.description = makeString(column, '');
-          projectDescriptionNext = false;
-        } else if (publicUrlNext) {
-          projectData.publicUrl = makeString(column, '');
-          publicUrlNext = false;
-        } else if (publicInfoNext) {
-          projectData.publicInfo = makeString(column, '');
-          publicInfoNext = false;
-        } else if (backstageUrlNext) {
-          projectData.backstageUrl = makeString(column, '');
-          backstageUrlNext = false;
-        } else if (backstageInfoNext) {
-          projectData.backstageInfo = makeString(column, '');
-          backstageInfoNext = false;
-        } else if (j === timeStartIndex) {
-          event.timeStart = parseExcelDate(column);
-        } else if (j === timeEndIndex) {
-          event.timeEnd = parseExcelDate(column);
-        } else if (j === durationIndex) {
-          event.duration = parseExcelDate(column);
-        } else if (j === titleIndex) {
-          event.title = makeString(column, '');
-        } else if (j === cueIndex) {
-          event.cue = makeString(column, '');
-        } else if (j === presenterIndex) {
-          event.presenter = makeString(column, '');
-        } else if (j === subtitleIndex) {
-          event.subtitle = makeString(column, '');
-        } else if (j === isPublicIndex) {
-          event.isPublic = Boolean(column);
-        } else if (j === skipIndex) {
-          event.skip = Boolean(column);
-        } else if (j === notesIndex) {
-          event.note = makeString(column, '');
-        } else if (j === endActionIndex) {
-          event.endAction = validateEndAction(column);
-        } else if (j === timerTypeIndex) {
-          event.timerType = validateTimerType(column);
-        } else if (j === colourIndex) {
-          event.colour = makeString(column, '');
-        } else if (j === user0Index) {
-          event.user0 = makeString(column, '');
-        } else if (j === user1Index) {
-          event.user1 = makeString(column, '');
-        } else if (j === user2Index) {
-          event.user2 = makeString(column, '');
-        } else if (j === user3Index) {
-          event.user3 = makeString(column, '');
-        } else if (j === user4Index) {
-          event.user4 = makeString(column, '');
-        } else if (j === user5Index) {
-          event.user5 = makeString(column, '');
-        } else if (j === user6Index) {
-          event.user6 = makeString(column, '');
-        } else if (j === user7Index) {
-          event.user7 = makeString(column, '');
-        } else if (j === user8Index) {
-          event.user8 = makeString(column, '');
-        } else if (j === user9Index) {
-          event.user9 = makeString(column, '');
-        } else {
-          // 2. if there is no flag, lets see if we know the field type
-          if (typeof column === 'string') {
-            const col = column.toLowerCase();
+    row.forEach((column, j) => {
+      // 1. we check if we have set a flag for a known field
+      if (projectTitleNext) {
+        projectData.title = makeString(column, '');
+        projectTitleNext = false;
+      } else if (projectDescriptionNext) {
+        projectData.description = makeString(column, '');
+        projectDescriptionNext = false;
+      } else if (publicUrlNext) {
+        projectData.publicUrl = makeString(column, '');
+        publicUrlNext = false;
+      } else if (publicInfoNext) {
+        projectData.publicInfo = makeString(column, '');
+        publicInfoNext = false;
+      } else if (backstageUrlNext) {
+        projectData.backstageUrl = makeString(column, '');
+        backstageUrlNext = false;
+      } else if (backstageInfoNext) {
+        projectData.backstageInfo = makeString(column, '');
+        backstageInfoNext = false;
+      } else if (j === timeStartIndex) {
+        event.timeStart = parseExcelDate(column);
+      } else if (j === timeEndIndex) {
+        event.timeEnd = parseExcelDate(column);
+      } else if (j === durationIndex) {
+        event.duration = parseExcelDate(column);
+      } else if (j === titleIndex) {
+        event.title = makeString(column, '');
+      } else if (j === cueIndex) {
+        event.cue = makeString(column, '');
+      } else if (j === presenterIndex) {
+        event.presenter = makeString(column, '');
+      } else if (j === subtitleIndex) {
+        event.subtitle = makeString(column, '');
+      } else if (j === isPublicIndex) {
+        event.isPublic = column == 'x' ? true : coerceBoolean(column);
+      } else if (j === skipIndex) {
+        event.skip = column == 'x' ? true : coerceBoolean(column);
+      } else if (j === notesIndex) {
+        event.note = makeString(column, '');
+      } else if (j === endActionIndex) {
+        event.endAction = validateEndAction(column);
+      } else if (j === timerTypeIndex) {
+        event.timerType = validateTimerType(column);
+      } else if (j === colourIndex) {
+        event.colour = makeString(column, '');
+      } else if (j === user0Index) {
+        event.user0 = makeString(column, '');
+      } else if (j === user1Index) {
+        event.user1 = makeString(column, '');
+      } else if (j === user2Index) {
+        event.user2 = makeString(column, '');
+      } else if (j === user3Index) {
+        event.user3 = makeString(column, '');
+      } else if (j === user4Index) {
+        event.user4 = makeString(column, '');
+      } else if (j === user5Index) {
+        event.user5 = makeString(column, '');
+      } else if (j === user6Index) {
+        event.user6 = makeString(column, '');
+      } else if (j === user7Index) {
+        event.user7 = makeString(column, '');
+      } else if (j === user8Index) {
+        event.user8 = makeString(column, '');
+      } else if (j === user9Index) {
+        event.user9 = makeString(column, '');
+      } else {
+        // 2. if there is no flag, lets see if we know the field type
+        if (typeof column === 'string') {
+          const col = column.toLowerCase();
 
-            if (handlers[col]) {
-              handlers[col](j);
-            }
-            // else. we don't know how to handle this column
-            // just ignore it
+          if (handlers[col]) {
+            handlers[col](rowIndex, j);
           }
+          // else. we don't know how to handle this column
+          // just ignore it
         }
-      });
-
-      if (Object.keys(event).length > 0) {
-        // if any data was found, push to array
-        rundown.push({ ...event, type: SupportedEvent.Event } as OntimeEvent);
       }
     });
 
+    if (Object.keys(event).length > 0) {
+      // if any data was found, push to array
+      rundown.push({ ...event, type: SupportedEvent.Event } as OntimeEvent);
+    }
+  });
+
   return {
     rundown,
     project: projectData,
@@ -245,6 +336,8 @@ export const parseExcel = (excelData: unknown[][], options?: Partial<ExcelImport
       version: '2.0.0',
     },
     userFields: customUserFields,
+    projectMetadata,
+    rundownMetadata,
   };
 };
 

apps/server/src/utils/parserFunctions.ts

@@ -331,4 +331,4 @@ export const parseUserFields = (data): UserFields => {
     }
   }
   return { ...newUserFields };
-};
+};

apps/server/src/utils/sheetUtils.ts

@@ -0,0 +1,165 @@
+import { sheets_v4 } from '@googleapis/sheets';
+import { millisToString } from 'ontime-utils';
+import { OntimeRundownEntry, ProjectData, isOntimeEvent } from 'ontime-types';
+
+/**
+ *
+ * @param {number} row - The row number of the cell reference. Row 1 is row number 0.
+ * @param {number} column - The column number of the cell reference. A is column number 0.
+ * @returns {string} - Returns a cell reference as a string using A1 Notation
+ * @author https://www.labnol.org/convert-column-a1-notation-210601
+ * @example
+ *
+ *   getA1Notation(2, 4) returns "E3"
+ *   getA1Notation(99, 26) returns "AA100"
+ *
+ */
+export function getA1Notation(row: number, column: number): string {
+  if (row < 0 || column < 0) {
+    throw new Error('Index can not be less than 0');
+  }
+  const a1Notation = [`${row + 1}`];
+  const totalAlphabets = 'Z'.charCodeAt(0) - 'A'.charCodeAt(0) + 1;
+  let block = column;
+  while (block >= 0) {
+    a1Notation.unshift(String.fromCharCode((block % totalAlphabets) + 'A'.charCodeAt(0)));
+    block = Math.floor(block / totalAlphabets) - 1;
+  }
+  return a1Notation.join('');
+}
+
+/**
+ * @description - creates updateCells request from ontime event
+ * @param {OntimeRundownEntry} event
+ * @param {number} index - index of the event
+ * @param {number} worksheetId
+ * @param {any} metadata - object with all the cell positions of the title of each attribute
+ * @returns {sheets_v4.Schema} - list of update requests
+ */
+export function cellRequenstFromEvent(
+  event: OntimeRundownEntry,
+  index: number,
+  worksheetId: number,
+  metadata,
+): sheets_v4.Schema$Request {
+  const returnRows: sheets_v4.Schema$CellData[] = [];
+  const tmp = Object.entries(metadata)
+    .filter(([_, value]) => value !== undefined)
+    .sort(([_a, a], [_b, b]) => a['col'] - b['col']) as [string, { col: number; row: number }][];
+
+  const titleCol = tmp[0][1].col;
+
+  for (const [index, e] of tmp.entries()) {
+    if (index != 0) {
+      const prevCol = tmp[index - 1][1].col;
+      const thisCol = e[1].col;
+      const diff = thisCol - prevCol;
+      if (diff > 1) {
+        const fillArr = new Array<(typeof tmp)[0]>(1).fill(['blank', { row: e[1].row, col: prevCol + 1 }]);
+        tmp.splice(index, 0, ...fillArr);
+      }
+    }
+  }
+
+  tmp.forEach(([key, _]) => {
+    if (isOntimeEvent(event)) {
+      if (key === 'blank') {
+        returnRows.push({});
+      } else if (key === 'colour') {
+        returnRows.push({
+          userEnteredValue: { stringValue: event.colour },
+        });
+      } else if (typeof event[key] === 'number') {
+        returnRows.push({
+          userEnteredValue: { stringValue: millisToString(event[key], true) },
+        });
+      } else if (typeof event[key] === 'string') {
+        returnRows.push({
+          userEnteredValue: { stringValue: event[key] },
+        });
+      } else if (typeof event[key] === 'boolean') {
+        returnRows.push({
+          userEnteredValue: { stringValue: event[key] ? 'x' : '' },
+        });
+      } else {
+        returnRows.push({});
+      }
+    }
+  });
+  return {
+    updateCells: {
+      start: {
+        sheetId: worksheetId,
+        rowIndex: index + tmp[0][1]['row'] + 1,
+        columnIndex: titleCol,
+      },
+      fields: 'userEnteredValue',
+      rows: [
+        {
+          values: returnRows,
+        },
+      ],
+    },
+  };
+}
+
+/**
+ * @description - creates updateCells request from ontime event
+ * @param {ProjectData} projectData
+ * @param {number} worksheetId
+ * @param {any} metadata - object with all the cell positions of the title of each attribute
+ * @returns {sheets_v4.Schema} - list of update requests
+ */
+export function cellRequenstFromProjectData(
+  projectData: ProjectData,
+  worksheetId: number,
+  metadata,
+): sheets_v4.Schema$Request {
+  const returnRows: sheets_v4.Schema$RowData[] = [];
+  const tmp = Object.entries(metadata)
+    .filter(([_, value]) => value !== undefined)
+    .sort(([_a, a], [_b, b]) => a['col'] - b['col']) as [string, { col: number; row: number }][];
+
+  const minRow = Object.values(metadata).reduce(
+    (accumulator: number, val) => Math.min(accumulator, val['row']),
+    Number.MAX_VALUE,
+  ) as number;
+  const minCol = tmp[0][1].col + 1;
+
+  for (const [index, e] of tmp.entries()) {
+    if (index != 0) {
+      const prevRow = tmp[index - 1][1].row;
+      const thisRow = e[1].row;
+      const diff = thisRow - prevRow;
+      if (diff > 1) {
+        const fillArr = new Array<(typeof tmp)[0]>(1).fill(['blank', { row: prevRow + 1, col: e[1].col }]);
+        tmp.splice(index, 0, ...fillArr);
+      }
+    }
+  }
+  tmp.forEach(([key, _]) => {
+    if (key == 'blank') {
+      returnRows.push({});
+    } else {
+      returnRows.push({
+        values: [
+          {
+            userEnteredValue: { stringValue: projectData[key] },
+          },
+        ],
+      });
+    }
+  });
+
+  return {
+    updateCells: {
+      start: {
+        sheetId: worksheetId,
+        rowIndex: minRow,
+        columnIndex: minCol,
+      },
+      fields: 'userEnteredValue',
+      rows: returnRows,
+    },
+  };
+}

apps/server/src/utils/sheetsAuth.ts

@@ -0,0 +1,382 @@
+import { sheets, sheets_v4 } from '@googleapis/sheets';
+import { writeFile } from 'fs/promises';
+import { readFileSync } from 'fs';
+import { OAuth2Client } from 'google-auth-library';
+import http from 'http';
+import { DatabaseModel, LogOrigin } from 'ontime-types';
+import { join } from 'path';
+import { URL } from 'url';
+import { logger } from '../classes/Logger.js';
+import { DataProvider } from '../classes/data-provider/DataProvider.js';
+import { getAppDataPath } from '../setup.js';
+import { ensureDirectory } from './fileManagement.js';
+import { cellRequenstFromEvent, cellRequenstFromProjectData, getA1Notation } from './sheetUtils.js';
+import { parseExcel } from './parser.js';
+import { parseProject, parseRundown, parseUserFields } from './parserFunctions.js';
+import { ExcelImportMap } from 'ontime-utils';
+
+type ResponseOK = {
+  data: Partial<DatabaseModel>;
+};
+
+class Sheet {
+  private static client: null | OAuth2Client = null;
+  private readonly scope = 'https://www.googleapis.com/auth/spreadsheets';
+  private readonly sheetsFolder: string;
+  private readonly clientSecretFile: string;
+  private static clientSecret = null;
+  private static authUrl: null | string = null;
+  private authServerTimeout;
+
+  private readonly requiredClientKeys = [
+    'client_id',
+    'project_id',
+    'auth_uri',
+    'token_uri',
+    'auth_provider_x509_cert_url',
+    'client_secret',
+    'redirect_uris',
+  ];
+
+  constructor() {
+    const appDataPath = getAppDataPath();
+    if (appDataPath === '') {
+      throw new Error('Sheet: Could not resolve sheet folser');
+    }
+    this.sheetsFolder = join(appDataPath, 'sheets');
+    this.clientSecretFile = join(this.sheetsFolder, 'client_secret.json');
+    ensureDirectory(this.sheetsFolder);
+    try {
+      const secrets = JSON.parse(readFileSync(this.clientSecretFile, 'utf-8'));
+      const isKeyMissing = this.requiredClientKeys.some((key) => !(key in secrets['installed']));
+      if (!isKeyMissing) {
+        Sheet.clientSecret = secrets;
+      }
+    } catch (_) {
+      /* empty - it is ok thet there is no clientSecret */
+    }
+  }
+
+  /**
+   * @description SETP 1 - saves secrets object to appdata path as client_secret.json
+   * @param {object} secrets
+   * @throws
+   */
+  public async saveClientSecrets(secrets: object) {
+    Sheet.client = null;
+    Sheet.authUrl = null;
+    Sheet.clientSecret = null;
+
+    const isKeyMissing = this.requiredClientKeys.some((key) => !(key in secrets['installed']));
+    if (isKeyMissing) {
+      throw new Error('Client file is missing some keys');
+    }
+
+    await writeFile(this.clientSecretFile, JSON.stringify(secrets), 'utf-8').catch((err) => {
+      throw new Error(`Unable to save client file to disk ${err}`);
+    });
+    Sheet.clientSecret = secrets;
+  }
+
+  /**
+   * @description SETP 1 - test that the saved object is pressent
+   */
+  testClientSecrect() {
+    return Sheet.clientSecret !== null;
+  }
+
+  /**
+   * @description SETP 2 - create server to interact with th OAuth2 request
+   * @returns {Promise<string | null>} - returns url path serve on success
+   * @throws
+   */
+  async openAuthServer(): Promise<string | null> {
+    //TODO: this only works on local networks
+
+    // if the server is allready running retun it
+    if (Sheet.authUrl) {
+      clearTimeout(this.authServerTimeout);
+      this.authServerTimeout = setTimeout(
+        () => {
+          Sheet.authUrl = null;
+          server.unref;
+        },
+        2 * 60 * 1000,
+      );
+      return Sheet.authUrl;
+    }
+
+    // Check that Secret is valid
+    const keyFile = Sheet.clientSecret;
+    const keys = keyFile.installed || keyFile.web;
+    if (!keys.redirect_uris || keys.redirect_uris.length === 0) {
+      throw new Error('Sheet: Missing redirect URI');
+    }
+    const redirectUri = new URL(keys.redirect_uris[0]);
+    if (redirectUri.hostname !== 'localhost') {
+      throw new Error('Sheet: Invalid redirect URI');
+    }
+
+    // create an oAuth client to authorize the API call
+    const client = new OAuth2Client({
+      clientId: keys.client_id,
+      clientSecret: keys.client_secret,
+    });
+
+    // start the server that will recive the codes
+    const server = http.createServer(async (req, res) => {
+      try {
+        const serverUrl = new URL(req.url, 'http://localhost:3000');
+        if (serverUrl.pathname !== redirectUri.pathname) {
+          res.end('Invalid callback URL');
+          return;
+        }
+        const searchParams = serverUrl.searchParams;
+        if (searchParams.has('error')) {
+          res.end('Authorization rejected.');
+          logger.info(LogOrigin.Server, `Sheet: ${searchParams.get('error')}`);
+          return;
+        }
+        if (!searchParams.has('code')) {
+          res.end('No authentication code provided.');
+          logger.info(LogOrigin.Server, `Sheet: Cannot read authentication code`);
+          return;
+        }
+        const code = searchParams.get('code');
+        const { tokens } = await client.getToken({
+          code,
+          redirect_uri: redirectUri.toString(),
+        });
+        client.credentials = tokens;
+        Sheet.client = client;
+        res.end('Authentication successful! Please close this tab and return to OnTime.');
+        logger.info(LogOrigin.Server, `Sheet: Authentication successful`);
+      } catch (e) {
+        logger.error(LogOrigin.Server, `Sheet: ${e}`);
+      } finally {
+        server.close();
+      }
+    });
+    let listenPort = 3000;
+    if (keyFile.installed) {
+      // Use emphemeral port if not a web client
+      listenPort = 0;
+    } else if (redirectUri.port !== '') {
+      listenPort = Number(redirectUri.port);
+    }
+    //TODO: the server might not start correctly
+    server.listen(listenPort);
+    const address = server.address();
+    if (typeof address !== 'string') {
+      redirectUri.port = String(address.port);
+    }
+    // open the browser to the authorize url to start the workflow
+    const authorizeUrl = client.generateAuthUrl({
+      redirect_uri: redirectUri.toString(),
+      access_type: 'offline',
+      scope: this.scope,
+    });
+    Sheet.authUrl = authorizeUrl;
+    this.authServerTimeout = setTimeout(
+      () => {
+        Sheet.authUrl = null;
+        server.unref();
+      },
+      2 * 60 * 1000,
+    );
+    return authorizeUrl;
+  }
+
+  /**
+   * @description SETP 2 - test that the reciveed OAuth2 is still valid
+   * @throws
+   */
+  async testAuthentication() {
+    if (Sheet.client) {
+      const ref = await Sheet.client.refreshAccessToken();
+      if (ref.credentials.expiry_date > 10000) {
+        return true;
+      } else {
+        throw new Error('Unable to use accese token');
+      }
+    } else {
+      throw new Error('Unable to authenticate');
+    }
+  }
+
+  /**
+   * @description SETP 3 - test the given sheet id
+   * @throws
+   */
+  async testSheetId(id: string) {
+    const spreadsheets = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.get({
+      spreadsheetId: id,
+      includeGridData: false,
+    });
+    if (spreadsheets.status != 200) {
+      throw new Error(spreadsheets.statusText);
+    }
+    return { worksheetOptions: spreadsheets.data.sheets.map((i) => i.properties.title) };
+  }
+
+  /**
+   * @description SETP 4 - test the given worksheet
+   * @throws
+   */
+  async testWorksheet(id: string, worksheet: string) {
+    const spreadsheets = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.get({
+      spreadsheetId: id,
+      includeGridData: false,
+    });
+    if (spreadsheets.status != 200) {
+      throw new Error(spreadsheets.statusText);
+    }
+    const worksheetExist = spreadsheets.data.sheets.find((i) => i.properties.title === worksheet);
+    if (!worksheetExist) {
+      throw new Error('Unable to find worksheet');
+    }
+  }
+
+  /**
+   * test existence of sheet and worksheet
+   * @param {string} sheetId - https://docs.google.com/spreadsheets/d/[[spreadsheetId]]/edit#gid=0
+   * @param {string} worksheet - the name of the worksheet containing ontime data
+   * @returns {Promise<{worksheetId: number, range: string}>} - id of worksheet and rage of worksheet
+   * @throws
+   */
+  private async exist(sheetId: string, worksheet: string): Promise<{ worksheetId: number; range: string }> {
+    const spreadsheets = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.get({
+      spreadsheetId: sheetId,
+    });
+
+    if (spreadsheets.status === 200) {
+      const ourWorksheetData = spreadsheets.data.sheets.find((n) => n.properties.title == worksheet);
+      if (ourWorksheetData !== undefined) {
+        const endCell = getA1Notation(
+          ourWorksheetData.properties.gridProperties.rowCount,
+          ourWorksheetData.properties.gridProperties.columnCount,
+        );
+        return { worksheetId: ourWorksheetData.properties.sheetId, range: `${worksheet}!A1:${endCell}` };
+      }
+    } else {
+      throw new Error('Uable to open spreadsheets');
+    }
+  }
+
+  /**
+   * @description SETP 5 - Upload the rundown to sheet
+   * @param {string} id - id of the sheet https://docs.google.com/spreadsheets/d/[[spreadsheetId]]/edit#gid=0
+   * @param {ExcelImportMap} options
+   * @throws
+   */
+  public async push(id: string, options: ExcelImportMap) {
+    const { worksheetId, range } = await this.exist(id, options.worksheet);
+
+    const rq = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.values.get({
+      spreadsheetId: id,
+      valueRenderOption: 'FORMATTED_VALUE',
+      majorDimension: 'ROWS',
+      range: range,
+    });
+    if (rq.status === 200) {
+      const { rundownMetadata, projectMetadata } = parseExcel(rq.data.values, options);
+      const rundown = DataProvider.getRundown();
+      const projectData = DataProvider.getProjectData();
+      const titleRow = Object.values(rundownMetadata)[0]['row'];
+
+      const updateRundown = Array<sheets_v4.Schema$Request>();
+
+      // we can't delete the last unflozzen row so we create an empty one
+      updateRundown.push({
+        insertDimension: {
+          inheritFromBefore: false,
+          range: {
+            dimension: 'ROWS',
+            startIndex: titleRow + 1,
+            endIndex: titleRow + 2,
+            sheetId: worksheetId,
+          },
+        },
+      });
+      //and delete the rest
+      updateRundown.push({
+        deleteDimension: { range: { dimension: 'ROWS', startIndex: titleRow + 2, sheetId: worksheetId } },
+      });
+      // insert the lenght of the rundown
+      updateRundown.push({
+        insertDimension: {
+          inheritFromBefore: false,
+          range: {
+            dimension: 'ROWS',
+            startIndex: titleRow + 1,
+            endIndex: titleRow + rundown.length,
+            sheetId: worksheetId,
+          },
+        },
+      });
+
+      //update the corresponding row with event data
+      rundown.forEach((entry, index) =>
+        updateRundown.push(cellRequenstFromEvent(entry, index, worksheetId, rundownMetadata)),
+      );
+
+      //update project data
+      updateRundown.push(cellRequenstFromProjectData(projectData, worksheetId, projectMetadata));
+
+      const writeResponds = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.batchUpdate({
+        spreadsheetId: id,
+        requestBody: {
+          includeSpreadsheetInResponse: false,
+          responseRanges: [range],
+          requests: updateRundown,
+        },
+      });
+
+      if (writeResponds.status == 200) {
+        logger.info(LogOrigin.Server, `Sheet: write: ${writeResponds.statusText}`);
+      } else {
+        throw new Error(`Sheet: write faild: ${writeResponds.statusText}`);
+      }
+    } else {
+      throw new Error(`Sheet: read faild: ${rq.statusText}`);
+    }
+  }
+
+  /**
+   * @description SETP 5 - Downpload the rundown from sheet
+   * @param {string} id - id of the sheet https://docs.google.com/spreadsheets/d/[[spreadsheetId]]/edit#gid=0
+   * @param {ExcelImportMap} options
+   * @returns {Promise<Partial<ResponseOK>>}
+   * @throws
+   */
+  public async pull(id: string, options: ExcelImportMap): Promise<Partial<ResponseOK>> {
+    const { range } = await this.exist(id, options.worksheet);
+
+    const res: Partial<ResponseOK> = {};
+
+    const rq = await sheets({ version: 'v4', auth: Sheet.client }).spreadsheets.values.get({
+      spreadsheetId: id,
+      valueRenderOption: 'FORMATTED_VALUE',
+      majorDimension: 'ROWS',
+      range,
+    });
+
+    if (rq.status === 200) {
+      res.data = {};
+      const dataFromSheet = parseExcel(rq.data.values, options);
+      res.data.rundown = parseRundown(dataFromSheet);
+      if (res.data.rundown.length < 1) {
+        throw new Error(`Sheet: Could not find data to import in the worksheet`);
+      }
+      console.log(dataFromSheet.project);
+      console.log(dataFromSheet.userFields);
+      res.data.project = parseProject(dataFromSheet);
+      res.data.userFields = parseUserFields(dataFromSheet);
+      return res;
+    } else {
+      throw new Error(`Sheet: read faild: ${rq.statusText}`);
+    }
+  }
+}
+
+export const sheet = new Sheet();

pnpm-lock.yaml

@@ -249,6 +249,9 @@ importers:
 
   apps/server:
     dependencies:
+      '@googleapis/sheets':
+        specifier: ^5.0.5
+        version: 5.0.5
       body-parser:
         specifier: ^1.20.0
         version: 1.20.1
@@ -270,6 +273,9 @@ importers:
       express-validator:
         specifier: ^6.14.2
         version: 6.14.2
+      google-auth-library:
+        specifier: ^9.2.0
+        version: 9.2.0
       got:
         specifier: ^14.0.0
         version: 14.0.0
@@ -2228,6 +2234,16 @@ packages:
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dev: true
 
+  /@googleapis/sheets@5.0.5:
+    resolution: {integrity: sha512-XMoONmgAJm2jYeTYHX4054VcEkElxlgqmnHvt0wAurzEHoGJLdUHhTAJXGPLgSs4WVMPtgU8HLrmk7/U+Qlw7A==}
+    engines: {node: '>=12.0.0'}
+    dependencies:
+      googleapis-common: 7.0.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
   /@humanwhocodes/config-array@0.11.13:
     resolution: {integrity: sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==}
     engines: {node: '>=10.10.0'}
@@ -3535,6 +3551,15 @@ packages:
       - supports-color
     dev: true
 
+  /agent-base@7.1.0:
+    resolution: {integrity: sha512-o/zjMZRhJxny7OyEF+Op8X+efiELC7k7yOjMzgfzVqOzXqkBkWI79YoTdOtsuWd5BWhAGAuOY/Xa6xpiaWXiNg==}
+    engines: {node: '>= 14'}
+    dependencies:
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /ajv-keywords@3.5.2(ajv@6.12.6):
     resolution: {integrity: sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==}
     peerDependencies:
@@ -3787,13 +3812,16 @@ packages:
   /base64-js@1.5.1:
     resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
     requiresBuild: true
-    dev: true
 
   /big-integer@1.6.51:
     resolution: {integrity: sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==}
     engines: {node: '>=0.6'}
     dev: true
 
+  /bignumber.js@9.1.2:
+    resolution: {integrity: sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==}
+    dev: false
+
   /binary-extensions@2.2.0:
     resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
     engines: {node: '>=8'}
@@ -3896,6 +3924,10 @@ packages:
     resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
     dev: true
 
+  /buffer-equal-constant-time@1.0.1:
+    resolution: {integrity: sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==}
+    dev: false
+
   /buffer-equal@1.0.0:
     resolution: {integrity: sha512-tcBWO2Dl4e7Asr9hTGcpVrCe+F7DubpmqWCTbj4FHLmjqO2hIaC383acQubWtRJhdceqs5uBHs6Es+Sk//RKiQ==}
     engines: {node: '>=0.4.0'}
@@ -4425,7 +4457,6 @@ packages:
         optional: true
     dependencies:
       ms: 2.1.2
-    dev: true
 
   /decimal.js@10.4.3:
     resolution: {integrity: sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA==}
@@ -4654,6 +4685,12 @@ packages:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
     dev: true
 
+  /ecdsa-sig-formatter@1.0.11:
+    resolution: {integrity: sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==}
+    dependencies:
+      safe-buffer: 5.2.1
+    dev: false
+
   /ee-first@1.1.1:
     resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
     dev: false
@@ -5300,6 +5337,10 @@ packages:
       - supports-color
     dev: false
 
+  /extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+    dev: false
+
   /extract-zip@2.0.1:
     resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
     engines: {node: '>= 10.17.0'}
@@ -5562,6 +5603,30 @@ packages:
     resolution: {integrity: sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==}
     dev: true
 
+  /gaxios@6.1.1:
+    resolution: {integrity: sha512-bw8smrX+XlAoo9o1JAksBwX+hi/RG15J+NTSxmNPIclKC3ZVK6C2afwY8OSdRvOK0+ZLecUJYtj2MmjOt3Dm0w==}
+    engines: {node: '>=14'}
+    dependencies:
+      extend: 3.0.2
+      https-proxy-agent: 7.0.2
+      is-stream: 2.0.1
+      node-fetch: 2.7.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
+  /gcp-metadata@6.1.0:
+    resolution: {integrity: sha512-Jh/AIwwgaxan+7ZUUmRLCjtchyDiqh4KjBJ5tW3plBZb5iL/BPcso8A5DlzeD9qlw0duCamnNdpFjxwaT0KyKg==}
+    engines: {node: '>=14'}
+    dependencies:
+      gaxios: 6.1.1
+      json-bigint: 1.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
   /gensync@1.0.0-beta.2:
     resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
     engines: {node: '>=6.9.0'}
@@ -5693,6 +5758,36 @@ packages:
     resolution: {integrity: sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==}
     dev: true
 
+  /google-auth-library@9.2.0:
+    resolution: {integrity: sha512-1oV3p0JhNEhVbj26eF3FAJcv9MXXQt4S0wcvKZaDbl4oHq5V3UJoSbsGZGQNcjoCdhW4kDSwOs11wLlHog3fgQ==}
+    engines: {node: '>=14'}
+    dependencies:
+      base64-js: 1.5.1
+      ecdsa-sig-formatter: 1.0.11
+      gaxios: 6.1.1
+      gcp-metadata: 6.1.0
+      gtoken: 7.0.1
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
+  /googleapis-common@7.0.1:
+    resolution: {integrity: sha512-mgt5zsd7zj5t5QXvDanjWguMdHAcJmmDrF9RkInCecNsyV7S7YtGqm5v2IWONNID88osb7zmx5FtrAP12JfD0w==}
+    engines: {node: '>=14.0.0'}
+    dependencies:
+      extend: 3.0.2
+      gaxios: 6.1.1
+      google-auth-library: 9.2.0
+      qs: 6.11.0
+      url-template: 2.0.8
+      uuid: 9.0.1
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
   /gopd@1.0.1:
     resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==}
     dependencies:
@@ -5745,6 +5840,17 @@ packages:
     resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
     dev: true
 
+  /gtoken@7.0.1:
+    resolution: {integrity: sha512-KcFVtoP1CVFtQu0aSk3AyAt2og66PFhZAlkUOuWKwzMLoulHXG5W5wE5xAnHb+yl3/wEFoqGW7/cDGMU8igDZQ==}
+    engines: {node: '>=14.0.0'}
+    dependencies:
+      gaxios: 6.1.1
+      jws: 4.0.0
+    transitivePeerDependencies:
+      - encoding
+      - supports-color
+    dev: false
+
   /has-bigints@1.0.2:
     resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==}
     dev: true
@@ -5857,6 +5963,16 @@ packages:
       - supports-color
     dev: true
 
+  /https-proxy-agent@7.0.2:
+    resolution: {integrity: sha512-NmLNjm6ucYwtcUmL7JQC1ZQ57LmHP4lT15FQ8D61nak1rO6DH+fz5qNK2Ap5UN4ZapYICE3/0KodcLYSPsPbaA==}
+    engines: {node: '>= 14'}
+    dependencies:
+      agent-base: 7.1.0
+      debug: 4.3.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
   /human-signals@2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
@@ -6135,7 +6251,6 @@ packages:
   /is-stream@2.0.1:
     resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
     engines: {node: '>=8'}
-    dev: true
 
   /is-stream@3.0.0:
     resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
@@ -6340,6 +6455,12 @@ packages:
     hasBin: true
     dev: true
 
+  /json-bigint@1.0.0:
+    resolution: {integrity: sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==}
+    dependencies:
+      bignumber.js: 9.1.2
+    dev: false
+
   /json-buffer@3.0.1:
     resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
 
@@ -6392,6 +6513,21 @@ packages:
       object.assign: 4.1.4
     dev: true
 
+  /jwa@2.0.0:
+    resolution: {integrity: sha512-jrZ2Qx916EA+fq9cEAeCROWPTfCwi1IVHqT2tapuqLEVVDKFDENFw1oL+MwrTvH6msKxsd1YTDVw6uKEcsrLEA==}
+    dependencies:
+      buffer-equal-constant-time: 1.0.1
+      ecdsa-sig-formatter: 1.0.11
+      safe-buffer: 5.2.1
+    dev: false
+
+  /jws@4.0.0:
+    resolution: {integrity: sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg==}
+    dependencies:
+      jwa: 2.0.0
+      safe-buffer: 5.2.1
+    dev: false
+
   /keyv@4.5.2:
     resolution: {integrity: sha512-5MHbFaKn8cNSmVW7BYnijeAVlE4cYA/SVkifVgrh7yotnfhKmjuXpDKjrABLnT0SfHWV21P8ow07OGfRrNDg8g==}
     dependencies:
@@ -6744,7 +6880,6 @@ packages:
 
   /ms@2.1.2:
     resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
-    dev: true
 
   /ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
@@ -6801,6 +6936,18 @@ packages:
       whatwg-url: 5.0.0
     dev: true
 
+  /node-fetch@2.7.0:
+    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+    engines: {node: 4.x || >=6.0.0}
+    peerDependencies:
+      encoding: ^0.1.0
+    peerDependenciesMeta:
+      encoding:
+        optional: true
+    dependencies:
+      whatwg-url: 5.0.0
+    dev: false
+
   /node-osc@9.0.2:
     resolution: {integrity: sha512-q+VQL7DMWRL5+yvzRlWVig8BD9raotLs6onHU4e8MaFgxmYuIwcXhsvQeyUZFiKP6y/qGUXU6K0T99gVmISwmA==}
     engines: {node: ^18.17.0 || >=20.5.0}
@@ -8203,7 +8350,6 @@ packages:
 
   /tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
-    dev: true
 
   /tr46@3.0.0:
     resolution: {integrity: sha512-l7FvfAHlcmulp8kr+flpQZmVwtu7nfRV7NZujtN0OqES8EL4O4e0qqzL0DC5gAvx/ZC/9lk6rhcUwYvkBnBnYA==}
@@ -8507,6 +8653,10 @@ packages:
       requires-port: 1.0.0
     dev: true
 
+  /url-template@2.0.8:
+    resolution: {integrity: sha512-XdVKMF4SJ0nP/O7XIPB0JwAEuT9lDIYnNsK8yGVe43y0AWoKeJNdv3ZNWh7ksJ6KqQFjOO6ox/VEitLnaVNufw==}
+    dev: false
+
   /use-callback-ref@1.3.0(@types/react@18.0.26)(react@18.2.0):
     resolution: {integrity: sha512-3FT9PRuRdbB9HfXhEq35u4oZkvpJ5kuYbpqhCfmiZyReuRgpnhDlbr2ZEnnuS0RrJAPn6l23xjFg9kpDM+Ms7w==}
     engines: {node: '>=10'}
@@ -8559,6 +8709,11 @@ packages:
     engines: {node: '>= 0.4.0'}
     dev: false
 
+  /uuid@9.0.1:
+    resolution: {integrity: sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==}
+    hasBin: true
+    dev: false
+
   /v8-compile-cache-lib@3.0.1:
     resolution: {integrity: sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==}
     dev: true
@@ -8911,7 +9066,6 @@ packages:
 
   /webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
-    dev: true
 
   /webidl-conversions@7.0.0:
     resolution: {integrity: sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==}
@@ -8957,7 +9111,6 @@ packages:
     dependencies:
       tr46: 0.0.3
       webidl-conversions: 3.0.1
-    dev: true
 
   /which-boxed-primitive@1.0.2:
     resolution: {integrity: sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==}