@hivedev/hivesdk 1.0.3

package/Client/Utility/DisableAllButtons.js

@@ -0,0 +1,4 @@
+export function disableAllbuttons()
+{
+    document.querySelectorAll("button").forEach(button => button.disabled = true);
+}

package/Client/Utility/GenerateUUID.js

@@ -0,0 +1,23 @@
+export function generateUUID()
+{
+    let d = new Date().getTime();
+    let d2 = (performance && performance.now && (performance.now() * 1000)) || 0;
+
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c)
+    {
+        let r = Math.random() * 16;
+
+        if (d > 0)
+        {
+            r = (d + r) % 16 | 0;
+            d = Math.floor(d / 16);
+        }
+        else
+        {
+            r = (d2 + r) % 16 | 0;
+            d2 = Math.floor(d2 / 16);
+        }
+
+        return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}

package/Client/Utility/GetDeviceId.js

@@ -0,0 +1,21 @@
+import { sha256 } from "../../Common/Utility/Sha256.js";
+import { generateUUID } from "./GenerateUUID.js";
+
+export async function getDeviceId()
+{
+    let uuid = localStorage.getItem("deviceId");
+
+    if (!uuid)
+    {
+        uuid = generateUUID();
+        localStorage.setItem("deviceId", uuid);
+    }
+
+    const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const language = navigator.language;
+    const userAgent = navigator.userAgent;
+
+    const rawId = `${uuid}|${timezone}|${language}|${userAgent}`;
+
+    return sha256(rawId);
+}

package/Client/Utility/IsInApp.js

@@ -0,0 +1,4 @@
+export function isInApp()
+{
+    return window.self !== window.top;
+}

package/Client/Utility/SetupAppUsage.js

@@ -0,0 +1,65 @@
+import { appWebViewInteractions } from "../../Common/Enumerations/AppWebViewInteractions.js";
+import { isInApp } from "./IsInApp.js";
+
+export function setupAppUsage()
+{
+    document.cookie = "usesCookies=true; path=/";
+
+    if(isInApp())
+    {
+        window.fallbackOpen = window.open;
+        
+        window.open = (url, name, features)=>
+        {
+            const iframe = document.createElement("iframe");
+            iframe.src = url;
+            iframe.style.position = "fixed";
+            iframe.style.display = "block";
+            iframe.style.height = "100vh";
+            iframe.style.width = "100vw";
+            iframe.style.top = "0px";
+            iframe.style.left = "0px";
+            iframe.style.border = "none";
+            iframe.style.zIndex = "10000"
+            document.body.appendChild(iframe);
+
+            return {
+                close: ()=>
+                {
+                    iframe.remove();
+                }
+                
+            }
+        }
+
+        document.querySelectorAll("img").forEach(img => 
+        {
+            if(img.getAttribute("src") && !img.src.startsWith("http")) 
+            {
+                img.src = new URL(img.getAttribute("src"), window.location.origin).href;
+            }
+        });
+
+        window.addEventListener("message", (event)=>
+        {
+            try
+            {
+               
+                const messageObject = typeof event.data === 'string' ? JSON.parse(event.data) : event.data;
+                
+                switch(messageObject.interaction)
+                {
+                    case appWebViewInteractions.BACK_PRESSED:
+                    {
+                        window.history.back();
+                    }
+                }
+                
+            }
+            catch(error)
+            {
+                return;
+            }
+        });
+    }
+}

package/Common/Constants.js

@@ -0,0 +1,6 @@
+export let serviceName = `UnknownService${Date.now()}`;
+
+export function setServiceName(name) 
+{
+    serviceName = name;
+}

package/Common/Enumerations/AppWebViewInteractions.js

@@ -0,0 +1,5 @@
+export const appWebViewInteractions =
+{
+    REQUEST_NOTIFICATION_TOKEN: 0,
+    BACK_PRESSED: 1
+};

package/Common/Enumerations/ApprovalTypes.js

@@ -0,0 +1,5 @@
+export const approvalTypes = 
+{
+    USER_REGISTERATION: 0,
+    SERVICE_REGISTERATION: 1
+};

package/Common/Enumerations/FileTreeNodeTypes.js

