cacholong-cloud-cli 0.3.0__py3-none-any.whl

cacholong_cli/AsyncTyper.py

@@ -0,0 +1,17 @@
+from asyncio import run
+from functools import wraps
+
+import typer
+
+
+class AsyncTyper(typer.Typer):
+    def async_command(self, *args, **kwargs):
+        def decorator(async_func):
+            @wraps(async_func)
+            def sync_func(*_args, **_kwargs):
+                return run(async_func(*_args, **_kwargs))
+
+            self.command(*args, **kwargs)(sync_func)
+            return async_func
+
+        return decorator

cacholong_cli/cli.py

@@ -0,0 +1,110 @@
+import importlib.metadata
+
+import os
+import sys
+import typer
+from typing import Optional
+from cacholong_cli.commands import (
+    accounts,
+    addresses,
+    companies,
+    dns_records,
+    dns_templates,
+    dns_zones,
+    products,
+    purchases,
+)
+from cacholong_cli.common import OutputFormat
+from xdg import BaseDirectory
+
+
+# Version of our CLI
+__version__ = importlib.metadata.version("cacholong-cloud-cli")
+
+# Check if required config.ini file exists
+configpath = BaseDirectory.save_config_path("cacholong-cli")
+if not os.path.exists(os.path.join(configpath, "config.ini")):
+    print("Get a token through our panel at https://cp.cacholong.eu/")
+    token = input("API Token: ")
+    if len(token) == 0:
+        print("Invalid token")
+        sys.exit(1)
+    with open(os.path.join(configpath, "config.ini"), "w") as f:
+        f.write("[DEFAULT]\n")
+        f.write("api_url = 'https://api.cacholong.eu/api/v1/'\n")
+        f.write("api_key = '" + token + "'\n")
+
+# Generate the available commands
+app = typer.Typer()
+app.add_typer(accounts.app, name="accounts", help="Manage accounts")
+app.add_typer(
+    addresses.app, name="addresses", help="Manage addresses for users and companies"
+)
+app.add_typer(companies.app, name="companies", help="Manage companies")
+app.add_typer(dns_records.app, name="dns-records", help="Manage DNS records")
+app.add_typer(dns_templates.app, name="dns-templates", help="Manage DNS templates")
+app.add_typer(dns_zones.app, name="dns-zones", help="Manage DNS zones")
+app.add_typer(products.app, name="products", help="Manage products")
+app.add_typer(purchases.app, name="purchases", help="Manage purchases")
+
+
+# Handle version
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"cacholong cli version: {__version__}")
+        raise typer.Exit()
+
+
+def _verbose_callback(ctx: typer.Context, value: bool) -> None:
+    ctx.obj["verbose"] = False
+    if value:
+        ctx.obj["verbose"] = True
+
+
+def _output_callback(ctx: typer.Context, value: OutputFormat) -> None:
+    ctx.obj["output"] = value
+
+
+def _create_issue_callback(ctx: typer.Context, value: bool) -> None:
+    ctx.obj["create_issue"] = value
+
+
+def _sync_callback(ctx: typer.Context, value: bool) -> None:
+    ctx.obj["sync"] = value
+
+
+def _sort_callback(ctx: typer.Context, value: str) -> None:
+    ctx.obj["sort"] = value
+
+
+@app.callback(context_settings={"obj": {}})
+def main(
+    ctx: typer.Context,
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        help="Show the application's version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+    verbose: Optional[bool] = typer.Option(
+        None, "--verbose", help="Verbose output", callback=_verbose_callback
+    ),
+    sort: Optional[str] = typer.Option(
+        "-created_at", "--sort", help="Field to sort on", callback=_sort_callback
+    ),
+    create_issue: bool = typer.Option(
+        False,
+        "--create-issue",
+        help="Create an issue in gitlab",
+        callback=_create_issue_callback,
+    ),
+    sync: bool = typer.Option(
+        False, "--sync", help="Process action directly", callback=_sync_callback
+    ),
+    output: OutputFormat = typer.Option(
+        "table", "--output", help="Output format", callback=_output_callback
+    ),
+) -> None:
+
+    return

