vesta-web 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

vesta/db/db_service.py

@@ -152,7 +152,7 @@ class DB:
             else:
                 return []
         except Exception as e:
-            print(f"[VESTA] An error occurred with the db: {e}")
+            print(f"[VESTA] An error occurred with the db in getFilters: {e}")
             self.conn.rollback()
 
     def insertDict(self, table, dict, getId=False):
@@ -194,8 +194,15 @@ class DB:
         self.conn.commit()
 
     def resetTable(self, table):
-        sql_str = """delete from {} cascade;ALTER SEQUENCE {} RESTART WITH 1""".format(table, table + "_id_seq")
-        self.cur.execute(sql_str)
+        # Use SQL identifiers to prevent SQL injection
+        self.cur.execute(
+            sql.SQL("DELETE FROM {} CASCADE").format(sql.Identifier(table))
+        )
+        self.cur.execute(
+            sql.SQL("ALTER SEQUENCE {} RESTART WITH 1").format(
+                sql.Identifier(table + "_id_seq")
+            )
+        )
         self.conn.commit()
 
     def edit(self, table, id, element, value, selector='id'):

vesta/emptyProject/.gitlab-ci.yml

@@ -8,5 +8,4 @@ test:
     - python -m venv venv
     - source venv/bin/activate
     - pip install -r requirements.txt
-    - pip install git+https://gitlab.com/Louciole/vesta.git/
     - vesta test

vesta/emptyProject/requirements.txt

@@ -0,0 +1 @@
+vesta-web

vesta/emptyProject/static/framework/global.mjs

@@ -0,0 +1,11 @@
+let global = {
+    "state":{
+    },
+    "i18n":{
+    },
+    "settings":{
+    },
+    "user":{
+    },
+}
+export default global

vesta/emptyProject/static/framework/navigation.mjs

