in v2/api/documentdb/v1api20231115/database_account_types_gen.go [3026:3484]
func (account *DatabaseAccount_STATUS) AssignProperties_To_DatabaseAccount_STATUS(destination *storage.DatabaseAccount_STATUS) error {
// Create a new property bag
propertyBag := genruntime.NewPropertyBag()
// AnalyticalStorageConfiguration
if account.AnalyticalStorageConfiguration != nil {
var analyticalStorageConfiguration storage.AnalyticalStorageConfiguration_STATUS
err := account.AnalyticalStorageConfiguration.AssignProperties_To_AnalyticalStorageConfiguration_STATUS(&analyticalStorageConfiguration)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_AnalyticalStorageConfiguration_STATUS() to populate field AnalyticalStorageConfiguration")
}
destination.AnalyticalStorageConfiguration = &analyticalStorageConfiguration
} else {
destination.AnalyticalStorageConfiguration = nil
}
// ApiProperties
if account.ApiProperties != nil {
var apiProperty storage.ApiProperties_STATUS
err := account.ApiProperties.AssignProperties_To_ApiProperties_STATUS(&apiProperty)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ApiProperties_STATUS() to populate field ApiProperties")
}
destination.ApiProperties = &apiProperty
} else {
destination.ApiProperties = nil
}
// BackupPolicy
if account.BackupPolicy != nil {
var backupPolicy storage.BackupPolicy_STATUS
err := account.BackupPolicy.AssignProperties_To_BackupPolicy_STATUS(&backupPolicy)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_BackupPolicy_STATUS() to populate field BackupPolicy")
}
destination.BackupPolicy = &backupPolicy
} else {
destination.BackupPolicy = nil
}
// Capabilities
if account.Capabilities != nil {
capabilityList := make([]storage.Capability_STATUS, len(account.Capabilities))
for capabilityIndex, capabilityItem := range account.Capabilities {
// Shadow the loop variable to avoid aliasing
capabilityItem := capabilityItem
var capability storage.Capability_STATUS
err := capabilityItem.AssignProperties_To_Capability_STATUS(&capability)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_Capability_STATUS() to populate field Capabilities")
}
capabilityList[capabilityIndex] = capability
}
destination.Capabilities = capabilityList
} else {
destination.Capabilities = nil
}
// Capacity
if account.Capacity != nil {
var capacity storage.Capacity_STATUS
err := account.Capacity.AssignProperties_To_Capacity_STATUS(&capacity)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_Capacity_STATUS() to populate field Capacity")
}
destination.Capacity = &capacity
} else {
destination.Capacity = nil
}
// Conditions
destination.Conditions = genruntime.CloneSliceOfCondition(account.Conditions)
// ConnectorOffer
if account.ConnectorOffer != nil {
connectorOffer := string(*account.ConnectorOffer)
destination.ConnectorOffer = &connectorOffer
} else {
destination.ConnectorOffer = nil
}
// ConsistencyPolicy
if account.ConsistencyPolicy != nil {
var consistencyPolicy storage.ConsistencyPolicy_STATUS
err := account.ConsistencyPolicy.AssignProperties_To_ConsistencyPolicy_STATUS(&consistencyPolicy)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ConsistencyPolicy_STATUS() to populate field ConsistencyPolicy")
}
destination.ConsistencyPolicy = &consistencyPolicy
} else {
destination.ConsistencyPolicy = nil
}
// Cors
if account.Cors != nil {
corList := make([]storage.CorsPolicy_STATUS, len(account.Cors))
for corIndex, corItem := range account.Cors {
// Shadow the loop variable to avoid aliasing
corItem := corItem
var cor storage.CorsPolicy_STATUS
err := corItem.AssignProperties_To_CorsPolicy_STATUS(&cor)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_CorsPolicy_STATUS() to populate field Cors")
}
corList[corIndex] = cor
}
destination.Cors = corList
} else {
destination.Cors = nil
}
// CreateMode
if account.CreateMode != nil {
createMode := string(*account.CreateMode)
destination.CreateMode = &createMode
} else {
destination.CreateMode = nil
}
// CustomerManagedKeyStatus
destination.CustomerManagedKeyStatus = genruntime.ClonePointerToString(account.CustomerManagedKeyStatus)
// DatabaseAccountOfferType
if account.DatabaseAccountOfferType != nil {
databaseAccountOfferType := string(*account.DatabaseAccountOfferType)
destination.DatabaseAccountOfferType = &databaseAccountOfferType
} else {
destination.DatabaseAccountOfferType = nil
}
// DefaultIdentity
destination.DefaultIdentity = genruntime.ClonePointerToString(account.DefaultIdentity)
// DisableKeyBasedMetadataWriteAccess
if account.DisableKeyBasedMetadataWriteAccess != nil {
disableKeyBasedMetadataWriteAccess := *account.DisableKeyBasedMetadataWriteAccess
destination.DisableKeyBasedMetadataWriteAccess = &disableKeyBasedMetadataWriteAccess
} else {
destination.DisableKeyBasedMetadataWriteAccess = nil
}
// DisableLocalAuth
if account.DisableLocalAuth != nil {
disableLocalAuth := *account.DisableLocalAuth
destination.DisableLocalAuth = &disableLocalAuth
} else {
destination.DisableLocalAuth = nil
}
// DocumentEndpoint
destination.DocumentEndpoint = genruntime.ClonePointerToString(account.DocumentEndpoint)
// EnableAnalyticalStorage
if account.EnableAnalyticalStorage != nil {
enableAnalyticalStorage := *account.EnableAnalyticalStorage
destination.EnableAnalyticalStorage = &enableAnalyticalStorage
} else {
destination.EnableAnalyticalStorage = nil
}
// EnableAutomaticFailover
if account.EnableAutomaticFailover != nil {
enableAutomaticFailover := *account.EnableAutomaticFailover
destination.EnableAutomaticFailover = &enableAutomaticFailover
} else {
destination.EnableAutomaticFailover = nil
}
// EnableBurstCapacity
if account.EnableBurstCapacity != nil {
enableBurstCapacity := *account.EnableBurstCapacity
destination.EnableBurstCapacity = &enableBurstCapacity
} else {
destination.EnableBurstCapacity = nil
}
// EnableCassandraConnector
if account.EnableCassandraConnector != nil {
enableCassandraConnector := *account.EnableCassandraConnector
destination.EnableCassandraConnector = &enableCassandraConnector
} else {
destination.EnableCassandraConnector = nil
}
// EnableFreeTier
if account.EnableFreeTier != nil {
enableFreeTier := *account.EnableFreeTier
destination.EnableFreeTier = &enableFreeTier
} else {
destination.EnableFreeTier = nil
}
// EnableMultipleWriteLocations
if account.EnableMultipleWriteLocations != nil {
enableMultipleWriteLocation := *account.EnableMultipleWriteLocations
destination.EnableMultipleWriteLocations = &enableMultipleWriteLocation
} else {
destination.EnableMultipleWriteLocations = nil
}
// EnablePartitionMerge
if account.EnablePartitionMerge != nil {
enablePartitionMerge := *account.EnablePartitionMerge
destination.EnablePartitionMerge = &enablePartitionMerge
} else {
destination.EnablePartitionMerge = nil
}
// FailoverPolicies
if account.FailoverPolicies != nil {
failoverPolicyList := make([]storage.FailoverPolicy_STATUS, len(account.FailoverPolicies))
for failoverPolicyIndex, failoverPolicyItem := range account.FailoverPolicies {
// Shadow the loop variable to avoid aliasing
failoverPolicyItem := failoverPolicyItem
var failoverPolicy storage.FailoverPolicy_STATUS
err := failoverPolicyItem.AssignProperties_To_FailoverPolicy_STATUS(&failoverPolicy)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_FailoverPolicy_STATUS() to populate field FailoverPolicies")
}
failoverPolicyList[failoverPolicyIndex] = failoverPolicy
}
destination.FailoverPolicies = failoverPolicyList
} else {
destination.FailoverPolicies = nil
}
// Id
destination.Id = genruntime.ClonePointerToString(account.Id)
// Identity
if account.Identity != nil {
var identity storage.ManagedServiceIdentity_STATUS
err := account.Identity.AssignProperties_To_ManagedServiceIdentity_STATUS(&identity)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_ManagedServiceIdentity_STATUS() to populate field Identity")
}
destination.Identity = &identity
} else {
destination.Identity = nil
}
// InstanceId
destination.InstanceId = genruntime.ClonePointerToString(account.InstanceId)
// IpRules
if account.IpRules != nil {
ipRuleList := make([]storage.IpAddressOrRange_STATUS, len(account.IpRules))
for ipRuleIndex, ipRuleItem := range account.IpRules {
// Shadow the loop variable to avoid aliasing
ipRuleItem := ipRuleItem
var ipRule storage.IpAddressOrRange_STATUS
err := ipRuleItem.AssignProperties_To_IpAddressOrRange_STATUS(&ipRule)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_IpAddressOrRange_STATUS() to populate field IpRules")
}
ipRuleList[ipRuleIndex] = ipRule
}
destination.IpRules = ipRuleList
} else {
destination.IpRules = nil
}
// IsVirtualNetworkFilterEnabled
if account.IsVirtualNetworkFilterEnabled != nil {
isVirtualNetworkFilterEnabled := *account.IsVirtualNetworkFilterEnabled
destination.IsVirtualNetworkFilterEnabled = &isVirtualNetworkFilterEnabled
} else {
destination.IsVirtualNetworkFilterEnabled = nil
}
// KeyVaultKeyUri
destination.KeyVaultKeyUri = genruntime.ClonePointerToString(account.KeyVaultKeyUri)
// KeysMetadata
if account.KeysMetadata != nil {
var keysMetadatum storage.DatabaseAccountKeysMetadata_STATUS
err := account.KeysMetadata.AssignProperties_To_DatabaseAccountKeysMetadata_STATUS(&keysMetadatum)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_DatabaseAccountKeysMetadata_STATUS() to populate field KeysMetadata")
}
destination.KeysMetadata = &keysMetadatum
} else {
destination.KeysMetadata = nil
}
// Kind
if account.Kind != nil {
kind := string(*account.Kind)
destination.Kind = &kind
} else {
destination.Kind = nil
}
// Location
destination.Location = genruntime.ClonePointerToString(account.Location)
// Locations
if account.Locations != nil {
locationList := make([]storage.Location_STATUS, len(account.Locations))
for locationIndex, locationItem := range account.Locations {
// Shadow the loop variable to avoid aliasing
locationItem := locationItem
var location storage.Location_STATUS
err := locationItem.AssignProperties_To_Location_STATUS(&location)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field Locations")
}
locationList[locationIndex] = location
}
destination.Locations = locationList
} else {
destination.Locations = nil
}
// MinimalTlsVersion
if account.MinimalTlsVersion != nil {
minimalTlsVersion := string(*account.MinimalTlsVersion)
destination.MinimalTlsVersion = &minimalTlsVersion
} else {
destination.MinimalTlsVersion = nil
}
// Name
destination.Name = genruntime.ClonePointerToString(account.Name)
// NetworkAclBypass
if account.NetworkAclBypass != nil {
networkAclBypass := string(*account.NetworkAclBypass)
destination.NetworkAclBypass = &networkAclBypass
} else {
destination.NetworkAclBypass = nil
}
// NetworkAclBypassResourceIds
destination.NetworkAclBypassResourceIds = genruntime.CloneSliceOfString(account.NetworkAclBypassResourceIds)
// PrivateEndpointConnections
if account.PrivateEndpointConnections != nil {
privateEndpointConnectionList := make([]storage.PrivateEndpointConnection_STATUS, len(account.PrivateEndpointConnections))
for privateEndpointConnectionIndex, privateEndpointConnectionItem := range account.PrivateEndpointConnections {
// Shadow the loop variable to avoid aliasing
privateEndpointConnectionItem := privateEndpointConnectionItem
var privateEndpointConnection storage.PrivateEndpointConnection_STATUS
err := privateEndpointConnectionItem.AssignProperties_To_PrivateEndpointConnection_STATUS(&privateEndpointConnection)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_PrivateEndpointConnection_STATUS() to populate field PrivateEndpointConnections")
}
privateEndpointConnectionList[privateEndpointConnectionIndex] = privateEndpointConnection
}
destination.PrivateEndpointConnections = privateEndpointConnectionList
} else {
destination.PrivateEndpointConnections = nil
}
// ProvisioningState
destination.ProvisioningState = genruntime.ClonePointerToString(account.ProvisioningState)
// PublicNetworkAccess
if account.PublicNetworkAccess != nil {
publicNetworkAccess := string(*account.PublicNetworkAccess)
destination.PublicNetworkAccess = &publicNetworkAccess
} else {
destination.PublicNetworkAccess = nil
}
// ReadLocations
if account.ReadLocations != nil {
readLocationList := make([]storage.Location_STATUS, len(account.ReadLocations))
for readLocationIndex, readLocationItem := range account.ReadLocations {
// Shadow the loop variable to avoid aliasing
readLocationItem := readLocationItem
var readLocation storage.Location_STATUS
err := readLocationItem.AssignProperties_To_Location_STATUS(&readLocation)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field ReadLocations")
}
readLocationList[readLocationIndex] = readLocation
}
destination.ReadLocations = readLocationList
} else {
destination.ReadLocations = nil
}
// RestoreParameters
if account.RestoreParameters != nil {
var restoreParameter storage.RestoreParameters_STATUS
err := account.RestoreParameters.AssignProperties_To_RestoreParameters_STATUS(&restoreParameter)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_RestoreParameters_STATUS() to populate field RestoreParameters")
}
destination.RestoreParameters = &restoreParameter
} else {
destination.RestoreParameters = nil
}
// SystemData
if account.SystemData != nil {
var systemDatum storage.SystemData_STATUS
err := account.SystemData.AssignProperties_To_SystemData_STATUS(&systemDatum)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_SystemData_STATUS() to populate field SystemData")
}
destination.SystemData = &systemDatum
} else {
destination.SystemData = nil
}
// Tags
destination.Tags = genruntime.CloneMapOfStringToString(account.Tags)
// Type
destination.Type = genruntime.ClonePointerToString(account.Type)
// VirtualNetworkRules
if account.VirtualNetworkRules != nil {
virtualNetworkRuleList := make([]storage.VirtualNetworkRule_STATUS, len(account.VirtualNetworkRules))
for virtualNetworkRuleIndex, virtualNetworkRuleItem := range account.VirtualNetworkRules {
// Shadow the loop variable to avoid aliasing
virtualNetworkRuleItem := virtualNetworkRuleItem
var virtualNetworkRule storage.VirtualNetworkRule_STATUS
err := virtualNetworkRuleItem.AssignProperties_To_VirtualNetworkRule_STATUS(&virtualNetworkRule)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_VirtualNetworkRule_STATUS() to populate field VirtualNetworkRules")
}
virtualNetworkRuleList[virtualNetworkRuleIndex] = virtualNetworkRule
}
destination.VirtualNetworkRules = virtualNetworkRuleList
} else {
destination.VirtualNetworkRules = nil
}
// WriteLocations
if account.WriteLocations != nil {
writeLocationList := make([]storage.Location_STATUS, len(account.WriteLocations))
for writeLocationIndex, writeLocationItem := range account.WriteLocations {
// Shadow the loop variable to avoid aliasing
writeLocationItem := writeLocationItem
var writeLocation storage.Location_STATUS
err := writeLocationItem.AssignProperties_To_Location_STATUS(&writeLocation)
if err != nil {
return eris.Wrap(err, "calling AssignProperties_To_Location_STATUS() to populate field WriteLocations")
}
writeLocationList[writeLocationIndex] = writeLocation
}
destination.WriteLocations = writeLocationList
} else {
destination.WriteLocations = nil
}
// Update the property bag
if len(propertyBag) > 0 {
destination.PropertyBag = propertyBag
} else {
destination.PropertyBag = nil
}
// No error
return nil
}