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

js7/client/action/iam/get_blocked_accounts_action.py

@@ -0,0 +1,76 @@
+from datetime import datetime
+from typing import List, Optional
+
+from ...context import Context
+from ....model.public.client.common.audit_log import AuditLog
+from ....model.private.api.endpoint import EndpointCall
+from ....model.public.client.common.accounts import BlockedAccount
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    BlockedAccountsFilter as BlockedAccountsFilter_V_2_8_2,
+    BlockedAccounts as BlockedAccounts_V_2_8_2,
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_blocked_accounts_action(
+    *, 
+    context: Context,
+    filter_date_from: Optional[datetime],
+    filter_date_to: Optional[datetime],
+    filter_account_name: Optional[str]
+) -> List[BlockedAccount]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        request_data = _build_v_2_8_2_request(
+            timezone=context.client_config.timezone,
+            filter_date_from=filter_date_from,
+            filter_date_to=filter_date_to,
+            filter_account_name=filter_account_name
+        )
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+    
+    # Calls the dispatcher for the matching JOC version
+    result = context.joc_api.dispatch(endpoint_id="iam/blockedAccounts", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=request_data,
+        options=None,
+    ))
+    
+    if isinstance(result, BlockedAccounts_V_2_8_2):
+        return [
+            BlockedAccount(
+                account_name=a.account_name,
+                comment=a.comment,
+                blocked_since=a.since,
+                audit_log=AuditLog(
+                    comment=a.audit_log.comment,
+                    ticket_link=a.audit_log.ticket_link,
+                    time_spent=a.audit_log.time_spent
+                ) if a.audit_log else None
+            )
+            for a in result.blocked_accounts
+        ] if result.blocked_accounts else []
+    
+    raise RuntimeError(f"Unexpected response type: {type(result).__name__}")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    timezone: str,
+    filter_date_from: Optional[datetime],
+    filter_date_to: Optional[datetime],
+    filter_account_name: Optional[str]
+) -> BlockedAccountsFilter_V_2_8_2:
+
+    # Result
+    return BlockedAccountsFilter_V_2_8_2(
+        time_zone=timezone,
+        date_from=filter_date_from,
+        date_to=filter_date_to,
+        account_name=filter_account_name
+    )

js7/client/action/iam/get_folder_permissions_action.py

@@ -0,0 +1,112 @@
+from typing import List, Optional, Union
+
+from ...context import Context
+from ....model.public.client.filter.element.folder import Folder
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    FolderListFilter as FolderListFilter_V_2_8_2,
+    Folders as Folders_V_2_8_2,
+    FolderFilter as FolderFilter_V_2_8_2,
+    FolderItem as FolderItem_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_folder_permissions_action(
+    *, 
+    context: Context,
+    identity_service_name: str,
+    folder_name: Optional[str],
+    role_name: str,
+    controller_id: str
+) -> List[Folder]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        result = _build_v_2_8_2_request(
+            context=context,
+            identity_service_name=identity_service_name,
+            folder_name=folder_name,
+            role_name=role_name,
+            controller_id=controller_id
+        )
+        
+        if isinstance(result, Folders_V_2_8_2):    
+            return [
+                Folder(
+                    folder_path=f.folder,
+                    recursive=f.recursive or False
+                )
+                for f in result.folders
+            ]
+        else:
+            return [
+                Folder(
+                    folder_path=result.folder.folder,
+                    recursive=result.folder.recursive or False
+                )
+            ] if result.folder else []
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    context: Context,
+    identity_service_name: str,
+    folder_name: Optional[str],
+    role_name: str,
+    controller_id: str
+) -> Union[Folders_V_2_8_2, FolderItem_V_2_8_2]:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Validate: role_name
+    if not role_name:
+        raise ValueError("'role_name' is required.")
+    
+    if not folder_name:
+        # Build: folders_req
+        folders_req = FolderListFilter_V_2_8_2(
+            identity_service_name=identity_service_name,
+            role_name=role_name,
+            controller_id=controller_id
+        )
+        
+        # Calls the dispatcher for the matching JOC version
+        folders_res = context.joc_api.dispatch(endpoint_id="iam/folders", call=EndpointCall(
+            http_service=context.http_service,
+            access_token=context.auth_provider.login(),
+            payload=folders_req,
+            options=None,
+        ))
+        
+        if not isinstance(folders_res, Folders_V_2_8_2):
+            raise RuntimeError(f"Unexpected response type: {type(folders_res).__name__}")
+        
+        return folders_res
+    
+    # Build: folder_req
+    folder_req = FolderFilter_V_2_8_2(
+        identity_service_name=identity_service_name,
+        role_name=role_name,
+        controller_id=controller_id,
+        folder_name=folder_name
+    )
+    
+    # Calls the dispatcher for the matching JOC version
+    folder_res = context.joc_api.dispatch(endpoint_id="iam/folder", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=folder_req,
+        options=None,
+    ))
+    
+    if not isinstance(folder_res, FolderItem_V_2_8_2):
+        raise RuntimeError(f"Unexpected response type: {type(folder_res).__name__}")
+    
+    return folder_res

