fix: list item export recode

cmd/climc/shell/users.go

@@ -40,7 +40,11 @@ func init() {
 		if err != nil {
 			return err
 		}
-		printList(result, modules.UsersV3.GetColumns(s))
+		if len(args.ExportFile) > 0 {
+			exportList(result, args.ExportFile, args.ExportKeys, args.ExportTexts, modules.UsersV3.GetColumns(s))
+		} else {
+			printList(result, modules.UsersV3.GetColumns(s))
+		}
 		return nil
 	})
 

pkg/cloudcommon/db/db_dispatcher.go

@@ -372,16 +372,21 @@ func Query2List(manager IModelManager, ctx context.Context, userCred mcclient.To
 		}
 
 		if exportKeys != nil {
-			extraData := jsonutils.NewDict()
-			RowMap, err := q.Row2Map(rows)
+			rowMap, err := q.Row2Map(rows)
 			if err != nil {
 				return nil, err
 			}
-			extraKeys := manager.GetExportExtraKeys(ctx, exportKeys, RowMap)
+			extraData := jsonutils.NewDict()
+			for k, v := range rowMap {
+				if len(v) > 0 {
+					extraData.Add(jsonutils.NewString(v), k)
+				}
+			}
+			extraKeys := manager.GetExportExtraKeys(ctx, exportKeys, rowMap)
 			if extraKeys != nil {
 				extraData.Update(extraKeys)
 			}
-			err = q.RowMap2Struct(RowMap, item)
+			err = q.RowMap2Struct(rowMap, item)
 			if err != nil {
 				return nil, err
 			}

pkg/cloudcommon/db/domain.go

@@ -178,3 +178,12 @@ func ValidateDomainizedResourceInput(ctx context.Context, input apis.DomainizedR
 	input.ProjectDomain = domain.GetId()
 	return domain, input, nil
 }
+
+func (manager *SDomainizedResourceBaseManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	if keys.Contains("project_domain") {
+		domainsQ := DefaultDomainQuery().SubQuery()
+		q = q.LeftJoin(domainsQ, sqlchemy.Equals(q.Field("domain_id"), domainsQ.Field("id")))
+		q = q.AppendField(domainsQ.Field("name", "project_domain"))
+	}
+	return q, nil
+}

pkg/cloudcommon/db/domainresource.go

@@ -307,3 +307,15 @@ func (model *SDomainLevelResourceBase) AllowGetDetailsChangeOwnerCandidateDomain
 func (model *SDomainLevelResourceBase) GetDetailsChangeOwnerCandidateDomains(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject) (apis.ChangeOwnerCandidateDomainsOutput, error) {
 	return IOwnerResourceBaseModelGetChangeOwnerCandidateDomains(model.GetIDomainLevelModel())
 }
+
+func (manager *SDomainLevelResourceBaseManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	q, err = manager.SDomainizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SDomainizedResourceBaseManager.ListItemExportKeys")
+	}
+	return q, nil
+}

pkg/cloudcommon/db/project.go

@@ -211,3 +211,16 @@ func ValidateProjectizedResourceInput(ctx context.Context, input apis.Projectize
 	input.Project = tenant.GetId()
 	return tenant, input, nil
 }
+
+func (manager *SProjectizedResourceBaseManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	q, err := manager.SDomainizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SDomainizedResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.Contains("tenant") {
+		projectsQ := DefaultProjectQuery().SubQuery()
+		q = q.LeftJoin(projectsQ, sqlchemy.Equals(q.Field("tenant_id"), projectsQ.Field("id")))
+		q = q.AppendField(projectsQ.Field("name", "tenant"))
+	}
+	return q, nil
+}

pkg/cloudcommon/db/tenantcache.go

