mbu-dev-shared-components 2.4.8__tar.gz → 3.0.0__tar.gz

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.8
+Version: 3.0.0
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT

mbu_dev_shared_components-3.0.0/mbu_dev_shared_components/database/__init__.py

@@ -0,0 +1,4 @@
+# mbu_dev_shared_components/database/__init__.py
+from .connection import RPAConnection
+
+__all__ = ["RPAConnection"]

mbu_dev_shared_components-3.0.0/mbu_dev_shared_components/database/connection.py

@@ -0,0 +1,49 @@
+"""Handles the RPA connection"""
+
+from .constants import Constants
+from .utility import Utility
+from .logging import Log
+
+
+class RPAConnection(
+    Constants,
+    Utility,
+    Log,
+):
+    """Class for running database related """
+    def __init__(self, db_env: str = "PROD", commit: bool | str = False):
+        Constants.__init__(self)
+        Utility.__init__(self)
+        Log.__init__(self)
+        self.db_env = db_env
+        self.commit = commit if isinstance(commit, bool) else commit == "True"
+        self.conn = None
+        self.cursor = None
+
+    def __enter__(self):
+        self.conn = self.connect_to_db(autocommit=False, db_env=self.db_env)
+        self.cursor = self.conn.cursor()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.commit:
+            print("Commiting transaction...")
+            self.conn.commit()
+        else:
+            print("Rolling back transaction....")
+            self.conn.rollback()
+        print("Closing conection...")
+        self.close()
+        print("Connection closed.")
+
+    def rollback(self):
+        """Rollback transaction on connection if autocommit is not enabled"""
+        if self.autocommit:
+            raise RuntimeError("Cannot rollback: autocommit is enabled.")
+        self.conn.rollback()
+
+    def close(self):
+        """Closes connection"""
+        self.cursor.close()
+        self.conn.close()

mbu_dev_shared_components-3.0.0/mbu_dev_shared_components/database/constants.py

@@ -0,0 +1,54 @@
+"""This module handles generating and fetching constants and credentials from the database"""
+
+from datetime import datetime
+
+from mbu_dev_shared_components.utils.fernet_encryptor import Encryptor
+
+
+class Constants:
+    """Base class for adding and collection constants and credentials"""
+
+    def add_constant(self, constant_name: str, value: str, changed_at: datetime = datetime.now()):
+        query = """
+            INSERT INTO [RPA].[rpa].[Constants] ([name], [value], [changed_at])
+            VALUES (?, ?, ?)
+        """
+        self.execute_query(query, [constant_name, value, changed_at])
+
+    def get_constant(self, constant_name: str) -> dict:
+        query = """
+            SELECT name, value FROM [RPA].[rpa].[Constants] WHERE name = ?
+        """
+        res = self.execute_query(query, [constant_name])
+        if res:
+            name, value = res[0]
+            return {"constant_name": name, "value": value}
+        raise ValueError(f"No constant found with name: {constant_name}")
+
+    def add_credential(self, credential_name: str, username: str, password: str,
+                       changed_at: datetime = datetime.now()):
+        encryptor = Encryptor()
+        encrypted_password = encryptor.encrypt(password)
+        query = """
+            INSERT INTO [RPA].[rpa].[Credentials] ([name], [username], [password], [changed_at])
+            VALUES (?, ?, ?, ?)
+        """
+        self.execute_query(query, [credential_name, username, encrypted_password, changed_at])
+
+    def get_credential(self, credential_name: str) -> dict:
+        encryptor = Encryptor()
+        query = """
+            SELECT username, CAST(password AS varbinary(max))
+            FROM [RPA].[rpa].[Credentials]
+            WHERE name = ?
+        """
+        res = self.execute_query(query, [credential_name])
+        if res:
+            username, encrypted_password = res[0]
+            decrypted_password = encryptor.decrypt(encrypted_password)
+            return {
+                "username": username,
+                "decrypted_password": decrypted_password,
+                "encrypted_password": encrypted_password
+            }
+        raise ValueError(f"No credential found with name {credential_name}")

mbu_dev_shared_components-3.0.0/mbu_dev_shared_components/database/logging.py

@@ -0,0 +1,139 @@
+"""This module handles logging in the RPA database"""
+
+from datetime import datetime
+import time
+import socket
+
+
+class Log:
+    """Base class for handling logging"""
+    def log_event(
+            self,
+            log_db: str,
+            level: str,
+            message: str,
+            context: str,
+    ):
+        """Logs the inputted parameters in """
+        created_at = datetime.now()
+        query = f"""
+            INSERT INTO RPA.{log_db}
+                ([level]
+                ,[message]
+                ,[created_at]
+                ,[context])
+            VALUES
+                (?
+                ,?
+                ,?
+                ,?)
+            """
+
+        params = [level, message, created_at, context]
+        self.execute_query(query=query, params=params)
+
+    def _get_log_event(
+            self,
+            log_db: str,
+            level: str,
+            message: str,
+            context: str,
+    ):
+        query = f"""
+            SELECT
+                ([level]
+                ,[message]
+                ,[created_at]
+                ,[context])
+            FROM
+                RPA.{log_db}
+            WHERE
+                level={level},
+                message={message},
+                context={context}
+            """
+
+        res = self.execute_query(query=query)
+        return res
+
+    def get_latest_log(
+            self,
+            log_db: str,
+    ):
+        """Retrieve latest log message from database"""
+        query = f"""
+            SELECT TOP (1)
+                [level]
+                ,[message]
+                ,[created_at]
+                ,[context]
+            FROM
+                RPA.{log_db}
+            ORDER BY
+                created_at desc
+            """
+
+        res = self.execute_query(query=query)
+        return res
+
+    def _send_heartbeat(
+            self,
+            servicename,
+            status,
+            details
+    ):
+        """Function to send heartbeat to database"""
+        hostname = socket.gethostname()
+        params = {
+            "ServiceName": (str, servicename),
+            "Status": (str, status),
+            "HostName": (str, hostname),
+            "Details": (str, details)
+        }
+        result = self.execute_stored_procedure(
+            stored_procedure='rpa.sp_UpdateHeartbeat',
+            params=params)
+        if result["success"] is not True:
+            print(result["error_message"])
+
+    def log_heartbeat(
+            self,
+            stop: str | bool,
+            servicename: str,
+            heartbeat_interval: int,
+            details: str = "",
+    ):
+        """Function to log heartbeat"""
+        # Update connection such that it autocommits
+        self.conn.autocommit = True  # Sets class attribute
+        if isinstance(stop, str):
+            stop = stop == "True"
+        if not isinstance(heartbeat_interval, int):
+            heartbeat_interval = int(heartbeat_interval)
+        while not stop:
+            status = "RUNNING"
+            self._send_heartbeat(
+                servicename,
+                status,
+                details,
+            )
+            time.sleep(heartbeat_interval)
+        status = "STOPPED"
+        self._send_heartbeat(
+            servicename,
+            status,
+            details,
+        )
+
+    def get_heartbeat(self, service_name: str):
+        """Get hearbeats """
+        query = f"""
+            SELECT
+                *
+            FROM
+                [RPA].[rpa].[ServiceHeartbeat]
+            WHERE
+                ServiceName = '{service_name}'
+        """
+        res = self.execute_query(query)
+        return res

mbu_dev_shared_components-3.0.0/mbu_dev_shared_components/database/utility.py

@@ -0,0 +1,109 @@
+"""This module handles general database connection and calls"""
+
+import os
+import json
+from typing import Dict, Union, Tuple, Any
+from dateutil import parser
+import pyodbc
+
+
+class Utility:
+    """Base class handling general utilities"""
+    def connect_to_db(self, autocommit=True, db_env="PROD") -> pyodbc.Connection:
+        """Establish connection to sql database
+
+        Returns:
+            rpa_conn (pyodbc.Connection): The connection object to the SQL database.
+        """
+        connection_env = self.fetch_env(db_env)
+        rpa_conn_string = os.getenv(connection_env)
+        rpa_conn = pyodbc.connect(rpa_conn_string, autocommit=autocommit)
+        return rpa_conn
+
+    def execute_query(self, query: str, params: list = None) -> pyodbc.Cursor:
+        """Execute SQL query with pyodbc"""
+        params = [] if not params else params
+        is_select = query.strip().upper().startswith('SELECT')
+        try:
+            res = self.cursor.execute(query, params)
+            if is_select:
+                res = self.cursor.fetchall()
+                if len(res) == 0:
+                    print("No results from query")
+                    return None
+                return res
+            else:
+                return None
+        except pyodbc.Error as e:
+            print(e)
+            print(query)
+            raise e
+
+    def fetch_env(self, db_env):
+        """Get env variable based on context, PROD or TEST"""
+        if db_env.upper() == "PROD":
+            connection_env = "DbConnectionString"
+            return connection_env
+        if db_env.upper() == "TEST":
+            connection_env = "DbConnectionStringTest"
+            return connection_env
+
+        raise ValueError(f"arg db_env is {db_env.upper()} but should be 'PROD' or 'TEST'")
+
+    def execute_stored_procedure(self, stored_procedure: str, params: Dict[str, Tuple[type, Any]] | None = None) -> Dict[str, Union[bool, str, Any]]:
+        """
+        Executes a stored procedure with the given parameters.
+
+        Args:
+            connection_string (str): The connection string to connect to the database.
+            stored_procedure (str): The name of the stored procedure to execute.
+            params (Dict[str, Tuple[type, Any]], optional): A dictionary of parameters to pass to the stored procedure.
+                                    Each value should be a tuple of (type, actual_value).
+
+        Returns:
+            Dict[str, Union[bool, str, Any]]: A dictionary containing the success status, an error message (if any),
+                                            number of affected rows, and additional data.
+        """
+        result = {
+            "success": False,
+            "error_message": None,
+        }
+
+        type_mapping = {
+            "str": str,
+            "int": int,
+            "float": float,
+            "datetime": parser.isoparse,
+            "json": lambda x: json.dumps(x, ensure_ascii=False)
+        }
+
+        try:
+            if params:
+                param_placeholders = ', '.join([f"@{key} = ?" for key in params.keys()])
+                param_values = []
+
+                for key, value in params.items():
+                    if isinstance(value, tuple) and len(value) == 2:
+                        value_type, actual_value = value
+                        if value_type in type_mapping:
+                            param_values.append(type_mapping[value_type](actual_value))
+                        else:
+                            param_values.append(actual_value)
+                    else:
+                        raise ValueError("Each parameter value must be a tuple of (type, actual_value).")
+
+                sql = f"EXEC {stored_procedure} {param_placeholders}"
+                rows_updated = self.cursor.execute(sql, tuple(param_values))
+            else:
+                sql = f"EXEC {stored_procedure}"
+                rows_updated = self.cursor.execute(sql)
+            result["success"] = True
+            result["rows_updated"] = rows_updated.rowcount
+        except pyodbc.Error as e:
+            result["error_message"] = f"Database error: {str(e)}"
+        except ValueError as e:
+            result["error_message"] = f"Value error: {str(e)}"
+        except Exception as e:
+            result["error_message"] = f"An unexpected error occurred: {str(e)}"
+
+        return result

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.0}/mbu_dev_shared_components/solteqtand/application/document.py

@@ -126,14 +126,6 @@ class DocumentHandler(HandlerBase):
             first_booking = controls[0]
             first_booking.RightClick(simulateMove=False, waitTime=0)
 
-            # list_bookings_group = self.wait_for_control(
-            #     auto.GroupControl,
-            #     {'AutomationId': 'GroupBoxView'},
-            #     search_depth=13,
-            # )
-            # group_bookings_list = list_bookings_group.GetChildren()[0].GetChildren()[1]
-            # group_bookings_list.RightClick(simulateMove=False, waitTime=0)
-
             pop_up_right_click_menu = self.wait_for_control(
                 auto.MenuControl,
                 {'Name': 'Kontekst'},

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.0}/mbu_dev_shared_components.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mbu_dev_shared_components
-Version: 2.4.8
+Version: 3.0.0
 Summary: Shared components to use in RPA projects
 Author-email: MBU <rpa@mbu.aarhus.dk>
 License-Expression: MIT

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.0}/mbu_dev_shared_components.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ mbu_dev_shared_components.egg-info/dependency_links.txt
 mbu_dev_shared_components.egg-info/requires.txt
 mbu_dev_shared_components.egg-info/top_level.txt
 mbu_dev_shared_components/database/__init__.py
+mbu_dev_shared_components/database/connection.py
 mbu_dev_shared_components/database/constants.py
 mbu_dev_shared_components/database/logging.py
 mbu_dev_shared_components/database/utility.py
@@ -53,4 +54,5 @@ mbu_dev_shared_components/utils/__init__.py
 mbu_dev_shared_components/utils/db_stored_procedure_executor.py
 mbu_dev_shared_components/utils/fernet_encryptor.py
 mbu_dev_shared_components/utils/file_handler.py
-mbu_dev_shared_components/utils/json_handler.py
+mbu_dev_shared_components/utils/json_handler.py
+tests/test_database.py

{mbu_dev_shared_components-2.4.8 → mbu_dev_shared_components-3.0.0}/pyproject.toml

@@ -2,13 +2,9 @@
 requires = ["setuptools>=65.0"]
 build-backend = "setuptools.build_meta"
 
-#[tool.setuptools]
-#package-dir = { "" = "." }
-#packages = ["mbu_dev_shared_components"]
-
 [project]
 name = "mbu_dev_shared_components"
-version = "2.4.8"  # Specify the version manually here
+version = "3.0.0"  # Specify the version manually here
 authors = [
   { name="MBU", email="rpa@mbu.aarhus.dk" },
 ]

mbu_dev_shared_components-3.0.0/tests/test_database.py

@@ -0,0 +1,319 @@
+"""
+Module to test RPAConnection functionalities in the Solteq Tand system
+
+Tested functionalities:
+
+    - Establish database connection:
+        Function:
+            RPAConnection.__enter__
+        Assertion:
+            Connection and cursor are not None
+        Dependencies:
+            None
+
+    - Add and retrieve constant:
+        Function:
+            RPAConnection.add_constant, RPAConnection.get_constant
+        Assertion:
+            Constant is correctly inserted and retrieved
+        Dependencies:
+            test_connection
+
+    - Add and retrieve credential:
+        Function:
+            RPAConnection.add_credential, RPAConnection.get_credential
+        Assertion:
+            Credential is correctly inserted and retrieved
+        Dependencies:
+            test_connection
+
+    - Rollback functionality:
+        Function:
+            RPAConnection.__exit__
+        Assertion:
+            Constant added without commit is not persisted
+        Dependencies:
+            test_connection, test_add_get_constant
+
+    - Log event:
+        Function:
+            RPAConnection.log_event, RPAConnection.get_latest_log
+        Assertion:
+            Log entry is correctly inserted and retrieved
+        Dependencies:
+            None
+
+    - Heartbeat logging (stop as string):
+        Function:
+            RPAConnection.log_heartbeat, RPAConnection.get_heartbeat
+        Assertion:
+            Heartbeat status is "STOPPED"
+        Dependencies:
+            None
+
+    - Heartbeat logging (stop as boolean):
+        Function:
+            RPAConnection.log_heartbeat, RPAConnection.get_heartbeat
+        Assertion:
+            Heartbeat status is "STOPPED"
+        Dependencies:
+            None
+
+    - Run heartbeat process:
+        Function:
+            External subprocess running heartbeat_worker.py
+        Assertion:
+            Heartbeat status is "RUNNING" and updates over time
+        Dependencies:
+            None
+
+Requirements:
+    - Database environment variable `TEST` must be configured
+    - pyodbc must be installed and accessible
+    - mbu_dev_shared_components must be available in PYTHONPATH
+    - `heartbeat_worker.py` must exist in the `tests/` directory and be executable
+    - `.venv/Scripts/python` must point to the correct Python interpreter
+Further description:
+    Each test uses the RPAConnection context manager to ensure proper handling of database transactions.
+    COMMIT is set to False to test rollback behavior and avoid persistent changes to the test database.
+    Heartbeat and logging tests validate time-sensitive operations with a threshold of 0.5 seconds.
+    The heartbeat process test (`test_run_heartbeat`) runs a parallel subprocess to simulate real-time heartbeat updates.
+"""
+
+from datetime import datetime, timedelta
+import time
+from uuid import uuid4
+import socket
+import subprocess
+
+import pyodbc
+import pytest
+from mbu_dev_shared_components.database.connection import RPAConnection  
+
+# Global test configuration
+DB_ENV = "TEST"
+COMMIT = False
+THRES_SEC = 0.5
+
+
+@pytest.mark.dependency()
+def test_connection():
+    """Test that RPAConnection successfully establishes a database connection
+
+    Verifies that the `conn` and `cursor` attributes are initialized and not None
+    after creating an instance of RPAConnection. Checks that 
+    """
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        # Assert connection is established
+        assert rpa_connection.conn is not None
+        assert rpa_connection.cursor is not None
+
+    # Assert connection is closed
+    with pytest.raises(pyodbc.ProgrammingError, match="Attempt to use a closed cursor."):
+        rpa_connection.get_constant("test_uuid")
+
+
+@pytest.mark.dependency(depends=["test_connection"])
+def test_add_get_constant():
+    """
+    Adds a test constant, rolls back the transaction.
+    """
+    test_constant_name = f"pytest_constant_{uuid4()}"
+    test_value = "temporary_value"
+
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        # Add constant (should be rolled back)
+        rpa_connection.add_constant(test_constant_name, test_value, datetime.now())
+
+        assert rpa_connection.cursor.rowcount == 1
+
+        # Check that constant is added (will be rolled back after function)
+        test_const = rpa_connection.get_constant(test_constant_name)
+
+        assert test_const
+        assert test_const["constant_name"] == test_constant_name
+        assert test_const["value"] == test_value
+
+
+@pytest.mark.dependency(depends=["test_connection"])
+def test_add_get_credential():
+    """
+    Adds a test credential, rolls back the transaction.
+    """
+    test_credential_name = f"pytest_constant_{uuid4()}"
+    test_username = "test_user"
+    test_password = "test_password"
+
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        # Add constant (should be rolled back)
+        rpa_connection.add_credential(test_credential_name, test_username, test_password, datetime.now())
+
+        # Check that constant is added (will be rolled back after function)
+        test_const = rpa_connection.get_credential(test_credential_name)
+
+        assert test_const
+        assert test_const["username"] == test_username
+        assert test_const["decrypted_password"] == test_password
+
+
+@pytest.mark.dependency(depends=["test_connection", "test_add_get_constant"])
+def test_rollback():
+    """
+    Test that rollback undoes the insertion of a constant through the context manager.
+    Asserts that a constant added in a scope without commiting to the db cannot be accessed outside the scope
+    """
+    test_constant_name = f"pytest_rollback_same_conn_{uuid4()}"
+    test_value = "temporary_value"
+
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        # Add constant
+        rpa_connection.add_constant(test_constant_name, test_value, datetime.now())
+
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        # Try to retrieve the constant in new connection
+        with pytest.raises(ValueError, match=f"No constant found with name: {test_constant_name}"):
+            rpa_connection.get_constant(test_constant_name)
+
+
+def test_log():
+    """Test log functionality """
+
+    # Variables for test log row
+    log_db = "journalizing.Journalize_log"
+    level = "INFO"
+    message = "test_log"
+    context = "pytest"
+
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        now = datetime.now()
+        # Attempt insertion of log_event
+        rpa_connection.log_event(
+            log_db=log_db,
+            level=level,
+            message=message,
+            context=context
+        )
+        # Assert that one row is inserted
+        assert rpa_connection.cursor.rowcount == 1
+
+        # Get latest log
+        # pylint: disable-next=W0212
+        log_row = rpa_connection.get_latest_log(
+            log_db=log_db
+        )[0]
+
+        # Assert values of inserted element
+        assert log_row[0] == level
+        assert log_row[1] == message
+        assert abs(log_row[2]-now) < timedelta(seconds=THRES_SEC)  # Latest log was within 0.1 second of start of function
+        assert log_row[3] == context
+
+
+def test_stop_heartbeat_str():
+    """Test stopping heartbeat functionality"""
+
+    servicename = "pytest"
+    heartbeat_interval = 1.0
+    details = "pytest testing heartbeat functionality"
+    stop = "True"
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        now = datetime.now()
+        rpa_connection.log_heartbeat(
+            stop=stop,
+            servicename=servicename,
+            heartbeat_interval=heartbeat_interval,
+            details=details
+        )
+
+        heartbeat = rpa_connection.get_heartbeat(service_name=servicename)[0]
+
+        assert heartbeat[0] == servicename
+        assert abs(heartbeat[1]-now) < timedelta(seconds=THRES_SEC)
+        assert heartbeat[2] == "STOPPED"
+        assert heartbeat[3] == socket.gethostname()
+
+
+def test_stop_heartbeat_bool():
+    """Test stopping heartbeat functionality"""
+
+    servicename = "pytest"
+    heartbeat_interval = 1.0
+    details = "pytest testing heartbeat functionality"
+    stop = True
+    with RPAConnection(db_env=DB_ENV, commit=COMMIT) as rpa_connection:
+        now = datetime.now()
+        rpa_connection.log_heartbeat(
+            stop=stop,
+            servicename=servicename,
+            heartbeat_interval=heartbeat_interval,
+            details=details
+        )
+
+        heartbeat = rpa_connection.get_heartbeat(service_name=servicename)[0]
+
+        assert heartbeat[0] == servicename
+        assert abs(heartbeat[1]-now) < timedelta(seconds=THRES_SEC)
+        assert heartbeat[2] == "STOPPED"
+        assert heartbeat[3] == socket.gethostname()
+
+
+def test_run_heartbeat():
+    """Test running heartbeat functionality
+    Uses subprocess to run the heartbeat process in parallel and allows to stop it after some time
+    Since we are using a stored procedure, we cannot roll back the transaction, so we have to accept the table being affected by the test
+    Effectively we insert one row to the heartbeat table for the 'pytest' service
+    """
+    servicename = "pytest"
+    heartbeat_interval = 2.0
+    details = "pytest testing heartbeat functionality"
+    stop = False
+    now = datetime.now()
+    heartbeat_process = subprocess.Popen(
+            [
+                ".venv/Scripts/python",
+                "tests/heartbeat_worker.py",
+                DB_ENV,
+                str(stop),
+                servicename,
+                str(heartbeat_interval),
+                details
+            ]
+        )
+
+    time.sleep(heartbeat_interval)
+
+    with RPAConnection(db_env="TEST", commit=False) as rpa_connection:
+        heartbeat = rpa_connection.get_heartbeat(servicename)[0]
+
+        # Assert heartbeat is running and recent
+        assert heartbeat[0] == servicename
+        assert abs(heartbeat[1]-now) < timedelta(seconds=THRES_SEC)
+        assert heartbeat[2] == "RUNNING"
+        assert heartbeat[3] == socket.gethostname()
+
+        # Test that heartbeat is updated by heartbeat interval time
+        for i in range(5):
+            print(f"Running assertion loop {i+1}")
+            prev_heartbeat_time = heartbeat[1]
+            time.sleep(heartbeat_interval)
+            # Get new heartbeat and assert that it is newer than previous hearbeat
+            heartbeat = rpa_connection.get_heartbeat(servicename)[0]
+            assert heartbeat[1] > prev_heartbeat_time, f"Heartbeat not updated on iteration {i+1}"
+
+    print("Should have finished assertion loop ")
+
+    heartbeat_process.terminate()
+
+    print("Should have terminated heartbeat process")
+
+    with RPAConnection(db_env="TEST", commit=True) as rpa_connection:
+        rpa_connection.log_heartbeat(
+            stop=True,
+            servicename=servicename,
+            heartbeat_interval=2,
+            details="Stop send from pytest"
+        )
+
+
+if __name__ == '__main__':
+    pytest.main([__file__])

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/constants.py

