crowdtime-cli 0.1.0__py3-none-any.whl

crowdtime_cli/commands/org_cmd.py

@@ -0,0 +1,134 @@
+"""Organization commands: list, switch, members, invite."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..client import APIError, CrowdTimeClient
+from ..config import get_config
+from ..formatters import format_error, format_members_table, format_success, print_json
+from ..models import Organization
+
+app = typer.Typer(name="org", help="Manage organizations.")
+console = Console()
+
+
+@app.command("list")
+def list_orgs(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List organizations you belong to."""
+    client = CrowdTimeClient(require_auth=True, require_org=False)
+
+    try:
+        data = client.get("/api/v1/organizations/", org_scoped=False)
+        orgs_list = data if isinstance(data, list) else data.get("results", [])
+        orgs = [Organization(**item) for item in orgs_list]
+
+        if output_json:
+            print_json(orgs)
+            return
+
+        if not orgs:
+            console.print("[dim]No organizations found.[/dim]")
+            return
+
+        current_slug = client.config.organization
+
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("", width=3)
+        table.add_column("Name", width=20)
+        table.add_column("Slug", width=15)
+        table.add_column("Role", width=10)
+        table.add_column("Members", justify="right", width=8)
+
+        for org in orgs:
+            marker = "[green]*[/green]" if org.slug == current_slug else " "
+            table.add_row(
+                marker,
+                org.name,
+                org.slug,
+                org.role or "",
+                str(org.member_count or ""),
+            )
+
+        console.print(table)
+        if current_slug:
+            console.print(f"\n[dim]* = current organization ({current_slug})[/dim]")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command("switch")
+def switch_org(
+    slug: str = typer.Argument(..., help="Organization slug to switch to."),
+) -> None:
+    """Switch the active organization."""
+    # Verify the org exists
+    client = CrowdTimeClient(require_auth=True, require_org=False)
+
+    try:
+        data = client.get("/api/v1/organizations/", org_scoped=False)
+        orgs_list = data if isinstance(data, list) else data.get("results", [])
+        slugs = [o.get("slug", "") for o in orgs_list]
+
+        if slug not in slugs:
+            format_error(f"Organization '{slug}' not found. Available: {', '.join(slugs)}")
+            raise typer.Exit(1)
+
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+    config = get_config()
+    config.set("defaults.organization", slug)
+    format_success(f"Switched to organization '{slug}'")
+
+
+@app.command()
+def members(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List members of the current organization."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.get("/members/")
+        members_list = data if isinstance(data, list) else data.get("results", [])
+
+        if output_json:
+            print_json(members_list)
+        else:
+            format_members_table(members_list)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def invite(
+    email: str = typer.Argument(..., help="Email address to invite."),
+    role: str = typer.Option("member", "--role", "-r", help="Role: admin, manager, member."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Invite a member to the current organization."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.post("/members/invite/", data={
+            "email": email,
+            "role": role,
+        })
+
+        if output_json:
+            print_json(data)
+        else:
+            format_success(f"Invitation sent to {email} (role: {role})")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)

crowdtime_cli/commands/projects_cmd.py