js7/client/action/iam/get_identity_service_settings_action.py

@@ -0,0 +1,70 @@
+import json
+from typing import Any, Dict, Literal
+
+from ...context import Context
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    Configuration as Configuration_V_2_8_2,
+    ConfigurationType as ConfigurationType_V_2_8_2,
+    Configuration200 as Configuration200_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_identity_service_settings_action(
+    *, 
+    context: Context,
+    identity_service_name: str,
+    identity_service_type: Literal["KEYCLOAK", "KEYCLOAK-JOC", "LDAP", "LDAP-JOC", "OIDC", "OIDC-JOC", "FIDO", "JOC", "CERTIFICATE"]
+) -> Dict[str, Any]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        request_data = _build_v_2_8_2_request(
+            identity_service_name=identity_service_name,
+            identity_service_type=identity_service_type
+        )
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+    
+    # Calls the dispatcher for the matching JOC version
+    result = context.joc_api.dispatch(endpoint_id="configuration", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=request_data,
+        options=None,
+    ))
+    
+    if isinstance(result, Configuration200_V_2_8_2):
+        # model_dump(mode="json")
+        if not (result.configuration and result.configuration.configuration_item):
+            return {}
+    
+        return json.loads(result.configuration.configuration_item)
+    
+    raise RuntimeError(f"Unexpected response type: {type(result).__name__}")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    identity_service_name: str,
+    identity_service_type: Literal["KEYCLOAK", "KEYCLOAK-JOC", "LDAP", "LDAP-JOC", "OIDC", "OIDC-JOC", "FIDO", "JOC", "CERTIFICATE"]
+) -> Configuration_V_2_8_2:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Validate: identity_service_type
+    if identity_service_type not in ["KEYCLOAK", "KEYCLOAK-JOC", "LDAP", "LDAP-JOC", "OIDC", "OIDC-JOC", "FIDO", "JOC", "CERTIFICATE"]:
+        raise ValueError(f"identity service type: {identity_service_type} is not supported.")
+    
+    # Result
+    return Configuration_V_2_8_2(
+        id=0,
+        configuration_type=ConfigurationType_V_2_8_2.IAM,
+        name=identity_service_name,
+        object_type=identity_service_type
+    )

js7/client/action/iam/get_identity_services_action.py

@@ -0,0 +1,102 @@
+from typing import List, Optional, Union
+
+from ...context import Context
+from ....model.public.client.common.identity_service import IdentityService
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    IdentityServiceFilter as IdentityServiceFilter_V_2_8_2,
+    IdentityService as IdentityService_V_2_8_2,
+    IdentityServices as IdentityServices_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_identity_services_action(
+    *, 
+    context: Context,
+    identity_service_name: Optional[str]
+) -> List[IdentityService]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        result = _build_v_2_8_2_request(
+            context=context,
+            identity_service_name=identity_service_name
+        )
+        
+        services: List[IdentityService] = []
+        
+        if isinstance(result, IdentityServices_V_2_8_2):
+            if result.identity_service_items:  
+                for s in result.identity_service_items:
+                    services.append(IdentityService(
+                        identity_service_name=s.identity_service_name,
+                        identity_service_type=s.identity_service_type.value if s.identity_service_type else "UNKNOWN",
+                        service_authentication_scheme=s.service_authentication_scheme.value,
+                        second_factor=s.second_factor or False,
+                        second_factor_identity_service_name=s.second_factor_identity_service_name,
+                        disabled=s.disabled or False,
+                        required=s.required or False,
+                        ordering=s.ordering or 1
+                    ))
+        else:
+            services.append(IdentityService(
+                identity_service_name=result.identity_service_name,
+                identity_service_type=result.identity_service_type.value if result.identity_service_type else "UNKNOWN",
+                service_authentication_scheme=result.service_authentication_scheme.value,
+                second_factor=result.second_factor or False,
+                second_factor_identity_service_name=result.second_factor_identity_service_name,
+                disabled=result.disabled or False,
+                required=result.required or False,
+                ordering=result.ordering or 1
+            ))
+            
+        return services
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    context: Context,
+    identity_service_name: Optional[str]
+) -> Union[IdentityServices_V_2_8_2, IdentityService_V_2_8_2]:
+    
+    if not identity_service_name:
+        # Build: services_req
+        services_req = IdentityServiceFilter_V_2_8_2(
+            identity_service_name=None,
+        )
+        
+        # Calls the dispatcher for the matching JOC version
+        services_res = context.joc_api.dispatch(endpoint_id="iam/identityservices", call=EndpointCall(
+            http_service=context.http_service,
+            access_token=context.auth_provider.login(),
+            payload=services_req,
+            options=None,
+        ))
+        
+        if not isinstance(services_res, IdentityServices_V_2_8_2):
+            raise RuntimeError(f"Unexpected response type: {type(services_res).__name__}")
+        
+        return services_res
+    
+    # Build: service_req
+    service_req = IdentityServiceFilter_V_2_8_2(
+        identity_service_name=identity_service_name
+    )
+    
+    # Calls the dispatcher for the matching JOC version
+    service_res = context.joc_api.dispatch(endpoint_id="iam/identityservice", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=service_req,
+        options=None,
+    ))
+    
+    if not isinstance(service_res, IdentityService_V_2_8_2):
+        raise RuntimeError(f"Unexpected response type: {type(service_res).__name__}")
+    
+    return service_res

js7/client/action/iam/get_permissions_action.py