@@ -0,0 +1,295 @@
+import global from "./global.mjs";
+import {xhr} from "./templating.mjs";
+
+
+/**
+ * Opens a menu by its DOM id. If the menu element exists, it is displayed. Otherwise, loads the menu template asynchronously.
+ * @param {string} id - The DOM id of the menu to open.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously if not found.
+ */
+function openMenu(id, async=true){
+    const menu = document.getElementById(id)
+    if (menu){
+        menu.style.display = "flex"
+    }else{
+        loadTemplate(id.concat(".html"), undefined, id, async)
+    }
+}
+window.openMenu = openMenu
+
+/**
+ * Toggles the display of a menu by its DOM id. If the menu exists, toggles its visibility. Otherwise, loads the menu template.
+ * @param {string} id - The DOM id of the menu to toggle.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously if not found.
+ * @param {HTMLElement} [target=undefined] - Optional target HTML element for template loading.
+ */
+function toggleMenu(id, async=true,target=undefined){
+    const menu = document.getElementById(id)
+    if (menu){
+        if (menu.style.display === "flex"){
+            menu.style.display = "none"
+            return
+        }
+        menu.style.display = "flex"
+    }else{
+        loadTemplate(id.concat(".html"), target, id, async)
+    }
+}
+window.toggleMenu = toggleMenu
+
+/**
+ * Navigates to a new view or section by loading a template and updating selection state.
+ *
+ * @param {string} id - The id of the element to inject the template into.
+ * @param {string} target - The base name of the template to load (without .html).
+ * @param {Object} [selected=undefined] - Optional selection context {category | event | id} allowing to add/remove the "selected" class.
+ * @param {boolean} [async=true] - Whether to load the template asynchronously.
+ * @param {Function} [postInsert=undefined] - Optional callback to run after template insertion.
+ *
+ */
+export function goTo(id, target, selected=undefined, async=true, postInsert=undefined){
+    if (postInsert){
+        loadTemplate(target.concat(".html"), id, undefined, false)
+        postInsert()
+    }else{
+        loadTemplate(target.concat(".html"), id, undefined, async)
+    }
+    
+    if(selected){
+        let targetElt;
+        if(global.state[selected.category]){
+            global.state[selected.category].classList.remove("selected")
+        }else if(selected.event){
+            selected.event.currentTarget.parentElement.querySelector('.selected').classList.remove("selected")
+        }else if(selected.id){
+            targetElt = document.getElementById(selected.id)
+            targetElt.parentElement.querySelector('.selected').classList.remove("selected")
+        }
+
+        if(selected.event){
+            global.state[selected.category] = selected.event.currentTarget
+        }else if(selected.id){
+            global.state[selected.category] = targetElt
+        }
+        global.state[selected.category].classList.add("selected")
+    }
+}
+window.goTo = goTo
+
+
+let openingFM = false;
+
+
+/**
+ * Toggles the visibility of a floating menu (FM) by its DOM id.
+ * If another FM is open, it will be hidden and the new one will be shown.
+ *
+ * @param {string} id - The DOM id of the floating menu to toggle.
+ */
+function toggleFM(id){
+    const FM = document.getElementById(id)
+    if(FM !== global.state.activeFM){
+        openingFM = true
+        if(global.state.activeFM){
+            global.state.activeFM.classList.toggle("visible")
+        }
+        global.state.activeFM = FM
+    }
+}
+window.toggleFM = toggleFM
+
+/**
+ * Closes the currently active floating menu (FM) if one is open.
+ */
+export function closeFM(){
+    if(global.state.activeFM){
+        global.state.activeFM.classList.toggle("visible")
+        global.state.activeFM = undefined
+    }
+}
+
+/**
+ * Toggles the display of a modal window at the mouse event position.
+ * If another modal is open, it will be hidden and the new one will be shown at the event's coordinates.
+ *
+ * @param {string} id - The DOM id of the modal to toggle.
+ * @param {Event} event - The event triggering the modal (used for positioning).
+ */
+function toggleModale(id, event){
+    const FM = document.getElementById(id)
+    if(FM !== global.state.activeFM){
+        openingFM = true
+        global.state.modaltarget = event.currentTarget
+        if(global.state.activeFM){
+            global.state.activeFM.classList.toggle("visible")
+        }
+        console.log(event.currentTarget,global.state.modaltarget)
+        FM.style.top = event.clientY.toString().concat("px")
+        FM.style.left = event.clientX.toString().concat("px")
+        global.state.activeFM = FM
+        if (event.type === "contextmenu"){
+            event.preventDefault()
+            global.state.activeFM.classList.add("visible")
+        }
+    }
+}
+window.toggleModale = toggleModale
+
+/**
+ * Toggles the closed/open state of a group element (e.g., collapsible section).
+ */
+function toggleGroup(){
+    event.currentTarget.classList.toggle("closed")
+}
+window.toggleGroup = toggleGroup
+
+/**
+ * Navigates to a specific step in a multi-step menu by translating the menu horizontally.
+ *
+ * @param {number} step - The step index to navigate to.
+ * @param {string} stepsID - The DOM id of the steps container.
+ */
+function gotoStep(step,stepsID){
+    const menu = document.getElementById(stepsID)
+    menu.style.transform=`translateX(${-100*step/menu.childElementCount}%)`
+}
+window.gotoStep = gotoStep
+
+/**
+ * Removes the 'selected' class from all elements with class 'selected' inside the given container.
+ * Used for resetting selection state in multi-step menus.
+ *
+ * @param {string} id - The DOM id of the container to reset selection in.
+ */
+function resetSelected(id){
+    const selected = document.getElementById(id).querySelectorAll(".selected")
+    for(let el of selected){
+        el.classList.remove("selected")
+    }
+}
+
+/**
+ * Closes a menu by hiding it and resetting its state. Can target a specific element or use the event target.
+ *
+ * @param {string|undefined} cible - CSS selector of the element to close, or undefined to use event target.
+ * @param {string} [id='createServerSteps'] - The DOM id of the steps container to reset.
+ *
+ */
+function closeMenu(cible = undefined,id='createServerSteps'){
+    if (global.state.disableClose){
+        return
+    }
+
+    if(!cible){
+        if(event.target !== event.currentTarget){
+            return
+        }
+        event.target.style.display = "none";
+    }else{
+        const cibleEl= document.querySelector(cible)
+        cibleEl.style.display = "none";
+    }
+    gotoStep(0,id)
+    resetSelected(id)
+}
+window.closeMenu = closeMenu
+
+/**
+ * Saves the current cursor position in a text input or textarea to global state.
+ * Used to paste emojis in a textarea from an emoji-keyboard.
+ *
+ * @param {Event} event - The input event containing the cursor position.
+ */
+function saveCursorPosition(event){
+    global.state.previousCursor={start:event.srcElement.selectionStart, end:event.srcElement.selectionEnd}
+}
+window.saveCursorPosition = saveCursorPosition
+
+function isMobileDevice() {
+    return /Mobi|Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
+}
+
+export function initNavigation(){
+    window.global = global
+    global.state.dom = document.querySelector("body")
+
+    const { hostname, port } = window.location;
+    global.state.location = { host:hostname, port:port, short:port ? hostname + ":" + port : hostname }
+
+    global.state.isMobile = isMobileDevice()
+    if (global.state.isMobile) {
+        global.state.dom.classList.add("mobile")
+
+        const onload = function(){
+            console.log(this.responseText)
+        }
+        xhr("/static/mobileUiManifest.mjs", onload)
+    }
+
+    document.addEventListener('click', function (event) {
+        if (global.state.activeFM && !global.state.activeFM.contains(event.target)) {
+            global.state.activeFM.classList.toggle("visible")
+            if (!openingFM){
+                global.state.activeFM = undefined
+            }else{
+                openingFM=false
+            }
+        }
+    }, false);
+
+    if (global.state.socket){
+        window.addEventListener('unload', () => {
+            if (global.state?.socket.readyState !== WebSocket.CLOSED) {
+                const message = {"type" : 'unregister', "clientID":global.state.clientID}
+                global.state.socket.send(JSON.stringify(message))
+                global.state.socket.close()
+            }
+        });
+    }
+
+}
+
+
+function print(...args){
+    const green ="#68f66e"
+    const blue ="#4284f5"
+    const yellow ="#fef972"
+    const red ="#ee6966"
+    const pink ="#fb7bfa"
+    const purple ="#6a76fa"
+
+    const colors = [green,blue,green,"white",green,blue,"white",yellow,blue,"white",yellow,"white",yellow,red,pink,purple];
+    console.log(`%c${args.join(' ')}`, ...colors.map(c => `color: ${c};`));
+    // console.log(colors.map(c => `%c${c}`).join(''), ...colors.map(c => `background: ${c};`));
+}
+
+
+export function printWatermark(name, git){
+    print(`                                            %c ${name}\n` +
+        "%c⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀        %c -----------------------------------\n" +
+        "%c⠀⠀⠀⠀⠀⠀⠀⢠⠀⠀⠀⠀⠀⠀⠀⠀⢰⣿⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀       %c  Credits%c: Lou !  \n" +
+        `%c⠀⠀⠀⠀⠀⠀⠀⠸⣷⣦⣀⠀⠀⠀⠀⠀⣿⣿⡇⠀⠀⠀⠀⠀⠀⠀⡀⠀⠀        %c Git%c: ${git}\n` +
+        "%c⠀⠀⠀⠀⠀⠀⠀⠀⠙⣿⣿⣿⣦⠀⠠⠾⠿⣿⣷⠀⠀⠀⠀⠀⣠⣤⣄⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠟⢉⣠⣤⣶⡆⠀⣠⣈⠀⢀⣠⣴⣿⣿⠋⠀⠀⠀⠀      %c Powered by Vesta ! \n" +
+        "%c⠀⢀⡀⢀⣀⣀⣠⣤⡄⢀⣀⡘⣿⣿⣿⣷⣼⣿⣿⣷⡄⠹⣿⡿⠁⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀⠻⠿⢿⣿⣿⣿⠁⣼⣿⣿⣿⣿⣿⣿⣿⣿⣿⣟⣁⠀⠋⠀⠀⠀⠀⠀⠀⠀ \n" +
+        "⠀⠀⠀⠀⠀⠀⠈⠻⠀⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡇⢰⣄⣀⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀ ⠀⠀⠀⠀⣠⡀⠀⣴⣿⣿⣿⣿⣿⣿⣿⡿⢿⡿⠀⣾⣿⣿⣿⣿⣶⡄⠀ \n" +
+        "⠀⠀⠀⠀⠀⢀⣾⣿⣷⡀⠻⣿⣿⡿⠻⣿⣿⣿⣿⠀⠀⠈⠉⠉⠉⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⣠⣾⡿⠟⠉⠉⠀⢀⡉⠁⠀⠛⠛⢉⣠⣴⣧⠀⠀⠀⠀⠀⠀⠀⠀⠀\n" +
+        "%c⠀⠀⠀⠈⠉⠉⠀⠀⠀⠀⠀⢸⣿⣿⡿⠉⠀⠙⠿⣿⣿⣧⡀⠀⠀⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⣿⣿⠁⠀⠀⠀⠀⠀⠙⠿⣷⠀⠀⠀⠀⠀⠀⠀\n" +
+        "⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣿⠟⠀⠀⠀⠀⠀⠀⠀⠀⠃⠀⠀⠀⠀⠀⠀⠀")
+}
+
+export function hideLoadingScreen() {
+    const loadingScreen = document.getElementById('loading-screen');
+
+    // Fade out the loading screen
+    loadingScreen.classList.add('fade-out');
+
+    // Optional: wait until the transition ends before removing or showing content
+    loadingScreen.addEventListener('transitionend', () => {
+        loadingScreen.style.display = 'none';
+    });
+}

