forked from hashicorp/terraform-provider-azurerm
-
Notifications
You must be signed in to change notification settings - Fork 0
/
id_authorizationrule.go
144 lines (122 loc) · 4.01 KB
/
id_authorizationrule.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
package eventhubs
import (
"fmt"
"strings"
"github.com/hashicorp/go-azure-helpers/resourcemanager/resourceids"
)
type AuthorizationRuleId struct {
SubscriptionId string
ResourceGroup string
NamespaceName string
EventhubName string
Name string
}
func NewAuthorizationRuleID(subscriptionId, resourceGroup, namespaceName, eventhubName, name string) AuthorizationRuleId {
return AuthorizationRuleId{
SubscriptionId: subscriptionId,
ResourceGroup: resourceGroup,
NamespaceName: namespaceName,
EventhubName: eventhubName,
Name: name,
}
}
func (id AuthorizationRuleId) String() string {
segments := []string{
fmt.Sprintf("Name %q", id.Name),
fmt.Sprintf("Eventhub Name %q", id.EventhubName),
fmt.Sprintf("Namespace Name %q", id.NamespaceName),
fmt.Sprintf("Resource Group %q", id.ResourceGroup),
}
segmentsStr := strings.Join(segments, " / ")
return fmt.Sprintf("%s: (%s)", "Authorization Rule", segmentsStr)
}
func (id AuthorizationRuleId) ID() string {
fmtString := "/subscriptions/%s/resourceGroups/%s/providers/Microsoft.EventHub/namespaces/%s/eventhubs/%s/authorizationRules/%s"
return fmt.Sprintf(fmtString, id.SubscriptionId, id.ResourceGroup, id.NamespaceName, id.EventhubName, id.Name)
}
// ParseAuthorizationRuleID parses a AuthorizationRule ID into an AuthorizationRuleId struct
func ParseAuthorizationRuleID(input string) (*AuthorizationRuleId, error) {
id, err := resourceids.ParseAzureResourceID(input)
if err != nil {
return nil, err
}
resourceId := AuthorizationRuleId{
SubscriptionId: id.SubscriptionID,
ResourceGroup: id.ResourceGroup,
}
if resourceId.SubscriptionId == "" {
return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
}
if resourceId.ResourceGroup == "" {
return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
}
if resourceId.NamespaceName, err = id.PopSegment("namespaces"); err != nil {
return nil, err
}
if resourceId.EventhubName, err = id.PopSegment("eventhubs"); err != nil {
return nil, err
}
if resourceId.Name, err = id.PopSegment("authorizationRules"); err != nil {
return nil, err
}
if err := id.ValidateNoEmptySegments(input); err != nil {
return nil, err
}
return &resourceId, nil
}
// ParseAuthorizationRuleIDInsensitively parses an AuthorizationRule ID into an AuthorizationRuleId struct, insensitively
// This should only be used to parse an ID for rewriting to a consistent casing,
// the ParseAuthorizationRuleID method should be used instead for validation etc.
func ParseAuthorizationRuleIDInsensitively(input string) (*AuthorizationRuleId, error) {
id, err := resourceids.ParseAzureResourceID(input)
if err != nil {
return nil, err
}
resourceId := AuthorizationRuleId{
SubscriptionId: id.SubscriptionID,
ResourceGroup: id.ResourceGroup,
}
if resourceId.SubscriptionId == "" {
return nil, fmt.Errorf("ID was missing the 'subscriptions' element")
}
if resourceId.ResourceGroup == "" {
return nil, fmt.Errorf("ID was missing the 'resourceGroups' element")
}
// find the correct casing for the 'namespaces' segment
namespacesKey := "namespaces"
for key := range id.Path {
if strings.EqualFold(key, namespacesKey) {
namespacesKey = key
break
}
}
if resourceId.NamespaceName, err = id.PopSegment(namespacesKey); err != nil {
return nil, err
}
// find the correct casing for the 'eventhubs' segment
eventhubsKey := "eventhubs"
for key := range id.Path {
if strings.EqualFold(key, eventhubsKey) {
eventhubsKey = key
break
}
}
if resourceId.EventhubName, err = id.PopSegment(eventhubsKey); err != nil {
return nil, err
}
// find the correct casing for the 'authorizationRules' segment
authorizationRulesKey := "authorizationRules"
for key := range id.Path {
if strings.EqualFold(key, authorizationRulesKey) {
authorizationRulesKey = key
break
}
}
if resourceId.Name, err = id.PopSegment(authorizationRulesKey); err != nil {
return nil, err
}
if err := id.ValidateNoEmptySegments(input); err != nil {
return nil, err
}
return &resourceId, nil
}