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

cyberfusion/CoreApiClient/resources/firewall_rules.py

@@ -0,0 +1,67 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class FirewallRules(Resource):
+    def create_firewall_rule(
+        self,
+        request: models.FirewallRuleCreateRequest,
+    ) -> models.FirewallRuleResource:
+        return models.FirewallRuleResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/firewall-rules",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_firewall_rules(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.FirewallRuleResource]:
+        return [
+            models.FirewallRuleResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/firewall-rules",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_firewall_rule(
+        self,
+        *,
+        id_: int,
+    ) -> models.FirewallRuleResource:
+        return models.FirewallRuleResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/firewall-rules/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_firewall_rule(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/firewall-rules/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/fpm_pools.py

@@ -0,0 +1,110 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class FPMPools(Resource):
+    def create_fpm_pool(
+        self,
+        request: models.FPMPoolCreateRequest,
+    ) -> models.FPMPoolResource:
+        return models.FPMPoolResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST", "/api/v1/fpm-pools", data=request.dict(), query_parameters={}
+            ).json
+        )
+
+    def list_fpm_pools(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.FPMPoolResource]:
+        return [
+            models.FPMPoolResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/fpm-pools",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_fpm_pool(
+        self,
+        *,
+        id_: int,
+    ) -> models.FPMPoolResource:
+        return models.FPMPoolResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/fpm-pools/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_fpm_pool(
+        self,
+        request: models.FPMPoolUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.FPMPoolResource:
+        return models.FPMPoolResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/fpm-pools/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_fpm_pool(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/fpm-pools/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def restart_fpm_pool(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/fpm-pools/{id_}/restart",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )
+
+    def reload_fpm_pool(
+        self,
+        *,
+        id_: int,
+        callback_url: Optional[str] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/fpm-pools/{id_}/reload",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                },
+            ).json
+        )

cyberfusion/CoreApiClient/resources/ftp_users.py

@@ -0,0 +1,89 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class FTPUsers(Resource):
+    def create_ftp_user(
+        self,
+        request: models.FTPUserCreateRequest,
+    ) -> models.FTPUserResource:
+        return models.FTPUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST", "/api/v1/ftp-users", data=request.dict(), query_parameters={}
+            ).json
+        )
+
+    def list_ftp_users(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.FTPUserResource]:
+        return [
+            models.FTPUserResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/ftp-users",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_ftp_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.FTPUserResource:
+        return models.FTPUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/ftp-users/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_ftp_user(
+        self,
+        request: models.FTPUserUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.FTPUserResource:
+        return models.FTPUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/ftp-users/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_ftp_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/ftp-users/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def create_temporary_ftp_user(
+        self,
+        request: models.TemporaryFTPUserCreateRequest,
+    ) -> models.TemporaryFTPUserResource:
+        return models.TemporaryFTPUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/ftp-users/temporary",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/haproxy_listens.py

@@ -0,0 +1,67 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class HAProxyListens(Resource):
+    def create_haproxy_listen(
+        self,
+        request: models.HAProxyListenCreateRequest,
+    ) -> models.HAProxyListenResource:
+        return models.HAProxyListenResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/haproxy-listens",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_haproxy_listens(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.HAProxyListenResource]:
+        return [
+            models.HAProxyListenResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/haproxy-listens",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_haproxy_listen(
+        self,
+        *,
+        id_: int,
+    ) -> models.HAProxyListenResource:
+        return models.HAProxyListenResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/haproxy-listens/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_haproxy_listen(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/haproxy-listens/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/haproxy_listens_to_nodes.py

@@ -0,0 +1,70 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class HAProxyListensToNodes(Resource):
+    def create_haproxy_listen_to_node(
+        self,
+        request: models.HAProxyListenToNodeCreateRequest,
+    ) -> models.HAProxyListenToNodeResource:
+        return models.HAProxyListenToNodeResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/haproxy-listens-to-nodes",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_haproxy_listens_to_nodes(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.HAProxyListenToNodeResource]:
+        return [
+            models.HAProxyListenToNodeResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/haproxy-listens-to-nodes",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_haproxy_listen_to_node(
+        self,
+        *,
+        id_: int,
+    ) -> models.HAProxyListenToNodeResource:
+        return models.HAProxyListenToNodeResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/haproxy-listens-to-nodes/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def delete_haproxy_listen_to_node(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/haproxy-listens-to-nodes/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/health.py

@@ -0,0 +1,14 @@
+from cyberfusion.CoreApiClient import models
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Health(Resource):
+    def read_health(
+        self,
+    ) -> models.HealthResource:
+        return models.HealthResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", "/api/v1/health", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/hosts_entries.py

@@ -0,0 +1,63 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class HostsEntries(Resource):
+    def create_hosts_entry(
+        self,
+        request: models.HostsEntryCreateRequest,
+    ) -> models.HostsEntryResource:
+        return models.HostsEntryResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/hosts-entries",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_hosts_entries(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.HostsEntryResource]:
+        return [
+            models.HostsEntryResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/hosts-entries",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_hosts_entry(
+        self,
+        *,
+        id_: int,
+    ) -> models.HostsEntryResource:
+        return models.HostsEntryResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/hosts-entries/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_hosts_entry(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/hosts-entries/{id_}", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/htpasswd_files.py

@@ -0,0 +1,67 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class HtpasswdFiles(Resource):
+    def create_htpasswd_file(
+        self,
+        request: models.HtpasswdFileCreateRequest,
+    ) -> models.HtpasswdFileResource:
+        return models.HtpasswdFileResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/htpasswd-files",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_htpasswd_files(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.HtpasswdFileResource]:
+        return [
+            models.HtpasswdFileResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/htpasswd-files",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_htpasswd_file(
+        self,
+        *,
+        id_: int,
+    ) -> models.HtpasswdFileResource:
+        return models.HtpasswdFileResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/htpasswd-files/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def delete_htpasswd_file(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/htpasswd-files/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/htpasswd_users.py

@@ -0,0 +1,82 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class HtpasswdUsers(Resource):
+    def create_htpasswd_user(
+        self,
+        request: models.HtpasswdUserCreateRequest,
+    ) -> models.HtpasswdUserResource:
+        return models.HtpasswdUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/htpasswd-users",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_htpasswd_users(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.HtpasswdUserResource]:
+        return [
+            models.HtpasswdUserResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/htpasswd-users",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_htpasswd_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.HtpasswdUserResource:
+        return models.HtpasswdUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/htpasswd-users/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_htpasswd_user(
+        self,
+        request: models.HtpasswdUserUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.HtpasswdUserResource:
+        return models.HtpasswdUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/htpasswd-users/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_htpasswd_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/htpasswd-users/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/login.py

@@ -0,0 +1,28 @@
+from cyberfusion.CoreApiClient import models
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Login(Resource):
+    def request_access_token(
+        self,
+        request: models.BodyLoginAccessToken,
+    ) -> models.TokenResource:
+        return models.TokenResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/login/access-token",
+                data=request.dict(),
+                query_parameters={},
+                content_type="application/x-www-form-urlencoded",
+            ).json
+        )
+
+    def test_access_token(
+        self,
+    ) -> models.APIUserInfo:
+        return models.APIUserInfo.construct(
+            **self.api_connector.send_or_fail(
+                "POST", "/api/v1/login/test-token", data=None, query_parameters={}
+            ).json
+        )