weni-cli 3.7.2__tar.gz → 3.8.0__tar.gz

{weni_cli-3.7.2 → weni_cli-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: weni-cli
-Version: 3.7.2
+Version: 3.8.0
 Summary: 
 Author: Paulo Bernardo
 Author-email: paulo.bernardo@weni.ai

{weni_cli-3.7.2 → weni_cli-3.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "weni-cli"
-version = "3.7.2"
+version = "3.8.0"
 description = ""
 authors = ["Paulo Bernardo <paulo.bernardo@weni.ai>", "Matheus Leal <matheus.cardoso@vtex.com>"]
 readme = "README.md"

{weni_cli-3.7.2 → weni_cli-3.8.0}/weni_cli/cli.py

@@ -160,6 +160,27 @@ def create_channel(channel_definition):
         click.echo(f"Error: {e}")
 
 
+@cli.group()
+def ticketer():
+    """Ticketer management commands"""
+    pass
+
+
+@ticketer.command("create")
+@click.argument("ticketer_definition", required=True, type=click.Path(exists=True, dir_okay=False))
+def create_ticketer(ticketer_definition):
+    """Create a new ticketer from a definition file
+
+    TICKETER_DEFINITION: The path to the YAML ticketer definition file
+    """
+    from weni_cli.commands.ticketer_create import TicketerCreateHandler
+
+    try:
+        TicketerCreateHandler().execute(ticketer_definition=ticketer_definition)
+    except Exception as e:
+        click.echo(f"Error: {e}")
+
+
 @cli.group()
 def eval():
     """Agent evaluation commands"""

{weni_cli-3.7.2 → weni_cli-3.8.0}/weni_cli/clients/cli_client.py

@@ -382,3 +382,21 @@ class CLIClient:
             return response.json()
         except RequestError as e:
             raise RequestError(f"Failed to create channel: {e.message}")
+
+    def create_ticketer(self, project_uuid: str, ticketer_definition: Dict) -> Dict[str, Any]:
+        """Create a ticketer."""
+        if "ticketers" not in ticketer_definition or not ticketer_definition["ticketers"]:
+            raise ValueError("No ticketers found in definition")
+
+        ticketer_data = ticketer_definition["ticketers"][0]
+
+        payload = {
+            "project_uuid": project_uuid,
+            "ticketer_definition": ticketer_data,
+        }
+
+        try:
+            response = self._make_request(method="POST", endpoint="api/v1/ticketers", json_data=payload)
+            return response.json()
+        except RequestError as e:
+            raise RequestError(f"Failed to create ticketer: {e.message}")

{weni_cli-3.7.2 → weni_cli-3.8.0}/weni_cli/clients/tests/test_cli_client.py

@@ -1169,3 +1169,90 @@ def test_create_channel_with_whatsapp_channel_type(client, mocker):
             "channel_definition": channel_definition["channels"][0]
         }
     )
