Support for Facebook platform

src/account_facebook/facebook_account_controller.ts

@@ -0,0 +1,237 @@
+import path from 'path'
+
+import fetch from 'node-fetch';
+import { session } from 'electron'
+import log from 'electron-log/main';
+import Database from 'better-sqlite3'
+
+import {
+    getAccountDataPath,
+} from '../util'
+import {
+    FacebookAccount,
+    FacebookJob,
+    FacebookProgress,
+    emptyFacebookProgress,
+} from '../shared_types'
+import {
+    runMigrations,
+    getAccount,
+    exec,
+    getConfig,
+    setConfig,
+} from '../database'
+import { IMITMController } from '../mitm';
+import {
+    FacebookJobRow,
+    convertFacebookJobRowToFacebookJob,
+} from './types'
+
+export class FacebookAccountController {
+    private accountUUID: string = "";
+    // Making this public so it can be accessed in tests
+    public account: FacebookAccount | null = null;
+    private accountID: number = 0;
+    private accountDataPath: string = "";
+
+    // Making this public so it can be accessed in tests
+    public db: Database.Database | null = null;
+
+    public mitmController: IMITMController;
+    private progress: FacebookProgress = emptyFacebookProgress();
+
+    private cookies: Record<string, string> = {};
+
+    constructor(accountID: number, mitmController: IMITMController) {
+        this.mitmController = mitmController;
+
+        this.accountID = accountID;
+        this.refreshAccount();
+
+        // Monitor web request metadata
+        const ses = session.fromPartition(`persist:account-${this.accountID}`);
+        ses.webRequest.onCompleted((_details) => {
+            // TODO: Monitor for rate limits
+        });
+
+        ses.webRequest.onSendHeaders((details) => {
+            // Keep track of cookies
+            if (details.url.startsWith("https://www.facebook.com/") && details.requestHeaders) {
+                this.cookies = {};
+
+                const cookieHeader = details.requestHeaders['Cookie'];
+                if (cookieHeader) {
+                    const cookies = cookieHeader.split(';');
+                    cookies.forEach((cookie) => {
+                        const parts = cookie.split('=');
+                        if (parts.length == 2) {
+                            this.cookies[parts[0].trim()] = parts[1].trim();
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    cleanup() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+
+    refreshAccount() {
+        // Load the account
+        const account = getAccount(this.accountID);
+        if (!account) {
+            log.error(`FacebookAccountController.refreshAccount: account ${this.accountID} not found`);
+            return;
+        }
+
+        // Make sure it's a Facebook account
+        if (account.type != "Facebook") {
+            log.error(`FacebookAccountController.refreshAccount: account ${this.accountID} is not a Facebook account`);
+            return;
+        }
+
+        // Get the account UUID
+        this.accountUUID = account.uuid;
+        log.debug(`FacebookAccountController.refreshAccount: accountUUID=${this.accountUUID}`);
+
+        // Load the Facebook account
+        this.account = account.facebookAccount;
+        if (!this.account) {
+            log.error(`FacebookAccountController.refreshAccount: xAccount ${this.accountID} not found`);
+            return;
+        }
+    }
+
+    initDB() {
+        if (!this.account || !this.account.accountID) {
+            log.error("FacebookAccountController: cannot initialize the database because the account is not found, or the account Facebook ID is not found", this.account, this.account?.accountID);
+            return;
+        }
+
+        // Make sure the account data folder exists
+        this.accountDataPath = getAccountDataPath('X', this.account.name);
+        log.info(`FacebookAccountController.initDB: accountDataPath=${this.accountDataPath}`);
+
+        // Open the database
+        this.db = new Database(path.join(this.accountDataPath, 'data.sqlite3'), {});
+        this.db.pragma('journal_mode = WAL');
+        runMigrations(this.db, [
+            // Create the tables
+            {
+                name: "initial",
+                sql: [
+                    `CREATE TABLE job (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    jobType TEXT NOT NULL,
+    status TEXT NOT NULL,
+    scheduledAt DATETIME NOT NULL,
+    startedAt DATETIME,
+    finishedAt DATETIME,
+    progressJSON TEXT,
+    error TEXT
+);`,
+                    `CREATE TABLE config (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    key TEXT NOT NULL UNIQUE,
+    value TEXT NOT NULL
+);`
+                ]
+            },
+        ])
+        log.info("FacebookAccountController.initDB: database initialized");
+    }
+
+    resetProgress(): FacebookProgress {
+        log.debug("FacebookAccountController.resetProgress");
+        this.progress = emptyFacebookProgress();
+        return this.progress;
+    }
+
+    createJobs(jobTypes: string[]): FacebookJob[] {
+        if (!this.db) {
+            this.initDB();
+        }
+
+        // Cancel pending jobs
+        exec(this.db, "UPDATE job SET status = ? WHERE status = ?", ["canceled", "pending"]);
+
+        // Create new pending jobs
+        jobTypes.forEach((jobType) => {
+            exec(this.db, 'INSERT INTO job (jobType, status, scheduledAt) VALUES (?, ?, ?)', [
+                jobType,
+                'pending',
+                new Date(),
+            ]);
+        });
+
+        // Select pending jobs
+        const jobs: FacebookJobRow[] = exec(this.db, "SELECT * FROM job WHERE status = ? ORDER BY id", ["pending"], "all") as FacebookJobRow[];
+        return jobs.map(convertFacebookJobRowToFacebookJob);
+    }
+
+    updateJob(job: FacebookJob) {
+        if (!this.db) {
+            this.initDB();
+        }
+
+        exec(
+            this.db,
+            'UPDATE job SET status = ?, startedAt = ?, finishedAt = ?, progressJSON = ?, error = ? WHERE id = ?',
+            [job.status, job.startedAt ? job.startedAt : null, job.finishedAt ? job.finishedAt : null, job.progressJSON, job.error, job.id]
+        );
+    }
+
+    async archiveBuild() {
+        if (!this.db) {
+            this.initDB();
+        }
+
+        if (!this.account) {
+            return false;
+        }
+
+        log.info("FacebookAccountController.archiveBuild: building archive");
+
+        // TODO: implement
+    }
+
+    async syncProgress(progressJSON: string) {
+        this.progress = JSON.parse(progressJSON);
+    }
+
+    async getProgress(): Promise<FacebookProgress> {
+        return this.progress;
+    }
+
+    async getCookie(name: string): Promise<string | null> {
+        return this.cookies[name] || null;
+    }
+
+    async getProfileImageDataURI(profilePictureURI: string): Promise<string> {
+        log.info("FacebookAccountController.getProfileImageDataURI: profilePictureURI", profilePictureURI);
+        try {
+            const response = await fetch(profilePictureURI, {});
+            if (!response.ok) {
+                return "";
+            }
+            const buffer = await response.buffer();
+            log.info("FacebookAccountController.getProfileImageDataURI: buffer", buffer);
+            return `data:${response.headers.get('content-type')};base64,${buffer.toString('base64')}`;
+        } catch (e) {
+            log.error("FacebookAccountController.getProfileImageDataURI: error", e);
+            return "";
+        }
+    }
+
+    async getConfig(key: string): Promise<string | null> {
+        return getConfig(key, this.db);
+    }
+
+    async setConfig(key: string, value: string) {
+        return setConfig(key, value, this.db);
+    }
+}

src/account_facebook/index.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './facebook_account_controller';
+export * from './ipc';

src/account_facebook/ipc.ts

@@ -0,0 +1,113 @@
+import { ipcMain } from 'electron'
+
+import { FacebookAccountController } from './facebook_account_controller';
+
+import {
+    FacebookJob,
+    FacebookProgress,
+} from '../shared_types'
+import { getMITMController } from '../mitm';
+import { packageExceptionForReport } from '../util'
+
+const controllers: Record<number, FacebookAccountController> = {};
+
+const getFacebookAccountController = (accountID: number): FacebookAccountController => {
+    if (!controllers[accountID]) {
+        controllers[accountID] = new FacebookAccountController(accountID, getMITMController(accountID));
+    }
+    controllers[accountID].refreshAccount();
+    return controllers[accountID];
+}
+
+export const defineIPCFacebook = () => {
+    ipcMain.handle('Facebook:resetProgress', async (_, accountID: number): Promise<FacebookProgress> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return controller.resetProgress();
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:createJobs', async (_, accountID: number, jobTypes: string[]): Promise<FacebookJob[]> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return controller.createJobs(jobTypes);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:updateJob', async (_, accountID: number, jobJSON: string) => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            const job = JSON.parse(jobJSON) as FacebookJob;
+            controller.updateJob(job);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:archiveBuild', async (_, accountID: number): Promise<void> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            await controller.archiveBuild();
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:syncProgress', async (_, accountID: number, progressJSON: string) => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            await controller.syncProgress(progressJSON);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:getProgress', async (_, accountID: number): Promise<FacebookProgress> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return await controller.getProgress();
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:getCookie', async (_, accountID: number, name: string): Promise<string | null> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return await controller.getCookie(name);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:getProfileImageDataURI', async (_, accountID: number, profilePictureURI: string): Promise<string> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return await controller.getProfileImageDataURI(profilePictureURI);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:getConfig', async (_, accountID: number, key: string): Promise<string | null> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return await controller.getConfig(key);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+
+    ipcMain.handle('Facebook:setConfig', async (_, accountID: number, key: string, value: string): Promise<void> => {
+        try {
+            const controller = getFacebookAccountController(accountID);
+            return await controller.setConfig(key, value);
+        } catch (error) {
+            throw new Error(packageExceptionForReport(error as Error));
+        }
+    });
+};

src/account_facebook/types.ts

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { FacebookJob } from '../shared_types'
+
+// Models
+
+export interface FacebookJobRow {
+    id: number;
+    jobType: string;
+    status: string;
+    scheduledAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    progressJSON: string | null;
+    error: string | null;
+}
+
+// Converters
+
+export function convertFacebookJobRowToFacebookJob(row: FacebookJobRow): FacebookJob {
+    return {
+        id: row.id,
+        jobType: row.jobType,
+        status: row.status,
+        scheduledAt: new Date(row.scheduledAt),
+        startedAt: row.startedAt ? new Date(row.startedAt) : null,
+        finishedAt: row.finishedAt ? new Date(row.finishedAt) : null,
+        progressJSON: row.progressJSON ? JSON.parse(row.progressJSON) : null,
+        error: row.error,
+    };
+}