add gateway products to report

src/services/keystone/access-request.ts

@@ -22,6 +22,7 @@ export async function getAccessRequestsByNamespace(
         requestor {
           name
           username
+          providerUsername
         }
         application {
           name

src/services/keystone/product-environment.ts

@@ -180,11 +180,20 @@ export async function lookupEnvironmentsByNS(
                         appId
                         name
                         flow
+                        active
                         additionalDetailsToRequest
                         approval
+                        services {
+                          name
+                        }
                         product {
                           id
                           name
+                          dataset {
+                            name
+                            title
+                            isInCatalog
+                          }
                         }
                         legal {
                           reference

src/services/report/data/consumer-requests.ts

@@ -5,7 +5,7 @@ import { ReportOfNamespaces } from './namespaces';
 import { ReportOfGatewayMetrics } from './gateway-metrics';
 import { getAccessRequestsByNamespace } from '../../keystone';
 
-interface ReportOfConsumerRequest {
+export interface ReportOfConsumerRequest {
   namespace: string;
   displayName?: string;
   prod_name: string;
@@ -44,7 +44,7 @@ export async function getConsumerRequests(
           prod_env_flow: req.productEnvironment?.flow,
           app_name: req.application.name,
           app_id: req.application.appId,
-          requestor: req.requestor.name,
+          requestor: req.requestor.name ?? req.requestor.providerUsername,
           req_created: req.createdAt,
           req_reviewer: '',
           req_result: req.isComplete

src/services/report/data/features/api_directory.ts

@@ -1,10 +1,18 @@
 import { GatewayService } from '../../../../services/keystone/types';
 import { ReportOfNamespaces } from '../namespaces';
+import { ReportOfProducts } from '../products';
 
-export function has_feature_api_directory(
+export function has_feature_api_directory_for_product(
+  ns: ReportOfNamespaces,
+  product: ReportOfProducts
+): Boolean {
+  return product.prod_env_active === 'Y';
+}
+
+export function has_feature_api_directory_for_service(
   ns: ReportOfNamespaces,
   service: GatewayService,
   routeName: string
 ): Boolean {
-  return Boolean(service?.environment?.active);
+  return Boolean(service.environment?.active);
 }

src/services/report/data/features/consumer_mgmt.ts

@@ -1,14 +1,13 @@
 import { GatewayService } from '../../../keystone/types';
 import { ReportOfNamespaces } from '../namespaces';
+import { ReportOfProducts } from '../products';
 
 export function has_feature_consumer_mgmt(
   ns: ReportOfNamespaces,
-  service: GatewayService,
-  routeName: string
+  product: ReportOfProducts
 ): Boolean {
-  return (
-    ['client-credentials', 'kong-api-key-acl'].indexOf(
-      service.environment?.flow
-    ) >= 0
+  return Boolean(
+    ['client-credentials', 'kong-api-key-acl'].indexOf(product.prod_env_flow) >=
+      0 && product.prod_env_active === 'Y'
   );
 }

src/services/report/data/features/dataset_in_catalog.ts

@@ -0,0 +1,10 @@
+import { GatewayService } from '../../../keystone/types';
+import { ReportOfNamespaces } from '../namespaces';
+import { ReportOfProducts } from '../products';
+
+export function has_feature_dataset_in_catalog(
+  ns: ReportOfNamespaces,
+  product: ReportOfProducts
+): Boolean {
+  return product.dataset_in_catalog;
+}

src/services/report/data/features/has_gateway_mgmt.ts

@@ -0,0 +1,12 @@
+import { GatewayService } from '../../../keystone/types';
+import { ReportOfNamespaces } from '../namespaces';
+
+// If there is a Route, then can consider gateway
+// management being used
+export function has_gateway_mgmt(
+  ns: ReportOfNamespaces,
+  service: GatewayService,
+  routeName: string
+): Boolean {
+  return Boolean(true);
+}

src/services/report/data/features/index.ts

@@ -3,20 +3,36 @@ import {
   GatewayService,
 } from '../../../../services/keystone/types';
 import { ReportOfNamespaces } from '../namespaces';
-import { has_feature_api_directory } from './api_directory';
+import {
+  has_feature_api_directory_for_product,
+  has_feature_api_directory_for_service,
+} from './api_directory';
 import { has_feature_consumer_mgmt } from './consumer_mgmt';
+import { has_feature_dataset_in_catalog } from './dataset_in_catalog';
+import { has_gateway_mgmt } from './has_gateway_mgmt';
 import { is_production } from './production';
 import { has_feature_protected } from './protected';
+import { has_feature_protected_externally } from './protected_exterrnally';
 import { has_feature_shared_idp } from './shared_idp';
 import { has_feature_two_tiered_access } from './two_tiered_access';
 
+export const ProductFeatureList: { [key: string]: Function } = {
+  consumer_mgmt: has_feature_consumer_mgmt,
+  protected_externally: has_feature_protected_externally,
+  dataset_in_catalog: has_feature_dataset_in_catalog,
+  api_directory: has_feature_api_directory_for_product,
+};
+
 export const FeatureList: { [key: string]: Function } = {
-  api_directory: has_feature_api_directory,
+  api_directory: has_feature_api_directory_for_service, // evaluated at a Gateway level
   shared_idp: has_feature_shared_idp,
-  consumer_mgmt: has_feature_consumer_mgmt,
+  gateway_mgmt: has_gateway_mgmt,
+  consumer_mgmt: undefined, // evaluated at a Gateway level
   protected: has_feature_protected,
   two_tiered_access: has_feature_two_tiered_access,
   production: is_production,
+  protected_externally: undefined, // evaluated at a Gateway level
+  dataset_in_catalog: undefined, // evaluated at a Gateway level
 };
 
 export function getFeatures(
@@ -27,7 +43,7 @@ export function getFeatures(
   const service = findService(services, routeName);
   const features: string[] = [];
   Object.entries(FeatureList).forEach((func) => {
-    if (func[1](ns, service, routeName)) {
+    if (func[1] && func[1](ns, service, routeName)) {
       features.push(func[0]);
     }
   });

src/services/report/data/namespaces.ts

@@ -12,6 +12,8 @@ import {
 import { GWAService } from '../../gwaapi';
 import { ReportOfGatewayMetrics } from './gateway-metrics';
 import { ReportOfProducts } from './products';
+import { ReportOfConsumerRequest } from './consumer-requests';
+import { lookupUsersByNamespace } from '@/services/keystone';
 
 export interface ReportOfNamespaces {
   resource_id: string;
@@ -23,7 +25,9 @@ export interface ReportOfNamespaces {
   org?: string;
   orgUnit?: string;
   decommissioned?: string;
-  features?: string[];
+  consumers?: number;
+  day_30_total?: number;
+  features?: { [feature: string]: string };
 }
 
 /*
@@ -87,18 +91,29 @@ export function rollupFeatures(
   products: ReportOfProducts[]
 ) {
   namespaces.forEach((ns) => {
-    ns.features = [];
+    ns.features = {};
+    ns.day_30_total = 0;
     gatewayMetrics
       .filter((gw) => gw.namespace == ns.name)
       .forEach((gw) => {
-        ns.features.push.apply(ns.features, gw.features);
+        gw.features.forEach((feat) => (ns.features[feat] = 'Y'));
+        ns.day_30_total = ns.day_30_total + gw.day_30_total;
       });
     products
       .filter((gw) => gw.namespace == ns.name)
       .forEach((gw) => {
-        ns.features.push.apply(ns.features, gw.features);
+        gw.features.forEach((feat) => (ns.features[feat] = 'Y'));
       });
+  });
+}
 
-    ns.features = dedup(ns.features).sort();
+export function rollupConsumers(
+  namespaces: ReportOfNamespaces[],
+  requests: ReportOfConsumerRequest[]
+) {
+  namespaces.forEach((ns) => {
+    ns.consumers = requests.filter(
+      (req) => req.namespace === ns.name && req.req_result === 'Approved'
+    ).length;
   });
 }

src/services/report/data/products.ts

@@ -3,19 +3,25 @@ import { Keystone } from '@keystonejs/keystone';
 import { ReportOfNamespaces } from './namespaces';
 import { getServiceMetrics, calculateStats } from '../../keystone';
 import { dateRange } from '../../utils';
-import { getFeatures, getPlugins } from './features';
+import { getFeatures, getPlugins, ProductFeatureList } from './features';
 import { lookupEnvironmentsByNS } from '../../../services/keystone/product-environment';
 import { Environment } from '../../../services/keystone/types';
 import { has_feature_protected_externally } from './features/protected_exterrnally';
+import { has_feature_dataset_in_catalog } from './features/dataset_in_catalog';
 
 export interface ReportOfProducts {
   namespace: string;
   display_name?: string;
   prod_name?: string;
-  prod_env_active: string;
+  prod_env_active: 'Y' | 'N';
+  prod_env_approval: 'Y' | 'N';
   prod_env_name?: string;
   prod_env_flow?: string;
   prod_env_app_id?: string;
+  dataset_name?: string;
+  dataset_title?: string;
+  dataset_in_catalog: boolean;
+  service_names?: string[];
   features: string[];
 }
 
@@ -35,16 +41,19 @@ export async function getProducts(
           prod_env_app_id: env.appId,
           prod_env_flow: env.flow,
           prod_env_active: env.active ? 'Y' : 'N',
+          prod_env_approval: env.approval ? 'Y' : 'N',
+          dataset_name: env.product?.dataset?.name,
+          dataset_title: env.product?.dataset?.title,
+          dataset_in_catalog: env.product?.dataset?.isInCatalog,
+          service_names: env.services.map((s) => s.name),
           features: [],
         } as ReportOfProducts;
 
-        const featureProtectedExternally = has_feature_protected_externally(
-          ns,
-          product
-        );
-        if (featureProtectedExternally) {
-          product.features.push('protected_externally');
-        }
+        Object.entries(ProductFeatureList).forEach((func) => {
+          if (func[1] && func[1](ns, product)) {
+            product.features.push(func[0]);
+          }
+        });
         return product;
       });
     }