OpenOrchestrator 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

OpenOrchestrator/orchestrator/popups/generic_popups.py

@@ -0,0 +1,27 @@
+"""This module contains functions to generate generic popups for various use cases."""
+
+from nicegui import ui
+
+
+async def question_popup(question: str, option1: str, option2: str, color1: str = 'primary', color2: str = 'primary') -> bool:
+    """Shows a popup with a question and two buttons with the given options.
+    Example:
+        result = await question_popup("Do you like candy", "YES!", "Not really")
+
+    Args:
+        question: The question to display.
+        option1: The text on button 1.
+        option2: The text on button 2.
+        color1: The color of button 1.
+        color2: The color of button 2.
+
+    Returns:
+        bool: True if button 1 is clicked, or False if button 2 is clicked.
+    """
+    with ui.dialog(value=True).props('persistent') as dialog, ui.card():
+        ui.label(question).classes("text-lg")
+        with ui.row():
+            ui.button(option1, on_click=lambda e: dialog.submit(True), color=color1)
+            ui.button(option2, on_click=lambda e: dialog.submit(False), color=color2)
+
+        return await dialog

OpenOrchestrator/orchestrator/popups/trigger_popup.py

@@ -0,0 +1,216 @@
+"""This module is responsible for the layout and functionality of the 'New single Trigger' popup."""
+
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from datetime import datetime
+
+from nicegui import ui
+from croniter import croniter, CroniterBadCronError
+
+from OpenOrchestrator.orchestrator.datetime_input import DatetimeInput
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.triggers import Trigger, TriggerStatus, TriggerType
+from OpenOrchestrator.orchestrator.popups import generic_popups
+
+if TYPE_CHECKING:
+    from OpenOrchestrator.orchestrator.tabs.trigger_tab import TriggerTab
+
+
+# pylint: disable-next=(too-many-instance-attributes, too-few-public-methods)
+class TriggerPopup():
+    """A popup for creating/updating triggers."""
+    def __init__(self, trigger_tab: TriggerTab, trigger_type: TriggerType, trigger: Trigger = None):
+        """Create a new popup.
+        If a trigger is given it will be updated instead of creating a new trigger.
+
+        Args:
+            trigger_tab: The tab parent of the popup.
+            trigger_type: The type of trigger popup to show.
+            trigger: The Trigger to update if any.
+        """
+        self.trigger_tab = trigger_tab
+        self.trigger_type = trigger_type
+        self.trigger = trigger
+        title = f'Update {trigger_type.value} Trigger' if trigger else f'New {trigger_type.value} Trigger'
+
+        with ui.dialog(value=True) as self.dialog, ui.card().classes('w-full'):
+            ui.label(title).classes("text-xl")
+            self.trigger_input = ui.input("Trigger Name").classes("w-full")
+            self.name_input = ui.input("Process Name").classes("w-full")
+            self.cron_input = ui.input("Cron expression", on_change=self._cron_change).classes("w-full")  # For scheduled triggers
+            self.time_input = DatetimeInput("Trigger Time")  # For scheduled/single triggers
+            with self.cron_input:
+                with ui.link(target="https://crontab.guru/", new_tab=True):
+                    with ui.button(icon="help").props("flat dense"):
+                        ui.tooltip("Help with cron: https://crontab.guru/")
+            self.queue_input = ui.input("Queue Name").classes("w-full")  # For queue triggers
+            self.batch_input = ui.number("Min Batch Size", value=1, min=1, precision=0, format="%.0f")  # For queue triggers
+            self.path_input = ui.input("Process Path").classes("w-full")
+            self.git_check = ui.checkbox("Is path a Git Repo?")
+            self.args_input = ui.input("Process Arguments").classes("w-full")
+            self.blocking_check = ui.checkbox("Is process blocking?")
+
+            if trigger:
+                with ui.row():
+                    ui.button("Enable", on_click=self._enable_trigger)
+                    ui.button("Disable", on_click=self._disable_trigger)
+                    ui.button("Delete", on_click=self._delete_trigger, color='red')
+            else:
+                # Dialog should only be persistent when a new trigger is being created
+                self.dialog.props('persistent')
+
+            with ui.row():
+                ui.button("Save", on_click=self._create_trigger)
+                ui.button("Cancel", on_click=self.dialog.close)
+
+        self._disable_unused()
+        self._define_validation()
+
+        if trigger:
+            self._pre_populate()
+
+    def _define_validation(self):
+        self.trigger_input.validation = {"Please enter a trigger name": bool}
+        self.name_input.validation = {"Please enter a process name": bool}
+        self.path_input.validation = {"Please enter a process path": bool}
+        self.queue_input.validation = {"Please enter a queue name": bool}
+
+        def validate_cron(value: str):
+            try:
+                croniter(value)
+                return True
+            except CroniterBadCronError:
+                return False
+
+        self.cron_input.validation = {"Invalid cron expression": validate_cron}
+
+    def _pre_populate(self):
+        """Populate the form with values from an existing trigger"""
+        self.trigger_input.value = self.trigger.trigger_name
+        self.name_input.value = self.trigger.process_name
+        self.path_input.value = self.trigger.process_path
+        self.args_input.value = self.trigger.process_args
+        self.git_check.value = self.trigger.is_git_repo
+        self.blocking_check.value = self.trigger.is_blocking
+
+        if self.trigger_type == TriggerType.SCHEDULED:
+            self.cron_input.value = self.trigger.cron_expr
+
+        if self.trigger_type in (TriggerType.SINGLE, TriggerType.SCHEDULED):
+            self.time_input.set_datetime(self.trigger.next_run)
+
+        if self.trigger_type == TriggerType.QUEUE:
+            self.queue_input.value = self.trigger.queue_name
+            self.batch_input.value = self.trigger.min_batch_size
+
+    def _disable_unused(self):
+        """Disable all inputs that aren't being used by the current trigger type."""
+        if self.trigger_type == TriggerType.QUEUE:
+            self.time_input.visible = False
+
+        if self.trigger_type != TriggerType.SCHEDULED:
+            self.cron_input.visible = False
+
+        if self.trigger_type != TriggerType.QUEUE:
+            self.queue_input.visible = False
+            self.batch_input.visible = False
+
+    def _cron_change(self):
+        if self.cron_input.validate():
+            cron_iter = croniter(self.cron_input.value, datetime.now())
+            self.time_input.set_datetime(cron_iter.next(datetime))
+
+    async def _validate(self) -> bool:
+        result = True
+
+        result &= self.trigger_input.validate()
+        result &= self.name_input.validate()
+        result &= self.path_input.validate()
+
+        if self.trigger_type in (TriggerType.SINGLE, TriggerType.SCHEDULED):
+            result &= self.time_input.validate()
+
+            next_run = self.time_input.get_datetime()
+            if next_run and next_run < datetime.now():
+                result &= await generic_popups.question_popup(
+                        "The selected datetime is in the past. Do you want to create the trigger anyway?",
+                        "Create", "Cancel")
+
+        if self.trigger_type == TriggerType.SCHEDULED:
+            result &= self.cron_input.validate()
+
+        if self.trigger_type == TriggerType.QUEUE:
+            result &= self.queue_input.validate()
+
+        return result
+
+    async def _create_trigger(self):
+        """Creates a new single trigger in the database using the data entered in the UI.
+        If an existing trigger was given when creating the popup it is updated instead.
+        """
+        if not await self._validate():
+            ui.notify("Please fill out required information.", type='warning')
+            return
+
+        trigger_name = self.trigger_input.value
+        process_name = self.name_input.value
+        next_run = self.time_input.get_datetime()
+        cron_expr = self.cron_input.value
+        queue_name = self.queue_input.value
+        min_batch_size = self.batch_input.value
+        path = self.path_input.value
+        args = self.args_input.value
+        is_git = self.git_check.value
+        is_blocking = self.blocking_check.value
+
+        if self.trigger is None:
+            # Create new trigger in database
+            if self.trigger_type == TriggerType.SINGLE:
+                db_util.create_single_trigger(trigger_name, process_name, next_run, path, args, is_git, is_blocking)
+            elif self.trigger_type == TriggerType.SCHEDULED:
+                db_util.create_scheduled_trigger(trigger_name, process_name, cron_expr, next_run, path, args, is_git, is_blocking)
+            elif self.trigger_type == TriggerType.QUEUE:
+                db_util.create_queue_trigger(trigger_name, process_name, queue_name, path, args, is_git, is_blocking, min_batch_size)
+
+            ui.notify("Trigger created", type='positive')
+        else:
+            # Update existing trigger
+            self.trigger.trigger_name = trigger_name
+            self.trigger.process_name = process_name
+            self.trigger.next_run = next_run
+            self.trigger.process_path = path
+            self.trigger.process_args = args
+            self.trigger.is_git_repo = is_git
+            self.trigger.is_blocking = is_blocking
+
+            if self.trigger_type == TriggerType.SINGLE:
+                self.trigger.next_run = next_run
+            elif self.trigger_type == TriggerType.SCHEDULED:
+                self.trigger.cron_expr = cron_expr
+                self.trigger.next_run = next_run
+            elif self.trigger_type == TriggerType.QUEUE:
+                self.trigger.queue_name = queue_name
+                self.trigger.min_batch_size = min_batch_size
+
+            db_util.update_trigger(self.trigger)
+            ui.notify("Trigger updated", type='positive')
+
+        self.dialog.close()
+        self.trigger_tab.update()
+
+    async def _delete_trigger(self):
+        if await generic_popups.question_popup(f"Delete trigger '{self.trigger.trigger_name}'?", "Delete", "Cancel", color1='red'):
+            db_util.delete_trigger(self.trigger.id)
+            ui.notify("Trigger deleted", type='positive')
+            self.dialog.close()
+            self.trigger_tab.update()
+
+    def _disable_trigger(self):
+        db_util.set_trigger_status(self.trigger.id, TriggerStatus.PAUSED)
+        ui.notify("Trigger status set to 'Paused'.", type='positive')
+        self.trigger_tab.update()
+
+    def _enable_trigger(self):
+        db_util.set_trigger_status(self.trigger.id, TriggerStatus.IDLE)
+        ui.notify("Trigger status set to 'Idle'.", type='positive')
+        self.trigger_tab.update()

