Teams API¶

from open_to_close import OpenToCloseAPI

client = OpenToCloseAPI()

# List all teams
teams = client.teams.list_teams()

# Get a specific team
team_data = client.teams.retrieve_team(123)

# Create a new team
new_team = client.teams.create_team({
    "name": "Downtown Sales Team",
    "description": "Team focused on downtown properties",
    "team_lead_id": 5
})

def list_teams(
    self, 
    params: Optional[Dict[str, Any]] = None
) -> List[Dict[str, Any]]

def create_team(
    self, 
    team_data: Dict[str, Any]
) -> Dict[str, Any]

def retrieve_team(
    self, 
    team_id: int
) -> Dict[str, Any]

def update_team(
    self, 
    team_id: int, 
    team_data: Dict[str, Any]
) -> Dict[str, Any]

def delete_team(
    self, 
    team_id: int
) -> Dict[str, Any]

def create_specialized_team(team_info, lead_agent_id):
    """Create a new specialized team with proper setup."""

    # Step 1: Create the team
    team_data = {
        "name": team_info["name"],
        "description": team_info["description"],
        "team_lead_id": lead_agent_id,
        "specialization": team_info["specialization"],
        "territory": team_info.get("territory"),
        "status": "Active",
        "created_date": datetime.now().isoformat()
    }

    new_team = client.teams.create_team(team_data)
    team_id = new_team['id']

    print(f"Created team: {new_team['name']} (ID: {team_id})")
    return new_team

# Usage
new_team = create_specialized_team({
    "name": "Commercial Division",
    "description": "Dedicated commercial real estate team",
    "specialization": "Commercial Properties",
    "territory": "Business District"
}, lead_agent_id=25)

class TeamManager:
    """Helper class for managing team operations."""

    def __init__(self, client):
        self.client = client

    def get_active_teams(self):
        """Get all active teams."""
        return self.client.teams.list_teams(params={
            "status": "Active"
        })

    def get_team_by_lead(self, lead_id):
        """Get teams led by a specific agent."""
        return self.client.teams.list_teams(params={
            "team_lead_id": lead_id
        })

    def get_team_summary(self, team_id):
        """Get comprehensive team information."""
        try:
            team = self.client.teams.retrieve_team(team_id)

            summary = {
                "basic_info": {
                    "name": team.get("name"),
                    "description": team.get("description"),
                    "status": team.get("status")
                },
                "organization": {
                    "lead_id": team.get("team_lead_id"),
                    "specialization": team.get("specialization"),
                    "territory": team.get("territory")
                },
                "performance": {
                    "target_revenue": team.get("target_revenue"),
                    "commission_split": team.get("commission_split")
                }
            }

            return summary

        except Exception as e:
            print(f"Error getting team summary: {e}")
            return None

    def reassign_team_lead(self, team_id, new_lead_id, reason=None):
        """Reassign team leadership."""
        update_data = {
            "team_lead_id": new_lead_id,
            "lead_change_date": datetime.now().isoformat()
        }
        if reason:
            update_data["lead_change_reason"] = reason

        return self.client.teams.update_team(team_id, update_data)

# Usage
team_manager = TeamManager(client)
active_teams = team_manager.get_active_teams()
team_summary = team_manager.get_team_summary(123)

from open_to_close.exceptions import (
    NotFoundError, 
    ValidationError, 
    AuthenticationError
)

def robust_team_operations(team_id):
    """Example of comprehensive error handling."""
    try:
        # Attempt team operations
        team_data = client.teams.retrieve_team(team_id)

        updated_team = client.teams.update_team(team_id, {
            "status": "Active"
        })

        return updated_team

    except NotFoundError:
        print(f"Team {team_id} does not exist")
        return None

    except ValidationError as e:
        print(f"Invalid data provided: {e}")
        return None

    except AuthenticationError:
        print("Authentication failed - check your API key")
        return None

    except Exception as e:
        print(f"Unexpected error: {e}")
        return None