Sync data with Google Drive

__tests__/__main__/import-export.js

@@ -4,8 +4,10 @@
 const {
  exportDatabaseToFile,
  importDatabaseFromFile,
+ importDatabaseFromBuffer,
  migrateFixedDbToFlexible,
- validEntry
+ validEntry,
+ getDatabaseAsJSON
 } = require('../../js/import-export');
 
 const fs = require('fs');
@@ -156,6 +158,41 @@ describe('Import export', function()
  });
  });
 
+ const regularEntriesJSON =
+ `[{"type": "flexible","date": "2020-4-1","values": ["08:00","12:00","13:00","17:00"]},
+ {"type": "flexible","date": "2020-4-2","values": ["07:00","11:00","14:00","18:00"]},
+ {"type": "waived","date": "2019-12-31","data": "New Year's eve","hours": "08:00"},
+ {"type": "waived","date": "2020-01-01","data": "New Year's Day","hours": "08:00"},
+ {"type": "waived","date": "2020-04-10","data": "Good Friday","hours": "08:00"}]`;
+
+ const notValidJSON =
+ '[{"type": "flexible","date": "2022-11-6","values": "08:44","08:45"]}]';
+
+ describe('importDatabaseFromBuffer', function()
+ {
+ test('Check that import fom buffer works', () =>
+ {
+ expect(importDatabaseFromBuffer(regularEntriesJSON)['result']).toBeTruthy();
+ expect(importDatabaseFromBuffer(notValidJSON)['result']).not.toBeTruthy();
+ expect(importDatabaseFromBuffer(notValidJSON)['failed']).toBe(0);
+ expect(importDatabaseFromBuffer(invalidEntriesContent)['result']).not.toBeTruthy();
+ expect(importDatabaseFromBuffer(invalidEntriesContent)['failed']).toBe(5);
+ });
+ });
+
+ store.clear();
+ store.set(regularEntries);
+
+ describe('getDatabaseAsJSON', function()
+ {
+ const databaseJSONObject = JSON.parse(getDatabaseAsJSON());
+ const regularEntriesJSONObject = JSON.parse(regularEntriesJSON);
+ test('Check that returning database as JSON works', () =>
+ {
+ expect(databaseJSONObject).toMatchObject(regularEntriesJSONObject);
+ });
+ });
+
  afterAll(() =>
  {
  fs.rmdirSync(folder, {recursive: true});

__tests__/__main__/invalid-entries-import-drive.js

@@ -0,0 +1,51 @@
+'use strict';
+const Store = require('electron-store');
+const { importDatabaseFromGoogleDrive } = require('../../js/import-export-online');
+
+// first five entries are invalid, second five are valid
+const invalidEntriesContent =
+`[{"type": "flexible", "date": "not-a-date", "data": "day-begin", "hours": "08:00"},
+ {"type": "waived", "date": "2020-01-01", "data": "example waiver 2", "hours": "not-an-hour"},
+ {"type": "flexible", "date": "not-a-date", "data": "day-end", "hours": "17:00"},
+ {"type": "flexible", "date": "not-a-date", "values": "not-an-array"},
+ {"type": "not-a-type", "date": "not-a-date", "data": "day-end", "hours": "17:00"},
+ {"type": "flexible","date": "2020-4-1","values": ["08:00","12:00","13:00","17:00"]},
+ {"type": "flexible","date": "2020-4-2","values": ["07:00","11:00","14:00","18:00"]},
+ {"type": "waived","date": "2019-12-31","data": "New Year's eve","hours": "08:00"},
+ {"type": "waived","date": "2020-01-01","data": "New Year's Day","hours": "08:00"},
+ {"type": "waived","date": "2020-04-10","data": "Good Friday","hours": "08:00"}
+ ]`;
+
+jest.mock('../../js/google-drive', () => ({
+ authorize: jest.fn(),
+ searchFile: jest.fn(),
+ downloadFile: jest.fn().mockResolvedValue(invalidEntriesContent),
+}));
+
+describe('Faulty import from google drive', function()
+{
+ process.env.NODE_ENV = 'test';
+ const store = new Store();
+ const flexibleStore = new Store({ name: 'flexible-store' });
+ const waivedWorkdays = new Store({ name: 'waived-workdays' });
+ store.clear();
+ flexibleStore.clear();
+ waivedWorkdays.clear();
+
+ test('Check that invalid json is not imported', async() =>
+ {
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(0);
+ expect(waivedWorkdays.size).toBe(0);
+
+ const data = await importDatabaseFromGoogleDrive();
+
+ expect(data['result']).not.toBeTruthy();
+ expect(data['failed']).toBe(5);
+ expect(data['total']).toBe(10);
+
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(2);
+ expect(waivedWorkdays.size).toBe(3);
+ });
+});

__tests__/__main__/invalid-json-import-drive.js

@@ -0,0 +1,41 @@
+/* eslint-disable no-undef */
+'use strict';
+const Store = require('electron-store');
+const { importDatabaseFromGoogleDrive } = require('../../js/import-export-online');
+
+const notValidJSON =
+'[{"type": "flexible","date": "2022-11-6","values": "08:44","08:45"]}]';
+
+jest.mock('../../js/google-drive', () => ({
+ authorize: jest.fn(),
+ searchFile: jest.fn(),
+ downloadFile: jest.fn().mockResolvedValue(notValidJSON),
+}));
+
+describe('Invalid import from google drive', function()
+{
+ process.env.NODE_ENV = 'test';
+ const store = new Store();
+ const flexibleStore = new Store({ name: 'flexible-store' });
+ const waivedWorkdays = new Store({ name: 'waived-workdays' });
+ store.clear();
+ flexibleStore.clear();
+ waivedWorkdays.clear();
+
+ test('Check that invalid json is not imported', async() =>
+ {
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(0);
+ expect(waivedWorkdays.size).toBe(0);
+
+ const data = await importDatabaseFromGoogleDrive();
+
+ expect(data['result']).not.toBeTruthy();
+ expect(data['failed']).toBe(0);
+ expect(data['total']).toBe(0);
+
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(0);
+ expect(waivedWorkdays.size).toBe(0);
+ });
+});

__tests__/__main__/regular-import-drive.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-undef */
+'use strict';
+
+const { importDatabaseFromGoogleDrive } = require('../../js/import-export-online');
+const Store = require('electron-store');
+
+const regularEntriesJSON =
+`[{"type": "flexible","date": "2020-4-1","values": ["08:00","12:00","13:00","17:00"]},
+ {"type": "flexible","date": "2020-4-2","values": ["07:00","11:00","14:00","18:00"]},
+ {"type": "waived","date": "2019-12-31","data": "New Year's eve","hours": "08:00"},
+ {"type": "waived","date": "2020-01-01","data": "New Year's Day","hours": "08:00"},
+ {"type": "waived","date": "2020-04-10","data": "Good Friday","hours": "08:00"}]`;
+
+jest.mock('../../js/google-drive', () => ({
+ authorize: jest.fn(),
+ searchFile: jest.fn(),
+ downloadFile: jest.fn().mockResolvedValue(regularEntriesJSON),
+}));
+
+describe('Regular import from google drive', function()
+{
+ process.env.NODE_ENV = 'test';
+
+ const store = new Store();
+ const flexibleStore = new Store({ name: 'flexible-store' });
+ const waivedWorkdays = new Store({ name: 'waived-workdays' });
+ store.clear();
+ flexibleStore.clear();
+ waivedWorkdays.clear();
+
+ test('Check valid json is imported', async() =>
+ {
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(0);
+ expect(waivedWorkdays.size).toBe(0);
+
+ const data = await importDatabaseFromGoogleDrive();
+
+ expect(data['result']).toBeTruthy();
+
+ expect(store.size).toBe(0);
+ expect(flexibleStore.size).toBe(2);
+ expect(waivedWorkdays.size).toBe(3);
+ });
+});

js/google-drive.js

@@ -0,0 +1,165 @@
+const fs = require('fs').promises;
+const path = require('path');
+const process = require('process');
+const { authenticate } = require('@google-cloud/local-auth');
+const { google } = require('googleapis');
+const { getDatabaseAsJSON } = require('./import-export.js');
+
+const SCOPES = ['https://www.googleapis.com/auth/drive'];
+const TOKEN_PATH = path.join(process.cwd(), 'token.json');
+const CREDENTIALS_PATH = path.join(process.cwd(), 'credentials.json');
+const VERSION = 'v3';
+
+/**
+ * Reads previously authorized credentials from the save file.
+ *
+ * @return {Promise<OAuth2Client|null>}
+ */
+async function maybeLoadSavedCredentials()
+{
+ try
+ {
+ const content = await fs.readFile(TOKEN_PATH);
+ const credentials = JSON.parse(content);
+ return google.auth.fromJSON(credentials);
+ }
+ catch (err)
+ {
+ return null;
+ }
+}
+
+/**
+ * Serializes credentials to a file compatible with GoogleAuth.fromJSON.
+ *
+ * @param {OAuth2Client} client
+ * @return {Promise<void>}
+ */
+async function saveCredentials(client)
+{
+ const content = await fs.readFile(CREDENTIALS_PATH);
+ const keys = JSON.parse(content);
+ const key = keys.installed || keys.web;
+ const payload = JSON.stringify({
+ type: 'authorized_user',
+ client_id: key.client_id,
+ client_secret: key.client_secret,
+ refresh_token: client.credentials.refresh_token,
+ });
+ await fs.writeFile(TOKEN_PATH, payload);
+}
+
+/**
+ * Load or request authorization to call APIs.
+ */
+async function authorize()
+{
+ let client = await maybeLoadSavedCredentials();
+ if (client)
+ {
+ return client;
+ }
+ client = await authenticate({
+ scopes: SCOPES,
+ keyfilePath: CREDENTIALS_PATH,
+ });
+ if (client.credentials)
+ {
+ await saveCredentials(client);
+ }
+ return client;
+}
+
+/**
+ * Upload database content as JSON to Google Drive.
+ * @param {OAuth2Client} authClient An authorized OAuth2 client.
+ * @param {String} path Path and name of the uploaded file.
+ */
+async function uploadData(authClient, path)
+{
+ const service = google.drive({ version: VERSION, auth: authClient });
+ const jsonData = getDatabaseAsJSON();
+ const fileMetadata = {
+ name: path,
+ mimeType: 'application/json',
+ };
+ const media = {
+ mimeType: 'application/json',
+ body: jsonData,
+ };
+ try
+ {
+ await service.files.create({
+ resource: fileMetadata,
+ media: media,
+ });
+ }
+ catch (err)
+ {
+ console.log(err);
+ throw new Error('Failed to upload data.');
+ }
+}
+
+/**
+ * Search file in drive location by filename.
+ * @param {OAuth2Client} authClient An authorized OAuth2 client.
+ * @param {String} fileName Name of the searched file.
+ *
+ * @return {String} fileId
+ * */
+async function searchFile(authClient, fileName)
+{
+ const service = google.drive({ version: VERSION, auth: authClient });
+ const files = [];
+ try
+ {
+ const res = await service.files.list({
+ q: `name='${fileName}'` ,
+ fields: 'nextPageToken, files(id, name)',
+ spaces: 'drive',
+ });
+ // use first file that matches the given file name
+ Array.prototype.push.apply(files, res.files);
+ const fileId = res.data.files[0].id;
+ return fileId;
+ }
+ catch (err)
+ {
+ console.log(err);
+ throw new Error(`Failed to find file ${fileName} in Drive.`);
+ }
+}
+
+/**
+ * Download TTL-data file from Google Drive.
+ * @param {OAuth2Client} authClient An authorized OAuth2 client.
+ * @param {String} fileId of the file that should be downloaded.
+ */
+async function downloadFile(authClient, fileId)
+{
+ const service = google.drive({ version: VERSION, auth: authClient });
+ try
+ {
+ const file = await service.files.get({
+ fileId: fileId,
+ alt: 'media',
+ });
+ const jsonData = JSON.stringify(file.data, null, '\t');
+ return jsonData;
+ }
+ catch (err)
+ {
+ console.log(err);
+ throw new Error('Failed to download file.');
+ }
+}
+
+module.exports = {
+ maybeLoadSavedCredentials,
+ saveCredentials,
+ authorize,
+ searchFile,
+ downloadFile,
+ uploadData
+};

js/import-export-online.js

@@ -0,0 +1,33 @@
+const { authorize, searchFile, downloadFile, uploadData } = require('./google-drive.js');
+const { importDatabaseFromBuffer } = require('./import-export.js');
+
+/**
+ * Authorize and upload database content as JSON to Google Drive.
+ * @param {String} path Path and name of the uploaded file.
+ */
+async function exportDatabaseToGoogleDrive(path)
+{
+ const client = await authorize();
+ await uploadData(client, path);
+}
+
+/**
+ * Import the database from Google Drive by downloading a JSON file that contains TTL data.
+ *
+ * @return {Promise<object>} result of the import in form {'result': false, 'total': 0, 'failed': 0} if failed
+ * and {'result': true} if import succeeded.
+ */
+async function importDatabaseFromGoogleDrive()
+{
+ // TODO: file name hardcoded at the moment, add user input
+ const client = await authorize();
+ const fileId = await searchFile(client, 'time_to_leave_export');
+ const jsonData = await downloadFile(client, fileId);
+ const importResult = importDatabaseFromBuffer(jsonData);
+ return importResult;
+}
+
+module.exports = {
+ importDatabaseFromGoogleDrive,
+ exportDatabaseToGoogleDrive
+};