OpenOrchestrator 1.0.2__tar.gz → 1.2.0__tar.gz

OpenOrchestrator-1.2.0/OpenOrchestrator/__init__.py

@@ -0,0 +1,7 @@
+"""OpenOrchestrator main module.
+https://itk-dev-rpa.github.io/OpenOrchestrator-docs/
+"""
+
+import importlib.metadata
+
+__version__ = importlib.metadata.version("OpenOrchestrator")

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/__main__.py

@@ -5,9 +5,11 @@ import sys
 from OpenOrchestrator.scheduler.application import Application as s_app
 from OpenOrchestrator.orchestrator.application import Application as o_app
 
+
 def _print_usage():
     print("Usage: -o to start Orchestrator. -s to start Scheduler")
 
+
 if len(sys.argv) != 2:
     _print_usage()
 elif sys.argv[1] == '-s':

OpenOrchestrator-1.2.0/OpenOrchestrator/common/connection_frame.py

@@ -0,0 +1,81 @@
+"""This module contains a single class: ConnectionFrame."""
+
+import os
+
+from nicegui import ui
+
+from OpenOrchestrator.common import crypto_util
+from OpenOrchestrator.database import db_util
+
+
+# pylint: disable-next=too-few-public-methods
+class ConnectionFrame():
+    """A ui module containing input and buttons for connecting to the database."""
+    def __init__(self):
+        self.conn_input = ui.input("Connection String").classes("w-4/6")
+        self.key_input = ui.input("Encryption Key").classes("w-4/6")
+        self._define_validation()
+        with ui.row().classes("w-full"):
+            self.conn_button = ui.button("Connect", on_click=self._connect)
+            self.disconn_button = ui.button("Disconnect", on_click=self._disconnect, )
+            self.disconn_button.disable()
+
+        self._initial_connect()
+
+    def _define_validation(self):
+        self.conn_input.validation = {"Please enter a connection string": bool}
+        self.key_input.validation = {"Invalid AES key": crypto_util.validate_key}
+
+    def _connect(self) -> None:
+        """Validate the connection string and encryption key
+        and connect to the database.
+        """
+        if not self.conn_input.validate() & self.key_input.validate():
+            ui.notify("Please fill out all fields.", type='warning')
+            return
+
+        conn_string = self.conn_input.value
+        crypto_key = self.key_input.value
+
+        if db_util.connect(conn_string):
+            crypto_util.set_key(crypto_key)
+            self._set_state(True)
+            ui.notify("Connected!", type='positive')
+
+    def _disconnect(self) -> None:
+        db_util.disconnect()
+        crypto_util.set_key(None)
+        self._set_state(False)
+        ui.notify("Disconnected!", type='positive')
+
+    def _set_state(self, connected: bool) -> None:
+        if connected:
+            self.conn_input.disable()
+            self.key_input.disable()
+            self.conn_button.disable()
+            self.disconn_button.enable()
+        else:
+            self.conn_input.enable()
+            self.key_input.enable()
+            self.conn_button.enable()
+            self.disconn_button.disable()
+
+    def _initial_connect(self) -> None:
+        """Check the environment for a connection string
+        and encryption key and connect to the database if both
+        are found.
+        """
+        conn_string = os.environ.get('OpenOrchestratorConnString', None)
+        if conn_string:
+            self.conn_input.value = conn_string
+
+        crypto_key = os.environ.get('OpenOrchestratorKey', None)
+        if crypto_key:
+            self.key_input.value = crypto_key
+
+    def new_key(self):
+        """Creates a new encryption key and inserts it
+        into the key entry.
+        """
+        key = crypto_util.generate_key()
+        self.key_input.value = key.decode()

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/common/crypto_util.py

@@ -3,9 +3,9 @@
 from cryptography.fernet import Fernet
 from cryptography.exceptions import InvalidSignature
 
-# The encryption key is a module wide variable used in
-# static functions. Linting is disabled on this.
-_encryption_key: str
+
+_encryption_key: str = None
+
 
 def generate_key() -> bytes:
     """Generates a new valid AES crypto key.
@@ -20,7 +20,7 @@ def set_key(key: str) -> None:
     """Set the crypto key for the module.
     The key will be used in all subsequent calls to this module.
     """
-    global _encryption_key # pylint: disable=global-statement
+    global _encryption_key  # pylint: disable=global-statement
     _encryption_key = key
 
 

OpenOrchestrator-1.2.0/OpenOrchestrator/common/datetime_util.py

@@ -0,0 +1,20 @@
+"""A module for performing common tasks regarding datetimes."""
+
+
+from datetime import datetime
+
+
+def format_datetime(datetime_: datetime, default: str = 'N/A') -> str:
+    """Format a datetime to a string.
+
+    Args:
+        datetime_: The datetime to format.
+        default: A default string to return if the datetime is None. Defaults to 'N/A'.
+
+    Returns:
+        A datetime string in the format %d-%m-%Y %H:%M:%S.
+    """
+    if not datetime_:
+        return default
+
+    return datetime_.strftime("%d-%m-%Y %H:%M:%S")

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/database/constants.py

@@ -5,9 +5,12 @@ from datetime import datetime
 from sqlalchemy import String, Engine
 from sqlalchemy.orm import Mapped, DeclarativeBase, mapped_column
 
+from OpenOrchestrator.common import datetime_util
+
 # All classes in this module are effectively dataclasses without methods.
 # pylint: disable=too-few-public-methods
 
+
 class Base(DeclarativeBase):
     """SqlAlchemy base class for all ORM classes in this module."""
 
@@ -20,13 +23,13 @@ class Constant(Base):
     value: Mapped[str] = mapped_column(String(1000))
     changed_at: Mapped[datetime] = mapped_column(onupdate=datetime.now, default=datetime.now)
 
-    def to_tuple(self) -> tuple:
-        """Convert the constant to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (self.name, self.value, self.changed_at)
+    def to_row_dict(self) -> dict[str, str]:
+        """Convert constant to a row dictionary for display in a table."""
+        return {
+            "Constant Name": self.name,
+            "Value": self.value,
+            "Last Changed": datetime_util.format_datetime(self.changed_at)
+        }
 
 
 class Credential(Base):
@@ -38,18 +41,21 @@ class Credential(Base):
     password: Mapped[str] = mapped_column(String(1000))
     changed_at: Mapped[datetime] = mapped_column(onupdate=datetime.now, default=datetime.now)
 
-    def to_tuple(self) -> tuple:
-        """Convert the credential to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.name,
-            self.username,
-            self.password,
-            self.changed_at
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        """Convert credential to a row dictionary for display in a table."""
+        return {
+            "Credential Name": self.name,
+            "Username": self.username,
+            "Password": self.format_password(),
+            "Last Changed": datetime_util.format_datetime(self.changed_at)
+        }
+
+    def format_password(self) -> str:
+        """Format the password to be shown in a table."""
+        length = len(self.password)
+        lower_length = int(((length-100)/20)*16)
+        upper_length = lower_length + 15
+        return f"{length} encrypted bytes. {lower_length}-{upper_length} decrypted bytes."
 
 
 def create_tables(engine: Engine):

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/database/db_util.py

@@ -1,9 +1,9 @@
 """This module handles the connection to the database in OpenOrchestrator."""
 
 from datetime import datetime
-from tkinter import messagebox
-from typing import Callable
+from typing import Callable, TypeVar, ParamSpec
 
+from croniter import croniter
 from sqlalchemy import Engine, create_engine, select, insert, desc
 from sqlalchemy import exc as alc_exc
 from sqlalchemy import func as alc_func
@@ -16,7 +16,11 @@ from OpenOrchestrator.database.constants import Constant, Credential
 from OpenOrchestrator.database.triggers import Trigger, SingleTrigger, ScheduledTrigger, QueueTrigger, TriggerStatus
 from OpenOrchestrator.database.queues import QueueElement, QueueStatus
 
-_connection_engine: Engine
+# Type hint helpers for decorators
+T = TypeVar("T")
+P = ParamSpec("P")
+
+_connection_engine: Engine = None
 
 
 def connect(conn_string: str) -> bool:
@@ -35,28 +39,27 @@ def connect(conn_string: str) -> bool:
         engine.connect()
         _connection_engine = engine
         return True
-    except alc_exc.InterfaceError as exc:
+    except (alc_exc.InterfaceError, alc_exc.ArgumentError, alc_exc.OperationalError):
         _connection_engine = None
-        messagebox.showerror("Connection failed", str(exc))
 
     return False
 
 
 def disconnect() -> None:
     """Disconnect from the database."""
-    global _connection_engine #pylint: disable=global-statement
+    global _connection_engine  # pylint: disable=global-statement
     _connection_engine.dispose()
     _connection_engine = None
 
 
-def catch_db_error(func: Callable) -> Callable:
+def catch_db_error(func: Callable[P, T]) -> Callable[P, T]:
     """A decorator that catches errors in SQL calls."""
-    def inner(*args, **kwargs):
-        try:
-            result = func(*args, **kwargs)
-        except alc_exc.ProgrammingError as exc:
-            messagebox.showerror("Error", f"Query failed:\n{exc}")
-        return result
+    def inner(*args, **kwargs) -> T:
+        if _connection_engine is None:
+            raise RuntimeError("Not connected to Database")
+
+        return func(*args, **kwargs)
+
     return inner
 
 
@@ -64,12 +67,14 @@ def get_conn_string() -> str:
     """Get the connection string.
 
     Returns:
-        str: The connection string.
+        str: The connection string if any.
     """
     try:
         return str(_connection_engine.url)
-    except AttributeError as exc:
-        raise RuntimeError("Unable to get the connection string from the database engine. Has the connection been established?") from exc
+    except AttributeError:
+        pass
+
+    return None
 
 
 @catch_db_error
@@ -79,7 +84,6 @@ def initialize_database() -> None:
     triggers.create_tables(_connection_engine)
     constants.create_tables(_connection_engine)
     queues.create_tables(_connection_engine)
-    messagebox.showinfo("Database initialized", "Database has been initialized!")
 
 
 @catch_db_error
@@ -101,6 +105,21 @@ def get_trigger(trigger_id: str) -> Trigger:
         return session.scalar(query)
 
 
+@catch_db_error
+def get_all_triggers() -> tuple[Trigger]:
+    """Get all triggers in the database.
+
+    Returns:
+        A tuple of Trigger objects.
+    """
+    with Session(_connection_engine) as session:
+        query = (
+            select(Trigger)
+            .options(selectin_polymorphic(Trigger, (ScheduledTrigger, QueueTrigger, SingleTrigger)))
+        )
+        return tuple(session.scalars(query))
+
+
 @catch_db_error
 def update_trigger(trigger: Trigger):
     """Updates an existing trigger in the database.
@@ -111,6 +130,7 @@ def update_trigger(trigger: Trigger):
     with Session(_connection_engine) as session:
         session.add(trigger)
         session.commit()
+        session.refresh(trigger)
 
 
 @catch_db_error
@@ -167,8 +187,8 @@ def delete_trigger(trigger_id: str) -> None:
 
 @catch_db_error
 def get_logs(offset: int, limit: int,
-             from_date: datetime|None, to_date: datetime|None,
-             process_name: str|None, log_level: LogLevel|None) -> tuple[Log]:
+             from_date: datetime = None, to_date: datetime = None,
+             process_name: str = None, log_level: LogLevel = None) -> tuple[Log]:
     """Get the logs from the database using filters and pagination.
 
     Args:
@@ -343,7 +363,7 @@ def get_constant(name: str) -> Constant:
 
     Returns:
         Constant: The constant with the given name.
-    
+
     Raises:
         ValueError: If no constant with the given name exists.
     """
@@ -418,7 +438,7 @@ def get_credential(name: str) -> Credential:
 
     Returns:
         Credential: The credential with the given name.
-    
+
     Raises:
         ValueError: If no credential with the given name exists.
     """
@@ -427,6 +447,7 @@ def get_credential(name: str) -> Credential:
 
     if credential is None:
         raise ValueError(f"No credential with name '{name}' was found.")
+
     credential.password = crypto_util.decrypt_string(credential.password)
     return credential
 
@@ -501,12 +522,12 @@ def delete_credential(name: str) -> None:
 
 @catch_db_error
 def begin_single_trigger(trigger_id: str) -> bool:
-    """Set the status of a single trigger to 'running' and 
+    """Set the status of a single trigger to 'running' and
     set the last run time to the current time.
 
     Args:
         trigger_id: The id of the trigger to begin.
-    
+
     Returns:
         bool: True if the trigger was 'idle' and now 'running'.
     """
