Search & Describe Twins

import json
from datetime import datetime, timedelta, timezone

from iotics.lib.identity.api.high_level_api import get_rest_high_level_identity_api
from requests import request

RESOLVER_URL = "resolver_url"
HOST = "host_url"

USER_KEY_NAME = "user_key_name"
AGENT_KEY_NAME = "agent_key_name"
USER_SEED = bytes.fromhex("user_seed")
AGENT_SEED = bytes.fromhex("agent_seed")


def make_api_call(method: str, url: str, json: dict = None):
    response = request(method=method, url=url, headers=headers, json=json)
    response.raise_for_status()

    return response.json()


def describe_remote_twin(host_id: str, twin_id: str):
    remote_twin = make_api_call(
        method="GET", url=f"{HOST}/qapi/hosts/{host_id}/twins/{twin_id}"
    )

    return remote_twin


# Not used in this example
def describe_local_twin(twin_id: str):
    local_twin = make_api_call(method="GET", url=f"{HOST}/qapi/twins/{twin_id}")

    return local_twin


# Set up the API with authentication delegation so the AGENT can authenticate on behalf of the USER
api = get_rest_high_level_identity_api(resolver_url=RESOLVER_URL)
(
    user_registered_id,
    agent_registered_id,
) = api.create_user_and_agent_with_auth_delegation(
    user_seed=USER_SEED,
    user_key_name=USER_KEY_NAME,
    agent_seed=AGENT_SEED,
    agent_key_name=AGENT_KEY_NAME,
    delegation_name="#AuthDeleg",
)

token = api.create_agent_auth_token(
    agent_registered_identity=agent_registered_id,
    user_did=user_registered_id.did,
    duration=600,
)

headers = {
    "accept": "application/json",
    "Iotics-ClientAppId": "example_code",
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json",
}

# Initialise an empty list.
# It will contain the list of Twins retrieved by the search
twins_list = []

# Add a new field in the headers.
# Client request timeout is used to stop the request processing once the timeout is reached
headers.update(
    {
        "Iotics-RequestTimeout": (
            datetime.now(tz=timezone.utc) + timedelta(seconds=10)
        ).isoformat(),
    }
)

with request(
    method="POST",
    url=f"{HOST}/qapi/searches",  # Replace with URL of the Host
    headers=headers,  # It includes the token and the Request Timeout
    stream=True,
    verify=False,
    params={"scope": "GLOBAL"},
    json={"responseType": "MINIMAL", "filter": {"text": "cambridge"}},
) as resp:
    # Raises HTTPError, if one occurred
    resp.raise_for_status()
    # Iterates over the response data, one line at a time
    for chunk in resp.iter_lines():
        response = json.loads(chunk)
        twins_found = []
        try:
            twins_found = response["result"]["payload"]["twins"]
            host_id = response["result"]["payload"]["remoteHostId"]["value"]
        except KeyError:
            host_id = "local"
        finally:
            if twins_found:
                # Add the host id value to each twin
                for twin in twins_found:
                    twin["hostId"] = host_id

                # Append the twins found to the list of twins
                twins_list.extend(twins_found)

print(f"Found {len(twins_list)} twin(s)")

twin_of_interest = next(
    iter(twins_list)
)  # For demo purpose take the fist Twin in the list
twin_id = twin_of_interest["id"]["value"]
twin_host_id = twin_of_interest["hostId"]

headers.pop("Iotics-RequestTimeout")  # RequestTimeout no longer needed in the headers

remote_twin = describe_remote_twin(host_id=twin_host_id, twin_id=twin_id)
print(remote_twin)