in v2/api/documentdb/v1api20210515/storage/database_account_types_gen.go [1663:2154]
func (account *DatabaseAccount_STATUS) AssignProperties_To_DatabaseAccount_STATUS(destination *storage.DatabaseAccount_STATUS) error {
// Clone the existing property bag
propertyBag := genruntime.NewPropertyBag(account.PropertyBag)
// 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 propertyBag.Contains("Capacity") {
var capacity storage.Capacity_STATUS
err := propertyBag.Pull("Capacity", &capacity)
if err != nil {
return eris.Wrap(err, "pulling 'Capacity' from propertyBag")
}
destination.Capacity = &capacity
} else {
destination.Capacity = nil
}
// Conditions
destination.Conditions = genruntime.CloneSliceOfCondition(account.Conditions)
// ConnectorOffer
destination.ConnectorOffer = genruntime.ClonePointerToString(account.ConnectorOffer)
// 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 propertyBag.Contains("CreateMode") {
var createMode string
err := propertyBag.Pull("CreateMode", &createMode)
if err != nil {
return eris.Wrap(err, "pulling 'CreateMode' from propertyBag")
}
destination.CreateMode = &createMode
} else {
destination.CreateMode = nil
}
// CustomerManagedKeyStatus
if propertyBag.Contains("CustomerManagedKeyStatus") {
var customerManagedKeyStatus string
err := propertyBag.Pull("CustomerManagedKeyStatus", &customerManagedKeyStatus)
if err != nil {
return eris.Wrap(err, "pulling 'CustomerManagedKeyStatus' from propertyBag")
}
destination.CustomerManagedKeyStatus = &customerManagedKeyStatus
} else {
destination.CustomerManagedKeyStatus = nil
}
// DatabaseAccountOfferType
destination.DatabaseAccountOfferType = genruntime.ClonePointerToString(account.DatabaseAccountOfferType)
// DefaultIdentity
destination.DefaultIdentity = genruntime.ClonePointerToString(account.DefaultIdentity)
// DisableKeyBasedMetadataWriteAccess
if account.DisableKeyBasedMetadataWriteAccess != nil {
disableKeyBasedMetadataWriteAccess := *account.DisableKeyBasedMetadataWriteAccess
destination.DisableKeyBasedMetadataWriteAccess = &disableKeyBasedMetadataWriteAccess
} else {
destination.DisableKeyBasedMetadataWriteAccess = nil
}
// DisableLocalAuth
if propertyBag.Contains("DisableLocalAuth") {
var disableLocalAuth bool
err := propertyBag.Pull("DisableLocalAuth", &disableLocalAuth)
if err != nil {
return eris.Wrap(err, "pulling 'DisableLocalAuth' from propertyBag")
}
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 propertyBag.Contains("EnableBurstCapacity") {
var enableBurstCapacity bool
err := propertyBag.Pull("EnableBurstCapacity", &enableBurstCapacity)
if err != nil {
return eris.Wrap(err, "pulling 'EnableBurstCapacity' from propertyBag")
}
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 propertyBag.Contains("EnablePartitionMerge") {
var enablePartitionMerge bool
err := propertyBag.Pull("EnablePartitionMerge", &enablePartitionMerge)
if err != nil {
return eris.Wrap(err, "pulling 'EnablePartitionMerge' from propertyBag")
}
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
if propertyBag.Contains("InstanceId") {
var instanceId string
err := propertyBag.Pull("InstanceId", &instanceId)
if err != nil {
return eris.Wrap(err, "pulling 'InstanceId' from propertyBag")
}
destination.InstanceId = &instanceId
} else {
destination.InstanceId = nil
}
// 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 propertyBag.Contains("KeysMetadata") {
var keysMetadatum storage.DatabaseAccountKeysMetadata_STATUS
err := propertyBag.Pull("KeysMetadata", &keysMetadatum)
if err != nil {
return eris.Wrap(err, "pulling 'KeysMetadata' from propertyBag")
}
destination.KeysMetadata = &keysMetadatum
} else {
destination.KeysMetadata = nil
}
// Kind
destination.Kind = genruntime.ClonePointerToString(account.Kind)
// 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 propertyBag.Contains("MinimalTlsVersion") {
var minimalTlsVersion string
err := propertyBag.Pull("MinimalTlsVersion", &minimalTlsVersion)
if err != nil {
return eris.Wrap(err, "pulling 'MinimalTlsVersion' from propertyBag")
}
destination.MinimalTlsVersion = &minimalTlsVersion
} else {
destination.MinimalTlsVersion = nil
}
// Name
destination.Name = genruntime.ClonePointerToString(account.Name)
// NetworkAclBypass
destination.NetworkAclBypass = genruntime.ClonePointerToString(account.NetworkAclBypass)
// 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
destination.PublicNetworkAccess = genruntime.ClonePointerToString(account.PublicNetworkAccess)
// 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 propertyBag.Contains("RestoreParameters") {
var restoreParameter storage.RestoreParameters_STATUS
err := propertyBag.Pull("RestoreParameters", &restoreParameter)
if err != nil {
return eris.Wrap(err, "pulling 'RestoreParameters' from propertyBag")
}
destination.RestoreParameters = &restoreParameter
} else {
destination.RestoreParameters = nil
}
// SystemData
if propertyBag.Contains("SystemData") {
var systemDatum storage.SystemData_STATUS
err := propertyBag.Pull("SystemData", &systemDatum)
if err != nil {
return eris.Wrap(err, "pulling 'SystemData' from propertyBag")
}
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
}
// Invoke the augmentConversionForDatabaseAccount_STATUS interface (if implemented) to customize the conversion
var accountAsAny any = account
if augmentedAccount, ok := accountAsAny.(augmentConversionForDatabaseAccount_STATUS); ok {
err := augmentedAccount.AssignPropertiesTo(destination)
if err != nil {
return eris.Wrap(err, "calling augmented AssignPropertiesTo() for conversion")
}
}
// No error
return nil
}