OpenOrchestrator/orchestrator/tabs/constants_tab.py

@@ -0,0 +1,52 @@
+"""This module is responsible for the layout and functionality of the Constants tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.orchestrator.popups.constant_popup import ConstantPopup
+from OpenOrchestrator.orchestrator.popups.credential_popup import CredentialPopup
+
+CONSTANT_COLUMNS = ("Constant Name", "Value", "Last Changed")
+CREDENTIAL_COLUMNS = ("Credential Name", "Username", "Password", "Last Changed")
+
+
+class ConstantTab():
+    """The 'Constants' tab object."""
+    def __init__(self, tab_name: str) -> None:
+        with ui.tab_panel(tab_name):
+            with ui.row():
+                ui.button("New Constant", icon='add', on_click=lambda e: ConstantPopup(self))
+                ui.button("New Credential", icon='add', on_click=lambda e: CredentialPopup(self))
+
+            columns = [{'name': label, 'label': label, 'field': label, 'align': 'left', 'sortable': True} for label in CONSTANT_COLUMNS]
+            self.constants_table = ui.table(title="Constants", columns=columns, rows=[], row_key='Constant Name', pagination=10).classes("w-full")
+            self.constants_table.on('rowClick', self.row_click_constant)
+
+            columns = [{'name': label, 'label': label, 'field': label, 'align': 'left', 'sortable': True} for label in CREDENTIAL_COLUMNS]
+            self.credentials_table = ui.table(title="Credentials", columns=columns, rows=[], row_key='Credential Name', pagination=10).classes("w-full")
+            self.credentials_table.on('rowClick', self.row_click_credential)
+
+    def row_click_constant(self, event):
+        """Callback for when a row is clicked in the table."""
+        row = event.args[1]
+        name = row['Constant Name']
+        constant = db_util.get_constant(name)
+        ConstantPopup(self, constant)
+
+    def row_click_credential(self, event):
+        """Callback for when a row is clicked in the table."""
+        row = event.args[1]
+        name = row['Credential Name']
+        credential = db_util.get_credential(name)
+        CredentialPopup(self, credential)
+
+    def update(self):
+        """Updates the tables on the tab."""
+        constants = db_util.get_constants()
+        self.constants_table.rows = [c.to_row_dict() for c in constants]
+        self.constants_table.update()
+
+        credentials = db_util.get_credentials()
+        self.credentials_table.rows = [c.to_row_dict() for c in credentials]
+        self.credentials_table.update()

OpenOrchestrator/orchestrator/tabs/logging_tab.py

@@ -0,0 +1,70 @@
+"""This module is responsible for the layout and functionality of the Logging tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.orchestrator.datetime_input import DatetimeInput
+
+
+COLUMNS = (
+    {'name': "Log Time", 'label': "Log Time", 'field': "Log Time", 'align': 'left', 'sortable': True},
+    {'name': "Process Name", 'label': "Process Name", 'field': "Process Name", 'align': 'left'},
+    {'name': "Level", 'label': "Level", 'field': "Level", 'align': 'left'},
+    {'name': "Message", 'label': "Message", 'field': "Message", 'align': 'left', ':format': 'value => value.length < 100 ? value : value.substring(0, 100)+"..."'},
+    {'name': "ID", 'label': "ID", 'field': "ID", 'headerClasses': 'hidden', 'classes': 'hidden'}
+)
+
+
+# pylint: disable-next=too-few-public-methods
+class LoggingTab():
+    """The 'Logs' tab object."""
+    def __init__(self, tab_name: str) -> None:
+        with ui.tab_panel(tab_name):
+            with ui.row():
+                self.from_input = DatetimeInput("From Date", on_change=self.update, allow_empty=True)
+                self.to_input = DatetimeInput("To Date", on_change=self.update, allow_empty=True)
+                self.process_input = ui.select(["All"], label="Process Name", value="All", on_change=self.update).classes("w-48")
+                self.level_input = ui.select(["All", "Trace", "Info", "Error"], value="All", label="Level", on_change=self.update).classes("w-48")
+                self.limit_input = ui.select([100, 200, 500, 1000], value=100, label="Limit", on_change=self.update).classes("w-24")
+
+            self.logs_table = ui.table(title="Logs", columns=COLUMNS, rows=[], row_key='ID', pagination=50).classes("w-full")
+            self.logs_table.on("rowClick", self._row_click)
+
+    def update(self):
+        """Update the logs table and Process input list"""
+        self._update_table()
+        self._update_process_input()
+
+    def _update_table(self):
+        """Update the table with logs from the database applying the filters."""
+        from_date = self.from_input.get_datetime()
+        to_date = self.to_input.get_datetime()
+        process_name = self.process_input.value if self.process_input.value != 'All' else None
+        level = self.level_input.value if self.level_input.value != "All" else None
+        limit = self.limit_input.value
+
+        logs = db_util.get_logs(0, limit=limit, from_date=from_date, to_date=to_date, log_level=level, process_name=process_name)
+        self.logs_table.rows = [log.to_row_dict() for log in logs]
+
+    def _update_process_input(self):
+        """Update the process input with names from the database."""
+        process_names = list(db_util.get_unique_log_process_names())
+        process_names.insert(0, "All")
+        self.process_input.options = process_names
+        self.process_input.update()
+
+    def _row_click(self, event):
+        """Display a dialog with info on the clicked log."""
+        row = event.args[1]
+        with ui.dialog(value=True), ui.card():
+            ui.label("Log ID:").classes("font-bold")
+            ui.label(row['ID'])
+            ui.label("Log Time:").classes("font-bold")
+            ui.label(row['Log Time'])
+            ui.label("Process Name:").classes("font-bold")
+            ui.label(row['Process Name'])
+            ui.label("Log Level:").classes("font-bold")
+            ui.label(row['Level'])
+            ui.label("Message:").classes("font-bold")
+            ui.html(f"<pre>{row['Message']}</pre>")