@@ -0,0 +1,175 @@
+"""Project commands: list, show, create, archive, switch."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..client import APIError, CrowdTimeClient
+from ..config import get_config
+from ..formatters import format_error, format_projects_table, format_success, print_json
+from ..models import Project
+
+app = typer.Typer(name="projects", help="Manage projects.")
+console = Console()
+
+
+def _resolve_or_create_client(api_client: CrowdTimeClient, client_name: str) -> str:
+    """Look up a client by name; create one if it doesn't exist. Returns the client UUID."""
+    # Search for existing clients matching the name
+    data = api_client.get("/clients/", params={"search": client_name})
+    clients_list = data if isinstance(data, list) else data.get("results", [])
+
+    # Exact match (case-insensitive)
+    for c in clients_list:
+        if c.get("name", "").lower() == client_name.lower():
+            return c["id"]
+
+    # No match — auto-create the client
+    console.print(f"[dim]Client '{client_name}' not found — creating it...[/dim]")
+    new_client = api_client.post("/clients/", data={"name": client_name})
+    return new_client["id"]
+
+
+@app.command("list")
+def list_projects(
+    archived: bool = typer.Option(False, "--archived", "-a", help="Include archived projects."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """List all projects in the current organization."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {}
+    if archived:
+        params["status"] = "archived"
+
+    try:
+        data = client.get("/projects/", params=params)
+        projects_list = data if isinstance(data, list) else data.get("results", [])
+        projects = [Project(**item) for item in projects_list]
+
+        if output_json:
+            print_json(projects)
+        else:
+            # Show which is default
+            default_proj = client.config.default_project
+            format_projects_table(projects)
+            if default_proj:
+                console.print(f"\n[dim]Default project: {default_proj}[/dim]")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def show(
+    project_id: str = typer.Argument(..., help="Project ID or slug."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Show details for a specific project."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.get(f"/projects/{project_id}/")
+        project = Project(**data)
+
+        if output_json:
+            print_json(project)
+        else:
+            console.print(f"\n[bold]{project.name}[/bold]")
+            console.print(f"  ID:       {project.id}")
+            console.print(f"  Code:     {project.code}")
+            console.print(f"  Client:   {project.client or '-'}")
+            console.print(f"  Status:   {project.status}")
+            console.print(f"  Billable: {'Yes' if project.is_billable else 'No'}")
+            if project.budget_hours:
+                console.print(f"  Budget:   {project.budget_hours}h")
+            if project.description:
+                console.print(f"  Notes:    {project.description}")
+            console.print()
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Project '{project_id}' not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def create(
+    name: str = typer.Argument(..., help="Project name."),
+    client_name: Optional[str] = typer.Option(None, "--client", "-c", help="Client name."),
+    billable: bool = typer.Option(True, "--billable/--no-billable", "-b/-B",
+                                  help="Mark as billable."),
+    color: Optional[str] = typer.Option(None, "--color", help="Project color (hex)."),
+    budget: Optional[float] = typer.Option(None, "--budget", help="Budget in hours."),
+    code: Optional[str] = typer.Option(None, "--code", help="Short project code."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Create a new project."""
+    api_client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    payload: dict = {"name": name, "is_billable": billable}
+    if color:
+        payload["color"] = color
+    if budget:
+        payload["budget_hours"] = budget
+    if code:
+        payload["code"] = code
+
+    # Resolve client name to UUID (or auto-create)
+    if client_name:
+        try:
+            client_id = _resolve_or_create_client(api_client, client_name)
+            payload["client"] = str(client_id)
+        except APIError as e:
+            format_error(f"Failed to resolve client '{client_name}': {e.message}")
+            raise typer.Exit(1)
+
+    try:
+        data = api_client.post("/projects/", data=payload)
+        project = Project(**data)
+
+        if output_json:
+            print_json(project)
+        else:
+            format_success(f"Project '{project.name}' created (ID: {project.id})")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command()
+def archive(
+    project_id: str = typer.Argument(..., help="Project ID or slug to archive."),
+    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation."),
+) -> None:
+    """Archive a project."""
+    if not force:
+        if not typer.confirm(f"Archive project '{project_id}'?"):
+            console.print("[dim]Cancelled.[/dim]")
+            return
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.patch(f"/projects/{project_id}/", data={"status": "archived"})
+        format_success(f"Project '{project_id}' archived.")
+    except APIError as e:
+        if e.status_code == 404:
+            format_error(f"Project '{project_id}' not found.")
+        else:
+            format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command("switch")
+def switch_project(
+    slug: str = typer.Argument(..., help="Project slug or name to set as default."),
+) -> None:
+    """Set a project as the default for new entries."""
+    config = get_config()
+    config.set("defaults.project", slug)
+    format_success(f"Default project set to '{slug}'")

crowdtime_cli/commands/report_cmd.py

@@ -0,0 +1,242 @@
+"""Report commands: report, projects, team."""
+
+from __future__ import annotations
+
+from datetime import date as date_type, timedelta
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from ..client import APIError, CrowdTimeClient
+from ..formatters import format_error, format_report, print_json
+from ..utils import format_date, parse_date
+
+app = typer.Typer(name="report", help="Generate time reports.")
+console = Console()
+
+
+def _resolve_period(
+    today_flag: bool = False,
+    yesterday_flag: bool = False,
+    week: bool = False,
+    last_week: bool = False,
+    month: bool = False,
+    from_date: str | None = None,
+    to_date: str | None = None,
+) -> tuple[str, str]:
+    """Resolve date range from flags."""
+    today = date_type.today()
+
+    if today_flag:
+        d = format_date(today)
+        return d, d
+    if yesterday_flag:
+        d = format_date(today - timedelta(days=1))
+        return d, d
+    if week:
+        start = today - timedelta(days=today.weekday())
+        return format_date(start), format_date(today)
+    if last_week:
+        start = today - timedelta(days=today.weekday() + 7)
+        end = start + timedelta(days=6)
+        return format_date(start), format_date(end)
+    if month:
+        start = today.replace(day=1)
+        return format_date(start), format_date(today)
+    if from_date and to_date:
+        try:
+            return format_date(parse_date(from_date)), format_date(parse_date(to_date))
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+    if from_date:
+        try:
+            return format_date(parse_date(from_date)), format_date(today)
+        except ValueError as e:
+            format_error(str(e))
+            raise typer.Exit(1)
+
+    # Default: this week
+    start = today - timedelta(days=today.weekday())
+    return format_date(start), format_date(today)
+
+
+@app.callback(invoke_without_command=True)
+def report(
+    ctx: typer.Context,
+    today_flag: bool = typer.Option(False, "--today", help="Report for today."),
+    yesterday_flag: bool = typer.Option(False, "--yesterday", help="Report for yesterday."),
+    week: bool = typer.Option(False, "--week", "-w", help="Report for this week."),
+    last_week: bool = typer.Option(False, "--last-week", help="Report for last week."),
+    month: bool = typer.Option(False, "--month", "-m", help="Report for this month."),
+    from_date: Optional[str] = typer.Option(None, "--from", help="Start date."),
+    to_date: Optional[str] = typer.Option(None, "--to", help="End date."),
+    project: Optional[str] = typer.Option(None, "--project", "-p", help="Filter by project."),
+    group_by: str = typer.Option("project", "--group-by", "-g",
+                                 help="Group by: project, task, day, client."),
+    format_output: str = typer.Option("table", "--format", "-f",
+                                      help="Output format: table, json, csv, markdown."),
+) -> None:
+    """Generate a time report.
+
+    Examples:
+        ct report --week
+        ct report --month --group-by task
+        ct report --from 2026-03-01 --to 2026-03-10 -p myproject
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    period_from, period_to = _resolve_period(
+        today_flag, yesterday_flag, week, last_week, month, from_date, to_date
+    )
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {
+        "from": period_from,
+        "to": period_to,
+        "group_by": group_by,
+    }
+    if project:
+        params["project"] = project
+
+    endpoint = "/reports/project-summary/" if group_by == "project" else "/reports/time-detail/"
+
+    try:
+        data = client.get(endpoint, params=params)
+        results = data if isinstance(data, list) else data.get("results", [])
+
+        if format_output == "json":
+            print_json(results)
+        elif format_output == "csv":
+            _print_report_csv(results, group_by)
+        elif format_output == "markdown":
+            _print_report_markdown(results, group_by, period_from, period_to)
+        else:
+            console.print(f"\n[dim]Period: {period_from} to {period_to}[/dim]")
+            format_report(results, group_by=group_by)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command("projects")
+def project_report(
+    week: bool = typer.Option(False, "--week", "-w", help="This week."),
+    month: bool = typer.Option(True, "--month", "-m", help="This month (default)."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Project breakdown report."""
+    period_from, period_to = _resolve_period(week=week, month=month)
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    try:
+        data = client.get("/reports/project-summary/", params={
+            "from": period_from,
+            "to": period_to,
+        })
+        results = data if isinstance(data, list) else data.get("results", [])
+
+        if output_json:
+            print_json(results)
+        else:
+            console.print(f"\n[dim]Period: {period_from} to {period_to}[/dim]")
+            format_report(results, group_by="project")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+@app.command("team")
+def team_report(
+    week: bool = typer.Option(False, "--week", "-w", help="This week."),
+    month: bool = typer.Option(True, "--month", "-m", help="This month (default)."),
+    member: Optional[str] = typer.Option(None, "--member", help="Filter by team member."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Team utilization report."""
+    period_from, period_to = _resolve_period(week=week, month=month)
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+
+    params: dict = {
+        "from": period_from,
+        "to": period_to,
+    }
+    if member:
+        params["member"] = member
+
+    try:
+        data = client.get("/reports/team-utilization/", params=params)
+        results = data if isinstance(data, list) else data.get("results", [])
+
+        if output_json:
+            print_json(results)
+        else:
+            console.print(f"\n[dim]Team Report: {period_from} to {period_to}[/dim]")
+            _print_team_table(results)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
+def _print_team_table(data: list[dict]) -> None:
+    """Print team utilization table."""
+    from rich.table import Table
+    from ..utils import format_duration
+    from decimal import Decimal
+
+    if not data:
+        console.print("[dim]No data.[/dim]")
+        return
+
+    table = Table(show_header=True, header_style="bold", title="Team Utilization")
+    table.add_column("Member", width=20)
+    table.add_column("Hours", justify="right", width=10)
+    table.add_column("Billable", justify="right", width=10)
+    table.add_column("Utilization", justify="right", width=12)
+
+    for row in data:
+        hours = Decimal(str(row.get("hours", 0)))
+        billable = Decimal(str(row.get("billable_hours", 0)))
+        utilization = row.get("utilization", 0)
+        table.add_row(
+            row.get("member", ""),
+            format_duration(hours),
+            format_duration(billable),
+            f"{utilization}%",
+        )
+
+    console.print(table)
+
+
+def _print_report_csv(data: list[dict], group_by: str) -> None:
+    """Print report as CSV."""
+    console.print(f"{group_by},hours,billable_hours,entries_count")
+    for row in data:
+        console.print(
+            f'{row.get(group_by, row.get("project", ""))},'
+            f'{row.get("hours", 0)},'
+            f'{row.get("billable_hours", 0)},'
+            f'{row.get("entries_count", 0)}'
+        )
+
+
+def _print_report_markdown(data: list[dict], group_by: str, from_d: str, to_d: str) -> None:
+    """Print report as Markdown."""
+    from ..utils import format_duration
+    from decimal import Decimal
+
+    console.print(f"## Time Report ({from_d} to {to_d})\n")
+    console.print(f"| {group_by.capitalize()} | Hours | Billable | Entries |")
+    console.print("|---|---|---|---|")
+    for row in data:
+        hours = format_duration(Decimal(str(row.get("hours", 0))))
+        billable = format_duration(Decimal(str(row.get("billable_hours", 0))))
+        console.print(
+            f"| {row.get(group_by, row.get('project', ''))} "
+            f"| {hours} | {billable} | {row.get('entries_count', 0)} |"
+        )