@@ -0,0 +1,5 @@
+export const fileTreeNodeTypes = 
+{
+    FILE: 0,
+    FOLDER: 1
+};

package/Common/Enumerations/FilterOperators.js

@@ -0,0 +1,5 @@
+export const filterOperators = 
+{
+    INCLUDE: 0,
+    EXCLUDE: 1
+};

package/Common/Enumerations/FilterTypes.js

@@ -0,0 +1,6 @@
+export const filterTypes = 
+{
+    EQUALS: 0,
+    CONTAINS: 1,
+    RANGE: 2
+};

package/Common/Enumerations/UserDataFetchFilterComparision.js

@@ -0,0 +1,11 @@
+export const userDataFetchFilterComparision = 
+{
+    EQUAL: 0,
+    NOT_EQUAL: 1,
+    GREATER_THAN: 2,
+    LESS_THAN: 3,
+    GREATER_THAN_OR_EQUAL: 4,
+    LESS_THAN_OR_EQUAL: 5,
+    EQUAL_CASE_INSENSITIVE: 6,
+    NOT_EQUAL_CASE_INSENSITIVE: 7
+};

package/Common/Enumerations/UserFieldFormats.js

@@ -0,0 +1,12 @@
+export const userFieldFormats =
+{
+    NONE: 0,
+    EMAIL: 1,
+    PASSWORD: 2,
+    DATE: 3,
+    NUMBER: 4,
+    PHONE_NUMBER: 5,
+    URL: 6,
+    MULTI_LINE_TEXT: 7,
+    CUSTOM: 8
+}

package/Common/Enumerations/UserFieldTypes.js

@@ -0,0 +1,6 @@
+export const userFieldTypes =
+{
+    ID: 0,
+    NON_ID: 1,
+    DROPDOWN: 2
+};

package/Common/Enumerations/UserPrivileges.js

@@ -0,0 +1,12 @@
+export const userPrivileges = 
+{
+    STUDENT: 0,
+    CLASS_REPRESENTATIVE: 10,
+    STUDENT_COORDINATOR: 20,
+    ASSISTANT: 30,
+    TEACHER: 40,
+    COURSE_COORDINATOR: 50,
+    HEAD_OF_DEPARTMENT: 70,
+    MANAGEMENT: 80,
+    SUPER_USER: 100
+};

package/Common/Utility/ConvertEnumerationKeyToTitleCase.js

@@ -0,0 +1,8 @@
+export function convertEnumerationKeyToTitleCase(input)
+{
+  return input
+    .toLowerCase()
+    .split('_')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}

package/Common/Utility/Delay.js

@@ -0,0 +1,4 @@
+export function delay(ms) 
+{
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/Common/Utility/ExtractIpFromUrl.js

@@ -0,0 +1,18 @@
+import { URL } from "url";
+import dns from "dns/promises";
+
+export async function extractIpFromUrl(httpUrl)
+{
+    console.log("URL IS" + httpUrl);
+    console.log(httpUrl);
+    const parsed = new URL(httpUrl);
+    const hostname = parsed.hostname;  
+
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) 
+    {
+        return hostname;
+    }
+
+    const addresses = await dns.lookup(hostname);
+    return addresses.address;
+}

package/Common/Utility/GenerateRandomId.js

@@ -0,0 +1,12 @@
+export function generateRandomId(length)
+{
+    const characters = `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`;
+    let result = '';
+
+    for(let i = 0; i < length; i++)
+    {
+        result += characters[Math.floor(Math.random() * characters.length)]
+    }
+
+    return result;
+}

package/Common/Utility/GetDirectoryName.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+export function getDirectoryName(metaUrl)
+{
+    const __filename = fileURLToPath(metaUrl);
+    return path.dirname(__filename).replace(/\\/g, "/");
+}

package/Common/Utility/GetSha512Hash.js

@@ -0,0 +1,6 @@
+import { createHash } from 'crypto';
+
+export function getSha512Hash(text) 
+{
+    return createHash('sha512').update(text).digest('hex');
+}

package/Common/Utility/NormalizeIp.js

@@ -0,0 +1,12 @@
+export function normalizeIp(ip)
+{
+    if (ip.startsWith("::ffff:")) 
+    {
+        return ip.replace("::ffff:", "");
+    }
+    if (ip === "::1") 
+    {
+        return "127.0.0.1";
+    }
+    return ip;
+}

