Merge pull request #22 from whdalsrnt/master

fix: fix missing domain_id issue

Author: Jongmin Kim

src/spaceone/statistics/manager/identity_manager.py

@@ -16,5 +16,5 @@ def __init__(self, *args, **kwargs):
     def list_domains(self, query: dict) -> dict:
         system_token = config.get_global("TOKEN")
         return self.identity_conn.dispatch(
-            "Domain.list", {"query": query}, token=system_token
+            "Domain.list", {"query": query, "state": "ENABLED"}, token=system_token
         )

src/spaceone/statistics/manager/resource_manager.py

@@ -2,6 +2,7 @@
 import pandas as pd
 import numpy as np
 
+from spaceone.core.auth.jwt.jwt_util import JWTUtil
 from spaceone.core.manager import BaseManager
 from spaceone.core.connector.space_connector import SpaceConnector
 from spaceone.statistics.error import *
@@ -20,25 +21,25 @@
 
 
 class ResourceManager(BaseManager):
-    def stat(self, aggregate: list, page: dict) -> dict:
-        results = self._execute_aggregate_operations(aggregate)
+    def stat(self, aggregate: list, page: dict, domain_id: str = None) -> dict:
+        results = self._execute_aggregate_operations(aggregate, domain_id)
         return self._page(page, results)
 
-    def _execute_aggregate_operations(self, aggregate):
+    def _execute_aggregate_operations(self, aggregate: list, domain_id: str = None):
         df = None
 
         if "query" not in aggregate[0]:
             raise ERROR_REQUIRED_QUERY_OPERATION()
 
         for stage in aggregate:
             if "query" in stage:
-                df = self._query(stage["query"])
+                df = self._query(stage["query"], domain_id=domain_id)
 
             elif "join" in stage:
-                df = self._join(stage["join"], df)
+                df = self._join(stage["join"], df, domain_id)
 
             elif "concat" in stage:
-                df = self._concat(stage["concat"], df)
+                df = self._concat(stage["concat"], df, domain_id)
 
             elif "sort" in stage:
                 df = self._sort(stage["sort"], df)
@@ -122,8 +123,8 @@ def _sort(options, base_df):
 
         return base_df
 
-    def _concat(self, options, base_df):
-        concat_df = self._query(options, operator="join")
+    def _concat(self, options, base_df, domain_id):
+        concat_df = self._query(options, operator="join", domain_id=domain_id)
 
         try:
             base_df = pd.concat([base_df, concat_df], ignore_index=True)
@@ -152,15 +153,15 @@ def _generate_empty_data(query):
 
         return pd.DataFrame(empty_data)
 
-    def _join(self, options, base_df):
+    def _join(self, options, base_df, domain_id):
         if "type" in options and options["type"] not in _JOIN_TYPE_MAP:
             raise ERROR_INVALID_PARAMETER_TYPE(
                 key="aggregate.join.type", type=list(_JOIN_TYPE_MAP.keys())
             )
 
         join_keys = options.get("keys")
         join_type = options.get("type", "LEFT")
-        join_df = self._query(options, operator="join")
+        join_df = self._query(options, operator="join", domain_id=domain_id)
 
         try:
             if join_keys:
@@ -185,7 +186,7 @@ def _join(self, options, base_df):
 
         return base_df
 
-    def _query(self, options, operator="query"):
+    def _query(self, options, operator="query", domain_id=None):
         resource_type = options.get("resource_type")
         query = options.get("query")
         extend_data = options.get("extend_data", {})
@@ -199,12 +200,21 @@ def _query(self, options, operator="query"):
         service, resource = self._parse_resource_type(resource_type)
 
         try:
+            token = self.transaction.get_meta("token")
+            token_type = JWTUtil.get_value_from_token(token, "typ")
+
             connector: SpaceConnector = self.locator.get_connector(
                 "SpaceConnector", service=service
             )
 
             _LOGGER.debug(f"[_query] stat resource: {resource_type}.stat")
-            response = connector.dispatch(f"{resource}.stat", {"query": query})
+            if token_type == "SYSTEM_TOKEN":
+                response = connector.dispatch(
+                    f"{resource}.stat", {"query": query}, x_domain_id=domain_id
+                )
+            else:
+                response = connector.dispatch(f"{resource}.stat", {"query": query})
+
             results = response.get("results", [])
 
             if len(results) > 0 and not isinstance(results[0], dict):

src/spaceone/statistics/service/history_service.py

@@ -46,7 +46,7 @@ def create(self, params: dict) -> None:
         aggregate = options.get("aggregate", [])
         page = params.get("page", {})
 
-        response = self.resource_mgr.stat(aggregate, page)
+        response = self.resource_mgr.stat(aggregate, page, domain_id)
 
         results = response.get("results", [])
         self.history_mgr.create_history(schedule_vo, topic, results, domain_id)