func()

in v2/api/machinelearningservices/v1api20240401/workspace_types_gen.go [346:566]


func (workspace *Workspace_Spec) ConvertToARM(resolved genruntime.ConvertToARMResolvedDetails) (interface{}, error) {
	if workspace == nil {
		return nil, nil
	}
	result := &arm.Workspace_Spec{}

	// Set property "Identity":
	if workspace.Identity != nil {
		identity_ARM, err := (*workspace.Identity).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		identity := *identity_ARM.(*arm.ManagedServiceIdentity)
		result.Identity = &identity
	}

	// Set property "Kind":
	if workspace.Kind != nil {
		kind := *workspace.Kind
		result.Kind = &kind
	}

	// Set property "Location":
	if workspace.Location != nil {
		location := *workspace.Location
		result.Location = &location
	}

	// Set property "Name":
	result.Name = resolved.Name

	// Set property "Properties":
	if workspace.AllowPublicAccessWhenBehindVnet != nil ||
		workspace.ApplicationInsightsReference != nil ||
		workspace.AssociatedWorkspaces != nil ||
		workspace.ContainerRegistryReference != nil ||
		workspace.Description != nil ||
		workspace.DiscoveryUrl != nil ||
		workspace.EnableDataIsolation != nil ||
		workspace.Encryption != nil ||
		workspace.FeatureStoreSettings != nil ||
		workspace.FriendlyName != nil ||
		workspace.HbiWorkspace != nil ||
		workspace.HubResourceReference != nil ||
		workspace.ImageBuildCompute != nil ||
		workspace.KeyVaultReference != nil ||
		workspace.ManagedNetwork != nil ||
		workspace.PrimaryUserAssignedIdentityReference != nil ||
		workspace.PublicNetworkAccess != nil ||
		workspace.ServerlessComputeSettings != nil ||
		workspace.ServiceManagedResourcesSettings != nil ||
		workspace.SharedPrivateLinkResources != nil ||
		workspace.StorageAccountReference != nil ||
		workspace.V1LegacyMode != nil ||
		workspace.WorkspaceHubConfig != nil {
		result.Properties = &arm.WorkspaceProperties{}
	}
	if workspace.AllowPublicAccessWhenBehindVnet != nil {
		allowPublicAccessWhenBehindVnet := *workspace.AllowPublicAccessWhenBehindVnet
		result.Properties.AllowPublicAccessWhenBehindVnet = &allowPublicAccessWhenBehindVnet
	}
	if workspace.ApplicationInsightsReference != nil {
		applicationInsightsARMID, err := resolved.ResolvedReferences.Lookup(*workspace.ApplicationInsightsReference)
		if err != nil {
			return nil, err
		}
		applicationInsights := applicationInsightsARMID
		result.Properties.ApplicationInsights = &applicationInsights
	}
	for _, item := range workspace.AssociatedWorkspaces {
		result.Properties.AssociatedWorkspaces = append(result.Properties.AssociatedWorkspaces, item)
	}
	if workspace.ContainerRegistryReference != nil {
		containerRegistryARMID, err := resolved.ResolvedReferences.Lookup(*workspace.ContainerRegistryReference)
		if err != nil {
			return nil, err
		}
		containerRegistry := containerRegistryARMID
		result.Properties.ContainerRegistry = &containerRegistry
	}
	if workspace.Description != nil {
		description := *workspace.Description
		result.Properties.Description = &description
	}
	if workspace.DiscoveryUrl != nil {
		discoveryUrl := *workspace.DiscoveryUrl
		result.Properties.DiscoveryUrl = &discoveryUrl
	}
	if workspace.EnableDataIsolation != nil {
		enableDataIsolation := *workspace.EnableDataIsolation
		result.Properties.EnableDataIsolation = &enableDataIsolation
	}
	if workspace.Encryption != nil {
		encryption_ARM, err := (*workspace.Encryption).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		encryption := *encryption_ARM.(*arm.EncryptionProperty)
		result.Properties.Encryption = &encryption
	}
	if workspace.FeatureStoreSettings != nil {
		featureStoreSettings_ARM, err := (*workspace.FeatureStoreSettings).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		featureStoreSettings := *featureStoreSettings_ARM.(*arm.FeatureStoreSettings)
		result.Properties.FeatureStoreSettings = &featureStoreSettings
	}
	if workspace.FriendlyName != nil {
		friendlyName := *workspace.FriendlyName
		result.Properties.FriendlyName = &friendlyName
	}
	if workspace.HbiWorkspace != nil {
		hbiWorkspace := *workspace.HbiWorkspace
		result.Properties.HbiWorkspace = &hbiWorkspace
	}
	if workspace.HubResourceReference != nil {
		hubResourceIdARMID, err := resolved.ResolvedReferences.Lookup(*workspace.HubResourceReference)
		if err != nil {
			return nil, err
		}
		hubResourceId := hubResourceIdARMID
		result.Properties.HubResourceId = &hubResourceId
	}
	if workspace.ImageBuildCompute != nil {
		imageBuildCompute := *workspace.ImageBuildCompute
		result.Properties.ImageBuildCompute = &imageBuildCompute
	}
	if workspace.KeyVaultReference != nil {
		keyVaultARMID, err := resolved.ResolvedReferences.Lookup(*workspace.KeyVaultReference)
		if err != nil {
			return nil, err
		}
		keyVault := keyVaultARMID
		result.Properties.KeyVault = &keyVault
	}
	if workspace.ManagedNetwork != nil {
		managedNetwork_ARM, err := (*workspace.ManagedNetwork).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		managedNetwork := *managedNetwork_ARM.(*arm.ManagedNetworkSettings)
		result.Properties.ManagedNetwork = &managedNetwork
	}
	if workspace.PrimaryUserAssignedIdentityReference != nil {
		primaryUserAssignedIdentityARMID, err := resolved.ResolvedReferences.Lookup(*workspace.PrimaryUserAssignedIdentityReference)
		if err != nil {
			return nil, err
		}
		primaryUserAssignedIdentity := primaryUserAssignedIdentityARMID
		result.Properties.PrimaryUserAssignedIdentity = &primaryUserAssignedIdentity
	}
	if workspace.PublicNetworkAccess != nil {
		var temp string
		temp = string(*workspace.PublicNetworkAccess)
		publicNetworkAccess := arm.WorkspaceProperties_PublicNetworkAccess(temp)
		result.Properties.PublicNetworkAccess = &publicNetworkAccess
	}
	if workspace.ServerlessComputeSettings != nil {
		serverlessComputeSettings_ARM, err := (*workspace.ServerlessComputeSettings).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		serverlessComputeSettings := *serverlessComputeSettings_ARM.(*arm.ServerlessComputeSettings)
		result.Properties.ServerlessComputeSettings = &serverlessComputeSettings
	}
	if workspace.ServiceManagedResourcesSettings != nil {
		serviceManagedResourcesSettings_ARM, err := (*workspace.ServiceManagedResourcesSettings).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		serviceManagedResourcesSettings := *serviceManagedResourcesSettings_ARM.(*arm.ServiceManagedResourcesSettings)
		result.Properties.ServiceManagedResourcesSettings = &serviceManagedResourcesSettings
	}
	for _, item := range workspace.SharedPrivateLinkResources {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.SharedPrivateLinkResources = append(result.Properties.SharedPrivateLinkResources, *item_ARM.(*arm.SharedPrivateLinkResource))
	}
	if workspace.StorageAccountReference != nil {
		storageAccountARMID, err := resolved.ResolvedReferences.Lookup(*workspace.StorageAccountReference)
		if err != nil {
			return nil, err
		}
		storageAccount := storageAccountARMID
		result.Properties.StorageAccount = &storageAccount
	}
	if workspace.V1LegacyMode != nil {
		v1LegacyMode := *workspace.V1LegacyMode
		result.Properties.V1LegacyMode = &v1LegacyMode
	}
	if workspace.WorkspaceHubConfig != nil {
		workspaceHubConfig_ARM, err := (*workspace.WorkspaceHubConfig).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		workspaceHubConfig := *workspaceHubConfig_ARM.(*arm.WorkspaceHubConfig)
		result.Properties.WorkspaceHubConfig = &workspaceHubConfig
	}

	// Set property "Sku":
	if workspace.Sku != nil {
		sku_ARM, err := (*workspace.Sku).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		sku := *sku_ARM.(*arm.Sku)
		result.Sku = &sku
	}

	// Set property "Tags":
	if workspace.Tags != nil {
		result.Tags = make(map[string]string, len(workspace.Tags))
		for key, value := range workspace.Tags {
			result.Tags[key] = value
		}
	}
	return result, nil
}