MendMD OLIS Widget Documentation

// In your main process
const { app, BrowserWindow, session, protocol } = require("electron");
const path = require("path");
const { ipcMain } = require('electron');

let mainWindow;
let authWindow;
let apiKey = null;

app.setAsDefaultProtocolClient("mendwidget");

ipcMain.on("save-api-key", (event, key) => {
    apiKey = key;
});

// Handle OneID authorization
ipcMain.handle("oneid-authorize", async (event, url) => {
    // Open auth window
    authWindow = new BrowserWindow({
        width: 800,
        height: 600,
        parent: mainWindow,       // Make it a child of your main window
        modal: true,              // Keeps it on top of the parent
        alwaysOnTop: true,        // Ensures it's visible above
        center: true,             // Centers it over the parent
        frame: true,
        webPreferences: {
            nodeIntegration: false,
            contextIsolation: true
        }
    });

    if (mainWindow) {
        const [mainX, mainY] = mainWindow.getPosition();
        const [mainWidth, mainHeight] = mainWindow.getSize();
        const authWidth = 800;
        const authHeight = 600;

        authWindow.setBounds({
            x: mainX + (mainWidth - authWidth) / 2,
            y: mainY + (mainHeight - authHeight) / 2,
            width: authWidth,
            height: authHeight
        });
    }

    session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
        details.requestHeaders["X-Api-Key"] = apiKey;
        callback({ requestHeaders: details.requestHeaders });
    });

    authWindow.loadURL(url);

    // Handle redirect
    authWindow.webContents.on("will-navigate", (event, url) => {
        // Handle auth code
        if (url.startsWith("mendwidget://")) {
            handleAuthCallBack(url);
        }
    });

    authWindow.show();
});

// Handle registration
ipcMain.handle("mendmd-register", async (event, url) => {
    // Open auth window
    const registerWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            nodeIntegration: false,
            contextIsolation: true
        }
    });

    registerWindow.loadURL(url);

    registerWindow.show();
});


app.whenReady().then(() => {
    mainWindow = new BrowserWindow({
        width: 800,
        height: 600,
        webPreferences: {
            nodeIntegration: true,
            contextIsolation: true,
            preload: path.join(__dirname, "bin", "preload.js")
        }
    });

    mainWindow.loadFile("myrenderfile.html");

    protocol.registerHttpProtocol("mendwidget", (request, callback) => {
        const url = request.url;
        handleAuthCallBack(url);
    });
});


function handleAuthCallBack(url) {
    const hashParams = new URL(url).hash.substring(1);
    const access_token = new URLSearchParams(hashParams).get("access_token");
    const refresh_token = new URLSearchParams(hashParams).get("refresh_token");
    if (refresh_token && mainWindow) {
        mainWindow.webContents.send("refresh_token", refresh_token);
    }
    if (access_token && mainWindow) {
        mainWindow.webContents.send("access_token", access_token);
    }

    authWindow.close();
}

    // Set up token listeners in renderer
    const widget = document.querySelector('mend-olis-widget');
    const apiKey = widget.getAttribute('api-key');
    window.oneIdAuth.sendApiKey(apiKey);

    window.oneIdAuth.onAccessToken((token) => {
    const widget = document.querySelector('mend-olis-widget');
    widget.setAttribute('access-token', token);
    });

    window.oneIdAuth.onRefreshToken((token) => {
    const widget = document.querySelector('mend-olis-widget');
    widget.setAttribute('refresh-token', token);
    });

    const { contextBridge, ipcRenderer } = require("electron");

    contextBridge.exposeInMainWorld("electron", {
        send: (channel) => ipcRenderer.send(channel)
        });

    contextBridge.exposeInMainWorld("mendmd", {
        register: (url) => ipcRenderer.invoke("mendmd-register", url)
        });


    contextBridge.exposeInMainWorld("oneIdAuth", {
        authorize: (url) => ipcRenderer.invoke("oneid-authorize", url),
        getTokens: () => ipcRenderer.invoke("oneid-get-tokens"),
        onAccessToken: (callback) => {
            ipcRenderer.removeAllListeners("access_token"); // Prevent duplicate listeners
            ipcRenderer.on("access_token", (event, token) => {
                callback(token);
            });
        },
        onRefreshToken: (callback) => {
            ipcRenderer.removeAllListeners("refresh_token"); // Prevent duplicate listeners
            ipcRenderer.on("refresh_token", (event, token) => {
            callback(token);
            });
        },
        sendApiKey: (apiKey) => ipcRenderer.send("save-api-key", apiKey),
        on: (channel, func) => ipcRenderer.on(channel, (event, ...args) => func(...args))
    });