python3-core-api-client 0.1__py3-none-any.whl

cyberfusion/CoreApiClient/resources/logs.py

@@ -0,0 +1,50 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Logs(Resource):
+    def list_access_logs(
+        self,
+        *,
+        virtual_host_id: int,
+        timestamp: Optional[str] = None,
+        sort: Optional[models.LogAccessResource] = None,
+        limit: Optional[int] = None,
+    ) -> list[models.LogAccessResource]:
+        return [
+            models.LogAccessResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/logs/access/{virtual_host_id}",
+                data=None,
+                query_parameters={
+                    "timestamp": timestamp,
+                    "sort": sort,
+                    "limit": limit,
+                },
+            ).json
+        ]
+
+    def list_error_logs(
+        self,
+        *,
+        virtual_host_id: int,
+        timestamp: Optional[str] = None,
+        sort: Optional[models.LogErrorResource] = None,
+        limit: Optional[int] = None,
+    ) -> list[models.LogErrorResource]:
+        return [
+            models.LogErrorResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/logs/error/{virtual_host_id}",
+                data=None,
+                query_parameters={
+                    "timestamp": timestamp,
+                    "sort": sort,
+                    "limit": limit,
+                },
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/mail_accounts.py

@@ -0,0 +1,105 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class MailAccounts(Resource):
+    def create_mail_account(
+        self,
+        request: models.MailAccountCreateRequest,
+    ) -> models.MailAccountResource:
+        return models.MailAccountResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/mail-accounts",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_mail_accounts(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MailAccountResource]:
+        return [
+            models.MailAccountResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/mail-accounts",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_mail_account(
+        self,
+        *,
+        id_: int,
+    ) -> models.MailAccountResource:
+        return models.MailAccountResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/mail-accounts/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_mail_account(
+        self,
+        request: models.MailAccountUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.MailAccountResource:
+        return models.MailAccountResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/mail-accounts/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_mail_account(
+        self,
+        *,
+        id_: int,
+        delete_on_cluster: Optional[bool] = None,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/mail-accounts/{id_}",
+                data=None,
+                query_parameters={
+                    "delete_on_cluster": delete_on_cluster,
+                },
+            ).json
+        )
+
+    def list_mail_account_usages(
+        self,
+        *,
+        mail_account_id: int,
+        timestamp: str,
+        time_unit: Optional[models.MailAccountUsageResource] = None,
+    ) -> list[models.MailAccountUsageResource]:
+        return [
+            models.MailAccountUsageResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/mail-accounts/usages/{mail_account_id}",
+                data=None,
+                query_parameters={
+                    "timestamp": timestamp,
+                    "time_unit": time_unit,
+                },
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/mail_aliases.py

@@ -0,0 +1,79 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class MailAliases(Resource):
+    def create_mail_alias(
+        self,
+        request: models.MailAliasCreateRequest,
+    ) -> models.MailAliasResource:
+        return models.MailAliasResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/mail-aliases",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_mail_aliases(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MailAliasResource]:
+        return [
+            models.MailAliasResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/mail-aliases",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_mail_alias(
+        self,
+        *,
+        id_: int,
+    ) -> models.MailAliasResource:
+        return models.MailAliasResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/mail-aliases/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_mail_alias(
+        self,
+        request: models.MailAliasUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.MailAliasResource:
+        return models.MailAliasResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/mail-aliases/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_mail_alias(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/mail-aliases/{id_}", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/mail_domains.py

@@ -0,0 +1,79 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class MailDomains(Resource):
+    def create_mail_domain(
+        self,
+        request: models.MailDomainCreateRequest,
+    ) -> models.MailDomainResource:
+        return models.MailDomainResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/mail-domains",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_mail_domains(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MailDomainResource]:
+        return [
+            models.MailDomainResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/mail-domains",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_mail_domain(
+        self,
+        *,
+        id_: int,
+    ) -> models.MailDomainResource:
+        return models.MailDomainResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/mail-domains/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_mail_domain(
+        self,
+        request: models.MailDomainUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.MailDomainResource:
+        return models.MailDomainResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/mail-domains/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_mail_domain(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/mail-domains/{id_}", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/mail_hostnames.py

@@ -0,0 +1,82 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class MailHostnames(Resource):
+    def create_mail_hostname(
+        self,
+        request: models.MailHostnameCreateRequest,
+    ) -> models.MailHostnameResource:
+        return models.MailHostnameResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/mail-hostnames",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_mail_hostnames(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MailHostnameResource]:
+        return [
+            models.MailHostnameResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/mail-hostnames",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_mail_hostname(
+        self,
+        *,
+        id_: int,
+    ) -> models.MailHostnameResource:
+        return models.MailHostnameResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/mail-hostnames/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_mail_hostname(
+        self,
+        request: models.MailHostnameUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.MailHostnameResource:
+        return models.MailHostnameResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/mail-hostnames/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_mail_hostname(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/mail-hostnames/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/malwares.py

@@ -0,0 +1,53 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Malwares(Resource):
+    def list_malwares(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MalwareResource]:
+        return [
+            models.MalwareResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/malwares",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def list_malwares_for_unix_users(
+        self,
+        *,
+        unix_user_id: int,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MalwareResource]:
+        return [
+            models.MalwareResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/malwares/{unix_user_id}",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/mariadb_encryption_keys.py

@@ -0,0 +1,56 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class MariaDBEncryptionKeys(Resource):
+    def create_mariadb_encryption_key(
+        self,
+        request: models.MariaDBEncryptionKeyCreateRequest,
+    ) -> models.MariaDBEncryptionKeyResource:
+        return models.MariaDBEncryptionKeyResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/mariadb-encryption-keys",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_mariadb_encryption_keys(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.MariaDBEncryptionKeyResource]:
+        return [
+            models.MariaDBEncryptionKeyResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/mariadb-encryption-keys",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_mariadb_encryption_key(
+        self,
+        *,
+        id_: int,
+    ) -> models.MariaDBEncryptionKeyResource:
+        return models.MariaDBEncryptionKeyResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/mariadb-encryption-keys/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/node_add_ons.py

@@ -0,0 +1,74 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class NodeAddOns(Resource):
+    def create_node_add_on(
+        self,
+        request: models.NodeAddOnCreateRequest,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/node-add-ons",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_node_add_ons(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.NodeAddOnResource]:
+        return [
+            models.NodeAddOnResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/node-add-ons",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def get_node_add_on_products(
+        self,
+    ) -> list[models.NodeAddOnProduct]:
+        return [
+            models.NodeAddOnProduct.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET", "/api/v1/node-add-ons/products", data=None, query_parameters={}
+            ).json
+        ]
+
+    def read_node_add_on(
+        self,
+        *,
+        id_: int,
+    ) -> models.NodeAddOnResource:
+        return models.NodeAddOnResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/node-add-ons/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_node_add_on(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/node-add-ons/{id_}", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/nodes.py

@@ -0,0 +1,112 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Nodes(Resource):
+    def create_node(
+        self,
+        request: models.NodeCreateRequest,
+        *,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/nodes",
+                data=request.dict(),
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def list_nodes(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.NodeResource]:
+        return [
+            models.NodeResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/nodes",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def get_node_products(
+        self,
+    ) -> list[models.NodeProduct]:
+        return [
+            models.NodeProduct.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET", "/api/v1/nodes/products", data=None, query_parameters={}
+            ).json
+        ]
+
+    def read_node(
+        self,
+        *,
+        id_: int,
+    ) -> models.NodeResource:
+        return models.NodeResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/nodes/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_node(
+        self,
+        request: models.NodeUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.NodeResource:
+        return models.NodeResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/nodes/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_node(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/nodes/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def upgrade_downgrade_node(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+        product: str,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/nodes/{id_}/xgrade",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                    "product": product,
+                },
+            ).json
+        )