[COST-4945] Create a new API to return list of EC2-compute instances

koku/api/common/pagination.py

@@ -139,6 +139,12 @@ def get_limit_parameter(self, request):
             return int(request.query_params.get(self.limit_query_param))
         return None
 
+    def get_paginated_data(self, queryset):
+        """Shared logic for paginating the data list."""
+        if self.limit:
+            return queryset.get("data", [])[self.offset : self.offset + self.limit]
+        return queryset.get("data", [])
+
     def paginate_queryset(self, queryset, request, view=None):
         """Override queryset pagination."""
         self.count = self.get_count(queryset)
@@ -157,12 +163,7 @@ def paginate_queryset(self, queryset, request, view=None):
             queryset["data"] = []
             return queryset
 
-        if self.limit:
-            query_data = queryset.get("data", [])[self.offset : self.offset + self.limit]  # noqa
-        else:
-            query_data = queryset.get("data", [])
-
-        queryset["data"] = query_data
+        queryset["data"] = self.get_paginated_data(queryset)
 
         return queryset
 
@@ -295,3 +296,30 @@ def get_paginated_response(self):
                 "data": self.data_set,
             }
         )
+
+
+class AWSEC2ComputePagination(ReportPagination):
+    """Paginator for AWS EC2 compute instances report data."""
+
+    def get_count(self, queryset):
+        """Special case count for EC2 resource IDs."""
+        return len(queryset.get("data", [])[0].get("resource_ids", []))
+
+    def get_paginated_data(self, queryset):
+        """Special case pagination for EC2 resource IDs."""
+
+        paginated_data = []
+
+        for item in queryset.get("data", []):
+            resource_ids = item.get("resource_ids", [])
+            resource_count = len(resource_ids)
+
+            # if the current offset is within the range of resource IDs.
+            if self.offset < resource_count:
+                paginated_item = item.copy()
+
+                # paginate resource IDs from current_offset to the limit
+                paginated_item["resource_ids"] = resource_ids[self.offset : self.offset + self.limit]
+                paginated_data.append(paginated_item)
+
+        return paginated_data

koku/api/query_handler.py

@@ -21,6 +21,9 @@
 from api.currency.models import ExchangeRateDictionary
 from api.query_filter import QueryFilter
 from api.query_filter import QueryFilterCollection
+from api.report.constants import RESOLUTION_DAILY
+from api.report.constants import TIME_SCOPE_UNITS_DAILY
+from api.report.constants import TIME_SCOPE_VALUES_DAILY
 from api.utils import DateHelper
 
 LOG = logging.getLogger(__name__)
@@ -67,9 +70,9 @@
         self._max_rank = 0
 
         self.time_scope_units = self.parameters.get_filter("time_scope_units")
-        if self.parameters.get_filter("time_scope_value"):
-            self.time_scope_value = int(self.parameters.get_filter("time_scope_value"))
-        # self.time_order = parameters["date"]
+        self.time_scope_value = (
+            int(time_scope_value) if (time_scope_value := self.parameters.get_filter("time_scope_value")) else None
+        )
 
         # self.start_datetime = parameters["start_date"]
         # self.end_datetime = parameters["end_date"]
@@ -187,7 +190,11 @@
             (String): The value of how data will be sliced.
 
         """
-        return self.parameters.get_filter("resolution", default="daily")
+
+        get_default_report_value = self._mapper._report_type_map.get("default_time_period", {}).get(
+            "resolution", RESOLUTION_DAILY
+        )
+        return self.parameters.get_filter("resolution", default=get_default_report_value)
 
     def check_query_params(self, key, in_key):
         """Test if query parameters has a given key and key within it.