@@ -0,0 +1,113 @@
+from typing import List, Optional, Tuple, Union
+
+from ...context import Context
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    PermissionListFilter as PermissionListFilter_V_2_8_2,
+    Permissions as Permissions_V_2_8_2,
+    PermissionItem as PermissionItem_V_2_8_2,
+    PermissionFilter as PermissionFilter_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_permissions_action(
+    *, 
+    context: Context,
+    permission_path: Optional[str],
+    identity_service_name: str,
+    role_name: str,
+    controller_id: Optional[str],
+    without_excluded: bool
+) -> List[Tuple[str, bool]]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        result = _build_v_2_8_2_request(
+            context=context,
+            permission_path=permission_path,
+            identity_service_name=identity_service_name,
+            role_name=role_name,
+            controller_id=controller_id
+        )
+        
+        permissions: List[Tuple[str, bool]] = []
+        
+        if isinstance(result, Permissions_V_2_8_2):    
+            for p in result.permissions:
+                if p.excluded is True and without_excluded:
+                    continue
+                
+                permissions.append((p.permission_path, p.excluded or False))
+        else:
+            if result.permission:
+                if result.permission.excluded is True and without_excluded:
+                    return permissions
+                
+                permissions.append((result.permission.permission_path, result.permission.excluded or False))
+            
+        return permissions
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    context: Context,
+    permission_path: Optional[str],
+    identity_service_name: str,
+    role_name: str,
+    controller_id: Optional[str]
+) -> Union[PermissionItem_V_2_8_2, Permissions_V_2_8_2]:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Validate: role_name
+    if not role_name:
+        raise ValueError("'role_name' is required.")
+    
+    if not permission_path:
+        # Build: permissions_req
+        permissions_req = PermissionListFilter_V_2_8_2(
+            identity_service_name=identity_service_name,
+            role_name=role_name,
+            controller_id=controller_id
+        )
+        
+        # Calls the dispatcher for the matching JOC version
+        permissions_res = context.joc_api.dispatch(endpoint_id="iam/permissions", call=EndpointCall(
+            http_service=context.http_service,
+            access_token=context.auth_provider.login(),
+            payload=permissions_req,
+            options=None,
+        ))
+        
+        if not isinstance(permissions_res, Permissions_V_2_8_2):
+            raise RuntimeError(f"Unexpected response type: {type(permissions_res).__name__}")
+        
+        return permissions_res
+    
+    # Build: permission_req
+    permission_req = PermissionFilter_V_2_8_2(
+        identity_service_name=identity_service_name,
+        role_name=role_name,
+        controller_id=controller_id,
+        permission_path=permission_path
+    )
+    
+    # Calls the dispatcher for the matching JOC version
+    permission_res = context.joc_api.dispatch(endpoint_id="iam/permission", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=permission_req,
+        options=None,
+    ))
+    
+    if not isinstance(permission_res, PermissionItem_V_2_8_2):
+        raise RuntimeError(f"Unexpected response type: {type(permission_res).__name__}")
+    
+    return permission_res

js7/client/action/iam/get_roles_action.py

@@ -0,0 +1,57 @@
+from typing import List
+
+from ...context import Context
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    RoleListFilter as RoleListFilter_V_2_8_2,
+    Roles as Roles_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def get_roles_action(
+    *, 
+    context: Context,
+    identity_service_name: str
+) -> List[str]:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        request_data = _build_v_2_8_2_request(
+            identity_service_name=identity_service_name
+        )
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+    
+    # Calls the dispatcher for the matching JOC version
+    result = context.joc_api.dispatch(endpoint_id="iam/roles", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=request_data,
+        options=None,
+    ))
+    
+    if isinstance(result, Roles_V_2_8_2):
+        return [
+            r.role_name
+            for r in result.roles
+        ] if result.roles else []
+    
+    raise RuntimeError(f"Unexpected response type: {type(result).__name__}")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    identity_service_name: str
+) -> RoleListFilter_V_2_8_2:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Result
+    return RoleListFilter_V_2_8_2(
+        identity_service_name=identity_service_name
+    )

js7/client/action/iam/remove_accounts_action.py

@@ -0,0 +1,75 @@
+from typing import List, Optional
+
+from ...context import Context
+from ....model.public.client.common.audit_log import AuditLog
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    AccountsFilter as AccountsFilter_V_2_8_2,
+    AuditParams as AuditParams_V_2_8_2,
+    OK as OK_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def remove_accounts_action(
+    *, 
+    context: Context,
+    identity_service_name: str,
+    account_names: List[str],
+    audit_log: Optional[AuditLog]
+) -> bool:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        request_data = _build_v_2_8_2_request(
+            identity_service_name=identity_service_name,
+            account_names=account_names,
+            audit_log=audit_log,
+        )
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+    
+    # Calls the dispatcher for the matching JOC version
+    result = context.joc_api.dispatch(endpoint_id="iam/accounts/delete", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=request_data,
+        options=None,
+    ))
+    
+    if isinstance(result, OK_V_2_8_2):
+        return bool(result.ok)
+    
+    raise RuntimeError(f"Unexpected response type: {type(result).__name__}")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    identity_service_name: str,
+    account_names: List[str],
+    audit_log: Optional[AuditLog]
+) -> AccountsFilter_V_2_8_2:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Validate: account_names
+    if not account_names:
+        raise ValueError("At least one account name in 'account_names' is required.")
+    
+    # Build: audit_log 
+    res_audit_log = AuditParams_V_2_8_2(
+        ticket_link=audit_log.ticket_link,
+        comment=audit_log.comment,
+        time_spent=audit_log.time_spent
+    ) if audit_log else None
+    
+    # Result
+    return AccountsFilter_V_2_8_2(
+        identity_service_name=identity_service_name,
+        account_names=account_names,
+        audit_log=res_audit_log
+    )

