-
Notifications
You must be signed in to change notification settings - Fork 37
/
model_workloadprotectableitem.go
149 lines (127 loc) · 4.71 KB
/
model_workloadprotectableitem.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package backupprotectableitems
import (
"encoding/json"
"fmt"
"strings"
)
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
type WorkloadProtectableItem interface {
}
// RawWorkloadProtectableItemImpl is returned when the Discriminated Value
// doesn't match any of the defined types
// NOTE: this should only be used when a type isn't defined for this type of Object (as a workaround)
// and is used only for Deserialization (e.g. this cannot be used as a Request Payload).
type RawWorkloadProtectableItemImpl struct {
Type string
Values map[string]interface{}
}
func unmarshalWorkloadProtectableItemImplementation(input []byte) (WorkloadProtectableItem, error) {
if input == nil {
return nil, nil
}
var temp map[string]interface{}
if err := json.Unmarshal(input, &temp); err != nil {
return nil, fmt.Errorf("unmarshaling WorkloadProtectableItem into map[string]interface: %+v", err)
}
value, ok := temp["protectableItemType"].(string)
if !ok {
return nil, nil
}
if strings.EqualFold(value, "AzureFileShare") {
var out AzureFileShareProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureFileShareProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "Microsoft.ClassicCompute/virtualMachines") {
var out AzureIaaSClassicComputeVMProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureIaaSClassicComputeVMProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "Microsoft.Compute/virtualMachines") {
var out AzureIaaSComputeVMProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureIaaSComputeVMProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "AzureVmWorkloadProtectableItem") {
var out AzureVMWorkloadProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SAPAseSystem") {
var out AzureVMWorkloadSAPAseSystemProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSAPAseSystemProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SAPHanaDBInstance") {
var out AzureVMWorkloadSAPHanaDBInstance
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSAPHanaDBInstance: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SAPHanaDatabase") {
var out AzureVMWorkloadSAPHanaDatabaseProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSAPHanaDatabaseProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "HanaHSRContainer") {
var out AzureVMWorkloadSAPHanaHSRProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSAPHanaHSRProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SAPHanaSystem") {
var out AzureVMWorkloadSAPHanaSystemProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSAPHanaSystemProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SQLAvailabilityGroupContainer") {
var out AzureVMWorkloadSQLAvailabilityGroupProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSQLAvailabilityGroupProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SQLDataBase") {
var out AzureVMWorkloadSQLDatabaseProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSQLDatabaseProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "SQLInstance") {
var out AzureVMWorkloadSQLInstanceProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into AzureVMWorkloadSQLInstanceProtectableItem: %+v", err)
}
return out, nil
}
if strings.EqualFold(value, "IaaSVMProtectableItem") {
var out IaaSVMProtectableItem
if err := json.Unmarshal(input, &out); err != nil {
return nil, fmt.Errorf("unmarshaling into IaaSVMProtectableItem: %+v", err)
}
return out, nil
}
out := RawWorkloadProtectableItemImpl{
Type: value,
Values: temp,
}
return out, nil
}