resolve merge conflicts

functions/fb.js

@@ -0,0 +1,173 @@
+import firebase from "firebase/app";
+import "firebase/firestore";
+import "firebase/auth";
+
+// Initialize Firebase, copied from cloud console
+const firebaseConfig = {
+  apiKey: "AIzaSyCMsFreESs58-hRxTtiqQrIcimh4i1wbsM",
+  authDomain: "postwoman-api.firebaseapp.com",
+  databaseURL: "https://postwoman-api.firebaseio.com",
+  projectId: "postwoman-api",
+  storageBucket: "postwoman-api.appspot.com",
+  messagingSenderId: "421993993223",
+  appId: "1:421993993223:web:ec0baa8ee8c02ffa1fc6a2",
+  measurementId: "G-ERJ6025CEB"
+};
+firebase.initializeApp(firebaseConfig);
+
+// a reference to the users collection
+const usersCollection = firebase.firestore().collection("users");
+
+// the shared state object that any vue component
+// can get access to
+export const fb = {
+  currentUser: {},
+  currentFeeds: [],
+  currentSettings: [],
+  currentHistory: [],
+  writeFeeds: async (message, label) => {
+    const dt = {
+      createdOn: new Date(),
+      author: fb.currentUser.uid,
+      author_name: fb.currentUser.displayName,
+      author_image: fb.currentUser.photoURL,
+      message,
+      label
+    };
+    try {
+      return usersCollection
+        .doc(fb.currentUser.uid)
+        .collection("feeds")
+        .add(dt);
+    } catch (e) {
+      return console.error("error inserting", dt, e);
+    }
+  },
+  deleteFeed: id => {
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("feeds")
+      .doc(id)
+      .delete()
+      .catch(e => console.error("error deleting", id, e));
+  },
+  writeSettings: async (setting, value) => {
+    const st = {
+      updatedOn: new Date(),
+      author: fb.currentUser.uid,
+      author_name: fb.currentUser.displayName,
+      author_image: fb.currentUser.photoURL,
+      name: setting,
+      value
+    };
+    try {
+      return usersCollection
+        .doc(fb.currentUser.uid)
+        .collection("settings")
+        .doc(setting)
+        .set(st);
+    } catch (e) {
+      return console.error("error updating", st, e);
+    }
+  },
+  writeHistory: async entry => {
+    const hs = entry;
+    try {
+      return usersCollection
+        .doc(fb.currentUser.uid)
+        .collection("history")
+        .add(hs);
+    } catch (e) {
+      return console.error("error inserting", hs, e);
+    }
+  },
+  deleteHistory: entry => {
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("history")
+      .doc(entry.id)
+      .delete()
+      .catch(e => console.error("error deleting", entry, e));
+  },
+  clearHistory: () => {
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("history")
+      .get()
+      .then(({ docs }) => {
+        docs.forEach(e => fb.deleteHistory(e));
+      });
+  },
+  toggleStar: (entry, value) => {
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("history")
+      .doc(entry.id)
+      .update({ star: value })
+      .catch(e => console.error("error deleting", entry, e));
+  }
+};
+
+// When a user logs in or out, save that in the store
+firebase.auth().onAuthStateChanged(user => {
+  if (user) {
+    fb.currentUser = user;
+    fb.currentUser.providerData.forEach(profile => {
+      let us = {
+        updatedOn: new Date(),
+        provider: profile.providerId,
+        name: profile.displayName,
+        email: profile.email,
+        photoUrl: profile.photoURL,
+        uid: profile.uid
+      };
+      try {
+        usersCollection.doc(fb.currentUser.uid).set(us);
+      } catch (e) {
+        console.error("error updating", us, e);
+      }
+    });
+
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("feeds")
+      .orderBy("createdOn", "desc")
+      .onSnapshot(feedsRef => {
+        const feeds = [];
+        feedsRef.forEach(doc => {
+          const feed = doc.data();
+          feed.id = doc.id;
+          feeds.push(feed);
+        });
+        fb.currentFeeds = feeds;
+      });
+
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("settings")
+      .onSnapshot(settingsRef => {
+        const settings = [];
+        settingsRef.forEach(doc => {
+          const setting = doc.data();
+          setting.id = doc.id;
+          settings.push(setting);
+        });
+        fb.currentSettings = settings;
+      });
+
+    usersCollection
+      .doc(fb.currentUser.uid)
+      .collection("history")
+      .onSnapshot(historyRef => {
+        const history = [];
+        historyRef.forEach(doc => {
+          const entry = doc.data();
+          entry.id = doc.id;
+          history.push(entry);
+        });
+        fb.currentHistory = history;
+      });
+  } else {
+    fb.currentUser = null;
+  }
+});

functions/network.js

@@ -1,19 +1,19 @@
 import AxiosStrategy from "./strategies/AxiosStrategy";
-import ProxyStrategy from "./strategies/ProxyStrategy";
 import FirefoxStrategy from "./strategies/FirefoxStrategy";
-
+import ChromeStrategy, { hasChromeExtensionInstalled } from "./strategies/ChromeStrategy";
 
 const runAppropriateStrategy = (req, store) => {
+  // Chrome Provides a chrome object for scripts to access
+  // Check its availability to say whether you are in Google Chrome
+  if (window.chrome && hasChromeExtensionInstalled()) {
+      return ChromeStrategy(req, store);
+  }
   // The firefox plugin injects a function to send requests through it
   // If that is available, then we can use the FirefoxStrategy
   if (window.firefoxExtSendRequest) {
     return FirefoxStrategy(req, store); 
   }
 
-  if (store.state.postwoman.settings.PROXY_ENABLED) {
-    return ProxyStrategy(req, store);
-  }
-
   return AxiosStrategy(req, store);
 }
 

