page

page

Page Route Functions

This module provides functions for managing Domo pages including retrieval, layout management, access control, and sharing operations.

The module is organized into functional areas: - core: Basic page retrieval and definition functions - access: Access control and permissions functions - crud: Layout management, locks, and ownership functions - exceptions: All page-related exception classes

Functions:

Name	Description
get_pages_adminsummary	Retrieve all pages visible to the user
get_page_by_id	Retrieve a specific page by ID
get_page_definition	Retrieve detailed page definition
get_page_layout	Retrieve page layout configuration
get_page_access_test	Test page access permissions
get_page_access_list	Retrieve page access list with users and groups
update_page_layout	Update page layout configuration
put_writelock	Set write lock on a page layout
delete_writelock	Remove write lock from a page layout
add_page_owner	Add owners to pages

Classes:

Name	Description
PageAccess	Page sharing permissions enum

Exception Classes

Page_GET_Error: Raised when page retrieval fails SearchPageNotFoundError: Raised when page search returns no results Page_CRUD_Error: Raised when page create/update/delete operations fail PageSharing_Error: Raised when page sharing operations fail

PageAccess

Bases: Access, Enum

Page sharing permissions (users and groups).

Represents the access levels that can be granted when sharing pages in Domo. Unlike accounts which have separate v1/v2 APIs, page sharing uses a unified API.

Attributes:

Name	Type	Description
OWNER		Full ownership with all permissions
CAN_EDIT		Can modify page content and configuration
CAN_VIEW		Read-only access to view the page

Example

access = PageAccess.CAN_VIEW access.value 'CAN_VIEW' PageAccess.get("CAN_EDIT")

PageSharing_Error

PageSharing_Error(
    message: str | None = None,
    operation: str | None = None,
    page_id: str | None = None,
    res: ResponseGetData | None = None,
    **kwargs
)

Bases: RouteError

Raised when page sharing operations fail.

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

def __init__(
    self,
    message: str | None = None,
    operation: str | None = None,
    page_id: str | None = None,
    res: rgd.ResponseGetData | None = None,
    **kwargs,
):
    super().__init__(
        message=message or f"Page sharing {operation} failed",
        entity_id=page_id,
        res=res,
        **kwargs,
    )

Page_CRUD_Error

Page_CRUD_Error(
    message: str | None = None,
    operation: str | None = None,
    page_id: str | None = None,
    res=None,
    **kwargs
)

Bases: RouteError

Raised when page create, update, or delete operations fail.

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

def __init__(
    self,
    message: str | None = None,
    operation: str | None = None,
    page_id: str | None = None,
    res=None,
    **kwargs,
):
    super().__init__(
        message=message or f"Page {operation} operation failed",
        entity_id=page_id,
        res=res,
        **kwargs,
    )

Page_GET_Error

Page_GET_Error(
    page_id: str | None = None,
    message: str | None = None,
    res: ResponseGetData | None = None,
    **kwargs
)

Bases: RouteError

Raised when page retrieval operations fail.

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

def __init__(
    self,
    page_id: str | None = None,
    message: str | None = None,
    res: rgd.ResponseGetData | None = None,
    **kwargs,
):
    super().__init__(
        message=message or "Page retrieval failed",
        entity_id=page_id,
        res=res,
        **kwargs,
    )

SearchPageNotFoundError

SearchPageNotFoundError(
    message: str | None = None,
    search_criteria: str | None = None,
    res: ResponseGetData | None = None,
    **kwargs
)

Bases: RouteError

Raised when page search operations return no results.

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

def __init__(
    self,
    message: str | None = None,
    search_criteria: str | None = None,
    res: rgd.ResponseGetData | None = None,
    **kwargs,
):
    super().__init__(
        message=message or f"No pages found matching: {search_criteria}",
        res=res,
        additional_context={"search_criteria": search_criteria},
        **kwargs,
    )

add_page_owner async

add_page_owner(
    auth: DomoAuth,
    page_id_ls: list[int | str],
    group_id_ls: list[int | str] | None = None,
    user_id_ls: list[int | str] | None = None,
    note: str = "",
    send_email: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs
) -> ResponseGetData

Add owners to multiple pages.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id_ls	list[int | str]	list of page IDs to add owners to	required
group_id_ls	list[int | str] | None	Optional list of group IDs to add as owners	None
user_id_ls	list[int | str] | None	Optional list of user IDs to add as owners	None
note	str	Optional note to include with ownership changes	''
send_email	bool	Whether to send notification email	False
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 ownership update result

Raises:

