elab matlab

utils/config/loader_matlab_elab.py

@@ -29,3 +29,10 @@ class Config:
         self.dbrawdata = c.get("tables", "rawTableName")
         self.dbrawdata = c.get("tables", "rawTableName")
         self.dbnodes = c.get("tables", "nodesTableName")
+
+        # Matlab
+        self.matlab_runtime = c.get("matlab", "runtime")
+        self.matlab_func_path = c.get("matlab", "func_path")
+        self.matlab_timeout = c.getint("matlab", "timeout")
+        self.matlab_error = c.get("matlab", "error")
+        self.matlab_error_path = c.get("matlab", "error_path")

utils/csv/data_preparation.py

@@ -9,6 +9,16 @@ from itertools import islice
 logger = logging.getLogger(__name__)
 
 async def get_data(cfg: object, id: int, pool) -> tuple:
+    """
+    Retrieves unit name, tool name, and tool data for a given record ID from the database.
+
+    Args:
+        cfg (object): Configuration object containing database table name.
+        id (int): The ID of the record to retrieve.
+        pool: The database connection pool.
+    Returns:
+        tuple: A tuple containing unit_name, tool_name, and tool_data.
+    """
     async with pool.acquire() as conn:
         async with conn.cursor() as cur:
             await cur.execute(f'select unit_name, tool_name, tool_data from {cfg.dbrectable} where id = {id}')
@@ -17,6 +27,16 @@ async def get_data(cfg: object, id: int, pool) -> tuple:
             return unit_name, tool_name, tool_data
 
 async def make_pipe_sep_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes pipe-separated data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     righe = ToolData.splitlines()
     matrice_valori = []
@@ -39,6 +59,16 @@ async def make_pipe_sep_matrix(cfg: object, id: int, pool) -> list:
     return matrice_valori
 
 async def make_ain_din_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes analog and digital input data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     node_channels, node_types, node_ains, node_dins = get_nodes_type(cfg, ToolNameID, UnitName)
     righe = ToolData.splitlines()
@@ -63,6 +93,16 @@ async def make_ain_din_matrix(cfg: object, id: int, pool) -> list:
     return matrice_valori
 
 async def make_channels_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes channel-based data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     node_channels, node_types, node_ains, node_dins = get_nodes_type(cfg, ToolNameID, UnitName)
     righe = ToolData.splitlines()
@@ -81,6 +121,16 @@ async def make_channels_matrix(cfg: object, id: int, pool) -> list:
     return matrice_valori
 
 async def make_musa_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes 'Musa' specific data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     node_channels, node_types, node_ains, node_dins = get_nodes_type(cfg, ToolNameID, UnitName)
     righe = ToolData.splitlines()
@@ -104,6 +154,16 @@ async def make_musa_matrix(cfg: object, id: int, pool) -> list:
 
 
 async def make_tlp_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes 'TLP' specific data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     righe = ToolData.splitlines()
     valori_x_nodo = 2
@@ -121,6 +181,16 @@ async def make_tlp_matrix(cfg: object, id: int, pool) -> list:
 
 
 async def make_gd_matrix(cfg: object, id: int, pool) -> list:
+    """
+    Processes 'GD' specific data from a CSV record into a structured matrix.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record.
+        pool: The database connection pool.
+    Returns:
+        list: A list of lists, where each inner list represents a row in the matrix.
+    """
     UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
     righe = ToolData.splitlines()
     matrice_valori = []

utils/csv/loaders.py

@@ -7,6 +7,15 @@ import logging
 logger = logging.getLogger(__name__)
 
 async def main_loader(cfg: object, id: int, pool, action: str) -> None:
