arde-packages 0.0.1

package/client.js

@@ -0,0 +1,69 @@
+const express = require("express");
+const axios = require("axios");
+require("dotenv").config();
+const logs = require("./logs");
+let localUrl = null;
+const type = "urlFinder";
+
+const app = express();
+
+app.get("/", (req, res) => {
+    res.send("Hello from urlFinder");
+});
+
+app.get("/kill", (req, res) => {
+    setTimeout(() => {
+        process.exit(0);
+    }, 1000);
+    res.send("killed");
+});
+
+app.get("/restart", (req, res) => {
+    setTimeout(() => {
+        process.exit(1);
+    }, 1000);
+    res.send("restarted");
+});
+
+app.get("/ping", (req, res) => {
+    res.send("pong");
+});
+
+function addRoute(url, callback) {
+    app.get(url, callback);
+}
+
+async function getCurentUrl() {
+    localUrl = `http://localhost:${port}`;
+    let res = await axios.get("https://api.ipify.org?format=json");
+    if (process.env.ENV != "dev") {
+        localUrl = `http://${res.data.ip}:${port}`;
+    }
+
+    console.log(`Server url: http://${res.data.ip}:${port}`);
+    console.log(`Server url: http://localhost:${port}`);
+    logs(1, `Server ${process.env.SERVER_NAME} started on: http://${res.data.ip}:${port}`);
+    conectToServ();
+    return localUrl;
+}
+
+async function conectToServ() {
+    try {
+        await axios.post(process.env.SERVER_ADRESS + "/conect", {
+            url: localUrl,
+            type,
+        });
+        logs(3, "Conected to server");
+    } catch (error) {
+        logs(2, "error to conect with botManageur !!!", error);
+    }
+}
+
+const port = process.env.PORT || 3000;
+
+app.listen(port, async () => {
+    logs(2, "server started");
+    getCurentUrl();
+});
+
+module.exports = addRoute;

package/index.js

@@ -0,0 +1,22 @@
+const logs = require("./logs");
+const Supabase = require("./supabase");
+const moment = require("moment");
+const addRoute = require("./client");
+
+async function wait(milliseconds) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve("secondes se sont écoulées");
+        }, milliseconds); // 10000 millisecondes équivalent à 10 secondes
+    });
+}
+
+function getCurentDate() {
+    const now = moment();
+    const utc = 2;
+    // YYYY-MM-DD
+    const formattedDate = now.utcOffset(60 * utc).format("YYYY-MM-DD");
+    return formattedDate;
+}
+
+module.exports = { logs, Supabase, wait, getCurentDate, addRoute };

package/logs.js

@@ -0,0 +1,75 @@
+const moment = require("moment");
+const { default: axios } = require("axios");
+const dotenv = require("dotenv");
+dotenv.config();
+const TelegramBot = require("node-telegram-bot-api");
+
+class Telegram {
+    constructor() {
+        this.chatId = 6070254981;
+        this.bot = new TelegramBot(process.env.TELEGRAM_KEY, { polling: false });
+        this.commandActionList = [];
+    }
+    async sendMessage(text, options) {
+        if (!text || text.length == 0) {
+            console.log("No text to send");
+            return;
+        }
+        this.bot.sendMessage(this.chatId, text, options);
+    }
+}
+
+const tl = new Telegram();
+
+let localUrl = null;
+let ipIsSet = false;
+
+function logs(importance, message, error = "") {
+    const now = moment();
+    const utc = 2;
+    const formattedDate = now.utcOffset(60 * utc).format("DD/MM HH:mm:ss");
+    let errorText = error ? " : " + error : "";
+    let messageFormater = message.replace(/\n/g, "\n\t\t ");
+
+    if (typeof errorText == "object") {
+        errorText = JSON.stringify(errorText);
+    }
+
+    let log = formattedDate + " : " + messageFormater;
+    if (importance == 1) {
+        console.log("\x1b[31m" + log + errorText + "\x1b[0m");
+        if (process.env.ENV == "dev") {
+            console.log("\x1b[31m" + "No telegram message send du to local environement." + "\x1b[0m");
+            return;
+        }
+        try {
+            let message = `from : ${localUrl}\n${messageFormater}`;
+            // axios.post(process.env.SERVER_ADRESS + "/sendMessage", {
+            //     message: messageFormater,
+            //     url: localUrl,
+            // });
+            tl.sendMessage(message);
+        } catch (error) {
+            console.log("\x1b[31m" + formattedDate + " : error to send telegram message !!!" + "\x1b[0m");
+        }
+    }
+    if (importance == 2) {
+        console.log("\x1b[33m" + log + errorText + "\x1b[0m");
+    }
+    if (importance == 3) {
+        console.log(log + errorText);
+    }
+}
+
+async function setLocalUrl() {
+    // localUrl = url;
+    if (ipIsSet) return;
+    ipIsSet = true;
+    let res = await axios.get("https://api.ipify.org?format=json");
+    const port = process.env.PORT || 3000;
+    localUrl = res.data.ip + ":" + port;
+}
+
+setLocalUrl();
+
+module.exports = logs;