cacholong_cli/commands/accounts.py

@@ -0,0 +1,105 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import Account, AccountModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def list(
+    ctx: typer.Context,
+    name: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Must be unique. Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote, numbers 0 to 9, space or the following symbols: @ & + - ( ) ? ! * # /"
+        ),
+    ] = None,
+    display_name: Annotated[Optional[str], typer.Option(help="")] = None,
+    description: Annotated[Optional[str], typer.Option(help="")] = None,
+    created_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    updated_at: Annotated[Optional[str], typer.Option(help="")] = None,
+    account_type: Annotated[
+        Optional[str], typer.Option(help="Only available for certain users.")
+    ] = None,
+    account_account_id: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Only available for certain users. When used, account_account_relation is mandatory."
+        ),
+    ] = None,
+    account_account_relation: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Only available for certain users. When used, account_account_id is mandatory."
+        ),
+    ] = None,
+    company: Annotated[Optional[UUID], typer.Option(help="")] = None,
+):
+    # Build modifier
+    modifier = []
+    if name is not None:
+        modifier.append(Filter(name=name))
+    if display_name is not None:
+        modifier.append(Filter(query_str="filter[display_name]=" + str(display_name)))
+    if description is not None:
+        modifier.append(Filter(description=description))
+    if created_at is not None:
+        modifier.append(Filter(query_str="filter[created_at]=" + str(created_at)))
+    if updated_at is not None:
+        modifier.append(Filter(query_str="filter[updated_at]=" + str(updated_at)))
+    if account_type is not None:
+        modifier.append(Filter(query_str="filter[account_type]=" + str(account_type)))
+    if account_account_id is not None:
+        modifier.append(
+            Filter(query_str="filter[account_account_id]=" + str(account_account_id))
+        )
+    if account_account_relation is not None:
+        modifier.append(
+            Filter(
+                query_str="filter[account_account_relation]="
+                + str(account_account_relation)
+            )
+        )
+    if company is not None:
+        modifier.append(Filter(company=str(company)))
+
+    # Table definition
+    tabledef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {"header": "Name", "column": "name"},
+        {"header": "Display name", "column": "display_name"},
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+    async with Connection() as conn:
+        await list_resources(ctx, Account(conn), tabledef, modifier)
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    account_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = Account(conn)
+            model = await ctrl.fetch(account_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)

cacholong_cli/commands/addresses.py