package/Common/Utility/Sha256.js

@@ -0,0 +1,98 @@
+// Pure JS SHA-256 (no dependencies)
+export function sha256(ascii)
+{
+    function rightRotate(value, amount)
+    {
+        return (value >>> amount) | (value << (32 - amount));
+    }
+
+    var mathPow = Math.pow;
+    var maxWord = mathPow(2, 32);
+    var lengthProperty = "length";
+    var i, j;
+    var result = "";
+
+    var words = [];
+    var asciiBitLength = ascii[lengthProperty] * 8;
+
+    var hash = sha256.h = sha256.h || [];
+    var k = sha256.k = sha256.k || [];
+    var primeCounter = k[lengthProperty];
+
+    var isComposite = {};
+    for (var candidate = 2; primeCounter < 64; candidate++)
+    {
+        if (!isComposite[candidate])
+        {
+            for (i = 0; i < 313; i += candidate)
+            {
+                isComposite[i] = candidate;
+            }
+            hash[primeCounter] = (mathPow(candidate, 0.5) * maxWord) | 0;
+            k[primeCounter++] = (mathPow(candidate, 1 / 3) * maxWord) | 0;
+        }
+    }
+
+    ascii += "\x80"; // Append '1' bit (plus zero padding)
+    while (ascii[lengthProperty] % 64 - 56)
+    {
+        ascii += "\x00";
+    }
+
+    for (i = 0; i < ascii[lengthProperty]; i++)
+    {
+        j = ascii.charCodeAt(i);
+        if (j >> 8) return; // ASCII check
+        words[i >> 2] |= j << ((3 - i) % 4) * 8;
+    }
+    words[words[lengthProperty]] = ((asciiBitLength / maxWord) | 0);
+    words[words[lengthProperty]] = (asciiBitLength);
+
+    for (j = 0; j < words[lengthProperty];)
+    {
+        var w = words.slice(j, j += 16);
+        var oldHash = hash;
+
+        // This is now the "working hash", often labelled as variables a...g
+        hash = hash.slice(0, 8);
+
+        for (i = 0; i < 64; i++)
+        {
+            var w15 = w[i - 15], w2 = w[i - 2];
+
+            var a = hash[0], e = hash[4];
+            var temp1 = hash[7]
+                + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25))
+                + ((e & hash[5]) ^ ((~e) & hash[6]))
+                + k[i]
+                + (w[i] = (i < 16) ? w[i] : (
+                    w[i - 16]
+                    + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15 >>> 3))
+                    + w[i - 7]
+                    + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2 >>> 10))
+                ) | 0
+                );
+
+            var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22))
+                + ((a & hash[1]) ^ (a & hash[2]) ^ (hash[1] & hash[2]));
+
+            hash = [(temp1 + temp2) | 0].concat(hash);
+            hash[4] = (hash[4] + temp1) | 0;
+        }
+
+        for (i = 0; i < 8; i++)
+        {
+            hash[i] = (hash[i] + oldHash[i]) | 0;
+        }
+    }
+
+    for (i = 0; i < 8; i++)
+    {
+        for (j = 3; j + 1; j--)
+        {
+            var b = (hash[i] >> (j * 8)) & 255;
+            result += ((b < 16) ? 0 : "") + b.toString(16);
+        }
+    }
+    return result;
+}

package/README.md

@@ -0,0 +1 @@
+Test

package/Server/Utility/DecryptDataWithPassword.js

@@ -0,0 +1,13 @@
+import crypto from "crypto";
+
+export async function decryptDataWithPassword(data, password)
+{
+    const iv = data.subarray(0, 16);
+    const encrypted = data.subarray(16);
+
+    const key = crypto.scryptSync(password, "salt", 32);
+    const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString("utf8");
+}

package/Server/Utility/DecryptFileWithPassword.js

@@ -0,0 +1,18 @@
+import { promises as fs } from "fs";
+import crypto from "crypto";
+import { decryptDataWithPassword } from "./DecryptDataWithPassword.js";
+
+export async function decryptFileWithPassword(fullPath, password)
+{
+    const payload = await fs.readFile(fullPath);
+
+    try
+    {
+        return (await decryptDataWithPassword(payload, password));
+    }
+    catch(e)
+    {
+        return null;
+    }
+}
+

