crud

crud

bulk_add_cards_to_pages async

bulk_add_cards_to_pages(
    auth: DomoAuth,
    card_ids: list[str],
    destination_page_ids: list[int],
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Add cards to pages in bulk (does not remove existing cards).

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
card_ids	list[str]	List of card IDs to add	required
destination_page_ids	list[int]	List of page IDs to add the cards to	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object confirming the bulk add

Raises:

Type	Description
Page_CRUD_Error	If bulk add fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def bulk_add_cards_to_pages(
    auth: DomoAuth,
    card_ids: list[str],
    destination_page_ids: list[int],
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Add cards to pages in bulk (does not remove existing cards).

    Args:
        auth: Authentication object containing credentials and instance info
        card_ids: List of card IDs to add
        destination_page_ids: List of page IDs to add the cards to
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters

    Returns:
        ResponseGetData object confirming the bulk add

    Raises:
        Page_CRUD_Error: If bulk add fails
    """
    # Delegate the HTTP call to the canonical card route so the
    # /content/v1/cards/bulk/pages endpoint is defined in exactly one place.
    body = {
        "cardIds": [str(cid) for cid in card_ids],
        "destinationPageIds": [int(pid) for pid in destination_page_ids],
    }

    try:
        res = await put_content_cards_bulk_pages(
            auth=auth, body=body, context=context, **context_kwargs
        )
    except RouteError as e:
        if return_raw:
            return e.res
        raise Page_CRUD_Error(
            operation="bulk_add_cards",
            message="Unable to bulk add cards to pages",
            res=e.res,
        ) from e

    return res

create_page async

create_page(
    auth: DomoAuth,
    title: str,
    parent_page_id: int = 0,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Create a new page (dashboard).

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
title	str	Title of the new page	required
parent_page_id	int	Parent page ID (0 for top-level page)	0
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing the created page info (pageId, ownerId, etc.)

Raises:

Type	Description
Page_CRUD_Error	If page creation fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def create_page(
    auth: DomoAuth,
    title: str,
    parent_page_id: int = 0,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Create a new page (dashboard).

    Args:
        auth: Authentication object containing credentials and instance info
        title: Title of the new page
        parent_page_id: Parent page ID (0 for top-level page)
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters

    Returns:
        ResponseGetData object containing the created page info (pageId, ownerId, etc.)

    Raises:
        Page_CRUD_Error: If page creation fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v1/pages"

    body = {"parentPageId": parent_page_id, "title": title}

    res = await gd.get_data(
        auth=auth, url=url, method="POST", body=body, context=context
    )

    if return_raw:
        return res
    if not res.is_success:
        raise Page_CRUD_Error(
            operation="create", message=f"Unable to create page '{title}'", res=res
        )
    return res

create_page_layout async

create_page_layout(
    auth: DomoAuth,
    page_id: str,
    body: dict | None = None,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Create a new page layout for a page.

Creates a v4 layout for a page. If the page already has cards (added via bulk_add_cards_to_pages), the layout will auto-populate with content items for each card in an "Appendix" section.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	ID of the page to create a layout for	required
body	dict | None	Optional custom layout body. If None, a default empty layout is created.	None
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing the created layout (with layoutId)

Raises:

Type	Description
Page_CRUD_Error	If layout creation fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def create_page_layout(
    auth: DomoAuth,
    page_id: str,
    body: dict | None = None,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Create a new page layout for a page.

    Creates a v4 layout for a page. If the page already has cards (added via
    bulk_add_cards_to_pages), the layout will auto-populate with content items
    for each card in an "Appendix" section.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: ID of the page to create a layout for
        body: Optional custom layout body. If None, a default empty layout is created.
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters

    Returns:
        ResponseGetData object containing the created layout (with layoutId)

    Raises:
        Page_CRUD_Error: If layout creation fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v4/pages/layouts"

    if body is None:
        body = {
            "pageUrn": str(page_id),
            "printFriendly": True,
            "enabled": True,
            "isDynamic": False,
            "hasPageBreaks": False,
            "content": [],
            "standard": {
                "aspectRatio": 1.67,
                "width": 60,
                "type": "STANDARD",
                "template": [],
            },
            "compact": {
                "aspectRatio": 1.0,
                "width": 12,
                "type": "COMPACT",
                "template": [],
            },
            "background": {
                "selectedColor": "#FFFFFF",
                "textColor": "#4A4A4A",
                "type": "COLOR",
                "darkMode": False,
                "alpha": 1.0,
            },
        }

    res = await gd.get_data(
        auth=auth, url=url, method="POST", body=body, context=context
    )

    if return_raw:
        return res
    if not res.is_success:
        raise Page_CRUD_Error(
            operation="create_layout",
            page_id=str(page_id),
            message=f"Unable to create layout for page {page_id}",
            res=res,
        )
    return res

delete_page async

delete_page(
    auth: DomoAuth,
    page_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Delete a page.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	ID of the page to delete	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object confirming deletion

Raises:

Type	Description
Page_CRUD_Error	If page deletion fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def delete_page(
    auth: DomoAuth,
    page_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Delete a page.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: ID of the page to delete
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters

    Returns:
        ResponseGetData object confirming deletion

    Raises:
        Page_CRUD_Error: If page deletion fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v1/pages/{page_id}"

    res = await gd.get_data(auth=auth, url=url, method="DELETE", context=context)

    if return_raw:
        return res
    if not res.is_success:
        raise Page_CRUD_Error(operation="delete", page_id=str(page_id), res=res)
    return res

delete_writelock async

delete_writelock(
    auth: DomoAuth,
    layout_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Remove write lock from a page layout.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
layout_id	str	Unique identifier for the page layout	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters (session, debug_api, etc.)	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing unlock operation result

Raises:

Type	Description
Page_CRUD_Error	If write lock removal fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def delete_writelock(
    auth: DomoAuth,
    layout_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Remove write lock from a page layout.

    Args:
        auth: Authentication object containing credentials and instance info
        layout_id: Unique identifier for the page layout
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters (session, debug_api, etc.)

    Returns:
        ResponseGetData object containing unlock operation result

    Raises:
        Page_CRUD_Error: If write lock removal fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v4/pages/layouts/{layout_id}/writelock"
    res = await gd.get_data(
        auth=auth,
        url=url,
        method="DELETE",
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        raise Page_CRUD_Error(
            operation="remove writelock",
            page_id=layout_id,
            message=f"Unable to remove writelock from layout {layout_id}",
            res=res,
        )

    return res

get_page_layout async

get_page_layout(
    auth: DomoAuth,
    layout_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Retrieve page layout configuration including card arrangement.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
layout_id	str	Unique identifier for the page layout	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters (session, debug_api, etc.)	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing layout configuration

Raises:

Type	Description
Page_GET_Error	If layout retrieval fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def get_page_layout(
    auth: DomoAuth,
    layout_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Retrieve page layout configuration including card arrangement.

    Args:
        auth: Authentication object containing credentials and instance info
        layout_id: Unique identifier for the page layout
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters (session, debug_api, etc.)

    Returns:
        ResponseGetData object containing layout configuration

    Raises:
        Page_GET_Error: If layout retrieval fails
    """
    from .exceptions import Page_GET_Error

    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v4/pages/layouts/{layout_id}"

    res = await gd.get_data(
        auth=auth,
        url=url,
        method="GET",
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        raise Page_GET_Error(
            page_id=layout_id,
            message=f"Unable to retrieve layout {layout_id}",
            res=res,
        )

    return res

put_writelock async

put_writelock(
    auth: DomoAuth,
    layout_id: str,
    user_id: str,
    epoch_time: int,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Set write lock on a page layout.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
layout_id	str	Unique identifier for the page layout	required
user_id	str	ID of the user acquiring the lock	required
epoch_time	int	Timestamp for lock acquisition	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters (session, debug_api, etc.)	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing lock operation result

Raises:

Type	Description
Page_CRUD_Error	If write lock operation fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def put_writelock(
    auth: DomoAuth,
    layout_id: str,
    user_id: str,
    epoch_time: int,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Set write lock on a page layout.

    Args:
        auth: Authentication object containing credentials and instance info
        layout_id: Unique identifier for the page layout
        user_id: ID of the user acquiring the lock
        epoch_time: Timestamp for lock acquisition
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters (session, debug_api, etc.)

    Returns:
        ResponseGetData object containing lock operation result

    Raises:
        Page_CRUD_Error: If write lock operation fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v4/pages/layouts/{layout_id}/writelock"

    body = {
        "layoutId": layout_id,
        "lockHeartbeat": epoch_time,
        "lockTimestamp": epoch_time,
        "userId": user_id,
    }

    res = await gd.get_data(
        auth=auth,
        url=url,
        body=body,
        method="PUT",
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        raise Page_CRUD_Error(
            operation="set writelock",
            page_id=layout_id,
            message=f"Unable to set writelock on layout {layout_id}",
            res=res,
        )

    return res

update_page async

update_page(
    auth: DomoAuth,
    page_id: str,
    title: str | None = None,
    locked: bool | None = None,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Update page properties (title, lock status).

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	ID of the page to update	required
title	str | None	New title (optional)	None
locked	bool | None	Lock status (optional)	None
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing the updated page info

Raises:

Type	Description
Page_CRUD_Error	If page update fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def update_page(
    auth: DomoAuth,
    page_id: str,
    title: str | None = None,
    locked: bool | None = None,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Update page properties (title, lock status).

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: ID of the page to update
        title: New title (optional)
        locked: Lock status (optional)
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters

    Returns:
        ResponseGetData object containing the updated page info

    Raises:
        Page_CRUD_Error: If page update fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v1/pages/{page_id}"

    body: dict[str, Any] = {}
    if title is not None:
        body["title"] = title
    if locked is not None:
        body["locked"] = locked

    res = await gd.get_data(
        auth=auth, url=url, method="PUT", body=body, context=context
    )

    if return_raw:
        return res
    if not res.is_success:
        raise Page_CRUD_Error(operation="update", page_id=str(page_id), res=res)
    return res

update_page_layout async

update_page_layout(
    auth: DomoAuth,
    layout_id: str,
    body: dict,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Update page layout configuration.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
layout_id	str	Unique identifier for the page layout	required
body	dict	Layout configuration data	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None
**context_kwargs		Additional context parameters (session, debug_api, etc.)	{}

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing update result

Raises:

Type	Description
Page_CRUD_Error	If layout update fails

Source code in src/crew_dcs/routes/page/crud.py

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def update_page_layout(
    auth: DomoAuth,
    layout_id: str,
    body: dict,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Update page layout configuration.

    Args:
        auth: Authentication object containing credentials and instance info
        layout_id: Unique identifier for the page layout
        body: Layout configuration data
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration
        **context_kwargs: Additional context parameters (session, debug_api, etc.)

    Returns:
        ResponseGetData object containing update result

    Raises:
        Page_CRUD_Error: If layout update fails
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v4/pages/layouts/{layout_id}"

    res = await gd.get_data(
        auth=auth,
        url=url,
        body=body,
        method="PUT",
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        raise Page_CRUD_Error(
            operation="update",
            page_id=layout_id,
            message=f"Unable to update layout {layout_id}",
            res=res,
        )

    return res