vesta/emptyProject/static/framework/templating.mjs

@@ -0,0 +1,110 @@
+let templates = {}
+
+export function xhr(endpoint,effect,method="GET", async=true, body=undefined){
+    let xhr= new XMLHttpRequest();
+    xhr.open(method, endpoint, async);
+    xhr.onload=effect
+    xhr.onerror = function() {
+        console.log("request failed")
+    };
+    if (body) {
+        xhr.setRequestHeader("Content-Type", "application/json");
+        xhr.send(JSON.stringify(body));
+    }else{
+        xhr.send();
+    }
+    return xhr
+}
+
+
+function loadTemplate(template, target=undefined, flex= undefined, async){
+    const effect = function() {
+        if (target){
+            //maybe not using eval
+            document.getElementById(target).innerHTML = eval('`' + this.responseText + '`');
+        }else{
+            global.state.dom.insertAdjacentHTML('beforeend',eval('`' + this.responseText + '`'))
+        }
+        if (flex){
+            document.getElementById(flex).style.display = "flex"
+        }
+    };
+
+    xhr( '/static/templates/'.concat(template), effect,"GET", async)
+}
+window.loadTemplate = loadTemplate
+
+function fillWith(template, list){
+    // console.log("fillWith",template,list,typeof list)
+
+    let request
+    if(templates[template]){
+        request={"responseText":templates[template]}
+    }else{
+        request = xhr( '/static/templates/'.concat(template,".html"), undefined, "GET", false)
+        // console.log("adding to cache",templates, template)
+        templates[template] = request.responseText
+    }
+
+    let content = ""
+    if (typeof list == 'object'){
+        for (let elementId in list){
+            const element = list[elementId]
+            content += eval('`' + request.responseText + '`')
+        }
+    }else if (!list){
+        console.warn("fillWith called with undefined list")
+        return content
+    }else{
+        for (let element of list){
+            content += eval('`' + request.responseText + '`')
+        }
+    }
+
+    return content
+}
+window.fillWith = fillWith
+
+function Subscribe(element, content, className=undefined, params=undefined){
+    //subscribe content to element, content will be reevaluated on element change
+    const domElement = document.createElement('div')
+    domElement.className = element.replaceAll('.','-').replaceAll('[','🪟').replaceAll(']','🥹')
+
+    if (className){
+        const classList = className.split(" ")
+        for (let name of classList){
+            domElement.classList.add(name)
+        }
+        domElement.dataset.defaultClass = domElement.className
+    }
+
+    if (params?.target === "class"){
+        domElement.dataset.target = params.target
+        domElement.className = domElement.className + " " + content()
+    }else if(params?.target === "style"){
+        domElement.dataset.target = params.target
+        domElement.style = content()
+    } else{
+        domElement.innerHTML = content()
+    }
+
+
+
+    if (params?.element){
+        domElement.dataset.element = params.element
+    }
+
+    if(params?.repaint){
+        domElement.dataset.repaint = params.repaint
+    }else{
+        domElement.dataset.content = content
+    }
+    return domElement.outerHTML
+}
+window.Subscribe = Subscribe
+
+function getTemplate(name){
+    const request = xhr( '/static/templates/'.concat(name,".html"), ()=>{}, "GET", false)
+    return eval('`' + request.responseText + '`')
+}
+window.getTemplate = getTemplate

