General Bug Fixes/Additons

frontend/lib/_electron/app.js

@@ -13,7 +13,6 @@ const { default: installExtension, REACT_DEVELOPER_TOOLS, REDUX_DEVTOOLS } = req
  * Application entry point.
  */
 class App {
-
   /**
    * Initialize instance.
    */
@@ -38,6 +37,12 @@ class App {
      */
     this._shell = Electron.shell;
 
+    /**
+     * The application's session storage
+     * @type {session}
+     */
+    this._session = Electron.session;
+
     /**
      * Manage the window.
      * @type {WindowManager}
@@ -73,6 +78,14 @@ class App {
     return this._shell;
   }
 
+  /**
+   * Get the session module.
+   * @return {session} Application session
+   */
+  get session() {
+    return this._session;
+  }
+
   /**
    * Get the window manager.
    *

frontend/lib/_electron/authManager.js

@@ -184,4 +184,4 @@ class AuthManager {
   }
 }
 
-module.exports = AuthManager;
+module.exports = AuthManager;

frontend/lib/_electron/captchaWindowManager.js

@@ -0,0 +1,184 @@
+const IPCKeys = require('../common/constants');
+const moment = require('moment');
+const _ = require('underscore');
+
+const Token = require('../common/classes/token');
+
+class CaptchaWindowManager {
+  constructor(context, captchaWindow, session) {
+    /**
+     * Application context
+     */
+    this._context = context;
+
+    /**
+     * Main window reference
+     */
+    this._main = this._context._windowManager._main;
+
+    /**
+     * Captcha window that the manager takes care of
+     */
+    this._captchaWindow = captchaWindow;
+
+    /**
+     * Window Manager reference
+     */
+    this._windowManager = this._context._windowManager;
+
+    /**
+     * YouTube window that the manager takes care of
+     */
+    this._youtubeWindow = null;
+
+    /**
+     * All harvested tokens for this window
+     */
+    this._tokens = [];
+
+    /**
+     * Session that the captcha window will use / YouTube window will set
+     */
+    this._session = session;
+
+    /**
+     * IPC Function Definitions
+     */
+    context.ipc.on(IPCKeys.RequestLaunchYoutube, this._onRequestLaunchYoutube.bind(this));
+    context.ipc.on(IPCKeys.RequestEndSession, this._onRequestEndSession.bind(this));
+    context.ipc.on(IPCKeys.RequestHarvestToken, this._onRequestHarvestToken.bind(this));
+    context.ipc.on(
+      IPCKeys.RequestRefreshCaptchaWindow,
+      this._onRequestRefreshCaptchaWindow.bind(this),
+    );
+
+    /**
+    * Constantly check for expired tokens every second
+    */
+    this._checkTokens = setInterval(this.checkTokens, 1000);
+  }
+
+  /**
+   * Check harvested captcha tokens to see if they're expired or not
+   */
+  checkTokens() {
+    if (this._tokens && this._tokens.length > 0) {
+      this._tokens.forEach((token) => {
+        token.setTimestamp(110 - moment().diff(moment(token.timestamp, 'seconds')));
+        if (this.isTokenExpired(token)) {
+          this.removeExpiredToken(token);
+        }
+      });
+    } else {
+      // don't run the interval check if no tokens are present
+      clearInterval(this._checkTokens);
+      this._checkTokens = null;
+    }
+  }
+
+  static isTokenExpired(token) {
+    // if token has existed for > 110 seconds
+    if (moment().diff(moment(token.timestamp), 'seconds') > 110) {
+      return true;
+    } return false;
+  }
+
+  /**
+   * Get the current session
+   */
+  getSession() {
+    return this._session;
+  }
+
+  /**
+   * Sets the session
+   * @param {Object} session - session object to use
+   */
+  setSession(session) {
+    this._session = session;
+  }
+
+  /**
+   * See what the proxy is for the given url
+   * @param {String} url - urk to ping
+   */
+  resolveProxy(url) {
+    return this._session.resolveProxy(url, proxy => proxy);
+  }
+
+  /**
+   * Sets the proxy for the window's session
+   *
+   * @param {String} proxy proxyRules = schemeProxies[";"<schemeProxies>]
+                           schemeProxies = [<urlScheme>"="]<proxyURIList>
+                           urlScheme = "http" | "https" | "ftp" | "socks"
+                           proxyURIList = <proxyURL>[","<proxyURIList>]
+                           proxyURL = [<proxyScheme>"://"]<proxyHost>[":"<proxyPort>]
+   *
+   *
+   */
+  setProxy(proxy) {
+    this._session.setProxy({
+      pacScript: null,
+      proxyRules: proxy,
+      proxyBypassRules: null,
+    }, () => {
+      const p = this.resolveProxy('https://www.google.com/');
+      console.log(`Using proxy: ${p}`);
+    });
+  }
+
+  /**
+   * Sets the 'User-Agent' header for the session
+   * @param {String} userAgent - user agent to set on all headers
+   * @param {String} acceptLanguages - the incoming languages to accept from the response (optional)
+   *                                   should be a comma separated list: "en-US,fr,de,ko,zh-CN,ja"
+   */
+  setUserAgent(userAgent, acceptLanguages) {
+    this._session.setUserAgent(userAgent, acceptLanguages);
+  }
+
+  /**
+   * Gets the 'User-Agent' header for the session
+   */
+  getUserAgent() {
+    return this._session.getUserAgent();
+  }
+
+  removeExpiredToken(token) {
+    this._tokens = _.reject(this._tokens, el => el.token === token);
+  }
+
+  /**
+   * Clears the storage data and cache for the session
+   */
+  _onRequestEndSession() {
+    this._session.flushStorageData();
+    this._session.clearStorageData([], () => {});
+    this._session.clearCache(() => {});
+  }
+
+  _onRequestHarvestToken(ev, token, host, sitekey) {
+    this._tokens.push(new Token(token, moment(), host, sitekey));
+    if (this._checkTokens === null) {
+      this._checkTokens = setInterval(this.checkTokens, 1000);
+    }
+  }
+
+  /**
+   * Refresh window object
+  */
+  _onRequestRefreshCaptchaWindow() {
+    this._captchaWindow.reload();
+  }
+
+  async _onRequestLaunchYoutube() {
+    if (this._youtubeWindow === null) {
+      const w = await this._windowManager.createNewWindow('youtube');
+      this._youtubeWindow = w;
+    } else {
+      this._youtubeWindow.show();
+    }
+  }
+}
+module.exports = CaptchaWindowManager;