+
+
+def test_create_ticketer_success(client, mocker):
+    """Test successful ticketer creation."""
+    mock_response = mocker.MagicMock()
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"uuid": "ticketer-uuid", "name": "org support"}
+    mocker.patch.object(client, "_make_request", return_value=mock_response)
+
+    project_uuid = "test-project-uuid"
+    ticketer_definition = {
+        "ticketers": [
+            {
+                "name": "org support",
+                "ticketer_type": "generic",
+                "config": {
+                    "base_url": "https://example.com",
+                    "api_token": "test-api-token",
+                    "webhook_secret": "test-webhook-secret",
+                },
+            }
+        ]
+    }
+
+    client.create_ticketer(project_uuid, ticketer_definition)
+
+    client._make_request.assert_called_once_with(
+        method="POST",
+        endpoint="api/v1/ticketers",
+        json_data={
+            "project_uuid": project_uuid,
+            "ticketer_definition": ticketer_definition["ticketers"][0],
+        },
+    )
+
+
+def test_create_ticketer_no_ticketers_in_definition(client):
+    """Test ticketer creation with no ticketers in definition."""
+    project_uuid = "test-project-uuid"
+    ticketer_definition = {}
+
+    with pytest.raises(ValueError) as exc_info:
+        client.create_ticketer(project_uuid, ticketer_definition)
+
+    assert "No ticketers found in definition" in str(exc_info.value)
+
+
+def test_create_ticketer_empty_ticketers_array(client):
+    """Test ticketer creation with empty ticketers array."""
+    project_uuid = "test-project-uuid"
+    ticketer_definition = {"ticketers": []}
+
+    with pytest.raises(ValueError) as exc_info:
+        client.create_ticketer(project_uuid, ticketer_definition)
+
+    assert "No ticketers found in definition" in str(exc_info.value)
+
+
+def test_create_ticketer_request_error(client, mocker):
+    """Test ticketer creation with request error."""
+    error_message = "Failed to create ticketer in Flows"
+    mocker.patch.object(
+        client,
+        "_make_request",
+        side_effect=RequestError(message=error_message, status_code=400),
+    )
+
+    project_uuid = "test-project-uuid"
+    ticketer_definition = {
+        "ticketers": [
+            {
+                "name": "org support",
+                "ticketer_type": "generic",
+                "config": {
+                    "base_url": "https://example.com",
+                    "api_token": "test-api-token",
+                    "webhook_secret": "test-webhook-secret",
+                },
+            }
+        ]
+    }
+
+    with pytest.raises(RequestError) as exc_info:
+        client.create_ticketer(project_uuid, ticketer_definition)
+
+    assert "Failed to create ticketer" in str(exc_info.value)
+    assert error_message in str(exc_info.value)

weni_cli-3.8.0/weni_cli/commands/ticketer_create.py

@@ -0,0 +1,63 @@
+from weni_cli.clients.cli_client import CLIClient
+from weni_cli.formatter.formatter import Formatter
+from weni_cli.handler import Handler
+from weni_cli.store import STORE_PROJECT_UUID_KEY, Store
+from weni_cli.validators.ticketer_definition import (
+    load_ticketer_definition,
+    validate_ticketer_definition_schema,
+)
+
+
+class TicketerCreateHandler(Handler):
+    def execute(self, **kwargs):
+        ticketer_definition_path = kwargs.get("ticketer_definition")
+
+        formatter = Formatter()
+
+        if not ticketer_definition_path:
+            formatter.print_error_panel("Ticketer definition path is required")
+            return
+
+        store = Store()
+        project_uuid = store.get(STORE_PROJECT_UUID_KEY)
+
+        if not project_uuid:
+            formatter.print_error_panel("No project selected, please select a project first")
+            return
+
+        ticketer_data, error = load_ticketer_definition(ticketer_definition_path)
+        if error:
+            formatter.print_error_panel(error)
+            return
+
+        schema_error = validate_ticketer_definition_schema(ticketer_data)
+        if schema_error:
+            formatter.print_error_panel(schema_error)
+            return
+
+        self._ensure_project_uuid(ticketer_data, project_uuid)
+
+        client = CLIClient()
+        response = client.create_ticketer(project_uuid, ticketer_data)
+
+        ticketer_name = response.get("name") if isinstance(response, dict) else None
+        ticketer_uuid = response.get("uuid") if isinstance(response, dict) else None
+
+        details = []
+        if ticketer_name:
+            details.append(f"Name: {ticketer_name}")
+        if ticketer_uuid:
+            details.append(f"UUID: {ticketer_uuid}")
+
+        if details:
+            formatter.print_success_panel("Ticketer created successfully\n" + "\n".join(details))
+        else:
+            formatter.print_success_panel("Ticketer created successfully")
+
+    def _ensure_project_uuid(self, ticketer_data, project_uuid):
+        if not ticketer_data.get("ticketers"):
+            return
+
+        config = ticketer_data["ticketers"][0].setdefault("config", {})
+        if not config.get("project_uuid", "").strip():
+            config["project_uuid"] = project_uuid

weni_cli-3.8.0/weni_cli/validators/tests/test_ticketer_definition.py

