Address comments

Author: vishesh92

ui/src/components/view/SearchFilter.vue

@@ -58,7 +58,6 @@ export default {
   emits: ['close'],
   data () {
     return {
-      alertTypes: {},
       searchFilter: {
         key: this.filterKey,
         value: this.filterKey
@@ -192,92 +191,55 @@ export default {
       }
 
       if (key.includes('zoneid')) {
-        formattedValue = await this.getZone(value)
+        formattedValue = await this.getResourceName('listZones', 'listzonesresponse', 'zone', value)
       }
 
       if (key.includes('domainid')) {
-        formattedValue = await this.getDomain(value)
+        formattedValue = await this.getResourceName('listDomains', 'listdomainsresponse', 'domain', value)
       }
 
       if (key.includes('account')) {
-        formattedValue = await this.getAccount(value)
+        formattedValue = await this.getResourceName('listAccounts', 'listaccountsresponse', 'account', value)
       }
 
       if (key.includes('hypervisor')) {
         formattedValue = await this.getHypervisor(value)
       }
 
       if (key.includes('imagestoreid')) {
-        formattedValue = await this.getImageStore(value)
+        formattedValue = await this.getResourceName('listImageStores', 'listimagestoresresponse', 'imagestore', value)
       }
 
       if (key.includes('storageid')) {
-        formattedValue = await this.getStoragePool(value)
+        formattedValue = await this.getResourceName('listStoragePools', 'liststoragepoolsresponse', 'storagepool', value)
       }
 
       if (key.includes('podid')) {
-        formattedValue = await this.getPod(value)
+        formattedValue = await this.getResourceName('listPods', 'listpodsresponse', 'pod', value)
       }
 
       if (key.includes('clusterid')) {
-        formattedValue = await this.getCluster(value)
+        formattedValue = await this.getResourceName('listClusters', 'listclustersresponse', 'cluster', value)
       }
 
       if (key.includes('groupid')) {
-        formattedValue = await this.getInstanceGroup(value)
+        formattedValue = await this.getResourceName('listInstanceGroups', 'listinstancegroupsresponse', 'instancegroup', value)
       }
 
       if (key.includes('managementserverid')) {
-        formattedValue = await this.getManagementServer(value)
+        formattedValue = await this.getResourceName('listManagementServers', 'listmanagementserversresponse', 'managementserver', value)
       }
 
       if (key.includes('serviceofferingid')) {
-        formattedValue = await this.getServiceOffering(value)
+        formattedValue = await this.getResourceName('listServiceOfferings', 'listserviceofferingsresponse', 'serviceoffering', value)
       }
 
       if (key.includes('diskofferingid')) {
-        formattedValue = await this.getDiskOffering(value)
+        formattedValue = await this.getResourceName('listDiskOfferings', 'listdiskofferingsresponse', 'diskoffering', value)
       }
 
       return formattedValue
     },
-    getZone (zoneId) {
-      return new Promise((resolve) => {
-        api('listZones', { showicon: true, id: zoneId }).then(json => {
-          if (json?.listzonesresponse?.zone) {
-            resolve(json.listzonesresponse.zone[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getDomain (domainId) {
-      return new Promise((resolve) => {
-        api('listDomains', { listAll: true, showicon: true, id: domainId }).then(json => {
-          if (json?.listdomainsresponse?.domain) {
-            resolve(json.listdomainsresponse.domain[0].path)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getAccount (accountId) {
-      return new Promise((resolve) => {
-        if (!this.$isValidUuid(accountId)) {
-          resolve(accountId)
-        }
-        const params = { listAll: true, isrecursive: false, showicon: true, id: accountId }
-        api('listAccounts', params).then(json => {
-          if (json?.listaccountsresponse?.account) {
-            resolve(json.listaccountsresponse.account[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
     getHypervisor (value) {
       return new Promise((resolve) => {
         api('listHypervisors').then(json => {
@@ -294,139 +256,52 @@ export default {
         })
       })
     },
-    getImageStore (storeId) {
-      return new Promise((resolve) => {
-        api('listImageStores', { listAll: true, showicon: true, id: storeId }).then(json => {
-          if (json?.listimagestoresresponse?.imagestore) {
-            resolve(json.listimagestoresresponse.imagestore[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getStoragePool (poolId) {
-      return new Promise((resolve) => {
-        api('listStoragePools', { listAll: true, showicon: true, id: poolId }).then(json => {
-          if (json?.liststoragepoolsresponse?.storagepool) {
-            resolve(json.liststoragepoolsresponse.storagepool[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getPod (podId) {
-      return new Promise((resolve) => {
-        api('listPods', { id: podId }).then(json => {
-          if (json?.listpodsresponse?.pod) {
-            resolve(json.listpodsresponse.pod[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getCluster (clusterId) {
+    getResourceName (apiName, responseKey1, responseKey2, id) {
       return new Promise((resolve) => {
-        api('listClusters', { id: clusterId }).then(json => {
-          if (json?.listclustersresponse?.cluster) {
-            resolve(json.listclustersresponse.cluster[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getInstanceGroup (groupId) {
-      return new Promise((resolve) => {
-        api('listInstanceGroups', { listAll: true, id: groupId }).then(json => {
-          if (json?.listinstancegroupsresponse?.instancegroup) {
-            resolve(json.listinstancegroupsresponse.instancegroup[0].name)
-          }
-        }).catch(() => {
-          resolve(null)
-        })
-      })
-    },
-    getServiceOffering (offeringId) {
-      return new Promise((resolve) => {
-        api('listServiceOfferings', { listAll: true, id: offeringId }).then(json => {
-          if (json?.listserviceofferingsresponse?.serviceoffering) {
-            resolve(json.listserviceofferingsresponse.serviceoffering[0].name)
+        if (!this.$isValidUuid(id)) {
+          return resolve(null)
+        }
+        api(apiName, { listAll: true, id: id }).then(json => {
+          if (json[responseKey1] && json[responseKey1][responseKey2]) {
+            resolve(json[responseKey1][responseKey2][0].name)
           }
         }).catch(() => {
           resolve(null)
         })
       })
     },
-    getDiskOffering (offeringId) {
+    getAlertType (type) {
       return new Promise((resolve) => {
-        api('listDiskOfferings', { listAll: true, id: offeringId }).then(json => {
-          if (json?.listdiskofferingsresponse?.diskoffering) {
-            resolve(json.listdiskofferingsresponse.diskoffering[0].name)
+        api('listAlertTypes').then(json => {
+          const alertTypes = {}
+          for (const key in json.listalerttypesresponse.alerttype) {
+            const alerttype = json.listalerttypesresponse.alerttype[key]
+            alertTypes[alerttype.id] = alerttype.name
           }
+          resolve(alertTypes[type])
         }).catch(() => {
           resolve(null)
         })
       })
     },
-    getAlertType (type) {
-      if (this.alertTypes.length > 0) {
-        return new Promise((resolve) => {
-          resolve(this.alertTypes[type])
-        })
-      } else {
-        return new Promise((resolve) => {
-          api('listAlertTypes').then(json => {
-            const alertTypes = {}
-            for (const key in json.listalerttypesresponse.alerttype) {
-              const alerttype = json.listalerttypesresponse.alerttype[key]
-              alertTypes[alerttype.id] = alerttype.name
-            }
-            this.alertTypes = alertTypes
-            resolve(alertTypes[type])
-          }).catch(() => {
-            resolve(null)
-          })
-        })
-      }
-    },
     getAffinityGroupType (type) {
-      if (this.alertTypes.length > 0) {
-        return new Promise((resolve) => {
-          resolve(this.alertTypes[type])
-        })
-      } else {
-        return new Promise((resolve) => {
-          api('listAffinityGroupTypes').then(json => {
-            const alertTypes = {}
-            for (const key in json.listaffinitygrouptypesresponse.affinityGroupType) {
-              const affinityGroupType = json.listaffinitygrouptypesresponse.affinityGroupType[key]
-              if (affinityGroupType.type === 'host anti-affinity') {
-                alertTypes[affinityGroupType.type] = 'host anti-affinity (Strict)'
-              } else if (affinityGroupType.type === 'host affinity') {
-                alertTypes[affinityGroupType.type] = 'host affinity (Strict)'
-              } else if (affinityGroupType.type === 'non-strict host anti-affinity') {
-                alertTypes[affinityGroupType.type] = 'host anti-affinity (Non-Strict)'
-              } else if (affinityGroupType.type === 'non-strict host affinity') {
-                alertTypes[affinityGroupType.type] = 'host affinity (Non-Strict)'
-              }
-            }
-            this.alertTypes = alertTypes
-            resolve(alertTypes[type])
-          }).catch(() => {
-            resolve(null)
-          })
-        })
-      }
-    },
-    getManagementServer (msId) {
       return new Promise((resolve) => {
-        api('listManagementServers', { listAll: true, id: msId }).then(json => {
-          if (json?.listmanagementserversresponse?.managementserver) {
-            resolve(json.listmanagementserversresponse.managementserver[0].name)
+        api('listAffinityGroupTypes').then(json => {
+          const alertTypes = {}
+          for (const key in json.listaffinitygrouptypesresponse.affinityGroupType) {
+            const affinityGroupType = json.listaffinitygrouptypesresponse.affinityGroupType[key]
+            if (affinityGroupType.type === 'host anti-affinity') {
+              alertTypes[affinityGroupType.type] = 'host anti-affinity (Strict)'
+            } else if (affinityGroupType.type === 'host affinity') {
+              alertTypes[affinityGroupType.type] = 'host affinity (Strict)'
+            } else if (affinityGroupType.type === 'non-strict host anti-affinity') {
+              alertTypes[affinityGroupType.type] = 'host anti-affinity (Non-Strict)'
+            } else if (affinityGroupType.type === 'non-strict host affinity') {
+              alertTypes[affinityGroupType.type] = 'host affinity (Non-Strict)'
+            }
           }
+          this.alertTypes = alertTypes
+          resolve(alertTypes[type])
         }).catch(() => {
           resolve(null)
         })