package/package.json

@@ -0,0 +1,14 @@
+{
+    "name": "arde-packages",
+    "version": "0.0.1",
+    "main": "index.js",
+    "dependencies": {
+        "@supabase/supabase-js": "^2.33.1",
+        "axios": "^1.4.0",
+        "dotenv": "^16.3.1",
+        "express": "^4.18.2",
+        "moment": "^2.29.4",
+        "node-telegram-bot-api": "^0.61.0",
+        "pg": "^8.11.3"
+    }
+}

package/supabase.js

@@ -0,0 +1,76 @@
+const { createClient } = require("@supabase/supabase-js");
+require("dotenv").config();
+const { Pool } = require("pg");
+const logs = require("./logs");
+
+const pool = new Pool({
+    connectionString: process.env.POSTGRES_URL,
+});
+const supabaseUrl = process.env.SUPABASE_URL;
+const supabaseKey = process.env.SUPABASE_KEY;
+
+async function wait(second) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve("secondes se sont écoulées");
+        }, second * 1000);
+    });
+}
+class Supabase {
+    constructor() {
+        this.supabase = createClient(supabaseUrl, supabaseKey, {
+            auth: {
+                persistSession: false,
+            },
+        });
+        this.client = null;
+        this.haveCompanyWithUnscrapedUrl = true;
+    }
+
+    async init() {
+        this.client = await pool.connect();
+        await this.client.query("set statement_timeout to 60000000;");
+    }
+
+    async query(request) {
+        let res = null;
+        try {
+            res = await this.client.query(request);
+        } catch (err) {
+            logs(1, "Erreur lors de l'exécution de la requête :" + request, err.stack);
+            return null;
+        }
+        return res;
+    }
+
+    async upsert(table, data, errorNumber = 0) {
+        try {
+            let { error } = await this.supabase.from(table).upsert(data);
+            if (error) {
+                if (errorNumber < 3) {
+                    wait(3);
+                    logs(2, "error on upsert to the table : " + table, JSON.stringify(error));
+                    console.error(error);
+                    return await this.upsert(table, data, errorNumber + 1);
+                } else {
+                    logs(1, "More than 3 error on upsert to the table : " + table, JSON.stringify(error));
+                    logs(2, JSON.stringify(data));
+                }
+            }
+        } catch (error) {
+            if (errorNumber < 3) {
+                wait(3);
+                logs(2, "catch on upsert to the table : " + table, error);
+                return await this.upsert(table, data, errorNumber + 1);
+            } else {
+                logs(1, "More than 3 catch on upsert to the table : " + table, error);
+            }
+        }
+    }
+
+    async destroy() {
+        this.client.end();
+    }
+}
+
+module.exports = Supabase;