@@ -1,131 +0,0 @@
-"""This module handles generating and fetching constants and credentials from the database"""
-
-import os
-import pyodbc
-from datetime import datetime
-
-from mbu_dev_shared_components.utils.fernet_encryptor import Encryptor
-from mbu_dev_shared_components.database.utility import connect_to_db, execute_query
-
-
-def add_credential(
-        credential_name: str,
-        username: str,
-        password: str,
-        changed_at: datetime = datetime.now(),
-        db_env: str = "PROD"
-):
-    encryptor = Encryptor()
-    encrypted_password = encryptor.encrypt(password)
-
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    query = """
-        INSERT INTO [RPA].[rpa].[Credentials]
-            ([name]
-            ,[username]
-            ,[password]
-            ,[changed_at])
-        VALUES
-            (?
-            ,?
-            ,?
-            ,?)
-        """
-    params = [credential_name, username, encrypted_password, changed_at]
-    execute_query(query=query, cursor=cursor, params=params)
-
-
-def get_credential(
-        credential_name: str,
-        db_env: str = "PROD"
-    ) -> dict:
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-    encryptor = Encryptor()
-
-    query = """
-        SELECT 
-            Username
-            ,cast(Password as varbinary(max))
-        FROM [RPA].[rpa].[Credentials]
-        WHERE
-            name = ?
-        """
-    
-    params = [credential_name]
-
-    res = execute_query(query=query, cursor=cursor, params=params)
-    if res is not None:
-        res = res[0]
-        username = res[0]
-        encrypted_password = res[1]
-
-        decrypted_password = encryptor.decrypt(encrypted_password)
-
-        return  {
-            "username": username, 
-            "decrypted_password": decrypted_password, 
-            "encrypted_password": encrypted_password
-        } 
-    else:
-        print(f"No credential found with name {credential_name}")
-
-def get_constant(
-        constant_name: str,
-        db_env: str = "PROD"
-    ) -> tuple:
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-    encryptor = Encryptor()
-
-    query = """
-        SELECT 
-            name
-            ,value
-        FROM [RPA].[rpa].[Constants]
-        WHERE
-            name = ?
-        """
-    
-    params = [constant_name]
-
-    res = execute_query(query=query, cursor=cursor, params=params)
-    if res is not None:
-
-        returned_constant = res[0]
-        constant_name = returned_constant[0]
-        value = returned_constant[1]
-
-        return {"constant_name": constant_name, "value": value}
-    else:
-        print(f"No constant found with name: {constant_name}")
-
-
-def add_constant(
-        constant_name: str,
-        value: str,
-        changed_at: datetime = datetime.now(),
-        db_env: str = "PROD"
-):
-    query = """
-        INSERT INTO [RPA].[rpa].[Constants]
-            ([name]
-            ,[value]
-            ,[changed_at])
-        VALUES
-            (?
-            ,?
-            ,?)
-        """
-    
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    params = [constant_name, value, changed_at]
-    execute_query(query=query, cursor=cursor, params=params)
-
-

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/logging.py