package/Server/Utility/EncryptDataWithPassword.js

@@ -0,0 +1,12 @@
+import crypto from "crypto";
+
+export async function encryptDataWithPassword(data, password)
+{
+    const key = crypto.scryptSync(password, "salt", 32);
+    const iv = crypto.randomBytes(16);
+
+    const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
+    const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
+
+    return Buffer.concat([iv, encrypted]);
+}

package/Server/Utility/EncryptFileWithPassword.js

@@ -0,0 +1,13 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { encryptDataWithPassword } from "./EncryptDataWithPassword.js";
+
+export async function encryptAndStoreFile(data, fullPath, password)
+{  
+    const payload = await encryptDataWithPassword(data, password);
+
+    const dir = path.dirname(fullPath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(fullPath, payload);
+
+}

package/Server/Utility/ExtractConfigurationForService.js

@@ -0,0 +1,11 @@
+export function extractConfigurationForService(serviceName)
+{
+    const firebaseAdminCredentials = process.env.firebaseAdminCredentials? JSON.parse(process.env.firebaseAdminCredentials): null;
+    const databaseCredentials = process.env.databaseCredentials? JSON.parse(process.env.databaseCredentials): null;
+    const permissions = process.env.permissions? JSON.parse(process.env.permissions): null;
+    const smtpCredentials = process.env.smtpCredentials? JSON.parse(process.env.smtpCredentials): null;
+    
+    const databaseCredentialsForService = databaseCredentials[serviceName]? databaseCredentials[serviceName]: null;
+    return { firebaseAdminCredentials: firebaseAdminCredentials, databaseCredentials: databaseCredentialsForService, permissions: permissions, smtpCredentials: smtpCredentials };
+     
+}

package/Server/Utility/GetAppdataDirectory.js

@@ -0,0 +1,16 @@
+import path from "path";
+import fs from "fs";
+
+export function getAppDataDirectory()
+{
+    const baseDir = process.env.APPDATA ||
+        (process.platform === "darwin"
+            ? path.join(process.env.HOME, "Library", "Application Support")
+            : path.join(process.env.HOME, ".config"));
+
+    const hiveDir = path.join(baseDir, "Hive");
+
+    fs.mkdirSync(hiveDir, { recursive: true });
+
+    return hiveDir.replace(/\\/g, "/");
+}

package/Server/Utility/GetHostIp.js

@@ -0,0 +1,19 @@
+import os from 'os';    
+
+export function getHostIp()
+{
+    const interfaces = os.networkInterfaces();
+
+    for (const devName in interfaces)
+    {
+        const iface = interfaces[devName];
+        for (let i = 0; i < iface.length; i++)
+        {
+            const alias = iface[i];
+            if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal)
+            {
+                return alias.address;
+            }
+        }
+    }
+}   

package/Server/Utility/IsLocalRequest.js

@@ -0,0 +1,21 @@
+import os from "os";
+
+export function isLocalRequest(request)
+{
+    const ip = request.ip || request.connection.remoteAddress || request.socket.remoteAddress;
+
+    const localAddresses = new Set(["127.0.0.1", "::1"]);
+
+    for (const iface of Object.values(os.networkInterfaces()))
+    {
+        for (const net of iface || [])
+        {
+            if (!net.internal)
+            {
+                localAddresses.add(net.address);
+            }
+        }
+    }
+
+    return localAddresses.has(ip);
+}

package/Server/Utility/IsRequestOriginatingFromService.js