@@ -209,11 +216,12 @@
             (String): The value of how data will be sliced.
 
         """
-        if self.time_scope_units:
-            return self.time_scope_units
-
-        time_scope_units = self.parameters.get_filter("time_scope_units", default="day")
-        self.time_scope_units = time_scope_units
+        if not self.time_scope_units:
+            get_default_report_value = self._mapper._report_type_map.get("default_time_period", {}).get(
+                "time_scope_units", TIME_SCOPE_UNITS_DAILY
+            )
+            time_scope_units = self.parameters.get_filter("time_scope_units", default=get_default_report_value)
+            self.time_scope_units = time_scope_units
         return self.time_scope_units
 
     def get_time_scope_value(self):
@@ -223,11 +231,12 @@
             (Integer): time relative value providing query scope
 
         """
-        if self.time_scope_value:
-            return self.time_scope_value
-
-        time_scope_value = self.parameters.get_filter("time_scope_value", default=-10)
-        self.time_scope_value = int(time_scope_value)
+        if not self.time_scope_value:
+            get_default_report_value = self._mapper._report_type_map.get("default_time_period", {}).get(
+                "time_scope_value", TIME_SCOPE_VALUES_DAILY[0]
+            )
+            time_scope_value = self.parameters.get_filter("time_scope_value", default=get_default_report_value)
+            self.time_scope_value = int(time_scope_value)
         return self.time_scope_value
 
     def _get_timeframe(self):

koku/api/query_params.py

@@ -26,10 +26,15 @@
 from api.report.constants import AWS_CATEGORY_PREFIX
 from api.report.constants import OR_AWS_CATEGORY_PREFIX
 from api.report.constants import OR_TAG_PREFIX
+from api.report.constants import RESOLUTION_DAILY
+from api.report.constants import RESOLUTION_MONTHLY
 from api.report.constants import TAG_PREFIX
+from api.report.constants import TIME_SCOPE_UNITS_DAILY
+from api.report.constants import TIME_SCOPE_UNITS_MONTHLY
+from api.report.constants import TIME_SCOPE_VALUES_DAILY
+from api.report.constants import TIME_SCOPE_VALUES_MONTHLY
 from api.report.constants import URL_ENCODED_SAFE
 from api.report.queries import ReportQueryHandler
-from api.tags.serializers import month_list
 from reporting.models import OCPAllCostLineItemDailySummaryP
 from reporting.provider.all.models import EnabledTagKeys
 from reporting.provider.aws.models import AWSEnabledCategoryKeys
@@ -421,21 +426,40 @@ def _set_time_scope_defaults(self):
         start_date = self.get_start_date()
         end_date = self.get_end_date()
         resolution = self.get_filter("resolution")
+
         if not (start_date or end_date):
             if not time_scope_value:
-                time_scope_value = -1 if time_scope_units == "month" else -10
+                time_scope_value = (
+                    TIME_SCOPE_VALUES_MONTHLY[0]
+                    if time_scope_units == TIME_SCOPE_UNITS_MONTHLY
+                    else TIME_SCOPE_VALUES_DAILY[0]
+                )
             if not time_scope_units:
-                time_scope_units = "month" if int(time_scope_value) in month_list else "day"
+                time_scope_units = (
+                    TIME_SCOPE_UNITS_MONTHLY
+                    if time_scope_value in TIME_SCOPE_VALUES_MONTHLY
+                    else TIME_SCOPE_UNITS_DAILY
+                )
             if not resolution:
-                resolution = "monthly" if int(time_scope_value) in month_list else "daily"
+                resolution = RESOLUTION_MONTHLY if time_scope_value in TIME_SCOPE_VALUES_MONTHLY else RESOLUTION_DAILY
+
             self.set_filter(
                 time_scope_value=str(time_scope_value),
                 time_scope_units=str(time_scope_units),
                 resolution=str(resolution),
             )
         else:
             if not resolution:
-                self.set_filter(resolution="daily")
+                self.set_filter(resolution=RESOLUTION_DAILY)
+
+        if self.report_type == "ec2_compute":
+            self.set_filter(
+                time_scope_value=(
+                    time_scope_value if time_scope_value in TIME_SCOPE_VALUES_MONTHLY else TIME_SCOPE_VALUES_MONTHLY[0]
+                ),
+                time_scope_units=TIME_SCOPE_UNITS_MONTHLY,
+                resolution=RESOLUTION_MONTHLY,
+            )
 
     def _validate(self, query_params):
         """Validate query parameters.

koku/api/report/aws/provider_map.py

@@ -20,6 +20,7 @@
 from reporting.provider.aws.models import AWSComputeSummaryByAccountP
 from reporting.provider.aws.models import AWSComputeSummaryP
 from reporting.provider.aws.models import AWSCostEntryLineItemDailySummary
+from reporting.provider.aws.models import AWSCostEntryLineItemSummaryByEC2Compute
 from reporting.provider.aws.models import AWSCostSummaryByAccountP
 from reporting.provider.aws.models import AWSCostSummaryByRegionP
 from reporting.provider.aws.models import AWSCostSummaryByServiceP
@@ -29,7 +30,6 @@
 from reporting.provider.aws.models import AWSStorageSummaryByAccountP
 from reporting.provider.aws.models import AWSStorageSummaryP
 
-
 CSV_FIELD_MAP = {"account": "id", "account_alias": "alias"}
 
 
@@ -69,6 +69,9 @@ def __init__(self, provider, report_type, schema_name, cost_type, markup_cost="m
                     "org_unit_id": {"field": "organizational_unit__org_unit_path", "operation": "icontains"},
                     "org_unit_single_level": {"field": "organizational_unit__org_unit_id", "operation": "icontains"},
                     "instance_type": {"field": "instance_type", "operation": "icontains"},
+                    "operating_system": {"field": "operating_system", "operation": "icontains"},
+                    "instance_name": {"field": "instance_name", "operation": "icontains"},
+                    "resource_id": {"field": "resource_id", "operation": "icontains"},
                 },
                 "group_by_options": ["service", "account", "region", "az", "product_family", "org_unit_id"],
                 "tag_column": "tags",
@@ -270,6 +273,116 @@ def __init__(self, provider, report_type, schema_name, cost_type, markup_cost="m
                         "sum_columns": ["usage", "cost_total", "infra_total", "sup_total"],
                         "default_ordering": {"usage": "desc"},
                     },
+                    "ec2_compute": {
+                        "aggregates": {
+                            "infra_raw": Sum(
+                                Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "infra_usage": Sum(Value(0, output_field=DecimalField())),
+                            "infra_markup": Sum(
+                                Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "infra_total": Sum(
+                                (
+                                    Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                    + Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                )
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "sup_raw": Sum(Value(0, output_field=DecimalField())),
+                            "sup_usage": Sum(Value(0, output_field=DecimalField())),
+                            "sup_markup": Sum(Value(0, output_field=DecimalField())),
+                            "sup_total": Sum(Value(0, output_field=DecimalField())),
+                            "cost_total": Sum(
+                                (
+                                    Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                    + Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                )
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "cost_raw": Sum(
+                                Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "cost_usage": Sum(Value(0, output_field=DecimalField())),
+                            "cost_markup": Sum(
+                                Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "usage": Sum("usage_amount"),
+                        },
+                        "aggregate_key": "usage_amount",
+                        "annotations": {
+                            "infra_raw": Sum(
+                                Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "infra_usage": Value(0, output_field=DecimalField()),
+                            "infra_markup": Sum(
+                                Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "infra_total": Sum(
+                                (
+                                    Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                    + Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                )
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "sup_raw": Value(0, output_field=DecimalField()),
+                            "sup_usage": Value(0, output_field=DecimalField()),
+                            "sup_markup": Value(0, output_field=DecimalField()),
+                            "sup_total": Value(0, output_field=DecimalField()),
+                            "cost_raw": Sum(
+                                Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "cost_usage": Value(0, output_field=DecimalField()),
+                            "cost_markup": Sum(
+                                Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            "cost_total": Sum(
+                                (
+                                    Coalesce(F(self.cost_type), Value(0, output_field=DecimalField()))
+                                    + Coalesce(F(self.markup_cost), Value(0, output_field=DecimalField()))
+                                )
+                                * Coalesce("exchange_rate", Value(1, output_field=DecimalField()))
+                            ),
+                            # the `currency_annotation` is inserted by the `annotations` property of the query-handler
+                            "cost_units": Coalesce("currency_annotation", Value("USD", output_field=CharField())),
+                            "usage": Sum("usage_amount"),
+                            "usage_units": Coalesce(Max("unit"), Value("Hrs")),
+                            "source_uuid": ArrayAgg(
+                                F("source_uuid"), filter=Q(source_uuid__isnull=False), distinct=True
+                            ),
+                            "account_alias": Max("account_alias"),
+                            "account": Max("usage_account_id"),
+                            "instance_name": Max("instance_name"),
+                            "instance_type": Max("instance_type"),
+                            "operating_system": Max("operating_system"),
+                            "region": Max("region"),
+                            "vcpu": Max("vcpu"),
+                            "memory": Max("memory"),
+                            "tags": ArrayAgg(F("tags")),
+                        },
+                        "filter": [{}],
+                        "group_by": ["resource_id"],
+                        "cost_units_key": "currency_code",
+                        "cost_units_fallback": "USD",
+                        "usage_units_key": "unit",
+                        "usage_units_fallback": "Hrs",
+                        "sum_columns": ["usage", "cost_total", "infra_total", "sup_total"],
+                        "default_ordering": {"resource_id": "desc"},
+                        "tables": {"query": AWSCostEntryLineItemSummaryByEC2Compute},
+                        "default_time_period": {
+                            "time_scope_value": "-1",
+                            "time_scope_units": "month",
+                            "resolution": "monthly",
+                        },
+                    },
                     "storage": {
                         "aggregates": {
                             "infra_total": Sum(
@@ -446,6 +559,9 @@ def __init__(self, provider, report_type, schema_name, cost_type, markup_cost="m
                 ("account", "org_unit_id"): AWSComputeSummaryByAccountP,
                 ("org_unit_id",): AWSComputeSummaryByAccountP,
             },
+            "ec2_compute": {
+                "default": AWSCostEntryLineItemSummaryByEC2Compute,
+            },
             "storage": {
                 "default": AWSStorageSummaryP,
                 ("account",): AWSStorageSummaryByAccountP,

koku/api/report/aws/query_handler.py

@@ -318,8 +318,11 @@ def _format_query_response(self):
             (Dict): Dictionary response of query params, data, and total
 
         """
-        output = self._initialize_response_output(self.parameters)
 
+        if self._report_type == "ec2_compute":
+            self._format_ec2_response()
+
+        output = self._initialize_response_output(self.parameters)
         output["data"] = self.query_data
         output["total"] = self.query_sum
 
@@ -556,3 +559,36 @@ def _get_sub_org_units(self, org_unit_list):
         except Exception as e:
             LOG.error(f"Error getting sub org units: \n{e}")
             return []
+
+    def _format_ec2_response(self):
+        """
+        Format EC2 response data tansforming tags to the desired UI format.
+
+        Example transformation:
+
+        Input:
+        "tags": [
+            {"Map":"c2"},
+            {"Name":"instance_name_3"},
+        ]
+
+
+        Output:
+        "tags": [
+            {
+                "key": "Map",
+                "values": ["c2"]
+            },
+            {
+                "key": "Name",
+                "values": ["instance_name_3"]
+            },
+        ]
+        """
+
+        for item in self.query_data:
+            for resource in item["resource_ids"]:
+                resource_values = resource["values"][0]
+                resource_values["tags"] = [
+                    {"key": key, "values": [value]} for tag in resource_values["tags"] for key, value in tag.items()
+                ]