@@ -1,86 +0,0 @@
-"""This module handles logging in the RPA database"""
-
-from datetime import datetime
-import time
-import os
-import socket
-
-from mbu_dev_shared_components.database.utility import execute_query, connect_to_db, fetch_env
-from mbu_dev_shared_components.utils.db_stored_procedure_executor import execute_stored_procedure
-
-def log_event(
-        log_db: str,
-        level: str, 
-        message: str, 
-        context: str, 
-        db_env="TEST"
-    ):
-    created_at = datetime.now()
-    """Logs the inputted parameters in """
-    query = f"""
-        INSERT INTO RPA.{log_db}
-            ([level]
-            ,[message]
-            ,[created_at]
-            ,[context])
-        VALUES
-            (?
-            ,?
-            ,?
-            ,?)
-        """
-    rpa_conn = connect_to_db(db_env=db_env)
-    cursor = rpa_conn.cursor()
-
-    params = [level, message, created_at, context]
-    execute_query(query=query, cursor=cursor, params=params)
-
-def _send_heartbeat(
-        servicename,
-        status,
-        details,
-        db_env,
-):
-    conn_env = fetch_env(db_env=db_env)
-    conn_str = os.getenv(conn_env)
-    hostname = socket.gethostname()
-    params = {
-        "ServiceName": (str, servicename), 
-        "Status": (str, status), 
-        "HostName": (str, hostname), 
-        "Details": (str, details)
-    }
-    result = execute_stored_procedure(
-        connection_string=conn_str,
-        stored_procedure='rpa.sp_UpdateHeartbeat',
-        params=params)
-    if result["success"] is not True:
-        print(result["error_message"])
-    
-def log_heartbeat(
-        stop: str|bool,
-        servicename: str,
-        heartbeat_interval: int,
-        details: str = "",
-        db_env: str = "PROD"
-    ):
-    if isinstance(stop,str):
-        stop = stop == "True"
-    if not isinstance(heartbeat_interval, int):
-        heartbeat_interval = int(heartbeat_interval)
-    while not stop:
-        status = "RUNNING"
-        _send_heartbeat(
-            servicename,
-            status,
-            details,
-            db_env,
-        )
-        time.sleep(heartbeat_interval)
-    status = "STOPPED"
-    _send_heartbeat(
-        servicename,
-        status,
-        details,
-        db_env,
-    )