@@ -41,6 +41,8 @@ var (
 	DefaultProjectFetcher  func(ctx context.Context, id string) (*STenant, error)
 	DefaultDomainFetcher   func(ctx context.Context, id string) (*STenant, error)
 	DefaultProjectsFetcher func(ctx context.Context, idList []string, isDomain bool) map[string]STenant
+	DefaultDomainQuery     func(fields ...string) *sqlchemy.SQuery
+	DefaultProjectQuery    func(fields ...string) *sqlchemy.SQuery
 )
 
 type STenantCacheManager struct {
@@ -74,6 +76,8 @@ func init() {
 	DefaultProjectFetcher = TenantCacheManager.FetchTenantByIdOrName
 	DefaultDomainFetcher = TenantCacheManager.FetchDomainByIdOrName
 	DefaultProjectsFetcher = fetchProjects
+	DefaultDomainQuery = TenantCacheManager.GetDomainQuery
+	DefaultProjectQuery = TenantCacheManager.GetTenantQuery
 }
 
 func RegistUserCredCacheUpdater() {

pkg/cloudcommon/db/virtualresource.go

@@ -538,3 +538,15 @@ func (model *SVirtualResourceBase) AllowGetDetailsChangeOwnerCandidateDomains(ct
 func (model *SVirtualResourceBase) GetDetailsChangeOwnerCandidateDomains(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject) (apis.ChangeOwnerCandidateDomainsOutput, error) {
 	return IOwnerResourceBaseModelGetChangeOwnerCandidateDomains(model.GetIVirtualModel())
 }
+
+func (manager *SVirtualResourceBaseManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	q, err = manager.SProjectizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SProjectizedResourceBaseManager.ListItemExportKeys")
+	}
+	return q, nil
+}

pkg/compute/models/baremetalagents.go

@@ -333,3 +333,21 @@ func (manager *SBaremetalagentManager) OrderByExtraFields(
 	}
 	return q, nil
 }
+
+func (manager *SBaremetalagentManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/buckets.go

@@ -1399,3 +1399,27 @@ func (bucket *SBucket) processObjectsActionInput(input api.BucketObjectsActionIn
 	}
 	return iBucket, objects, nil
 }
+
+func (manager *SBucketManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SSharableVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SSharableVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/cloudprovider_quotas.go

@@ -284,3 +284,32 @@ func (manager *SCloudproviderQuotaManager) newFromCloudQuota(ctx context.Context
 
 	return manager.TableSpec().Insert(&quota)
 }
+
+func (manager *SCloudproviderQuotaManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/cloudproviderregions.go

@@ -591,3 +591,32 @@ func (cpr *SCloudproviderregion) removeCapabilities(ctx context.Context, userCre
 func (cpr *SCloudproviderregion) getCapabilities() ([]string, error) {
 	return CloudproviderCapabilityManager.getRegionCapabilities(cpr.CloudproviderId, cpr.CloudregionId)
 }
+
+func (manager *SCloudproviderregionManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SJointResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/cloudregionresource.go

@@ -155,3 +155,22 @@ func (manager *SCloudregionResourceBaseManager) GetOrderBySubQuery(
 func (manager *SCloudregionResourceBaseManager) GetOrderByFields(query api.RegionalFilterListInput) []string {
 	return []string{query.OrderByRegion, query.OrderByCity}
 }
+
+func (manager *SCloudregionResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		regionsQ := CloudregionManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(regionsQ, sqlchemy.Equals(q.Field("cloudregion_id"), regionsQ.Field("id")))
+		if keys.Contains("region") {
+			q = q.AppendField(regionsQ.Field("name", "region"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SCloudregionResourceBaseManager) GetExportKeys() []string {
+	return []string{"region"}
+}

pkg/compute/models/dbinstance_accounts.go

@@ -686,3 +686,23 @@ func (self *SDBInstanceAccount) StartDBInstanceAccountDeleteTask(ctx context.Con
 	task.ScheduleRun(nil)
 	return nil
 }
+
+func (manager *SDBInstanceAccountManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SDBInstanceResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SDBInstanceResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDBInstanceResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/dbinstance_backups.go

@@ -546,3 +546,35 @@ func (self *SDBInstanceBackup) GetCloudprovider() *SCloudprovider {
 func (self *SDBInstanceBackup) GetRegion() *SCloudregion {
 	return self.SCloudregionResourceBase.GetRegion()
 }
+
+func (manager *SDBInstanceBackupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny("dbinstance") {
+		q, err = manager.SDBInstanceResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDBInstanceResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/dbinstance_databases.go

@@ -442,3 +442,23 @@ func (self *SDBInstanceDatabase) StartDBInstanceDatabaseDeleteTask(ctx context.C
 	task.ScheduleRun(nil)
 	return nil
 }
+
+func (manager *SDBInstanceDatabaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SDBInstanceResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SDBInstanceResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDBInstanceResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/dbinstance_parameters.go

@@ -244,3 +244,25 @@ func (manager *SDBInstanceParameterManager) FetchCustomizeColumns(
 
 	return rows
 }
+
+func (manager *SDBInstanceParameterManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SDBInstanceResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SDBInstanceResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDBInstanceResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/dbinstance_skus.go

@@ -640,3 +640,24 @@ func SyncRegionDBInstanceSkus(ctx context.Context, userCred mcclient.TokenCreden
 func SyncDBInstanceSkus(ctx context.Context, userCred mcclient.TokenCredential, isStart bool) {
 	SyncRegionDBInstanceSkus(ctx, userCred, "", isStart)
 }
+
+func (manager *SDBInstanceSkuManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SEnabledStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SEnabledStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/dbinstanceresource.go

@@ -236,3 +236,31 @@ func (manager *SDBInstanceResourceBaseManager) FilterByParentId(q *sqlchemy.SQue
 	return q
 }
 */
+
+func (manager *SDBInstanceResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := DBInstanceManager.Query("id", "name", "vpc_id", "manager_id", "cloudregion_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("dbinstance_id"), subq.Field("id")))
+		if keys.Contains("dbinstance") {
+			q = q.AppendField(subq.Field("name", "dbinstance"))
+		}
+		if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SDBInstanceResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"dbinstance"}
+	keys = append(keys, manager.SVpcResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/dbinstances.go

@@ -1620,3 +1620,39 @@ func (dbinstance *SDBInstance) GetIRegion() (cloudprovider.ICloudRegion, error)
 	}
 	return provider.GetIRegionById(region.GetExternalId())
 }
+
+func (manager *SDBInstanceManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/diskresource.go

@@ -224,3 +224,31 @@ func (manager *SDiskResourceBaseManager) GetOrderByFields(query api.DiskFilterLi
 	orders = append(orders, query.OrderByDisk)
 	return orders
 }
+
+func (manager *SDiskResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := DiskManager.Query("id", "name", "storage_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("storage_id"), subq.Field("id")))
+		if keys.Contains("disk") {
+			q = q.AppendField(subq.Field("name", "disk"))
+		}
+		if keys.ContainsAny(manager.SStorageResourceBaseManager.GetExportKeys()...) {
+			var err error
+			q, err = manager.SStorageResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SStorageResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SDiskResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"disk"}
+	keys = append(keys, manager.SStorageResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/disks.go

@@ -2617,3 +2617,23 @@ func (disk *SDisk) PerformUnbindSnapshotpolicy(ctx context.Context, userCred mcc
 	}
 	return nil, nil
 }
+
+func (manager *SDiskManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SStorageResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SStorageResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SStorageResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_accounts.go

@@ -545,3 +545,22 @@ func (manager *SElasticcacheAccountManager) FetchCustomizeColumns(
 
 	return rows
 }
+
+func (manager *SElasticcacheAccountManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SElasticcacheResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SElasticcacheResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SElasticcacheResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_acls.go

@@ -429,3 +429,22 @@ func (manager *SElasticcacheAclManager) FetchCustomizeColumns(
 
 	return rows
 }
+
+func (manager *SElasticcacheAclManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SElasticcacheResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SElasticcacheResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SElasticcacheResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_backups.go

@@ -443,3 +443,22 @@ func (manager *SElasticcacheBackupManager) FetchCustomizeColumns(
 
 	return rows
 }
+
+func (manager *SElasticcacheBackupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SElasticcacheResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SElasticcacheResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SElasticcacheResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_instances.go

@@ -1473,3 +1473,35 @@ func (cache *SElasticcache) GetUsages() []db.IUsage {
 		&usage,
 	}
 }
+
+func (manager *SElasticcacheManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("zone") {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny("network", "wire") {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_parameters.go

@@ -348,3 +348,22 @@ func (manager *SElasticcacheParameterManager) FetchCustomizeColumns(
 
 	return rows
 }
+
+func (manager *SElasticcacheParameterManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SElasticcacheResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SElasticcacheResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SElasticcacheResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/elasticcache_skus.go

@@ -621,3 +621,30 @@ func (manager *SElasticcacheSkuManager) PerformActionSync(ctx context.Context, u
 
 	return nil, nil
 }
+
+func (manager *SElasticcacheSkuManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("zone") {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/elasticcacheresource.go

@@ -267,3 +267,38 @@ func (manager *SElasticcacheResourceBaseManager) FilterByParentId(q *sqlchemy.SQ
 	return q
 }
 */
+
+func (manager *SElasticcacheResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := ElasticcacheManager.Query("id", "name", "vpc_id", "zone_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("elasticcache_id"), subq.Field("id")))
+		if keys.Contains("elasticcache") {
+			q = q.AppendField(subq.Field("name", "elasticcache"))
+		}
+		if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.Contains("zone") {
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SElasticcacheResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"elasticcache"}
+	keys = append(keys, manager.SVpcResourceBaseManager.GetExportKeys()...)
+	keys = append(keys, "zone")
+	return keys
+}

pkg/compute/models/elasticips.go

@@ -1433,22 +1433,24 @@ func (eip *SElasticip) GetUsages() []db.IUsage {
 	}
 }
 
-/*func (manager *SElasticipManager) QueryDistinctExtraField(q *sqlchemy.SQuery, field string) (*sqlchemy.SQuery, error) {
+func (manager *SElasticipManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
 	var err error
-	q, err = manager.SStatusStandaloneResourceBaseManager.QueryDistinctExtraField(q, field)
-	if err == nil {
-		return q, nil
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
 	}
-	switch field {
-	case "account":
-		cloudproviders := CloudproviderManager.Query().SubQuery()
-		cloudaccounts := CloudaccountManager.Query("name", "id").Distinct().SubQuery()
-		q = q.Join(cloudproviders, sqlchemy.Equals(q.Field("manager_id"), cloudproviders.Field("id")))
-		q = q.Join(cloudaccounts, sqlchemy.Equals(cloudproviders.Field("cloudaccount_id"), cloudaccounts.Field("id")))
-		q.GroupBy(cloudaccounts.Field("name"))
-		q.AppendField(cloudaccounts.Field("name", "account"))
-	default:
-		return q, httperrors.NewBadRequestError("unsupport field %s", field)
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
 	}
+
 	return q, nil
-}*/
+}

pkg/compute/models/external_projects.go

@@ -356,3 +356,16 @@ func (manager *SExternalProjectManager) QueryDistinctExtraField(q *sqlchemy.SQue
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SExternalProjectManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	q, err = manager.SProjectizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SProjectizedResourceBaseManager.ListItemExportKeys")
+	}
+	return q, nil
+}

pkg/compute/models/globalvpcresource.go

@@ -133,3 +133,22 @@ func (manager *SGlobalVpcResourceBaseManager) OrderByExtraFields(
 	q = db.OrderByStandaloneResourceName(q, GlobalVpcManager, "globalvpc_id", query.OrderByGlobalvpc)
 	return q, nil
 }
+
+func (manager *SGlobalVpcResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := GlobalVpcManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("globalvpc_id"), subq.Field("id")))
+		if keys.Contains("globalvpc") {
+			q = q.AppendField(subq.Field("name", "globalvpc"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SGlobalVpcResourceBaseManager) GetExportKeys() []string {
+	return []string{"globalvpc"}
+}

pkg/compute/models/groupguests.go

@@ -199,3 +199,24 @@ func (manager *SGroupguestManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGroupguestManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SGroupJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SGroupJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SGuestResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGuestResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGuestResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/groupjoints.go

@@ -149,3 +149,22 @@ func (manager *SGroupJointsManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGroupJointsManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SVirtualJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualJointResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SGroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGroupResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/groupnetworks.go

@@ -178,3 +178,24 @@ func (manager *SGroupnetworkManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGroupnetworkManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SGroupJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SGroupJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SNetworkResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/groupresource.go

@@ -160,3 +160,22 @@ func (manager *SGroupResourceBaseManager) GetOrderBySubQuery(
 func (manager *SGroupResourceBaseManager) GetOrderByFields(query api.GroupFilterListInput) []string {
 	return []string{query.OrderByGroup}
 }
+
+func (manager *SGroupResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := GroupManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("group_id"), subq.Field("id")))
+		if keys.Contains("group") {
+			q = q.AppendField(subq.Field("name", "group"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SGroupResourceBaseManager) GetExportKeys() []string {
+	return []string{"group"}
+}

pkg/compute/models/groups.go

@@ -405,3 +405,22 @@ func (group *SGroup) fetchAllGuests() ([]SGuest, error) {
 	}
 	return guests, nil
 }
+
+func (manager *SGroupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/guest_template.go

@@ -700,3 +700,30 @@ func (gt *SGuestTemplate) Validate(ctx context.Context, userCred mcclient.TokenC
 	}
 	return true, ""
 }
+
+func (manager *SGuestTemplateManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SSharableVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SSharableVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/guestdisks.go

@@ -382,3 +382,24 @@ func (manager *SGuestdiskManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGuestdiskManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SGuestJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SGuestJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SDiskResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SDiskResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDiskResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/guestjoints.go

@@ -164,3 +164,24 @@ func (self *SGuestJointsBase) ValidateUpdateData(
 	}
 	return input, nil
 }
+
+func (manager *SGuestJointsManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualJointResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SGuestResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGuestResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGuestResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/guestnetworks.go

@@ -910,3 +910,24 @@ func (manager *SGuestnetworkManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGuestnetworkManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SGuestJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SGuestJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SNetworkResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/guestresource.go

@@ -223,3 +223,31 @@ func (manager *SGuestResourceBaseManager) GetOrderByFields(query api.ServerFilte
 	orders = append(orders, query.OrderByServer)
 	return orders
 }
+
+func (manager *SGuestResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := GuestManager.Query("id", "name", "host_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("id"), subq.Field("id")))
+		if keys.Contains("guest") {
+			q = q.AppendField(subq.Field("name", "guest"))
+		}
+		if keys.ContainsAny(manager.SHostResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SHostResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SHostResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SGuestResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"guest"}
+	keys = append(keys, manager.SHostResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/guests.go

@@ -1871,47 +1871,13 @@ func (manager *SGuestManager) ListItemExportKeys(ctx context.Context, q *sqlchem
 		q.AppendField(eipsSubQuery.Field("ip_addr", "eip"))
 	}
 
-	if keys.Contains("host") {
-		hostQuery := HostManager.Query("id", "name").GroupBy("id")
-		hostSubQuery := hostQuery.SubQuery()
-		q.LeftJoin(hostSubQuery, sqlchemy.Equals(q.Field("host_id"), hostSubQuery.Field("id")))
-		q.AppendField(hostSubQuery.Field("name", "host"))
+	if keys.ContainsAny(manager.SHostResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SHostResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SHostResourceBaseManager.ListItemExportKeys")
+		}
 	}
 
-	if keys.Contains("zone") {
-		zoneQuery := ZoneManager.Query("id", "name").SubQuery()
-		hostQuery := HostManager.Query("id", "zone_id").GroupBy("id")
-		hostQuery.LeftJoin(zoneQuery, sqlchemy.Equals(hostQuery.Field("zone_id"), zoneQuery.Field("id")))
-		hostQuery.AppendField(zoneQuery.Field("name", "zone"))
-		hostSubQuery := hostQuery.SubQuery()
-		q.LeftJoin(hostSubQuery, sqlchemy.Equals(q.Field("host_id"), hostSubQuery.Field("id")))
-		q.AppendField(hostSubQuery.Field("zone"))
-	}
-
-	// host_id as filter key
-	if keys.Contains("region") {
-		zoneQuery := ZoneManager.Query("id", "cloudregion_id").SubQuery()
-		hostQuery := HostManager.Query("id", "zone_id").GroupBy("id")
-		cloudregionQuery := CloudregionManager.Query("id", "name").SubQuery()
-		hostQuery.LeftJoin(zoneQuery, sqlchemy.Equals(hostQuery.Field("zone_id"), zoneQuery.Field("id"))).
-			LeftJoin(cloudregionQuery, sqlchemy.OR(sqlchemy.Equals(cloudregionQuery.Field("id"),
-				zoneQuery.Field("cloudregion_id")), sqlchemy.Equals(cloudregionQuery.Field("id"), "default")))
-		hostQuery.AppendField(cloudregionQuery.Field("name", "region"))
-		hostSubQuery := hostQuery.SubQuery()
-		q.LeftJoin(hostSubQuery, sqlchemy.Equals(q.Field("host_id"), hostSubQuery.Field("id")))
-		q.AppendField(hostSubQuery.Field("region"))
-	}
-
-	if keys.Contains("manager") {
-		hostQuery := HostManager.Query("id", "manager_id").GroupBy("id")
-		cloudProviderQuery := CloudproviderManager.Query("id", "name").SubQuery()
-		hostQuery.LeftJoin(cloudProviderQuery, sqlchemy.Equals(hostQuery.Field("manager_id"),
-			cloudProviderQuery.Field("id")))
-		hostQuery.AppendField(cloudProviderQuery.Field("name", "manager"))
-		hostSubQuery := hostQuery.SubQuery()
-		q.LeftJoin(hostSubQuery, sqlchemy.Equals(q.Field("host_id"), hostSubQuery.Field("id")))
-		q.AppendField(hostSubQuery.Field("manager"))
-	}
 	return q, nil
 }
 

pkg/compute/models/guestsecgroups.go

@@ -26,6 +26,7 @@ import (
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/util/stringutils2"
 )
 
 type SGuestsecgroupManager struct {
@@ -172,3 +173,24 @@ func (manager *SGuestsecgroupManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SGuestsecgroupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SGuestJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SGuestJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SSecurityGroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SSecurityGroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SSecurityGroupResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/guesttemplate_resource.go

@@ -112,3 +112,22 @@ func (manager *SGuestTemplateResourceBaseManager) QueryDistinctExtraField(q *sql
 	}
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SGuestTemplateResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := GuestTemplateManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("guest_template_id"), subq.Field("id")))
+		if keys.Contains("guest_template") {
+			q = q.AppendField(subq.Field("name", "guest_template"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SGuestTemplateResourceBaseManager) GetExportKeys() []string {
+	return []string{"guest_template"}
+}

pkg/compute/models/hostjoints.go

@@ -149,3 +149,25 @@ func (manager *SHostJointsManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SHostJointsManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SJointResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SHostResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SHostResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SHostResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/hostnetworks.go

@@ -260,3 +260,24 @@ func (manager *SHostnetworkManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SHostnetworkManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SHostJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SHostJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SNetworkResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/hostresource.go

@@ -240,3 +240,42 @@ func (manager *SHostResourceBaseManager) GetOrderByFields(query api.HostFilterLi
 	fields = append(fields, query.OrderByHost, query.OrderByHostSN)
 	return fields
 }
+
+func (manager *SHostResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		hostsQ := HostManager.Query("id", "name", "sn", "zone_id", "manager_id").SubQuery()
+		q = q.LeftJoin(hostsQ, sqlchemy.Equals(q.Field(manager.getHostIdFieldName()), hostsQ.Field("id")))
+		if keys.Contains("host") {
+			q = q.AppendField(hostsQ.Field("name", "host"))
+		}
+		if keys.Contains("host_sn") {
+			q = q.AppendField(hostsQ.Field("sn", "host_sn"))
+		}
+		if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+			var err error
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+			var err error
+			q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SHostResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"host", "host_sn"}
+	keys = append(keys, manager.SZoneResourceBaseManager.GetExportKeys()...)
+	keys = append(keys, manager.SManagedResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/hosts.go

@@ -5028,3 +5028,27 @@ func (host *SHost) PerformPrivate(ctx context.Context, userCred mcclient.TokenCr
 	}
 	return host.SEnabledStatusInfrasResourceBase.PerformPrivate(ctx, userCred, query, input)
 }
+
+func (manager *SHostManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/hoststorages.go

@@ -369,3 +369,24 @@ func (manager *SHoststorageManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SHoststorageManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SHostJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SHostJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SStorageResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SStorageResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SStorageResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/hostwires.go

@@ -254,3 +254,24 @@ func (manager *SHostwireManager) OrderByExtraFields(
 
 	return q, nil
 }
+
+func (manager *SHostwireManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SHostJointsManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SHostJointsManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SWireResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SWireResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SWireResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalanceracls.go

@@ -529,3 +529,32 @@ func (manager *SLoadbalancerAclManager) QueryDistinctExtraField(q *sqlchemy.SQue
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SLoadbalancerAclManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SSharableVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SSharableVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalanceragents.go

@@ -637,6 +637,27 @@ func (manager *SLoadbalancerAgentManager) FetchCustomizeColumns(
 	return q, nil
 }*/
 
+func (manager *SLoadbalancerAgentManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SLoadbalancerClusterResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerClusterResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerClusterResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}
+
 func (man *SLoadbalancerAgentManager) getByClusterId(clusterId string) ([]SLoadbalancerAgent, error) {
 	r := []SLoadbalancerAgent{}
 	q := man.Query().Equals("cluster_id", clusterId)

pkg/compute/models/loadbalancerbackendgroupresource.go

@@ -258,3 +258,31 @@ func (manager *SLoadbalancerBackendgroupResourceBaseManager) GetOrderByFields(qu
 	fields = append(fields, query.OrderByBackendGroup)
 	return fields
 }
+
+func (manager *SLoadbalancerBackendgroupResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := LoadbalancerBackendGroupManager.Query("id", "name", "loadbalancer_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("backend_group_id"), subq.Field("id")))
+		if keys.Contains("backend_group") {
+			q = q.AppendField(subq.Field("name", "backend_group"))
+		}
+		if keys.ContainsAny(manager.SLoadbalancerResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SLoadbalancerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SLoadbalancerResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SLoadbalancerBackendgroupResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"backend_group"}
+	keys = append(keys, manager.SLoadbalancerResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/loadbalancerbackendgroups.go

@@ -1053,3 +1053,25 @@ func (manager *SLoadbalancerBackendGroupManager) GetResourceCount() ([]db.SScope
 	virts := manager.Query().IsFalse("pending_deleted")
 	return db.CalculateProjectResourceCount(virts)
 }
+
+func (manager *SLoadbalancerBackendGroupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SLoadbalancerResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalancerbackends.go

@@ -651,3 +651,25 @@ func (manager *SLoadbalancerBackendManager) GetResourceCount() ([]db.SScopeResou
 	virts := manager.Query().IsFalse("pending_deleted")
 	return db.CalculateProjectResourceCount(virts)
 }
+
+func (manager *SLoadbalancerBackendManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SLoadbalancerBackendgroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerBackendgroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerBackendgroupResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalancercachedacls.go

@@ -611,3 +611,30 @@ func (manager *SCachedLoadbalancerAclManager) QueryDistinctExtraField(q *sqlchem
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SCachedLoadbalancerAclManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SSharableVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SSharableVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalancercachedcertificates.go

@@ -538,3 +538,35 @@ func (man *SCachedLoadbalancerCertificateManager) QueryDistinctExtraField(q *sql
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SCachedLoadbalancerCertificateManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SLoadbalancerCertificateResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerCertificateResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerCertificateResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/loadbalancercertificateresource.go

@@ -163,3 +163,22 @@ func (manager *SLoadbalancerCertificateResourceBaseManager) GetOrderBySubQuery(
 func (manager *SLoadbalancerCertificateResourceBaseManager) GetOrderByFields(query api.LoadbalancerCertificateFilterListInput) []string {
 	return []string{query.OrderByCertificate}
 }
+
+func (manager *SLoadbalancerCertificateResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := LoadbalancerCertificateManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("certificate_id"), subq.Field("id")))
+		if keys.Contains("certificate") {
+			q = q.AppendField(subq.Field("name", "certificate"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SLoadbalancerCertificateResourceBaseManager) GetExportKeys() []string {
+	return []string{"certificate"}
+}

pkg/compute/models/loadbalancerclusterresource.go

@@ -226,3 +226,38 @@ func (manager *SLoadbalancerClusterResourceBaseManager) GetOrderByFields(query a
 	fields = append(fields, query.OrderByCluster)
 	return fields
 }
+
+func (manager *SLoadbalancerClusterResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := LoadbalancerClusterManager.Query("id", "name", "wire_d", "zone_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("cluster_id"), subq.Field("id")))
+
+		if keys.Contains("cluster") {
+			q = q.AppendField(subq.Field("name", "cluster"))
+		}
+		if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.Contains("wire") {
+			q, err = manager.SWireResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SWireResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SLoadbalancerClusterResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"cluster"}
+	keys = append(keys, manager.SWireResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/loadbalancerclusters.go

@@ -405,3 +405,28 @@ func (man *SLoadbalancerClusterManager) InitializeData() error {
 
 	return nil
 }
+
+func (manager *SLoadbalancerClusterManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("wire") {
+		q, err = manager.SWireResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SWireResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/loadbalancerlistenerresource.go

@@ -223,3 +223,32 @@ func (manager *SLoadbalancerListenerResourceBaseManager) GetOrderByFields(query
 	fields = append(fields, query.OrderByListener)
 	return fields
 }
+
+func (manager *SLoadbalancerListenerResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := LoadbalancerListenerManager.Query("id", "name", "loadbalancer_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("loadbalancer_id"), subq.Field("id")))
+		if keys.Contains("listener") {
+			q = q.AppendField(subq.Field("name", "listener"))
+		}
+		if keys.ContainsAny(manager.SLoadbalancerResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SLoadbalancerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SLoadbalancerResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+
+	return q, nil
+}
+
+func (manager *SLoadbalancerListenerResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"listener"}
+	keys = append(keys, manager.SLoadbalancerResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/loadbalancerlistenerrules.go

@@ -940,3 +940,22 @@ func (manager *SLoadbalancerListenerRuleManager) GetResourceCount() ([]db.SScope
 	virts := manager.Query().IsFalse("pending_deleted")
 	return db.CalculateProjectResourceCount(virts)
 }
+
+func (manager *SLoadbalancerListenerRuleManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SLoadbalancerListenerResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerListenerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerListenerResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/loadbalancerlisteners.go

@@ -1236,3 +1236,24 @@ func (manager *SLoadbalancerListenerManager) GetResourceCount() ([]db.SScopeReso
 	virts := manager.Query().IsFalse("pending_deleted")
 	return db.CalculateProjectResourceCount(virts)
 }
+
+func (manager *SLoadbalancerListenerManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SLoadbalancerResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, ".SLoadbalancerResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalancernetworks.go

@@ -368,3 +368,32 @@ func (manager *SLoadbalancernetworkManager) QueryDistinctExtraField(q *sqlchemy.
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SLoadbalancernetworkManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualJointResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SLoadbalancerResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SNetworkResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/loadbalancerresource.go

@@ -309,3 +309,38 @@ func (manager *SLoadbalancerResourceBaseManager) GetOrderByFields(query api.Load
 	fields = append(fields, query.OrderByLoadbalancer)
 	return fields
 }
+
+func (manager *SLoadbalancerResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := LoadbalancerManager.Query("id", "name", "vpc_id", "zone_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("loadbalancer_id"), q.Field("id")))
+		if keys.Contains("loadbalancer") {
+			q = q.AppendField(subq.Field("name", "loadbalancer"))
+		}
+		if keys.Contains("vpc") {
+			q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SLoadbalancerResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"loadbalancer"}
+	keys = append(keys, manager.SZoneResourceBaseManager.GetExportKeys()...)
+	keys = append(keys, "vpc")
+	return keys
+}

pkg/compute/models/loadbalancers.go

@@ -1056,3 +1056,36 @@ func (lb *SLoadbalancer) GetUsages() []db.IUsage {
 		&usage,
 	}
 }
+
+func (manager *SLoadbalancerManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("vpc") {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny("network", "wire") {
+		q, err = manager.SNetworkResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SNetworkResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/managedresource.go

@@ -372,6 +372,38 @@ func (model *SManagedResourceBase) GetChangeOwnerCandidateDomainIds() []string {
 	return candidateIds
 }
 
+func (manager *SManagedResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		cloudprovidersQ := CloudproviderManager.Query("id", "name", "cloudaccount_id").SubQuery()
+		q = q.LeftJoin(cloudprovidersQ, sqlchemy.Equals(q.Field(manager.getManagerIdFileName()), cloudprovidersQ.Field("id")))
+		if keys.Contains("manager") {
+			q = q.AppendField(cloudprovidersQ.Field("name", "manager"))
+		}
+		if keys.Contains("account") || keys.Contains("provider") || keys.Contains("brand") {
+			cloudaccountsQ := CloudaccountManager.Query("id", "name", "provider", "brand").SubQuery()
+			q = q.LeftJoin(cloudaccountsQ, sqlchemy.Equals(cloudprovidersQ.Field("cloudaccount_id"), cloudaccountsQ.Field("id")))
+			if keys.Contains("account") {
+				q = q.AppendField(cloudaccountsQ.Field("name", "account"))
+			}
+			if keys.Contains("provider") {
+				q = q.AppendField(cloudaccountsQ.Field("provider"))
+			}
+			if keys.Contains("brand") {
+				q = q.AppendField(cloudaccountsQ.Field("provider"))
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SManagedResourceBaseManager) GetExportKeys() []string {
+	return []string{"manager", "account", "provider", "brand"}
+}
+
 func _managedResourceFilterByDomain(managerIdFieldName string, q *sqlchemy.SQuery, query apis.DomainizedResourceListInput, filterField string, subqFunc func() *sqlchemy.SQuery) (*sqlchemy.SQuery, error) {
 	domainStr := query.ProjectDomain
 	if len(domainStr) > 0 {

pkg/compute/models/networkinterfaces.go

@@ -368,3 +368,32 @@ func (self *SNetworkInterface) GetNetworks() ([]SNetworkinterfacenetwork, error)
 	}
 	return networks, nil
 }
+
+func (manager *SNetworkInterfaceManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusInfrasResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusInfrasResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/networkresource.go

@@ -232,3 +232,31 @@ func (manager *SNetworkResourceBaseManager) GetOrderByFields(query api.NetworkFi
 	orders = append(orders, query.OrderByNetwork)
 	return orders
 }
+
+func (manager *SNetworkResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := NetworkManager.Query("id", "name", "wire_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("network_id"), subq.Field("id")))
+		if keys.Contains("network") {
+			q = q.AppendField(subq.Field("name", "network"))
+		}
+		if keys.ContainsAny(manager.SWireResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SWireResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SWireResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SNetworkResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"network"}
+	keys = append(keys, manager.SWireResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/networks.go

@@ -2568,3 +2568,22 @@ func (net *SNetwork) GetChangeOwnerCandidateDomainIds() []string {
 	}
 	return db.ISharableMergeChangeOwnerCandidateDomainIds(net, candidates...)
 }
+
+func (manager *SNetworkManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SSharableVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SSharableVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SWireResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SWireResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SWireResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/scaling_group.go

@@ -721,3 +721,49 @@ func (sg *SScalingGroup) Activities() ([]SScalingActivity, error) {
 	}
 	return activities, nil
 }
+
+func (manager *SScalingGroupManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		// SCloudregionResourceBaseManager
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SLoadbalancerBackendgroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SLoadbalancerBackendgroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SLoadbalancerBackendgroupResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SGroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGroupResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SGuestTemplateResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGuestTemplateResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGuestTemplateResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SGuestResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGuestResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGuestResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/secgroupcache.go

@@ -478,3 +478,46 @@ func (manager *SSecurityGroupCacheManager) InitializeData() error {
 	log.Debugf("SSecurityGroupCacheManager cleaned %d deprecated security group cache.", len(deprecatedSecgroups))
 	return nil
 }
+
+func (manager *SSecurityGroupCacheManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	if keys.ContainsAny(manager.SSecurityGroupResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SSecurityGroupResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SSecurityGroupResourceBaseManager.ListItemExportKey")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/secgroupresource.go

@@ -161,3 +161,20 @@ func (manager *SSecurityGroupResourceBaseManager) GetOrderBySubQuery(
 func (manager *SSecurityGroupResourceBaseManager) GetOrderByFields(query api.SecgroupFilterListInput) []string {
 	return []string{query.OrderBySecgroup}
 }
+
+func (manager *SSecurityGroupResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := SecurityGroupManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("secgroup_id"), subq.Field("id")))
+		q = q.AppendField(subq.Field("name", "secgroup"))
+	}
+	return q, nil
+}
+
+func (manager *SSecurityGroupResourceBaseManager) GetExportKeys() []string {
+	return []string{"secgroup"}
+}

pkg/compute/models/skus.go

@@ -1518,3 +1518,30 @@ func (manager *SServerSkuManager) InitializeData() error {
 
 	return manager.initializeSkuStatus()
 }
+
+func (manager *SServerSkuManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("zone") {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/snapshotpolicycache.go

@@ -507,3 +507,31 @@ func (spc *SSnapshotPolicyCache) UpdateCloudSnapshotPolicy(input *cloudprovider.
 
 	return nil
 }
+
+func (manager *SSnapshotPolicyCacheManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SStatusStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStatusStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/snapshotpolicydisks.go

@@ -566,3 +566,30 @@ func (manager *SSnapshotPolicyDiskManager) QueryDistinctExtraField(q *sqlchemy.S
 
 	return q, httperrors.ErrNotFound
 }
+
+func (manager *SSnapshotPolicyDiskManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+
+	q, err = manager.SVirtualJointResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualJointResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SSnapshotPolicyResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SSnapshotPolicyResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SSnapshotPolicyResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SDiskResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SDiskResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDiskResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/snapshotpolicyresource.go

@@ -162,3 +162,22 @@ func (manager *SSnapshotPolicyResourceBaseManager) GetOrderBySubQuery(
 func (manager *SSnapshotPolicyResourceBaseManager) GetOrderByFields(query api.SnapshotPolicyFilterListInput) []string {
 	return []string{query.OrderBySnapshotpolicy}
 }
+
+func (manager *SSnapshotPolicyResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		subq := SnapshotPolicyManager.Query("id", "name").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("snapshotpolicy_id"), subq.Field("id")))
+		if keys.Contains("snapshotpolicy") {
+			q = q.AppendField(subq.Field("name", "snapshotpolicy"))
+		}
+	}
+	return q, nil
+}
+
+func (manager *SSnapshotPolicyResourceBaseManager) GetExportKeys() []string {
+	return []string{"snapshotpolicy"}
+}

pkg/compute/models/snapshots.go

@@ -1076,3 +1076,42 @@ func (snapshot *SSnapshot) GetUsages() []db.IUsage {
 		&usage,
 	}
 }
+
+func (manager *SSnapshotManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SVirtualResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.ListItemExportKeys")
+	}
+
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.Contains("disk") {
+		q, err = manager.SDiskResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SDiskResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SStorageResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SStorageResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SStorageResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/storagecaches.go

@@ -699,3 +699,21 @@ func (cache *SStoragecache) CustomizeDelete(ctx context.Context, userCred mcclie
 	}
 	return nil
 }
+
+func (manager *SStoragecacheManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/storageresource.go

@@ -233,3 +233,38 @@ func (manager *SStorageResourceBaseManager) GetOrderByFields(query api.StorageFi
 	fields = append(fields, query.OrderByStorage)
 	return fields
 }
+
+func (manager *SStorageResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := StorageManager.Query("id", "name", "zone_id", "manager_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("storage_id"), subq.Field("id")))
+		if keys.Contains("storage") {
+			q = q.AppendField(subq.Field("name", "storage"))
+		}
+		if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SStorageResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"storage"}
+	keys = append(keys, manager.SZoneResourceBaseManager.GetExportKeys()...)
+	keys = append(keys, manager.SManagedResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/storages.go

@@ -1483,3 +1483,27 @@ func (storage *SStorage) PerformPrivate(ctx context.Context, userCred mcclient.T
 func (storage *SStorage) performPrivateInternal(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, input apis.PerformPrivateInput) (jsonutils.JSONObject, error) {
 	return storage.SEnabledStatusInfrasResourceBase.PerformPrivate(ctx, userCred, query, input)
 }
+
+func (manager *SStorageManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/vpcresource.go

@@ -275,3 +275,38 @@ func (manager *SVpcResourceBaseManager) GetOrderByFields(query api.VpcFilterList
 	fields = append(fields, query.OrderByVpc)
 	return fields
 }
+
+func (manager *SVpcResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := VpcManager.Query("id", "name", "manager_id", "cloudregion_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("vpc_id"), subq.Field("id")))
+		if keys.Contains("vpc") {
+			q = q.AppendField(subq.Field("name", "vpc"))
+		}
+		if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SVpcResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"vpc"}
+	keys = append(keys, manager.SManagedResourceBaseManager.GetExportKeys()...)
+	keys = append(keys, manager.SCloudregionResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/vpcs.go

@@ -1113,3 +1113,34 @@ func (vpc *SVpc) GetRequiredSharedDomainIds() []string {
 	}
 	return db.ISharableMergeShareRequireDomainIds(requires...)
 }
+
+func (manager *SVpcManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	q, err := manager.SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SEnabledStatusInfrasResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SManagedResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SManagedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SGlobalVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SGlobalVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SGlobalVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+
+	return q, nil
+}

pkg/compute/models/wireresource.go

@@ -270,3 +270,38 @@ func (manager *SWireResourceBaseManager) GetOrderByFields(query api.WireFilterLi
 	fields = append(fields, query.OrderByWire)
 	return fields
 }
+
+func (manager *SWireResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		var err error
+		subq := WireManager.Query("id", "name", "vpc_id", "zone_id").SubQuery()
+		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("wire_id"), subq.Field("id")))
+		if keys.Contains("wire") {
+			q = q.AppendField(subq.Field("name", "wire"))
+		}
+		if keys.Contains("zone") {
+			q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+			}
+		}
+		if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+			q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SWireResourceBaseManager) GetExportKeys() []string {
+	keys := []string{"wire"}
+	keys = append(keys, "zone")
+	keys = append(keys, manager.SVpcResourceBaseManager.GetExportKeys()...)
+	return keys
+}

pkg/compute/models/wires.go

@@ -1026,3 +1026,28 @@ func (wire *SWire) GetRequiredSharedDomainIds() []string {
 	}
 	return db.ISharableMergeShareRequireDomainIds(requires...)
 }
+
+func (manager *SWireManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	var err error
+	q, err = manager.SInfrasResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SInfrasResourceBaseManager.ListItemExportKeys")
+	}
+	if keys.ContainsAny(manager.SZoneResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SZoneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SZoneResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	if keys.ContainsAny(manager.SVpcResourceBaseManager.GetExportKeys()...) {
+		q, err = manager.SVpcResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+		if err != nil {
+			return nil, errors.Wrap(err, "SVpcResourceBaseManager.ListItemExportKeys")
+		}
+	}
+	return q, nil
+}

pkg/compute/models/zoneresource.go

@@ -187,3 +187,29 @@ func (manager *SZoneResourceBaseManager) GetOrderByFields(query api.ZonalFilterL
 	orders = append(orders, query.OrderByZone)
 	return orders
 }
+
+func (manager *SZoneResourceBaseManager) ListItemExportKeys(ctx context.Context,
+	q *sqlchemy.SQuery,
+	userCred mcclient.TokenCredential,
+	keys stringutils2.SSortedStrings,
+) (*sqlchemy.SQuery, error) {
+	if keys.ContainsAny(manager.GetExportKeys()...) {
+		zonesQ := ZoneManager.Query("id", "name", "cloudregion_id").SubQuery()
+		q = q.LeftJoin(zonesQ, sqlchemy.Equals(q.Field("zone_id"), zonesQ.Field("id")))
+		if keys.Contains("zone") {
+			q = q.AppendField(zonesQ.Field("name", "zone"))
+		}
+		if keys.ContainsAny(manager.SCloudregionResourceBaseManager.GetExportKeys()...) {
+			var err error
+			q, err = manager.SCloudregionResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+			if err != nil {
+				return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemExportKeys")
+			}
+		}
+	}
+	return q, nil
+}
+
+func (manager *SZoneResourceBaseManager) GetExportKeys() []string {
+	return append(manager.SCloudregionResourceBaseManager.GetExportKeys(), "zones")
+}

pkg/keystone/models/identitybase.go

@@ -438,3 +438,15 @@ func (manager *SIdentityBaseResourceManager) totalCount(scope rbacutils.TRbacSco
 	cnt, _ := q.CountWithError()
 	return cnt
 }
+
+func (manager *SIdentityBaseResourceManager) ListItemExportKeys(ctx context.Context, q *sqlchemy.SQuery, userCred mcclient.TokenCredential, keys stringutils2.SSortedStrings) (*sqlchemy.SQuery, error) {
+	q, err := manager.SStandaloneResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SStandaloneResourceBaseManager.ListItemExportKeys")
+	}
+	q, err = manager.SDomainizedResourceBaseManager.ListItemExportKeys(ctx, q, userCred, keys)
+	if err != nil {
+		return nil, errors.Wrap(err, "SDomainizedResourceBaseManager.ListItemExportKeys")
+	}
+	return q, nil
+}

pkg/keystone/service/override.go

@@ -22,6 +22,7 @@ import (
 
 	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
+	"yunion.io/x/sqlchemy"
 
 	api "yunion.io/x/onecloud/pkg/apis/identity"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
@@ -105,3 +106,11 @@ func keystoneProjectsFetcher(ctx context.Context, idList []string, isDomain bool
 		return ret
 	}
 }
+
+func keystoneProjectQuery(fields ...string) *sqlchemy.SQuery {
+	return models.ProjectManager.Query(fields...)
+}
+
+func keystoneDomainQuery(fields ...string) *sqlchemy.SQuery {
+	return models.DomainManager.Query(fields...)
+}

pkg/keystone/service/service.go

@@ -45,6 +45,8 @@ func StartService() {
 	db.DefaultUUIDGenerator = keystoneUUIDGenerator
 	db.DefaultProjectFetcher = keystoneProjectFetcher
 	db.DefaultDomainFetcher = keystoneDomainFetcher
+	db.DefaultDomainQuery = keystoneDomainQuery
+	db.DefaultProjectQuery = keystoneProjectQuery
 	db.DefaultProjectsFetcher = keystoneProjectsFetcher
 	policy.DefaultPolicyFetcher = localPolicyFetcher
 	logclient.DefaultSessionGenerator = models.GetDefaultClientSession