generated from hashicorp/terraform-provider-scaffolding
-
Notifications
You must be signed in to change notification settings - Fork 3
/
enterprise_dns.go
93 lines (83 loc) · 2.68 KB
/
enterprise_dns.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
package client
import (
"context"
"encoding/json"
"fmt"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
u "net/url"
)
const enterpriseDNSEndpoint = "v1/enterprise_dns"
type EnterpriseDNS struct {
ID string `json:"id,omitempty"`
Name string `json:"name,omitempty"`
Description string `json:"description,omitempty"`
MappedDomains []MappedDomain `json:"mapped_domains,omitempty"`
}
func NewEnterpriseDNS(d *schema.ResourceData) *EnterpriseDNS {
res := &EnterpriseDNS{}
if d.HasChange("name") {
res.Name = d.Get("name").(string)
}
res.Description = d.Get("description").(string)
if d.HasChange("mapped_domains") {
res.MappedDomains = newMappedDomains(d)
}
return res
}
func newMappedDomains(d *schema.ResourceData) []MappedDomain {
mds := d.Get("mapped_domains").(*schema.Set)
resp := make([]MappedDomain, mds.Len())
for i, v := range mds.List() {
md := v.(map[string]interface{})
resp[i] = MappedDomain{Name: md["name"].(string), MappedDomain: md["mapped_domain"].(string)}
}
return resp
}
func parseEnterpriseDNS(resp []byte) (*EnterpriseDNS, error) {
ed := &EnterpriseDNS{}
err := json.Unmarshal(resp, ed)
if err != nil {
return nil, fmt.Errorf("could not parse enterprise dns response: %v", err)
}
return ed, nil
}
func CreateEnterpriseDNS(ctx context.Context, c *Client, ed *EnterpriseDNS) (*EnterpriseDNS, error) {
edUrl := fmt.Sprintf("%s/%s", c.BaseURL, enterpriseDNSEndpoint)
body, err := json.Marshal(ed)
if err != nil {
return nil, fmt.Errorf("could not convert enterprise dns to json: %v", err)
}
resp, err := c.Post(ctx, edUrl, body)
if err != nil {
return nil, err
}
return parseEnterpriseDNS(resp)
}
func UpdateEnterpriseDNS(ctx context.Context, c *Client, edID string, ed *EnterpriseDNS) (*EnterpriseDNS, error) {
edUrl := fmt.Sprintf("%s/%s/%s", c.BaseURL, enterpriseDNSEndpoint, edID)
body, err := json.Marshal(ed)
if err != nil {
return nil, fmt.Errorf("could not convert enterprise dns to json: %v", err)
}
resp, err := c.Patch(ctx, edUrl, body)
if err != nil {
return nil, err
}
return parseEnterpriseDNS(resp)
}
func GetEnterpriseDNS(ctx context.Context, c *Client, edID string) (*EnterpriseDNS, error) {
edUrl := fmt.Sprintf("%s/%s/%s", c.BaseURL, enterpriseDNSEndpoint, edID)
resp, err := c.Get(ctx, edUrl, u.Values{"expand": {"true"}})
if err != nil {
return nil, err
}
return parseEnterpriseDNS(resp)
}
func DeleteEnterpriseDNS(ctx context.Context, c *Client, edID string) (*EnterpriseDNS, error) {
edUrl := fmt.Sprintf("%s/%s/%s", c.BaseURL, enterpriseDNSEndpoint, edID)
resp, err := c.Delete(ctx, edUrl, nil)
if err != nil {
return nil, err
}
return parseEnterpriseDNS(resp)
}