blib/lib/Paws/Honeycode.pm untested

filter: Statementstmt 0.0% 0 / 129 Branchbran 0.0% 0 / 16 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 22 Podpod 0.0% 0 / 21 totaltotal 0.0% 0 / 188 CC 9 SCAR 17.9
CC
9
Cov
0%
ListAllTableColumns
12.0
ListAllTableRows
12.0
ListAllTables
12.0
CRAP 6.0
1 package Paws::Honeycode;
2 use Moose;
3 sub service { 'honeycode' }
4 sub signing_name { 'honeycode' }
5 sub version { '2020-03-01' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub BatchCreateTableRows {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::Honeycode::BatchCreateTableRows', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub BatchDeleteTableRows {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::Honeycode::BatchDeleteTableRows', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub BatchUpdateTableRows {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::Honeycode::BatchUpdateTableRows', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub BatchUpsertTableRows {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::Honeycode::BatchUpsertTableRows', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub DescribeTableDataImportJob {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::Honeycode::DescribeTableDataImportJob', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub GetScreenData {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::Honeycode::GetScreenData', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub InvokeScreenAutomation {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::Honeycode::InvokeScreenAutomation', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub ListTableColumns {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::Honeycode::ListTableColumns', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub ListTableRows {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::Honeycode::ListTableRows', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub ListTables {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::Honeycode::ListTables', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub QueryTableRows {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::Honeycode::QueryTableRows', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub StartTableDataImportJob {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::Honeycode::StartTableDataImportJob', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77
78 sub ListAllTableColumns {
79 my $self = shift;
80  
81 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
82 my $result = $self->ListTableColumns(@_);
83 my $next_result = $result;
84  
85 if (not defined $callback) {
86 while ($next_result->nextToken) {
87 $next_result = $self->ListTableColumns(@_, nextToken => $next_result->nextToken);
88 push @{ $result->tableColumns }, @{ $next_result->tableColumns };
89 }
90 return $result;
91 } else {
92 while ($result->nextToken) {
93 $callback->($_ => 'tableColumns') foreach (@{ $result->tableColumns });
94 $result = $self->ListTableColumns(@_, nextToken => $result->nextToken);
95 }
96 $callback->($_ => 'tableColumns') foreach (@{ $result->tableColumns });
97 }
98  
99 return undef
100 }
101 sub ListAllTableRows {
102 my $self = shift;
103  
104 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
105 my $result = $self->ListTableRows(@_);
106 my $next_result = $result;
107  
108 if (not defined $callback) {
109 while ($next_result->nextToken) {
110 $next_result = $self->ListTableRows(@_, nextToken => $next_result->nextToken);
111 push @{ $result->rows }, @{ $next_result->rows };
112 }
113 return $result;
114 } else {
115 while ($result->nextToken) {
116 $callback->($_ => 'rows') foreach (@{ $result->rows });
117 $result = $self->ListTableRows(@_, nextToken => $result->nextToken);
118 }
119 $callback->($_ => 'rows') foreach (@{ $result->rows });
120 }
121  
122 return undef
123 }
124 sub ListAllTables {
125 my $self = shift;
126  
127 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
128 my $result = $self->ListTables(@_);
129 my $next_result = $result;
130  
131 if (not defined $callback) {
132 while ($next_result->nextToken) {
133 $next_result = $self->ListTables(@_, nextToken => $next_result->nextToken);
134 push @{ $result->tables }, @{ $next_result->tables };
135 }
136 return $result;
137 } else {
138 while ($result->nextToken) {
139 $callback->($_ => 'tables') foreach (@{ $result->tables });
140 $result = $self->ListTables(@_, nextToken => $result->nextToken);
141 }
142 $callback->($_ => 'tables') foreach (@{ $result->tables });
143 }
144  
145 return undef
146 }
147 sub QueryAllTableRows {
148 my $self = shift;
149  
150 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
151 my $result = $self->QueryTableRows(@_);
152 my $next_result = $result;
153  
154 if (not defined $callback) {
155 while ($next_result->nextToken) {
156 $next_result = $self->QueryTableRows(@_, nextToken => $next_result->nextToken);
157 push @{ $result->rows }, @{ $next_result->rows };
158 }
159 return $result;
160 } else {
161 while ($result->nextToken) {
162 $callback->($_ => 'rows') foreach (@{ $result->rows });
163 $result = $self->QueryTableRows(@_, nextToken => $result->nextToken);
164 }
165 $callback->($_ => 'rows') foreach (@{ $result->rows });
166 }
167  
168 return undef
169 }
170  
171  
172 sub operations { qw/BatchCreateTableRows BatchDeleteTableRows BatchUpdateTableRows BatchUpsertTableRows DescribeTableDataImportJob GetScreenData InvokeScreenAutomation ListTableColumns ListTableRows ListTables QueryTableRows StartTableDataImportJob / }
173  
174 1;
175  
176 ### main pod documentation begin ###
177  
178 =head1 NAME
179  
180 Paws::Honeycode - Perl Interface to AWS Amazon Honeycode
181  
182 =head1 SYNOPSIS
183  
184 use Paws;
185  
186 my $obj = Paws->service('Honeycode');
187 my $res = $obj->Method(
188 Arg1 => $val1,
189 Arg2 => [ 'V1', 'V2' ],
190 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
191 # of the arguments type
192 Arg3 => { Att1 => 'Val1' },
193 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
194 # the constructor of the arguments type
195 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
196 );
197  
198 =head1 DESCRIPTION
199  
200 Amazon Honeycode is a fully managed service that allows you to quickly
201 build mobile and web apps for teamsE<mdash>without programming. Build
202 Honeycode apps for managing almost anything, like projects, customers,
203 operations, approvals, resources, and even your team.
204  
205 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/honeycode-2020-03-01>
206  
207  
208 =head1 METHODS
209  
210 =head2 BatchCreateTableRows
211  
212 =over
213  
214 =item RowsToCreate => ArrayRef[L<Paws::Honeycode::CreateRowData>]
215  
216 =item TableId => Str
217  
218 =item WorkbookId => Str
219  
220 =item [ClientRequestToken => Str]
221  
222  
223 =back
224  
225 Each argument is described in detail in: L<Paws::Honeycode::BatchCreateTableRows>
226  
227 Returns: a L<Paws::Honeycode::BatchCreateTableRowsResult> instance
228  
229 The BatchCreateTableRows API allows you to create one or more rows at
230 the end of a table in a workbook. The API allows you to specify the
231 values to set in some or all of the columns in the new rows.
232  
233 If a column is not explicitly set in a specific row, then the column
234 level formula specified in the table will be applied to the new row. If
235 there is no column level formula but the last row of the table has a
236 formula, then that formula will be copied down to the new row. If there
237 is no column level formula and no formula in the last row of the table,
238 then that column will be left blank for the new rows.
239  
240  
241 =head2 BatchDeleteTableRows
242  
243 =over
244  
245 =item RowIds => ArrayRef[Str|Undef]
246  
247 =item TableId => Str
248  
249 =item WorkbookId => Str
250  
251 =item [ClientRequestToken => Str]
252  
253  
254 =back
255  
256 Each argument is described in detail in: L<Paws::Honeycode::BatchDeleteTableRows>
257  
258 Returns: a L<Paws::Honeycode::BatchDeleteTableRowsResult> instance
259  
260 The BatchDeleteTableRows API allows you to delete one or more rows from
261 a table in a workbook. You need to specify the ids of the rows that you
262 want to delete from the table.
263  
264  
265 =head2 BatchUpdateTableRows
266  
267 =over
268  
269 =item RowsToUpdate => ArrayRef[L<Paws::Honeycode::UpdateRowData>]
270  
271 =item TableId => Str
272  
273 =item WorkbookId => Str
274  
275 =item [ClientRequestToken => Str]
276  
277  
278 =back
279  
280 Each argument is described in detail in: L<Paws::Honeycode::BatchUpdateTableRows>
281  
282 Returns: a L<Paws::Honeycode::BatchUpdateTableRowsResult> instance
283  
284 The BatchUpdateTableRows API allows you to update one or more rows in a
285 table in a workbook.
286  
287 You can specify the values to set in some or all of the columns in the
288 table for the specified rows. If a column is not explicitly specified
289 in a particular row, then that column will not be updated for that row.
290 To clear out the data in a specific cell, you need to set the value as
291 an empty string ("").
292  
293  
294 =head2 BatchUpsertTableRows
295  
296 =over
297  
298 =item RowsToUpsert => ArrayRef[L<Paws::Honeycode::UpsertRowData>]
299  
300 =item TableId => Str
301  
302 =item WorkbookId => Str
303  
304 =item [ClientRequestToken => Str]
305  
306  
307 =back
308  
309 Each argument is described in detail in: L<Paws::Honeycode::BatchUpsertTableRows>
310  
311 Returns: a L<Paws::Honeycode::BatchUpsertTableRowsResult> instance
312  
313 The BatchUpsertTableRows API allows you to upsert one or more rows in a
314 table. The upsert operation takes a filter expression as input and
315 evaluates it to find matching rows on the destination table. If
316 matching rows are found, it will update the cells in the matching rows
317 to new values specified in the request. If no matching rows are found,
318 a new row is added at the end of the table and the cells in that row
319 are set to the new values specified in the request.
320  
321 You can specify the values to set in some or all of the columns in the
322 table for the matching or newly appended rows. If a column is not
323 explicitly specified for a particular row, then that column will not be
324 updated for that row. To clear out the data in a specific cell, you
325 need to set the value as an empty string ("").
326  
327  
328 =head2 DescribeTableDataImportJob
329  
330 =over
331  
332 =item JobId => Str
333  
334 =item TableId => Str
335  
336 =item WorkbookId => Str
337  
338  
339 =back
340  
341 Each argument is described in detail in: L<Paws::Honeycode::DescribeTableDataImportJob>
342  
343 Returns: a L<Paws::Honeycode::DescribeTableDataImportJobResult> instance
344  
345 The DescribeTableDataImportJob API allows you to retrieve the status
346 and details of a table data import job.
347  
348  
349 =head2 GetScreenData
350  
351 =over
352  
353 =item AppId => Str
354  
355 =item ScreenId => Str
356  
357 =item WorkbookId => Str
358  
359 =item [MaxResults => Int]
360  
361 =item [NextToken => Str]
362  
363 =item [Variables => L<Paws::Honeycode::VariableValueMap>]
364  
365  
366 =back
367  
368 Each argument is described in detail in: L<Paws::Honeycode::GetScreenData>
369  
370 Returns: a L<Paws::Honeycode::GetScreenDataResult> instance
371  
372 The GetScreenData API allows retrieval of data from a screen in a
373 Honeycode app. The API allows setting local variables in the screen to
374 filter, sort or otherwise affect what will be displayed on the screen.
375  
376  
377 =head2 InvokeScreenAutomation
378  
379 =over
380  
381 =item AppId => Str
382  
383 =item ScreenAutomationId => Str
384  
385 =item ScreenId => Str
386  
387 =item WorkbookId => Str
388  
389 =item [ClientRequestToken => Str]
390  
391 =item [RowId => Str]
392  
393 =item [Variables => L<Paws::Honeycode::VariableValueMap>]
394  
395  
396 =back
397  
398 Each argument is described in detail in: L<Paws::Honeycode::InvokeScreenAutomation>
399  
400 Returns: a L<Paws::Honeycode::InvokeScreenAutomationResult> instance
401  
402 The InvokeScreenAutomation API allows invoking an action defined in a
403 screen in a Honeycode app. The API allows setting local variables,
404 which can then be used in the automation being invoked. This allows
405 automating the Honeycode app interactions to write, update or delete
406 data in the workbook.
407  
408  
409 =head2 ListTableColumns
410  
411 =over
412  
413 =item TableId => Str
414  
415 =item WorkbookId => Str
416  
417 =item [NextToken => Str]
418  
419  
420 =back
421  
422 Each argument is described in detail in: L<Paws::Honeycode::ListTableColumns>
423  
424 Returns: a L<Paws::Honeycode::ListTableColumnsResult> instance
425  
426 The ListTableColumns API allows you to retrieve a list of all the
427 columns in a table in a workbook.
428  
429  
430 =head2 ListTableRows
431  
432 =over
433  
434 =item TableId => Str
435  
436 =item WorkbookId => Str
437  
438 =item [MaxResults => Int]
439  
440 =item [NextToken => Str]
441  
442 =item [RowIds => ArrayRef[Str|Undef]]
443  
444  
445 =back
446  
447 Each argument is described in detail in: L<Paws::Honeycode::ListTableRows>
448  
449 Returns: a L<Paws::Honeycode::ListTableRowsResult> instance
450  
451 The ListTableRows API allows you to retrieve a list of all the rows in
452 a table in a workbook.
453  
454  
455 =head2 ListTables
456  
457 =over
458  
459 =item WorkbookId => Str
460  
461 =item [MaxResults => Int]
462  
463 =item [NextToken => Str]
464  
465  
466 =back
467  
468 Each argument is described in detail in: L<Paws::Honeycode::ListTables>
469  
470 Returns: a L<Paws::Honeycode::ListTablesResult> instance
471  
472 The ListTables API allows you to retrieve a list of all the tables in a
473 workbook.
474  
475  
476 =head2 QueryTableRows
477  
478 =over
479  
480 =item FilterFormula => L<Paws::Honeycode::Filter>
481  
482 =item TableId => Str
483  
484 =item WorkbookId => Str
485  
486 =item [MaxResults => Int]
487  
488 =item [NextToken => Str]
489  
490  
491 =back
492  
493 Each argument is described in detail in: L<Paws::Honeycode::QueryTableRows>
494  
495 Returns: a L<Paws::Honeycode::QueryTableRowsResult> instance
496  
497 The QueryTableRows API allows you to use a filter formula to query for
498 specific rows in a table.
499  
500  
501 =head2 StartTableDataImportJob
502  
503 =over
504  
505 =item ClientRequestToken => Str
506  
507 =item DataFormat => Str
508  
509 =item DataSource => L<Paws::Honeycode::ImportDataSource>
510  
511 =item DestinationTableId => Str
512  
513 =item ImportOptions => L<Paws::Honeycode::ImportOptions>
514  
515 =item WorkbookId => Str
516  
517  
518 =back
519  
520 Each argument is described in detail in: L<Paws::Honeycode::StartTableDataImportJob>
521  
522 Returns: a L<Paws::Honeycode::StartTableDataImportJobResult> instance
523  
524 The StartTableDataImportJob API allows you to start an import job on a
525 table. This API will only return the id of the job that was started. To
526 find out the status of the import request, you need to call the
527 DescribeTableDataImportJob API.
528  
529  
530  
531  
532 =head1 PAGINATORS
533  
534 Paginator methods are helpers that repetively call methods that return partial results
535  
536 =head2 ListAllTableColumns(sub { },TableId => Str, WorkbookId => Str, [NextToken => Str])
537  
538 =head2 ListAllTableColumns(TableId => Str, WorkbookId => Str, [NextToken => Str])
539  
540  
541 If passed a sub as first parameter, it will call the sub for each element found in :
542  
543 - tableColumns, passing the object as the first parameter, and the string 'tableColumns' as the second parameter
544  
545 If not, it will return a a L<Paws::Honeycode::ListTableColumnsResult> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
546  
547  
548 =head2 ListAllTableRows(sub { },TableId => Str, WorkbookId => Str, [MaxResults => Int, NextToken => Str, RowIds => ArrayRef[Str|Undef]])
549  
550 =head2 ListAllTableRows(TableId => Str, WorkbookId => Str, [MaxResults => Int, NextToken => Str, RowIds => ArrayRef[Str|Undef]])
551  
552  
553 If passed a sub as first parameter, it will call the sub for each element found in :
554  
555 - rows, passing the object as the first parameter, and the string 'rows' as the second parameter
556  
557 If not, it will return a a L<Paws::Honeycode::ListTableRowsResult> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
558  
559  
560 =head2 ListAllTables(sub { },WorkbookId => Str, [MaxResults => Int, NextToken => Str])
561  
562 =head2 ListAllTables(WorkbookId => Str, [MaxResults => Int, NextToken => Str])
563  
564  
565 If passed a sub as first parameter, it will call the sub for each element found in :
566  
567 - tables, passing the object as the first parameter, and the string 'tables' as the second parameter
568  
569 If not, it will return a a L<Paws::Honeycode::ListTablesResult> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
570  
571  
572 =head2 QueryAllTableRows(sub { },FilterFormula => L<Paws::Honeycode::Filter>, TableId => Str, WorkbookId => Str, [MaxResults => Int, NextToken => Str])
573  
574 =head2 QueryAllTableRows(FilterFormula => L<Paws::Honeycode::Filter>, TableId => Str, WorkbookId => Str, [MaxResults => Int, NextToken => Str])
575  
576  
577 If passed a sub as first parameter, it will call the sub for each element found in :
578  
579 - rows, passing the object as the first parameter, and the string 'rows' as the second parameter
580  
581 If not, it will return a a L<Paws::Honeycode::QueryTableRowsResult> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
582  
583  
584  
585  
586  
587 =head1 SEE ALSO
588  
589 This service class forms part of L<Paws>
590  
591 =head1 BUGS and CONTRIBUTIONS
592  
593 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
594  
595 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
596  
597 =cut
598