ThreeDCloudApi.pm untested

filter: Statementstmt 0.0% 0 / 905 Branchbran 0.0% 0 / 386 Conditioncond 0.0% 0 / 6 MC/DCmcdc 0.0% 0 / 3 Subroutinesub 0.0% 0 / 36 Podpod 0.0% 0 / 27 totaltotal 0.0% 0 / 1363 CC 194 SCAR 45.7
CC
194
Cov
0%
post_save_as_part
210.0
post_triangulate_part
182.0
post_convert_by_format
156.0
CRAP 96.5
1 =begin comment
2
3 Aspose.3D Cloud API Reference
4
5 No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
6
7 OpenAPI spec version: 3.0
8
9 Generated by: https://github.com/swagger-api/swagger-codegen.git
10
11 =end comment
12
13 =cut
14
15 #
16 # NOTE: This class is auto generated by the swagger code generator program.
17 # Do not edit the class manually.
18 # Ref: https://github.com/swagger-api/swagger-codegen
19 #
20 package AsposeThreeDCloud::ThreeDCloudApi;
21
22 require 5.6.0;
23 use strict;
24 use warnings;
25 use utf8;
26 use Exporter;
27 use Carp qw( croak );
28 use Log::Any qw($log);
29
30 use AsposeThreeDCloud::ApiClient;
31
32 use base "Class::Data::Inheritable";
33
34 __PACKAGE__->mk_classdata('method_documentation' => {});
35
36 sub new {
37 my $class = shift;
38 my $api_client;
39
40 if ($_[0] && ref $_[0] && ref $_[0] eq 'AsposeThreeDCloud::ApiClient' ) {
41 $api_client = $_[0];
42 } else {
43 $api_client = AsposeThreeDCloud::ApiClient->new(@_);
44 }
45
46 bless { api_client => $api_client }, $class;
47
48 }
49
50
51 #
52 # copy_file
53 #
54 # Copy file
55 #
56 # @param string $src_path Source file path e.g. '/folder/file.ext' (required)
57 # @param string $dest_path Destination file path (required)
58 # @param string $src_storage_name Source storage name (optional)
59 # @param string $dest_storage_name Destination storage name (optional)
60 # @param string $version_id File version ID to copy (optional)
61 {
62 my $params = {
63 'src_path' => {
64 data_type => 'string',
65 description => 'Source file path e.g. '/folder/file.ext'',
66 required => '1',
67 },
68 'dest_path' => {
69 data_type => 'string',
70 description => 'Destination file path',
71 required => '1',
72 },
73 'src_storage_name' => {
74 data_type => 'string',
75 description => 'Source storage name',
76 required => '0',
77 },
78 'dest_storage_name' => {
79 data_type => 'string',
80 description => 'Destination storage name',
81 required => '0',
82 },
83 'version_id' => {
84 data_type => 'string',
85 description => 'File version ID to copy',
86 required => '0',
87 },
88 };
89 __PACKAGE__->method_documentation->{ 'copy_file' } = {
90 summary => 'Copy file',
91 params => $params,
92 returns => undef,
93 };
94 }
95 # @return void
96 #
97 sub copy_file {
98 my ($self, %args) = @_;
99
100 # verify the required parameter 'src_path' is set
101 unless (exists $args{'src_path'}) {
102 croak("Missing the required parameter 'src_path' when calling copy_file");
103 }
104
105 # verify the required parameter 'dest_path' is set
106 unless (exists $args{'dest_path'}) {
107 croak("Missing the required parameter 'dest_path' when calling copy_file");
108 }
109
110 # parse inputs
111 my $_resource_path = '/3d/storage/file/copy/{srcPath}';
112
113 my $_method = 'PUT';
114 my $query_params = {};
115 my $header_params = {};
116 my $form_params = {};
117
118 # 'Accept' and 'Content-Type' header
119 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
120 if ($_header_accept) {
121 $header_params->{'Accept'} = $_header_accept;
122 }
123 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
124
125 # query params
126 if ( exists $args{'dest_path'}) {
127 $query_params->{'destPath'} = $self->{api_client}->to_query_value($args{'dest_path'});
128 }
129
130 # query params
131 if ( exists $args{'src_storage_name'}) {
132 $query_params->{'srcStorageName'} = $self->{api_client}->to_query_value($args{'src_storage_name'});
133 }
134
135 # query params
136 if ( exists $args{'dest_storage_name'}) {
137 $query_params->{'destStorageName'} = $self->{api_client}->to_query_value($args{'dest_storage_name'});
138 }
139
140 # query params
141 if ( exists $args{'version_id'}) {
142 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
143 }
144
145 # path params
146 if ( exists $args{'src_path'}) {
147 my $_base_variable = "{" . "srcPath" . "}";
148 my $_base_value = $self->{api_client}->to_path_value($args{'src_path'});
149 $_resource_path =~ s/$_base_variable/$_base_value/g;
150 }
151
152 my $_body_data;
153 # authentication setting, if any
154 my $auth_settings = [qw(JWT )];
155
156 # make the API Call
157 $self->{api_client}->call_api($_resource_path, $_method,
158 $query_params, $form_params,
159 $header_params, $_body_data, $auth_settings);
160 return;
161 }
162
163 #
164 # copy_folder
165 #
166 # Copy folder
167 #
168 # @param string $src_path Source folder path e.g. '/src' (required)
169 # @param string $dest_path Destination folder path e.g. '/dst' (required)
170 # @param string $src_storage_name Source storage name (optional)
171 # @param string $dest_storage_name Destination storage name (optional)
172 {
173 my $params = {
174 'src_path' => {
175 data_type => 'string',
176 description => 'Source folder path e.g. '/src'',
177 required => '1',
178 },
179 'dest_path' => {
180 data_type => 'string',
181 description => 'Destination folder path e.g. '/dst'',
182 required => '1',
183 },
184 'src_storage_name' => {
185 data_type => 'string',
186 description => 'Source storage name',
187 required => '0',
188 },
189 'dest_storage_name' => {
190 data_type => 'string',
191 description => 'Destination storage name',
192 required => '0',
193 },
194 };
195 __PACKAGE__->method_documentation->{ 'copy_folder' } = {
196 summary => 'Copy folder',
197 params => $params,
198 returns => undef,
199 };
200 }
201 # @return void
202 #
203 sub copy_folder {
204 my ($self, %args) = @_;
205
206 # verify the required parameter 'src_path' is set
207 unless (exists $args{'src_path'}) {
208 croak("Missing the required parameter 'src_path' when calling copy_folder");
209 }
210
211 # verify the required parameter 'dest_path' is set
212 unless (exists $args{'dest_path'}) {
213 croak("Missing the required parameter 'dest_path' when calling copy_folder");
214 }
215
216 # parse inputs
217 my $_resource_path = '/3d/storage/folder/copy/{srcPath}';
218
219 my $_method = 'PUT';
220 my $query_params = {};
221 my $header_params = {};
222 my $form_params = {};
223
224 # 'Accept' and 'Content-Type' header
225 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
226 if ($_header_accept) {
227 $header_params->{'Accept'} = $_header_accept;
228 }
229 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
230
231 # query params
232 if ( exists $args{'dest_path'}) {
233 $query_params->{'destPath'} = $self->{api_client}->to_query_value($args{'dest_path'});
234 }
235
236 # query params
237 if ( exists $args{'src_storage_name'}) {
238 $query_params->{'srcStorageName'} = $self->{api_client}->to_query_value($args{'src_storage_name'});
239 }
240
241 # query params
242 if ( exists $args{'dest_storage_name'}) {
243 $query_params->{'destStorageName'} = $self->{api_client}->to_query_value($args{'dest_storage_name'});
244 }
245
246 # path params
247 if ( exists $args{'src_path'}) {
248 my $_base_variable = "{" . "srcPath" . "}";
249 my $_base_value = $self->{api_client}->to_path_value($args{'src_path'});
250 $_resource_path =~ s/$_base_variable/$_base_value/g;
251 }
252
253 my $_body_data;
254 # authentication setting, if any
255 my $auth_settings = [qw(JWT )];
256
257 # make the API Call
258 $self->{api_client}->call_api($_resource_path, $_method,
259 $query_params, $form_params,
260 $header_params, $_body_data, $auth_settings);
261 return;
262 }
263
264 #
265 # create_folder
266 #
267 # Create the folder
268 #
269 # @param string $path Folder path to create e.g. 'folder_1/folder_2/' (required)
270 # @param string $storage_name Storage name (optional)
271 {
272 my $params = {
273 'path' => {
274 data_type => 'string',
275 description => 'Folder path to create e.g. 'folder_1/folder_2/'',
276 required => '1',
277 },
278 'storage_name' => {
279 data_type => 'string',
280 description => 'Storage name',
281 required => '0',
282 },
283 };
284 __PACKAGE__->method_documentation->{ 'create_folder' } = {
285 summary => 'Create the folder',
286 params => $params,
287 returns => undef,
288 };
289 }
290 # @return void
291 #
292 sub create_folder {
293 my ($self, %args) = @_;
294
295 # verify the required parameter 'path' is set
296 unless (exists $args{'path'}) {
297 croak("Missing the required parameter 'path' when calling create_folder");
298 }
299
300 # parse inputs
301 my $_resource_path = '/3d/storage/folder/{path}';
302
303 my $_method = 'PUT';
304 my $query_params = {};
305 my $header_params = {};
306 my $form_params = {};
307
308 # 'Accept' and 'Content-Type' header
309 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
310 if ($_header_accept) {
311 $header_params->{'Accept'} = $_header_accept;
312 }
313 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
314
315 # query params
316 if ( exists $args{'storage_name'}) {
317 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
318 }
319
320 # path params
321 if ( exists $args{'path'}) {
322 my $_base_variable = "{" . "path" . "}";
323 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
324 $_resource_path =~ s/$_base_variable/$_base_value/g;
325 }
326
327 my $_body_data;
328 # authentication setting, if any
329 my $auth_settings = [qw(JWT )];
330
331 # make the API Call
332 $self->{api_client}->call_api($_resource_path, $_method,
333 $query_params, $form_params,
334 $header_params, $_body_data, $auth_settings);
335 return;
336 }
337
338 #
339 # delete_file
340 #
341 # Delete file
342 #
343 # @param string $path File path e.g. '/folder/file.ext' (required)
344 # @param string $storage_name Storage name (optional)
345 # @param string $version_id File version ID to delete (optional)
346 {
347 my $params = {
348 'path' => {
349 data_type => 'string',
350 description => 'File path e.g. '/folder/file.ext'',
351 required => '1',
352 },
353 'storage_name' => {
354 data_type => 'string',
355 description => 'Storage name',
356 required => '0',
357 },
358 'version_id' => {
359 data_type => 'string',
360 description => 'File version ID to delete',
361 required => '0',
362 },
363 };
364 __PACKAGE__->method_documentation->{ 'delete_file' } = {
365 summary => 'Delete file',
366 params => $params,
367 returns => undef,
368 };
369 }
370 # @return void
371 #
372 sub delete_file {
373 my ($self, %args) = @_;
374
375 # verify the required parameter 'path' is set
376 unless (exists $args{'path'}) {
377 croak("Missing the required parameter 'path' when calling delete_file");
378 }
379
380 # parse inputs
381 my $_resource_path = '/3d/storage/file/{path}';
382
383 my $_method = 'DELETE';
384 my $query_params = {};
385 my $header_params = {};
386 my $form_params = {};
387
388 # 'Accept' and 'Content-Type' header
389 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
390 if ($_header_accept) {
391 $header_params->{'Accept'} = $_header_accept;
392 }
393 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
394
395 # query params
396 if ( exists $args{'storage_name'}) {
397 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
398 }
399
400 # query params
401 if ( exists $args{'version_id'}) {
402 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
403 }
404
405 # path params
406 if ( exists $args{'path'}) {
407 my $_base_variable = "{" . "path" . "}";
408 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
409 $_resource_path =~ s/$_base_variable/$_base_value/g;
410 }
411
412 my $_body_data;
413 # authentication setting, if any
414 my $auth_settings = [qw(JWT )];
415
416 # make the API Call
417 $self->{api_client}->call_api($_resource_path, $_method,
418 $query_params, $form_params,
419 $header_params, $_body_data, $auth_settings);
420 return;
421 }
422
423 #
424 # delete_folder
425 #
426 # Delete folder
427 #
428 # @param string $path Folder path e.g. '/folder' (required)
429 # @param string $storage_name Storage name (optional)
430 # @param boolean $recursive Enable to delete folders, subfolders and files (optional, default to false)
431 {
432 my $params = {
433 'path' => {
434 data_type => 'string',
435 description => 'Folder path e.g. '/folder'',
436 required => '1',
437 },
438 'storage_name' => {
439 data_type => 'string',
440 description => 'Storage name',
441 required => '0',
442 },
443 'recursive' => {
444 data_type => 'boolean',
445 description => 'Enable to delete folders, subfolders and files',
446 required => '0',
447 },
448 };
449 __PACKAGE__->method_documentation->{ 'delete_folder' } = {
450 summary => 'Delete folder',
451 params => $params,
452 returns => undef,
453 };
454 }
455 # @return void
456 #
457 sub delete_folder {
458 my ($self, %args) = @_;
459
460 # verify the required parameter 'path' is set
461 unless (exists $args{'path'}) {
462 croak("Missing the required parameter 'path' when calling delete_folder");
463 }
464
465 # parse inputs
466 my $_resource_path = '/3d/storage/folder/{path}';
467
468 my $_method = 'DELETE';
469 my $query_params = {};
470 my $header_params = {};
471 my $form_params = {};
472
473 # 'Accept' and 'Content-Type' header
474 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
475 if ($_header_accept) {
476 $header_params->{'Accept'} = $_header_accept;
477 }
478 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
479
480 # query params
481 if ( exists $args{'storage_name'}) {
482 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
483 }
484
485 # query params
486 if ( exists $args{'recursive'}) {
487 $query_params->{'recursive'} = $self->{api_client}->to_query_value($args{'recursive'});
488 }
489
490 # path params
491 if ( exists $args{'path'}) {
492 my $_base_variable = "{" . "path" . "}";
493 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
494 $_resource_path =~ s/$_base_variable/$_base_value/g;
495 }
496
497 my $_body_data;
498 # authentication setting, if any
499 my $auth_settings = [qw(JWT )];
500
501 # make the API Call
502 $self->{api_client}->call_api($_resource_path, $_method,
503 $query_params, $form_params,
504 $header_params, $_body_data, $auth_settings);
505 return;
506 }
507
508 #
509 # delete_nodes
510 #
511 # Delete nodes from scene,nodes are addressed by Object Addressing Path
512 #
513 # @param string $name The name of the source file. (required)
514 # @param string $objectaddressingpath The object addressing path. (required)
515 # @param string $folder The folder of the source file. (optional)
516 # @param string $storage The storage type (optional)
517 {
518 my $params = {
519 'name' => {
520 data_type => 'string',
521 description => 'The name of the source file.',
522 required => '1',
523 },
524 'objectaddressingpath' => {
525 data_type => 'string',
526 description => 'The object addressing path.',
527 required => '1',
528 },
529 'folder' => {
530 data_type => 'string',
531 description => 'The folder of the source file.',
532 required => '0',
533 },
534 'storage' => {
535 data_type => 'string',
536 description => 'The storage type',
537 required => '0',
538 },
539 };
540 __PACKAGE__->method_documentation->{ 'delete_nodes' } = {
541 summary => 'Delete nodes from scene,nodes are addressed by Object Addressing Path',
542 params => $params,
543 returns => 'File',
544 };
545 }
546 # @return File
547 #
548 sub delete_nodes {
549 my ($self, %args) = @_;
550
551 # verify the required parameter 'name' is set
552 unless (exists $args{'name'}) {
553 croak("Missing the required parameter 'name' when calling delete_nodes");
554 }
555
556 # verify the required parameter 'objectaddressingpath' is set
557 unless (exists $args{'objectaddressingpath'}) {
558 croak("Missing the required parameter 'objectaddressingpath' when calling delete_nodes");
559 }
560
561 # parse inputs
562 my $_resource_path = '/3d/nodes';
563
564 my $_method = 'DELETE';
565 my $query_params = {};
566 my $header_params = {};
567 my $form_params = {};
568
569 # 'Accept' and 'Content-Type' header
570 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
571 if ($_header_accept) {
572 $header_params->{'Accept'} = $_header_accept;
573 }
574 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
575
576 # query params
577 if ( exists $args{'name'}) {
578 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
579 }
580
581 # query params
582 if ( exists $args{'objectaddressingpath'}) {
583 $query_params->{'objectaddressingpath'} = $self->{api_client}->to_query_value($args{'objectaddressingpath'});
584 }
585
586 # query params
587 if ( exists $args{'folder'}) {
588 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
589 }
590
591 # query params
592 if ( exists $args{'storage'}) {
593 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
594 }
595
596 my $_body_data;
597 # authentication setting, if any
598 my $auth_settings = [qw(JWT )];
599
600 # make the API Call
601 my $response = $self->{api_client}->call_api($_resource_path, $_method,
602 $query_params, $form_params,
603 $header_params, $_body_data, $auth_settings);
604 if (!$response) {
605 return;
606 }
607 my $_response_object = $self->{api_client}->deserialize('File', $response);
608 return $_response_object;
609 }
610
611 #
612 # download_file
613 #
614 # Download file
615 #
616 # @param string $path File path e.g. '/folder/file.ext' (required)
617 # @param string $storage_name Storage name (optional)
618 # @param string $version_id File version ID to download (optional)
619 {
620 my $params = {
621 'path' => {
622 data_type => 'string',
623 description => 'File path e.g. '/folder/file.ext'',
624 required => '1',
625 },
626 'storage_name' => {
627 data_type => 'string',
628 description => 'Storage name',
629 required => '0',
630 },
631 'version_id' => {
632 data_type => 'string',
633 description => 'File version ID to download',
634 required => '0',
635 },
636 };
637 __PACKAGE__->method_documentation->{ 'download_file' } = {
638 summary => 'Download file',
639 params => $params,
640 returns => 'File',
641 };
642 }
643 # @return File
644 #
645 sub download_file {
646 my ($self, %args) = @_;
647
648 # verify the required parameter 'path' is set
649 unless (exists $args{'path'}) {
650 croak("Missing the required parameter 'path' when calling download_file");
651 }
652
653 # parse inputs
654 my $_resource_path = '/3d/storage/file/{path}';
655
656 my $_method = 'GET';
657 my $query_params = {};
658 my $header_params = {};
659 my $form_params = {};
660
661 # 'Accept' and 'Content-Type' header
662 my $_header_accept = $self->{api_client}->select_header_accept('multipart/form-data');
663 if ($_header_accept) {
664 $header_params->{'Accept'} = $_header_accept;
665 }
666 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
667
668 # query params
669 if ( exists $args{'storage_name'}) {
670 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
671 }
672
673 # query params
674 if ( exists $args{'version_id'}) {
675 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
676 }
677
678 # path params
679 if ( exists $args{'path'}) {
680 my $_base_variable = "{" . "path" . "}";
681 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
682 $_resource_path =~ s/$_base_variable/$_base_value/g;
683 }
684
685 my $_body_data;
686 # authentication setting, if any
687 my $auth_settings = [qw(JWT )];
688
689 # make the API Call
690 my $response = $self->{api_client}->call_api($_resource_path, $_method,
691 $query_params, $form_params,
692 $header_params, $_body_data, $auth_settings);
693 if (!$response) {
694 return;
695 }
696 my $_response_object = $self->{api_client}->deserialize('File', $response);
697 return $_response_object;
698 }
699
700 #
701 # get_disc_usage
702 #
703 # Get disc usage
704 #
705 # @param string $storage_name Storage name (optional)
706 {
707 my $params = {
708 'storage_name' => {
709 data_type => 'string',
710 description => 'Storage name',
711 required => '0',
712 },
713 };
714 __PACKAGE__->method_documentation->{ 'get_disc_usage' } = {
715 summary => 'Get disc usage',
716 params => $params,
717 returns => 'DiscUsage',
718 };
719 }
720 # @return DiscUsage
721 #
722 sub get_disc_usage {
723 my ($self, %args) = @_;
724
725 # parse inputs
726 my $_resource_path = '/3d/storage/disc';
727
728 my $_method = 'GET';
729 my $query_params = {};
730 my $header_params = {};
731 my $form_params = {};
732
733 # 'Accept' and 'Content-Type' header
734 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
735 if ($_header_accept) {
736 $header_params->{'Accept'} = $_header_accept;
737 }
738 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
739
740 # query params
741 if ( exists $args{'storage_name'}) {
742 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
743 }
744
745 my $_body_data;
746 # authentication setting, if any
747 my $auth_settings = [qw(JWT )];
748
749 # make the API Call
750 my $response = $self->{api_client}->call_api($_resource_path, $_method,
751 $query_params, $form_params,
752 $header_params, $_body_data, $auth_settings);
753 if (!$response) {
754 return;
755 }
756 my $_response_object = $self->{api_client}->deserialize('DiscUsage', $response);
757 return $_response_object;
758 }
759
760 #
761 # get_file_versions
762 #
763 # Get file versions
764 #
765 # @param string $path File path e.g. '/file.ext' (required)
766 # @param string $storage_name Storage name (optional)
767 {
768 my $params = {
769 'path' => {
770 data_type => 'string',
771 description => 'File path e.g. '/file.ext'',
772 required => '1',
773 },
774 'storage_name' => {
775 data_type => 'string',
776 description => 'Storage name',
777 required => '0',
778 },
779 };
780 __PACKAGE__->method_documentation->{ 'get_file_versions' } = {
781 summary => 'Get file versions',
782 params => $params,
783 returns => 'FileVersions',
784 };
785 }
786 # @return FileVersions
787 #
788 sub get_file_versions {
789 my ($self, %args) = @_;
790
791 # verify the required parameter 'path' is set
792 unless (exists $args{'path'}) {
793 croak("Missing the required parameter 'path' when calling get_file_versions");
794 }
795
796 # parse inputs
797 my $_resource_path = '/3d/storage/version/{path}';
798
799 my $_method = 'GET';
800 my $query_params = {};
801 my $header_params = {};
802 my $form_params = {};
803
804 # 'Accept' and 'Content-Type' header
805 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
806 if ($_header_accept) {
807 $header_params->{'Accept'} = $_header_accept;
808 }
809 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
810
811 # query params
812 if ( exists $args{'storage_name'}) {
813 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
814 }
815
816 # path params
817 if ( exists $args{'path'}) {
818 my $_base_variable = "{" . "path" . "}";
819 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
820 $_resource_path =~ s/$_base_variable/$_base_value/g;
821 }
822
823 my $_body_data;
824 # authentication setting, if any
825 my $auth_settings = [qw(JWT )];
826
827 # make the API Call
828 my $response = $self->{api_client}->call_api($_resource_path, $_method,
829 $query_params, $form_params,
830 $header_params, $_body_data, $auth_settings);
831 if (!$response) {
832 return;
833 }
834 my $_response_object = $self->{api_client}->deserialize('FileVersions', $response);
835 return $_response_object;
836 }
837
838 #
839 # get_files_list
840 #
841 # Get all files and folders within a folder
842 #
843 # @param string $path Folder path e.g. '/folder' (required)
844 # @param string $storage_name Storage name (optional)
845 {
846 my $params = {
847 'path' => {
848 data_type => 'string',
849 description => 'Folder path e.g. '/folder'',
850 required => '1',
851 },
852 'storage_name' => {
853 data_type => 'string',
854 description => 'Storage name',
855 required => '0',
856 },
857 };
858 __PACKAGE__->method_documentation->{ 'get_files_list' } = {
859 summary => 'Get all files and folders within a folder',
860 params => $params,
861 returns => 'FilesList',
862 };
863 }
864 # @return FilesList
865 #
866 sub get_files_list {
867 my ($self, %args) = @_;
868
869 # verify the required parameter 'path' is set
870 unless (exists $args{'path'}) {
871 croak("Missing the required parameter 'path' when calling get_files_list");
872 }
873
874 # parse inputs
875 my $_resource_path = '/3d/storage/folder/{path}';
876
877 my $_method = 'GET';
878 my $query_params = {};
879 my $header_params = {};
880 my $form_params = {};
881
882 # 'Accept' and 'Content-Type' header
883 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
884 if ($_header_accept) {
885 $header_params->{'Accept'} = $_header_accept;
886 }
887 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
888
889 # query params
890 if ( exists $args{'storage_name'}) {
891 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
892 }
893
894 # path params
895 if ( exists $args{'path'}) {
896 my $_base_variable = "{" . "path" . "}";
897 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
898 $_resource_path =~ s/$_base_variable/$_base_value/g;
899 }
900
901 my $_body_data;
902 # authentication setting, if any
903 my $auth_settings = [qw(JWT )];
904
905 # make the API Call
906 my $response = $self->{api_client}->call_api($_resource_path, $_method,
907 $query_params, $form_params,
908 $header_params, $_body_data, $auth_settings);
909 if (!$response) {
910 return;
911 }
912 my $_response_object = $self->{api_client}->deserialize('FilesList', $response);
913 return $_response_object;
914 }
915
916 #
917 # move_file
918 #
919 # Move file
920 #
921 # @param string $src_path Source file path e.g. '/src.ext' (required)
922 # @param string $dest_path Destination file path e.g. '/dest.ext' (required)
923 # @param string $src_storage_name Source storage name (optional)
924 # @param string $dest_storage_name Destination storage name (optional)
925 # @param string $version_id File version ID to move (optional)
926 {
927 my $params = {
928 'src_path' => {
929 data_type => 'string',
930 description => 'Source file path e.g. '/src.ext'',
931 required => '1',
932 },
933 'dest_path' => {
934 data_type => 'string',
935 description => 'Destination file path e.g. '/dest.ext'',
936 required => '1',
937 },
938 'src_storage_name' => {
939 data_type => 'string',
940 description => 'Source storage name',
941 required => '0',
942 },
943 'dest_storage_name' => {
944 data_type => 'string',
945 description => 'Destination storage name',
946 required => '0',
947 },
948 'version_id' => {
949 data_type => 'string',
950 description => 'File version ID to move',
951 required => '0',
952 },
953 };
954 __PACKAGE__->method_documentation->{ 'move_file' } = {
955 summary => 'Move file',
956 params => $params,
957 returns => undef,
958 };
959 }
960 # @return void
961 #
962 sub move_file {
963 my ($self, %args) = @_;
964
965 # verify the required parameter 'src_path' is set
966 unless (exists $args{'src_path'}) {
967 croak("Missing the required parameter 'src_path' when calling move_file");
968 }
969
970 # verify the required parameter 'dest_path' is set
971 unless (exists $args{'dest_path'}) {
972 croak("Missing the required parameter 'dest_path' when calling move_file");
973 }
974
975 # parse inputs
976 my $_resource_path = '/3d/storage/file/move/{srcPath}';
977
978 my $_method = 'PUT';
979 my $query_params = {};
980 my $header_params = {};
981 my $form_params = {};
982
983 # 'Accept' and 'Content-Type' header
984 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
985 if ($_header_accept) {
986 $header_params->{'Accept'} = $_header_accept;
987 }
988 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
989
990 # query params
991 if ( exists $args{'dest_path'}) {
992 $query_params->{'destPath'} = $self->{api_client}->to_query_value($args{'dest_path'});
993 }
994
995 # query params
996 if ( exists $args{'src_storage_name'}) {
997 $query_params->{'srcStorageName'} = $self->{api_client}->to_query_value($args{'src_storage_name'});
998 }
999
1000 # query params
1001 if ( exists $args{'dest_storage_name'}) {
1002 $query_params->{'destStorageName'} = $self->{api_client}->to_query_value($args{'dest_storage_name'});
1003 }
1004
1005 # query params
1006 if ( exists $args{'version_id'}) {
1007 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
1008 }
1009
1010 # path params
1011 if ( exists $args{'src_path'}) {
1012 my $_base_variable = "{" . "srcPath" . "}";
1013 my $_base_value = $self->{api_client}->to_path_value($args{'src_path'});
1014 $_resource_path =~ s/$_base_variable/$_base_value/g;
1015 }
1016
1017 my $_body_data;
1018 # authentication setting, if any
1019 my $auth_settings = [qw(JWT )];
1020
1021 # make the API Call
1022 $self->{api_client}->call_api($_resource_path, $_method,
1023 $query_params, $form_params,
1024 $header_params, $_body_data, $auth_settings);
1025 return;
1026 }
1027
1028 #
1029 # move_folder
1030 #
1031 # Move folder
1032 #
1033 # @param string $src_path Folder path to move e.g. '/folder' (required)
1034 # @param string $dest_path Destination folder path to move to e.g '/dst' (required)
1035 # @param string $src_storage_name Source storage name (optional)
1036 # @param string $dest_storage_name Destination storage name (optional)
1037 {
1038 my $params = {
1039 'src_path' => {
1040 data_type => 'string',
1041 description => 'Folder path to move e.g. '/folder'',
1042 required => '1',
1043 },
1044 'dest_path' => {
1045 data_type => 'string',
1046 description => 'Destination folder path to move to e.g '/dst'',
1047 required => '1',
1048 },
1049 'src_storage_name' => {
1050 data_type => 'string',
1051 description => 'Source storage name',
1052 required => '0',
1053 },
1054 'dest_storage_name' => {
1055 data_type => 'string',
1056 description => 'Destination storage name',
1057 required => '0',
1058 },
1059 };
1060 __PACKAGE__->method_documentation->{ 'move_folder' } = {
1061 summary => 'Move folder',
1062 params => $params,
1063 returns => undef,
1064 };
1065 }
1066 # @return void
1067 #
1068 sub move_folder {
1069 my ($self, %args) = @_;
1070
1071 # verify the required parameter 'src_path' is set
1072 unless (exists $args{'src_path'}) {
1073 croak("Missing the required parameter 'src_path' when calling move_folder");
1074 }
1075
1076 # verify the required parameter 'dest_path' is set
1077 unless (exists $args{'dest_path'}) {
1078 croak("Missing the required parameter 'dest_path' when calling move_folder");
1079 }
1080
1081 # parse inputs
1082 my $_resource_path = '/3d/storage/folder/move/{srcPath}';
1083
1084 my $_method = 'PUT';
1085 my $query_params = {};
1086 my $header_params = {};
1087 my $form_params = {};
1088
1089 # 'Accept' and 'Content-Type' header
1090 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1091 if ($_header_accept) {
1092 $header_params->{'Accept'} = $_header_accept;
1093 }
1094 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1095
1096 # query params
1097 if ( exists $args{'dest_path'}) {
1098 $query_params->{'destPath'} = $self->{api_client}->to_query_value($args{'dest_path'});
1099 }
1100
1101 # query params
1102 if ( exists $args{'src_storage_name'}) {
1103 $query_params->{'srcStorageName'} = $self->{api_client}->to_query_value($args{'src_storage_name'});
1104 }
1105
1106 # query params
1107 if ( exists $args{'dest_storage_name'}) {
1108 $query_params->{'destStorageName'} = $self->{api_client}->to_query_value($args{'dest_storage_name'});
1109 }
1110
1111 # path params
1112 if ( exists $args{'src_path'}) {
1113 my $_base_variable = "{" . "srcPath" . "}";
1114 my $_base_value = $self->{api_client}->to_path_value($args{'src_path'});
1115 $_resource_path =~ s/$_base_variable/$_base_value/g;
1116 }
1117
1118 my $_body_data;
1119 # authentication setting, if any
1120 my $auth_settings = [qw(JWT )];
1121
1122 # make the API Call
1123 $self->{api_client}->call_api($_resource_path, $_method,
1124 $query_params, $form_params,
1125 $header_params, $_body_data, $auth_settings);
1126 return;
1127 }
1128
1129 #
1130 # o_auth_post
1131 #
1132 # Get Access token
1133 #
1134 # @param string $grant_type Grant Type (required)
1135 # @param string $client_id App SID (required)
1136 # @param string $client_secret App Key (required)
1137 {
1138 my $params = {
1139 'grant_type' => {
1140 data_type => 'string',
1141 description => 'Grant Type',
1142 required => '1',
1143 },
1144 'client_id' => {
1145 data_type => 'string',
1146 description => 'App SID',
1147 required => '1',
1148 },
1149 'client_secret' => {
1150 data_type => 'string',
1151 description => 'App Key',
1152 required => '1',
1153 },
1154 };
1155 __PACKAGE__->method_documentation->{ 'o_auth_post' } = {
1156 summary => 'Get Access token',
1157 params => $params,
1158 returns => 'AccessTokenResponse',
1159 };
1160 }
1161 # @return AccessTokenResponse
1162 #
1163 sub o_auth_post {
1164 my ($self, %args) = @_;
1165
1166 # verify the required parameter 'grant_type' is set
1167 unless (exists $args{'grant_type'}) {
1168 croak("Missing the required parameter 'grant_type' when calling o_auth_post");
1169 }
1170
1171 # verify the required parameter 'client_id' is set
1172 unless (exists $args{'client_id'}) {
1173 croak("Missing the required parameter 'client_id' when calling o_auth_post");
1174 }
1175
1176 # verify the required parameter 'client_secret' is set
1177 unless (exists $args{'client_secret'}) {
1178 croak("Missing the required parameter 'client_secret' when calling o_auth_post");
1179 }
1180
1181 # parse inputs
1182 my $_resource_path = '/connect/token';
1183
1184 my $_method = 'POST';
1185 my $query_params = {};
1186 my $header_params = {};
1187 my $form_params = {};
1188
1189 # 'Accept' and 'Content-Type' header
1190 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1191 if ($_header_accept) {
1192 $header_params->{'Accept'} = $_header_accept;
1193 }
1194 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/x-www-form-urlencoded');
1195
1196 # form params
1197 if ( exists $args{'grant_type'} ) {
1198 $form_params->{'grant_type'} = $self->{api_client}->to_form_value($args{'grant_type'});
1199 }
1200
1201 # form params
1202 if ( exists $args{'client_id'} ) {
1203 $form_params->{'client_id'} = $self->{api_client}->to_form_value($args{'client_id'});
1204 }
1205
1206 # form params
1207 if ( exists $args{'client_secret'} ) {
1208 $form_params->{'client_secret'} = $self->{api_client}->to_form_value($args{'client_secret'});
1209 }
1210
1211 my $_body_data;
1212 # authentication setting, if any
1213 my $auth_settings = [qw()];
1214
1215 # make the API Call
1216 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1217 $query_params, $form_params,
1218 $header_params, $_body_data, $auth_settings);
1219 if (!$response) {
1220 return;
1221 }
1222 my $_response_object = $self->{api_client}->deserialize('AccessTokenResponse', $response);
1223 return $_response_object;
1224 }
1225
1226 #
1227 # object_exists
1228 #
1229 # Check if file or folder exists
1230 #
1231 # @param string $path File or folder path e.g. '/file.ext' or '/folder' (required)
1232 # @param string $storage_name Storage name (optional)
1233 # @param string $version_id File version ID (optional)
1234 {
1235 my $params = {
1236 'path' => {
1237 data_type => 'string',
1238 description => 'File or folder path e.g. '/file.ext' or '/folder'',
1239 required => '1',
1240 },
1241 'storage_name' => {
1242 data_type => 'string',
1243 description => 'Storage name',
1244 required => '0',
1245 },
1246 'version_id' => {
1247 data_type => 'string',
1248 description => 'File version ID',
1249 required => '0',
1250 },
1251 };
1252 __PACKAGE__->method_documentation->{ 'object_exists' } = {
1253 summary => 'Check if file or folder exists',
1254 params => $params,
1255 returns => 'ObjectExist',
1256 };
1257 }
1258 # @return ObjectExist
1259 #
1260 sub object_exists {
1261 my ($self, %args) = @_;
1262
1263 # verify the required parameter 'path' is set
1264 unless (exists $args{'path'}) {
1265 croak("Missing the required parameter 'path' when calling object_exists");
1266 }
1267
1268 # parse inputs
1269 my $_resource_path = '/3d/storage/exist/{path}';
1270
1271 my $_method = 'GET';
1272 my $query_params = {};
1273 my $header_params = {};
1274 my $form_params = {};
1275
1276 # 'Accept' and 'Content-Type' header
1277 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1278 if ($_header_accept) {
1279 $header_params->{'Accept'} = $_header_accept;
1280 }
1281 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1282
1283 # query params
1284 if ( exists $args{'storage_name'}) {
1285 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
1286 }
1287
1288 # query params
1289 if ( exists $args{'version_id'}) {
1290 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
1291 }
1292
1293 # path params
1294 if ( exists $args{'path'}) {
1295 my $_base_variable = "{" . "path" . "}";
1296 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
1297 $_resource_path =~ s/$_base_variable/$_base_value/g;
1298 }
1299
1300 my $_body_data;
1301 # authentication setting, if any
1302 my $auth_settings = [qw(JWT )];
1303
1304 # make the API Call
1305 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1306 $query_params, $form_params,
1307 $header_params, $_body_data, $auth_settings);
1308 if (!$response) {
1309 return;
1310 }
1311 my $_response_object = $self->{api_client}->deserialize('ObjectExist', $response);
1312 return $_response_object;
1313 }
1314
1315 #
1316 # post_convert_by_format
1317 #
1318 # Convert file on server to other formats with fileformat parameter
1319 #
1320 # @param string $name The name of the source file. (required)
1321 # @param string $newformat The format of the new file. (required)
1322 # @param string $newfilename The name of the new file. (required)
1323 # @param string $folder The folder of the source file. (optional)
1324 # @param boolean $is_overwrite Overwrite the source file? true or false. (optional, default to false)
1325 # @param string $storage The storage type. (optional)
1326 {
1327 my $params = {
1328 'name' => {
1329 data_type => 'string',
1330 description => 'The name of the source file.',
1331 required => '1',
1332 },
1333 'newformat' => {
1334 data_type => 'string',
1335 description => 'The format of the new file.',
1336 required => '1',
1337 },
1338 'newfilename' => {
1339 data_type => 'string',
1340 description => 'The name of the new file.',
1341 required => '1',
1342 },
1343 'folder' => {
1344 data_type => 'string',
1345 description => 'The folder of the source file.',
1346 required => '0',
1347 },
1348 'is_overwrite' => {
1349 data_type => 'boolean',
1350 description => 'Overwrite the source file? true or false.',
1351 required => '0',
1352 },
1353 'storage' => {
1354 data_type => 'string',
1355 description => 'The storage type.',
1356 required => '0',
1357 },
1358 };
1359 __PACKAGE__->method_documentation->{ 'post_convert_by_format' } = {
1360 summary => 'Convert file on server to other formats with fileformat parameter ',
1361 params => $params,
1362 returns => 'File',
1363 };
1364 }
1365 # @return File
1366 #
1367 sub post_convert_by_format {
1368 my ($self, %args) = @_;
1369
1370 # verify the required parameter 'name' is set
1371 unless (exists $args{'name'}) {
1372 croak("Missing the required parameter 'name' when calling post_convert_by_format");
1373 }
1374
1375 # verify the required parameter 'newformat' is set
1376 unless (exists $args{'newformat'}) {
1377 croak("Missing the required parameter 'newformat' when calling post_convert_by_format");
1378 }
1379
1380 # verify the required parameter 'newfilename' is set
1381 unless (exists $args{'newfilename'}) {
1382 croak("Missing the required parameter 'newfilename' when calling post_convert_by_format");
1383 }
1384
1385 # parse inputs
1386 my $_resource_path = '/3d/saveas/newformat';
1387
1388 my $_method = 'POST';
1389 my $query_params = {};
1390 my $header_params = {};
1391 my $form_params = {};
1392
1393 # 'Accept' and 'Content-Type' header
1394 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1395 if ($_header_accept) {
1396 $header_params->{'Accept'} = $_header_accept;
1397 }
1398 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1399
1400 # query params
1401 if ( exists $args{'name'}) {
1402 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
1403 }
1404
1405 # query params
1406 if ( exists $args{'newformat'}) {
1407 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
1408 }
1409
1410 # query params
1411 if ( exists $args{'newfilename'}) {
1412 $query_params->{'newfilename'} = $self->{api_client}->to_query_value($args{'newfilename'});
1413 }
1414
1415 # query params
1416 if ( exists $args{'folder'}) {
1417 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1418 }
1419
1420 # query params
1421 if ( exists $args{'is_overwrite'}) {
1422 $query_params->{'IsOverwrite'} = $self->{api_client}->to_query_value($args{'is_overwrite'});
1423 }
1424
1425 # query params
1426 if ( exists $args{'storage'}) {
1427 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1428 }
1429
1430 my $_body_data;
1431 # authentication setting, if any
1432 my $auth_settings = [qw(JWT )];
1433
1434 # make the API Call
1435 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1436 $query_params, $form_params,
1437 $header_params, $_body_data, $auth_settings);
1438 if (!$response) {
1439 return;
1440 }
1441 my $_response_object = $self->{api_client}->deserialize('File', $response);
1442 return $_response_object;
1443 }
1444
1445 #
1446 # post_convert_by_opt
1447 #
1448 # Convert file on server to other formats with saveOption parameter
1449 #
1450 # @param string $name The name of the source file. (required)
1451 # @param SaveOptions $save_options The saveOptions to save the file (required)
1452 # @param string $newfilename The name of the new file (required)
1453 # @param string $folder The folder of the source file (optional)
1454 # @param boolean $is_overwrite Overwrite the source file? true or false (optional, default to false)
1455 # @param string $storage The storage type (optional)
1456 {
1457 my $params = {
1458 'name' => {
1459 data_type => 'string',
1460 description => 'The name of the source file.',
1461 required => '1',
1462 },
1463 'save_options' => {
1464 data_type => 'SaveOptions',
1465 description => 'The saveOptions to save the file',
1466 required => '1',
1467 },
1468 'newfilename' => {
1469 data_type => 'string',
1470 description => 'The name of the new file',
1471 required => '1',
1472 },
1473 'folder' => {
1474 data_type => 'string',
1475 description => 'The folder of the source file',
1476 required => '0',
1477 },
1478 'is_overwrite' => {
1479 data_type => 'boolean',
1480 description => 'Overwrite the source file? true or false',
1481 required => '0',
1482 },
1483 'storage' => {
1484 data_type => 'string',
1485 description => 'The storage type',
1486 required => '0',
1487 },
1488 };
1489 __PACKAGE__->method_documentation->{ 'post_convert_by_opt' } = {
1490 summary => 'Convert file on server to other formats with saveOption parameter ',
1491 params => $params,
1492 returns => 'File',
1493 };
1494 }
1495 # @return File
1496 #
1497 sub post_convert_by_opt {
1498 my ($self, %args) = @_;
1499
1500 # verify the required parameter 'name' is set
1501 unless (exists $args{'name'}) {
1502 croak("Missing the required parameter 'name' when calling post_convert_by_opt");
1503 }
1504
1505 # verify the required parameter 'save_options' is set
1506 unless (exists $args{'save_options'}) {
1507 croak("Missing the required parameter 'save_options' when calling post_convert_by_opt");
1508 }
1509
1510 # verify the required parameter 'newfilename' is set
1511 unless (exists $args{'newfilename'}) {
1512 croak("Missing the required parameter 'newfilename' when calling post_convert_by_opt");
1513 }
1514
1515 # parse inputs
1516 my $_resource_path = '/3d/saveas/saveoption';
1517
1518 my $_method = 'POST';
1519 my $query_params = {};
1520 my $header_params = {};
1521 my $form_params = {};
1522
1523 # 'Accept' and 'Content-Type' header
1524 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1525 if ($_header_accept) {
1526 $header_params->{'Accept'} = $_header_accept;
1527 }
1528 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1529
1530 # query params
1531 if ( exists $args{'name'}) {
1532 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
1533 }
1534
1535 # query params
1536 if ( exists $args{'newfilename'}) {
1537 $query_params->{'newfilename'} = $self->{api_client}->to_query_value($args{'newfilename'});
1538 }
1539
1540 # query params
1541 if ( exists $args{'folder'}) {
1542 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1543 }
1544
1545 # query params
1546 if ( exists $args{'is_overwrite'}) {
1547 $query_params->{'IsOverwrite'} = $self->{api_client}->to_query_value($args{'is_overwrite'});
1548 }
1549
1550 # query params
1551 if ( exists $args{'storage'}) {
1552 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1553 }
1554
1555 my $_body_data;
1556 # body params
1557 if ( exists $args{'save_options'}) {
1558 $_body_data = $args{'save_options'};
1559 }
1560
1561 # authentication setting, if any
1562 my $auth_settings = [qw(JWT )];
1563
1564 # make the API Call
1565 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1566 $query_params, $form_params,
1567 $header_params, $_body_data, $auth_settings);
1568 if (!$response) {
1569 return;
1570 }
1571 my $_response_object = $self->{api_client}->deserialize('File', $response);
1572 return $_response_object;
1573 }
1574
1575 #
1576 # post_create
1577 #
1578 # Create new file with specified format.
1579 #
1580 # @param string $format The format of the new file. (required)
1581 {
1582 my $params = {
1583 'format' => {
1584 data_type => 'string',
1585 description => 'The format of the new file.',
1586 required => '1',
1587 },
1588 };
1589 __PACKAGE__->method_documentation->{ 'post_create' } = {
1590 summary => 'Create new file with specified format. ',
1591 params => $params,
1592 returns => 'File',
1593 };
1594 }
1595 # @return File
1596 #
1597 sub post_create {
1598 my ($self, %args) = @_;
1599
1600 # verify the required parameter 'format' is set
1601 unless (exists $args{'format'}) {
1602 croak("Missing the required parameter 'format' when calling post_create");
1603 }
1604
1605 # parse inputs
1606 my $_resource_path = '/3d/new';
1607
1608 my $_method = 'POST';
1609 my $query_params = {};
1610 my $header_params = {};
1611 my $form_params = {};
1612
1613 # 'Accept' and 'Content-Type' header
1614 my $_header_accept = $self->{api_client}->select_header_accept('multipart/form-data');
1615 if ($_header_accept) {
1616 $header_params->{'Accept'} = $_header_accept;
1617 }
1618 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1619
1620 # query params
1621 if ( exists $args{'format'}) {
1622 $query_params->{'format'} = $self->{api_client}->to_query_value($args{'format'});
1623 }
1624
1625 my $_body_data;
1626 # authentication setting, if any
1627 my $auth_settings = [qw(JWT )];
1628
1629 # make the API Call
1630 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1631 $query_params, $form_params,
1632 $header_params, $_body_data, $auth_settings);
1633 if (!$response) {
1634 return;
1635 }
1636 my $_response_object = $self->{api_client}->deserialize('File', $response);
1637 return $_response_object;
1638 }
1639
1640 #
1641 # post_model
1642 #
1643 # Parametric Modeling, Create a Entity with size and located in ...
1644 #
1645 # @param string $name The name of the source file. (required)
1646 # @param ModelData $modeldata ModelData struct. (required)
1647 # @param string $newformat new format of the source file. (optional)
1648 # @param string $folder The folder of the source file. (optional)
1649 # @param string $storage The storage type (optional)
1650 {
1651 my $params = {
1652 'name' => {
1653 data_type => 'string',
1654 description => 'The name of the source file.',
1655 required => '1',
1656 },
1657 'modeldata' => {
1658 data_type => 'ModelData',
1659 description => 'ModelData struct.',
1660 required => '1',
1661 },
1662 'newformat' => {
1663 data_type => 'string',
1664 description => 'new format of the source file.',
1665 required => '0',
1666 },
1667 'folder' => {
1668 data_type => 'string',
1669 description => 'The folder of the source file.',
1670 required => '0',
1671 },
1672 'storage' => {
1673 data_type => 'string',
1674 description => 'The storage type',
1675 required => '0',
1676 },
1677 };
1678 __PACKAGE__->method_documentation->{ 'post_model' } = {
1679 summary => 'Parametric Modeling, Create a Entity with size and located in ...',
1680 params => $params,
1681 returns => 'File',
1682 };
1683 }
1684 # @return File
1685 #
1686 sub post_model {
1687 my ($self, %args) = @_;
1688
1689 # verify the required parameter 'name' is set
1690 unless (exists $args{'name'}) {
1691 croak("Missing the required parameter 'name' when calling post_model");
1692 }
1693
1694 # verify the required parameter 'modeldata' is set
1695 unless (exists $args{'modeldata'}) {
1696 croak("Missing the required parameter 'modeldata' when calling post_model");
1697 }
1698
1699 # parse inputs
1700 my $_resource_path = '/3d/root';
1701
1702 my $_method = 'POST';
1703 my $query_params = {};
1704 my $header_params = {};
1705 my $form_params = {};
1706
1707 # 'Accept' and 'Content-Type' header
1708 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1709 if ($_header_accept) {
1710 $header_params->{'Accept'} = $_header_accept;
1711 }
1712 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1713
1714 # query params
1715 if ( exists $args{'name'}) {
1716 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
1717 }
1718
1719 # query params
1720 if ( exists $args{'newformat'}) {
1721 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
1722 }
1723
1724 # query params
1725 if ( exists $args{'folder'}) {
1726 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1727 }
1728
1729 # query params
1730 if ( exists $args{'storage'}) {
1731 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1732 }
1733
1734 my $_body_data;
1735 # body params
1736 if ( exists $args{'modeldata'}) {
1737 $_body_data = $args{'modeldata'};
1738 }
1739
1740 # authentication setting, if any
1741 my $auth_settings = [qw(JWT )];
1742
1743 # make the API Call
1744 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1745 $query_params, $form_params,
1746 $header_params, $_body_data, $auth_settings);
1747 if (!$response) {
1748 return;
1749 }
1750 my $_response_object = $self->{api_client}->deserialize('File', $response);
1751 return $_response_object;
1752 }
1753
1754 #
1755 # post_pdf_raw_data
1756 #
1757 # Extract raw data(without any modification) from a password protected PDF file
1758 #
1759 # @param string $name The PDF file's mame (required)
1760 # @param string $multifileprefix The file name for generated raw date (required)
1761 # @param string $password The password to open the PDF (optional)
1762 # @param string $folder The folder for source file (optional)
1763 # @param string $storage The storage type (optional)
1764 {
1765 my $params = {
1766 'name' => {
1767 data_type => 'string',
1768 description => 'The PDF file's mame',
1769 required => '1',
1770 },
1771 'multifileprefix' => {
1772 data_type => 'string',
1773 description => 'The file name for generated raw date',
1774 required => '1',
1775 },
1776 'password' => {
1777 data_type => 'string',
1778 description => 'The password to open the PDF',
1779 required => '0',
1780 },
1781 'folder' => {
1782 data_type => 'string',
1783 description => 'The folder for source file',
1784 required => '0',
1785 },
1786 'storage' => {
1787 data_type => 'string',
1788 description => 'The storage type',
1789 required => '0',
1790 },
1791 };
1792 __PACKAGE__->method_documentation->{ 'post_pdf_raw_data' } = {
1793 summary => 'Extract raw data(without any modification) from a password protected PDF file ',
1794 params => $params,
1795 returns => 'File',
1796 };
1797 }
1798 # @return File
1799 #
1800 sub post_pdf_raw_data {
1801 my ($self, %args) = @_;
1802
1803 # verify the required parameter 'name' is set
1804 unless (exists $args{'name'}) {
1805 croak("Missing the required parameter 'name' when calling post_pdf_raw_data");
1806 }
1807
1808 # verify the required parameter 'multifileprefix' is set
1809 unless (exists $args{'multifileprefix'}) {
1810 croak("Missing the required parameter 'multifileprefix' when calling post_pdf_raw_data");
1811 }
1812
1813 # parse inputs
1814 my $_resource_path = '/3d/extract/rawdata';
1815
1816 my $_method = 'POST';
1817 my $query_params = {};
1818 my $header_params = {};
1819 my $form_params = {};
1820
1821 # 'Accept' and 'Content-Type' header
1822 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1823 if ($_header_accept) {
1824 $header_params->{'Accept'} = $_header_accept;
1825 }
1826 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1827
1828 # query params
1829 if ( exists $args{'name'}) {
1830 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
1831 }
1832
1833 # query params
1834 if ( exists $args{'multifileprefix'}) {
1835 $query_params->{'multifileprefix'} = $self->{api_client}->to_query_value($args{'multifileprefix'});
1836 }
1837
1838 # query params
1839 if ( exists $args{'password'}) {
1840 $query_params->{'password'} = $self->{api_client}->to_query_value($args{'password'});
1841 }
1842
1843 # query params
1844 if ( exists $args{'folder'}) {
1845 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1846 }
1847
1848 # query params
1849 if ( exists $args{'storage'}) {
1850 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1851 }
1852
1853 my $_body_data;
1854 # authentication setting, if any
1855 my $auth_settings = [qw(JWT )];
1856
1857 # make the API Call
1858 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1859 $query_params, $form_params,
1860 $header_params, $_body_data, $auth_settings);
1861 if (!$response) {
1862 return;
1863 }
1864 my $_response_object = $self->{api_client}->deserialize('File', $response);
1865 return $_response_object;
1866 }
1867
1868 #
1869 # post_save_as_part
1870 #
1871 # Convert part of the file into different format
1872 #
1873 # @param string $name The name of the source file (required)
1874 # @param string $objectaddressingpath The object addressing path (required)
1875 # @param string $newformat The format of the new file (required)
1876 # @param string $newfilename The name of the new file (required)
1877 # @param string $folder The folder of the source file (optional)
1878 # @param boolean $is_overwrite Overwrite the source file? true or false (optional, default to false)
1879 # @param string $storage The storage type (optional)
1880 {
1881 my $params = {
1882 'name' => {
1883 data_type => 'string',
1884 description => 'The name of the source file',
1885 required => '1',
1886 },
1887 'objectaddressingpath' => {
1888 data_type => 'string',
1889 description => 'The object addressing path',
1890 required => '1',
1891 },
1892 'newformat' => {
1893 data_type => 'string',
1894 description => 'The format of the new file',
1895 required => '1',
1896 },
1897 'newfilename' => {
1898 data_type => 'string',
1899 description => 'The name of the new file',
1900 required => '1',
1901 },
1902 'folder' => {
1903 data_type => 'string',
1904 description => 'The folder of the source file',
1905 required => '0',
1906 },
1907 'is_overwrite' => {
1908 data_type => 'boolean',
1909 description => 'Overwrite the source file? true or false',
1910 required => '0',
1911 },
1912 'storage' => {
1913 data_type => 'string',
1914 description => 'The storage type',
1915 required => '0',
1916 },
1917 };
1918 __PACKAGE__->method_documentation->{ 'post_save_as_part' } = {
1919 summary => 'Convert part of the file into different format',
1920 params => $params,
1921 returns => 'File',
1922 };
1923 }
1924 # @return File
1925 #
1926 sub post_save_as_part {
1927 my ($self, %args) = @_;
1928
1929 # verify the required parameter 'name' is set
1930 unless (exists $args{'name'}) {
1931 croak("Missing the required parameter 'name' when calling post_save_as_part");
1932 }
1933
1934 # verify the required parameter 'objectaddressingpath' is set
1935 unless (exists $args{'objectaddressingpath'}) {
1936 croak("Missing the required parameter 'objectaddressingpath' when calling post_save_as_part");
1937 }
1938
1939 # verify the required parameter 'newformat' is set
1940 unless (exists $args{'newformat'}) {
1941 croak("Missing the required parameter 'newformat' when calling post_save_as_part");
1942 }
1943
1944 # verify the required parameter 'newfilename' is set
1945 unless (exists $args{'newfilename'}) {
1946 croak("Missing the required parameter 'newfilename' when calling post_save_as_part");
1947 }
1948
1949 # parse inputs
1950 my $_resource_path = '/3d/saveas/part';
1951
1952 my $_method = 'POST';
1953 my $query_params = {};
1954 my $header_params = {};
1955 my $form_params = {};
1956
1957 # 'Accept' and 'Content-Type' header
1958 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1959 if ($_header_accept) {
1960 $header_params->{'Accept'} = $_header_accept;
1961 }
1962 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1963
1964 # query params
1965 if ( exists $args{'name'}) {
1966 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
1967 }
1968
1969 # query params
1970 if ( exists $args{'objectaddressingpath'}) {
1971 $query_params->{'objectaddressingpath'} = $self->{api_client}->to_query_value($args{'objectaddressingpath'});
1972 }
1973
1974 # query params
1975 if ( exists $args{'newformat'}) {
1976 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
1977 }
1978
1979 # query params
1980 if ( exists $args{'newfilename'}) {
1981 $query_params->{'newfilename'} = $self->{api_client}->to_query_value($args{'newfilename'});
1982 }
1983
1984 # query params
1985 if ( exists $args{'folder'}) {
1986 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1987 }
1988
1989 # query params
1990 if ( exists $args{'is_overwrite'}) {
1991 $query_params->{'IsOverwrite'} = $self->{api_client}->to_query_value($args{'is_overwrite'});
1992 }
1993
1994 # query params
1995 if ( exists $args{'storage'}) {
1996 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1997 }
1998
1999 my $_body_data;
2000 # authentication setting, if any
2001 my $auth_settings = [qw(JWT )];
2002
2003 # make the API Call
2004 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2005 $query_params, $form_params,
2006 $header_params, $_body_data, $auth_settings);
2007 if (!$response) {
2008 return;
2009 }
2010 my $_response_object = $self->{api_client}->deserialize('File', $response);
2011 return $_response_object;
2012 }
2013
2014 #
2015 # post_scene_to_file
2016 #
2017 # Extract and save in different format
2018 #
2019 # @param string $name The PDF file's mame (required)
2020 # @param string $multifileprefix The file name for extracted scene (required)
2021 # @param string $newformat The format of new file (optional)
2022 # @param string $password The password to open the PDF (optional)
2023 # @param string $folder The folder for source file (optional)
2024 # @param string $storage The storage type (optional)
2025 {
2026 my $params = {
2027 'name' => {
2028 data_type => 'string',
2029 description => 'The PDF file's mame',
2030 required => '1',
2031 },
2032 'multifileprefix' => {
2033 data_type => 'string',
2034 description => 'The file name for extracted scene',
2035 required => '1',
2036 },
2037 'newformat' => {
2038 data_type => 'string',
2039 description => 'The format of new file',
2040 required => '0',
2041 },
2042 'password' => {
2043 data_type => 'string',
2044 description => 'The password to open the PDF',
2045 required => '0',
2046 },
2047 'folder' => {
2048 data_type => 'string',
2049 description => 'The folder for source file',
2050 required => '0',
2051 },
2052 'storage' => {
2053 data_type => 'string',
2054 description => 'The storage type',
2055 required => '0',
2056 },
2057 };
2058 __PACKAGE__->method_documentation->{ 'post_scene_to_file' } = {
2059 summary => 'Extract and save in different format ',
2060 params => $params,
2061 returns => 'File',
2062 };
2063 }
2064 # @return File
2065 #
2066 sub post_scene_to_file {
2067 my ($self, %args) = @_;
2068
2069 # verify the required parameter 'name' is set
2070 unless (exists $args{'name'}) {
2071 croak("Missing the required parameter 'name' when calling post_scene_to_file");
2072 }
2073
2074 # verify the required parameter 'multifileprefix' is set
2075 unless (exists $args{'multifileprefix'}) {
2076 croak("Missing the required parameter 'multifileprefix' when calling post_scene_to_file");
2077 }
2078
2079 # parse inputs
2080 my $_resource_path = '/3d/extract/scene';
2081
2082 my $_method = 'POST';
2083 my $query_params = {};
2084 my $header_params = {};
2085 my $form_params = {};
2086
2087 # 'Accept' and 'Content-Type' header
2088 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2089 if ($_header_accept) {
2090 $header_params->{'Accept'} = $_header_accept;
2091 }
2092 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
2093
2094 # query params
2095 if ( exists $args{'name'}) {
2096 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
2097 }
2098
2099 # query params
2100 if ( exists $args{'multifileprefix'}) {
2101 $query_params->{'multifileprefix'} = $self->{api_client}->to_query_value($args{'multifileprefix'});
2102 }
2103
2104 # query params
2105 if ( exists $args{'newformat'}) {
2106 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
2107 }
2108
2109 # query params
2110 if ( exists $args{'password'}) {
2111 $query_params->{'password'} = $self->{api_client}->to_query_value($args{'password'});
2112 }
2113
2114 # query params
2115 if ( exists $args{'folder'}) {
2116 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
2117 }
2118
2119 # query params
2120 if ( exists $args{'storage'}) {
2121 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
2122 }
2123
2124 my $_body_data;
2125 # authentication setting, if any
2126 my $auth_settings = [qw(JWT )];
2127
2128 # make the API Call
2129 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2130 $query_params, $form_params,
2131 $header_params, $_body_data, $auth_settings);
2132 if (!$response) {
2133 return;
2134 }
2135 my $_response_object = $self->{api_client}->deserialize('File', $response);
2136 return $_response_object;
2137 }
2138
2139 #
2140 # post_triangulate_new
2141 #
2142 # Triangulate whole file and save to the different file
2143 #
2144 # @param string $name The file's mame (required)
2145 # @param string $newfilename The new file's mame (required)
2146 # @param string $newformat The new file's format (required)
2147 # @param string $folder The folder for source file (optional)
2148 # @param string $storage The storage type (optional)
2149 {
2150 my $params = {
2151 'name' => {
2152 data_type => 'string',
2153 description => 'The file's mame',
2154 required => '1',
2155 },
2156 'newfilename' => {
2157 data_type => 'string',
2158 description => 'The new file's mame',
2159 required => '1',
2160 },
2161 'newformat' => {
2162 data_type => 'string',
2163 description => 'The new file's format',
2164 required => '1',
2165 },
2166 'folder' => {
2167 data_type => 'string',
2168 description => 'The folder for source file',
2169 required => '0',
2170 },
2171 'storage' => {
2172 data_type => 'string',
2173 description => 'The storage type',
2174 required => '0',
2175 },
2176 };
2177 __PACKAGE__->method_documentation->{ 'post_triangulate_new' } = {
2178 summary => 'Triangulate whole file and save to the different file',
2179 params => $params,
2180 returns => 'File',
2181 };
2182 }
2183 # @return File
2184 #
2185 sub post_triangulate_new {
2186 my ($self, %args) = @_;
2187
2188 # verify the required parameter 'name' is set
2189 unless (exists $args{'name'}) {
2190 croak("Missing the required parameter 'name' when calling post_triangulate_new");
2191 }
2192
2193 # verify the required parameter 'newfilename' is set
2194 unless (exists $args{'newfilename'}) {
2195 croak("Missing the required parameter 'newfilename' when calling post_triangulate_new");
2196 }
2197
2198 # verify the required parameter 'newformat' is set
2199 unless (exists $args{'newformat'}) {
2200 croak("Missing the required parameter 'newformat' when calling post_triangulate_new");
2201 }
2202
2203 # parse inputs
2204 my $_resource_path = '/3d/triangulate/new';
2205
2206 my $_method = 'POST';
2207 my $query_params = {};
2208 my $header_params = {};
2209 my $form_params = {};
2210
2211 # 'Accept' and 'Content-Type' header
2212 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2213 if ($_header_accept) {
2214 $header_params->{'Accept'} = $_header_accept;
2215 }
2216 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
2217
2218 # query params
2219 if ( exists $args{'name'}) {
2220 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
2221 }
2222
2223 # query params
2224 if ( exists $args{'newfilename'}) {
2225 $query_params->{'newfilename'} = $self->{api_client}->to_query_value($args{'newfilename'});
2226 }
2227
2228 # query params
2229 if ( exists $args{'newformat'}) {
2230 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
2231 }
2232
2233 # query params
2234 if ( exists $args{'folder'}) {
2235 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
2236 }
2237
2238 # query params
2239 if ( exists $args{'storage'}) {
2240 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
2241 }
2242
2243 my $_body_data;
2244 # authentication setting, if any
2245 my $auth_settings = [qw(JWT )];
2246
2247 # make the API Call
2248 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2249 $query_params, $form_params,
2250 $header_params, $_body_data, $auth_settings);
2251 if (!$response) {
2252 return;
2253 }
2254 my $_response_object = $self->{api_client}->deserialize('File', $response);
2255 return $_response_object;
2256 }
2257
2258 #
2259 # post_triangulate_original
2260 #
2261 # Triangulate whole file and save to original file
2262 #
2263 # @param string $name The file's mame (required)
2264 # @param string $folder The folder for source file (optional)
2265 # @param string $storage The storage type (optional)
2266 {
2267 my $params = {
2268 'name' => {
2269 data_type => 'string',
2270 description => 'The file's mame',
2271 required => '1',
2272 },
2273 'folder' => {
2274 data_type => 'string',
2275 description => 'The folder for source file',
2276 required => '0',
2277 },
2278 'storage' => {
2279 data_type => 'string',
2280 description => 'The storage type',
2281 required => '0',
2282 },
2283 };
2284 __PACKAGE__->method_documentation->{ 'post_triangulate_original' } = {
2285 summary => 'Triangulate whole file and save to original file',
2286 params => $params,
2287 returns => 'File',
2288 };
2289 }
2290 # @return File
2291 #
2292 sub post_triangulate_original {
2293 my ($self, %args) = @_;
2294
2295 # verify the required parameter 'name' is set
2296 unless (exists $args{'name'}) {
2297 croak("Missing the required parameter 'name' when calling post_triangulate_original");
2298 }
2299
2300 # parse inputs
2301 my $_resource_path = '/3d/triangulate/original';
2302
2303 my $_method = 'POST';
2304 my $query_params = {};
2305 my $header_params = {};
2306 my $form_params = {};
2307
2308 # 'Accept' and 'Content-Type' header
2309 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2310 if ($_header_accept) {
2311 $header_params->{'Accept'} = $_header_accept;
2312 }
2313 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
2314
2315 # query params
2316 if ( exists $args{'name'}) {
2317 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
2318 }
2319
2320 # query params
2321 if ( exists $args{'folder'}) {
2322 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
2323 }
2324
2325 # query params
2326 if ( exists $args{'storage'}) {
2327 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
2328 }
2329
2330 my $_body_data;
2331 # authentication setting, if any
2332 my $auth_settings = [qw(JWT )];
2333
2334 # make the API Call
2335 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2336 $query_params, $form_params,
2337 $header_params, $_body_data, $auth_settings);
2338 if (!$response) {
2339 return;
2340 }
2341 my $_response_object = $self->{api_client}->deserialize('File', $response);
2342 return $_response_object;
2343 }
2344
2345 #
2346 # post_triangulate_part
2347 #
2348 # Triangulate part of the scene(Specified by OAP) and save the scene to different file
2349 #
2350 # @param string $name The file's mame (required)
2351 # @param string $objectaddressingpath The node or mesh getted by OAP. (required)
2352 # @param string $newfilename The new file's mame (required)
2353 # @param string $newformat The new file's format (required)
2354 # @param string $folder The folder for source file (optional)
2355 # @param string $storage The storage type (optional)
2356 {
2357 my $params = {
2358 'name' => {
2359 data_type => 'string',
2360 description => 'The file's mame',
2361 required => '1',
2362 },
2363 'objectaddressingpath' => {
2364 data_type => 'string',
2365 description => 'The node or mesh getted by OAP.',
2366 required => '1',
2367 },
2368 'newfilename' => {
2369 data_type => 'string',
2370 description => 'The new file's mame',
2371 required => '1',
2372 },
2373 'newformat' => {
2374 data_type => 'string',
2375 description => 'The new file's format',
2376 required => '1',
2377 },
2378 'folder' => {
2379 data_type => 'string',
2380 description => 'The folder for source file',
2381 required => '0',
2382 },
2383 'storage' => {
2384 data_type => 'string',
2385 description => 'The storage type',
2386 required => '0',
2387 },
2388 };
2389 __PACKAGE__->method_documentation->{ 'post_triangulate_part' } = {
2390 summary => 'Triangulate part of the scene(Specified by OAP) and save the scene to different file ',
2391 params => $params,
2392 returns => 'File',
2393 };
2394 }
2395 # @return File
2396 #
2397 sub post_triangulate_part {
2398 my ($self, %args) = @_;
2399
2400 # verify the required parameter 'name' is set
2401 unless (exists $args{'name'}) {
2402 croak("Missing the required parameter 'name' when calling post_triangulate_part");
2403 }
2404
2405 # verify the required parameter 'objectaddressingpath' is set
2406 unless (exists $args{'objectaddressingpath'}) {
2407 croak("Missing the required parameter 'objectaddressingpath' when calling post_triangulate_part");
2408 }
2409
2410 # verify the required parameter 'newfilename' is set
2411 unless (exists $args{'newfilename'}) {
2412 croak("Missing the required parameter 'newfilename' when calling post_triangulate_part");
2413 }
2414
2415 # verify the required parameter 'newformat' is set
2416 unless (exists $args{'newformat'}) {
2417 croak("Missing the required parameter 'newformat' when calling post_triangulate_part");
2418 }
2419
2420 # parse inputs
2421 my $_resource_path = '/3d/triangulate/part';
2422
2423 my $_method = 'POST';
2424 my $query_params = {};
2425 my $header_params = {};
2426 my $form_params = {};
2427
2428 # 'Accept' and 'Content-Type' header
2429 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2430 if ($_header_accept) {
2431 $header_params->{'Accept'} = $_header_accept;
2432 }
2433 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
2434
2435 # query params
2436 if ( exists $args{'name'}) {
2437 $query_params->{'name'} = $self->{api_client}->to_query_value($args{'name'});
2438 }
2439
2440 # query params
2441 if ( exists $args{'objectaddressingpath'}) {
2442 $query_params->{'objectaddressingpath'} = $self->{api_client}->to_query_value($args{'objectaddressingpath'});
2443 }
2444
2445 # query params
2446 if ( exists $args{'newfilename'}) {
2447 $query_params->{'newfilename'} = $self->{api_client}->to_query_value($args{'newfilename'});
2448 }
2449
2450 # query params
2451 if ( exists $args{'newformat'}) {
2452 $query_params->{'newformat'} = $self->{api_client}->to_query_value($args{'newformat'});
2453 }
2454
2455 # query params
2456 if ( exists $args{'folder'}) {
2457 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
2458 }
2459
2460 # query params
2461 if ( exists $args{'storage'}) {
2462 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
2463 }
2464
2465 my $_body_data;
2466 # authentication setting, if any
2467 my $auth_settings = [qw(JWT )];
2468
2469 # make the API Call
2470 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2471 $query_params, $form_params,
2472 $header_params, $_body_data, $auth_settings);
2473 if (!$response) {
2474 return;
2475 }
2476 my $_response_object = $self->{api_client}->deserialize('File', $response);
2477 return $_response_object;
2478 }
2479
2480 #
2481 # storage_exists
2482 #
2483 # Check if storage exists
2484 #
2485 # @param string $storage_name Storage name (required)
2486 {
2487 my $params = {
2488 'storage_name' => {
2489 data_type => 'string',
2490 description => 'Storage name',
2491 required => '1',
2492 },
2493 };
2494 __PACKAGE__->method_documentation->{ 'storage_exists' } = {
2495 summary => 'Check if storage exists',
2496 params => $params,
2497 returns => 'StorageExist',
2498 };
2499 }
2500 # @return StorageExist
2501 #
2502 sub storage_exists {
2503 my ($self, %args) = @_;
2504
2505 # verify the required parameter 'storage_name' is set
2506 unless (exists $args{'storage_name'}) {
2507 croak("Missing the required parameter 'storage_name' when calling storage_exists");
2508 }
2509
2510 # parse inputs
2511 my $_resource_path = '/3d/storage/{storageName}/exist';
2512
2513 my $_method = 'GET';
2514 my $query_params = {};
2515 my $header_params = {};
2516 my $form_params = {};
2517
2518 # 'Accept' and 'Content-Type' header
2519 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2520 if ($_header_accept) {
2521 $header_params->{'Accept'} = $_header_accept;
2522 }
2523 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
2524
2525 # path params
2526 if ( exists $args{'storage_name'}) {
2527 my $_base_variable = "{" . "storageName" . "}";
2528 my $_base_value = $self->{api_client}->to_path_value($args{'storage_name'});
2529 $_resource_path =~ s/$_base_variable/$_base_value/g;
2530 }
2531
2532 my $_body_data;
2533 # authentication setting, if any
2534 my $auth_settings = [qw(JWT )];
2535
2536 # make the API Call
2537 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2538 $query_params, $form_params,
2539 $header_params, $_body_data, $auth_settings);
2540 if (!$response) {
2541 return;
2542 }
2543 my $_response_object = $self->{api_client}->deserialize('StorageExist', $response);
2544 return $_response_object;
2545 }
2546
2547 #
2548 # upload_file
2549 #
2550 # Upload file
2551 #
2552 # @param string $path Path where to upload including filename and extension e.g. /file.ext or /Folder 1/file.ext If the content is multipart and path does not contains the file name it tries to get them from filename parameter from Content-Disposition header. (required)
2553 # @param File $file File to upload (required)
2554 # @param string $storage_name Storage name (optional)
2555 {
2556 my $params = {
2557 'path' => {
2558 data_type => 'string',
2559 description => 'Path where to upload including filename and extension e.g. /file.ext or /Folder 1/file.ext If the content is multipart and path does not contains the file name it tries to get them from filename parameter from Content-Disposition header. ',
2560 required => '1',
2561 },
2562 'file' => {
2563 data_type => 'File',
2564 description => 'File to upload',
2565 required => '1',
2566 },
2567 'storage_name' => {
2568 data_type => 'string',
2569 description => 'Storage name',
2570 required => '0',
2571 },
2572 };
2573 __PACKAGE__->method_documentation->{ 'upload_file' } = {
2574 summary => 'Upload file',
2575 params => $params,
2576 returns => 'FilesUploadResult',
2577 };
2578 }
2579 # @return FilesUploadResult
2580 #
2581 sub upload_file {
2582 my ($self, %args) = @_;
2583
2584 # verify the required parameter 'path' is set
2585 unless (exists $args{'path'}) {
2586 croak("Missing the required parameter 'path' when calling upload_file");
2587 }
2588
2589 # verify the required parameter 'file' is set
2590 unless (exists $args{'file'}) {
2591 croak("Missing the required parameter 'file' when calling upload_file");
2592 }
2593
2594 # parse inputs
2595 my $_resource_path = '/3d/storage/file/{path}';
2596
2597 my $_method = 'PUT';
2598 my $query_params = {};
2599 my $header_params = {};
2600 my $form_params = {};
2601
2602 # 'Accept' and 'Content-Type' header
2603 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
2604 if ($_header_accept) {
2605 $header_params->{'Accept'} = $_header_accept;
2606 }
2607 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
2608
2609 # query params
2610 if ( exists $args{'storage_name'}) {
2611 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
2612 }
2613
2614 # path params
2615 if ( exists $args{'path'}) {
2616 my $_base_variable = "{" . "path" . "}";
2617 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
2618 $_resource_path =~ s/$_base_variable/$_base_value/g;
2619 }
2620
2621 # form params
2622 if ( exists $args{'file'} ) {
2623 $form_params->{'File'} = [] unless defined $form_params->{'File'};
2624 push @{$form_params->{'File'}}, $args{'file'};
2625 }
2626
2627 my $_body_data;
2628 # authentication setting, if any
2629 my $auth_settings = [qw(JWT )];
2630
2631 # make the API Call
2632 my $response = $self->{api_client}->call_api($_resource_path, $_method,
2633 $query_params, $form_params,
2634 $header_params, $_body_data, $auth_settings);
2635 if (!$response) {
2636 return;
2637 }
2638 my $_response_object = $self->{api_client}->deserialize('FilesUploadResult', $response);
2639 return $_response_object;
2640 }
2641
2642 1;