mbu_dev_shared_components-2.4.8/mbu_dev_shared_components/database/utility.py

@@ -1,44 +0,0 @@
-"""This module handles general database connection and calls"""
-
-import os
-import pyodbc
-from datetime import datetime
-
-def connect_to_db(autocommit=True, db_env="PROD") -> pyodbc.Connection:
-    """Establish connection to sql database
-
-    Returns:
-        rpa_conn (pyodbc.Connection): The connection object to the SQL database.
-    """
-    connection_env = fetch_env(db_env)
-    rpa_conn_string = os.getenv(connection_env)
-    rpa_conn = pyodbc.connect(rpa_conn_string, autocommit=autocommit)
-    return rpa_conn
-
-def execute_query(query: str, cursor: pyodbc.Cursor, params: list) -> pyodbc.Cursor:
-    is_select = query.strip().upper().startswith('SELECT')
-    try:
-        res = cursor.execute(query, params)
-        if is_select:
-            res = cursor.fetchall()
-            if len(res) == 0:
-                print("No results from query")
-                return None
-            return res
-        else:
-            return None
-    except pyodbc.Error as e:
-        print(e)
-    finally:
-        cursor.close()
-
-
-def fetch_env(db_env):
-    if db_env.upper() == "PROD":
-        connection_env = "DbConnectionString"
-        return connection_env
-    if db_env.upper() == "TEST":
-        connection_env = "DbConnectionStringTest"
-        return connection_env
-    
-    raise ValueError(f"arg db_env is {db_env.upper()} but should be 'PROD' or 'TEST'")