OpenOrchestrator/orchestrator/tabs/queue_tab.py

@@ -0,0 +1,116 @@
+"""This module is responsible for the layout and functionality of the Queues tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.queues import QueueStatus
+
+
+QUEUE_COLUMNS = (
+    {'name': "Queue Name", 'label': "Queue Name", 'field': "Queue Name", 'align': 'left', 'sortable': True},
+    {'name': "New", 'label': "New", 'field': "New", 'align': 'left', 'sortable': True},
+    {'name': "In Progress", 'label': "In Progress", 'field': "In Progress", 'align': 'left', 'sortable': True},
+    {'name': "Done", 'label': "Done", 'field': "Done", 'align': 'left', 'sortable': True},
+    {'name': "Failed", 'label': "Failed", 'field': "Failed", 'align': 'left', 'sortable': True}
+)
+
+ELEMENT_COLUMNS = (
+    {'name': "Reference", 'label': "Reference", 'field': "Reference", 'align': 'left', 'sortable': True},
+    {'name': "Status", 'label': "Status", 'field': "Status", 'align': 'left', 'sortable': True},
+    {'name': "Data", 'label': "Data", 'field': "Data", 'align': 'left', 'sortable': True},
+    {'name': "Message", 'label': "Message", 'field': "Message", 'align': 'left', 'sortable': True},
+    {'name': "Created Date", 'label': "Created Date", 'field': "Created Date", 'align': 'left', 'sortable': True},
+    {'name': "Start Date", 'label': "Start Date", 'field': "Start Date", 'align': 'left', 'sortable': True},
+    {'name': "End Date", 'label': "End Date", 'field': "End Date", 'align': 'left', 'sortable': True},
+    {'name': "Created By", 'label': "Created By", 'field': "Created By", 'align': 'left', 'sortable': True},
+    {'name': "ID", 'label': "ID", 'field': "ID", 'align': 'left', 'sortable': True}
+)
+
+
+# pylint: disable-next=too-few-public-methods
+class QueueTab():
+    """The 'Queues' tab object. It contains tables and buttons for dealing with queues."""
+    def __init__(self, tab_name: str) -> None:
+        with ui.tab_panel(tab_name):
+            self.queue_table = ui.table(title="Queues", columns=QUEUE_COLUMNS, rows=[], row_key='Queue Name', pagination=50).classes("w-full")
+            self.queue_table.on("rowClick", self._row_click)
+
+    def update(self):
+        """Update the queue table with data from the database."""
+        queue_count = db_util.get_queue_count()
+
+        # Convert queue count to row elements
+        rows = []
+        for queue_name, count in queue_count.items():
+            row = {
+                "Queue Name": queue_name,
+                "New": count.get(QueueStatus.NEW, 0),
+                "In Progress": count.get(QueueStatus.IN_PROGRESS, 0),
+                "Done": count.get(QueueStatus.DONE, 0),
+                "Failed": count.get(QueueStatus.FAILED, 0)
+            }
+            rows.append(row)
+
+        self.queue_table.update_rows(rows)
+
+    def _row_click(self, event):
+        row = event.args[1]
+        queue_name = row["Queue Name"]
+        QueuePopup(queue_name)
+
+
+# pylint: disable-next=too-few-public-methods
+class QueuePopup():
+    """A popup that displays queue elements in a queue."""
+    def __init__(self, queue_name) -> None:
+        self.queue_name = queue_name
+
+        with ui.dialog(value=True).props('full-width full-height') as dialog, ui.card():
+            with ui.row().classes("w-full"):
+                self._create_column_filter()
+
+                self.limit_select = ui.select(
+                    options=[100, 200, 500, 1000, "All"],
+                    label="Limit",
+                    value=100,
+                    on_change=self._update).classes("w-24")
+
+                ui.switch("Dense", on_change=lambda e: self._dense_table(e.value))
+
+                ui.space()
+                ui.button(icon='refresh', on_click=self._update)
+                ui.button(icon="close", on_click=dialog.close)
+            with ui.scroll_area().classes("h-full"):
+                self.table = ui.table(columns=ELEMENT_COLUMNS, rows=[], row_key='ID', title=queue_name, pagination=100).classes("w-full")
+
+        self._update()
+
+    def _dense_table(self, value: bool):
+        """Change if the table is dense or not."""
+        if value:
+            self.table.props("dense")
+        else:
+            self.table.props(remove="dense")
+
+    def _create_column_filter(self):
+        """Create a menu with switches for toggling columns on and off."""
+        def toggle(column: dict, visible: bool) -> None:
+            column['classes'] = '' if visible else 'hidden'
+            column['headerClasses'] = '' if visible else 'hidden'
+            self.table.update()
+
+        with ui.button("Columns", icon="menu"):
+            with ui.menu(), ui.column().classes('gap-0 p-2'):
+                for column in ELEMENT_COLUMNS:
+                    ui.switch(column['label'], value=True, on_change=lambda e, column=column: toggle(column, e.value))
+
+    def _update(self):
+        """Update the table with values from the database."""
+        limit = self.limit_select.value
+        if limit == 'All':
+            limit = 1_000_000_000
+
+        queue_elements = db_util.get_queue_elements(self.queue_name, limit=limit)
+        rows = [element.to_row_dict() for element in queue_elements]
+        self.table.update_rows(rows)

OpenOrchestrator/orchestrator/tabs/settings_tab.py

@@ -0,0 +1,22 @@
+"""This module is responsible for the layout and functionality of the Settings tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.common.connection_frame import ConnectionFrame
+
+
+# pylint: disable-next=too-few-public-methods
+class SettingsTab():
+    """The settings tab object for Orchestrator."""
+    def __init__(self, tab: ui.tab) -> None:
+        with ui.tab_panel(tab):
+            conn_frame = ConnectionFrame()
+            with ui.row().classes("w-full"):
+                self.key_button = ui.button("Generate Key", on_click=conn_frame.new_key)
+                self.init_button = ui.button("Initialize Database", on_click=self._init_database)
+
+    def _init_database(self):
+        db_util.initialize_database()
+        ui.notify("Database initialized!", type='positive')