vesta/emptyProject/static/framework/vesta.mjs

@@ -0,0 +1,173 @@
+function logout() {
+    const url = "/logout";
+    fetch(url, {
+        method: 'POST',
+        redirect: 'manual'
+    })
+        .then(response => {
+            const location = response.headers.get('location');
+            if (response.status === 302 && location) {
+                window.location.href = location;
+            } else {
+                // fallback: reload page or handle error
+                window.location.reload();
+            }
+        })
+        .catch(() => {
+            console.log("request failed");
+        });
+}
+window.logout = logout
+
+
+
+export function updateElement(selector,value=undefined){
+    const subscriptions = document.querySelectorAll(`[class^="${selector.replaceAll('.','-').replaceAll('[','🪟').replaceAll(']','🥹')}"]`)
+    for (let sub of subscriptions){
+        if(sub.dataset.repaint){
+            const fn = eval(sub.dataset.repaint)
+            fn()
+        }else if(sub.dataset.target === "class"){
+
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.className = sub.dataset.defaultClass.concat(' ',content(eval(sub.dataset.element)))
+            }else{
+                sub.className = sub.dataset.defaultClass.concat(' ',content())
+            }
+        }else if(sub.dataset.target === "style"){
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.style = content(eval(sub.dataset.element))
+            }else{
+                sub.style = content()
+            }
+        }else{
+
+            const content = eval(sub.dataset.content)
+            if(sub.dataset.element){
+                sub.innerHTML = content(eval(sub.dataset.element))
+            }else{
+                sub.innerHTML = content()
+            }
+        }
+    }
+}
+
+export function setElement(element, value){
+    // console.log(element,'has been updated to:', value);
+    eval(`${element} = value`);
+    updateElement(element,value)
+}
+
+export function pushElement(element, value){
+    // console.log(element,'has been added:', value);
+    eval(`${element}.push(value)`);
+    updateElement(element,value)
+}
+
+export function addElement(element, value){
+    // console.log(element,'has been added:', value);
+    eval(`${element}[value.id] = value`);
+    updateElement(element,value)
+}
+
+// this deletes an element from a list BY ID
+export function deleteElement(element, id){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`${element}.splice(id,1)`);
+    updateElement(element)
+}
+
+// this deletes an element from a dict BY ID
+export function deleteElementDict(element, id){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`delete ${element}[id]`);
+    updateElement(element)
+}
+
+// this deletes an element from a list BY VALUE
+export function deleteVal(element, val){
+    // console.log(element,'has been removed:', element[id]);
+    eval(`${element} = ${element}.filter(item => item !== val)`);
+    updateElement(element)
+}
+
+function checkEnter(event, effect){
+    if (event.key === "Enter"){
+        effect()
+    }
+}
+window.checkEnter = checkEnter
+
+function getTimeStr(timestamp, options = { locale: "fr-FR" }) {
+    const date = new Date(timestamp);
+
+    const defaultOptions = {
+        year: "numeric",
+        month: "numeric",
+        day: "numeric",
+        hour: "numeric",
+        minute: "numeric",
+        hour12: false,
+    };
+
+    const mergedOptions = { ...defaultOptions, ...options };
+    // console.log("TIMESTR",date.toLocaleDateString(undefined, mergedOptions))
+    return date.toLocaleDateString(undefined, mergedOptions);
+}
+window.getTimeStr = getTimeStr
+
+
+function goodbye(){
+    if (confirm('Voulez-vous vraiment vous désinscrire et supprimer votre compte de tous les services Carbonlab ? (toutes vos informations seront effacées)')) {
+        const url = "/goodbye";
+        let request = new XMLHttpRequest();
+        request.open('POST', url, true);
+        request.onload = function() { // request successful
+            console.log("account deleted")
+
+            if (request.response === 302){
+                window.location.href = request.response.headers.get('location');
+            }
+        };
+
+        request.onerror = function() {
+            console.log("request failed")
+        };
+
+        request.send();
+    } else {
+        console.log("ouf 😖")
+    }
+}
+window.goodbye = goodbye
+
+export function difference(arrKeys, dict) {
+    const result = [];
+    const dictKeys = new Set(Object.keys(dict)); // Convert dict keys to a set for efficient lookup
+
+    for (const key of arrKeys) {
+        if (!dictKeys.has(key.toString())) {
+            result.push(key);
+        }
+    }
+    return Array.from(result);
+}
+
+export function generateUUID() {
+    let d = new Date().getTime();//Timestamp
+    let d2 = ((typeof performance !== 'undefined') && performance.now && (performance.now()*1000)) || 0;//Time in microseconds since page-load or 0 if unsupported
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        let r = Math.random() * 16;//random number between 0 and 16
+        if(d > 0){//Use timestamp until depleted
+            r = (d + r)%16 | 0;
+            d = Math.floor(d/16);
+        } else {//Use microseconds since page-load if supported
+            r = (d2 + r)%16 | 0;
+            d2 = Math.floor(d2/16);
+        }
+        return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+    });
+}
+

