feat: Extend parser to parse most of resources

visualization_tool/src/components/ControlMenu/Controller.ts

@@ -1,45 +1,62 @@
-import {OutputFile, Resource} from '../../types/resources';
-
-const getResourceData = (
-  resource: Resource,
-  projectId: string,
-  fileName: string
-) => {
-  return {
-    projectId,
-    file: fileName,
-    id: resource.id,
-    name: resource.name,
-    creationTimestamp: resource.creationTimestamp,
-    status: resource?.status || 'READY',
-  };
+import {
+  OutputFile,
+  Resource,
+  ResourceType,
+  availableResourceTypes,
+} from '../../types/resources';
+
+const titleCase = (str: string) => {
+  return str
+    .replace('_', ' ')
+    .split(' ')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
 };
 
 const parseData = (data: OutputFile, fileName: string) => {
   const resources = [];
   for (const [projectId, projectData] of Object.entries(data.projects)) {
-    const computeInstances = projectData.compute_instances?.map(
-      computeInstance => {
-        return {
-          ...getResourceData(computeInstance, projectId, fileName),
-          type: 'Compute Instance' as const,
-          zone: computeInstance.zone.split('/').at(-1) as string,
-          machineType: computeInstance.machineType.split('/').at(-1) as string,
-        };
+    for (const [resourceType, resourceList] of Object.entries(projectData)) {
+      let type = titleCase(resourceType.slice(0, -1));
+      if (type === 'Dns Policie') type = 'Dns Policy';
+      if (
+        resourceList instanceof Array &&
+        availableResourceTypes.includes(type as ResourceType)
+      ) {
+        const currentResources = [];
+        for (const resource of resourceList) {
+          const resourceData: Record<string, string | number> = {};
+          resourceData['file'] = fileName;
+          resourceData['projectId'] = projectId;
+
+          for (const [key, value] of Object.entries(resource)) {
+            switch (typeof value) {
+              case 'string':
+                // if this attribute is a link, get the last part of the link
+                if (value.split('/').length > 1) {
+                  resourceData[key] = value.split('/').at(-1) || 'unknown';
+                } else {
+                  resourceData[key] = value;
+                }
+                break;
+              case 'number':
+                resourceData[key] = value;
+                break;
+              default:
+                break;
+            }
+          }
+
+          resourceData['name'] = resourceData['name'] || 'unknown';
+          resourceData['status'] = resourceData['status'] || 'READY';
+          resourceData['type'] = type;
+
+          currentResources.push(resourceData as Resource);
+        }
+
+        resources.push(...currentResources);
       }
-    );
-    resources.push(...computeInstances);
-
-    const computeDisks = projectData.compute_disks.map(computeDisk => {
-      return {
-        ...getResourceData(computeDisk, projectId, fileName),
-        type: 'Compute Disk' as const,
-        storageType: computeDisk.type.split('/').at(-1) as string,
-        sizeGb: computeDisk.sizeGb,
-      };
-    });
-
-    resources.push(...computeDisks);
+    }
   }
 
   return resources;

visualization_tool/src/components/ResourcesList/ResourcesList.css

@@ -35,6 +35,11 @@
   font-family: Inter;
   font-size: 18px;
   margin-bottom: 5px;
+
+  display: -webkit-box;
+  -webkit-line-clamp: 1;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
 }
 
 .resource-type {

visualization_tool/src/components/ResourcesList/utils.ts

@@ -1,15 +1,28 @@
 import {Resource} from '../../types/resources';
 import ComputeInstance from '../../assets/resources/Compute Instance.png';
 import ComputeDisk from '../../assets/resources/Compute Disk.png';
+import ManagedZone from '../../assets/resources/Managed Zone.png';
+import SQLInstance from '../../assets/resources/SQL Instance.png';
+import CloudFunction from '../../assets/resources/Cloud Function.png';
+import defaultLogo from '../../assets/resources/resource.png';
 
 const typeToImage = (resource: Resource) => {
   switch (resource.type) {
     case 'Compute Instance':
+    case 'Compute Image':
+    case 'Machine Image':
+    case 'Compute Snapshot':
       return ComputeInstance;
     case 'Compute Disk':
       return ComputeDisk;
+    case 'Managed Zone':
+      return ManagedZone;
+    case 'SQL Instance':
+      return SQLInstance;
+    case 'Cloud Function':
+      return CloudFunction;
     default:
-      return '';
+      return defaultLogo;
   }
 };
 

visualization_tool/src/types/resources.ts

@@ -1,5 +1,29 @@
-type ResourceType = 'Compute Instance' | 'Compute Disk';
-type ResourceStatus = 'READY' | 'RUNNING' | 'STOPPED' | 'DELETED';
+type ResourceType =
+  | 'Compute Instance'
+  | 'Compute Disk'
+  | 'Compute Image'
+  | 'Machine Image'
+  | 'Compute Snapshot'
+  | 'Managed Zone'
+  | 'SQL Instance'
+  | 'Cloud Function'
+  | 'Dns Policy'
+  | 'Pubsub Sub';
+
+const availableResourceTypes: ResourceType[] = [
+  'Compute Instance',
+  'Compute Disk',
+  'Compute Image',
+  'Machine Image',
+  'Compute Snapshot',
+  'Managed Zone',
+  'SQL Instance',
+  'Cloud Function',
+  'Dns Policy',
+  'Pubsub Sub',
+];
+
+type ResourceStatus = 'READY' | 'ACTIVE' | 'RUNNING' | 'STOPPED' | 'DELETED';
 
 type Resource = {
   projectId: string;
@@ -11,25 +35,8 @@ type Resource = {
   status: ResourceStatus;
 };
 
-type ComputeInstance = Resource & {
-  type: 'Compute Instance';
-  zone: string;
-  machineType: string;
-};
-
-type ComputeDisk = Resource & {
-  type: 'Compute Disk';
-  storageType: string;
-  sizeGb: number;
-};
-
 type Project = {
-  project_info: {
-    projectNumber: string;
-    projectId: string;
-  };
-  compute_instances: ComputeInstance[];
-  compute_disks: ComputeDisk[];
+  [key: string]: Resource[];
 };
 
 type OutputFile = {
@@ -38,12 +45,6 @@ type OutputFile = {
   };
 };
 
-export type {
-  ResourceType,
-  ResourceStatus,
-  Resource,
-  ComputeInstance,
-  ComputeDisk,
-  Project,
-  OutputFile,
-};
+export type {ResourceType, ResourceStatus, Resource, Project, OutputFile};
+
+export {availableResourceTypes};