@@ -560,15 +581,15 @@ def get_next_scheduled_trigger() -> ScheduledTrigger | None:
 
 
 @catch_db_error
-def begin_scheduled_trigger(trigger_id: str, next_run: datetime) -> bool:
-    """Set the status of a scheduled trigger to 'running', 
+def begin_scheduled_trigger(trigger_id: str) -> bool:
+    """Set the status of a scheduled trigger to 'running',
     set the last run time to the current time,
     and set the next run time to the given datetime.
 
     Args:
         trigger_id: The id of the trigger to begin.
         next_run: The next datetime the trigger should run.
-    
+
     Returns:
         bool: True if the trigger was 'idle' and now 'running'.
     """
@@ -580,7 +601,7 @@ def begin_scheduled_trigger(trigger_id: str, next_run: datetime) -> bool:
 
         trigger.process_status = TriggerStatus.RUNNING
         trigger.last_run = datetime.now()
-        trigger.next_run = next_run
+        trigger.next_run = croniter(trigger.cron_expr, datetime.now()).get_next(datetime)
 
         session.commit()
         return True
@@ -617,12 +638,12 @@ def get_next_queue_trigger() -> QueueTrigger | None:
 
 @catch_db_error
 def begin_queue_trigger(trigger_id: str) -> None:
-    """Set the status of a queue trigger to 'running' and 
+    """Set the status of a queue trigger to 'running' and
     set the last run time to the current time.
 
     Args:
         trigger_id: The id of the trigger to begin.
-    
+
     Returns:
         bool: True if the trigger was 'idle' and now 'running'.
     """