vesta/emptyProject/static/framework/websockets.mjs

@@ -0,0 +1,41 @@
+import global from "./global.mjs";
+import {onMessage} from "../ws/onMessage.mjs";
+import {WEBSOCKETS} from "/config";
+
+
+export function initWebSockets(){
+    global.state.websocket = new WebSocket(WEBSOCKETS);
+
+    global.state.websocket.onopen = function(event) {
+        if (!global.user.id) {
+            const cookie = document.cookie.split('; ').find(row => row.startsWith('client' + '='));
+            if (cookie) {
+                global.user['id'] = cookie.split('=')[1];
+            } else {
+                console.log("ERROR : INVALID SESSION",document);
+            }
+        }
+
+
+        console.log("Connection opened to Python WebSocket server!");
+        const message = {"type" : 'register', "uid": global.user.id};
+        global.state.websocket.send(JSON.stringify(message));
+    };
+
+    global.state.websocket.onmessage = onMessage;
+
+    global.state.websocket.onclose = function(event) {
+        console.log(`[WS] Connexion closed - Code: ${event.code}, Reason: ${event.reason}`);
+
+        if (event.code !== 1000 && event.code !== 1001) {
+            console.log("[WS] Trying to reconnect in 3 secondes...");
+            setTimeout(() => {
+                initWebSockets();
+            }, 3000);
+        }
+    };
+
+    global.state.websocket.onerror = function(error) {
+        console.error("WebSocket error:", error);
+    };
+}