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
|
package groups
import (
"encoding/json"
"github.com/gophercloud/gophercloud"
"github.com/gophercloud/gophercloud/internal"
"github.com/gophercloud/gophercloud/pagination"
)
// Group helps manage related users.
type Group struct {
// Description describes the group purpose.
Description string `json:"description"`
// DomainID is the domain ID the group belongs to.
DomainID string `json:"domain_id"`
// ID is the unique ID of the group.
ID string `json:"id"`
// Extra is a collection of miscellaneous key/values.
Extra map[string]interface{} `json:"-"`
// Links contains referencing links to the group.
Links map[string]interface{} `json:"links"`
// Name is the name of the group.
Name string `json:"name"`
}
func (r *Group) UnmarshalJSON(b []byte) error {
type tmp Group
var s struct {
tmp
Extra map[string]interface{} `json:"extra"`
}
err := json.Unmarshal(b, &s)
if err != nil {
return err
}
*r = Group(s.tmp)
// Collect other fields and bundle them into Extra
// but only if a field titled "extra" wasn't sent.
if s.Extra != nil {
r.Extra = s.Extra
} else {
var result interface{}
err := json.Unmarshal(b, &result)
if err != nil {
return err
}
if resultMap, ok := result.(map[string]interface{}); ok {
r.Extra = internal.RemainingKeys(Group{}, resultMap)
}
}
return err
}
type groupResult struct {
gophercloud.Result
}
// GetResult is the response from a Get operation. Call its Extract method
// to interpret it as a Group.
type GetResult struct {
groupResult
}
// CreateResult is the response from a Create operation. Call its Extract method
// to interpret it as a Group.
type CreateResult struct {
groupResult
}
// UpdateResult is the response from an Update operation. Call its Extract
// method to interpret it as a Group.
type UpdateResult struct {
groupResult
}
// DeleteResult is the response from a Delete operation. Call its ExtractErr to
// determine if the request succeeded or failed.
type DeleteResult struct {
gophercloud.ErrResult
}
// GroupPage is a single page of Group results.
type GroupPage struct {
pagination.LinkedPageBase
}
// IsEmpty determines whether or not a page of Groups contains any results.
func (r GroupPage) IsEmpty() (bool, error) {
groups, err := ExtractGroups(r)
return len(groups) == 0, err
}
// NextPageURL extracts the "next" link from the links section of the result.
func (r GroupPage) NextPageURL() (string, error) {
var s struct {
Links struct {
Next string `json:"next"`
Previous string `json:"previous"`
} `json:"links"`
}
err := r.ExtractInto(&s)
if err != nil {
return "", err
}
return s.Links.Next, err
}
// ExtractGroups returns a slice of Groups contained in a single page of results.
func ExtractGroups(r pagination.Page) ([]Group, error) {
var s struct {
Groups []Group `json:"groups"`
}
err := (r.(GroupPage)).ExtractInto(&s)
return s.Groups, err
}
// Extract interprets any group results as a Group.
func (r groupResult) Extract() (*Group, error) {
var s struct {
Group *Group `json:"group"`
}
err := r.ExtractInto(&s)
return s.Group, err
}
|
