func()

in v2/api/documentdb/v1api20231115/database_account_types_gen.go [390:644]
243 lines of code
82 McCabe index (conditional complexity)

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

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

	// Set property "Kind":
	if account.Kind != nil {
		var temp string
		temp = string(*account.Kind)
		kind := arm.DatabaseAccount_Kind_Spec(temp)
		result.Kind = &kind
	}

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

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

	// Set property "Properties":
	if account.AnalyticalStorageConfiguration != nil ||
		account.ApiProperties != nil ||
		account.BackupPolicy != nil ||
		account.Capabilities != nil ||
		account.Capacity != nil ||
		account.ConnectorOffer != nil ||
		account.ConsistencyPolicy != nil ||
		account.Cors != nil ||
		account.CreateMode != nil ||
		account.CustomerManagedKeyStatus != nil ||
		account.DatabaseAccountOfferType != nil ||
		account.DefaultIdentity != nil ||
		account.DisableKeyBasedMetadataWriteAccess != nil ||
		account.DisableLocalAuth != nil ||
		account.EnableAnalyticalStorage != nil ||
		account.EnableAutomaticFailover != nil ||
		account.EnableBurstCapacity != nil ||
		account.EnableCassandraConnector != nil ||
		account.EnableFreeTier != nil ||
		account.EnableMultipleWriteLocations != nil ||
		account.EnablePartitionMerge != nil ||
		account.IpRules != nil ||
		account.IsVirtualNetworkFilterEnabled != nil ||
		account.KeyVaultKeyUri != nil ||
		account.Locations != nil ||
		account.MinimalTlsVersion != nil ||
		account.NetworkAclBypass != nil ||
		account.NetworkAclBypassResourceReferences != nil ||
		account.PublicNetworkAccess != nil ||
		account.RestoreParameters != nil ||
		account.VirtualNetworkRules != nil {
		result.Properties = &arm.DatabaseAccountCreateUpdateProperties{}
	}
	if account.AnalyticalStorageConfiguration != nil {
		analyticalStorageConfiguration_ARM, err := (*account.AnalyticalStorageConfiguration).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		analyticalStorageConfiguration := *analyticalStorageConfiguration_ARM.(*arm.AnalyticalStorageConfiguration)
		result.Properties.AnalyticalStorageConfiguration = &analyticalStorageConfiguration
	}
	if account.ApiProperties != nil {
		apiProperties_ARM, err := (*account.ApiProperties).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		apiProperties := *apiProperties_ARM.(*arm.ApiProperties)
		result.Properties.ApiProperties = &apiProperties
	}
	if account.BackupPolicy != nil {
		backupPolicy_ARM, err := (*account.BackupPolicy).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		backupPolicy := *backupPolicy_ARM.(*arm.BackupPolicy)
		result.Properties.BackupPolicy = &backupPolicy
	}
	for _, item := range account.Capabilities {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.Capabilities = append(result.Properties.Capabilities, *item_ARM.(*arm.Capability))
	}
	if account.Capacity != nil {
		capacity_ARM, err := (*account.Capacity).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		capacity := *capacity_ARM.(*arm.Capacity)
		result.Properties.Capacity = &capacity
	}
	if account.ConnectorOffer != nil {
		var temp string
		temp = string(*account.ConnectorOffer)
		connectorOffer := arm.ConnectorOffer(temp)
		result.Properties.ConnectorOffer = &connectorOffer
	}
	if account.ConsistencyPolicy != nil {
		consistencyPolicy_ARM, err := (*account.ConsistencyPolicy).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		consistencyPolicy := *consistencyPolicy_ARM.(*arm.ConsistencyPolicy)
		result.Properties.ConsistencyPolicy = &consistencyPolicy
	}
	for _, item := range account.Cors {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.Cors = append(result.Properties.Cors, *item_ARM.(*arm.CorsPolicy))
	}
	if account.CreateMode != nil {
		var temp string
		temp = string(*account.CreateMode)
		createMode := arm.CreateMode(temp)
		result.Properties.CreateMode = &createMode
	}
	if account.CustomerManagedKeyStatus != nil {
		customerManagedKeyStatus := *account.CustomerManagedKeyStatus
		result.Properties.CustomerManagedKeyStatus = &customerManagedKeyStatus
	}
	if account.DatabaseAccountOfferType != nil {
		var temp string
		temp = string(*account.DatabaseAccountOfferType)
		databaseAccountOfferType := arm.DatabaseAccountOfferType(temp)
		result.Properties.DatabaseAccountOfferType = &databaseAccountOfferType
	}
	if account.DefaultIdentity != nil {
		defaultIdentity := *account.DefaultIdentity
		result.Properties.DefaultIdentity = &defaultIdentity
	}
	if account.DisableKeyBasedMetadataWriteAccess != nil {
		disableKeyBasedMetadataWriteAccess := *account.DisableKeyBasedMetadataWriteAccess
		result.Properties.DisableKeyBasedMetadataWriteAccess = &disableKeyBasedMetadataWriteAccess
	}
	if account.DisableLocalAuth != nil {
		disableLocalAuth := *account.DisableLocalAuth
		result.Properties.DisableLocalAuth = &disableLocalAuth
	}
	if account.EnableAnalyticalStorage != nil {
		enableAnalyticalStorage := *account.EnableAnalyticalStorage
		result.Properties.EnableAnalyticalStorage = &enableAnalyticalStorage
	}
	if account.EnableAutomaticFailover != nil {
		enableAutomaticFailover := *account.EnableAutomaticFailover
		result.Properties.EnableAutomaticFailover = &enableAutomaticFailover
	}
	if account.EnableBurstCapacity != nil {
		enableBurstCapacity := *account.EnableBurstCapacity
		result.Properties.EnableBurstCapacity = &enableBurstCapacity
	}
	if account.EnableCassandraConnector != nil {
		enableCassandraConnector := *account.EnableCassandraConnector
		result.Properties.EnableCassandraConnector = &enableCassandraConnector
	}
	if account.EnableFreeTier != nil {
		enableFreeTier := *account.EnableFreeTier
		result.Properties.EnableFreeTier = &enableFreeTier
	}
	if account.EnableMultipleWriteLocations != nil {
		enableMultipleWriteLocations := *account.EnableMultipleWriteLocations
		result.Properties.EnableMultipleWriteLocations = &enableMultipleWriteLocations
	}
	if account.EnablePartitionMerge != nil {
		enablePartitionMerge := *account.EnablePartitionMerge
		result.Properties.EnablePartitionMerge = &enablePartitionMerge
	}
	for _, item := range account.IpRules {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.IpRules = append(result.Properties.IpRules, *item_ARM.(*arm.IpAddressOrRange))
	}
	if account.IsVirtualNetworkFilterEnabled != nil {
		isVirtualNetworkFilterEnabled := *account.IsVirtualNetworkFilterEnabled
		result.Properties.IsVirtualNetworkFilterEnabled = &isVirtualNetworkFilterEnabled
	}
	if account.KeyVaultKeyUri != nil {
		keyVaultKeyUri := *account.KeyVaultKeyUri
		result.Properties.KeyVaultKeyUri = &keyVaultKeyUri
	}
	for _, item := range account.Locations {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.Locations = append(result.Properties.Locations, *item_ARM.(*arm.Location))
	}
	if account.MinimalTlsVersion != nil {
		var temp string
		temp = string(*account.MinimalTlsVersion)
		minimalTlsVersion := arm.MinimalTlsVersion(temp)
		result.Properties.MinimalTlsVersion = &minimalTlsVersion
	}
	if account.NetworkAclBypass != nil {
		var temp string
		temp = string(*account.NetworkAclBypass)
		networkAclBypass := arm.NetworkAclBypass(temp)
		result.Properties.NetworkAclBypass = &networkAclBypass
	}
	for _, item := range account.NetworkAclBypassResourceReferences {
		itemARMID, err := resolved.ResolvedReferences.Lookup(item)
		if err != nil {
			return nil, err
		}
		result.Properties.NetworkAclBypassResourceIds = append(result.Properties.NetworkAclBypassResourceIds, itemARMID)
	}
	if account.PublicNetworkAccess != nil {
		var temp string
		temp = string(*account.PublicNetworkAccess)
		publicNetworkAccess := arm.PublicNetworkAccess(temp)
		result.Properties.PublicNetworkAccess = &publicNetworkAccess
	}
	if account.RestoreParameters != nil {
		restoreParameters_ARM, err := (*account.RestoreParameters).ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		restoreParameters := *restoreParameters_ARM.(*arm.RestoreParameters)
		result.Properties.RestoreParameters = &restoreParameters
	}
	for _, item := range account.VirtualNetworkRules {
		item_ARM, err := item.ConvertToARM(resolved)
		if err != nil {
			return nil, err
		}
		result.Properties.VirtualNetworkRules = append(result.Properties.VirtualNetworkRules, *item_ARM.(*arm.VirtualNetworkRule))
	}

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