functions/strategies/AxiosStrategy.js

@@ -1,8 +1,23 @@
 import axios from "axios";
 
-const axiosStrategy = async (req, _store) => {
+const axiosWithProxy = async (req, { state }) => {
+  const { data } = await axios.post(
+    state.postwoman.settings.PROXY_URL || "https://postwoman.apollotv.xyz/",
+    req
+  );
+  return data;
+};
+
+const axiosWithoutProxy = async (req, _store) => {
   const res = await axios(req);
   return res;
 };
 
+const axiosStrategy = (req, store) => {
+  if (store.state.postwoman.settings.PROXY_ENABLED) {
+    return axiosWithProxy(req, store);
+  }
+  return axiosWithoutProxy(req, store);
+};
+
 export default axiosStrategy;

functions/strategies/ChromeStrategy.js

@@ -0,0 +1,56 @@
+const EXTENSION_ID = "amknoiejhlmhancpahfcfcfhllgkpbld";
+
+// Check if the Chrome Extension is present
+// The Chrome extension injects an empty span to help detection.
+// Also check for the presence of window.chrome object to confirm smooth operations
+export const hasChromeExtensionInstalled = () => {
+  return document.getElementById("chromePWExtensionDetect") !== null;
+}
+
+const chromeWithoutProxy = (req, _store) => new Promise((resolve, reject) => {
+  chrome.runtime.sendMessage(
+    EXTENSION_ID, {
+      messageType: "send-req",
+      data: {
+        config: req
+      }
+    }, (message) => {
+      if (message.data.error) {
+        reject(message.data.error);
+      } else {
+        resolve(message.data.response);
+      }
+    }
+  );
+});
+
+const chromeWithProxy = (req, { state }) => new Promise((resolve, reject) => {
+  chrome.runtime.sendMessage(
+    EXTENSION_ID, {
+      messageType: "send-req",
+      data: {
+        config: {
+          method: "post",
+          url: state.postwoman.settings.PROXY_URL || "https://postwoman.apollotv.xyz/",
+          data: req
+        }
+      }
+    }, (message) => {
+      if (message.data.error) {
+        reject(error);
+      } else {
+        resolve(message.data.response.data);
+      }
+    }
+  )
+});
+
+const chromeStrategy = (req, store) => {
+  if (store.state.postwoman.settings.PROXY_ENABLED) {
+    return chromeWithProxy(req, store);
+  } else {
+    return chromeWithoutProxy(req, store);
+  }
+}
+
+export default chromeStrategy;

functions/strategies/FirefoxStrategy.js

@@ -1,15 +1,50 @@
-const firefoxStrategy = (req, _store) => new Promise((resolve, reject) => {
+const firefoxWithProxy = (req, { state }) =>
+  new Promise((resolve, reject) => {
+    const eventListener = event => {
+      window.removeEventListener("firefoxExtSendRequestComplete", event);
 
-  const eventListener = (event) => {
-    window.removeEventListener("firefoxExtSendRequestComplete", eventListener);
+      if (event.detail.error) {
+        reject(JSON.parse(event.detail.error));
+      } else {
+        resolve(JSON.parse(event.detail.response).data);
+      }
+    };
 
-    if (event.detail.error) reject(JSON.parse(event.detail.error));
-    else resolve(JSON.parse(event.detail.response));
-  };
+    window.addEventListener("firefoxExtSendRequestComplete", eventListener);
 
-  window.addEventListener("firefoxExtSendRequestComplete", eventListener);
+    window.firefoxExtSendRequest({
+      method: "post",
+      url:
+        state.postwoman.settings.PROXY_URL || "https://postwoman.apollotv.xyz/",
+      data: req
+    });
+  });
 
-  window.firefoxExtSendRequest(req);
-});
+const firefoxWithoutProxy = (req, _store) =>
+  new Promise((resolve, reject) => {
+    const eventListener = ({ detail }) => {
+      window.removeEventListener(
+        "firefoxExtSendRequestComplete",
+        eventListener
+      );
+
+      if (detail.error) {
+        reject(JSON.parse(detail.error));
+      } else {
+        resolve(JSON.parse(detail.response));
+      }
+    };
+
+    window.addEventListener("firefoxExtSendRequestComplete", eventListener);
+
+    window.firefoxExtSendRequest(req);
+  });
+
+const firefoxStrategy = (req, store) => {
+  if (store.state.postwoman.settings.PROXY_ENABLED) {
+    return firefoxWithProxy(req, store);
+  }
+  return firefoxWithoutProxy(req, store);
+};
 
 export default firefoxStrategy;

functions/strategies/ProxyStrategy.js

@@ -1,12 +0,0 @@
-import axios from "axios";
-
-const proxyStrategy = async (req, store) => {
-  const { data } = await axios.post(
-    store.state.postwoman.settings.PROXY_URL ||
-      "https://postwoman.apollotv.xyz/",
-    req
-  );
-  return data;
-};
-
-export default proxyStrategy;

functions/utils/debounce.js

@@ -0,0 +1,15 @@
+// Debounce is a higher order function which makes its enclosed function be executed
+// only if the function wasn't called again till 'delay' time has passed, this helps reduce impact of heavy working
+// functions which might be called frequently
+// NOTE : Don't use lambda functions as this doesn't get bound properly in them, use the 'function (args) {}' format
+const debounce = (func, delay) => {
+  let inDebounce
+  return function() {
+    const context = this
+    const args = arguments
+    clearTimeout(inDebounce)
+    inDebounce = setTimeout(() => func.apply(context, args), delay)
+  }
+}
+
+export default debounce;