@@ -0,0 +1,206 @@
+import pytest
+from click.testing import CliRunner
+
+from weni_cli.validators.ticketer_definition import (
+    AVAILABLE_TICKETER_TYPES,
+    MAX_TICKETER_NAME_LENGTH,
+    load_ticketer_definition,
+    validate_ticketer_definition_schema,
+)
+
+
+@pytest.fixture
+def sample_definition_file():
+    """Create a sample ticketer definition file for testing."""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        with open("valid_ticketer_definition.yaml", "w") as f:
+            f.write(
+                """
+ticketers:
+  - name: org support
+    ticketer_type: generic
+    config:
+      base_url: https://example.com
+      api_token: test-api-token
+      webhook_secret: test-webhook-secret
+      project_name: org support
+                """
+            )
+
+        with open("empty_ticketer_definition.yaml", "w") as f:
+            f.write("")
+
+        yield {
+            "valid_path": "valid_ticketer_definition.yaml",
+            "empty_path": "empty_ticketer_definition.yaml",
+        }
+
+
+@pytest.fixture
+def valid_ticketer_definition():
+    """Return a valid ticketer definition dictionary."""
+    return {
+        "ticketers": [
+            {
+                "name": "org support",
+                "ticketer_type": "generic",
+                "config": {
+                    "base_url": "https://example.com",
+                    "api_token": "test-api-token",
+                    "webhook_secret": "test-webhook-secret",
+                },
+            }
+        ]
+    }
+
+
+class TestValidateTicketerDefinitionSchema:
+    """Tests for validate_ticketer_definition_schema function."""
+
+    def test_valid_ticketer_definition(self, valid_ticketer_definition):
+        error = validate_ticketer_definition_schema(valid_ticketer_definition)
+        assert error is None
+
+    def test_valid_ticketer_definition_with_skip_hmac(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        del data["ticketers"][0]["config"]["webhook_secret"]
+        data["ticketers"][0]["config"]["skip_webhook_hmac"] = "true"
+        error = validate_ticketer_definition_schema(data)
+        assert error is None
+
+    def test_missing_ticketers_key(self):
+        error = validate_ticketer_definition_schema({})
+        assert error == "Missing required root key 'ticketers' in the ticketer definition file"
+
+    def test_ticketers_not_array(self):
+        error = validate_ticketer_definition_schema({"ticketers": {}})
+        assert error == "'ticketers' must be an array in the ticketer definition file"
+
+    def test_empty_ticketers_array(self):
+        error = validate_ticketer_definition_schema({"ticketers": []})
+        assert error == "No ticketers defined in the ticketer definition file"
+
+    def test_ticketer_not_object(self):
+        error = validate_ticketer_definition_schema({"ticketers": ["not an object"]})
+        assert error == "Ticketer at index 0 must be an object in the ticketer definition file"
+
+    def test_missing_name(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        del data["ticketers"][0]["name"]
+        error = validate_ticketer_definition_schema(data)
+        assert error == "Ticketer at index 0 is missing required field 'name' in the ticketer definition file"
+
+    def test_name_too_long(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["name"] = "x" * (MAX_TICKETER_NAME_LENGTH + 1)
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == f"Ticketer at index 0: 'name' must be less than {MAX_TICKETER_NAME_LENGTH} characters in the ticketer definition file"
+        )
+
+    def test_missing_ticketer_type(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        del data["ticketers"][0]["ticketer_type"]
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == "Ticketer at index 0 is missing required field 'ticketer_type' in the ticketer definition file"
+        )
+
+    def test_invalid_ticketer_type(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["ticketer_type"] = "invalid"
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == f"Ticketer at index 0: 'ticketer_type' must be one of: {', '.join(AVAILABLE_TICKETER_TYPES)} in the ticketer definition file"
+        )
+
+    def test_missing_config(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        del data["ticketers"][0]["config"]
+        error = validate_ticketer_definition_schema(data)
+        assert error == "Ticketer at index 0 is missing required field 'config' in the ticketer definition file"
+
+    def test_missing_base_url(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        del data["ticketers"][0]["config"]["base_url"]
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == "Ticketer at index 0: 'config' is missing required field 'base_url' in the ticketer definition file"
+        )
+
+    def test_invalid_base_url(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        data["ticketers"][0]["config"]["base_url"] = "not-a-valid-url"
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == "Ticketer at index 0: 'config.base_url' must be a valid URL starting with http:// or https:// in the ticketer definition file"
+        )
+
+    def test_missing_webhook_secret_without_skip_hmac(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        del data["ticketers"][0]["config"]["webhook_secret"]
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == "Ticketer at index 0: 'config.webhook_secret' is required unless "
+            "'config.skip_webhook_hmac' is set to true, 1 or yes in the ticketer definition file"
+        )
+
+    def test_config_value_not_string(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        data["ticketers"][0]["config"]["api_token"] = 123
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error == "Ticketer at index 0: 'config.api_token' must be a string in the ticketer definition file"
+        )
+
+    def test_unknown_config_field(self, valid_ticketer_definition):
+        data = valid_ticketer_definition.copy()
+        data["ticketers"] = [dict(data["ticketers"][0])]
+        data["ticketers"][0]["config"] = dict(data["ticketers"][0]["config"])
+        data["ticketers"][0]["config"]["unknown_field"] = "value"
+        error = validate_ticketer_definition_schema(data)
+        assert (
+            error
+            == "Ticketer at index 0: 'config.unknown_field' is not a recognized field in the ticketer definition file"
+        )
+
+
+class TestLoadTicketerDefinition:
+    """Tests for load_ticketer_definition function."""
+
+    def test_load_valid_ticketer_definition(self, sample_definition_file):
+        data, error = load_ticketer_definition(sample_definition_file["valid_path"])
+        assert error is None
+        assert "ticketers" in data
+
+    def test_load_empty_ticketer_definition(self, sample_definition_file):
+        data, error = load_ticketer_definition(sample_definition_file["empty_path"])
+        assert data is None
+        assert str(error) == "Empty definition file"
+
+    def test_load_nonexistent_file(self):
+        data, error = load_ticketer_definition("nonexistent.yaml")
+        assert data is None
+        assert error is not None

weni_cli-3.8.0/weni_cli/validators/ticketer_definition.py

@@ -0,0 +1,177 @@
+import re
+from typing import Any, Optional
+
+from weni_cli.validators.channel_definition import load_yaml_file
+
+# Constants for ticketer validation
+MAX_TICKETER_NAME_LENGTH = 100
+AVAILABLE_TICKETER_TYPES = ["generic"]
+
+REQUIRED_CONFIG_FIELDS = ["base_url", "api_token"]
+
+OPTIONAL_CONFIG_FIELDS = [
+    "skip_webhook_hmac",
+    "project_uuid",
+    "project_name",
+    "route_open",
+    "route_forward",
+    "route_close",
+    "route_reopen",
+    "route_history",
+    "webhook_secret",
+]
+
+URL_PATTERN = re.compile(r"^https?://")
+
+
+def skip_webhook_hmac_enabled(value: str) -> bool:
+    """Return True when skip_webhook_hmac disables HMAC verification."""
+    normalized = value.strip().lower()
+    return normalized in ("true", "1", "yes")
+
+
+def validate_ticketer_definition_schema(data):
+    """
+    Validates that the ticketer definition YAML contains all required fields and has a valid structure.
+
+    Args:
+        data (dict): Parsed YAML data
+
+    Returns:
+        str | None: Error message if validation fails, None otherwise
+    """
+    if data.get("ticketers") is None:
+        return "Missing required root key 'ticketers' in the ticketer definition file"
+
+    if not isinstance(data["ticketers"], list):
+        return "'ticketers' must be an array in the ticketer definition file"
+
+    if not data["ticketers"]:
+        return "No ticketers defined in the ticketer definition file"
+
+    for ticketer_idx, ticketer_data in enumerate(data["ticketers"]):
+        if not isinstance(ticketer_data, dict):
+            return f"Ticketer at index {ticketer_idx} must be an object in the ticketer definition file"
+
+        if not ticketer_data.get("name"):
+            return (
+                f"Ticketer at index {ticketer_idx} is missing required field 'name' "
+                "in the ticketer definition file"
+            )
+        if not isinstance(ticketer_data["name"], str):
+            return (
+                f"Ticketer at index {ticketer_idx}: 'name' must be a string "
+                "in the ticketer definition file"
+            )
+        if len(ticketer_data["name"]) > MAX_TICKETER_NAME_LENGTH:
+            return (
+                f"Ticketer at index {ticketer_idx}: 'name' must be less than "
+                f"{MAX_TICKETER_NAME_LENGTH} characters in the ticketer definition file"
+            )
+
+        if not ticketer_data.get("ticketer_type"):
+            return (
+                f"Ticketer at index {ticketer_idx} is missing required field 'ticketer_type' "
+                "in the ticketer definition file"
+            )
+        if not isinstance(ticketer_data["ticketer_type"], str):
+            return (
+                f"Ticketer at index {ticketer_idx}: 'ticketer_type' must be a string "
+                "in the ticketer definition file"
+            )
+        if ticketer_data["ticketer_type"] not in AVAILABLE_TICKETER_TYPES:
+            return (
+                f"Ticketer at index {ticketer_idx}: 'ticketer_type' must be one of: "
+                f"{', '.join(AVAILABLE_TICKETER_TYPES)} in the ticketer definition file"
+            )
+
+        if not ticketer_data.get("config"):
+            return (
+                f"Ticketer at index {ticketer_idx} is missing required field 'config' "
+                "in the ticketer definition file"
+            )
+        if not isinstance(ticketer_data["config"], dict):
+            return (
+                f"Ticketer at index {ticketer_idx}: 'config' must be an object "
+                "in the ticketer definition file"
+            )
+
+        config = ticketer_data["config"]
+        allowed_fields = set(REQUIRED_CONFIG_FIELDS + OPTIONAL_CONFIG_FIELDS)
+
+        for field in REQUIRED_CONFIG_FIELDS:
+            if field not in config:
+                return (
+                    f"Ticketer at index {ticketer_idx}: 'config' is missing required field "
+                    f"'{field}' in the ticketer definition file"
+                )
+
+        for field, value in config.items():
+            if field not in allowed_fields:
+                return (
+                    f"Ticketer at index {ticketer_idx}: 'config.{field}' is not a recognized "
+                    "field in the ticketer definition file"
+                )
+            if not isinstance(value, str):
+                return (
+                    f"Ticketer at index {ticketer_idx}: 'config.{field}' must be a string "
+                    "in the ticketer definition file"
+                )
+
+        if not config["base_url"].strip():
+            return (
+                f"Ticketer at index {ticketer_idx}: 'config.base_url' must not be empty "
+                "in the ticketer definition file"
+            )
+        if not URL_PATTERN.match(config["base_url"].strip()):
+            return (
+                f"Ticketer at index {ticketer_idx}: 'config.base_url' must be a valid URL "
+                "starting with http:// or https:// in the ticketer definition file"
+            )
+
+        if not config["api_token"].strip():
+            return (
+                f"Ticketer at index {ticketer_idx}: 'config.api_token' must not be empty "
+                "in the ticketer definition file"
+            )
+
+        skip_hmac = skip_webhook_hmac_enabled(config.get("skip_webhook_hmac", ""))
+        webhook_secret = config.get("webhook_secret", "").strip()
+        if not skip_hmac and not webhook_secret:
+            return (
+                f"Ticketer at index {ticketer_idx}: 'config.webhook_secret' is required unless "
+                "'config.skip_webhook_hmac' is set to true, 1 or yes in the ticketer definition file"
+            )
+
+        for field in OPTIONAL_CONFIG_FIELDS:
+            if field in config and field != "skip_webhook_hmac" and not config[field].strip():
+                if field == "webhook_secret" and skip_hmac:
+                    continue
+                if field in ("project_uuid", "project_name") and config[field] == "":
+                    continue
+                return (
+                    f"Ticketer at index {ticketer_idx}: 'config.{field}' must not be empty "
+                    "in the ticketer definition file"
+                )
+
+    return None
+
+
+def load_ticketer_definition(path) -> tuple[Any, Optional[Exception]]:
+    """
+    Loads a ticketer definition from a YAML file.
+
+    Args:
+        path (str): Path to the ticketer definition file
+
+    Returns:
+        tuple: (parsed_data, error) where error is None if successful
+    """
+    data, error = load_yaml_file(path)
+    if error:
+        return None, error
+
+    if not data:
+        return None, Exception("Empty definition file")
+
+    return data, None