js7-client-python 2.0.1__py3-none-any.whl

js7/client/feature/joc/operate.py

@@ -0,0 +1,185 @@
+from typing import Any, Dict, Literal, Optional
+
+from ....client.context import Context
+from ....model.public.client.common.audit_log import AuditLog
+
+from ...action.joc.switch_over_action import switch_over_action
+from ...action.joc.run_service_action import run_service_action
+from ...action.joc.restart_service_action import restart_service_action
+from ...action.joc.restart_proxies_action import restart_proxies_action
+from ...action.joc.store_settings_action import store_settings_action
+
+
+class Operate:
+    def __init__(self, context: Context):
+        self._ctx = context
+    
+    def switch_over(self, controller_id: str) -> bool:
+        """
+        Switch to an inactive JOC cluster member.
+
+        Args:
+            controller_id (str):
+                The ID of the controller whose JOC cluster
+                should perform the switchover.
+
+        Returns:
+            bool:
+                Returns `True` if the switchover was successful,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the switchover fails or the server version
+                is incompatible.
+        """
+        
+        return switch_over_action(context=self._ctx, controller_id=controller_id)
+    
+    def run_service(
+        self,
+        service_type: Literal["cleanup", "cluster", "dailyplan", "history", "lognotification", "monitor"],
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Run a JOC service immediately.
+
+        Supported services include:
+        - "cleanup"
+        - "cluster"
+        - "dailyplan"
+        - "history"
+        - "lognotification"
+        - "monitor"
+
+        Args:
+            service_type (Literal["cleanup", "cluster", "dailyplan", "history", "lognotification", "monitor"]):
+                The type of service to be executed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the service was successfully started,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the service execution fails or the server version
+                is incompatible.
+        """
+    
+        return run_service_action(
+            context=self._ctx,
+            service_type=service_type,
+            audit_log=audit_log
+        )
+        
+    def restart_service(
+        self, 
+        service_type: Literal["cleanup", "cluster", "dailyplan", "history", "lognotification", "monitor"],
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Restart a JOC service.
+
+        Supported services include:
+        - "cleanup"
+        - "cluster"
+        - "dailyplan"
+        - "history"
+        - "lognotification"
+        - "monitor"
+
+        Args:
+            service_type (Literal["cleanup", "cluster", "dailyplan", "history", "lognotification", "monitor"]):
+                The type of service to be restarted.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the service was successfully restarted,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the restart operation fails or the server version
+                is incompatible.
+        """
+        
+        return restart_service_action(
+            context=self._ctx,
+            service_type=service_type,
+            audit_log=audit_log
+        )
+    
+    def restart_proxies(self, audit_log: Optional[AuditLog] = None) -> bool:
+        """
+        Restart proxy instances for all registered controllers.
+
+        Args:
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the proxy instances were successfully restarted,
+                otherwise `False`.
+
+        Raises:
+            RuntimeError:
+                If the restart operation fails or the server version
+                is incompatible.
+        """
+        
+        return restart_proxies_action(
+            context=self._ctx,
+            audit_log=audit_log
+        )
+        
+    def store_settings(self, payload: Dict[str, Any], audit_log: Optional[AuditLog] = None) -> bool:
+        """
+        Store global JOC settings.
+
+        Args:
+            payload (Dict[str, Any]):
+                A dictionary representing the settings to be stored.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns ``True`` if the settings were successfully stored,
+                otherwise ``False``.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return store_settings_action(
+            context=self._ctx,
+            payload=payload,
+            audit_log=audit_log
+        )

js7/client/feature/order/manage.py

@@ -0,0 +1,79 @@
+from typing import Any, Dict, List
+
+from ...context import Context
+from ....model.public.client.filter.order_history_filter import OrderHistoryFilter
+from ....model.public.client.filter.get_order_filter import GetOrderFilter
+from ....model.public.client.input.add_order import Order
+
+from ...action.order.get_order_history_action import get_order_history_action
+from ...action.order.get_orders_action import get_orders_action
+
+
+class Manage:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def get_order_history(self, controller_id: str, filter: OrderHistoryFilter) -> Dict[str, Any]:
+        """
+        Retrieve the order history for the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller whose order history
+                should be retrieved.
+
+            filter (OrderHistoryFilter):
+                Defines the criteria used to filter the order history.
+
+        Returns:
+            Dict[str, Any]:
+                A dictionary containing the order history data.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return get_order_history_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            filter=filter
+        )
+        
+    def get_orders(self, controller_id: str, filter: GetOrderFilter) -> List[Order]:
+        """
+        Retrieve orders from the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller from which the orders
+                should be retrieved.
+
+            filter (GetOrderFilter):
+                Defines the criteria used to filter the orders,
+                such as workflow path or order state.
+
+        Returns:
+            List[Order]:
+                A list of matching order objects.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return get_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            filter=filter
+        )
+
+    

js7/client/feature/order/operate.py

@@ -0,0 +1,346 @@
+from typing import List, Optional
+
+from ...context import Context
+from ....model.public.client.common.audit_log import AuditLog
+from ....model.public.client.input.add_order import Order
+from ....model.public.client.filter.resume_order_filter import ResumeOrderFilter
+from ....model.public.client.filter.suspend_order_filter import SuspendOrderFilter
+
+from ...action.order.cancel_orders_action import cancel_orders_action
+from ...action.order.continue_orders_action import continue_orders_action
+from ...action.order.remove_terminated_orders_action import remove_terminated_orders_action
+from ...action.order.resume_orders_action import resume_orders_action
+from ...action.order.suspend_orders_action import suspend_orders_action
+from ...action.order.confirm_orders_action import confirm_orders_action
+from ...action.order.add_orders_action import add_orders_action
+
+
+class Operate:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def cancel_orders(
+        self,
+        controller_id: str,
+        order_ids: Optional[List[str]] = None,
+        workflow_paths: Optional[List[str]] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Cancel orders on the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be canceled.
+
+            order_ids (Optional[List[str]]):
+                A list of specific order IDs to be canceled.
+
+            workflow_paths (Optional[List[str]]):
+                A list of workflow paths whose orders
+                should be canceled.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the orders were successfully canceled,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If neither `order_ids` nor `workflow_paths` is provided,
+                or if arguments are invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return cancel_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            order_ids=order_ids,
+            workflow_paths=workflow_paths,
+            audit_log=audit_log
+        )
+        
+    def continue_orders(
+        self,
+        controller_id: str,
+        order_ids: Optional[List[str]] = None,
+        workflow_paths: Optional[List[str]] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Continue paused or waiting orders on the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be continued.
+
+            order_ids (Optional[List[str]]):
+                A list of specific order IDs to be continued.
+
+            workflow_paths (Optional[List[str]]):
+                A list of workflow paths whose orders
+                should be continued.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the orders were successfully continued,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If neither `order_ids` nor `workflow_paths` is provided,
+                or if arguments are invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return continue_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            order_ids=order_ids,
+            workflow_paths=workflow_paths,
+            audit_log=audit_log
+        )
+        
+    def remove_terminated_orders(
+        self,
+        controller_id: str,
+        order_ids: Optional[List[str]] = None,
+        workflow_paths: Optional[List[str]] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Remove terminated orders from the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller from which terminated
+                orders should be removed.
+
+            order_ids (Optional[List[str]]):
+                A list of specific terminated order IDs to be removed.
+
+            workflow_paths (Optional[List[str]]):
+                A list of workflow paths whose terminated orders
+                should be removed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the terminated orders were successfully removed,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If neither `order_ids` nor `workflow_paths` is provided,
+                or if arguments are invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return remove_terminated_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            order_ids=order_ids,
+            workflow_paths=workflow_paths,
+            audit_log=audit_log
+        )
+        
+    def resume_orders(
+        self,
+        controller_id: str,
+        filter: ResumeOrderFilter,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Resume suspended or failed orders on the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be resumed.
+
+            filter (ResumeOrderFilter):
+                Defines the criteria used to select the orders
+                to be resumed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the orders were successfully resumed,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return resume_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            filter=filter,
+            audit_log=audit_log
+        )
+        
+    def suspend_orders(
+        self,
+        controller_id: str,
+        filter: SuspendOrderFilter,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Suspend orders on the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be suspended.
+
+            filter (SuspendOrderFilter):
+                Defines the criteria used to select the orders
+                to be suspended.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the orders were successfully suspended,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return suspend_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            filter=filter,
+            audit_log=audit_log
+        )
+        
+    def confirm_orders(
+        self,
+        controller_id: str,
+        order_ids: Optional[List[str]] = None,
+        workflow_paths: Optional[List[str]] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Confirm prompting orders on the specified controller.
+
+        This operation applies to workflows that include a
+        "Prompt" block and require manual confirmation.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be confirmed.
+
+            order_ids (Optional[List[str]]):
+                A list of specific order IDs to be confirmed.
+
+            workflow_paths (Optional[List[str]]):
+                A list of workflow paths for which prompting
+                orders should be confirmed.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the confirmation was successful,
+                otherwise `False`.
+
+        Raises:
+            ValueError:
+                If neither `order_ids` nor `workflow_paths` is provided,
+                or if arguments are invalid.
+
+            RuntimeError:
+                If the operation fails or the server version
+                is incompatible.
+        """
+        
+        return confirm_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            order_ids=order_ids,
+            workflow_paths=workflow_paths,
+            audit_log=audit_log
+        )
+        
+    def add_orders(
+        self,
+        controller_id: str,
+        orders: List[Order],
+        audit_log: Optional[AuditLog] = None
+    ) -> List[str]:
+        """
+        Create new orders on the specified controller.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the orders
+                should be created.
+
+            orders (List[Order]):
+                A list of order objects to be created.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to create an audit entry
+                for this operation.
+
+        Returns:
+            List[str]:
+                A list of the created order IDs.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If order creation fails or the server version
+                is incompatible.
+        """
+        
+        return add_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            orders=orders,
+            audit_log=audit_log
+        )