frontend/lib/_electron/preload.js

@@ -1,7 +1,7 @@
 const { remote } = require('electron');
-const { dialog } = require('electron').remote;
+const { dialog, app } = require('electron').remote;
 const { ipcRenderer, webFrame } = require('electron');
-const IPCKeys = require('../common/Constants');
+const IPCKeys = require('../common/constants');
 const nebulaEnv = require('../_electron/env');
 
 // setup environment
@@ -14,7 +14,7 @@ webFrame.setLayoutZoomLevelLimits(0, 0);
 /**
  * Sends IPCMain an event trigger
  * @param {String} channel definition for which trigger to look for
- * @param {*} msg any object to send along with the event
+ * @param {*} msg any object to send along with the event || null
  */
 const _sendEvent = (channel, msg) => {
   ipcRenderer.send(channel, msg);
@@ -27,6 +27,22 @@ const _deactivate = () => {
   _sendEvent(IPCKeys.AuthRequestDeactivate);
 };
 
+/**
+ * Prevent dragover events globally
+ */
+window.addEventListener('dragover', (event) => {
+  event.preventDefault();
+  return false;
+}, false);
+
+/**
+ * Prevent drop events globally
+ */
+window.addEventListener('drop', (event) => {
+  event.preventDefault();
+  return false;
+}, false);
+
 /**
  * Sends the deactivate trigger to authManager.js
  *
@@ -44,41 +60,51 @@ const _close = () => {
   _sendEvent(IPCKeys.RequestCloseWindow, id);
 };
 
+const _closeAllCaptchaWindows = () => {
+  _sendEvent(IPCKeys.RequestCloseAllCaptchaWindows);
+};
+
 /**
  * Sends the launch youtube window trigger to windowManager.js
  */
 const _launchYoutube = () => {
-  _sendEvent(IPCKeys.RequestCreateNewWindow, 'youtube');
+  _sendEvent(IPCKeys.RequestLaunchYoutube);
 };
 
 /**
  * Sends the launch captcha window trigger to windowManager.js
  */
-const _launchHarvester = () => {
+const _launchCaptchaHarvester = () => {
   _sendEvent(IPCKeys.RequestCreateNewWindow, 'captcha');
 };
 
 /**
  * Sends the end session trigger to windowManager.js
  */
-const _endSession = () => {
-  _sendEvent(IPCKeys.RequestEndSession);
+const _endCaptchaSession = () => {
+  const { id } = remote.getCurrentWindow();
+  _sendEvent(IPCKeys.RequestEndSession, id);
 };
 
 /**
  * Sends the harvest captcha trigger to windowManager.js
  */
-const _harvest = (token) => {
+const _harvestCaptchaToken = (token) => {
   _sendEvent(IPCKeys.HarvestCaptcha, token);
 };
 
 /**
  * Sends the refresh window trigger to windowManager.js
  */
-const _refresh = (window) => {
-  _sendEvent(IPCKeys.RequestRefresh, window);
+const _refreshCaptchaWindow = () => {
+  _sendEvent(IPCKeys.RequestRefresh);
 };
 
+/**
+ * Send app name/version to the renderer
+ */
+const _getAppData = () => ({ name: app.getName(), version: app.getVersion() });
+
 /**
  * ... TODO!
  * Sends the confirmation dialog trigger to windowManager.js
@@ -100,11 +126,13 @@ process.once('loaded', () => {
   window.Bridge = window.Bridge || {};
   /* BRIDGED EVENTS */
   window.Bridge.launchYoutube = _launchYoutube;
-  window.Bridge.launchHarvester = _launchHarvester;
+  window.Bridge.launchCaptchaHarvester = _launchCaptchaHarvester;
+  window.Bridge.closeAllCaptchaWindows = _closeAllCaptchaWindows;
   window.Bridge.close = _close;
-  window.Bridge.refresh = _refresh;
-  window.Bridge.harvest = _harvest;
-  window.Bridge.endSession = _endSession;
+  window.Bridge.refreshCaptchaWindow = _refreshCaptchaWindow;
+  window.Bridge.harvestCaptchaToken = _harvestCaptchaToken;
+  window.Bridge.endCaptchaSession = _endCaptchaSession;
+  window.Bridge.getAppData = _getAppData;
   window.Bridge.deactivate = _deactivate;
   window.Bridge.authenticate = _authenticate;
   window.Bridge.confirmDialog = _confirmDialog;