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

js7/client/feature/controller/manage.py

@@ -0,0 +1,214 @@
+from typing import Any, Dict, Literal, Optional
+
+from ....client.context import Context
+from ....model.public.client.common.audit_log import AuditLog
+
+from ...action.controller.test_controller_instance_action import test_controller_instance_action
+from ...action.controller.confirm_cluster_node_loss_action import confirm_cluster_node_loss_action
+from ...action.controller.get_controller_components_action import get_controller_components_action
+from ...action.controller.get_controller_status_action import get_controller_status_action
+from ...action.controller.register_controller_action import register_controller_action
+
+
+class Manage:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def test_controller_instance(
+        self,
+        url: str,
+        controller_id: Optional[str] = None,
+    ) -> bool:
+        """
+        Tests the connectivity of a Controller instance and optionally verifies its Controller ID.
+
+        Args:
+            url (str):
+                The URL of the Controller instance against which the connection test is performed.
+
+            controller_id (Optional[str]):
+                If provided, verifies that the Controller instance is registered with
+                the specified Controller ID.
+
+        Returns:
+            bool:
+                Returns `True` if the connection status is `established`.
+                Returns `False` if the status is `unstable`, `unreachable`, or `unknown`.
+
+        Raises:
+            ValueError:
+                If required arguments such as `url` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return test_controller_instance_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url
+        )
+        
+    def confirm_cluster_node_loss(
+        self,
+        controller_id: str,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Confirms that a Controller node in the cluster is permanently lost.
+
+        Args:
+            controller_id (str):
+                The unique identifier of the Controller instance that is
+                expected to be lost.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to be included with the request.
+
+        Returns:
+            bool:
+                Returns `True` if the specified Controller node is confirmed as lost,
+                otherwise returns `False`.
+
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return confirm_cluster_node_loss_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            audit_log=audit_log
+        )
+        
+    def get_controller_components(self, controller_id: str) -> Dict[str, Any]:
+        """
+        Retrieves the components of the specified Controller instance.
+
+        Args:
+            controller_id (str):
+                The unique identifier of the Controller instance for which
+                component information is requested.
+
+        Returns:
+            Dict ([str, Any]):
+                A dictionary containing details about the Controller components.
+
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return get_controller_components_action(
+            context=self._ctx,
+            controller_id=controller_id
+        )
+        
+    def get_controller_status(
+        self,
+        controller_id: str,
+        url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> Dict[str, Any]:
+        """
+        Gets Controller status information.
+        
+        Args:
+            controller_id (str):
+                The unique identifier of the Controller instance for which
+                status information is requested.
+                
+            url (str):
+                URL of the Controller instance. This parameter is required for a Controller cluster.
+                
+        Returns:
+            Dict ([str, Any]):
+                A dictionary containing details about the Controller status.
+                
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return get_controller_status_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url,
+            audit_log=audit_log
+        )
+        
+    def register_controller(
+        self,
+        url: str,
+        role: Literal['STANDALONE', 'PRIMARY', 'BACKUP'],
+        controller_id: Optional[str] = None,
+        title: Optional[str] = None,
+        cluster_url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Registers a Controller or Controller cluster in JOC Cockpit.
+
+        A Controller can be either a standalone instance or part of a cluster
+        with PRIMARY and BACKUP roles. This operation adds a new Controller
+        (or cluster) to JOC Cockpit or updates existing Controller information
+        such as the URL or title.
+
+        Args:
+            url (str):
+                The URL of the Controller instance.
+
+            role (Literal['STANDALONE', 'PRIMARY', 'BACKUP']):
+                The role of the Controller within the cluster.
+
+            controller_id (Optional[str]):
+                The Controller ID. Can be omitted only when registering
+                a new Controller (cluster).
+
+            title (Optional[str]):
+                A display name used in JOC Cockpit.
+
+            cluster_url (Optional[str]):
+                For clustered Controllers only: The URL used by cluster
+                nodes to communicate with each other.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to be included with the request.
+
+        Returns:
+            bool:
+                Returns `True` if the Controller was successfully registered
+                or updated.
+
+        Raises:
+            ValueError:
+                If required arguments such as `url` or `role` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return register_controller_action(
+            context=self._ctx,
+            url=url,
+            role=role,
+            controller_id=controller_id,
+            title=title,
+            cluster_url=cluster_url,
+            audit_log=audit_log
+        )
+        

js7/client/feature/controller/operate.py

@@ -0,0 +1,274 @@
+from typing import Optional
+from ....client.context import Context
+from ....model.public.client.common.audit_log import AuditLog
+
+from ...action.controller.appoint_nodes_controller_action import appoint_controller_cluster_roles_action
+from ...action.controller.cancel_and_restart_controller_action import cancel_and_restart_controller_action
+from ...action.controller.cancel_controller_action import cancel_controller_action
+from ...action.controller.switchover_controller_cluster_action import switchover_controller_cluster_action
+from ...action.controller.restart_controller_action import restart_controller_action
+from ...action.controller.terminate_controller_action import terminate_controller_action
+from ...action.controller.unregister_controller_action import unregister_controller_action
+
+
+class Operate:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def appoint_controller_cluster_roles(
+        self,
+        controller_id: str,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Re-establishes Controller Cluster roles.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+
+        Returns:
+            bool:
+                Returns `True` if the operation was successful, otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return appoint_controller_cluster_roles_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            audit_log=audit_log
+        )
+        
+    def cancel_and_restart_controller(
+        self,
+        controller_id: str,
+        url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Aborts and restarts Controller and optionally switches over.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+                
+            url (str):
+                URL of the Controller instance. This parameter is required for a Controller cluster.
+                
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool:
+                Returns `True` if the operation was successful, otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return cancel_and_restart_controller_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url,
+            audit_log=audit_log
+        )
+        
+    def cancel_controller(
+        self,
+        controller_id: str,
+        url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Cancels the specified Controller instance.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+                
+            url (str):
+                URL of the Controller instance. This parameter is required for a Controller cluster.
+                
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool:
+                Returns `True` if the operation was successful, otherwise `False`.
+
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return cancel_controller_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url,
+            audit_log=audit_log
+        )
+        
+    def switchover_controller_cluster(
+        self,
+        controller_id: str,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Performs a switch-over to the standby node.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+                
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool: Returns `True` if the operation was successful, otherwise `False`.
+            
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return switchover_controller_cluster_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            audit_log=audit_log
+        )
+        
+    def restart_controller(
+        self,
+        controller_id: str,
+        url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Restarts a Controller instance.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+            
+            url (Optional[str]):
+                URL of the Controller instance. This parameter is required for a Controller cluster.
+            
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool: 
+                Returns `True` if the operation was successful, otherwise `False`.
+                
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return restart_controller_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url,
+            audit_log=audit_log
+        )
+    
+    def terminate_controller(
+        self,
+        controller_id: str,
+        url: Optional[str] = None,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Terminates a Controller instance.
+            
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+            
+            url (Optional[str]):
+                URL of the Controller instance. This parameter is required for a Controller cluster.
+            
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool: 
+                Returns `True` if the operation was successful, otherwise `False`.
+                
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return terminate_controller_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            url=url,
+            audit_log=audit_log
+        )
+        
+    def unregister_controller(
+        self,
+        controller_id: str,
+        audit_log: Optional[AuditLog] = None
+    ) -> bool:
+        """
+        Unregisters a Controller instance.
+        
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation should be executed.
+            
+            audit_log (Optional[AuditLog]):
+                Creates an audit log entry for this operation.
+                
+        Returns:
+            bool: 
+                Returns `True` if the operation was successful, otherwise `False`.
+                
+        Raises:
+            ValueError:
+                If required arguments such as `controller_id` are missing or invalid.
+
+            RuntimeError:
+                If the server version is not compatible or if an
+                unexpected response is returned.
+        """
+        
+        return unregister_controller_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            audit_log=audit_log
+        )
+    

js7/client/feature/daily_plan/daily_plan.py

@@ -0,0 +1,14 @@
+from functools import cached_property
+
+from ....client.context import Context
+
+from .manage import Manage
+
+   
+class DailyPlan:
+    def __init__(self, context: Context):
+        self._ctx = context
+    
+    @cached_property
+    def manage(self) -> Manage:
+        return Manage(context=self._ctx)

js7/client/feature/daily_plan/manage.py

@@ -0,0 +1,179 @@
+from typing import Any, Dict, List, Optional, Tuple
+
+from ....client.context import Context
+from ....model.public.client.common.schedule_time import ScheduleTime
+from ....model.public.client.common.audit_log import AuditLog
+from ....model.public.client.common.cycle import Cycle
+from ....model.public.client.filter.daily_plan_order_filters import (
+    DailyPlanOrdersFilter,  
+    DailyPlanProjectionsFilter
+)
+
+from ...action.daily_plan.get_orders_action import get_orders_action
+from ...action.daily_plan.copy_orders_action import copy_orders_action
+from ...action.daily_plan.create_projections_action import create_projections_action
+from ...action.daily_plan.get_calendar_projections_action import get_calendar_projections_action
+from ...action.daily_plan.get_projection_dates_action import get_projection_dates_action
+
+
+class Manage:
+    def __init__(self, context: Context):
+        self._ctx = context
+        
+    def get_orders(self, filter: DailyPlanOrdersFilter) -> Dict[str, Any]:
+        """
+        Retrieves orders for a specified daily plan interval.
+
+        Args:
+            filter (DailyPlanOrdersFilter):
+                Defines the filter criteria used to select orders
+                from the daily plan interval.
+
+        Returns:
+            Dict ([str, Any]):
+                A dictionary containing the orders matching the
+                specified daily plan filter.
+
+        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_orders_action(
+            context=self._ctx,
+            filter=filter
+        )
+        
+    def copy_orders(
+        self,
+        controller_id: str,
+        order_ids: List[str],
+        scheduled_for: Optional[ScheduleTime] = None,
+        cycle: Optional[Cycle] = None,
+        force_job_admission: bool = False,
+        sticky_daily_plan_date: bool = False,
+        audit_log: Optional[AuditLog] = None
+    ) -> List[Tuple[str, str]]:
+        """
+        Copy orders.
+
+        Args:
+            controller_id (str):
+                The ID of the controller on which the operation will be executed.
+
+            order_ids (List[str]):
+                A list of order IDs to be copied.
+
+            scheduled_for (Optional[ScheduleTime]):
+                Specifies the time for which the copied orders should be scheduled.
+
+            cycle (Optional[Cycle]):
+                Defines the cycle for cyclic orders, including the begin date,
+                end date, and repeat interval.
+
+            force_job_admission (bool):
+                If True, any job admission times defined in job instructions
+                will be ignored.
+
+            sticky_daily_plan_date (bool):
+                If True, the copied orders will retain their original Daily Plan date.
+
+            audit_log (Optional[AuditLog]):
+                Optional audit log information to include with the request.
+
+        Returns:
+            List (Tuple[str, str]):
+                A list of tuples in the format `(old_id, new_id)`, mapping the
+                original order ID to the newly created order ID.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return copy_orders_action(
+            context=self._ctx,
+            controller_id=controller_id,
+            order_ids=order_ids,
+            scheduled_for=scheduled_for,
+            cycle=cycle,
+            force_job_admission=force_job_admission,
+            sticky_daily_plan_date=sticky_daily_plan_date,
+            audit_log=audit_log
+        )
+        
+    def create_projections(self) -> bool:
+        """
+        (Re)creates daily plan projections.
+
+        Returns:
+            bool:
+                Returns True if the operation was successful.
+
+        Raises:
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return create_projections_action(context=self._ctx)
+    
+    def get_calendar_projections(self, filter: DailyPlanProjectionsFilter) -> Dict[str, Any]:
+        """
+        Retrieve the daily plan projection dates that include start times.
+
+        Args:
+            filter (DailyPlanProjectionsFilter):
+                Defines the criteria used to filter the projection entries.
+
+        Returns:
+            Dict ([str, Any]):
+                A dictionary containing the JSON representation of the years.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return get_calendar_projections_action(
+            context=self._ctx,
+            filter=filter
+        )
+        
+    def get_projection_dates(self, filter: DailyPlanProjectionsFilter) -> Dict[str, Any]:
+        """
+        Retrieve the start times for a date range of daily plan projections.
+
+        Args:
+            filter (DailyPlanProjectionsFilter):
+                Defines the criteria used to filter the projection entries.
+
+        Returns:
+            Dict ([str, Any]):
+                A dictionary containing the JSON representation of the years.
+
+        Raises:
+            ValueError:
+                If required arguments are missing or invalid.
+
+            RuntimeError:
+                If the server version is incompatible or if an unexpected
+                response is returned.
+        """
+        
+        return get_projection_dates_action(
+            context=self._ctx,
+            filter=filter
+        )