google-analytics-cli 0.1.0__py3-none-any.whl

ga_cli/commands/data_streams.py

@@ -0,0 +1,277 @@
+"""Data stream management commands."""
+
+from typing import Optional
+
+import questionary
+import typer
+
+from ..api.client import get_admin_client
+from ..config.store import get_effective_value
+from ..utils import (
+    handle_dry_run,
+    handle_error,
+    info,
+    output,
+    require_options,
+    resolve_output_format,
+    success,
+)
+from ..utils.pagination import paginate_all
+
+data_streams_app = typer.Typer(
+    name="data-streams", help="Manage GA4 data streams", no_args_is_help=True
+)
+
+# Stream types that require additional configuration
+_WEB_STREAM = "WEB_DATA_STREAM"
+_ANDROID_STREAM = "ANDROID_APP_DATA_STREAM"
+_IOS_STREAM = "IOS_APP_DATA_STREAM"
+
+
+@data_streams_app.command("list")
+def list_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """List data streams for a property."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_client()
+        streams = paginate_all(
+            lambda **kw: admin.properties()
+            .dataStreams()
+            .list(parent=f"properties/{effective_property}", **kw)
+            .execute(),
+            "dataStreams",
+            pageSize=200,
+        )
+
+        output(
+            streams,
+            effective_format,
+            columns=["name", "type", "displayName", "createTime"],
+            headers=["Resource Name", "Type", "Display Name", "Created"],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@data_streams_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data Stream ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get data stream details."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_client()
+        stream = (
+            admin.properties()
+            .dataStreams()
+            .get(
+                name=f"properties/{effective_property}/dataStreams/{stream_id}",
+            )
+            .execute()
+        )
+        output(stream, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@data_streams_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    display_name: str = typer.Option(
+        ..., "--display-name", help="Stream display name"
+    ),
+    stream_type: str = typer.Option(
+        _WEB_STREAM,
+        "--type",
+        "-t",
+        help="Stream type: WEB_DATA_STREAM, ANDROID_APP_DATA_STREAM, IOS_APP_DATA_STREAM",
+    ),
+    url: Optional[str] = typer.Option(
+        None, "--url", help="Default URI (required for web streams)"
+    ),
+    bundle_id: Optional[str] = typer.Option(
+        None, "--bundle-id", help="App bundle ID (required for app streams)"
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Create a new data stream."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = {
+            "displayName": display_name,
+            "type": stream_type,
+        }
+
+        # Validate and add type-specific data
+        if stream_type == _WEB_STREAM:
+            if not url:
+                raise typer.BadParameter(
+                    "--url is required for WEB_DATA_STREAM type"
+                )
+            body["webStreamData"] = {"defaultUri": url}
+        elif stream_type == _ANDROID_STREAM:
+            if not bundle_id:
+                raise typer.BadParameter(
+                    "--bundle-id is required for ANDROID_APP_DATA_STREAM type"
+                )
+            body["androidAppStreamData"] = {"packageName": bundle_id}
+        elif stream_type == _IOS_STREAM:
+            if not bundle_id:
+                raise typer.BadParameter(
+                    "--bundle-id is required for IOS_APP_DATA_STREAM type"
+                )
+            body["iosAppStreamData"] = {"bundleId": bundle_id}
+
+        if dry_run:
+            handle_dry_run("create", "POST", f"properties/{effective_property}", body)
+
+        admin = get_admin_client()
+        stream = (
+            admin.properties()
+            .dataStreams()
+            .create(parent=f"properties/{effective_property}", body=body)
+            .execute()
+        )
+        output(stream, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@data_streams_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data Stream ID"
+    ),
+    display_name: Optional[str] = typer.Option(
+        None, "--display-name", help="New display name"
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Update a data stream."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        field_map = {
+            "displayName": display_name,
+        }
+        body = {k: v for k, v in field_map.items() if v is not None}
+
+        if not body:
+            raise typer.BadParameter(
+                "At least one of --display-name must be specified."
+            )
+
+        update_mask = ",".join(body.keys())
+
+        if dry_run:
+            handle_dry_run(
+                "update", "PATCH",
+                f"properties/{effective_property}/dataStreams/{stream_id}",
+                body, update_mask=update_mask,
+            )
+
+        admin = get_admin_client()
+        stream = (
+            admin.properties()
+            .dataStreams()
+            .patch(
+                name=f"properties/{effective_property}/dataStreams/{stream_id}",
+                body=body,
+                updateMask=update_mask,
+            )
+            .execute()
+        )
+        output(stream, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@data_streams_app.command("delete")
+def delete_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data Stream ID"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip confirmation prompt"
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview the request without executing"
+    ),
+):
+    """Delete a data stream."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+
+        if dry_run:
+            handle_dry_run(
+                "delete", "DELETE",
+                f"properties/{effective_property}/dataStreams/{stream_id}",
+                None,
+            )
+
+        if not yes:
+            confirmed = questionary.confirm(
+                f"Delete data stream {stream_id}? This cannot be undone."
+            ).ask()
+            if not confirmed:
+                info("Cancelled.")
+                raise typer.Exit()
+
+        admin = get_admin_client()
+        admin.properties().dataStreams().delete(
+            name=f"properties/{effective_property}/dataStreams/{stream_id}",
+        ).execute()
+        success(f"Data stream {stream_id} deleted.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)

ga_cli/commands/event_create_rules.py

@@ -0,0 +1,250 @@
+"""Event create rule management commands."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import questionary
+import typer
+
+from ..api.client import get_admin_alpha_client
+from ..config.store import get_effective_value
+from ..utils import handle_error, info, output, require_options, resolve_output_format, success
+from ..utils.pagination import paginate_all
+
+event_create_rules_app = typer.Typer(
+    name="event-create-rules",
+    help="Manage event create rules",
+    no_args_is_help=True,
+)
+
+
+def _load_json_config(config_file: str) -> dict:
+    """Load and parse a JSON config file."""
+    config_path = Path(config_file)
+    if not config_path.exists():
+        raise typer.BadParameter(f"Config file not found: {config_file}")
+    try:
+        return json.loads(config_path.read_text())
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"Invalid JSON in config file: {exc}")
+
+
+@event_create_rules_app.command("list")
+def list_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data stream ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """List event create rules for a data stream."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_alpha_client()
+        parent = f"properties/{effective_property}/dataStreams/{stream_id}"
+        rules = paginate_all(
+            lambda **kw: admin.properties()
+            .dataStreams()
+            .eventCreateRules()
+            .list(parent=parent, **kw)
+            .execute(),
+            "eventCreateRules",
+            pageSize=200,
+        )
+
+        output(
+            rules,
+            effective_format,
+            columns=[
+                "name",
+                "destinationEvent",
+                "sourceCopyParameters",
+            ],
+            headers=[
+                "Resource Name",
+                "Destination Event",
+                "Copy Source Params",
+            ],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@event_create_rules_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data stream ID"
+    ),
+    rule_id: str = typer.Option(
+        ..., "--rule-id", "-r", help="Event create rule ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get details for an event create rule."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        admin = get_admin_alpha_client()
+        resource_name = (
+            f"properties/{effective_property}/dataStreams/{stream_id}"
+            f"/eventCreateRules/{rule_id}"
+        )
+        rule = (
+            admin.properties()
+            .dataStreams()
+            .eventCreateRules()
+            .get(name=resource_name)
+            .execute()
+        )
+        output(rule, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@event_create_rules_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data stream ID"
+    ),
+    config_file: str = typer.Option(
+        ..., "--config", "-c", help="Path to JSON event create rule config file"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Create an event create rule from a JSON config file."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = _load_json_config(config_file)
+
+        admin = get_admin_alpha_client()
+        parent = f"properties/{effective_property}/dataStreams/{stream_id}"
+        rule = (
+            admin.properties()
+            .dataStreams()
+            .eventCreateRules()
+            .create(parent=parent, body=body)
+            .execute()
+        )
+        output(rule, effective_format)
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@event_create_rules_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data stream ID"
+    ),
+    rule_id: str = typer.Option(
+        ..., "--rule-id", "-r", help="Event create rule ID"
+    ),
+    config_file: str = typer.Option(
+        ..., "--config", "-c", help="Path to JSON file with fields to update"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Update an event create rule from a JSON config file."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+        effective_format = resolve_output_format(output_format)
+
+        body = _load_json_config(config_file)
+
+        if not body:
+            raise typer.BadParameter("Config file must contain at least one field to update.")
+
+        update_mask = ",".join(body.keys())
+
+        admin = get_admin_alpha_client()
+        resource_name = (
+            f"properties/{effective_property}/dataStreams/{stream_id}"
+            f"/eventCreateRules/{rule_id}"
+        )
+        rule = (
+            admin.properties()
+            .dataStreams()
+            .eventCreateRules()
+            .patch(
+                name=resource_name,
+                body=body,
+                updateMask=update_mask,
+            )
+            .execute()
+        )
+        output(rule, effective_format)
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@event_create_rules_app.command("delete")
+def delete_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    stream_id: str = typer.Option(
+        ..., "--stream-id", "-s", help="Data stream ID"
+    ),
+    rule_id: str = typer.Option(
+        ..., "--rule-id", "-r", help="Event create rule ID"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete an event create rule."""
+    try:
+        effective_property = get_effective_value(property_id, "default_property_id")
+        require_options({"property_id": effective_property}, ["property_id"])
+
+        if not yes:
+            confirmed = questionary.confirm(
+                f"Delete event create rule {rule_id}? This cannot be undone."
+            ).ask()
+            if not confirmed:
+                info("Cancelled.")
+                raise typer.Exit()
+
+        admin = get_admin_alpha_client()
+        resource_name = (
+            f"properties/{effective_property}/dataStreams/{stream_id}"
+            f"/eventCreateRules/{rule_id}"
+        )
+        admin.properties().dataStreams().eventCreateRules().delete(
+            name=resource_name
+        ).execute()
+        success(f"Event create rule {rule_id} deleted.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)