@@ -773,7 +794,7 @@ def get_queue_elements(queue_name: str, reference: str = None, status: QueueStat
         query = (
             select(QueueElement)
             .where(QueueElement.queue_name == queue_name)
-            .order_by(QueueElement.created_date)
+            .order_by(desc(QueueElement.created_date))
             .offset(offset)
             .limit(limit)
         )
@@ -787,6 +808,32 @@ def get_queue_elements(queue_name: str, reference: str = None, status: QueueStat
         return tuple(result)
 
 
+@catch_db_error
+def get_queue_count() -> dict[str, dict[QueueStatus, int]]:
+    """Count the number of queue elements of each status for every queue.
+
+    Returns:
+        A dict for each queue with the count for each status. E.g. result[queue_name][status] => count.
+    """
+    with Session(_connection_engine) as session:
+        query = (
+            select(QueueElement.queue_name, QueueElement.status, alc_func.count())  # pylint: disable=not-callable
+            .group_by(QueueElement.queue_name)
+            .group_by(QueueElement.status)
+        )
+        rows = session.execute(query)
+        rows = tuple(rows)
+
+    # Aggregate result into a dict
+    result = {}
+    for queue_name, status, count in rows:
+        if queue_name not in result:
+            result[queue_name] = {}
+        result[queue_name][status] = count
+
+    return result
+
+
 @catch_db_error
 def set_queue_element_status(element_id: str, status: QueueStatus, message: str = None) -> None:
     """Set the status of a queue element.

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/database/logs.py

@@ -7,9 +7,12 @@ import uuid
 from sqlalchemy import String, Engine
 from sqlalchemy.orm import Mapped, DeclarativeBase, mapped_column
 
+from OpenOrchestrator.common import datetime_util
+
 # All classes in this module are effectively dataclasses without methods.
 # pylint: disable=too-few-public-methods
 
+
 class LogLevel(enum.Enum):
     """An enum representing the level of logs."""
     TRACE = "Trace"
@@ -31,6 +34,16 @@ class Log(Base):
     process_name: Mapped[str] = mapped_column(String(100))
     log_message: Mapped[str] = mapped_column(String(8000))
 
+    def to_row_dict(self) -> dict[str, str]:
+        """Convert log to a row dictionary for display in a table."""
+        return {
+            "Log Time": datetime_util.format_datetime(self.log_time),
+            "Level": self.log_level.value,
+            "Process Name": self.process_name,
+            "Message": self.log_message,
+            "ID": str(self.id)
+        }
+
 
 def create_tables(engine: Engine):
     """Create all SQL tables related to ORM classes in this module.

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/database/queues.py

@@ -8,9 +8,12 @@ import uuid
 from sqlalchemy import String, Engine
 from sqlalchemy.orm import Mapped, DeclarativeBase, mapped_column
 
+from OpenOrchestrator.common import datetime_util
+
 # All classes in this module are effectively dataclasses without methods.
 # pylint: disable=too-few-public-methods
 
+
 class QueueStatus(enum.Enum):
     """An enum representing the status of a queue element."""
     NEW = 'New'
@@ -38,6 +41,20 @@ class QueueElement(Base):
     message: Mapped[Optional[str]] = mapped_column(String(1000))
     created_by: Mapped[Optional[str]] = mapped_column(String(100))
 
+    def to_row_dict(self) -> dict:
+        """Convert the object to a dict for display in a table."""
+        return {
+            "ID": self.id,
+            "Reference": self.reference,
+            "Status": self.status,
+            "Data": self.data,
+            "Created Date": datetime_util.format_datetime(self.created_date),
+            "Start Date": datetime_util.format_datetime(self.start_date),
+            "End Date": datetime_util.format_datetime(self.end_date),
+            "Message": self.message,
+            "Created By": self.created_by
+        }
+
 
 def create_tables(engine: Engine):
     """Create all SQL tables related to ORM classes in this module.

{OpenOrchestrator-1.0.2 → OpenOrchestrator-1.2.0}/OpenOrchestrator/database/triggers.py

@@ -8,6 +8,8 @@ import uuid
 from sqlalchemy import String, ForeignKey, Engine
 from sqlalchemy.orm import Mapped, DeclarativeBase, mapped_column
 
+from OpenOrchestrator.common import datetime_util
+
 # All classes in this module are effectively dataclasses without methods.
 # pylint: disable=too-few-public-methods
 
@@ -55,6 +57,17 @@ class Trigger(Base):
     def __repr__(self) -> str:
         return f"{self.trigger_name}: {self.type.value}"
 
+    def to_row_dict(self) -> dict[str, str]:
+        """Convert trigger to a row dictionary for display in a table."""
+        return {
+            "Trigger Name": self.trigger_name,
+            "Type": self.type.value,
+            "Status": self.process_status.value,
+            "Process Name": self.process_name,
+            "Last Run": datetime_util.format_datetime(self.last_run, "Never"),
+            "ID": str(self.id)
+        }
+
 
 class SingleTrigger(Trigger):
     """A class representing single trigger objects in the ORM."""
@@ -65,24 +78,10 @@ class SingleTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.SINGLE}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.last_run,
-            self.next_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = datetime_util.format_datetime(self.next_run)
+        return row_dict
 
 
 class ScheduledTrigger(Trigger):
@@ -95,25 +94,10 @@ class ScheduledTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.SCHEDULED}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.cron_expr,
-            self.last_run,
-            self.next_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = datetime_util.format_datetime(self.next_run)
+        return row_dict
 
 
 class QueueTrigger(Trigger):
@@ -126,25 +110,10 @@ class QueueTrigger(Trigger):
 
     __mapper_args__ = {"polymorphic_identity": TriggerType.QUEUE}
 
-    def to_tuple(self) -> tuple:
-        """Convert the trigger to a tuple of values.
-
-        Returns:
-            tuple: A tuple of all the triggers values.
-        """
-        return (
-            self.trigger_name,
-            self.process_status.value,
-            self.process_name,
-            self.queue_name,
-            self.min_batch_size,
-            self.last_run,
-            self.process_path,
-            self.process_args,
-            self.is_git_repo,
-            self.is_blocking,
-            self.id
-        )
+    def to_row_dict(self) -> dict[str, str]:
+        row_dict = super().to_row_dict()
+        row_dict["Next Run"] = "N/A"
+        return row_dict
 
 
 def create_tables(engine: Engine):