@@ -0,0 +1,55 @@
+import url from "url";
+import { normalizeIp } from "../../Common/Utility/NormalizeIp.js";
+import DatabaseQueryEngine from "../../Database/DatabaseQueryEngine.js";
+import { extractIpFromUrl } from "../../Common/Utility/ExtractIpFromUrl.js";
+
+export async function isRequestOriginatingFromService(request)
+{
+    const serviceUrls = await DatabaseQueryEngine.getServiceUrls(null);
+
+    if (!serviceUrls || serviceUrls.length === 0)
+    {
+        return false;
+    }
+
+    const ip = request.ip || request.connection.remoteAddress || request.socket.remoteAddress;
+
+    const normalizedIp = normalizeIp(ip);
+
+    for (const service of serviceUrls)
+    {
+        for (const key of ["local", "remote"])
+        {
+            console.log(service);
+            console.log(key);
+            console.log(service.urls[key]);
+
+            try
+            {
+                const serviceUrl = await extractIpFromUrl(service.urls[key]);
+            }
+            catch(err)
+            {
+                console.log("ERROR");
+                continue;
+            }
+            
+            const serviceUrl = await extractIpFromUrl(service.urls[key]);
+            if (!serviceUrl) continue;
+
+            const normalizedServiceUrl = normalizeIp(serviceUrl);
+
+            console.log(normalizedIp);
+            console.log(normalizedServiceUrl);
+
+            console.log("____")
+
+            if (normalizedIp === normalizedServiceUrl)
+            {
+                return true;
+            }
+        }
+    }
+
+    return false;
+}

package/Server/Utility/LoadConfiguration.js

@@ -0,0 +1,62 @@
+import { decryptFileWithPassword } from "./DecryptFileWithPassword.js";
+import { getHiveAppDataDirectory } from "./GetHiveAppdataDirectory.js";
+import DatabaseConnector from "../../Database/DatabaseConnector.js";
+
+import path from "path";
+import fs from "fs";
+
+export async function loadConfiguration()
+{
+    let firebaseAdminCredentials = "";
+    let databaseCredentials = "";
+    let permissions = "";
+    let smtpCredentials = "";
+
+    const firebaseAdminCredentialsPath = path.join(getHiveAppDataDirectory(), "firebase_admin_credentials.dat");
+    const databaseCredentialsPath = path.join(getHiveAppDataDirectory(), "database_credentials.dat");
+    const permissionsPath = path.join(getHiveAppDataDirectory(), "permissions.dat");
+    const smtpCredentialsPath = path.join(getHiveAppDataDirectory(), "smtp_credentials.dat");
+
+    if(fs.existsSync(firebaseAdminCredentialsPath))
+    {
+        firebaseAdminCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "firebase_admin_credentials.dat"), process.env.serverPassword);
+    }
+
+    if(fs.existsSync(databaseCredentialsPath))
+    {
+        databaseCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "database_credentials.dat"), process.env.serverPassword);
+    }
+
+    if(fs.existsSync(permissionsPath))
+    {
+        permissions = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "permissions.dat"), process.env.serverPassword);
+    }
+
+    if(fs.existsSync(smtpCredentialsPath))
+    {
+        smtpCredentials = await decryptFileWithPassword(path.join(getHiveAppDataDirectory(), "smtp_credentials.dat"), process.env.serverPassword);
+    }
+
+    process.env.firebaseAdminCredentials = firebaseAdminCredentials;
+    process.env.databaseCredentials = databaseCredentials;
+    process.env.permissions = permissions;
+    process.env.smtpCredentials = smtpCredentials;
+    
+    if(databaseCredentials)
+    {
+        databaseCredentials = JSON.parse(databaseCredentials);
+        
+        const hivePortalDatabaseCredentials = databaseCredentials["HivePortal"];
+        DatabaseConnector.setCredentials
+        (
+            { 
+                host: hivePortalDatabaseCredentials.host || "127.0.0.1", 
+                username: hivePortalDatabaseCredentials.username || "", 
+                password: hivePortalDatabaseCredentials.password || "", 
+                name: hivePortalDatabaseCredentials.name || "hive"
+            }
+        );
+    }
+
+
+}

package/Server/Utility/PromptPassword.js

@@ -0,0 +1,24 @@
+//This is not my code, it is chatgpt code please do not complain readbility
+import readline from "readline";
+
+export async function promptPassword(promptText = "Enter password: ")
+{
+    return new Promise((resolve) =>
+    {
+        const rl = readline.createInterface(
+        {
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        rl.question(promptText, (answer) =>
+        {
+            rl.close();
+            process.stdout.write("\n");
+            resolve(answer);
+        });
+
+        
+        rl._writeToOutput = () => {};
+    });
+}