js7/client/feature/order/order.py

@@ -0,0 +1,18 @@
+from functools import cached_property
+
+from ...context import Context
+from .manage import Manage
+from .operate import Operate
+    
+    
+class Order:
+    def __init__(self, context: Context):
+        self._ctx = context
+    
+    @cached_property
+    def manage(self) -> Manage:
+        return Manage(context=self._ctx)
+    
+    @cached_property
+    def operate(self) -> Operate:
+        return Operate(context=self._ctx)

js7/client/feature/task/task.py

@@ -0,0 +1,54 @@
+from functools import cached_property
+from typing import Any, Dict
+
+from ....client.context import Context
+from ....model.public.client.filter.tasks_filter import TasksFilter
+
+from ...action.task.get_task_history_info_action import get_task_history_info_action
+
+
+class Manage:
+    def __init__(self, context: Context):
+        self._ctx = context
+
+    def get_task_history_info(
+        self,
+        controller_id: str,
+        filter: TasksFilter
+    ) -> Dict[str, Any]:
+        """
+        Args:
+            controller_id (str): 
+                Identifier of the controller on which the search is executed.
+            
+            filter (TasksFilter): 
+                Filter used to control the results.
+
+        Returns:
+            Dict ([str, Any]): 
+                A JSON representation of the task history.
+            
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return get_task_history_info_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            filter=filter            
+        )
+
+
+class Task:
+    def __init__(self, context: Context):
+        self._ctx = context
+    
+    @cached_property
+    def manage(self) -> Manage:
+        return Manage(context=self._ctx)
+