@@ -0,0 +1,280 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import Address, AddressModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def list(
+    ctx: typer.Context,
+    street: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ] = None,
+    number: Annotated[
+        Optional[str], typer.Option(help="Can contain any number from any language.")
+    ] = None,
+    suffix: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter or number from any language or space."
+        ),
+    ] = None,
+    zipcode: Annotated[
+        Optional[str],
+        typer.Option(help="Must contain valid zipcode from NL,BE,DE,GB or US."),
+    ] = None,
+    city: Annotated[
+        Optional[str],
+        typer.Option(help="Can contain any letter from any language or space."),
+    ] = None,
+    state: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ] = None,
+    country: Annotated[
+        Optional[str], typer.Option(help="Must contain two uppercase letters (A-Z).")
+    ] = None,
+    user: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing user. Required unless company is given. Readonly on update."
+        ),
+    ] = None,
+    company: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing company. Required unless user is given. Readonly on update."
+        ),
+    ] = None,
+):
+    # Build modifier
+    modifier = []
+    if street is not None:
+        modifier.append(Filter(street=street))
+    if number is not None:
+        modifier.append(Filter(number=number))
+    if suffix is not None:
+        modifier.append(Filter(suffix=suffix))
+    if zipcode is not None:
+        modifier.append(Filter(zipcode=zipcode))
+    if city is not None:
+        modifier.append(Filter(city=city))
+    if state is not None:
+        modifier.append(Filter(state=state))
+    if country is not None:
+        modifier.append(Filter(country=country))
+    if user is not None:
+        modifier.append(Filter(user=str(user)))
+    if company is not None:
+        modifier.append(Filter(company=str(company)))
+    modifier.append(Inclusion("company"))
+    modifier.append(Inclusion("user"))
+
+    # Table definition
+    tabledef = [
+        {"header": Column("Id", no_wrap=True), "column": "id"},
+        {"header": "Company", "column": "company", "nested_column": "name"},
+        {"header": "User", "column": "user", "nested_column": "name"},
+        {"header": "Street", "column": "street"},
+        {"header": "Number", "column": "number"},
+        {"header": "City", "column": "city"},
+        {"header": "Created", "column": "created_at"},
+        {"header": "Updated", "column": "updated_at"},
+    ]
+    async with Connection() as conn:
+        await list_resources(ctx, Address(conn), tabledef, modifier)
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    address_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = Address(conn)
+            model = await ctrl.fetch(address_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def create(
+    ctx: typer.Context,
+    street: Annotated[
+        str,
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ],
+    number: Annotated[
+        str, typer.Option(help="Can contain any number from any language.")
+    ],
+    zipcode: Annotated[
+        str, typer.Option(help="Must contain valid zipcode from NL,BE,DE,GB or US.")
+    ],
+    city: Annotated[
+        str, typer.Option(help="Can contain any letter from any language or space.")
+    ],
+    country: Annotated[
+        str, typer.Option(help="Must contain two uppercase letters (A-Z).")
+    ],
+    suffix: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter or number from any language or space."
+        ),
+    ] = None,
+    state: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ] = None,
+    user: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing user. Required unless company is given. Readonly on update."
+        ),
+    ] = None,
+    company: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing company. Required unless user is given. Readonly on update."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = Address(conn)
+            model = ctrl.create()
+            model["street"] = street
+            model["number"] = number
+            if suffix is not None:
+                model["suffix"] = suffix
+            model["zipcode"] = zipcode
+            model["city"] = city
+            if state is not None:
+                model["state"] = state
+            model["country"] = country
+            if user is not None:
+                model["user"] = ResourceTuple(user, "users")
+            if company is not None:
+                model["company"] = ResourceTuple(company, "companies")
+            await ctrl.store(model, ctx.obj["create_issue"])
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def update(
+    ctx: typer.Context,
+    address_id: Annotated[UUID, typer.Argument()],
+    street: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ] = None,
+    number: Annotated[
+        Optional[str], typer.Option(help="Can contain any number from any language.")
+    ] = None,
+    suffix: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter or number from any language or space."
+        ),
+    ] = None,
+    zipcode: Annotated[
+        Optional[str],
+        typer.Option(help="Must contain valid zipcode from NL,BE,DE,GB or US."),
+    ] = None,
+    city: Annotated[
+        Optional[str],
+        typer.Option(help="Can contain any letter from any language or space."),
+    ] = None,
+    state: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, single or alternative quote or space."
+        ),
+    ] = None,
+    country: Annotated[
+        Optional[str], typer.Option(help="Must contain two uppercase letters (A-Z).")
+    ] = None,
+    user: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing user. Required unless company is given. Readonly on update."
+        ),
+    ] = None,
+    company: Annotated[
+        Optional[UUID],
+        typer.Option(
+            help="Existing company. Required unless user is given. Readonly on update."
+        ),
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = Address(conn)
+            model = await ctrl.fetch(address_id)
+            if street is not None:
+                model["street"] = street
+            if number is not None:
+                model["number"] = number
+            if suffix is not None:
+                model["suffix"] = suffix
+            if zipcode is not None:
+                model["zipcode"] = zipcode
+            if city is not None:
+                model["city"] = city
+            if state is not None:
+                model["state"] = state
+            if country is not None:
+                model["country"] = country
+            if user is not None:
+                model["user"].set(user, "users")
+            if company is not None:
+                model["company"].set(company, "companies")
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def delete(
+    ctx: typer.Context,
+    address_id: Annotated[List[UUID], typer.Argument()],
+):
+    try:
+        async with Connection() as conn, asyncio.TaskGroup() as tg:
+            ctrl = Address(conn)
+            for resource_id in address_id:
+                tg.create_task(ctrl.destroy(resource_id))
+    except DocumentError as e:
+        await print_document_error(e)

cacholong_cli/commands/companies.py

@@ -0,0 +1,100 @@
+import asyncio
+import typer
+from typing import List, Optional
+from typing_extensions import Annotated
+from rich.table import Column
+from uuid import UUID
+from cacholong_cli.AsyncTyper import AsyncTyper
+from cacholong_cli.common import (
+    list_resources,
+    list_relation_resources,
+    show_resource,
+    print_document_error,
+)
+from cacholong_cli.connection import Connection
+from cacholong_sdk import Filter, Inclusion, DocumentError, ResourceTuple
+from cacholong_sdk import Company, CompanyModel
+
+# Create typer object
+app = AsyncTyper()
+
+
+@app.async_command()
+async def show(
+    ctx: typer.Context,
+    company_id: Annotated[UUID, typer.Argument()],
+):
+    # Show resource
+    try:
+        async with Connection() as conn:
+            ctrl = Company(conn)
+            model = await ctrl.fetch(company_id)
+
+            show_resource(ctx, model)
+    except DocumentError as e:
+        await print_document_error(e)
+
+
+@app.async_command()
+async def update(
+    ctx: typer.Context,
+    company_id: Annotated[UUID, typer.Argument()],
+    name: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Must be unique. Can contain any letter (combined with accent) from any language, any kind of hyphen or dash, numbers 0 to 9, space, point or the folowing symbols: @ & + - ( ) ? ! * # /"
+        ),
+    ] = None,
+    kvknr: Annotated[Optional[str], typer.Option(help="")] = None,
+    phone: Annotated[
+        Optional[str],
+        typer.Option(help="Can contain valid phonenumber from NL,BE,DE,GB or US."),
+    ] = None,
+    email: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Email will be validated and DNS records checked to make sure server accepts emails."
+        ),
+    ] = None,
+    email_invoice: Annotated[
+        Optional[str],
+        typer.Option(
+            help="Email for invoicing, defaults to email if not given. Email will be validated and DNS records checked to make sure server accepts emails."
+        ),
+    ] = None,
+    vat_number: Annotated[
+        Optional[str],
+        typer.Option(
+            help="VAT number, must be valid. If not given, it will be set to null. If given, it will be validated."
+        ),
+    ] = None,
+    account: Annotated[
+        Optional[UUID],
+        typer.Option(help="Existing account. Must be unique. Readonly on update."),
+    ] = None,
+    addresses: Annotated[
+        Optional[List[UUID]], typer.Option(help="Existing addresses. Readonly.")
+    ] = None,
+):
+    try:
+        async with Connection() as conn:
+            ctrl = Company(conn)
+            model = await ctrl.fetch(company_id)
+            if name is not None:
+                model["name"] = name
+            if kvknr is not None:
+                model["kvknr"] = kvknr
+            if phone is not None:
+                model["phone"] = phone
+            if email is not None:
+                model["email"] = email
+            if email_invoice is not None:
+                model["email_invoice"] = email_invoice
+            if vat_number is not None:
+                model["vat_number"] = vat_number
+            if account is not None:
+                model["account"].set(account, "accounts")
+            if addresses is not None:
+                model["addresses"].set(addresses, "addresses")
+    except DocumentError as e:
+        await print_document_error(e)