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

ga_cli/commands/bigquery_links.py

@@ -0,0 +1,309 @@
+"""BigQuery link management commands."""
+
+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
+
+bigquery_links_app = typer.Typer(
+    name="bigquery-links",
+    help="Manage BigQuery links",
+    no_args_is_help=True,
+)
+
+
+def _normalize_project(project: str) -> str:
+    """Ensure project is in 'projects/{id}' format."""
+    if project.startswith("projects/"):
+        return project
+    return f"projects/{project}"
+
+
+@bigquery_links_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 BigQuery links 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_alpha_client()
+        links = paginate_all(
+            lambda **kw: admin.properties()
+            .bigQueryLinks()
+            .list(parent=f"properties/{effective_property}", **kw)
+            .execute(),
+            "bigqueryLinks",
+            pageSize=200,
+        )
+
+        output(
+            links,
+            effective_format,
+            columns=[
+                "name",
+                "project",
+                "datasetLocation",
+                "dailyExportEnabled",
+                "streamingExportEnabled",
+                "createTime",
+            ],
+            headers=[
+                "Resource Name",
+                "Project",
+                "Dataset Location",
+                "Daily Export",
+                "Streaming Export",
+                "Create Time",
+            ],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@bigquery_links_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    link_id: str = typer.Option(
+        ..., "--link-id", "-l", help="BigQuery link ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get details for a BigQuery link."""
+    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()
+        link = (
+            admin.properties()
+            .bigQueryLinks()
+            .get(
+                name=f"properties/{effective_property}/bigQueryLinks/{link_id}"
+            )
+            .execute()
+        )
+        output(link, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@bigquery_links_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    project: str = typer.Option(
+        ..., "--project", help="Google Cloud project (number or ID)"
+    ),
+    dataset_location: str = typer.Option(
+        ..., "--dataset-location", help="BigQuery dataset location (e.g., US, EU)"
+    ),
+    daily_export: Optional[bool] = typer.Option(
+        None, "--daily-export/--no-daily-export", help="Enable daily export"
+    ),
+    streaming_export: Optional[bool] = typer.Option(
+        None, "--streaming-export/--no-streaming-export", help="Enable streaming export"
+    ),
+    fresh_daily_export: Optional[bool] = typer.Option(
+        None, "--fresh-daily-export/--no-fresh-daily-export", help="Enable fresh daily export"
+    ),
+    include_advertising_id: Optional[bool] = typer.Option(
+        None,
+        "--include-advertising-id/--no-include-advertising-id",
+        help="Include advertising identifiers for mobile app streams",
+    ),
+    export_streams: Optional[str] = typer.Option(
+        None, "--export-streams", help="Comma-separated data stream IDs to export"
+    ),
+    excluded_events: Optional[str] = typer.Option(
+        None, "--excluded-events", help="Comma-separated event names to exclude"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Create a BigQuery link."""
+    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 = {
+            "project": _normalize_project(project),
+            "datasetLocation": dataset_location,
+        }
+        if daily_export is not None:
+            body["dailyExportEnabled"] = daily_export
+        if streaming_export is not None:
+            body["streamingExportEnabled"] = streaming_export
+        if fresh_daily_export is not None:
+            body["freshDailyExportEnabled"] = fresh_daily_export
+        if include_advertising_id is not None:
+            body["includeAdvertisingId"] = include_advertising_id
+        if export_streams is not None:
+            body["exportStreams"] = [
+                f"properties/{effective_property}/dataStreams/{sid.strip()}"
+                for sid in export_streams.split(",")
+            ]
+        if excluded_events is not None:
+            body["excludedEvents"] = [
+                e.strip() for e in excluded_events.split(",")
+            ]
+
+        admin = get_admin_alpha_client()
+        link = (
+            admin.properties()
+            .bigQueryLinks()
+            .create(parent=f"properties/{effective_property}", body=body)
+            .execute()
+        )
+        output(link, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@bigquery_links_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    link_id: str = typer.Option(
+        ..., "--link-id", "-l", help="BigQuery link ID"
+    ),
+    daily_export: Optional[bool] = typer.Option(
+        None, "--daily-export/--no-daily-export", help="Enable daily export"
+    ),
+    streaming_export: Optional[bool] = typer.Option(
+        None, "--streaming-export/--no-streaming-export", help="Enable streaming export"
+    ),
+    fresh_daily_export: Optional[bool] = typer.Option(
+        None, "--fresh-daily-export/--no-fresh-daily-export", help="Enable fresh daily export"
+    ),
+    include_advertising_id: Optional[bool] = typer.Option(
+        None,
+        "--include-advertising-id/--no-include-advertising-id",
+        help="Include advertising identifiers for mobile app streams",
+    ),
+    export_streams: Optional[str] = typer.Option(
+        None, "--export-streams", help="Comma-separated data stream IDs to export"
+    ),
+    excluded_events: Optional[str] = typer.Option(
+        None, "--excluded-events", help="Comma-separated event names to exclude"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Update a BigQuery link."""
+    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 = {}
+        mask_fields = []
+        if daily_export is not None:
+            body["dailyExportEnabled"] = daily_export
+            mask_fields.append("dailyExportEnabled")
+        if streaming_export is not None:
+            body["streamingExportEnabled"] = streaming_export
+            mask_fields.append("streamingExportEnabled")
+        if fresh_daily_export is not None:
+            body["freshDailyExportEnabled"] = fresh_daily_export
+            mask_fields.append("freshDailyExportEnabled")
+        if include_advertising_id is not None:
+            body["includeAdvertisingId"] = include_advertising_id
+            mask_fields.append("includeAdvertisingId")
+        if export_streams is not None:
+            body["exportStreams"] = [
+                f"properties/{effective_property}/dataStreams/{sid.strip()}"
+                for sid in export_streams.split(",")
+            ]
+            mask_fields.append("exportStreams")
+        if excluded_events is not None:
+            body["excludedEvents"] = [
+                e.strip() for e in excluded_events.split(",")
+            ]
+            mask_fields.append("excludedEvents")
+
+        if not mask_fields:
+            raise typer.BadParameter(
+                "At least one field must be specified: "
+                "--daily-export, --streaming-export, --fresh-daily-export, "
+                "--include-advertising-id, --export-streams, --excluded-events"
+            )
+
+        admin = get_admin_alpha_client()
+        resource_name = (
+            f"properties/{effective_property}/bigQueryLinks/{link_id}"
+        )
+        link = (
+            admin.properties()
+            .bigQueryLinks()
+            .patch(
+                name=resource_name,
+                body=body,
+                updateMask=",".join(mask_fields),
+            )
+            .execute()
+        )
+        output(link, effective_format)
+    except typer.BadParameter:
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@bigquery_links_app.command("delete")
+def delete_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    link_id: str = typer.Option(
+        ..., "--link-id", "-l", help="BigQuery link ID"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
+):
+    """Delete a BigQuery link."""
+    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 BigQuery link {link_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}/bigQueryLinks/{link_id}"
+        )
+        admin.properties().bigQueryLinks().delete(
+            name=resource_name
+        ).execute()
+        success(f"BigQuery link {link_id} deleted.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)

ga_cli/commands/calculated_metrics.py

@@ -0,0 +1,312 @@
+"""Calculated metric management commands."""
+
+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_dry_run,
+    handle_error,
+    info,
+    output,
+    require_options,
+    resolve_output_format,
+    success,
+)
+from ..utils.pagination import paginate_all
+
+calculated_metrics_app = typer.Typer(
+    name="calculated-metrics",
+    help="Manage calculated metrics",
+    no_args_is_help=True,
+)
+
+_VALID_METRIC_UNITS = (
+    "STANDARD",
+    "CURRENCY",
+    "FEET",
+    "METERS",
+    "KILOMETERS",
+    "MILES",
+    "MILLISECONDS",
+    "SECONDS",
+    "MINUTES",
+    "HOURS",
+)
+
+
+@calculated_metrics_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 calculated metrics 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_alpha_client()
+        metrics = paginate_all(
+            lambda **kw: admin.properties()
+            .calculatedMetrics()
+            .list(parent=f"properties/{effective_property}", **kw)
+            .execute(),
+            "calculatedMetrics",
+            pageSize=200,
+        )
+
+        output(
+            metrics,
+            effective_format,
+            columns=[
+                "name",
+                "calculatedMetricId",
+                "displayName",
+                "formula",
+                "metricUnit",
+            ],
+            headers=[
+                "Resource Name",
+                "Metric ID",
+                "Display Name",
+                "Formula",
+                "Metric Unit",
+            ],
+        )
+    except Exception as e:
+        handle_error(e)
+
+
+@calculated_metrics_app.command("get")
+def get_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    metric_id: str = typer.Option(
+        ..., "--metric-id", "-m", help="Calculated metric ID"
+    ),
+    output_format: Optional[str] = typer.Option(
+        None, "--output", "-o", help="Output format (json, table, compact)"
+    ),
+):
+    """Get details for a calculated metric."""
+    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()
+        metric = (
+            admin.properties()
+            .calculatedMetrics()
+            .get(
+                name=f"properties/{effective_property}/calculatedMetrics/{metric_id}"
+            )
+            .execute()
+        )
+        output(metric, effective_format)
+    except Exception as e:
+        handle_error(e)
+
+
+@calculated_metrics_app.command("create")
+def create_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    calculated_metric_id: str = typer.Option(
+        ..., "--calculated-metric-id", help="Unique metric ID (e.g., 'revenuePerUser')"
+    ),
+    display_name: str = typer.Option(..., "--display-name", help="Display name"),
+    formula: str = typer.Option(
+        ..., "--formula", help='Formula (e.g., "{{totalRevenue}} / {{totalUsers}}")'
+    ),
+    metric_unit: str = typer.Option(
+        ..., "--metric-unit", help="Metric unit (STANDARD, CURRENCY, etc.)"
+    ),
+    description: str = typer.Option("", "--description", help="Description"),
+    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 calculated metric."""
+    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)
+
+        unit_upper = metric_unit.upper()
+        if unit_upper not in _VALID_METRIC_UNITS:
+            raise typer.BadParameter(
+                f"Invalid metric unit '{metric_unit}'. "
+                f"Must be one of: {', '.join(_VALID_METRIC_UNITS)}"
+            )
+
+        body = {
+            "displayName": display_name,
+            "description": description,
+            "formula": formula,
+            "metricUnit": unit_upper,
+        }
+        if dry_run:
+            handle_dry_run("create", "POST", f"properties/{effective_property}", body)
+
+        admin = get_admin_alpha_client()
+        metric = (
+            admin.properties()
+            .calculatedMetrics()
+            .create(
+                parent=f"properties/{effective_property}",
+                calculatedMetricId=calculated_metric_id,
+                body=body,
+            )
+            .execute()
+        )
+        output(metric, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@calculated_metrics_app.command("update")
+def update_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    metric_id: str = typer.Option(
+        ..., "--metric-id", "-m", help="Calculated metric ID"
+    ),
+    display_name: Optional[str] = typer.Option(
+        None, "--display-name", help="New display name"
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", help="New description"
+    ),
+    formula: Optional[str] = typer.Option(None, "--formula", help="New formula"),
+    metric_unit: Optional[str] = typer.Option(
+        None, "--metric-unit", help="New metric unit"
+    ),
+    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 calculated metric."""
+    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 = {}
+        mask_fields = []
+        if display_name is not None:
+            body["displayName"] = display_name
+            mask_fields.append("displayName")
+        if description is not None:
+            body["description"] = description
+            mask_fields.append("description")
+        if formula is not None:
+            body["formula"] = formula
+            mask_fields.append("formula")
+        if metric_unit is not None:
+            unit_upper = metric_unit.upper()
+            if unit_upper not in _VALID_METRIC_UNITS:
+                raise typer.BadParameter(
+                    f"Invalid metric unit '{metric_unit}'. "
+                    f"Must be one of: {', '.join(_VALID_METRIC_UNITS)}"
+                )
+            body["metricUnit"] = unit_upper
+            mask_fields.append("metricUnit")
+
+        if not mask_fields:
+            raise typer.BadParameter(
+                "At least one field must be specified: "
+                "--display-name, --description, --formula, --metric-unit"
+            )
+
+        resource_name = (
+            f"properties/{effective_property}/calculatedMetrics/{metric_id}"
+        )
+        if dry_run:
+            handle_dry_run(
+                "update", "PATCH", resource_name,
+                body, update_mask=",".join(mask_fields),
+            )
+
+        admin = get_admin_alpha_client()
+        metric = (
+            admin.properties()
+            .calculatedMetrics()
+            .patch(
+                name=resource_name,
+                body=body,
+                updateMask=",".join(mask_fields),
+            )
+            .execute()
+        )
+        output(metric, effective_format)
+    except (typer.BadParameter, typer.Exit):
+        raise
+    except Exception as e:
+        handle_error(e)
+
+
+@calculated_metrics_app.command("delete")
+def delete_cmd(
+    property_id: Optional[str] = typer.Option(
+        None, "--property-id", "-p", help="Property ID (numeric)"
+    ),
+    metric_id: str = typer.Option(
+        ..., "--metric-id", "-m", help="Calculated metric 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 calculated metric."""
+    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}/calculatedMetrics/{metric_id}",
+                None,
+            )
+
+        if not yes:
+            confirmed = questionary.confirm(
+                f"Delete calculated metric {metric_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}/calculatedMetrics/{metric_id}"
+        )
+        admin.properties().calculatedMetrics().delete(
+            name=resource_name
+        ).execute()
+        success(f"Calculated metric {metric_id} deleted.")
+    except typer.Exit:
+        raise
+    except Exception as e:
+        handle_error(e)