/
api_op_ListAssignmentsForHIT.go
256 lines (219 loc) · 7.92 KB
/
api_op_ListAssignmentsForHIT.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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
// Code generated by smithy-go-codegen DO NOT EDIT.
package mturk
import (
"context"
"fmt"
awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
"github.com/aws/aws-sdk-go-v2/service/mturk/types"
"github.com/aws/smithy-go/middleware"
smithyhttp "github.com/aws/smithy-go/transport/http"
)
// The ListAssignmentsForHIT operation retrieves completed assignments for a HIT.
// You can use this operation to retrieve the results for a HIT. You can get
// assignments for a HIT at any time, even if the HIT is not yet Reviewable. If a
// HIT requested multiple assignments, and has received some results but has not
// yet become Reviewable, you can still retrieve the partial results with this
// operation. Use the AssignmentStatus parameter to control which set of
// assignments for a HIT are returned. The ListAssignmentsForHIT operation can
// return submitted assignments awaiting approval, or it can return assignments
// that have already been approved or rejected. You can set
// AssignmentStatus=Approved,Rejected to get assignments that have already been
// approved and rejected together in one result set. Only the Requester who created
// the HIT can retrieve the assignments for that HIT. Results are sorted and
// divided into numbered pages and the operation returns a single page of results.
// You can use the parameters of the operation to control sorting and pagination.
func (c *Client) ListAssignmentsForHIT(ctx context.Context, params *ListAssignmentsForHITInput, optFns ...func(*Options)) (*ListAssignmentsForHITOutput, error) {
if params == nil {
params = &ListAssignmentsForHITInput{}
}
result, metadata, err := c.invokeOperation(ctx, "ListAssignmentsForHIT", params, optFns, c.addOperationListAssignmentsForHITMiddlewares)
if err != nil {
return nil, err
}
out := result.(*ListAssignmentsForHITOutput)
out.ResultMetadata = metadata
return out, nil
}
type ListAssignmentsForHITInput struct {
// The ID of the HIT.
//
// This member is required.
HITId *string
// The status of the assignments to return: Submitted | Approved | Rejected
AssignmentStatuses []types.AssignmentStatus
MaxResults *int32
// Pagination token
NextToken *string
noSmithyDocumentSerde
}
type ListAssignmentsForHITOutput struct {
// The collection of Assignment data structures returned by this call.
Assignments []types.Assignment
// If the previous response was incomplete (because there is more data to
// retrieve), Amazon Mechanical Turk returns a pagination token in the response.
// You can use this pagination token to retrieve the next set of results.
NextToken *string
// The number of assignments on the page in the filtered results list, equivalent
// to the number of assignments returned by this call.
NumResults *int32
// Metadata pertaining to the operation's result.
ResultMetadata middleware.Metadata
noSmithyDocumentSerde
}
func (c *Client) addOperationListAssignmentsForHITMiddlewares(stack *middleware.Stack, options Options) (err error) {
if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
return err
}
err = stack.Serialize.Add(&awsAwsjson11_serializeOpListAssignmentsForHIT{}, middleware.After)
if err != nil {
return err
}
err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpListAssignmentsForHIT{}, middleware.After)
if err != nil {
return err
}
if err := addProtocolFinalizerMiddlewares(stack, options, "ListAssignmentsForHIT"); err != nil {
return fmt.Errorf("add protocol finalizers: %v", err)
}
if err = addlegacyEndpointContextSetter(stack, options); err != nil {
return err
}
if err = addSetLoggerMiddleware(stack, options); err != nil {
return err
}
if err = addClientRequestID(stack); err != nil {
return err
}
if err = addComputeContentLength(stack); err != nil {
return err
}
if err = addResolveEndpointMiddleware(stack, options); err != nil {
return err
}
if err = addComputePayloadSHA256(stack); err != nil {
return err
}
if err = addRetry(stack, options); err != nil {
return err
}
if err = addRawResponseToMetadata(stack); err != nil {
return err
}
if err = addRecordResponseTiming(stack); err != nil {
return err
}
if err = addClientUserAgent(stack, options); err != nil {
return err
}
if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
return err
}
if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
return err
}
if err = addOpListAssignmentsForHITValidationMiddleware(stack); err != nil {
return err
}
if err = stack.Initialize.Add(newServiceMetadataMiddleware_opListAssignmentsForHIT(options.Region), middleware.Before); err != nil {
return err
}
if err = addRecursionDetection(stack); err != nil {
return err
}
if err = addRequestIDRetrieverMiddleware(stack); err != nil {
return err
}
if err = addResponseErrorMiddleware(stack); err != nil {
return err
}
if err = addRequestResponseLogging(stack, options); err != nil {
return err
}
if err = addDisableHTTPSMiddleware(stack, options); err != nil {
return err
}
return nil
}
// ListAssignmentsForHITAPIClient is a client that implements the
// ListAssignmentsForHIT operation.
type ListAssignmentsForHITAPIClient interface {
ListAssignmentsForHIT(context.Context, *ListAssignmentsForHITInput, ...func(*Options)) (*ListAssignmentsForHITOutput, error)
}
var _ ListAssignmentsForHITAPIClient = (*Client)(nil)
// ListAssignmentsForHITPaginatorOptions is the paginator options for
// ListAssignmentsForHIT
type ListAssignmentsForHITPaginatorOptions struct {
Limit int32
// Set to true if pagination should stop if the service returns a pagination token
// that matches the most recent token provided to the service.
StopOnDuplicateToken bool
}
// ListAssignmentsForHITPaginator is a paginator for ListAssignmentsForHIT
type ListAssignmentsForHITPaginator struct {
options ListAssignmentsForHITPaginatorOptions
client ListAssignmentsForHITAPIClient
params *ListAssignmentsForHITInput
nextToken *string
firstPage bool
}
// NewListAssignmentsForHITPaginator returns a new ListAssignmentsForHITPaginator
func NewListAssignmentsForHITPaginator(client ListAssignmentsForHITAPIClient, params *ListAssignmentsForHITInput, optFns ...func(*ListAssignmentsForHITPaginatorOptions)) *ListAssignmentsForHITPaginator {
if params == nil {
params = &ListAssignmentsForHITInput{}
}
options := ListAssignmentsForHITPaginatorOptions{}
if params.MaxResults != nil {
options.Limit = *params.MaxResults
}
for _, fn := range optFns {
fn(&options)
}
return &ListAssignmentsForHITPaginator{
options: options,
client: client,
params: params,
firstPage: true,
nextToken: params.NextToken,
}
}
// HasMorePages returns a boolean indicating whether more pages are available
func (p *ListAssignmentsForHITPaginator) HasMorePages() bool {
return p.firstPage || (p.nextToken != nil && len(*p.nextToken) != 0)
}
// NextPage retrieves the next ListAssignmentsForHIT page.
func (p *ListAssignmentsForHITPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListAssignmentsForHITOutput, error) {
if !p.HasMorePages() {
return nil, fmt.Errorf("no more pages available")
}
params := *p.params
params.NextToken = p.nextToken
var limit *int32
if p.options.Limit > 0 {
limit = &p.options.Limit
}
params.MaxResults = limit
result, err := p.client.ListAssignmentsForHIT(ctx, ¶ms, optFns...)
if err != nil {
return nil, err
}
p.firstPage = false
prevToken := p.nextToken
p.nextToken = result.NextToken
if p.options.StopOnDuplicateToken &&
prevToken != nil &&
p.nextToken != nil &&
*prevToken == *p.nextToken {
p.nextToken = nil
}
return result, nil
}
func newServiceMetadataMiddleware_opListAssignmentsForHIT(region string) *awsmiddleware.RegisterServiceMetadata {
return &awsmiddleware.RegisterServiceMetadata{
Region: region,
ServiceID: ServiceID,
OperationName: "ListAssignmentsForHIT",
}
}