manager_owner

manager_owner

Owner manager for DomoCard.

DomoCard_OwnerManager dataclass

DomoCard_OwnerManager(
    auth: DomoAuth | None = None,
    parent: DomoCard_Default | None = None,
    owners: list[Any] = list(),
)

Bases: DomoRelationshipController

Manager for owners associated with a DomoCard.

add_owners async

add_owners(
    owners: list[Any],
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Add owners (users or groups) to this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def add_owners(
    self,
    owners: list[Any],
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:
    """Add owners (users or groups) to this card."""
    if not owners:
        raise ValueError("owners must be a non-empty list")

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    existing_owners = await self.get(context=context)
    existing = [self._normalize_owner(owner) for owner in existing_owners]
    existing = [owner for owner in existing if owner]

    additions = [self._normalize_owner(owner) for owner in owners]
    additions = [owner for owner in additions if owner]

    if not additions:
        raise ValueError("owners did not contain valid user or group entries")

    combined = {f"{o['type']}:{o['id']}": o for o in existing}
    combined.update({f"{o['type']}:{o['id']}": o for o in additions})

    await card_routes.replace_card_owners(
        auth=self.auth,
        card_id=self.parent.id,
        owners=list(combined.values()),
        context=context,
    )

    return await self.get(context=context)

create_relationship async

create_relationship(
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs
) -> bool

Create an owner relationship for this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def create_relationship(
    self,
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs,
) -> bool:
    """Create an owner relationship for this card."""
    if relationship_type != RelationshipType.HAS_ACCESS_OWNER:
        raise ValueError(
            "Only owner relationships are supported by DomoCard_OwnerManager"
        )

    if target_entity_type == EntityType.USER:
        await self.add_owners([{"id": target_entity_id, "type": "USER"}], **kwargs)
        return True

    if target_entity_type == EntityType.GROUP:
        await self.add_owners([{"id": target_entity_id, "type": "GROUP"}], **kwargs)
        return True

    raise ValueError(f"Unsupported owner entity type: {target_entity_type}")

get async

get(
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Get owners for this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def get(
    self,
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:  # Returns list[DomoUser|DomoGroup]
    """Get owners for this card."""
    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    if not self.parent.Access:
        from .access_controller import DomoCardAccessController

        self.parent.Access = DomoCardAccessController.from_parent(
            parent=self.parent
        )

    owners = await self.parent.Access.get_owner_entities(
        is_suppress_errors=True,
        context=context,
    )

    self.owners = owners
    self.parent.owners = owners

    return owners

get_direct_relationships async

get_direct_relationships() -> list[Relationship]

Get owner relationships for this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def get_direct_relationships(self) -> list[Relationship]:
    """Get owner relationships for this card."""
    if not self.parent.Access:
        from .access_controller import DomoCardAccessController

        self.parent.Access = DomoCardAccessController.from_parent(
            parent=self.parent
        )

    return await self.parent.Access.get_owners()

remove_owners async

remove_owners(
    owners: list[Any],
    debug_api: bool = False,
    session: AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> list[Any]

Remove owners (users or groups) from this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def remove_owners(
    self,
    owners: list[Any],
    debug_api: bool = False,
    session: httpx.AsyncClient | None = None,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> list[Any]:
    """Remove owners (users or groups) from this card."""
    if not owners:
        raise ValueError("owners must be a non-empty list")

    context = RouteContext.build_context(
        context=context,
        session=session,
        debug_api=debug_api,
        debug_num_stacks_to_drop=1,
        **context_kwargs,
    )

    existing_owners = await self.get(context=context)
    existing = [self._normalize_owner(owner) for owner in existing_owners]
    existing = [owner for owner in existing if owner]

    removals = [self._normalize_owner(owner) for owner in owners]
    removals = [owner for owner in removals if owner]

    if not removals:
        raise ValueError("owners did not contain valid user or group entries")

    remove_keys = {f"{o['type']}:{o['id']}" for o in removals}
    updated = [
        owner
        for owner in existing
        if f"{owner['type']}:{owner['id']}" not in remove_keys
    ]

    if not updated:
        raise ValueError("Cannot remove all owners; owners would be empty")

    await card_routes.replace_card_owners(
        auth=self.auth,
        card_id=self.parent.id,
        owners=updated,
        context=context,
    )

    return await self.get(context=context)

remove_relationship async

remove_relationship(
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs
) -> bool

Remove an owner relationship for this card.

Source code in src/crew_dcs/classes/DomoCard/manager_owner.py

async def remove_relationship(
    self,
    target_entity_id: str,
    target_entity_type: EntityType,
    relationship_type: RelationshipType,
    **kwargs,
) -> bool:
    """Remove an owner relationship for this card."""
    if relationship_type != RelationshipType.HAS_ACCESS_OWNER:
        raise ValueError(
            "Only owner relationships are supported by DomoCard_OwnerManager"
        )

    if target_entity_type == EntityType.USER:
        await self.remove_owners(
            [{"id": target_entity_id, "type": "USER"}], **kwargs
        )
        return True

    if target_entity_type == EntityType.GROUP:
        await self.remove_owners(
            [{"id": target_entity_id, "type": "GROUP"}], **kwargs
        )
        return True

    raise ValueError(f"Unsupported owner entity type: {target_entity_type}")