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 orders
import (
"time"
"github.com/gophercloud/gophercloud"
"github.com/gophercloud/gophercloud/pagination"
)
// OrderType represents the valid types of orders.
type OrderType string
const (
KeyOrder OrderType = "key"
AsymmetricOrder OrderType = "asymmetric"
)
// ListOptsBuilder allows extensions to add additional parameters to
// the List request
type ListOptsBuilder interface {
ToOrderListQuery() (string, error)
}
// ListOpts provides options to filter the List results.
type ListOpts struct {
// Limit is the amount of containers to retrieve.
Limit int `q:"limit"`
// Offset is the index within the list to retrieve.
Offset int `q:"offset"`
}
// ToOrderListQuery formats a ListOpts into a query string.
func (opts ListOpts) ToOrderListQuery() (string, error) {
q, err := gophercloud.BuildQueryString(opts)
return q.String(), err
}
// List retrieves a list of orders.
func List(client *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
url := listURL(client)
if opts != nil {
query, err := opts.ToOrderListQuery()
if err != nil {
return pagination.Pager{Err: err}
}
url += query
}
return pagination.NewPager(client, url, func(r pagination.PageResult) pagination.Page {
return OrderPage{pagination.LinkedPageBase{PageResult: r}}
})
}
// Get retrieves details of a orders.
func Get(client *gophercloud.ServiceClient, id string) (r GetResult) {
resp, err := client.Get(getURL(client, id), &r.Body, nil)
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// CreateOptsBuilder allows extensions to add additional parameters to
// the Create request.
type CreateOptsBuilder interface {
ToOrderCreateMap() (map[string]interface{}, error)
}
// MetaOpts represents options used for creating an order.
type MetaOpts struct {
// Algorithm is the algorithm of the secret.
Algorithm string `json:"algorithm"`
// BitLength is the bit length of the secret.
BitLength int `json:"bit_length"`
// Expiration is the expiration date of the order.
Expiration *time.Time `json:"-"`
// Mode is the mode of the secret.
Mode string `json:"mode"`
// Name is the name of the secret.
Name string `json:"name,omitempty"`
// PayloadContentType is the content type of the secret payload.
PayloadContentType string `json:"payload_content_type,omitempty"`
}
// CreateOpts provides options used to create a orders.
type CreateOpts struct {
// Type is the type of order to create.
Type OrderType `json:"type"`
// Meta contains secrets data to create a secret.
Meta MetaOpts `json:"meta"`
}
// ToOrderCreateMap formats a CreateOpts into a create request.
func (opts CreateOpts) ToOrderCreateMap() (map[string]interface{}, error) {
b, err := gophercloud.BuildRequestBody(opts, "")
if err != nil {
return nil, err
}
if opts.Meta.Expiration != nil {
meta := b["meta"].(map[string]interface{})
meta["expiration"] = opts.Meta.Expiration.Format(gophercloud.RFC3339NoZ)
b["meta"] = meta
}
return b, nil
}
// Create creates a new orders.
func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
b, err := opts.ToOrderCreateMap()
if err != nil {
r.Err = err
return
}
resp, err := client.Post(createURL(client), &b, &r.Body, &gophercloud.RequestOpts{
OkCodes: []int{202},
})
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
// Delete deletes a orders.
func Delete(client *gophercloud.ServiceClient, id string) (r DeleteResult) {
resp, err := client.Delete(deleteURL(client, id), nil)
_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
return
}
|