js7/client/action/iam/remove_folder_permissions_action.py

@@ -0,0 +1,91 @@
+from typing import List, Optional
+
+from ...context import Context
+from ....model.public.client.common.audit_log import AuditLog
+from ....model.private.api.endpoint import EndpointCall
+from ....model.private.http.joc.joc_v_2_8_2 import (
+    AuditParams as AuditParams_V_2_8_2,
+    OK as OK_V_2_8_2,
+    FoldersFilter as FoldersFilter_V_2_8_2
+)
+
+from ....util.check_matching_version import check_matching_version
+
+
+def remove_folder_permissions_action(
+    *, 
+    context: Context,
+    identity_service_name: str,
+    role_name: str,
+    controller_id: str,
+    folder_names: List[str],
+    audit_log: Optional[AuditLog]
+) -> bool:
+
+    if check_matching_version(min="2.6.5", max="2.8.3", check=context.version):
+        request_data = _build_v_2_8_2_request(
+            identity_service_name=identity_service_name,
+            role_name=role_name,
+            controller_id=controller_id,
+            folder_names=folder_names,
+            audit_log=audit_log
+        )
+    else:
+        raise RuntimeError(f"Version {context.version} is not compatible with building the request.")
+    
+    # Calls the dispatcher for the matching JOC version
+    result = context.joc_api.dispatch(endpoint_id="iam/folders/delete", call=EndpointCall(
+        http_service=context.http_service,
+        access_token=context.auth_provider.login(),
+        payload=request_data,
+        options=None,
+    ))
+    
+    if isinstance(result, OK_V_2_8_2):
+        return bool(result.ok)
+    
+    raise RuntimeError(f"Unexpected response type: {type(result).__name__}")
+
+#---------------------#
+# Build 2.8.2 request #
+#---------------------#
+def _build_v_2_8_2_request(
+    *,
+    identity_service_name: str,
+    role_name: str,
+    controller_id: str,
+    folder_names: List[str],
+    audit_log: Optional[AuditLog]
+) -> FoldersFilter_V_2_8_2:
+
+    # Validate: identity_service_name
+    if not identity_service_name:
+        raise ValueError("'identity_service_name' is required.")
+    
+    # Validate: role_name
+    if not role_name:
+        raise ValueError("'role_name' is required.")
+    
+    # Validate: controller_id
+    if not controller_id:
+        raise ValueError("'controller_id' is required.")
+    
+    # Validate: folder_names
+    if not folder_names:
+        raise ValueError("At least one folder name in 'folder_names' is required.")
+    
+    # Build: audit_log 
+    res_audit_log = AuditParams_V_2_8_2(
+        ticket_link=audit_log.ticket_link,
+        comment=audit_log.comment,
+        time_spent=audit_log.time_spent
+    ) if audit_log else None
+    
+    # Result
+    return FoldersFilter_V_2_8_2(
+        identity_service_name=identity_service_name,
+        role_name=role_name,
+        controller_id=controller_id,
+        folder_names=folder_names,
+        audit_log=res_audit_log
+    )