OpenOrchestrator/orchestrator/tabs/trigger_tab.py

@@ -0,0 +1,87 @@
+"""This module is responsible for the layout and functionality of the Trigger tab
+in Orchestrator."""
+
+from nicegui import ui
+
+from OpenOrchestrator.database import db_util
+from OpenOrchestrator.database.triggers import SingleTrigger, ScheduledTrigger, QueueTrigger, TriggerType
+from OpenOrchestrator.orchestrator.popups.trigger_popup import TriggerPopup
+
+COLUMNS = ("Trigger Name", "Type", "Status", "Process Name", "Last Run", "Next Run", "ID")
+
+COLUMNS = (
+    {'name': "Trigger Name", 'label': "Trigger Name", 'field': "Trigger Name", 'align': 'left', 'sortable': True},
+    {'name': "Type", 'label': "Type", 'field': "Type", 'align': 'left', 'sortable': True},
+    {'name': "Status", 'label': "Status", 'field': "Status", 'align': 'left', 'sortable': True},
+    {'name': "Process Name", 'label': "Process Name", 'field': "Process Name", 'align': 'left', 'sortable': True},
+    {'name': "Last Run", 'label': "Last Run", 'field': "Last Run", 'align': 'left', 'sortable': True},
+    {'name': "Next_Run", 'label': "Next Run", 'field': "Next Run", 'align': 'left', 'sortable': True},
+    {'name': "ID", 'label': "ID", 'field': "ID", 'align': 'left', 'sortable': True}
+)
+
+
+# pylint disable-next=too-few-public-methods
+class TriggerTab():
+    """The 'Trigger' tab object. It contains tables and buttons for dealing with triggers."""
+    def __init__(self, tab_name: str) -> None:
+        with ui.tab_panel(tab_name):
+            with ui.row():
+                ui.button("New Single Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SINGLE))
+                ui.button("New Scheduled Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.SCHEDULED))
+                ui.button("New Queue Trigger", icon="add", on_click=lambda e: TriggerPopup(self, TriggerType.QUEUE))
+
+            self.trigger_table = ui.table(COLUMNS, [], title="Triggers", pagination=50, row_key='ID').classes("w-full")
+            self.trigger_table.on('rowClick', self._row_click)
+
+            self.add_column_colors()
+
+    def _row_click(self, event):
+        """Callback for when a row is clicked in the table."""
+        row = event.args[1]
+        trigger_id = row["ID"]
+        trigger = db_util.get_trigger(trigger_id)
+
+        if isinstance(trigger, SingleTrigger):
+            TriggerPopup(self, TriggerType.SINGLE, trigger)
+        elif isinstance(trigger, ScheduledTrigger):
+            TriggerPopup(self, TriggerType.SCHEDULED, trigger)
+        elif isinstance(trigger, QueueTrigger):
+            TriggerPopup(self, TriggerType.QUEUE, trigger)
+
+    def update(self):
+        """Updates the tab and it's data."""
+        triggers = db_util.get_all_triggers()
+        self.trigger_table.rows = [t.to_row_dict() for t in triggers]
+        self.trigger_table.update()
+
+    def add_column_colors(self):
+        """Add custom coloring to the trigger table."""
+        # Add coloring to the status column
+        self.trigger_table.add_slot(
+            "body-cell-Status",
+            '''
+            <q-td key="Status" :props="props">
+                <q-badge v-if="{Running: 'green', Failed: 'red'}[props.value]" :color="{Running: 'green', Failed: 'red'}[props.value]">
+                    {{props.value}}
+                </q-badge>
+                <p v-else>
+                    {{props.value}}
+                </p>
+            </q-td>
+            '''
+        )
+
+        # Add coloring to 'Next run' column
+        # If the next run is in the past the value should be red.
+        # Use a very ugly parser to create a date from a dd-MM-yyyy HH:mm:ss date string.
+        self.trigger_table.add_slot(
+            "body-cell-Next_Run",
+            '''
+            <q-td key="Next_Run" :props="props">
+                {{props.value}}
+                <q-badge v-if="new Date(+props.value.substr(6,4), +props.value.substr(3,2)-1, +props.value.substr(0,2), +props.value.substr(11,2), +props.value.substr(14,2)) < new Date()" color='red'>
+                    Overdue
+                </q-badge>
+            </q-td>
+            '''
+        )

OpenOrchestrator/scheduler/application.py

@@ -5,6 +5,7 @@ import tkinter
 from tkinter import ttk, messagebox
 from OpenOrchestrator.scheduler import settings_tab, run_tab
 
+
 class Application(tkinter.Tk):
     """The main application object of the Scheduler app.
     Extends the tkinter.Tk object.
@@ -25,7 +26,7 @@ class Application(tkinter.Tk):
         notebook = ttk.Notebook(self)
         notebook.pack(expand=True, fill='both')
 
-        run_tab_ = run_tab.create_tab(notebook, self)
+        run_tab_ = run_tab.RunTab(notebook, self)
         settings_tab_ = settings_tab.create_tab(notebook)
 
         notebook.add(run_tab_, text='Run')
@@ -44,6 +45,5 @@ class Application(tkinter.Tk):
             self.destroy()
 
 
-
-if __name__=='__main__':
+if __name__ == '__main__':
     Application()