fca-priyansh 16.0.0 → 18.0.0

package/Extra/ExtraGetThread.js

@@ -1,118 +1,365 @@
 /* eslint-disable */
 "use strict";
-var Database = require("../Extra/Database");
-var { lastRun,capture } = require('./Src/Last-Run');
-var logger = require("../logger");
-var getText = global.Fca.getText;
+var Database= require("./Database");
+const { lastRun,capture } = require('./Src/Last-Run');
+const logger = require("../logger");
+const getText = global.Fca.getText;
 var language = require("../Language/index.json");
+const fs = require("fs");
 language = language.find(i => i.Language == require(process.cwd() + "/PriyanshFca.json").Language).Folder.ExtraGetThread;
+const Always_True = [];
+if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+    if (!fs.existsSync(process.cwd() + "/Horizon_Database/Threads.json")) {
+        fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify({}));
+    }
+}
+else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type != "default" && global.Fca.Require.Priyansh.AntiGetInfo.Database_Type != "json") {
+    logger.Warning("Database_Type in PriyanshFca.json is not valid. Only default and json are valid.");
+    process.exit(0);
+}
 
 exports.createData = function(threadID,threadData) {
-    try { 
-        Database.set(String(threadID),Object(threadData),true);
-        logger.Normal(getText(language.CreateDatabaseSuccess,String(threadID)));
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        try { 
+            Database(true).set(String(threadID),Object(threadData));
+            logger.Normal(getText(language.CreateDatabaseSuccess,String(threadID)));
+        }
+        catch (e) {
+            console.log(e);
+            logger.Warning(getText(language.CreateDatabaseFailure,String(threadID))); 
+        }
     }
-    catch (e) {
-        console.log(e);
-        logger.Warning(getText(language.CreateDatabaseFailure,String(threadID))); 
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            try {
+                var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            }
+            catch (e) {
+                var data = {};
+                fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+            }
+            
+            data[String(threadID)] = Object(threadData);
+            fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+            logger.Normal(getText(language.CreateDatabaseSuccess,String(threadID)));
+        }
+        catch (e) {
+            console.log(e);
+            logger.Warning(getText(language.CreateDatabaseFailure,String(threadID))); 
+        }
     }
 }
 
 exports.updateData = function(threadID,threadData) {
-    try { 
-        Database.set(String(threadID),Object(threadData),true);
-        logger.Normal(getText(language.updateDataSuccess,String(threadID)));
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        try { 
+            Database(true).set(String(threadID),Object(threadData));
+            logger.Normal(getText(language.updateDataSuccess,String(threadID)));
+        }
+        catch (e) {
+            console.log(e);
+            logger.Warning(getText(language.updateDataFailure,String(threadID))); 
+        }
     }
-    catch (e) {
-        console.log(e);
-        logger.Warning(getText(language.updateDataFailure,String(threadID))); 
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            try {
+                var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            }
+            catch (e) {
+                var data = {};
+                fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+            }
+            
+            data[String(threadID)] = Object(threadData);
+            fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+            logger.Normal(getText(language.updateDataSuccess,String(threadID)));
+        }
+        catch (e) {
+            console.log(e);
+            logger.Warning(getText(language.updateDataFailure,String(threadID))); 
+        }
     }
 }
 
 exports.updateMessageCount = function(threadID,threadData) {
-    try { 
-        Database.set(String(threadID),Object(threadData),true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        try { 
+            Database(true).set(String(threadID),Object(threadData));
+        }
+        catch (e) {
+            console.log(e);
+        }
     }
-    catch (e) {
-        console.log(e);
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            try {
+                var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            }
+            catch (e) {
+                var data = {};
+                fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+            }
+            
+            data[String(threadID)] = Object(threadData);
+            fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+        }
+        catch (e) {
+            console.log(e);
+        }
     }
 }
 
 exports.getData = function(threadID) {
-    switch (Database.has(String(threadID),true)) {
-        case true: {
-            return Database.get(String(threadID),{},true)
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        let Sw;
+        if (Always_True.includes(threadID)) Sw = true
+        else Sw = Database(true).has(String(threadID))
+        switch (Sw) {
+            case true: {
+                return Database(true).get(String(threadID))
+            }
+            case false: {
+                return null;
+            }
+        }
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            let Sw;
+            if (Always_True.includes(threadID)) Sw = true
+            else Sw = data.hasOwnProperty(String(threadID))
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            switch (Sw) {
+                case true: {
+                    return data[String(threadID)];
+                }
+                case false: {
+                    return null;
+                }
+            }
         }
-        case false: {
+        catch (e) {
+            console.log(e);
             return null;
         }
     }
 }
 
 exports.deleteAll = function(data) {
-    for (let i of data) {
-        Database.delete(String(i),true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        for (let i of data) {
+            Database(true).delete(String(i));
+        }
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            var data1 = require(process.cwd() + "/Horizon_Database/Threads.json");
+            for (let i of data) {
+                delete data1[String(i)];
+            }
+            fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data1));
+        }
+        catch (e) {
+            console.log(e);
+        }
     }
 }
 
 exports.getAll = function() {
-    return Database.list(true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        return Database(true).list();
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            const Data_Res = []
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            for (let i of Object.keys(data)) {
+                Data_Res.push({
+                    ID: String(i),
+                    data: data[String(i)]
+                });
+            }
+            return Data_Res;
+        }
+        catch (e) {
+            console.log(e);
+            return [];
+        }
+    }
 }
 
 exports.hasData = function(threadID) {
-    return Database.has(String(threadID),true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        if (Always_True.includes(threadID)) return true;
+        else {
+            const Data_Back = Database(true).has(String(threadID));
+            if (Data_Back === true) Always_True.push(threadID);
+            return Data_Back;
+        }
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            if (Always_True.includes(threadID)) return true;
+            else {
+                var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+                var has = data.hasOwnProperty(String(threadID));
+                if (has === true) Always_True.push(threadID);
+                return has
+            }
+        }
+        catch (e) {
+            console.log(e);
+            return false;
+        }
+    }
 }
 
 exports.alreadyUpdate = function(threadID) {
-    var Time = Database.get(String(threadID),{},true).TimeUpdate;
-        try { 
-            if (global.Fca.startTime >= (Time + (3600 * 1000))) {
-                logger.Normal(getText(language.alreadyUpdate, String(threadID)));
-                return true;
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        var Time = Database(true).get(String(threadID)).TimeUpdate;
+            try { 
+                if (global.Fca.startTime >= (Time + (3600 * 1000))) {
+                    logger.Normal(getText(language.alreadyUpdate, String(threadID)));
+                    return true;
+                }
+                else return false;
             }
-            else return false;
+            catch (e) { 
+                console.log(e);
+            return true;
+        }
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            var Time = data[String(threadID)].TimeUpdate;
+            try { 
+                if (global.Fca.startTime >= (Time + (3600 * 1000))) {
+                    logger.Normal(getText(language.alreadyUpdate, String(threadID)));
+                    return true;
+                }
+                else return false;
+            }
+            catch (e) { 
+                console.log(e);
+            return true;
+        }
         }
-        catch (e) { 
+        catch (e) {
             console.log(e);
-        return true;
+            return true;
+        }
     }
 }
 
 exports.readyCreate = function(Name) {
-    switch (Database.has(String(Name),true)) {
-        case true: {
-            if (Number(global.Fca.startTime) >= Number(Database.get(String(Name),{},true) + (120 * 1000))) {
-                return true;
-            }   
-            else {
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        switch (Database(true).has(String(Name))) {
+            case true: {
+                if (!Always_True.includes(Name)) Always_True.push(Name);
+
+                if (Number(global.Fca.startTime) >= Number(Database(true).get(String(Name)) + (120 * 1000))) {
+                    return true;
+                }   
+                else {
+                    return false;
+                }
+            }
+            case false: {
                 return false;
             }
         }
-        case false: {
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            switch (data.hasOwnProperty(String(Name))) {
+                case true: {
+                    if (Number(global.Fca.startTime) >= Number(data[String(Name)] + (120 * 1000))) {
+                        return true;
+                    }   
+                    else {
+                        return false;
+                    }
+                }
+                case false: {
+                    return false;
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
             return false;
         }
     }
 }
 
 exports.setLastRun = function(Name,LastRun) {
-    Database.set(String(Name),String(lastRun(LastRun)),true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        Database(true).set(String(Name),String(lastRun(LastRun)));
+    }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            data[String(Name)] = String(lastRun(LastRun));
+            fs.writeFileSync(process.cwd() + "/Horizon_Database/Threads.json",JSON.stringify(data));
+        }
+        catch (e) {
+            console.log(e);
+        }
+    }
 }
 
 exports.getLastRun = function(Name) {
-    switch (Database.has(String(Name),true)) {
-        case true: {
-            return Database.get(String(Name),{},true);
-        }
-        case false: {
-            try {
-                capture(Name)
-                this.setLastRun(Name,Name);
-                return Database.get(String(Name),{},true);
+    if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "default") {
+        let Sw;
+        if (Always_True.includes(Name)) Sw = true;
+        else Sw = Database(true).has(String(Name));
+
+        switch (Sw) {
+            case true: {
+                return Database(true).get(String(Name));
             }
-            catch(e) {
-                console.log(e);
-                return Date.now();
+            case false: {
+                try {
+                    capture(Name)
+                    this.setLastRun(Name,Name);
+                    return Database(true).get(String(Name));
+                }
+                catch(e) {
+                    console.log(e);
+                    return Date.now();
+                }
             }
         }
     }
+    else if (global.Fca.Require.Priyansh.AntiGetInfo.Database_Type == "json") {
+        try {
+            let Sw;
+            if (Always_True.includes(Name)) Sw = true;
+            else Sw = data.hasOwnProperty(String(Name));
+            var data = require(process.cwd() + "/Horizon_Database/Threads.json");
+            switch (Sw) {
+                case true: {
+                    return data[String(Name)];
+                }
+                case false: {
+                    try {
+                        capture(Name)
+                        this.setLastRun(Name,Name);
+                        return data[String(Name)];
+                    }
+                    catch(e) {
+                        console.log(e);
+                        return Date.now();
+                    }
+                }
+            }
+        }
+        catch (e) {
+            console.log(e);
+            return Date.now();
+        }
+    }
 }

package/Extra/ExtraUptimeRobot.js

@@ -1,9 +1,21 @@
+'use strict';
+
 const logger = require("../logger");
 module.exports = function() {
     var Logger = global.Fca.Require.logger;
     switch (process.platform) {
-        case 'win32': return Logger.Warning(global.Fca.Require.Language.ExtraUpTime.NotSupport);
-        case 'darwin': return Logger.Warning(global.Fca.Require.Language.ExtraUpTime.NotSupport);
+        case 'win32': {
+            if (global.Fca.Require.Priyansh.Uptime) {
+                logger.Warning(global.Fca.Require.Language.ExtraUpTime.NotSupport);
+            }
+            break;
+        }
+        case 'darwin': {
+            if (global.Fca.Require.Priyansh.Uptime) {
+                logger.Warning(global.Fca.Require.Language.ExtraUpTime.NotSupport);
+            }
+            break;
+        }
         case 'linux':
             if (process.env.REPL_SLUG) {
                 var Value = global.Fca.Require.Priyansh;
@@ -12,7 +24,7 @@ module.exports = function() {
                         logger.Normal(global.Fca.Require.Language.ExtraUpTime.Uptime);//
                         return setInterval(function() {
                             Fetch.get(`https://${process.env.REPL_SLUG}.${process.env.REPL_OWNER}.repl.co`);
-                        },1000);
+                        },10*1000);
                     }
                 else return;
             }

package/Extra/Html/Classic/script.js

@@ -18,7 +18,7 @@ var point = function(x,y,vx,vy){
   this.y = y;
   this.vx = vx || 1;
   this.vy = vy || 1;
-}
+};
 point.prototype.update = function() {
   ctx.beginPath();
   ctx.fillStyle = "#95a5a6";
@@ -58,7 +58,7 @@ point.prototype.update = function() {
   
   this.x += this.vx;
   this.y += this.vy;
-}
+};
 
 function loop() {
   ctx.clearRect(0,0,c.width,c.height);
@@ -116,4 +116,4 @@ function coordsToI(x,y,w) {
 }
 
 setInterval(loop,50);
-init();
+init();

package/Extra/Security/Base/Step_1.js

@@ -0,0 +1,6 @@
+'use strict';
+
+var CryptoJS = require("crypto-js");
+module.exports.EncryptState = function EncryptState(Data,PassWord) { return CryptoJS.AES.encrypt(Data, PassWord).toString(); };
+
+module.exports.DecryptState = function DecryptState(Data,PassWord) { return CryptoJS.AES.decrypt(Data, PassWord).toString(CryptoJS.enc.Utf8); };

package/Extra/Security/Base/Step_2.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var CryptoJS = require("crypto-js");
+
+/**
+ * Encrypt the text using the CryptoJS library and return the encrypted text as a Base64 string.
+ * @param Data - The data to be encrypted.
+ * @returns A string of characters that represent the encrypted data.
+ */
+module.exports.Encrypt = function Encrypt(Data) {
+    return CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(Data));
+};
+
+/**
+ * Decrypt the data using the CryptoJS library, and return the decrypted data as a string.
+ * @param Data - The data to be decrypted.
+ * @returns The decrypted data.
+ */
+
+module.exports.Decrypt = function Decrypt(Data) {
+    return CryptoJS.enc.Base64.parse(Data).toString(CryptoJS.enc.Utf8);
+};

package/Extra/Security/Base/Step_3.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const crypto = require('crypto');
+const aes = require("aes-js");
+
+module.exports.encryptState = function encryptState(data, key) {
+    let hashEngine = crypto.createHash("sha256");
+    let hashKey = hashEngine.update(key).digest();
+    let bytes = aes.utils.utf8.toBytes(data);
+    let aesCtr = new aes.ModeOfOperation.ctr(hashKey);
+    let encryptedData = aesCtr.encrypt(bytes);
+    return aes.utils.hex.fromBytes(encryptedData);
+};
+
+module.exports.decryptState = function decryptState(data, key) {
+    let hashEngine = crypto.createHash("sha256");
+    let hashKey = hashEngine.update(key).digest();
+    let encryptedBytes = aes.utils.hex.toBytes(data);
+    let aesCtr = new aes.ModeOfOperation.ctr(hashKey);
+    let decryptedData = aesCtr.decrypt(encryptedBytes);
+    return aes.utils.utf8.fromBytes(decryptedData);
+};