Type	Description
Page_CRUD_Error	If adding page owners fails

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

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def add_page_owner(
    auth: DomoAuth,
    page_id_ls: list[int | str],
    group_id_ls: list[int | str] | None = None,
    user_id_ls: list[int | str] | None = None,
    note: str = "",
    send_email: bool = False,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Add owners to multiple pages.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id_ls: list of page IDs to add owners to
        group_id_ls: Optional list of group IDs to add as owners
        user_id_ls: Optional list of user IDs to add as owners
        note: Optional note to include with ownership changes
        send_email: Whether to send notification email
        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 ownership update result

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

    page_id_ls = [str(ele) for ele in page_id_ls]
    group_id_ls = group_id_ls or []
    user_id_ls = user_id_ls or []

    url = f"https://{auth.domo_instance}.domo.com/api/content/v1/pages/bulk/owners"
    owners = []
    for group in group_id_ls:
        owners.append({"id": str(group), "type": "GROUP"})
    for user in user_id_ls:
        owners.append({"id": str(user), "type": "USER"})

    body = {
        "pageIds": page_id_ls,
        "owners": owners,
        "note": note,
        "sendEmail": send_email,
    }

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

    if return_raw:
        return res

    if not res.is_success:
        raise Page_CRUD_Error(
            operation="add owners",
            message=f"Unable to add owners to pages {', '.join(page_id_ls)}",
            res=res,
        )

    # NOTE: this string is built from the INPUT, not from a read-back. An empty
    # `owners` list produces the same sentence as a real grant — which is what
    # happens when a caller spells the argument `user_ids` instead of
    # `user_id_ls` (it is then swallowed by **context_kwargs). Callers that need
    # to know the grant landed must re-read the access list; see
    # .agents/guides/access-and-sharing.md.
    res.response = f"Successfully added owners to pages {', '.join(page_id_ls)}"

    return res

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_access_list async

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

Retrieve page access list showing which users and groups have access.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	Unique identifier for the page	required
is_expand_users	bool	Whether to expand group memberships to include individual users	True
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 access list with users and groups

Raises:

Type	Description
PageSharing_Error	If access list retrieval fails
SearchPageNotFoundError	If page with specified ID doesn't exist

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

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def get_page_access_list(
    auth: DomoAuth,
    page_id: str,
    is_expand_users: bool = True,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Retrieve page access list showing which users and groups have access.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: Unique identifier for the page
        is_expand_users: Whether to expand group memberships to include individual users
        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 access list with users and groups

    Raises:
        PageSharing_Error: If access list retrieval fails
        SearchPageNotFoundError: If page with specified ID doesn't exist
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v1/share/accesslist/page/{page_id}?expandUsers={is_expand_users}"

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

    if return_raw:
        return res

    if not res.is_success:
        if res.status == 404:
            raise SearchPageNotFoundError(
                search_criteria=f"page_id: {page_id}",
                res=res,
            )
        raise PageSharing_Error(
            operation="retrieve access list",
            page_id=page_id,
            res=res,
        )

    res.response["explicitSharedUserCount"] = len(res.response.get("users"))
    for user in res.response.get("users"):
        user.update({"isExplicitShare": True})

    # add group members to users response
    if is_expand_users:
        group_users = [
            {**user, "isExplicitShare": False}
            for group in res.response.get("groups")
            for user in group.get("users")
        ]
        users = res.response.get("users") + [
            group_user
            for group_user in group_users
            if group_user.get("id")
            not in [user.get("id") for user in res.response.get("users")]
        ]
        res.response.update({"users": users})

    return res

get_page_access_test async

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

Test page access permissions for the authenticated user.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	Unique identifier for the page	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 page access information

Raises:

Type	Description
Page_GET_Error	If access test fails
SearchPageNotFoundError	If page with specified ID doesn't exist

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

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def get_page_access_test(
    auth: DomoAuth,
    page_id: str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Test page access permissions for the authenticated user.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: Unique identifier for the page
        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 page access information

    Raises:
        Page_GET_Error: If access test fails
        SearchPageNotFoundError: If page with specified ID doesn't exist
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

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

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

    if return_raw:
        return res

    if not res.is_success:
        if res.status == 404:
            raise SearchPageNotFoundError(
                search_criteria=f"page_id: {page_id}",
                res=res,
            )
        raise Page_GET_Error(page_id=page_id, res=res)

    return res

get_page_by_id async

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

Retrieve a specific page by ID.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	str	Unique identifier for the page	required
include_layout	bool	Include page layout information in response	False
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing page information

Raises:

Type	Description
Page_GET_Error	If page retrieval fails
SearchPageNotFoundError	If page with specified ID doesn't exist

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

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

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: Unique identifier for the page
        include_layout: Include page layout information in response
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration

    Returns:
        ResponseGetData object containing page information

    Raises:
        Page_GET_Error: If page retrieval fails
        SearchPageNotFoundError: If page with specified ID doesn't exist
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    # 9/21/2023 - the domo UI uses /cards to get page info
    url = f"https://{auth.domo_instance}.domo.com/api/content/v3/stacks/{page_id}/cards"

    if include_layout:
        url += "?includeV4PageLayouts=true"

    # Use RouteContext for logging, caching, and session configuration
    res = await gd.get_data(
        auth=auth,
        url=url,
        method="GET",
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        if res.status == 404:
            raise SearchPageNotFoundError(
                search_criteria=f"page_id: {page_id}",
                res=res,
            )
        raise Page_GET_Error(page_id=page_id, res=res)

    if not isinstance(res.response, dict) or not res.response.get("id", None):
        raise Page_GET_Error(
            page_id=page_id,
            message="Invalid page response format",
            res=res,
        )

    return res

get_page_definition async

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

Retrieve detailed page definition including metadata and layout.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
page_id	int | str	Unique identifier for the page	required
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing detailed page information

Raises:

Type	Description
Page_GET_Error	If page definition retrieval fails
SearchPageNotFoundError	If page with specified ID doesn't exist

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

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def get_page_definition(
    auth: DomoAuth,
    page_id: int | str,
    return_raw: bool = False,
    *,
    context: RouteContext | None = None,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Retrieve detailed page definition including metadata and layout.

    Args:
        auth: Authentication object containing credentials and instance info
        page_id: Unique identifier for the page
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration

    Returns:
        ResponseGetData object containing detailed page information

    Raises:
        Page_GET_Error: If page definition retrieval fails
        SearchPageNotFoundError: If page with specified ID doesn't exist
    """
    context = RouteContext.build_context(context=context, **context_kwargs)

    url = f"https://{auth.domo_instance}.domo.com/api/content/v3/stacks/{page_id}/cards"

    params = {
        "includeV4PageLayouts": "true",
        "parts": "metadata,datasources,library,drillPathURNs,certification,owners,dateInfo,subscriptions,slicers",
    }

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

    if return_raw:
        return res

    if not res.is_success:
        if res.status == 404:
            raise SearchPageNotFoundError(
                search_criteria=f"page_id: {page_id}",
                res=res,
            )
        raise Page_GET_Error(page_id=str(page_id), res=res)

    if not isinstance(res.response, dict) or not res.response.get("id", None):
        raise Page_GET_Error(
            page_id=str(page_id),
            message="Invalid page definition response format",
            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

get_pages_adminsummary async

get_pages_adminsummary(
    auth: DomoAuth,
    search_title: str | None = None,
    page_parent_id: str | None = None,
    body: dict | None = None,
    limit: int = 35,
    debug_loop: bool = False,
    *,
    context: RouteContext | None = None,
    return_raw: bool = False,
    **context_kwargs
) -> ResponseGetData

Retrieve all pages in instance that user is able to see.

Parameters:

Name	Type	Description	Default
auth	DomoAuth	Authentication object containing credentials and instance info	required
search_title	str | None	Optional title search filter	None
page_parent_id	str | None	Optional parent page ID filter	None
body	dict | None	Optional custom request body	None
limit	int	Maximum number of results per request (default: 35)	35
debug_loop	bool	Enable loop debugging output	False
return_raw	bool	Return raw API response without processing	False
context	RouteContext | None	RouteContext for request configuration	None

Returns:

Type	Description
ResponseGetData	ResponseGetData object containing pages information

Raises:

Type	Description
Page_GET_Error	If page retrieval fails

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

@gd.route_function
@log_call(
    level_name="route",
    config=LogDecoratorConfig(
        entity_extractor=DomoEntityExtractor(),
        result_processor=DomoEntityResultProcessor(),
    ),
)
async def get_pages_adminsummary(
    auth: DomoAuth,
    search_title: str | None = None,
    page_parent_id: str | None = None,
    body: dict | None = None,
    limit: int = 35,
    debug_loop: bool = False,
    *,
    context: RouteContext | None = None,
    return_raw: bool = False,
    **context_kwargs,
) -> rgd.ResponseGetData:
    """Retrieve all pages in instance that user is able to see.

    Args:
        auth: Authentication object containing credentials and instance info
        search_title: Optional title search filter
        page_parent_id: Optional parent page ID filter
        body: Optional custom request body
        limit: Maximum number of results per request (default: 35)
        debug_loop: Enable loop debugging output
        return_raw: Return raw API response without processing
        context: RouteContext for request configuration

    Returns:
        ResponseGetData object containing pages information

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

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

    offset_params = {
        "offset": "skip",
        "limit": "limit",
    }

    body = body or {"orderBy": "pageTitle", "ascending": True}

    if search_title:
        body.update(
            {"includePageTitleClause": True, "pageTitleSearchText": search_title}
        )

    if page_parent_id:
        body.update(
            {"includeParentPageIdsClause": True, "parentPageIds": [page_parent_id]}
        )

    def arr_fn(res) -> list[dict]:
        return res.response.get("pageAdminSummaries")

    # Build/merge RouteContext via decorator; use it for looper call
    res = await gd.looper(
        auth=auth,
        method="POST",
        url=url,
        arr_fn=arr_fn,
        offset_params=offset_params,
        loop_until_end=True,
        body=body,
        limit=limit,
        debug_loop=debug_loop,
        context=context,
    )

    if return_raw:
        return res

    if not res.is_success:
        raise Page_GET_Error(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

Modules

• access
• core
• crud
• exceptions