Arnavkar · lucasNlind · Jun 22, 2022 · Jun 23, 2022 · Jun 30, 2022 · Jul 14, 2022
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,5 @@
 .DS_Store
 node_modules
-/dist
 
 
 # local env files

diff --git a/chromeExtension/button.css b/chromeExtension/button.css
@@ -0,0 +1,13 @@
+button {
+    height: 30px;
+    width: 30px;
+    outline: none;
+    margin: 10px;
+    border: none;
+    border-radius: 2px;
+  }
+
+  button.current {
+    box-shadow: 0 0 0 2px white,
+                0 0 0 4px black;
+  }
diff --git a/chromeExtension/images/get_started128.png b/chromeExtension/images/get_started128.png
diff --git a/chromeExtension/images/get_started16.png b/chromeExtension/images/get_started16.png
diff --git a/chromeExtension/images/get_started32.png b/chromeExtension/images/get_started32.png
diff --git a/chromeExtension/images/get_started48.png b/chromeExtension/images/get_started48.png
diff --git a/chromeExtension/manifest.json b/chromeExtension/manifest.json
@@ -0,0 +1,40 @@
+{
+    "name": "Trading Bias Helper",
+    "description": "Extension to help users beat their own overconfidence bias while putting in trade offers",
+    "version": "1.0",
+    "manifest_version": 3,
+    "icons": {
+      "16": "/images/get_started16.png",
+      "32": "/images/get_started32.png",
+      "48": "/images/get_started48.png",
+      "128": "/images/get_started128.png"
+    },
+    "permissions": [
+      "tabs",
+      "storage", 
+      "activeTab", 
+      "scripting",
+      "debugger",
+      "unlimitedStorage"
+    ],
+
+    "background": {
+      "service_worker": "/scripts/background.js"
+    },
+    "content_scripts": [
+        {
+          "matches": ["<all_urls>"],
+          "js": ["/scripts/pageTracker.js"]
+        }
+      ],
+    "action": {
+        "default_popup": "/popup/popup.html",
+        "default_icon": {
+            "16": "/images/get_started16.png",
+            "32": "/images/get_started32.png",
+            "48": "/images/get_started48.png",
+            "128": "/images/get_started128.png"
+        }
+    }
+
+}
diff --git a/chromeExtension/popup/popup.html b/chromeExtension/popup/popup.html
@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <link rel="stylesheet" href="button.css">
+  </head>
+  <body>
+    <script src="popup.js"></script>
+    <h1 id = "header">Message Title</h1>
+    <h2 id = "description">Message Description</h2>
+  </body>
+</html>
diff --git a/chromeExtension/popup/popup.js b/chromeExtension/popup/popup.js
@@ -0,0 +1 @@
+
diff --git a/chromeExtension/scripts/activity.js b/chromeExtension/scripts/activity.js
@@ -0,0 +1,162 @@
+'use strict';
+
+class Activity {
+    addTab(tab) {
+        if (this.isValidPage(tab) === true) {
+            if (tab.id && (tab.id != 0)) {
+                tabs = tabs || [];
+                var url = new Url(tab.url);
+                var isDifferentUrl = false;
+                if (!url.isMatch(currentTab)) {
+                    isDifferentUrl = true;
+                }
+
+                if (this.isNewUrl(url) && !this.isInBlackList(url)) {
+                    var favicon = tab.favIconUrl;
+                    if (favicon === undefined) {
+                        favicon = 'chrome://favicon/' + url.host;
+                    }
+                    var newTab = new Tab(url, favicon);
+                    tabs.push(newTab);
+                }
+
+                if (isDifferentUrl && !this.isInBlackList(url)) {
+                    this.setCurrentActiveTab(url);
+                    var tabUrl = this.getTab(url);
+                    if (tabUrl !== undefined)
+                        tabUrl.incCounter();
+                    this.addTimeInterval(url);
+                }
+            }
+        } else this.closeIntervalForCurrentTab();
+    }
+
+    isValidPage(tab) {//Checks if we are currently at a valid url -> maybe can check for our whitelisted pages?
+        if (!tab || !tab.url || (tab.url.indexOf('http:') == -1 && tab.url.indexOf('https:') == -1)
+            || tab.url.indexOf('chrome://') !== -1
+            || tab.url.indexOf('chrome-extension://') !== -1)
+            return false;
+        return true;
+    }
+
+    isInBlackList(domain) {
+        if (setting_black_list !== undefined && setting_black_list.length > 0)
+            return setting_black_list.find(o => o.isMatch(domain)) !== undefined;
+        else return false;
+    }
+
+    isLimitExceeded(domain, tab) {
+        if (setting_restriction_list !== undefined && setting_restriction_list.length > 0) {
+            var item = setting_restriction_list.find(o => o.url.isMatch(domain));
+            if (item !== undefined) {
+                var data = tab.days.find(x => x.date == todayLocalDate());
+                if (data !== undefined) {
+                    var todayTimeUse = data.summary;
+                    if (todayTimeUse >= item.time) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    wasDeferred(domain){
+        if (deferredRestrictionsList != undefined){
+            let defItem = deferredRestrictionsList.find(x => new Url(x.site).isMatch(domain));
+            if (defItem != null){
+                let time = defItem.dateOfDeferred;
+                if (time + DEFERRED_TIMEOUT > new Date().getTime()){
+                    return true;
+                }
+                else {
+                    let index = deferredRestrictionsList.indexOf(defItem);
+                    if (index > -1)
+                        deferredRestrictionsList.splice(index, 1);
+
+                    return false;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    isNewUrl(domain) {
+        if (tabs.length > 0)
+            return tabs.find(o => o.url.isMatch(domain)) === undefined;
+        else return true;
+    }
+
+    getTab(domain) {
+        if (tabs !== undefined)
+            return tabs.find(o => o.url.isMatch(domain));
+    }
+
+
+    updateFavicon(tab) {
+        if (!this.isValidPage(tab)){
+            return;
+        }
+
+        var url = new Url(tab.url);
+        var currentTab = this.getTab(url);
+        if (currentTab !== null && currentTab !== undefined) {
+            if (tab.favIconUrl !== undefined && tab.favIconUrl !== currentTab.favicon) {
+                currentTab.favicon = tab.favIconUrl;
+            }
+        }
+    }
+
+    setCurrentActiveTab(domain) {
+        this.closeIntervalForCurrentTab();
+        currentTab = domain;
+        this.addTimeInterval(domain);
+    }
+
+    addTimeInterval(domain) {
+        var item = timeIntervalList.find(o => o.url.isMatch(domain) && o.day == todayLocalDate());
+        if (item != undefined) {
+            if (item.day == todayLocalDate())
+                item.addInterval();
+            else {
+                var newInterval = new TimeInterval(todayLocalDate(), domain);
+                newInterval.addInterval();
+                timeIntervalList.push(newInterval);
+            }
+        } else {
+            var newInterval = new TimeInterval(todayLocalDate(), domain);
+            newInterval.addInterval();
+            timeIntervalList.push(newInterval);
+        }
+    }
+
+    closeIntervalForCurrentTab(preserveCurrentTab) {
+        if (currentTab && timeIntervalList != undefined) {
+            var item = timeIntervalList.find(o => o.url.isMatch(currentTab) && o.day == todayLocalDate());
+            if (item != undefined)
+                item.closeInterval();
+        }
+
+        if (!preserveCurrentTab) {
+            currentTab = null;
+        }
+    }
+
+    isNeedNotifyView(domain, tab){
+        if (setting_notification_list !== undefined && setting_notification_list.length > 0) {
+            var item = setting_notification_list.find(o => o.url.isMatch(domain));
+            if (item !== undefined) {
+                var today = todayLocalDate();
+                var data = tab.days.find(x => x.date == today);
+                if (data !== undefined) {
+                    var todayTimeUse = data.summary;
+                    if (todayTimeUse == item.time || todayTimeUse % item.time == 0) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+};
diff --git a/chromeExtension/scripts/background.js b/chromeExtension/scripts/background.js
@@ -0,0 +1,68 @@
+function checkPermissionsForNotifications(callback, ...props) {
+    chrome.permissions.contains({
+        permissions: ["notifications"]
+    }, function(result) {
+        if (callback != undefined && result)
+            callback(...props);
+        isHasPermissioForNotification = result;
+    });
+}
+
+function addListener() {
+    //Fires when an active tab in a window changes, 
+    //URL may not be set at the time the event is fired but we can listen to onUpdated events to check when URL is set
+    chrome.tabs.onActivated.addListener(info => {
+        chrome.tabs.get(info.tabId, function(tab) {
+            activity.addTab(tab); //register the tab
+        });
+    });
+
+    //Fires when a document including it's resources is completely loaded
+    // chrome.webNavigation.onCompleted.addListener(function(details) {
+    //     chrome.tabs.get(details.tabId, function(tab) {
+    //         activity.updateFavicon(tab);
+    //     });
+    // });
+
+    //fires when chrome extension is installed or updated
+    chrome.runtime.onInstalled.addListener(details => {
+        if (details.reason == 'install') {
+            storage.saveValue(SETTINGS_SHOW_HINT, SETTINGS_SHOW_HINT_DEFAULT);
+            setDefaultSettings();
+        }
+        if (details.reason == 'update') {
+            storage.saveValue(SETTINGS_SHOW_HINT, SETTINGS_SHOW_HINT_DEFAULT);
+            checkSettingsImEmpty();
+            setDefaultValueForNewSettings();
+            isNeedDeleteTimeIntervalFromTabs = true;
+        }
+    });
+
+    chrome.storage.onChanged.addListener(function(changes, namespace) {
+        for (var key in changes) {
+            if (key === STORAGE_BLACK_LIST) {
+                loadBlackList();
+            }
+            if (key === STORAGE_RESTRICTION_LIST) {
+                loadRestrictionList();
+            }
+            if (key === STORAGE_NOTIFICATION_LIST) {
+                loadNotificationList();
+            }
+            if (key === STORAGE_NOTIFICATION_MESSAGE) {
+                loadNotificationMessage();
+            }
+            if (key === SETTINGS_INTERVAL_INACTIVITY) {
+                storage.getValue(SETTINGS_INTERVAL_INACTIVITY, function(item) { setting_interval_inactivity = item; });
+            }
+            if (key === SETTINGS_VIEW_TIME_IN_BADGE) {
+                storage.getValue(SETTINGS_VIEW_TIME_IN_BADGE, function(item) { setting_view_in_badge = item; });
+            }
+            if (key === SETTINGS_BLOCK_DEFERRAL) {
+                storage.getValue(SETTINGS_BLOCK_DEFERRAL, function(item) { setting_block_deferral = item; });
+            }
+            if (key === SETTINGS_DARK_MODE) {
+                storage.getValue(SETTINGS_DARK_MODE, function(item) { setting_dark_mode = item; });
+            }
+        }
+    });
diff --git a/chromeExtension/scripts/pageTracker.js b/chromeExtension/scripts/pageTracker.js
@@ -0,0 +1,13 @@
+let newPageOpened = Date.now()
+let firstInstance = newPageOpened
+
+console.log(`currentTime is ${newPageOpened}, starting Timer now!`)
+
+document.addEventListener("click", function() {
+    let secondInstance = Date.now()
+    let timeElapsed = (secondInstance - firstInstance)/1000
+    console.log(`Time elapsed since last click is ${timeElapsed} seconds`)
+    firstInstance = secondInstance
+}, false);
+
+
diff --git a/chromeExtension/scripts/storage.js b/chromeExtension/scripts/storage.js
@@ -0,0 +1,42 @@
+'use strict';
+
+class LocalStorage {
+    loadTabs(name, callback, callbackIsUndefined) {
+        chrome.storage.local.get(name, function(item) {
+            if (item[name] !== undefined) {
+                var result = item[name];
+                if (result !== undefined)
+                    callback(result);
+            } else {
+                if (callbackIsUndefined !== undefined)
+                    callbackIsUndefined();
+            }
+        });
+    }
+
+    saveTabs(value, callback) {
+        chrome.storage.local.set({ tabs: value });
+        if (callback !== undefined)
+            callback();
+    }
+
+    saveValue(name, value) {
+        chrome.storage.local.set({
+            [name]: value
+        });
+    }
+
+    getValue(name, callback) {
+        chrome.storage.local.get(name, function(item) {
+            if (item !== undefined) {
+                callback(item[name]);
+            } else {
+                console.log(`${name} not found in local storage`)
+            }
+        });
+    }
+
+    getMemoryUse(name, callback) {
+        chrome.storage.local.getBytesInUse(name, callback);
+    };
+}