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

cyberfusion/CoreApiClient/resources/custom_configs.py

@@ -0,0 +1,82 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class CustomConfigs(Resource):
+    def create_custom_config(
+        self,
+        request: models.CustomConfigCreateRequest,
+    ) -> models.CustomConfigResource:
+        return models.CustomConfigResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/custom-configs",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_custom_configs(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.CustomConfigResource]:
+        return [
+            models.CustomConfigResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/custom-configs",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_custom_config(
+        self,
+        *,
+        id_: int,
+    ) -> models.CustomConfigResource:
+        return models.CustomConfigResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/custom-configs/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_custom_config(
+        self,
+        request: models.CustomConfigUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.CustomConfigResource:
+        return models.CustomConfigResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/custom-configs/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_custom_config(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/custom-configs/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/customers.py

@@ -0,0 +1,97 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Customers(Resource):
+    def list_customers(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.CustomerResource]:
+        return [
+            models.CustomerResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/customers",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_customer(
+        self,
+        *,
+        id_: int,
+    ) -> models.CustomerResource:
+        return models.CustomerResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/customers/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def list_ip_addresses_for_customer(
+        self,
+        *,
+        id_: int,
+    ) -> models.CustomerIPAddresses:
+        return models.CustomerIPAddresses.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/customers/{id_}/ip-addresses",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def create_ip_address_for_customer(
+        self,
+        request: models.CustomerIPAddressCreateRequest,
+        *,
+        id_: int,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/customers/{id_}/ip-addresses",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_ip_address_for_customer(
+        self,
+        *,
+        id_: int,
+        ip_address: str,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/customers/{id_}/ip-addresses/{ip_address}",
+                data=None,
+                query_parameters={},
+            ).json
+        )
+
+    def get_ip_addresses_products_for_customers(
+        self,
+    ) -> list[models.IPAddressProduct]:
+        return [
+            models.IPAddressProduct.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/customers/ip-addresses/products",
+                data=None,
+                query_parameters={},
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/daemons.py

@@ -0,0 +1,76 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Daemons(Resource):
+    def create_daemon(
+        self,
+        request: models.DaemonCreateRequest,
+    ) -> models.DaemonResource:
+        return models.DaemonResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST", "/api/v1/daemons", data=request.dict(), query_parameters={}
+            ).json
+        )
+
+    def list_daemons(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DaemonResource]:
+        return [
+            models.DaemonResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/daemons",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_daemon(
+        self,
+        *,
+        id_: int,
+    ) -> models.DaemonResource:
+        return models.DaemonResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/daemons/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_daemon(
+        self,
+        request: models.DaemonUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.DaemonResource:
+        return models.DaemonResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/daemons/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_daemon(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE", f"/api/v1/daemons/{id_}", data=None, query_parameters={}
+            ).json
+        )

cyberfusion/CoreApiClient/resources/database_user_grants.py

@@ -0,0 +1,66 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class DatabaseUserGrants(Resource):
+    def create_database_user_grant(
+        self,
+        request: models.DatabaseUserGrantCreateRequest,
+    ) -> models.DatabaseUserGrantResource:
+        return models.DatabaseUserGrantResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/database-user-grants",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_database_user_grants(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DatabaseUserGrantResource]:
+        return [
+            models.DatabaseUserGrantResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/database-user-grants",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def list_database_user_grants_for_database_users(
+        self,
+        *,
+        database_user_id: int,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DatabaseUserGrantResource]:
+        return [
+            models.DatabaseUserGrantResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/database-user-grants/{database_user_id}",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/database_users.py

@@ -0,0 +1,82 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class DatabaseUsers(Resource):
+    def create_database_user(
+        self,
+        request: models.DatabaseUserCreateRequest,
+    ) -> models.DatabaseUserResource:
+        return models.DatabaseUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/database-users",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_database_users(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DatabaseUserResource]:
+        return [
+            models.DatabaseUserResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/database-users",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_database_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.DatabaseUserResource:
+        return models.DatabaseUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/database-users/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_database_user(
+        self,
+        request: models.DatabaseUserUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.DatabaseUserResource:
+        return models.DatabaseUserResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/database-users/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_database_user(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/database-users/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/databases.py

@@ -0,0 +1,140 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class Databases(Resource):
+    def create_database(
+        self,
+        request: models.DatabaseCreateRequest,
+    ) -> models.DatabaseResource:
+        return models.DatabaseResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST", "/api/v1/databases", data=request.dict(), query_parameters={}
+            ).json
+        )
+
+    def list_databases(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DatabaseResource]:
+        return [
+            models.DatabaseResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/databases",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_database(
+        self,
+        *,
+        id_: int,
+    ) -> models.DatabaseResource:
+        return models.DatabaseResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/databases/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_database(
+        self,
+        request: models.DatabaseUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.DatabaseResource:
+        return models.DatabaseResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/databases/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_database(
+        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/databases/{id_}",
+                data=None,
+                query_parameters={
+                    "delete_on_cluster": delete_on_cluster,
+                },
+            ).json
+        )
+
+    def compare_databases(
+        self,
+        *,
+        left_database_id: int,
+        right_database_id: int,
+    ) -> models.DatabaseComparison:
+        return models.DatabaseComparison.construct(
+            **self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/databases/{left_database_id}/comparison",
+                data=None,
+                query_parameters={
+                    "right_database_id": right_database_id,
+                },
+            ).json
+        )
+
+    def sync_databases(
+        self,
+        *,
+        left_database_id: int,
+        right_database_id: int,
+        callback_url: Optional[str] = None,
+        exclude_tables_names: Optional[List[str]] = None,
+    ) -> models.TaskCollectionResource:
+        return models.TaskCollectionResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                f"/api/v1/databases/{left_database_id}/sync",
+                data=None,
+                query_parameters={
+                    "callback_url": callback_url,
+                    "right_database_id": right_database_id,
+                    "exclude_tables_names": exclude_tables_names,
+                },
+            ).json
+        )
+
+    def list_database_usages(
+        self,
+        *,
+        database_id: int,
+        timestamp: str,
+        time_unit: Optional[models.DatabaseUsageResource] = None,
+    ) -> list[models.DatabaseUsageResource]:
+        return [
+            models.DatabaseUsageResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                f"/api/v1/databases/usages/{database_id}",
+                data=None,
+                query_parameters={
+                    "timestamp": timestamp,
+                    "time_unit": time_unit,
+                },
+            ).json
+        ]