+    """
+    Main loader function to process CSV data based on the specified action.
+
+    Args:
+        cfg (object): Configuration object.
+        id (int): The ID of the CSV record to process.
+        pool: The database connection pool.
+        action (str): The type of data processing to perform (e.g., "pipe_separator", "analogic_digital").
+    """
     type_matrix_mapping = {
         "pipe_separator": make_pipe_sep_matrix,
         "analogic_digital": make_ain_din_matrix,
@@ -27,3 +36,39 @@ async def main_loader(cfg: object, id: int, pool, action: str) -> None:
             await unlock(cfg, id, pool)
     else:
         logger.warning(f"Action '{action}' non riconosciuta.")
+
+
+async def get_next_csv_atomic(pool, table_name, status):
+    """Preleva atomicamente il prossimo CSV da elaborare"""
+    async with pool.acquire() as conn:
+        # IMPORTANTE: Disabilita autocommit per questa transazione
+        await conn.begin()
+
+        try:
+            async with conn.cursor() as cur:
+                # Usa SELECT FOR UPDATE per lock atomico
+                await cur.execute(f"""
+                    SELECT id, unit_type, tool_type, unit_name, tool_name
+                    FROM {table_name}
+                    WHERE locked = 0 AND status = %s
+                    ORDER BY id
+                    LIMIT 1
+                    FOR UPDATE SKIP LOCKED
+                """, (status,))
+
+                result = await cur.fetchone()
+                if result:
+                    await cur.execute(f"""
+                        UPDATE {table_name}
+                        SET locked = 1
+                        WHERE id = %s
+                    """, (result[0],))
+
+                # Commit esplicito per rilasciare il lock
+                await conn.commit()
+                return result
+
+        except Exception as e:
+            # Rollback in caso di errore
+            await conn.rollback()
+            raise e

utils/database/matlab_query.py

@@ -0,0 +1,27 @@
+from utils.database.connection import connetti_db
+import logging
+
+logger = logging.getLogger(__name__)
+
+def get_matlab_command(cfg: object, tool: str, unit: str) -> tuple:
+
+    with connetti_db(cfg) as conn:
+        cur = conn.cursor(dictionary=True)
+        query = f"""
+            SELECT m.matcall, t.ftp_send , t.unit_id, s.`desc` as statustools, t.api_send, u.inoltro_api, u.inoltro_api_url, u.inoltro_api_bearer_token, IFNULL(u.duedate, "") as duedate from matfuncs as m
+			INNER JOIN tools as t on t.matfunc = m.id
+            INNER JOIN units as u on u.id = t.unit_id
+            INNER JOIN statustools as s on t.statustool_id = s.id
+            where t.name = '{tool}' AND u.name = '{unit}';
+
+        """
+        cur.execute(query)
+        result = cur.fetchone()
+        cur.close()
+        conn.close()
+
+        if not result:
+            logger.error(f"{unit} - {tool}: Matlab command not found.")
+            return None
+        else:
+            return result

utils/parsers/by_type/isi_csv_log_vulink.py

@@ -1,2 +1,35 @@
+import subprocess
+import tempfile
+import os
+
+from utils.database.loader_action import DATA_LOADED, update_status, unlock
+from utils.csv.data_preparation import get_data
+
+import logging
+
+logger = logging.getLogger(__name__)
+
 async def main_loader(cfg: object, id: int, pool) -> None:
-    pass
+
+    UnitName, ToolNameID, ToolData = await get_data(cfg, id, pool)
+    # Creare un file temporaneo
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as temp_file:
+        temp_file.write(ToolData)
+        temp_filename = temp_file.name
+
+    try:
+        # Eseguire il programma con il file temporaneo
+        result = await subprocess.run(['python3', 'old_script/TS_PiniScript.py', temp_filename], capture_output=True, text=True)
+        print(result.stdout)
+        print(result.stderr)
+    finally:
+        # Pulire il file temporaneo
+        os.unlink(temp_filename)
+
+    if result.returncode != 0:
+        logger.error(f"Errore nell'esecuzione del programma TS_PiniScript.py: {result.stderr}")
+        raise Exception(f"Errore nel programma: {result.stderr}")
+    else:
+        logger.info(f"Programma TS_PiniScript.py eseguito con successo: {result.stdout}")
+        await update_status(cfg, id, DATA_LOADED, pool)
+        await unlock(cfg, id, pool)