Minor refactor to OR client to properly support realm users

Author: dominiquekleeven

frontend/src/services/api-service.ts

@@ -23,7 +23,7 @@ function getBaseUrl(realm: string): string {
     return ML_SERVICE_URL + '/api/' + realm;
 }
 
-function getOpenRemoteBaseUrl(realm: string): string {
+function getOpenRemoteBaseUrl(realm: string = AuthService.realm): string {
     return ML_SERVICE_URL + '/proxy/openremote/' + realm;
 }
 
@@ -125,6 +125,7 @@ export const APIService = {
      * @returns The realm config
      */
     async getOpenRemoteRealmConfig(realm: string): Promise<RealmConfig> {
+        // Explicitly pass in the realm
         const response = await fetch(getOpenRemoteBaseUrl(realm) + '/realm/config', {
             method: 'GET',
             headers: buildHeaders()
@@ -140,7 +141,7 @@ export const APIService = {
      * @returns The list of accessible realms
      */
     async getAccessibleRealms(): Promise<BasicRealm[]> {
-        const response = await fetch(getOpenRemoteBaseUrl(AuthService.realm) + '/realm/accessible', {
+        const response = await fetch(getOpenRemoteBaseUrl() + '/realm/accessible', {
             method: 'GET',
             headers: buildHeaders()
         });
@@ -156,7 +157,7 @@ export const APIService = {
      * @returns The list of assets
      */
     async getOpenRemoteAssets(realm: string): Promise<BasicAsset[]> {
-        const response = await fetch(getOpenRemoteBaseUrl(realm) + '/assets', {
+        const response = await fetch(getOpenRemoteBaseUrl() + '/assets?realm_query=' + realm, {
             method: 'GET',
             headers: buildHeaders()
         });
@@ -173,7 +174,7 @@ export const APIService = {
      * @returns The list of assets
      */
     async getOpenRemoteAssetsById(realm: string, ids: string[]): Promise<BasicAsset[]> {
-        const response = await fetch(getOpenRemoteBaseUrl(realm) + '/assets/ids?ids=' + ids.join(','), {
+        const response = await fetch(getOpenRemoteBaseUrl() + '/assets/ids?realm_query=' + realm + '&ids=' + ids.join(','), {
             method: 'GET',
             headers: buildHeaders()
         });

src/service_ml_forecast/api/openremote_proxy_route.py

@@ -27,33 +27,38 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
 
 from service_ml_forecast.clients.openremote.models import Asset, BasicRealm, RealmConfig
-from service_ml_forecast.clients.openremote_proxy_client import OpenRemoteProxyClient
+from service_ml_forecast.clients.openremote.openremote_proxy_client import OpenRemoteProxyClient
 from service_ml_forecast.config import ENV
 from service_ml_forecast.dependencies import oauth2_scheme
-from service_ml_forecast.services.openremote_service import OpenRemoteService
 
 router = APIRouter(prefix="/proxy/openremote/{realm}", tags=["OpenRemote Proxy API"])
 
 
 @router.get(
     "/assets",
-    summary="Retrieve assets from an OpenRemote realm that store datapoints",
+    summary="Retrieve assets that store datapoints",
     responses={
         HTTPStatus.OK: {"description": "Assets have been retrieved"},
         HTTPStatus.UNAUTHORIZED: {"description": "Unauthorized"},
     },
 )
-async def get_assets(
+async def get_assets_with_historical_data(
     token: Annotated[str, Depends(oauth2_scheme)],
     realm: str,
+    realm_query: str = Query(..., alias="realm_query", description="The realm used for the asset query"),
 ) -> list[Asset]:
-    or_proxy_service = _build_proxy_service(token)
-    return or_proxy_service.get_assets_with_historical_datapoints(realm)
+    proxy_client = _build_proxy_client(token)
+    assets = proxy_client.get_assets_with_historical_data(realm_query, realm)
+
+    if assets is None:
+        return []
+
+    return assets
 
 
 @router.get(
     "/assets/ids",
-    summary="Retrieve assets from an OpenRemote realm by a comma-separated list of Asset IDs",
+    summary="Retrieve assets by a comma-separated list of Asset IDs",
     responses={
         HTTPStatus.OK: {"description": "Assets have been retrieved"},
         HTTPStatus.UNAUTHORIZED: {"description": "Unauthorized"},
@@ -62,17 +67,23 @@ async def get_assets(
 async def get_assets_by_ids(
     token: Annotated[str, Depends(oauth2_scheme)],
     realm: str,
+    realm_query: str = Query(..., alias="realm_query", description="The realm used for the asset query"),
     ids_str: str = Query(..., alias="ids", description="Comma-separated list of asset IDs"),
 ) -> list[Asset]:
     ids_list = [asset_id.strip() for asset_id in ids_str.split(",") if asset_id.strip()]
 
-    or_proxy_service = _build_proxy_service(token)
-    return or_proxy_service.get_assets_by_ids(realm, ids_list)
+    proxy_client = _build_proxy_client(token)
+    assets = proxy_client.get_assets_by_ids(ids_list, realm_query, realm)
+
+    if assets is None:
+        return []
+
+    return assets
 
 
 @router.get(
     "/realm/config",
-    summary="Retrieve the realm configuration of an OpenRemote realm",
+    summary="Retrieve realm configuration",
     responses={
         HTTPStatus.OK: {"description": "Realm configuration has been retrieved"},
         HTTPStatus.NOT_FOUND: {"description": "Realm configuration not found"},
@@ -83,18 +94,23 @@ async def get_realm_config(
     token: Annotated[str, Depends(oauth2_scheme)],
     realm: str,
 ) -> RealmConfig:
-    or_proxy_service = _build_proxy_service(token)
-    config = or_proxy_service.get_realm_config(realm)
+    proxy_client = _build_proxy_client(token)
+    config = proxy_client.get_manager_config(realm)
+
+    if config is None or config.realms is None:
+        raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Configuration not found")
+
+    realm_config = config.realms[realm]
 
-    if config is None:
+    if realm_config is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Realm configuration not found")
 
-    return config
+    return realm_config
 
 
 @router.get(
     "/realm/accessible",
-    summary="Retrieve accessible realms",
+    summary="Retrieve accessible realms for the current user",
     responses={
         HTTPStatus.OK: {"description": "Accessible realms have been retrieved"},
         HTTPStatus.UNAUTHORIZED: {"description": "Unauthorized"},
@@ -105,23 +121,22 @@ async def get_accessible_realms(
     token: Annotated[str, Depends(oauth2_scheme)],
     realm: str,
 ) -> list[BasicRealm]:
-    or_proxy_service = _build_proxy_service(token)
-    realms = or_proxy_service.get_accessible_realms(realm)
+    proxy_client = _build_proxy_client(token)
+    realms = proxy_client.get_accessible_realms(realm)
 
     if realms is None:
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Unable to retrieve realms")
 
     return realms
 
 
-def _build_proxy_service(token: str) -> OpenRemoteService:
-    """Build the OpenRemote service that proxies the request with the given token.
+def _build_proxy_client(token: str) -> OpenRemoteProxyClient:
+    """Build the OpenRemote proxy client with the given token.
 
     Args:
         token: The token to use for the OpenRemote service.
 
     Returns:
         The OpenRemote service with the proxy client.
     """
-    proxy_client = OpenRemoteProxyClient(openremote_url=ENV.ML_OR_URL, token=token)
-    return OpenRemoteService(client=proxy_client)
+    return OpenRemoteProxyClient(openremote_url=ENV.ML_OR_URL, token=token)

src/service_ml_forecast/clients/openremote/openremote_client.py

@@ -33,6 +33,8 @@
     Realm,
 )
 
+MASTER_REALM = "master"
+
 
 class OAuthTokenResponse(BaseModel):
     """Response model for OpenRemote OAuth token."""
@@ -148,7 +150,9 @@ def health_check(self) -> bool:
                 self.logger.error(f"OpenRemote API is not healthy: {e}")
                 return False
 
-    def retrieve_asset_datapoint_period(self, asset_id: str, attribute_name: str) -> AssetDatapointPeriod | None:
+    def get_asset_datapoint_period(
+        self, asset_id: str, attribute_name: str, realm: str = MASTER_REALM
+    ) -> AssetDatapointPeriod | None:
         """Retrieve the datapoints timestamp period of a given asset attribute.
 
         Args:
@@ -160,7 +164,7 @@ def retrieve_asset_datapoint_period(self, asset_id: str, attribute_name: str) ->
         """
 
         query = f"?assetId={asset_id}&attributeName={attribute_name}"
-        url = f"{self.openremote_url}/api/master/asset/datapoint/periods{query}"
+        url = f"{self.openremote_url}/api/{realm}/asset/datapoint/periods{query}"
 
         request = self.__build_request("GET", url)
 
@@ -173,12 +177,13 @@ def retrieve_asset_datapoint_period(self, asset_id: str, attribute_name: str) ->
                 self.logger.error(f"Error retrieving asset datapoint period: {e}")
                 return None
 
-    def retrieve_historical_datapoints(
+    def get_historical_datapoints(
         self,
         asset_id: str,
         attribute_name: str,
         from_timestamp: int,
         to_timestamp: int,
+        realm: str = MASTER_REALM,
     ) -> list[AssetDatapoint] | None:
         """Retrieve the historical data points of a given asset attribute.
 
@@ -187,13 +192,13 @@ def retrieve_historical_datapoints(
             attribute_name: The name of the attribute.
             from_timestamp: Epoch timestamp in milliseconds.
             to_timestamp: Epoch timestamp in milliseconds.
-
+            realm: The realm to retrieve assets from defaulting to MASTER_REALM.
         Returns:
             list[AssetDatapoint] | None: List of historical data points or None
         """
 
         params = f"{asset_id}/{attribute_name}"
-        url = f"{self.openremote_url}/api/master/asset/datapoint/{params}"
+        url = f"{self.openremote_url}/api/{realm}/asset/datapoint/{params}"
 
         request_body = AssetDatapointQuery(
             fromTimestamp=from_timestamp,
@@ -212,20 +217,22 @@ def retrieve_historical_datapoints(
                 self.logger.error(f"Error retrieving historical datapoints: {e}")
                 return None
 
-    def write_predicted_datapoints(self, asset_id: str, attribute_name: str, datapoints: list[AssetDatapoint]) -> bool:
+    def write_predicted_datapoints(
+        self, asset_id: str, attribute_name: str, datapoints: list[AssetDatapoint], realm: str = MASTER_REALM
+    ) -> bool:
         """Write the predicted data points of a given asset attribute.
 
         Args:
             asset_id: The ID of the asset.
             attribute_name: The name of the attribute.
             datapoints: The data points to write.
-
+            realm: The realm to write the data points to defaulting to MASTER_REALM.
         Returns:
             bool: True if successful
         """
 
         params = f"{asset_id}/{attribute_name}"
-        url = f"{self.openremote_url}/api/master/asset/predicted/{params}"
+        url = f"{self.openremote_url}/api/{realm}/asset/predicted/{params}"
 
         datapoints_json = [datapoint.model_dump() for datapoint in datapoints]
 
@@ -240,12 +247,13 @@ def write_predicted_datapoints(self, asset_id: str, attribute_name: str, datapoi
                 self.logger.error(f"Error writing predicted datapoints: {e}")
                 return False
 
-    def retrieve_predicted_datapoints(
+    def get_predicted_datapoints(
         self,
         asset_id: str,
         attribute_name: str,
         from_timestamp: int,
         to_timestamp: int,
+        realm: str = MASTER_REALM,
     ) -> list[AssetDatapoint] | None:
         """Retrieve the predicted data points of a given asset attribute.
 
@@ -254,13 +262,13 @@ def retrieve_predicted_datapoints(
             attribute_name: The name of the attribute.
             from_timestamp: Epoch timestamp in milliseconds.
             to_timestamp: Epoch timestamp in milliseconds.
-
+            realm: The realm to retrieve assets from defaulting to MASTER_REALM.
         Returns:
             list[AssetDatapoint] | None: List of predicted data points or None
         """
 
         params = f"{asset_id}/{attribute_name}"
-        url = f"{self.openremote_url}/api/master/asset/predicted/{params}"
+        url = f"{self.openremote_url}/api/{realm}/asset/predicted/{params}"
 
         request_body = AssetDatapointQuery(
             fromTimestamp=from_timestamp,
@@ -279,21 +287,22 @@ def retrieve_predicted_datapoints(
                 self.logger.error(f"Error retrieving predicted datapoints: {e}")
                 return None
 
-    def retrieve_assets_with_historical_datapoints(self, realm: str) -> list[Asset] | None:
+    def get_assets_with_historical_data(self, query_realm: str, realm: str = MASTER_REALM) -> list[Asset] | None:
         """Retrieve all assets for a given realm that store historical datapoints.
 
         Args:
-            realm: The realm to retrieve assets from.
+            query_realm: The realm for the asset query.
+            realm: The realm to retrieve assets from defaulting to MASTER_REALM.
 
         Returns:
             list[Asset] | None: List of assets or None
         """
 
-        url = f"{self.openremote_url}/api/master/asset/query"
+        url = f"{self.openremote_url}/api/{realm}/asset/query"
 
         # OR Asset Query to retrieve only assets that have attributes with "meta": {"storeDataPoints": true}
         asset_query = {
-            "realm": {"name": realm},
+            "realm": {"name": query_realm},
             "attributes": {
                 "operator": "AND",
                 "items": [
@@ -342,19 +351,22 @@ def _filter_asset_attributes(asset_obj: Asset) -> Asset:
                 self.logger.error(f"Error retrieving assets with storeDataPoints: {e}")
                 return None
 
-    def retrieve_assets_by_ids(self, asset_ids: list[str], realm: str) -> list[Asset] | None:
+    def get_assets_by_ids(
+        self, asset_ids: list[str], query_realm: str, realm: str = MASTER_REALM
+    ) -> list[Asset] | None:
         """Retrieve assets by their IDs.
 
         Args:
             asset_ids: The IDs of the assets to retrieve.
-            realm: The realm to retrieve assets from.
+            query_realm: The realm for the asset query.
+            realm: The realm to retrieve assets from defaulting to MASTER_REALM.
 
         Returns:
             list[Asset] | None: List of assets or None
         """
 
-        url = f"{self.openremote_url}/api/master/asset/query"
-        asset_query = {"recursive": False, "realm": {"name": realm}, "ids": asset_ids}
+        url = f"{self.openremote_url}/api/{realm}/asset/query"
+        asset_query = {"recursive": False, "realm": {"name": query_realm}, "ids": asset_ids}
 
         request = self.__build_request("POST", url, data=asset_query)
 
@@ -368,13 +380,16 @@ def retrieve_assets_by_ids(self, asset_ids: list[str], realm: str) -> list[Asset
                 self.logger.error(f"Error retrieving assets: {e}")
                 return None
 
-    def retrieve_manager_config(self) -> ManagerConfig | None:
+    def get_manager_config(self, realm: str = MASTER_REALM) -> ManagerConfig | None:
         """Retrieve the manager configuration.
 
+        Args:
+            realm: The realm to retrieve the manager configuration from defaulting to MASTER_REALM.
+
         Returns: ManagerConfig | None: The manager configuration or None
         """
 
-        url = f"{self.openremote_url}/api/master/configuration/manager"
+        url = f"{self.openremote_url}/api/{realm}/configuration/manager"
         request = self.__build_request("GET", url)
 
         with httpx.Client(timeout=self.timeout) as client:
@@ -388,9 +403,12 @@ def retrieve_manager_config(self) -> ManagerConfig | None:
                 self.logger.error(f"Error retrieving manager config: {e}")
                 return None
 
-    def retrieve_accessible_realms(self, realm: str) -> list[BasicRealm] | None:
+    def get_accessible_realms(self, realm: str = MASTER_REALM) -> list[BasicRealm] | None:
         """Retrieves accessible realms for the current user.
 
+        Args:
+            realm: The realm to retrieve realms from defaulting to MASTER_REALM.
+
         Returns:
             list[BasicRealm] | None: List of accessible realms or None
         """
@@ -408,14 +426,17 @@ def retrieve_accessible_realms(self, realm: str) -> list[BasicRealm] | None:
                 self.logger.error(f"Error retrieving accessible realms: {e}")
                 return None
 
-    def retrieve_all_realms(self) -> list[Realm] | None:
+    def get_all_enabled_realms(self, realm: str = MASTER_REALM) -> list[Realm] | None:
         """Retrieves all realms and filters out disabled ones.
 
+        Args:
+            realm: The realm to retrieve realms from defaulting to MASTER_REALM.
+
         Returns:
             list[Realm] | None: List of enabled realms or None
         """
 
-        url = f"{self.openremote_url}/api/master/realm"
+        url = f"{self.openremote_url}/api/{realm}/realm"
         request = self.__build_request("GET", url)
 
         with httpx.Client(timeout=self.timeout) as client: