forked from g8rswimmer/go-sfdc
-
Notifications
You must be signed in to change notification settings - Fork 0
/
batch.go
159 lines (138 loc) · 4.04 KB
/
batch.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
150
151
152
153
154
155
156
157
158
159
package batch
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"net/http"
"github.com/g8rswimmer/go-sfdc"
"github.com/g8rswimmer/go-sfdc/session"
)
// Subrequester provides the composite batch API requests.
type Subrequester interface {
URL() string
Method() string
BinaryPartName() string
BinaryPartNameAlias() string
RichInput() map[string]interface{}
}
// Value is the returned structure from the composite batch API response.
type Value struct {
HasErrors bool `json:"hasErrors"`
Results []Subvalue `json:"results"`
}
// Subvalue is the subresponses to the composite batch API.
type Subvalue struct {
Result interface{} `json:"result"`
StatusCode int `json:"statusCode"`
}
const endpoint = "/composite/batch"
var validMethods = map[string]struct{}{
"PUT": {},
"POST": {},
"PATCH": {},
"GET": {},
"DELETE": {},
}
// Resource is the structure that can be just to call composite batch APIs.
type Resource struct {
session session.ServiceFormatter
}
// NewResource creates a new resourse with the session. If the session is
// nil an error will be returned.
func NewResource(session session.ServiceFormatter) (*Resource, error) {
if session == nil {
return nil, errors.New("composite: session can not be nil")
}
return &Resource{
session: session,
}, nil
}
// Retrieve will retrieve the responses to a composite batch requests. The
// order of the array is the order in which the subrequests are
// placed in the composite batch body.
func (r *Resource) Retrieve(haltOnError bool, requesters []Subrequester) (Value, error) {
if requesters == nil {
return Value{}, errors.New("composite subrequests: requesters can not nil")
}
err := r.validateSubrequests(requesters)
if err != nil {
return Value{}, err
}
body, err := r.payload(haltOnError, requesters)
if err != nil {
return Value{}, err
}
url := r.session.ServiceURL() + endpoint
request, err := http.NewRequest(http.MethodPost, url, body)
if err != nil {
return Value{}, err
}
request.Header.Add("Accept", "application/json")
request.Header.Add("Content-Type", "application/json")
r.session.AuthorizationHeader(request)
response, err := r.session.Client().Do(request)
if err != nil {
return Value{}, err
}
decoder := json.NewDecoder(response.Body)
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
var insertErrs []sfdc.Error
err = decoder.Decode(&insertErrs)
var errMsg error
if err == nil {
for _, insertErr := range insertErrs {
errMsg = fmt.Errorf("insert response err: %s: %s", insertErr.ErrorCode, insertErr.Message)
}
} else {
errMsg = fmt.Errorf("insert response err: %d %s", response.StatusCode, response.Status)
}
return Value{}, errMsg
}
var value Value
err = decoder.Decode(&value)
if err != nil {
return Value{}, err
}
return value, nil
}
func (r *Resource) validateSubrequests(requesters []Subrequester) error {
for _, requester := range requesters {
if requester.URL() == "" {
return errors.New("composite subrequest: must contain a url")
}
if _, has := validMethods[requester.Method()]; has == false {
return errors.New("composite subrequest: empty or invalid method " + requester.Method())
}
}
return nil
}
func (r *Resource) payload(haltOnError bool, requesters []Subrequester) (*bytes.Reader, error) {
subRequests := make([]interface{}, len(requesters))
for idx, requester := range requesters {
subRequest := map[string]interface{}{
"url": requester.URL(),
"method": requester.Method(),
}
if requester.BinaryPartName() != "" {
subRequest["binaryPartName"] = requester.BinaryPartName()
}
if requester.BinaryPartNameAlias() != "" {
subRequest["binaryPartNameAlias"] = requester.BinaryPartNameAlias()
}
if requester.RichInput() != nil {
subRequest["richInput"] = requester.RichInput()
}
subRequests[idx] = subRequest
}
payload := map[string]interface{}{
"haltOnError": haltOnError,
"batchRequests": subRequests,
}
jsonBody, err := json.Marshal(payload)
if err != nil {
return nil, err
}
return bytes.NewReader(jsonBody), nil
}