cyberfusion/CoreApiClient/resources/domain_routers.py

@@ -0,0 +1,43 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class DomainRouters(Resource):
+    def list_domain_routers(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.DomainRouterResource]:
+        return [
+            models.DomainRouterResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/domain-routers",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def update_domain_router(
+        self,
+        request: models.DomainRouterUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.DomainRouterResource:
+        return models.DomainRouterResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/domain-routers/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )

cyberfusion/CoreApiClient/resources/firewall_groups.py

@@ -0,0 +1,82 @@
+from cyberfusion.CoreApiClient import models
+from typing import Optional, List
+
+from cyberfusion.CoreApiClient.interfaces import Resource
+
+
+class FirewallGroups(Resource):
+    def create_firewall_group(
+        self,
+        request: models.FirewallGroupCreateRequest,
+    ) -> models.FirewallGroupResource:
+        return models.FirewallGroupResource.construct(
+            **self.api_connector.send_or_fail(
+                "POST",
+                "/api/v1/firewall-groups",
+                data=request.dict(),
+                query_parameters={},
+            ).json
+        )
+
+    def list_firewall_groups(
+        self,
+        *,
+        skip: Optional[int] = None,
+        limit: Optional[int] = None,
+        filter_: Optional[List[str]] = None,
+        sort: Optional[List[str]] = None,
+    ) -> list[models.FirewallGroupResource]:
+        return [
+            models.FirewallGroupResource.construct(**model)
+            for model in self.api_connector.send_or_fail(
+                "GET",
+                "/api/v1/firewall-groups",
+                data=None,
+                query_parameters={
+                    "skip": skip,
+                    "limit": limit,
+                    "filter": filter_,
+                    "sort": sort,
+                },
+            ).json
+        ]
+
+    def read_firewall_group(
+        self,
+        *,
+        id_: int,
+    ) -> models.FirewallGroupResource:
+        return models.FirewallGroupResource.construct(
+            **self.api_connector.send_or_fail(
+                "GET", f"/api/v1/firewall-groups/{id_}", data=None, query_parameters={}
+            ).json
+        )
+
+    def update_firewall_group(
+        self,
+        request: models.FirewallGroupUpdateRequest,
+        *,
+        id_: int,
+    ) -> models.FirewallGroupResource:
+        return models.FirewallGroupResource.construct(
+            **self.api_connector.send_or_fail(
+                "PATCH",
+                f"/api/v1/firewall-groups/{id_}",
+                data=request.dict(exclude_unset=True),
+                query_parameters={},
+            ).json
+        )
+
+    def delete_firewall_group(
+        self,
+        *,
+        id_: int,
+    ) -> models.DetailMessage:
+        return models.DetailMessage.construct(
+            **self.api_connector.send_or_fail(
+                "DELETE",
+                f"/api/v1/firewall-groups/{id_}",
+                data=None,
+                query_parameters={},
+            ).json
+        )