blob: 20ea691237af4fb6e9a6d8a3d5937d4ad2cec0f2 [file] [log] [blame]
Matteo Scandolo3308d082015-12-02 11:30:46 -08001/*jshint -W069 */
2/*global angular:false */
3angular.module('xos.xos', [])
4 .factory('xos', ['$q', '$http', '$rootScope', function($q, $http, $rootScope) {
5 'use strict';
6
7 /**
8 *
9 * @class xos
10 * @param {(string|object)} [domainOrOptions] - The project domain or options object. If object, see the object's optional properties.
11 * @param {string} [domainOrOptions.domain] - The project domain
12 * @param {string} [domainOrOptions.cache] - An angularjs cache implementation
13 * @param {object} [domainOrOptions.token] - auth token - object with value property and optional headerOrQueryName and isQuery properties
14 * @param {string} [cache] - An angularjs cache implementation
15 */
16 var xos = (function() {
17 function xos(options, cache) {
18 var domain = (typeof options === 'object') ? options.domain : options;
19 this.domain = typeof(domain) === 'string' ? domain : 'http://localhost:9999';
20 cache = cache || ((typeof options === 'object') ? options.cache : cache);
21 this.cache = cache;
22 }
23
24 xos.prototype.$on = function($scope, path, handler) {
25 var url = domain + path;
26 $scope.$on(url, function() {
27 handler();
28 });
29 return this;
30 };
31
32 xos.prototype.$broadcast = function(path) {
33 var url = domain + path;
34 //cache.remove(url);
35 $rootScope.$broadcast(url);
36 return this;
37 };
38
39 xos.transformRequest = function(obj) {
40 var str = [];
41 for (var p in obj) {
42 var val = obj[p];
43 if (angular.isArray(val)) {
44 val.forEach(function(val) {
45 str.push(encodeURIComponent(p) + "=" + encodeURIComponent(val));
46 });
47 } else {
48 str.push(encodeURIComponent(p) + "=" + encodeURIComponent(val));
49 }
50 }
51 return str.join("&");
52 };
53
54 /**
55 *
56 * @method
57 * @name xos#Api_Root_GET
58 *
59 */
60 xos.prototype.Api_Root_GET = function(parameters) {
61 if (parameters === undefined) {
62 parameters = {};
63 }
64 var deferred = $q.defer();
65
66 var domain = this.domain;
67 var path = '/xos/';
68
69 var body;
70 var queryParameters = {};
71 var headers = {};
72 var form = {};
73
74 if (parameters.$queryParameters) {
75 Object.keys(parameters.$queryParameters)
76 .forEach(function(parameterName) {
77 var parameter = parameters.$queryParameters[parameterName];
78 queryParameters[parameterName] = parameter;
79 });
80 }
81
82 var url = domain + path;
83 var cached = parameters.$cache && parameters.$cache.get(url);
84 if (cached !== undefined && parameters.$refresh !== true) {
85 deferred.resolve(cached);
86 return deferred.promise;
87 }
88 var options = {
89 timeout: parameters.$timeout,
90 method: 'GET',
91 url: url,
92 params: queryParameters,
93 data: body,
94 headers: headers
95 };
96 if (Object.keys(form).length > 0) {
97 options.data = form;
98 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
99 options.transformRequest = xos.transformRequest;
100 }
101 $http(options)
102 .success(function(data, status, headers, config) {
103 deferred.resolve(data);
104 if (parameters.$cache !== undefined) {
105 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
106 }
107 })
108 .error(function(data, status, headers, config) {
109 deferred.reject({
110 status: status,
111 headers: headers,
112 config: config,
113 body: data
114 });
115 });
116
117 return deferred.promise;
118 };
119 /**
120 *
121 * @method
122 * @name xos#Site_Role_List_GET
123 *
124 */
125 xos.prototype.Site_Role_List_GET = function(parameters) {
126 if (parameters === undefined) {
127 parameters = {};
128 }
129 var deferred = $q.defer();
130
131 var domain = this.domain;
132 var path = '/xos/site_roles/';
133
134 var body;
135 var queryParameters = {};
136 var headers = {};
137 var form = {};
138
139 if (parameters.$queryParameters) {
140 Object.keys(parameters.$queryParameters)
141 .forEach(function(parameterName) {
142 var parameter = parameters.$queryParameters[parameterName];
143 queryParameters[parameterName] = parameter;
144 });
145 }
146
147 var url = domain + path;
148 var cached = parameters.$cache && parameters.$cache.get(url);
149 if (cached !== undefined && parameters.$refresh !== true) {
150 deferred.resolve(cached);
151 return deferred.promise;
152 }
153 var options = {
154 timeout: parameters.$timeout,
155 method: 'GET',
156 url: url,
157 params: queryParameters,
158 data: body,
159 headers: headers
160 };
161 if (Object.keys(form).length > 0) {
162 options.data = form;
163 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
164 options.transformRequest = xos.transformRequest;
165 }
166 $http(options)
167 .success(function(data, status, headers, config) {
168 deferred.resolve(data);
169 if (parameters.$cache !== undefined) {
170 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
171 }
172 })
173 .error(function(data, status, headers, config) {
174 deferred.reject({
175 status: status,
176 headers: headers,
177 config: config,
178 body: data
179 });
180 });
181
182 return deferred.promise;
183 };
184 /**
185 *
186 * @method
187 * @name xos#Site_Role_List_POST
188 * @param {string} enacted -
189 * @param {string} policed -
190 * @param {string} backend_register -
191 * @param {string} backend_status -
192 * @param {boolean} deleted -
193 * @param {boolean} write_protect -
194 * @param {boolean} lazy_blocked -
195 * @param {boolean} no_sync -
196 * @param {choice} role -
197 *
198 */
199 xos.prototype.Site_Role_List_POST = function(parameters) {
200 if (parameters === undefined) {
201 parameters = {};
202 }
203 var deferred = $q.defer();
204
205 var domain = this.domain;
206 var path = '/xos/site_roles/';
207
208 var body;
209 var queryParameters = {};
210 var headers = {};
211 var form = {};
212
213 if (parameters['enacted'] !== undefined) {
214 form['enacted'] = parameters['enacted'];
215 }
216
217 if (parameters['policed'] !== undefined) {
218 form['policed'] = parameters['policed'];
219 }
220
221 if (parameters['backend_register'] !== undefined) {
222 form['backend_register'] = parameters['backend_register'];
223 }
224
225 if (parameters['backend_status'] !== undefined) {
226 form['backend_status'] = parameters['backend_status'];
227 }
228
229 if (parameters['backend_status'] === undefined) {
230 deferred.reject(new Error('Missing required form parameter: backend_status'));
231 return deferred.promise;
232 }
233
234 if (parameters['deleted'] !== undefined) {
235 form['deleted'] = parameters['deleted'];
236 }
237
238 if (parameters['write_protect'] !== undefined) {
239 form['write_protect'] = parameters['write_protect'];
240 }
241
242 if (parameters['lazy_blocked'] !== undefined) {
243 form['lazy_blocked'] = parameters['lazy_blocked'];
244 }
245
246 if (parameters['no_sync'] !== undefined) {
247 form['no_sync'] = parameters['no_sync'];
248 }
249
250 if (parameters['role'] !== undefined) {
251 form['role'] = parameters['role'];
252 }
253
254 if (parameters['role'] === undefined) {
255 deferred.reject(new Error('Missing required form parameter: role'));
256 return deferred.promise;
257 }
258
259 if (parameters.$queryParameters) {
260 Object.keys(parameters.$queryParameters)
261 .forEach(function(parameterName) {
262 var parameter = parameters.$queryParameters[parameterName];
263 queryParameters[parameterName] = parameter;
264 });
265 }
266
267 var url = domain + path;
268 var options = {
269 timeout: parameters.$timeout,
270 method: 'POST',
271 url: url,
272 params: queryParameters,
273 data: body,
274 headers: headers
275 };
276 if (Object.keys(form).length > 0) {
277 options.data = form;
278 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
279 options.transformRequest = xos.transformRequest;
280 }
281 $http(options)
282 .success(function(data, status, headers, config) {
283 deferred.resolve(data);
284 if (parameters.$cache !== undefined) {
285 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
286 }
287 })
288 .error(function(data, status, headers, config) {
289 deferred.reject({
290 status: status,
291 headers: headers,
292 config: config,
293 body: data
294 });
295 });
296
297 return deferred.promise;
298 };
299 /**
300 *
301 * @method
302 * @name xos#Site_Role_Detail_GET
303 * @param {string} pk -
304 *
305 */
306 xos.prototype.Site_Role_Detail_GET = function(parameters) {
307 if (parameters === undefined) {
308 parameters = {};
309 }
310 var deferred = $q.defer();
311
312 var domain = this.domain;
313 var path = '/xos/site_roles/{pk}/';
314
315 var body;
316 var queryParameters = {};
317 var headers = {};
318 var form = {};
319
320 path = path.replace('{pk}', parameters['pk']);
321
322 if (parameters['pk'] === undefined) {
323 deferred.reject(new Error('Missing required path parameter: pk'));
324 return deferred.promise;
325 }
326
327 if (parameters.$queryParameters) {
328 Object.keys(parameters.$queryParameters)
329 .forEach(function(parameterName) {
330 var parameter = parameters.$queryParameters[parameterName];
331 queryParameters[parameterName] = parameter;
332 });
333 }
334
335 var url = domain + path;
336 var cached = parameters.$cache && parameters.$cache.get(url);
337 if (cached !== undefined && parameters.$refresh !== true) {
338 deferred.resolve(cached);
339 return deferred.promise;
340 }
341 var options = {
342 timeout: parameters.$timeout,
343 method: 'GET',
344 url: url,
345 params: queryParameters,
346 data: body,
347 headers: headers
348 };
349 if (Object.keys(form).length > 0) {
350 options.data = form;
351 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
352 options.transformRequest = xos.transformRequest;
353 }
354 $http(options)
355 .success(function(data, status, headers, config) {
356 deferred.resolve(data);
357 if (parameters.$cache !== undefined) {
358 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
359 }
360 })
361 .error(function(data, status, headers, config) {
362 deferred.reject({
363 status: status,
364 headers: headers,
365 config: config,
366 body: data
367 });
368 });
369
370 return deferred.promise;
371 };
372 /**
373 *
374 * @method
375 * @name xos#Site_Role_Detail_PUT
376 * @param {string} pk -
377 * @param {string} enacted -
378 * @param {string} policed -
379 * @param {string} backend_register -
380 * @param {string} backend_status -
381 * @param {boolean} deleted -
382 * @param {boolean} write_protect -
383 * @param {boolean} lazy_blocked -
384 * @param {boolean} no_sync -
385 * @param {choice} role -
386 *
387 */
388 xos.prototype.Site_Role_Detail_PUT = function(parameters) {
389 if (parameters === undefined) {
390 parameters = {};
391 }
392 var deferred = $q.defer();
393
394 var domain = this.domain;
395 var path = '/xos/site_roles/{pk}/';
396
397 var body;
398 var queryParameters = {};
399 var headers = {};
400 var form = {};
401
402 path = path.replace('{pk}', parameters['pk']);
403
404 if (parameters['pk'] === undefined) {
405 deferred.reject(new Error('Missing required path parameter: pk'));
406 return deferred.promise;
407 }
408
409 if (parameters['enacted'] !== undefined) {
410 form['enacted'] = parameters['enacted'];
411 }
412
413 if (parameters['policed'] !== undefined) {
414 form['policed'] = parameters['policed'];
415 }
416
417 if (parameters['backend_register'] !== undefined) {
418 form['backend_register'] = parameters['backend_register'];
419 }
420
421 if (parameters['backend_status'] !== undefined) {
422 form['backend_status'] = parameters['backend_status'];
423 }
424
425 if (parameters['backend_status'] === undefined) {
426 deferred.reject(new Error('Missing required form parameter: backend_status'));
427 return deferred.promise;
428 }
429
430 if (parameters['deleted'] !== undefined) {
431 form['deleted'] = parameters['deleted'];
432 }
433
434 if (parameters['write_protect'] !== undefined) {
435 form['write_protect'] = parameters['write_protect'];
436 }
437
438 if (parameters['lazy_blocked'] !== undefined) {
439 form['lazy_blocked'] = parameters['lazy_blocked'];
440 }
441
442 if (parameters['no_sync'] !== undefined) {
443 form['no_sync'] = parameters['no_sync'];
444 }
445
446 if (parameters['role'] !== undefined) {
447 form['role'] = parameters['role'];
448 }
449
450 if (parameters['role'] === undefined) {
451 deferred.reject(new Error('Missing required form parameter: role'));
452 return deferred.promise;
453 }
454
455 if (parameters.$queryParameters) {
456 Object.keys(parameters.$queryParameters)
457 .forEach(function(parameterName) {
458 var parameter = parameters.$queryParameters[parameterName];
459 queryParameters[parameterName] = parameter;
460 });
461 }
462
463 var url = domain + path;
464 var options = {
465 timeout: parameters.$timeout,
466 method: 'PUT',
467 url: url,
468 params: queryParameters,
469 data: body,
470 headers: headers
471 };
472 if (Object.keys(form).length > 0) {
473 options.data = form;
474 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
475 options.transformRequest = xos.transformRequest;
476 }
477 $http(options)
478 .success(function(data, status, headers, config) {
479 deferred.resolve(data);
480 if (parameters.$cache !== undefined) {
481 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
482 }
483 })
484 .error(function(data, status, headers, config) {
485 deferred.reject({
486 status: status,
487 headers: headers,
488 config: config,
489 body: data
490 });
491 });
492
493 return deferred.promise;
494 };
495 /**
496 *
497 * @method
498 * @name xos#Site_Role_Detail_PATCH
499 * @param {string} pk -
500 * @param {string} enacted -
501 * @param {string} policed -
502 * @param {string} backend_register -
503 * @param {string} backend_status -
504 * @param {boolean} deleted -
505 * @param {boolean} write_protect -
506 * @param {boolean} lazy_blocked -
507 * @param {boolean} no_sync -
508 * @param {choice} role -
509 *
510 */
511 xos.prototype.Site_Role_Detail_PATCH = function(parameters) {
512 if (parameters === undefined) {
513 parameters = {};
514 }
515 var deferred = $q.defer();
516
517 var domain = this.domain;
518 var path = '/xos/site_roles/{pk}/';
519
520 var body;
521 var queryParameters = {};
522 var headers = {};
523 var form = {};
524
525 path = path.replace('{pk}', parameters['pk']);
526
527 if (parameters['pk'] === undefined) {
528 deferred.reject(new Error('Missing required path parameter: pk'));
529 return deferred.promise;
530 }
531
532 if (parameters['enacted'] !== undefined) {
533 form['enacted'] = parameters['enacted'];
534 }
535
536 if (parameters['policed'] !== undefined) {
537 form['policed'] = parameters['policed'];
538 }
539
540 if (parameters['backend_register'] !== undefined) {
541 form['backend_register'] = parameters['backend_register'];
542 }
543
544 if (parameters['backend_status'] !== undefined) {
545 form['backend_status'] = parameters['backend_status'];
546 }
547
548 if (parameters['deleted'] !== undefined) {
549 form['deleted'] = parameters['deleted'];
550 }
551
552 if (parameters['write_protect'] !== undefined) {
553 form['write_protect'] = parameters['write_protect'];
554 }
555
556 if (parameters['lazy_blocked'] !== undefined) {
557 form['lazy_blocked'] = parameters['lazy_blocked'];
558 }
559
560 if (parameters['no_sync'] !== undefined) {
561 form['no_sync'] = parameters['no_sync'];
562 }
563
564 if (parameters['role'] !== undefined) {
565 form['role'] = parameters['role'];
566 }
567
568 if (parameters.$queryParameters) {
569 Object.keys(parameters.$queryParameters)
570 .forEach(function(parameterName) {
571 var parameter = parameters.$queryParameters[parameterName];
572 queryParameters[parameterName] = parameter;
573 });
574 }
575
576 var url = domain + path;
577 var options = {
578 timeout: parameters.$timeout,
579 method: 'PATCH',
580 url: url,
581 params: queryParameters,
582 data: body,
583 headers: headers
584 };
585 if (Object.keys(form).length > 0) {
586 options.data = form;
587 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
588 options.transformRequest = xos.transformRequest;
589 }
590 $http(options)
591 .success(function(data, status, headers, config) {
592 deferred.resolve(data);
593 if (parameters.$cache !== undefined) {
594 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
595 }
596 })
597 .error(function(data, status, headers, config) {
598 deferred.reject({
599 status: status,
600 headers: headers,
601 config: config,
602 body: data
603 });
604 });
605
606 return deferred.promise;
607 };
608 /**
609 *
610 * @method
611 * @name xos#Site_Role_Detail_DELETE
612 * @param {string} pk -
613 *
614 */
615 xos.prototype.Site_Role_Detail_DELETE = function(parameters) {
616 if (parameters === undefined) {
617 parameters = {};
618 }
619 var deferred = $q.defer();
620
621 var domain = this.domain;
622 var path = '/xos/site_roles/{pk}/';
623
624 var body;
625 var queryParameters = {};
626 var headers = {};
627 var form = {};
628
629 path = path.replace('{pk}', parameters['pk']);
630
631 if (parameters['pk'] === undefined) {
632 deferred.reject(new Error('Missing required path parameter: pk'));
633 return deferred.promise;
634 }
635
636 if (parameters.$queryParameters) {
637 Object.keys(parameters.$queryParameters)
638 .forEach(function(parameterName) {
639 var parameter = parameters.$queryParameters[parameterName];
640 queryParameters[parameterName] = parameter;
641 });
642 }
643
644 var url = domain + path;
645 var options = {
646 timeout: parameters.$timeout,
647 method: 'DELETE',
648 url: url,
649 params: queryParameters,
650 data: body,
651 headers: headers
652 };
653 if (Object.keys(form).length > 0) {
654 options.data = form;
655 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
656 options.transformRequest = xos.transformRequest;
657 }
658 $http(options)
659 .success(function(data, status, headers, config) {
660 deferred.resolve(data);
661 if (parameters.$cache !== undefined) {
662 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
663 }
664 })
665 .error(function(data, status, headers, config) {
666 deferred.reject({
667 status: status,
668 headers: headers,
669 config: config,
670 body: data
671 });
672 });
673
674 return deferred.promise;
675 };
676 /**
677 *
678 * @method
679 * @name xos#Service_Attribute_List_GET
680 *
681 */
682 xos.prototype.Service_Attribute_List_GET = function(parameters) {
683 if (parameters === undefined) {
684 parameters = {};
685 }
686 var deferred = $q.defer();
687
688 var domain = this.domain;
689 var path = '/xos/serviceattributes/';
690
691 var body;
692 var queryParameters = {};
693 var headers = {};
694 var form = {};
695
696 if (parameters.$queryParameters) {
697 Object.keys(parameters.$queryParameters)
698 .forEach(function(parameterName) {
699 var parameter = parameters.$queryParameters[parameterName];
700 queryParameters[parameterName] = parameter;
701 });
702 }
703
704 var url = domain + path;
705 var cached = parameters.$cache && parameters.$cache.get(url);
706 if (cached !== undefined && parameters.$refresh !== true) {
707 deferred.resolve(cached);
708 return deferred.promise;
709 }
710 var options = {
711 timeout: parameters.$timeout,
712 method: 'GET',
713 url: url,
714 params: queryParameters,
715 data: body,
716 headers: headers
717 };
718 if (Object.keys(form).length > 0) {
719 options.data = form;
720 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
721 options.transformRequest = xos.transformRequest;
722 }
723 $http(options)
724 .success(function(data, status, headers, config) {
725 deferred.resolve(data);
726 if (parameters.$cache !== undefined) {
727 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
728 }
729 })
730 .error(function(data, status, headers, config) {
731 deferred.reject({
732 status: status,
733 headers: headers,
734 config: config,
735 body: data
736 });
737 });
738
739 return deferred.promise;
740 };
741 /**
742 *
743 * @method
744 * @name xos#Service_Attribute_List_POST
745 * @param {string} enacted -
746 * @param {string} policed -
747 * @param {string} backend_register -
748 * @param {string} backend_status -
749 * @param {boolean} deleted -
750 * @param {boolean} write_protect -
751 * @param {boolean} lazy_blocked -
752 * @param {boolean} no_sync -
753 * @param {string} name - Attribute Name
754 * @param {string} value - Attribute Value
755 * @param {string} service - The Service this attribute is associated with
756 *
757 */
758 xos.prototype.Service_Attribute_List_POST = function(parameters) {
759 if (parameters === undefined) {
760 parameters = {};
761 }
762 var deferred = $q.defer();
763
764 var domain = this.domain;
765 var path = '/xos/serviceattributes/';
766
767 var body;
768 var queryParameters = {};
769 var headers = {};
770 var form = {};
771
772 if (parameters['enacted'] !== undefined) {
773 form['enacted'] = parameters['enacted'];
774 }
775
776 if (parameters['policed'] !== undefined) {
777 form['policed'] = parameters['policed'];
778 }
779
780 if (parameters['backend_register'] !== undefined) {
781 form['backend_register'] = parameters['backend_register'];
782 }
783
784 if (parameters['backend_status'] !== undefined) {
785 form['backend_status'] = parameters['backend_status'];
786 }
787
788 if (parameters['backend_status'] === undefined) {
789 deferred.reject(new Error('Missing required form parameter: backend_status'));
790 return deferred.promise;
791 }
792
793 if (parameters['deleted'] !== undefined) {
794 form['deleted'] = parameters['deleted'];
795 }
796
797 if (parameters['write_protect'] !== undefined) {
798 form['write_protect'] = parameters['write_protect'];
799 }
800
801 if (parameters['lazy_blocked'] !== undefined) {
802 form['lazy_blocked'] = parameters['lazy_blocked'];
803 }
804
805 if (parameters['no_sync'] !== undefined) {
806 form['no_sync'] = parameters['no_sync'];
807 }
808
809 if (parameters['name'] !== undefined) {
810 form['name'] = parameters['name'];
811 }
812
813 if (parameters['name'] === undefined) {
814 deferred.reject(new Error('Missing required form parameter: name'));
815 return deferred.promise;
816 }
817
818 if (parameters['value'] !== undefined) {
819 form['value'] = parameters['value'];
820 }
821
822 if (parameters['value'] === undefined) {
823 deferred.reject(new Error('Missing required form parameter: value'));
824 return deferred.promise;
825 }
826
827 if (parameters['service'] !== undefined) {
828 form['service'] = parameters['service'];
829 }
830
831 if (parameters['service'] === undefined) {
832 deferred.reject(new Error('Missing required form parameter: service'));
833 return deferred.promise;
834 }
835
836 if (parameters.$queryParameters) {
837 Object.keys(parameters.$queryParameters)
838 .forEach(function(parameterName) {
839 var parameter = parameters.$queryParameters[parameterName];
840 queryParameters[parameterName] = parameter;
841 });
842 }
843
844 var url = domain + path;
845 var options = {
846 timeout: parameters.$timeout,
847 method: 'POST',
848 url: url,
849 params: queryParameters,
850 data: body,
851 headers: headers
852 };
853 if (Object.keys(form).length > 0) {
854 options.data = form;
855 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
856 options.transformRequest = xos.transformRequest;
857 }
858 $http(options)
859 .success(function(data, status, headers, config) {
860 deferred.resolve(data);
861 if (parameters.$cache !== undefined) {
862 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
863 }
864 })
865 .error(function(data, status, headers, config) {
866 deferred.reject({
867 status: status,
868 headers: headers,
869 config: config,
870 body: data
871 });
872 });
873
874 return deferred.promise;
875 };
876 /**
877 *
878 * @method
879 * @name xos#Service_Attribute_Detail_GET
880 * @param {string} pk -
881 *
882 */
883 xos.prototype.Service_Attribute_Detail_GET = function(parameters) {
884 if (parameters === undefined) {
885 parameters = {};
886 }
887 var deferred = $q.defer();
888
889 var domain = this.domain;
890 var path = '/xos/serviceattributes/{pk}/';
891
892 var body;
893 var queryParameters = {};
894 var headers = {};
895 var form = {};
896
897 path = path.replace('{pk}', parameters['pk']);
898
899 if (parameters['pk'] === undefined) {
900 deferred.reject(new Error('Missing required path parameter: pk'));
901 return deferred.promise;
902 }
903
904 if (parameters.$queryParameters) {
905 Object.keys(parameters.$queryParameters)
906 .forEach(function(parameterName) {
907 var parameter = parameters.$queryParameters[parameterName];
908 queryParameters[parameterName] = parameter;
909 });
910 }
911
912 var url = domain + path;
913 var cached = parameters.$cache && parameters.$cache.get(url);
914 if (cached !== undefined && parameters.$refresh !== true) {
915 deferred.resolve(cached);
916 return deferred.promise;
917 }
918 var options = {
919 timeout: parameters.$timeout,
920 method: 'GET',
921 url: url,
922 params: queryParameters,
923 data: body,
924 headers: headers
925 };
926 if (Object.keys(form).length > 0) {
927 options.data = form;
928 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
929 options.transformRequest = xos.transformRequest;
930 }
931 $http(options)
932 .success(function(data, status, headers, config) {
933 deferred.resolve(data);
934 if (parameters.$cache !== undefined) {
935 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
936 }
937 })
938 .error(function(data, status, headers, config) {
939 deferred.reject({
940 status: status,
941 headers: headers,
942 config: config,
943 body: data
944 });
945 });
946
947 return deferred.promise;
948 };
949 /**
950 *
951 * @method
952 * @name xos#Service_Attribute_Detail_PUT
953 * @param {string} pk -
954 * @param {string} enacted -
955 * @param {string} policed -
956 * @param {string} backend_register -
957 * @param {string} backend_status -
958 * @param {boolean} deleted -
959 * @param {boolean} write_protect -
960 * @param {boolean} lazy_blocked -
961 * @param {boolean} no_sync -
962 * @param {string} name - Attribute Name
963 * @param {string} value - Attribute Value
964 * @param {string} service - The Service this attribute is associated with
965 *
966 */
967 xos.prototype.Service_Attribute_Detail_PUT = function(parameters) {
968 if (parameters === undefined) {
969 parameters = {};
970 }
971 var deferred = $q.defer();
972
973 var domain = this.domain;
974 var path = '/xos/serviceattributes/{pk}/';
975
976 var body;
977 var queryParameters = {};
978 var headers = {};
979 var form = {};
980
981 path = path.replace('{pk}', parameters['pk']);
982
983 if (parameters['pk'] === undefined) {
984 deferred.reject(new Error('Missing required path parameter: pk'));
985 return deferred.promise;
986 }
987
988 if (parameters['enacted'] !== undefined) {
989 form['enacted'] = parameters['enacted'];
990 }
991
992 if (parameters['policed'] !== undefined) {
993 form['policed'] = parameters['policed'];
994 }
995
996 if (parameters['backend_register'] !== undefined) {
997 form['backend_register'] = parameters['backend_register'];
998 }
999
1000 if (parameters['backend_status'] !== undefined) {
1001 form['backend_status'] = parameters['backend_status'];
1002 }
1003
1004 if (parameters['backend_status'] === undefined) {
1005 deferred.reject(new Error('Missing required form parameter: backend_status'));
1006 return deferred.promise;
1007 }
1008
1009 if (parameters['deleted'] !== undefined) {
1010 form['deleted'] = parameters['deleted'];
1011 }
1012
1013 if (parameters['write_protect'] !== undefined) {
1014 form['write_protect'] = parameters['write_protect'];
1015 }
1016
1017 if (parameters['lazy_blocked'] !== undefined) {
1018 form['lazy_blocked'] = parameters['lazy_blocked'];
1019 }
1020
1021 if (parameters['no_sync'] !== undefined) {
1022 form['no_sync'] = parameters['no_sync'];
1023 }
1024
1025 if (parameters['name'] !== undefined) {
1026 form['name'] = parameters['name'];
1027 }
1028
1029 if (parameters['name'] === undefined) {
1030 deferred.reject(new Error('Missing required form parameter: name'));
1031 return deferred.promise;
1032 }
1033
1034 if (parameters['value'] !== undefined) {
1035 form['value'] = parameters['value'];
1036 }
1037
1038 if (parameters['value'] === undefined) {
1039 deferred.reject(new Error('Missing required form parameter: value'));
1040 return deferred.promise;
1041 }
1042
1043 if (parameters['service'] !== undefined) {
1044 form['service'] = parameters['service'];
1045 }
1046
1047 if (parameters['service'] === undefined) {
1048 deferred.reject(new Error('Missing required form parameter: service'));
1049 return deferred.promise;
1050 }
1051
1052 if (parameters.$queryParameters) {
1053 Object.keys(parameters.$queryParameters)
1054 .forEach(function(parameterName) {
1055 var parameter = parameters.$queryParameters[parameterName];
1056 queryParameters[parameterName] = parameter;
1057 });
1058 }
1059
1060 var url = domain + path;
1061 var options = {
1062 timeout: parameters.$timeout,
1063 method: 'PUT',
1064 url: url,
1065 params: queryParameters,
1066 data: body,
1067 headers: headers
1068 };
1069 if (Object.keys(form).length > 0) {
1070 options.data = form;
1071 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1072 options.transformRequest = xos.transformRequest;
1073 }
1074 $http(options)
1075 .success(function(data, status, headers, config) {
1076 deferred.resolve(data);
1077 if (parameters.$cache !== undefined) {
1078 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1079 }
1080 })
1081 .error(function(data, status, headers, config) {
1082 deferred.reject({
1083 status: status,
1084 headers: headers,
1085 config: config,
1086 body: data
1087 });
1088 });
1089
1090 return deferred.promise;
1091 };
1092 /**
1093 *
1094 * @method
1095 * @name xos#Service_Attribute_Detail_PATCH
1096 * @param {string} pk -
1097 * @param {string} enacted -
1098 * @param {string} policed -
1099 * @param {string} backend_register -
1100 * @param {string} backend_status -
1101 * @param {boolean} deleted -
1102 * @param {boolean} write_protect -
1103 * @param {boolean} lazy_blocked -
1104 * @param {boolean} no_sync -
1105 * @param {string} name - Attribute Name
1106 * @param {string} value - Attribute Value
1107 * @param {string} service - The Service this attribute is associated with
1108 *
1109 */
1110 xos.prototype.Service_Attribute_Detail_PATCH = function(parameters) {
1111 if (parameters === undefined) {
1112 parameters = {};
1113 }
1114 var deferred = $q.defer();
1115
1116 var domain = this.domain;
1117 var path = '/xos/serviceattributes/{pk}/';
1118
1119 var body;
1120 var queryParameters = {};
1121 var headers = {};
1122 var form = {};
1123
1124 path = path.replace('{pk}', parameters['pk']);
1125
1126 if (parameters['pk'] === undefined) {
1127 deferred.reject(new Error('Missing required path parameter: pk'));
1128 return deferred.promise;
1129 }
1130
1131 if (parameters['enacted'] !== undefined) {
1132 form['enacted'] = parameters['enacted'];
1133 }
1134
1135 if (parameters['policed'] !== undefined) {
1136 form['policed'] = parameters['policed'];
1137 }
1138
1139 if (parameters['backend_register'] !== undefined) {
1140 form['backend_register'] = parameters['backend_register'];
1141 }
1142
1143 if (parameters['backend_status'] !== undefined) {
1144 form['backend_status'] = parameters['backend_status'];
1145 }
1146
1147 if (parameters['deleted'] !== undefined) {
1148 form['deleted'] = parameters['deleted'];
1149 }
1150
1151 if (parameters['write_protect'] !== undefined) {
1152 form['write_protect'] = parameters['write_protect'];
1153 }
1154
1155 if (parameters['lazy_blocked'] !== undefined) {
1156 form['lazy_blocked'] = parameters['lazy_blocked'];
1157 }
1158
1159 if (parameters['no_sync'] !== undefined) {
1160 form['no_sync'] = parameters['no_sync'];
1161 }
1162
1163 if (parameters['name'] !== undefined) {
1164 form['name'] = parameters['name'];
1165 }
1166
1167 if (parameters['value'] !== undefined) {
1168 form['value'] = parameters['value'];
1169 }
1170
1171 if (parameters['service'] !== undefined) {
1172 form['service'] = parameters['service'];
1173 }
1174
1175 if (parameters.$queryParameters) {
1176 Object.keys(parameters.$queryParameters)
1177 .forEach(function(parameterName) {
1178 var parameter = parameters.$queryParameters[parameterName];
1179 queryParameters[parameterName] = parameter;
1180 });
1181 }
1182
1183 var url = domain + path;
1184 var options = {
1185 timeout: parameters.$timeout,
1186 method: 'PATCH',
1187 url: url,
1188 params: queryParameters,
1189 data: body,
1190 headers: headers
1191 };
1192 if (Object.keys(form).length > 0) {
1193 options.data = form;
1194 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1195 options.transformRequest = xos.transformRequest;
1196 }
1197 $http(options)
1198 .success(function(data, status, headers, config) {
1199 deferred.resolve(data);
1200 if (parameters.$cache !== undefined) {
1201 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1202 }
1203 })
1204 .error(function(data, status, headers, config) {
1205 deferred.reject({
1206 status: status,
1207 headers: headers,
1208 config: config,
1209 body: data
1210 });
1211 });
1212
1213 return deferred.promise;
1214 };
1215 /**
1216 *
1217 * @method
1218 * @name xos#Service_Attribute_Detail_DELETE
1219 * @param {string} pk -
1220 *
1221 */
1222 xos.prototype.Service_Attribute_Detail_DELETE = function(parameters) {
1223 if (parameters === undefined) {
1224 parameters = {};
1225 }
1226 var deferred = $q.defer();
1227
1228 var domain = this.domain;
1229 var path = '/xos/serviceattributes/{pk}/';
1230
1231 var body;
1232 var queryParameters = {};
1233 var headers = {};
1234 var form = {};
1235
1236 path = path.replace('{pk}', parameters['pk']);
1237
1238 if (parameters['pk'] === undefined) {
1239 deferred.reject(new Error('Missing required path parameter: pk'));
1240 return deferred.promise;
1241 }
1242
1243 if (parameters.$queryParameters) {
1244 Object.keys(parameters.$queryParameters)
1245 .forEach(function(parameterName) {
1246 var parameter = parameters.$queryParameters[parameterName];
1247 queryParameters[parameterName] = parameter;
1248 });
1249 }
1250
1251 var url = domain + path;
1252 var options = {
1253 timeout: parameters.$timeout,
1254 method: 'DELETE',
1255 url: url,
1256 params: queryParameters,
1257 data: body,
1258 headers: headers
1259 };
1260 if (Object.keys(form).length > 0) {
1261 options.data = form;
1262 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1263 options.transformRequest = xos.transformRequest;
1264 }
1265 $http(options)
1266 .success(function(data, status, headers, config) {
1267 deferred.resolve(data);
1268 if (parameters.$cache !== undefined) {
1269 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1270 }
1271 })
1272 .error(function(data, status, headers, config) {
1273 deferred.reject({
1274 status: status,
1275 headers: headers,
1276 config: config,
1277 body: data
1278 });
1279 });
1280
1281 return deferred.promise;
1282 };
1283 /**
1284 *
1285 * @method
1286 * @name xos#Controller_Images_List_GET
1287 *
1288 */
1289 xos.prototype.Controller_Images_List_GET = function(parameters) {
1290 if (parameters === undefined) {
1291 parameters = {};
1292 }
1293 var deferred = $q.defer();
1294
1295 var domain = this.domain;
1296 var path = '/xos/controllerimages/';
1297
1298 var body;
1299 var queryParameters = {};
1300 var headers = {};
1301 var form = {};
1302
1303 if (parameters.$queryParameters) {
1304 Object.keys(parameters.$queryParameters)
1305 .forEach(function(parameterName) {
1306 var parameter = parameters.$queryParameters[parameterName];
1307 queryParameters[parameterName] = parameter;
1308 });
1309 }
1310
1311 var url = domain + path;
1312 var cached = parameters.$cache && parameters.$cache.get(url);
1313 if (cached !== undefined && parameters.$refresh !== true) {
1314 deferred.resolve(cached);
1315 return deferred.promise;
1316 }
1317 var options = {
1318 timeout: parameters.$timeout,
1319 method: 'GET',
1320 url: url,
1321 params: queryParameters,
1322 data: body,
1323 headers: headers
1324 };
1325 if (Object.keys(form).length > 0) {
1326 options.data = form;
1327 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1328 options.transformRequest = xos.transformRequest;
1329 }
1330 $http(options)
1331 .success(function(data, status, headers, config) {
1332 deferred.resolve(data);
1333 if (parameters.$cache !== undefined) {
1334 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1335 }
1336 })
1337 .error(function(data, status, headers, config) {
1338 deferred.reject({
1339 status: status,
1340 headers: headers,
1341 config: config,
1342 body: data
1343 });
1344 });
1345
1346 return deferred.promise;
1347 };
1348 /**
1349 *
1350 * @method
1351 * @name xos#Controller_Images_List_POST
1352 * @param {string} enacted -
1353 * @param {string} policed -
1354 * @param {string} backend_register -
1355 * @param {string} backend_status -
1356 * @param {boolean} deleted -
1357 * @param {boolean} write_protect -
1358 * @param {boolean} lazy_blocked -
1359 * @param {boolean} no_sync -
1360 * @param {string} image -
1361 * @param {string} controller -
1362 * @param {string} glance_image_id - Glance image id
1363 *
1364 */
1365 xos.prototype.Controller_Images_List_POST = function(parameters) {
1366 if (parameters === undefined) {
1367 parameters = {};
1368 }
1369 var deferred = $q.defer();
1370
1371 var domain = this.domain;
1372 var path = '/xos/controllerimages/';
1373
1374 var body;
1375 var queryParameters = {};
1376 var headers = {};
1377 var form = {};
1378
1379 if (parameters['enacted'] !== undefined) {
1380 form['enacted'] = parameters['enacted'];
1381 }
1382
1383 if (parameters['policed'] !== undefined) {
1384 form['policed'] = parameters['policed'];
1385 }
1386
1387 if (parameters['backend_register'] !== undefined) {
1388 form['backend_register'] = parameters['backend_register'];
1389 }
1390
1391 if (parameters['backend_status'] !== undefined) {
1392 form['backend_status'] = parameters['backend_status'];
1393 }
1394
1395 if (parameters['backend_status'] === undefined) {
1396 deferred.reject(new Error('Missing required form parameter: backend_status'));
1397 return deferred.promise;
1398 }
1399
1400 if (parameters['deleted'] !== undefined) {
1401 form['deleted'] = parameters['deleted'];
1402 }
1403
1404 if (parameters['write_protect'] !== undefined) {
1405 form['write_protect'] = parameters['write_protect'];
1406 }
1407
1408 if (parameters['lazy_blocked'] !== undefined) {
1409 form['lazy_blocked'] = parameters['lazy_blocked'];
1410 }
1411
1412 if (parameters['no_sync'] !== undefined) {
1413 form['no_sync'] = parameters['no_sync'];
1414 }
1415
1416 if (parameters['image'] !== undefined) {
1417 form['image'] = parameters['image'];
1418 }
1419
1420 if (parameters['image'] === undefined) {
1421 deferred.reject(new Error('Missing required form parameter: image'));
1422 return deferred.promise;
1423 }
1424
1425 if (parameters['controller'] !== undefined) {
1426 form['controller'] = parameters['controller'];
1427 }
1428
1429 if (parameters['controller'] === undefined) {
1430 deferred.reject(new Error('Missing required form parameter: controller'));
1431 return deferred.promise;
1432 }
1433
1434 if (parameters['glance_image_id'] !== undefined) {
1435 form['glance_image_id'] = parameters['glance_image_id'];
1436 }
1437
1438 if (parameters.$queryParameters) {
1439 Object.keys(parameters.$queryParameters)
1440 .forEach(function(parameterName) {
1441 var parameter = parameters.$queryParameters[parameterName];
1442 queryParameters[parameterName] = parameter;
1443 });
1444 }
1445
1446 var url = domain + path;
1447 var options = {
1448 timeout: parameters.$timeout,
1449 method: 'POST',
1450 url: url,
1451 params: queryParameters,
1452 data: body,
1453 headers: headers
1454 };
1455 if (Object.keys(form).length > 0) {
1456 options.data = form;
1457 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1458 options.transformRequest = xos.transformRequest;
1459 }
1460 $http(options)
1461 .success(function(data, status, headers, config) {
1462 deferred.resolve(data);
1463 if (parameters.$cache !== undefined) {
1464 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1465 }
1466 })
1467 .error(function(data, status, headers, config) {
1468 deferred.reject({
1469 status: status,
1470 headers: headers,
1471 config: config,
1472 body: data
1473 });
1474 });
1475
1476 return deferred.promise;
1477 };
1478 /**
1479 *
1480 * @method
1481 * @name xos#Controller_Images_Detail_GET
1482 * @param {string} pk -
1483 *
1484 */
1485 xos.prototype.Controller_Images_Detail_GET = function(parameters) {
1486 if (parameters === undefined) {
1487 parameters = {};
1488 }
1489 var deferred = $q.defer();
1490
1491 var domain = this.domain;
1492 var path = '/xos/controllerimages/{pk}/';
1493
1494 var body;
1495 var queryParameters = {};
1496 var headers = {};
1497 var form = {};
1498
1499 path = path.replace('{pk}', parameters['pk']);
1500
1501 if (parameters['pk'] === undefined) {
1502 deferred.reject(new Error('Missing required path parameter: pk'));
1503 return deferred.promise;
1504 }
1505
1506 if (parameters.$queryParameters) {
1507 Object.keys(parameters.$queryParameters)
1508 .forEach(function(parameterName) {
1509 var parameter = parameters.$queryParameters[parameterName];
1510 queryParameters[parameterName] = parameter;
1511 });
1512 }
1513
1514 var url = domain + path;
1515 var cached = parameters.$cache && parameters.$cache.get(url);
1516 if (cached !== undefined && parameters.$refresh !== true) {
1517 deferred.resolve(cached);
1518 return deferred.promise;
1519 }
1520 var options = {
1521 timeout: parameters.$timeout,
1522 method: 'GET',
1523 url: url,
1524 params: queryParameters,
1525 data: body,
1526 headers: headers
1527 };
1528 if (Object.keys(form).length > 0) {
1529 options.data = form;
1530 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1531 options.transformRequest = xos.transformRequest;
1532 }
1533 $http(options)
1534 .success(function(data, status, headers, config) {
1535 deferred.resolve(data);
1536 if (parameters.$cache !== undefined) {
1537 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1538 }
1539 })
1540 .error(function(data, status, headers, config) {
1541 deferred.reject({
1542 status: status,
1543 headers: headers,
1544 config: config,
1545 body: data
1546 });
1547 });
1548
1549 return deferred.promise;
1550 };
1551 /**
1552 *
1553 * @method
1554 * @name xos#Controller_Images_Detail_PUT
1555 * @param {string} pk -
1556 * @param {string} enacted -
1557 * @param {string} policed -
1558 * @param {string} backend_register -
1559 * @param {string} backend_status -
1560 * @param {boolean} deleted -
1561 * @param {boolean} write_protect -
1562 * @param {boolean} lazy_blocked -
1563 * @param {boolean} no_sync -
1564 * @param {string} image -
1565 * @param {string} controller -
1566 * @param {string} glance_image_id - Glance image id
1567 *
1568 */
1569 xos.prototype.Controller_Images_Detail_PUT = function(parameters) {
1570 if (parameters === undefined) {
1571 parameters = {};
1572 }
1573 var deferred = $q.defer();
1574
1575 var domain = this.domain;
1576 var path = '/xos/controllerimages/{pk}/';
1577
1578 var body;
1579 var queryParameters = {};
1580 var headers = {};
1581 var form = {};
1582
1583 path = path.replace('{pk}', parameters['pk']);
1584
1585 if (parameters['pk'] === undefined) {
1586 deferred.reject(new Error('Missing required path parameter: pk'));
1587 return deferred.promise;
1588 }
1589
1590 if (parameters['enacted'] !== undefined) {
1591 form['enacted'] = parameters['enacted'];
1592 }
1593
1594 if (parameters['policed'] !== undefined) {
1595 form['policed'] = parameters['policed'];
1596 }
1597
1598 if (parameters['backend_register'] !== undefined) {
1599 form['backend_register'] = parameters['backend_register'];
1600 }
1601
1602 if (parameters['backend_status'] !== undefined) {
1603 form['backend_status'] = parameters['backend_status'];
1604 }
1605
1606 if (parameters['backend_status'] === undefined) {
1607 deferred.reject(new Error('Missing required form parameter: backend_status'));
1608 return deferred.promise;
1609 }
1610
1611 if (parameters['deleted'] !== undefined) {
1612 form['deleted'] = parameters['deleted'];
1613 }
1614
1615 if (parameters['write_protect'] !== undefined) {
1616 form['write_protect'] = parameters['write_protect'];
1617 }
1618
1619 if (parameters['lazy_blocked'] !== undefined) {
1620 form['lazy_blocked'] = parameters['lazy_blocked'];
1621 }
1622
1623 if (parameters['no_sync'] !== undefined) {
1624 form['no_sync'] = parameters['no_sync'];
1625 }
1626
1627 if (parameters['image'] !== undefined) {
1628 form['image'] = parameters['image'];
1629 }
1630
1631 if (parameters['image'] === undefined) {
1632 deferred.reject(new Error('Missing required form parameter: image'));
1633 return deferred.promise;
1634 }
1635
1636 if (parameters['controller'] !== undefined) {
1637 form['controller'] = parameters['controller'];
1638 }
1639
1640 if (parameters['controller'] === undefined) {
1641 deferred.reject(new Error('Missing required form parameter: controller'));
1642 return deferred.promise;
1643 }
1644
1645 if (parameters['glance_image_id'] !== undefined) {
1646 form['glance_image_id'] = parameters['glance_image_id'];
1647 }
1648
1649 if (parameters.$queryParameters) {
1650 Object.keys(parameters.$queryParameters)
1651 .forEach(function(parameterName) {
1652 var parameter = parameters.$queryParameters[parameterName];
1653 queryParameters[parameterName] = parameter;
1654 });
1655 }
1656
1657 var url = domain + path;
1658 var options = {
1659 timeout: parameters.$timeout,
1660 method: 'PUT',
1661 url: url,
1662 params: queryParameters,
1663 data: body,
1664 headers: headers
1665 };
1666 if (Object.keys(form).length > 0) {
1667 options.data = form;
1668 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1669 options.transformRequest = xos.transformRequest;
1670 }
1671 $http(options)
1672 .success(function(data, status, headers, config) {
1673 deferred.resolve(data);
1674 if (parameters.$cache !== undefined) {
1675 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1676 }
1677 })
1678 .error(function(data, status, headers, config) {
1679 deferred.reject({
1680 status: status,
1681 headers: headers,
1682 config: config,
1683 body: data
1684 });
1685 });
1686
1687 return deferred.promise;
1688 };
1689 /**
1690 *
1691 * @method
1692 * @name xos#Controller_Images_Detail_PATCH
1693 * @param {string} pk -
1694 * @param {string} enacted -
1695 * @param {string} policed -
1696 * @param {string} backend_register -
1697 * @param {string} backend_status -
1698 * @param {boolean} deleted -
1699 * @param {boolean} write_protect -
1700 * @param {boolean} lazy_blocked -
1701 * @param {boolean} no_sync -
1702 * @param {string} image -
1703 * @param {string} controller -
1704 * @param {string} glance_image_id - Glance image id
1705 *
1706 */
1707 xos.prototype.Controller_Images_Detail_PATCH = function(parameters) {
1708 if (parameters === undefined) {
1709 parameters = {};
1710 }
1711 var deferred = $q.defer();
1712
1713 var domain = this.domain;
1714 var path = '/xos/controllerimages/{pk}/';
1715
1716 var body;
1717 var queryParameters = {};
1718 var headers = {};
1719 var form = {};
1720
1721 path = path.replace('{pk}', parameters['pk']);
1722
1723 if (parameters['pk'] === undefined) {
1724 deferred.reject(new Error('Missing required path parameter: pk'));
1725 return deferred.promise;
1726 }
1727
1728 if (parameters['enacted'] !== undefined) {
1729 form['enacted'] = parameters['enacted'];
1730 }
1731
1732 if (parameters['policed'] !== undefined) {
1733 form['policed'] = parameters['policed'];
1734 }
1735
1736 if (parameters['backend_register'] !== undefined) {
1737 form['backend_register'] = parameters['backend_register'];
1738 }
1739
1740 if (parameters['backend_status'] !== undefined) {
1741 form['backend_status'] = parameters['backend_status'];
1742 }
1743
1744 if (parameters['deleted'] !== undefined) {
1745 form['deleted'] = parameters['deleted'];
1746 }
1747
1748 if (parameters['write_protect'] !== undefined) {
1749 form['write_protect'] = parameters['write_protect'];
1750 }
1751
1752 if (parameters['lazy_blocked'] !== undefined) {
1753 form['lazy_blocked'] = parameters['lazy_blocked'];
1754 }
1755
1756 if (parameters['no_sync'] !== undefined) {
1757 form['no_sync'] = parameters['no_sync'];
1758 }
1759
1760 if (parameters['image'] !== undefined) {
1761 form['image'] = parameters['image'];
1762 }
1763
1764 if (parameters['controller'] !== undefined) {
1765 form['controller'] = parameters['controller'];
1766 }
1767
1768 if (parameters['glance_image_id'] !== undefined) {
1769 form['glance_image_id'] = parameters['glance_image_id'];
1770 }
1771
1772 if (parameters.$queryParameters) {
1773 Object.keys(parameters.$queryParameters)
1774 .forEach(function(parameterName) {
1775 var parameter = parameters.$queryParameters[parameterName];
1776 queryParameters[parameterName] = parameter;
1777 });
1778 }
1779
1780 var url = domain + path;
1781 var options = {
1782 timeout: parameters.$timeout,
1783 method: 'PATCH',
1784 url: url,
1785 params: queryParameters,
1786 data: body,
1787 headers: headers
1788 };
1789 if (Object.keys(form).length > 0) {
1790 options.data = form;
1791 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1792 options.transformRequest = xos.transformRequest;
1793 }
1794 $http(options)
1795 .success(function(data, status, headers, config) {
1796 deferred.resolve(data);
1797 if (parameters.$cache !== undefined) {
1798 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1799 }
1800 })
1801 .error(function(data, status, headers, config) {
1802 deferred.reject({
1803 status: status,
1804 headers: headers,
1805 config: config,
1806 body: data
1807 });
1808 });
1809
1810 return deferred.promise;
1811 };
1812 /**
1813 *
1814 * @method
1815 * @name xos#Controller_Images_Detail_DELETE
1816 * @param {string} pk -
1817 *
1818 */
1819 xos.prototype.Controller_Images_Detail_DELETE = function(parameters) {
1820 if (parameters === undefined) {
1821 parameters = {};
1822 }
1823 var deferred = $q.defer();
1824
1825 var domain = this.domain;
1826 var path = '/xos/controllerimages/{pk}/';
1827
1828 var body;
1829 var queryParameters = {};
1830 var headers = {};
1831 var form = {};
1832
1833 path = path.replace('{pk}', parameters['pk']);
1834
1835 if (parameters['pk'] === undefined) {
1836 deferred.reject(new Error('Missing required path parameter: pk'));
1837 return deferred.promise;
1838 }
1839
1840 if (parameters.$queryParameters) {
1841 Object.keys(parameters.$queryParameters)
1842 .forEach(function(parameterName) {
1843 var parameter = parameters.$queryParameters[parameterName];
1844 queryParameters[parameterName] = parameter;
1845 });
1846 }
1847
1848 var url = domain + path;
1849 var options = {
1850 timeout: parameters.$timeout,
1851 method: 'DELETE',
1852 url: url,
1853 params: queryParameters,
1854 data: body,
1855 headers: headers
1856 };
1857 if (Object.keys(form).length > 0) {
1858 options.data = form;
1859 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1860 options.transformRequest = xos.transformRequest;
1861 }
1862 $http(options)
1863 .success(function(data, status, headers, config) {
1864 deferred.resolve(data);
1865 if (parameters.$cache !== undefined) {
1866 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1867 }
1868 })
1869 .error(function(data, status, headers, config) {
1870 deferred.reject({
1871 status: status,
1872 headers: headers,
1873 config: config,
1874 body: data
1875 });
1876 });
1877
1878 return deferred.promise;
1879 };
1880 /**
1881 *
1882 * @method
1883 * @name xos#Controller_Site_Privilege_List_GET
1884 *
1885 */
1886 xos.prototype.Controller_Site_Privilege_List_GET = function(parameters) {
1887 if (parameters === undefined) {
1888 parameters = {};
1889 }
1890 var deferred = $q.defer();
1891
1892 var domain = this.domain;
1893 var path = '/xos/controllersiteprivileges/';
1894
1895 var body;
1896 var queryParameters = {};
1897 var headers = {};
1898 var form = {};
1899
1900 if (parameters.$queryParameters) {
1901 Object.keys(parameters.$queryParameters)
1902 .forEach(function(parameterName) {
1903 var parameter = parameters.$queryParameters[parameterName];
1904 queryParameters[parameterName] = parameter;
1905 });
1906 }
1907
1908 var url = domain + path;
1909 var cached = parameters.$cache && parameters.$cache.get(url);
1910 if (cached !== undefined && parameters.$refresh !== true) {
1911 deferred.resolve(cached);
1912 return deferred.promise;
1913 }
1914 var options = {
1915 timeout: parameters.$timeout,
1916 method: 'GET',
1917 url: url,
1918 params: queryParameters,
1919 data: body,
1920 headers: headers
1921 };
1922 if (Object.keys(form).length > 0) {
1923 options.data = form;
1924 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
1925 options.transformRequest = xos.transformRequest;
1926 }
1927 $http(options)
1928 .success(function(data, status, headers, config) {
1929 deferred.resolve(data);
1930 if (parameters.$cache !== undefined) {
1931 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
1932 }
1933 })
1934 .error(function(data, status, headers, config) {
1935 deferred.reject({
1936 status: status,
1937 headers: headers,
1938 config: config,
1939 body: data
1940 });
1941 });
1942
1943 return deferred.promise;
1944 };
1945 /**
1946 *
1947 * @method
1948 * @name xos#Controller_Site_Privilege_List_POST
1949 * @param {string} enacted -
1950 * @param {string} policed -
1951 * @param {string} backend_register -
1952 * @param {string} backend_status -
1953 * @param {boolean} deleted -
1954 * @param {boolean} write_protect -
1955 * @param {boolean} lazy_blocked -
1956 * @param {boolean} no_sync -
1957 * @param {string} controller -
1958 * @param {string} site_privilege -
1959 * @param {string} role_id - Keystone id
1960 *
1961 */
1962 xos.prototype.Controller_Site_Privilege_List_POST = function(parameters) {
1963 if (parameters === undefined) {
1964 parameters = {};
1965 }
1966 var deferred = $q.defer();
1967
1968 var domain = this.domain;
1969 var path = '/xos/controllersiteprivileges/';
1970
1971 var body;
1972 var queryParameters = {};
1973 var headers = {};
1974 var form = {};
1975
1976 if (parameters['enacted'] !== undefined) {
1977 form['enacted'] = parameters['enacted'];
1978 }
1979
1980 if (parameters['policed'] !== undefined) {
1981 form['policed'] = parameters['policed'];
1982 }
1983
1984 if (parameters['backend_register'] !== undefined) {
1985 form['backend_register'] = parameters['backend_register'];
1986 }
1987
1988 if (parameters['backend_status'] !== undefined) {
1989 form['backend_status'] = parameters['backend_status'];
1990 }
1991
1992 if (parameters['backend_status'] === undefined) {
1993 deferred.reject(new Error('Missing required form parameter: backend_status'));
1994 return deferred.promise;
1995 }
1996
1997 if (parameters['deleted'] !== undefined) {
1998 form['deleted'] = parameters['deleted'];
1999 }
2000
2001 if (parameters['write_protect'] !== undefined) {
2002 form['write_protect'] = parameters['write_protect'];
2003 }
2004
2005 if (parameters['lazy_blocked'] !== undefined) {
2006 form['lazy_blocked'] = parameters['lazy_blocked'];
2007 }
2008
2009 if (parameters['no_sync'] !== undefined) {
2010 form['no_sync'] = parameters['no_sync'];
2011 }
2012
2013 if (parameters['controller'] !== undefined) {
2014 form['controller'] = parameters['controller'];
2015 }
2016
2017 if (parameters['controller'] === undefined) {
2018 deferred.reject(new Error('Missing required form parameter: controller'));
2019 return deferred.promise;
2020 }
2021
2022 if (parameters['site_privilege'] !== undefined) {
2023 form['site_privilege'] = parameters['site_privilege'];
2024 }
2025
2026 if (parameters['site_privilege'] === undefined) {
2027 deferred.reject(new Error('Missing required form parameter: site_privilege'));
2028 return deferred.promise;
2029 }
2030
2031 if (parameters['role_id'] !== undefined) {
2032 form['role_id'] = parameters['role_id'];
2033 }
2034
2035 if (parameters.$queryParameters) {
2036 Object.keys(parameters.$queryParameters)
2037 .forEach(function(parameterName) {
2038 var parameter = parameters.$queryParameters[parameterName];
2039 queryParameters[parameterName] = parameter;
2040 });
2041 }
2042
2043 var url = domain + path;
2044 var options = {
2045 timeout: parameters.$timeout,
2046 method: 'POST',
2047 url: url,
2048 params: queryParameters,
2049 data: body,
2050 headers: headers
2051 };
2052 if (Object.keys(form).length > 0) {
2053 options.data = form;
2054 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2055 options.transformRequest = xos.transformRequest;
2056 }
2057 $http(options)
2058 .success(function(data, status, headers, config) {
2059 deferred.resolve(data);
2060 if (parameters.$cache !== undefined) {
2061 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2062 }
2063 })
2064 .error(function(data, status, headers, config) {
2065 deferred.reject({
2066 status: status,
2067 headers: headers,
2068 config: config,
2069 body: data
2070 });
2071 });
2072
2073 return deferred.promise;
2074 };
2075 /**
2076 *
2077 * @method
2078 * @name xos#Controller_Site_Privilege_Detail_GET
2079 * @param {string} pk -
2080 *
2081 */
2082 xos.prototype.Controller_Site_Privilege_Detail_GET = function(parameters) {
2083 if (parameters === undefined) {
2084 parameters = {};
2085 }
2086 var deferred = $q.defer();
2087
2088 var domain = this.domain;
2089 var path = '/xos/controllersiteprivileges/{pk}/';
2090
2091 var body;
2092 var queryParameters = {};
2093 var headers = {};
2094 var form = {};
2095
2096 path = path.replace('{pk}', parameters['pk']);
2097
2098 if (parameters['pk'] === undefined) {
2099 deferred.reject(new Error('Missing required path parameter: pk'));
2100 return deferred.promise;
2101 }
2102
2103 if (parameters.$queryParameters) {
2104 Object.keys(parameters.$queryParameters)
2105 .forEach(function(parameterName) {
2106 var parameter = parameters.$queryParameters[parameterName];
2107 queryParameters[parameterName] = parameter;
2108 });
2109 }
2110
2111 var url = domain + path;
2112 var cached = parameters.$cache && parameters.$cache.get(url);
2113 if (cached !== undefined && parameters.$refresh !== true) {
2114 deferred.resolve(cached);
2115 return deferred.promise;
2116 }
2117 var options = {
2118 timeout: parameters.$timeout,
2119 method: 'GET',
2120 url: url,
2121 params: queryParameters,
2122 data: body,
2123 headers: headers
2124 };
2125 if (Object.keys(form).length > 0) {
2126 options.data = form;
2127 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2128 options.transformRequest = xos.transformRequest;
2129 }
2130 $http(options)
2131 .success(function(data, status, headers, config) {
2132 deferred.resolve(data);
2133 if (parameters.$cache !== undefined) {
2134 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2135 }
2136 })
2137 .error(function(data, status, headers, config) {
2138 deferred.reject({
2139 status: status,
2140 headers: headers,
2141 config: config,
2142 body: data
2143 });
2144 });
2145
2146 return deferred.promise;
2147 };
2148 /**
2149 *
2150 * @method
2151 * @name xos#Controller_Site_Privilege_Detail_PUT
2152 * @param {string} pk -
2153 * @param {string} enacted -
2154 * @param {string} policed -
2155 * @param {string} backend_register -
2156 * @param {string} backend_status -
2157 * @param {boolean} deleted -
2158 * @param {boolean} write_protect -
2159 * @param {boolean} lazy_blocked -
2160 * @param {boolean} no_sync -
2161 * @param {string} controller -
2162 * @param {string} site_privilege -
2163 * @param {string} role_id - Keystone id
2164 *
2165 */
2166 xos.prototype.Controller_Site_Privilege_Detail_PUT = function(parameters) {
2167 if (parameters === undefined) {
2168 parameters = {};
2169 }
2170 var deferred = $q.defer();
2171
2172 var domain = this.domain;
2173 var path = '/xos/controllersiteprivileges/{pk}/';
2174
2175 var body;
2176 var queryParameters = {};
2177 var headers = {};
2178 var form = {};
2179
2180 path = path.replace('{pk}', parameters['pk']);
2181
2182 if (parameters['pk'] === undefined) {
2183 deferred.reject(new Error('Missing required path parameter: pk'));
2184 return deferred.promise;
2185 }
2186
2187 if (parameters['enacted'] !== undefined) {
2188 form['enacted'] = parameters['enacted'];
2189 }
2190
2191 if (parameters['policed'] !== undefined) {
2192 form['policed'] = parameters['policed'];
2193 }
2194
2195 if (parameters['backend_register'] !== undefined) {
2196 form['backend_register'] = parameters['backend_register'];
2197 }
2198
2199 if (parameters['backend_status'] !== undefined) {
2200 form['backend_status'] = parameters['backend_status'];
2201 }
2202
2203 if (parameters['backend_status'] === undefined) {
2204 deferred.reject(new Error('Missing required form parameter: backend_status'));
2205 return deferred.promise;
2206 }
2207
2208 if (parameters['deleted'] !== undefined) {
2209 form['deleted'] = parameters['deleted'];
2210 }
2211
2212 if (parameters['write_protect'] !== undefined) {
2213 form['write_protect'] = parameters['write_protect'];
2214 }
2215
2216 if (parameters['lazy_blocked'] !== undefined) {
2217 form['lazy_blocked'] = parameters['lazy_blocked'];
2218 }
2219
2220 if (parameters['no_sync'] !== undefined) {
2221 form['no_sync'] = parameters['no_sync'];
2222 }
2223
2224 if (parameters['controller'] !== undefined) {
2225 form['controller'] = parameters['controller'];
2226 }
2227
2228 if (parameters['controller'] === undefined) {
2229 deferred.reject(new Error('Missing required form parameter: controller'));
2230 return deferred.promise;
2231 }
2232
2233 if (parameters['site_privilege'] !== undefined) {
2234 form['site_privilege'] = parameters['site_privilege'];
2235 }
2236
2237 if (parameters['site_privilege'] === undefined) {
2238 deferred.reject(new Error('Missing required form parameter: site_privilege'));
2239 return deferred.promise;
2240 }
2241
2242 if (parameters['role_id'] !== undefined) {
2243 form['role_id'] = parameters['role_id'];
2244 }
2245
2246 if (parameters.$queryParameters) {
2247 Object.keys(parameters.$queryParameters)
2248 .forEach(function(parameterName) {
2249 var parameter = parameters.$queryParameters[parameterName];
2250 queryParameters[parameterName] = parameter;
2251 });
2252 }
2253
2254 var url = domain + path;
2255 var options = {
2256 timeout: parameters.$timeout,
2257 method: 'PUT',
2258 url: url,
2259 params: queryParameters,
2260 data: body,
2261 headers: headers
2262 };
2263 if (Object.keys(form).length > 0) {
2264 options.data = form;
2265 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2266 options.transformRequest = xos.transformRequest;
2267 }
2268 $http(options)
2269 .success(function(data, status, headers, config) {
2270 deferred.resolve(data);
2271 if (parameters.$cache !== undefined) {
2272 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2273 }
2274 })
2275 .error(function(data, status, headers, config) {
2276 deferred.reject({
2277 status: status,
2278 headers: headers,
2279 config: config,
2280 body: data
2281 });
2282 });
2283
2284 return deferred.promise;
2285 };
2286 /**
2287 *
2288 * @method
2289 * @name xos#Controller_Site_Privilege_Detail_PATCH
2290 * @param {string} pk -
2291 * @param {string} enacted -
2292 * @param {string} policed -
2293 * @param {string} backend_register -
2294 * @param {string} backend_status -
2295 * @param {boolean} deleted -
2296 * @param {boolean} write_protect -
2297 * @param {boolean} lazy_blocked -
2298 * @param {boolean} no_sync -
2299 * @param {string} controller -
2300 * @param {string} site_privilege -
2301 * @param {string} role_id - Keystone id
2302 *
2303 */
2304 xos.prototype.Controller_Site_Privilege_Detail_PATCH = function(parameters) {
2305 if (parameters === undefined) {
2306 parameters = {};
2307 }
2308 var deferred = $q.defer();
2309
2310 var domain = this.domain;
2311 var path = '/xos/controllersiteprivileges/{pk}/';
2312
2313 var body;
2314 var queryParameters = {};
2315 var headers = {};
2316 var form = {};
2317
2318 path = path.replace('{pk}', parameters['pk']);
2319
2320 if (parameters['pk'] === undefined) {
2321 deferred.reject(new Error('Missing required path parameter: pk'));
2322 return deferred.promise;
2323 }
2324
2325 if (parameters['enacted'] !== undefined) {
2326 form['enacted'] = parameters['enacted'];
2327 }
2328
2329 if (parameters['policed'] !== undefined) {
2330 form['policed'] = parameters['policed'];
2331 }
2332
2333 if (parameters['backend_register'] !== undefined) {
2334 form['backend_register'] = parameters['backend_register'];
2335 }
2336
2337 if (parameters['backend_status'] !== undefined) {
2338 form['backend_status'] = parameters['backend_status'];
2339 }
2340
2341 if (parameters['deleted'] !== undefined) {
2342 form['deleted'] = parameters['deleted'];
2343 }
2344
2345 if (parameters['write_protect'] !== undefined) {
2346 form['write_protect'] = parameters['write_protect'];
2347 }
2348
2349 if (parameters['lazy_blocked'] !== undefined) {
2350 form['lazy_blocked'] = parameters['lazy_blocked'];
2351 }
2352
2353 if (parameters['no_sync'] !== undefined) {
2354 form['no_sync'] = parameters['no_sync'];
2355 }
2356
2357 if (parameters['controller'] !== undefined) {
2358 form['controller'] = parameters['controller'];
2359 }
2360
2361 if (parameters['site_privilege'] !== undefined) {
2362 form['site_privilege'] = parameters['site_privilege'];
2363 }
2364
2365 if (parameters['role_id'] !== undefined) {
2366 form['role_id'] = parameters['role_id'];
2367 }
2368
2369 if (parameters.$queryParameters) {
2370 Object.keys(parameters.$queryParameters)
2371 .forEach(function(parameterName) {
2372 var parameter = parameters.$queryParameters[parameterName];
2373 queryParameters[parameterName] = parameter;
2374 });
2375 }
2376
2377 var url = domain + path;
2378 var options = {
2379 timeout: parameters.$timeout,
2380 method: 'PATCH',
2381 url: url,
2382 params: queryParameters,
2383 data: body,
2384 headers: headers
2385 };
2386 if (Object.keys(form).length > 0) {
2387 options.data = form;
2388 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2389 options.transformRequest = xos.transformRequest;
2390 }
2391 $http(options)
2392 .success(function(data, status, headers, config) {
2393 deferred.resolve(data);
2394 if (parameters.$cache !== undefined) {
2395 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2396 }
2397 })
2398 .error(function(data, status, headers, config) {
2399 deferred.reject({
2400 status: status,
2401 headers: headers,
2402 config: config,
2403 body: data
2404 });
2405 });
2406
2407 return deferred.promise;
2408 };
2409 /**
2410 *
2411 * @method
2412 * @name xos#Controller_Site_Privilege_Detail_DELETE
2413 * @param {string} pk -
2414 *
2415 */
2416 xos.prototype.Controller_Site_Privilege_Detail_DELETE = function(parameters) {
2417 if (parameters === undefined) {
2418 parameters = {};
2419 }
2420 var deferred = $q.defer();
2421
2422 var domain = this.domain;
2423 var path = '/xos/controllersiteprivileges/{pk}/';
2424
2425 var body;
2426 var queryParameters = {};
2427 var headers = {};
2428 var form = {};
2429
2430 path = path.replace('{pk}', parameters['pk']);
2431
2432 if (parameters['pk'] === undefined) {
2433 deferred.reject(new Error('Missing required path parameter: pk'));
2434 return deferred.promise;
2435 }
2436
2437 if (parameters.$queryParameters) {
2438 Object.keys(parameters.$queryParameters)
2439 .forEach(function(parameterName) {
2440 var parameter = parameters.$queryParameters[parameterName];
2441 queryParameters[parameterName] = parameter;
2442 });
2443 }
2444
2445 var url = domain + path;
2446 var options = {
2447 timeout: parameters.$timeout,
2448 method: 'DELETE',
2449 url: url,
2450 params: queryParameters,
2451 data: body,
2452 headers: headers
2453 };
2454 if (Object.keys(form).length > 0) {
2455 options.data = form;
2456 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2457 options.transformRequest = xos.transformRequest;
2458 }
2459 $http(options)
2460 .success(function(data, status, headers, config) {
2461 deferred.resolve(data);
2462 if (parameters.$cache !== undefined) {
2463 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2464 }
2465 })
2466 .error(function(data, status, headers, config) {
2467 deferred.reject({
2468 status: status,
2469 headers: headers,
2470 config: config,
2471 body: data
2472 });
2473 });
2474
2475 return deferred.promise;
2476 };
2477 /**
2478 *
2479 * @method
2480 * @name xos#Image_List_GET
2481 *
2482 */
2483 xos.prototype.Image_List_GET = function(parameters) {
2484 if (parameters === undefined) {
2485 parameters = {};
2486 }
2487 var deferred = $q.defer();
2488
2489 var domain = this.domain;
2490 var path = '/xos/images/';
2491
2492 var body;
2493 var queryParameters = {};
2494 var headers = {};
2495 var form = {};
2496
2497 if (parameters.$queryParameters) {
2498 Object.keys(parameters.$queryParameters)
2499 .forEach(function(parameterName) {
2500 var parameter = parameters.$queryParameters[parameterName];
2501 queryParameters[parameterName] = parameter;
2502 });
2503 }
2504
2505 var url = domain + path;
2506 var cached = parameters.$cache && parameters.$cache.get(url);
2507 if (cached !== undefined && parameters.$refresh !== true) {
2508 deferred.resolve(cached);
2509 return deferred.promise;
2510 }
2511 var options = {
2512 timeout: parameters.$timeout,
2513 method: 'GET',
2514 url: url,
2515 params: queryParameters,
2516 data: body,
2517 headers: headers
2518 };
2519 if (Object.keys(form).length > 0) {
2520 options.data = form;
2521 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2522 options.transformRequest = xos.transformRequest;
2523 }
2524 $http(options)
2525 .success(function(data, status, headers, config) {
2526 deferred.resolve(data);
2527 if (parameters.$cache !== undefined) {
2528 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2529 }
2530 })
2531 .error(function(data, status, headers, config) {
2532 deferred.reject({
2533 status: status,
2534 headers: headers,
2535 config: config,
2536 body: data
2537 });
2538 });
2539
2540 return deferred.promise;
2541 };
2542 /**
2543 *
2544 * @method
2545 * @name xos#Image_List_POST
2546 * @param {string} enacted -
2547 * @param {string} policed -
2548 * @param {string} backend_register -
2549 * @param {string} backend_status -
2550 * @param {boolean} deleted -
2551 * @param {boolean} write_protect -
2552 * @param {boolean} lazy_blocked -
2553 * @param {boolean} no_sync -
2554 * @param {string} name -
2555 * @param {string} disk_format -
2556 * @param {string} container_format -
2557 * @param {string} path - Path to image on local disk
2558 *
2559 */
2560 xos.prototype.Image_List_POST = function(parameters) {
2561 if (parameters === undefined) {
2562 parameters = {};
2563 }
2564 var deferred = $q.defer();
2565
2566 var domain = this.domain;
2567 var path = '/xos/images/';
2568
2569 var body;
2570 var queryParameters = {};
2571 var headers = {};
2572 var form = {};
2573
2574 if (parameters['enacted'] !== undefined) {
2575 form['enacted'] = parameters['enacted'];
2576 }
2577
2578 if (parameters['policed'] !== undefined) {
2579 form['policed'] = parameters['policed'];
2580 }
2581
2582 if (parameters['backend_register'] !== undefined) {
2583 form['backend_register'] = parameters['backend_register'];
2584 }
2585
2586 if (parameters['backend_status'] !== undefined) {
2587 form['backend_status'] = parameters['backend_status'];
2588 }
2589
2590 if (parameters['backend_status'] === undefined) {
2591 deferred.reject(new Error('Missing required form parameter: backend_status'));
2592 return deferred.promise;
2593 }
2594
2595 if (parameters['deleted'] !== undefined) {
2596 form['deleted'] = parameters['deleted'];
2597 }
2598
2599 if (parameters['write_protect'] !== undefined) {
2600 form['write_protect'] = parameters['write_protect'];
2601 }
2602
2603 if (parameters['lazy_blocked'] !== undefined) {
2604 form['lazy_blocked'] = parameters['lazy_blocked'];
2605 }
2606
2607 if (parameters['no_sync'] !== undefined) {
2608 form['no_sync'] = parameters['no_sync'];
2609 }
2610
2611 if (parameters['name'] !== undefined) {
2612 form['name'] = parameters['name'];
2613 }
2614
2615 if (parameters['name'] === undefined) {
2616 deferred.reject(new Error('Missing required form parameter: name'));
2617 return deferred.promise;
2618 }
2619
2620 if (parameters['disk_format'] !== undefined) {
2621 form['disk_format'] = parameters['disk_format'];
2622 }
2623
2624 if (parameters['disk_format'] === undefined) {
2625 deferred.reject(new Error('Missing required form parameter: disk_format'));
2626 return deferred.promise;
2627 }
2628
2629 if (parameters['container_format'] !== undefined) {
2630 form['container_format'] = parameters['container_format'];
2631 }
2632
2633 if (parameters['container_format'] === undefined) {
2634 deferred.reject(new Error('Missing required form parameter: container_format'));
2635 return deferred.promise;
2636 }
2637
2638 if (parameters['path'] !== undefined) {
2639 form['path'] = parameters['path'];
2640 }
2641
2642 if (parameters.$queryParameters) {
2643 Object.keys(parameters.$queryParameters)
2644 .forEach(function(parameterName) {
2645 var parameter = parameters.$queryParameters[parameterName];
2646 queryParameters[parameterName] = parameter;
2647 });
2648 }
2649
2650 var url = domain + path;
2651 var options = {
2652 timeout: parameters.$timeout,
2653 method: 'POST',
2654 url: url,
2655 params: queryParameters,
2656 data: body,
2657 headers: headers
2658 };
2659 if (Object.keys(form).length > 0) {
2660 options.data = form;
2661 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2662 options.transformRequest = xos.transformRequest;
2663 }
2664 $http(options)
2665 .success(function(data, status, headers, config) {
2666 deferred.resolve(data);
2667 if (parameters.$cache !== undefined) {
2668 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2669 }
2670 })
2671 .error(function(data, status, headers, config) {
2672 deferred.reject({
2673 status: status,
2674 headers: headers,
2675 config: config,
2676 body: data
2677 });
2678 });
2679
2680 return deferred.promise;
2681 };
2682 /**
2683 *
2684 * @method
2685 * @name xos#Image_Detail_GET
2686 * @param {string} pk -
2687 *
2688 */
2689 xos.prototype.Image_Detail_GET = function(parameters) {
2690 if (parameters === undefined) {
2691 parameters = {};
2692 }
2693 var deferred = $q.defer();
2694
2695 var domain = this.domain;
2696 var path = '/xos/images/{pk}/';
2697
2698 var body;
2699 var queryParameters = {};
2700 var headers = {};
2701 var form = {};
2702
2703 path = path.replace('{pk}', parameters['pk']);
2704
2705 if (parameters['pk'] === undefined) {
2706 deferred.reject(new Error('Missing required path parameter: pk'));
2707 return deferred.promise;
2708 }
2709
2710 if (parameters.$queryParameters) {
2711 Object.keys(parameters.$queryParameters)
2712 .forEach(function(parameterName) {
2713 var parameter = parameters.$queryParameters[parameterName];
2714 queryParameters[parameterName] = parameter;
2715 });
2716 }
2717
2718 var url = domain + path;
2719 var cached = parameters.$cache && parameters.$cache.get(url);
2720 if (cached !== undefined && parameters.$refresh !== true) {
2721 deferred.resolve(cached);
2722 return deferred.promise;
2723 }
2724 var options = {
2725 timeout: parameters.$timeout,
2726 method: 'GET',
2727 url: url,
2728 params: queryParameters,
2729 data: body,
2730 headers: headers
2731 };
2732 if (Object.keys(form).length > 0) {
2733 options.data = form;
2734 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2735 options.transformRequest = xos.transformRequest;
2736 }
2737 $http(options)
2738 .success(function(data, status, headers, config) {
2739 deferred.resolve(data);
2740 if (parameters.$cache !== undefined) {
2741 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2742 }
2743 })
2744 .error(function(data, status, headers, config) {
2745 deferred.reject({
2746 status: status,
2747 headers: headers,
2748 config: config,
2749 body: data
2750 });
2751 });
2752
2753 return deferred.promise;
2754 };
2755 /**
2756 *
2757 * @method
2758 * @name xos#Image_Detail_PUT
2759 * @param {string} pk -
2760 * @param {string} enacted -
2761 * @param {string} policed -
2762 * @param {string} backend_register -
2763 * @param {string} backend_status -
2764 * @param {boolean} deleted -
2765 * @param {boolean} write_protect -
2766 * @param {boolean} lazy_blocked -
2767 * @param {boolean} no_sync -
2768 * @param {string} name -
2769 * @param {string} disk_format -
2770 * @param {string} container_format -
2771 * @param {string} path - Path to image on local disk
2772 *
2773 */
2774 xos.prototype.Image_Detail_PUT = function(parameters) {
2775 if (parameters === undefined) {
2776 parameters = {};
2777 }
2778 var deferred = $q.defer();
2779
2780 var domain = this.domain;
2781 var path = '/xos/images/{pk}/';
2782
2783 var body;
2784 var queryParameters = {};
2785 var headers = {};
2786 var form = {};
2787
2788 path = path.replace('{pk}', parameters['pk']);
2789
2790 if (parameters['pk'] === undefined) {
2791 deferred.reject(new Error('Missing required path parameter: pk'));
2792 return deferred.promise;
2793 }
2794
2795 if (parameters['enacted'] !== undefined) {
2796 form['enacted'] = parameters['enacted'];
2797 }
2798
2799 if (parameters['policed'] !== undefined) {
2800 form['policed'] = parameters['policed'];
2801 }
2802
2803 if (parameters['backend_register'] !== undefined) {
2804 form['backend_register'] = parameters['backend_register'];
2805 }
2806
2807 if (parameters['backend_status'] !== undefined) {
2808 form['backend_status'] = parameters['backend_status'];
2809 }
2810
2811 if (parameters['backend_status'] === undefined) {
2812 deferred.reject(new Error('Missing required form parameter: backend_status'));
2813 return deferred.promise;
2814 }
2815
2816 if (parameters['deleted'] !== undefined) {
2817 form['deleted'] = parameters['deleted'];
2818 }
2819
2820 if (parameters['write_protect'] !== undefined) {
2821 form['write_protect'] = parameters['write_protect'];
2822 }
2823
2824 if (parameters['lazy_blocked'] !== undefined) {
2825 form['lazy_blocked'] = parameters['lazy_blocked'];
2826 }
2827
2828 if (parameters['no_sync'] !== undefined) {
2829 form['no_sync'] = parameters['no_sync'];
2830 }
2831
2832 if (parameters['name'] !== undefined) {
2833 form['name'] = parameters['name'];
2834 }
2835
2836 if (parameters['name'] === undefined) {
2837 deferred.reject(new Error('Missing required form parameter: name'));
2838 return deferred.promise;
2839 }
2840
2841 if (parameters['disk_format'] !== undefined) {
2842 form['disk_format'] = parameters['disk_format'];
2843 }
2844
2845 if (parameters['disk_format'] === undefined) {
2846 deferred.reject(new Error('Missing required form parameter: disk_format'));
2847 return deferred.promise;
2848 }
2849
2850 if (parameters['container_format'] !== undefined) {
2851 form['container_format'] = parameters['container_format'];
2852 }
2853
2854 if (parameters['container_format'] === undefined) {
2855 deferred.reject(new Error('Missing required form parameter: container_format'));
2856 return deferred.promise;
2857 }
2858
2859 if (parameters['path'] !== undefined) {
2860 form['path'] = parameters['path'];
2861 }
2862
2863 if (parameters.$queryParameters) {
2864 Object.keys(parameters.$queryParameters)
2865 .forEach(function(parameterName) {
2866 var parameter = parameters.$queryParameters[parameterName];
2867 queryParameters[parameterName] = parameter;
2868 });
2869 }
2870
2871 var url = domain + path;
2872 var options = {
2873 timeout: parameters.$timeout,
2874 method: 'PUT',
2875 url: url,
2876 params: queryParameters,
2877 data: body,
2878 headers: headers
2879 };
2880 if (Object.keys(form).length > 0) {
2881 options.data = form;
2882 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
2883 options.transformRequest = xos.transformRequest;
2884 }
2885 $http(options)
2886 .success(function(data, status, headers, config) {
2887 deferred.resolve(data);
2888 if (parameters.$cache !== undefined) {
2889 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
2890 }
2891 })
2892 .error(function(data, status, headers, config) {
2893 deferred.reject({
2894 status: status,
2895 headers: headers,
2896 config: config,
2897 body: data
2898 });
2899 });
2900
2901 return deferred.promise;
2902 };
2903 /**
2904 *
2905 * @method
2906 * @name xos#Image_Detail_PATCH
2907 * @param {string} pk -
2908 * @param {string} enacted -
2909 * @param {string} policed -
2910 * @param {string} backend_register -
2911 * @param {string} backend_status -
2912 * @param {boolean} deleted -
2913 * @param {boolean} write_protect -
2914 * @param {boolean} lazy_blocked -
2915 * @param {boolean} no_sync -
2916 * @param {string} name -
2917 * @param {string} disk_format -
2918 * @param {string} container_format -
2919 * @param {string} path - Path to image on local disk
2920 *
2921 */
2922 xos.prototype.Image_Detail_PATCH = function(parameters) {
2923 if (parameters === undefined) {
2924 parameters = {};
2925 }
2926 var deferred = $q.defer();
2927
2928 var domain = this.domain;
2929 var path = '/xos/images/{pk}/';
2930
2931 var body;
2932 var queryParameters = {};
2933 var headers = {};
2934 var form = {};
2935
2936 path = path.replace('{pk}', parameters['pk']);
2937
2938 if (parameters['pk'] === undefined) {
2939 deferred.reject(new Error('Missing required path parameter: pk'));
2940 return deferred.promise;
2941 }
2942
2943 if (parameters['enacted'] !== undefined) {
2944 form['enacted'] = parameters['enacted'];
2945 }
2946
2947 if (parameters['policed'] !== undefined) {
2948 form['policed'] = parameters['policed'];
2949 }
2950
2951 if (parameters['backend_register'] !== undefined) {
2952 form['backend_register'] = parameters['backend_register'];
2953 }
2954
2955 if (parameters['backend_status'] !== undefined) {
2956 form['backend_status'] = parameters['backend_status'];
2957 }
2958
2959 if (parameters['deleted'] !== undefined) {
2960 form['deleted'] = parameters['deleted'];
2961 }
2962
2963 if (parameters['write_protect'] !== undefined) {
2964 form['write_protect'] = parameters['write_protect'];
2965 }
2966
2967 if (parameters['lazy_blocked'] !== undefined) {
2968 form['lazy_blocked'] = parameters['lazy_blocked'];
2969 }
2970
2971 if (parameters['no_sync'] !== undefined) {
2972 form['no_sync'] = parameters['no_sync'];
2973 }
2974
2975 if (parameters['name'] !== undefined) {
2976 form['name'] = parameters['name'];
2977 }
2978
2979 if (parameters['disk_format'] !== undefined) {
2980 form['disk_format'] = parameters['disk_format'];
2981 }
2982
2983 if (parameters['container_format'] !== undefined) {
2984 form['container_format'] = parameters['container_format'];
2985 }
2986
2987 if (parameters['path'] !== undefined) {
2988 form['path'] = parameters['path'];
2989 }
2990
2991 if (parameters.$queryParameters) {
2992 Object.keys(parameters.$queryParameters)
2993 .forEach(function(parameterName) {
2994 var parameter = parameters.$queryParameters[parameterName];
2995 queryParameters[parameterName] = parameter;
2996 });
2997 }
2998
2999 var url = domain + path;
3000 var options = {
3001 timeout: parameters.$timeout,
3002 method: 'PATCH',
3003 url: url,
3004 params: queryParameters,
3005 data: body,
3006 headers: headers
3007 };
3008 if (Object.keys(form).length > 0) {
3009 options.data = form;
3010 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3011 options.transformRequest = xos.transformRequest;
3012 }
3013 $http(options)
3014 .success(function(data, status, headers, config) {
3015 deferred.resolve(data);
3016 if (parameters.$cache !== undefined) {
3017 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3018 }
3019 })
3020 .error(function(data, status, headers, config) {
3021 deferred.reject({
3022 status: status,
3023 headers: headers,
3024 config: config,
3025 body: data
3026 });
3027 });
3028
3029 return deferred.promise;
3030 };
3031 /**
3032 *
3033 * @method
3034 * @name xos#Image_Detail_DELETE
3035 * @param {string} pk -
3036 *
3037 */
3038 xos.prototype.Image_Detail_DELETE = function(parameters) {
3039 if (parameters === undefined) {
3040 parameters = {};
3041 }
3042 var deferred = $q.defer();
3043
3044 var domain = this.domain;
3045 var path = '/xos/images/{pk}/';
3046
3047 var body;
3048 var queryParameters = {};
3049 var headers = {};
3050 var form = {};
3051
3052 path = path.replace('{pk}', parameters['pk']);
3053
3054 if (parameters['pk'] === undefined) {
3055 deferred.reject(new Error('Missing required path parameter: pk'));
3056 return deferred.promise;
3057 }
3058
3059 if (parameters.$queryParameters) {
3060 Object.keys(parameters.$queryParameters)
3061 .forEach(function(parameterName) {
3062 var parameter = parameters.$queryParameters[parameterName];
3063 queryParameters[parameterName] = parameter;
3064 });
3065 }
3066
3067 var url = domain + path;
3068 var options = {
3069 timeout: parameters.$timeout,
3070 method: 'DELETE',
3071 url: url,
3072 params: queryParameters,
3073 data: body,
3074 headers: headers
3075 };
3076 if (Object.keys(form).length > 0) {
3077 options.data = form;
3078 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3079 options.transformRequest = xos.transformRequest;
3080 }
3081 $http(options)
3082 .success(function(data, status, headers, config) {
3083 deferred.resolve(data);
3084 if (parameters.$cache !== undefined) {
3085 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3086 }
3087 })
3088 .error(function(data, status, headers, config) {
3089 deferred.reject({
3090 status: status,
3091 headers: headers,
3092 config: config,
3093 body: data
3094 });
3095 });
3096
3097 return deferred.promise;
3098 };
3099 /**
3100 *
3101 * @method
3102 * @name xos#Network_Parameter_List_GET
3103 *
3104 */
3105 xos.prototype.Network_Parameter_List_GET = function(parameters) {
3106 if (parameters === undefined) {
3107 parameters = {};
3108 }
3109 var deferred = $q.defer();
3110
3111 var domain = this.domain;
3112 var path = '/xos/networkparameters/';
3113
3114 var body;
3115 var queryParameters = {};
3116 var headers = {};
3117 var form = {};
3118
3119 if (parameters.$queryParameters) {
3120 Object.keys(parameters.$queryParameters)
3121 .forEach(function(parameterName) {
3122 var parameter = parameters.$queryParameters[parameterName];
3123 queryParameters[parameterName] = parameter;
3124 });
3125 }
3126
3127 var url = domain + path;
3128 var cached = parameters.$cache && parameters.$cache.get(url);
3129 if (cached !== undefined && parameters.$refresh !== true) {
3130 deferred.resolve(cached);
3131 return deferred.promise;
3132 }
3133 var options = {
3134 timeout: parameters.$timeout,
3135 method: 'GET',
3136 url: url,
3137 params: queryParameters,
3138 data: body,
3139 headers: headers
3140 };
3141 if (Object.keys(form).length > 0) {
3142 options.data = form;
3143 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3144 options.transformRequest = xos.transformRequest;
3145 }
3146 $http(options)
3147 .success(function(data, status, headers, config) {
3148 deferred.resolve(data);
3149 if (parameters.$cache !== undefined) {
3150 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3151 }
3152 })
3153 .error(function(data, status, headers, config) {
3154 deferred.reject({
3155 status: status,
3156 headers: headers,
3157 config: config,
3158 body: data
3159 });
3160 });
3161
3162 return deferred.promise;
3163 };
3164 /**
3165 *
3166 * @method
3167 * @name xos#Network_Parameter_List_POST
3168 * @param {string} enacted -
3169 * @param {string} policed -
3170 * @param {string} backend_register -
3171 * @param {string} backend_status -
3172 * @param {boolean} deleted -
3173 * @param {boolean} write_protect -
3174 * @param {boolean} lazy_blocked -
3175 * @param {boolean} no_sync -
3176 * @param {string} parameter - The type of the parameter
3177 * @param {string} value - The value of this parameter
3178 * @param {string} content_type -
3179 * @param {integer} object_id -
3180 *
3181 */
3182 xos.prototype.Network_Parameter_List_POST = function(parameters) {
3183 if (parameters === undefined) {
3184 parameters = {};
3185 }
3186 var deferred = $q.defer();
3187
3188 var domain = this.domain;
3189 var path = '/xos/networkparameters/';
3190
3191 var body;
3192 var queryParameters = {};
3193 var headers = {};
3194 var form = {};
3195
3196 if (parameters['enacted'] !== undefined) {
3197 form['enacted'] = parameters['enacted'];
3198 }
3199
3200 if (parameters['policed'] !== undefined) {
3201 form['policed'] = parameters['policed'];
3202 }
3203
3204 if (parameters['backend_register'] !== undefined) {
3205 form['backend_register'] = parameters['backend_register'];
3206 }
3207
3208 if (parameters['backend_status'] !== undefined) {
3209 form['backend_status'] = parameters['backend_status'];
3210 }
3211
3212 if (parameters['backend_status'] === undefined) {
3213 deferred.reject(new Error('Missing required form parameter: backend_status'));
3214 return deferred.promise;
3215 }
3216
3217 if (parameters['deleted'] !== undefined) {
3218 form['deleted'] = parameters['deleted'];
3219 }
3220
3221 if (parameters['write_protect'] !== undefined) {
3222 form['write_protect'] = parameters['write_protect'];
3223 }
3224
3225 if (parameters['lazy_blocked'] !== undefined) {
3226 form['lazy_blocked'] = parameters['lazy_blocked'];
3227 }
3228
3229 if (parameters['no_sync'] !== undefined) {
3230 form['no_sync'] = parameters['no_sync'];
3231 }
3232
3233 if (parameters['parameter'] !== undefined) {
3234 form['parameter'] = parameters['parameter'];
3235 }
3236
3237 if (parameters['parameter'] === undefined) {
3238 deferred.reject(new Error('Missing required form parameter: parameter'));
3239 return deferred.promise;
3240 }
3241
3242 if (parameters['value'] !== undefined) {
3243 form['value'] = parameters['value'];
3244 }
3245
3246 if (parameters['value'] === undefined) {
3247 deferred.reject(new Error('Missing required form parameter: value'));
3248 return deferred.promise;
3249 }
3250
3251 if (parameters['content_type'] !== undefined) {
3252 form['content_type'] = parameters['content_type'];
3253 }
3254
3255 if (parameters['content_type'] === undefined) {
3256 deferred.reject(new Error('Missing required form parameter: content_type'));
3257 return deferred.promise;
3258 }
3259
3260 if (parameters['object_id'] !== undefined) {
3261 form['object_id'] = parameters['object_id'];
3262 }
3263
3264 if (parameters['object_id'] === undefined) {
3265 deferred.reject(new Error('Missing required form parameter: object_id'));
3266 return deferred.promise;
3267 }
3268
3269 if (parameters.$queryParameters) {
3270 Object.keys(parameters.$queryParameters)
3271 .forEach(function(parameterName) {
3272 var parameter = parameters.$queryParameters[parameterName];
3273 queryParameters[parameterName] = parameter;
3274 });
3275 }
3276
3277 var url = domain + path;
3278 var options = {
3279 timeout: parameters.$timeout,
3280 method: 'POST',
3281 url: url,
3282 params: queryParameters,
3283 data: body,
3284 headers: headers
3285 };
3286 if (Object.keys(form).length > 0) {
3287 options.data = form;
3288 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3289 options.transformRequest = xos.transformRequest;
3290 }
3291 $http(options)
3292 .success(function(data, status, headers, config) {
3293 deferred.resolve(data);
3294 if (parameters.$cache !== undefined) {
3295 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3296 }
3297 })
3298 .error(function(data, status, headers, config) {
3299 deferred.reject({
3300 status: status,
3301 headers: headers,
3302 config: config,
3303 body: data
3304 });
3305 });
3306
3307 return deferred.promise;
3308 };
3309 /**
3310 *
3311 * @method
3312 * @name xos#Network_Parameter_Detail_GET
3313 * @param {string} pk -
3314 *
3315 */
3316 xos.prototype.Network_Parameter_Detail_GET = function(parameters) {
3317 if (parameters === undefined) {
3318 parameters = {};
3319 }
3320 var deferred = $q.defer();
3321
3322 var domain = this.domain;
3323 var path = '/xos/networkparameters/{pk}/';
3324
3325 var body;
3326 var queryParameters = {};
3327 var headers = {};
3328 var form = {};
3329
3330 path = path.replace('{pk}', parameters['pk']);
3331
3332 if (parameters['pk'] === undefined) {
3333 deferred.reject(new Error('Missing required path parameter: pk'));
3334 return deferred.promise;
3335 }
3336
3337 if (parameters.$queryParameters) {
3338 Object.keys(parameters.$queryParameters)
3339 .forEach(function(parameterName) {
3340 var parameter = parameters.$queryParameters[parameterName];
3341 queryParameters[parameterName] = parameter;
3342 });
3343 }
3344
3345 var url = domain + path;
3346 var cached = parameters.$cache && parameters.$cache.get(url);
3347 if (cached !== undefined && parameters.$refresh !== true) {
3348 deferred.resolve(cached);
3349 return deferred.promise;
3350 }
3351 var options = {
3352 timeout: parameters.$timeout,
3353 method: 'GET',
3354 url: url,
3355 params: queryParameters,
3356 data: body,
3357 headers: headers
3358 };
3359 if (Object.keys(form).length > 0) {
3360 options.data = form;
3361 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3362 options.transformRequest = xos.transformRequest;
3363 }
3364 $http(options)
3365 .success(function(data, status, headers, config) {
3366 deferred.resolve(data);
3367 if (parameters.$cache !== undefined) {
3368 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3369 }
3370 })
3371 .error(function(data, status, headers, config) {
3372 deferred.reject({
3373 status: status,
3374 headers: headers,
3375 config: config,
3376 body: data
3377 });
3378 });
3379
3380 return deferred.promise;
3381 };
3382 /**
3383 *
3384 * @method
3385 * @name xos#Network_Parameter_Detail_PUT
3386 * @param {string} pk -
3387 * @param {string} enacted -
3388 * @param {string} policed -
3389 * @param {string} backend_register -
3390 * @param {string} backend_status -
3391 * @param {boolean} deleted -
3392 * @param {boolean} write_protect -
3393 * @param {boolean} lazy_blocked -
3394 * @param {boolean} no_sync -
3395 * @param {string} parameter - The type of the parameter
3396 * @param {string} value - The value of this parameter
3397 * @param {string} content_type -
3398 * @param {integer} object_id -
3399 *
3400 */
3401 xos.prototype.Network_Parameter_Detail_PUT = function(parameters) {
3402 if (parameters === undefined) {
3403 parameters = {};
3404 }
3405 var deferred = $q.defer();
3406
3407 var domain = this.domain;
3408 var path = '/xos/networkparameters/{pk}/';
3409
3410 var body;
3411 var queryParameters = {};
3412 var headers = {};
3413 var form = {};
3414
3415 path = path.replace('{pk}', parameters['pk']);
3416
3417 if (parameters['pk'] === undefined) {
3418 deferred.reject(new Error('Missing required path parameter: pk'));
3419 return deferred.promise;
3420 }
3421
3422 if (parameters['enacted'] !== undefined) {
3423 form['enacted'] = parameters['enacted'];
3424 }
3425
3426 if (parameters['policed'] !== undefined) {
3427 form['policed'] = parameters['policed'];
3428 }
3429
3430 if (parameters['backend_register'] !== undefined) {
3431 form['backend_register'] = parameters['backend_register'];
3432 }
3433
3434 if (parameters['backend_status'] !== undefined) {
3435 form['backend_status'] = parameters['backend_status'];
3436 }
3437
3438 if (parameters['backend_status'] === undefined) {
3439 deferred.reject(new Error('Missing required form parameter: backend_status'));
3440 return deferred.promise;
3441 }
3442
3443 if (parameters['deleted'] !== undefined) {
3444 form['deleted'] = parameters['deleted'];
3445 }
3446
3447 if (parameters['write_protect'] !== undefined) {
3448 form['write_protect'] = parameters['write_protect'];
3449 }
3450
3451 if (parameters['lazy_blocked'] !== undefined) {
3452 form['lazy_blocked'] = parameters['lazy_blocked'];
3453 }
3454
3455 if (parameters['no_sync'] !== undefined) {
3456 form['no_sync'] = parameters['no_sync'];
3457 }
3458
3459 if (parameters['parameter'] !== undefined) {
3460 form['parameter'] = parameters['parameter'];
3461 }
3462
3463 if (parameters['parameter'] === undefined) {
3464 deferred.reject(new Error('Missing required form parameter: parameter'));
3465 return deferred.promise;
3466 }
3467
3468 if (parameters['value'] !== undefined) {
3469 form['value'] = parameters['value'];
3470 }
3471
3472 if (parameters['value'] === undefined) {
3473 deferred.reject(new Error('Missing required form parameter: value'));
3474 return deferred.promise;
3475 }
3476
3477 if (parameters['content_type'] !== undefined) {
3478 form['content_type'] = parameters['content_type'];
3479 }
3480
3481 if (parameters['content_type'] === undefined) {
3482 deferred.reject(new Error('Missing required form parameter: content_type'));
3483 return deferred.promise;
3484 }
3485
3486 if (parameters['object_id'] !== undefined) {
3487 form['object_id'] = parameters['object_id'];
3488 }
3489
3490 if (parameters['object_id'] === undefined) {
3491 deferred.reject(new Error('Missing required form parameter: object_id'));
3492 return deferred.promise;
3493 }
3494
3495 if (parameters.$queryParameters) {
3496 Object.keys(parameters.$queryParameters)
3497 .forEach(function(parameterName) {
3498 var parameter = parameters.$queryParameters[parameterName];
3499 queryParameters[parameterName] = parameter;
3500 });
3501 }
3502
3503 var url = domain + path;
3504 var options = {
3505 timeout: parameters.$timeout,
3506 method: 'PUT',
3507 url: url,
3508 params: queryParameters,
3509 data: body,
3510 headers: headers
3511 };
3512 if (Object.keys(form).length > 0) {
3513 options.data = form;
3514 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3515 options.transformRequest = xos.transformRequest;
3516 }
3517 $http(options)
3518 .success(function(data, status, headers, config) {
3519 deferred.resolve(data);
3520 if (parameters.$cache !== undefined) {
3521 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3522 }
3523 })
3524 .error(function(data, status, headers, config) {
3525 deferred.reject({
3526 status: status,
3527 headers: headers,
3528 config: config,
3529 body: data
3530 });
3531 });
3532
3533 return deferred.promise;
3534 };
3535 /**
3536 *
3537 * @method
3538 * @name xos#Network_Parameter_Detail_PATCH
3539 * @param {string} pk -
3540 * @param {string} enacted -
3541 * @param {string} policed -
3542 * @param {string} backend_register -
3543 * @param {string} backend_status -
3544 * @param {boolean} deleted -
3545 * @param {boolean} write_protect -
3546 * @param {boolean} lazy_blocked -
3547 * @param {boolean} no_sync -
3548 * @param {string} parameter - The type of the parameter
3549 * @param {string} value - The value of this parameter
3550 * @param {string} content_type -
3551 * @param {integer} object_id -
3552 *
3553 */
3554 xos.prototype.Network_Parameter_Detail_PATCH = function(parameters) {
3555 if (parameters === undefined) {
3556 parameters = {};
3557 }
3558 var deferred = $q.defer();
3559
3560 var domain = this.domain;
3561 var path = '/xos/networkparameters/{pk}/';
3562
3563 var body;
3564 var queryParameters = {};
3565 var headers = {};
3566 var form = {};
3567
3568 path = path.replace('{pk}', parameters['pk']);
3569
3570 if (parameters['pk'] === undefined) {
3571 deferred.reject(new Error('Missing required path parameter: pk'));
3572 return deferred.promise;
3573 }
3574
3575 if (parameters['enacted'] !== undefined) {
3576 form['enacted'] = parameters['enacted'];
3577 }
3578
3579 if (parameters['policed'] !== undefined) {
3580 form['policed'] = parameters['policed'];
3581 }
3582
3583 if (parameters['backend_register'] !== undefined) {
3584 form['backend_register'] = parameters['backend_register'];
3585 }
3586
3587 if (parameters['backend_status'] !== undefined) {
3588 form['backend_status'] = parameters['backend_status'];
3589 }
3590
3591 if (parameters['deleted'] !== undefined) {
3592 form['deleted'] = parameters['deleted'];
3593 }
3594
3595 if (parameters['write_protect'] !== undefined) {
3596 form['write_protect'] = parameters['write_protect'];
3597 }
3598
3599 if (parameters['lazy_blocked'] !== undefined) {
3600 form['lazy_blocked'] = parameters['lazy_blocked'];
3601 }
3602
3603 if (parameters['no_sync'] !== undefined) {
3604 form['no_sync'] = parameters['no_sync'];
3605 }
3606
3607 if (parameters['parameter'] !== undefined) {
3608 form['parameter'] = parameters['parameter'];
3609 }
3610
3611 if (parameters['value'] !== undefined) {
3612 form['value'] = parameters['value'];
3613 }
3614
3615 if (parameters['content_type'] !== undefined) {
3616 form['content_type'] = parameters['content_type'];
3617 }
3618
3619 if (parameters['object_id'] !== undefined) {
3620 form['object_id'] = parameters['object_id'];
3621 }
3622
3623 if (parameters.$queryParameters) {
3624 Object.keys(parameters.$queryParameters)
3625 .forEach(function(parameterName) {
3626 var parameter = parameters.$queryParameters[parameterName];
3627 queryParameters[parameterName] = parameter;
3628 });
3629 }
3630
3631 var url = domain + path;
3632 var options = {
3633 timeout: parameters.$timeout,
3634 method: 'PATCH',
3635 url: url,
3636 params: queryParameters,
3637 data: body,
3638 headers: headers
3639 };
3640 if (Object.keys(form).length > 0) {
3641 options.data = form;
3642 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3643 options.transformRequest = xos.transformRequest;
3644 }
3645 $http(options)
3646 .success(function(data, status, headers, config) {
3647 deferred.resolve(data);
3648 if (parameters.$cache !== undefined) {
3649 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3650 }
3651 })
3652 .error(function(data, status, headers, config) {
3653 deferred.reject({
3654 status: status,
3655 headers: headers,
3656 config: config,
3657 body: data
3658 });
3659 });
3660
3661 return deferred.promise;
3662 };
3663 /**
3664 *
3665 * @method
3666 * @name xos#Network_Parameter_Detail_DELETE
3667 * @param {string} pk -
3668 *
3669 */
3670 xos.prototype.Network_Parameter_Detail_DELETE = function(parameters) {
3671 if (parameters === undefined) {
3672 parameters = {};
3673 }
3674 var deferred = $q.defer();
3675
3676 var domain = this.domain;
3677 var path = '/xos/networkparameters/{pk}/';
3678
3679 var body;
3680 var queryParameters = {};
3681 var headers = {};
3682 var form = {};
3683
3684 path = path.replace('{pk}', parameters['pk']);
3685
3686 if (parameters['pk'] === undefined) {
3687 deferred.reject(new Error('Missing required path parameter: pk'));
3688 return deferred.promise;
3689 }
3690
3691 if (parameters.$queryParameters) {
3692 Object.keys(parameters.$queryParameters)
3693 .forEach(function(parameterName) {
3694 var parameter = parameters.$queryParameters[parameterName];
3695 queryParameters[parameterName] = parameter;
3696 });
3697 }
3698
3699 var url = domain + path;
3700 var options = {
3701 timeout: parameters.$timeout,
3702 method: 'DELETE',
3703 url: url,
3704 params: queryParameters,
3705 data: body,
3706 headers: headers
3707 };
3708 if (Object.keys(form).length > 0) {
3709 options.data = form;
3710 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3711 options.transformRequest = xos.transformRequest;
3712 }
3713 $http(options)
3714 .success(function(data, status, headers, config) {
3715 deferred.resolve(data);
3716 if (parameters.$cache !== undefined) {
3717 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3718 }
3719 })
3720 .error(function(data, status, headers, config) {
3721 deferred.reject({
3722 status: status,
3723 headers: headers,
3724 config: config,
3725 body: data
3726 });
3727 });
3728
3729 return deferred.promise;
3730 };
3731 /**
3732 *
3733 * @method
3734 * @name xos#Site_List_GET
3735 *
3736 */
3737 xos.prototype.Site_List_GET = function(parameters) {
3738 if (parameters === undefined) {
3739 parameters = {};
3740 }
3741 var deferred = $q.defer();
3742
3743 var domain = this.domain;
3744 var path = '/xos/sites/';
3745
3746 var body;
3747 var queryParameters = {};
3748 var headers = {};
3749 var form = {};
3750
3751 if (parameters.$queryParameters) {
3752 Object.keys(parameters.$queryParameters)
3753 .forEach(function(parameterName) {
3754 var parameter = parameters.$queryParameters[parameterName];
3755 queryParameters[parameterName] = parameter;
3756 });
3757 }
3758
3759 var url = domain + path;
3760 var cached = parameters.$cache && parameters.$cache.get(url);
3761 if (cached !== undefined && parameters.$refresh !== true) {
3762 deferred.resolve(cached);
3763 return deferred.promise;
3764 }
3765 var options = {
3766 timeout: parameters.$timeout,
3767 method: 'GET',
3768 url: url,
3769 params: queryParameters,
3770 data: body,
3771 headers: headers
3772 };
3773 if (Object.keys(form).length > 0) {
3774 options.data = form;
3775 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3776 options.transformRequest = xos.transformRequest;
3777 }
3778 $http(options)
3779 .success(function(data, status, headers, config) {
3780 deferred.resolve(data);
3781 if (parameters.$cache !== undefined) {
3782 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3783 }
3784 })
3785 .error(function(data, status, headers, config) {
3786 deferred.reject({
3787 status: status,
3788 headers: headers,
3789 config: config,
3790 body: data
3791 });
3792 });
3793
3794 return deferred.promise;
3795 };
3796 /**
3797 *
3798 * @method
3799 * @name xos#Site_List_POST
3800 * @param {string} enacted -
3801 * @param {string} policed -
3802 * @param {string} backend_register -
3803 * @param {string} backend_status -
3804 * @param {boolean} deleted -
3805 * @param {boolean} write_protect -
3806 * @param {boolean} lazy_blocked -
3807 * @param {boolean} no_sync -
3808 * @param {string} name - Name for this Site
3809 * @param {string} site_url - Site's Home URL Page
3810 * @param {boolean} enabled - Status for this Site
3811 * @param {boolean} hosts_nodes - Indicates whether or not the site host nodes
3812 * @param {boolean} hosts_users - Indicates whether or not the site manages user accounts
3813 * @param {string} location -
3814 * @param {number} longitude -
3815 * @param {number} latitude -
3816 * @param {string} login_base - Prefix for Slices associated with this Site
3817 * @param {boolean} is_public - Indicates the visibility of this site to other members
3818 * @param {string} abbreviated_name -
3819 *
3820 */
3821 xos.prototype.Site_List_POST = function(parameters) {
3822 if (parameters === undefined) {
3823 parameters = {};
3824 }
3825 var deferred = $q.defer();
3826
3827 var domain = this.domain;
3828 var path = '/xos/sites/';
3829
3830 var body;
3831 var queryParameters = {};
3832 var headers = {};
3833 var form = {};
3834
3835 if (parameters['enacted'] !== undefined) {
3836 form['enacted'] = parameters['enacted'];
3837 }
3838
3839 if (parameters['policed'] !== undefined) {
3840 form['policed'] = parameters['policed'];
3841 }
3842
3843 if (parameters['backend_register'] !== undefined) {
3844 form['backend_register'] = parameters['backend_register'];
3845 }
3846
3847 if (parameters['backend_status'] !== undefined) {
3848 form['backend_status'] = parameters['backend_status'];
3849 }
3850
3851 if (parameters['backend_status'] === undefined) {
3852 deferred.reject(new Error('Missing required form parameter: backend_status'));
3853 return deferred.promise;
3854 }
3855
3856 if (parameters['deleted'] !== undefined) {
3857 form['deleted'] = parameters['deleted'];
3858 }
3859
3860 if (parameters['write_protect'] !== undefined) {
3861 form['write_protect'] = parameters['write_protect'];
3862 }
3863
3864 if (parameters['lazy_blocked'] !== undefined) {
3865 form['lazy_blocked'] = parameters['lazy_blocked'];
3866 }
3867
3868 if (parameters['no_sync'] !== undefined) {
3869 form['no_sync'] = parameters['no_sync'];
3870 }
3871
3872 if (parameters['name'] !== undefined) {
3873 form['name'] = parameters['name'];
3874 }
3875
3876 if (parameters['name'] === undefined) {
3877 deferred.reject(new Error('Missing required form parameter: name'));
3878 return deferred.promise;
3879 }
3880
3881 if (parameters['site_url'] !== undefined) {
3882 form['site_url'] = parameters['site_url'];
3883 }
3884
3885 if (parameters['enabled'] !== undefined) {
3886 form['enabled'] = parameters['enabled'];
3887 }
3888
3889 if (parameters['hosts_nodes'] !== undefined) {
3890 form['hosts_nodes'] = parameters['hosts_nodes'];
3891 }
3892
3893 if (parameters['hosts_users'] !== undefined) {
3894 form['hosts_users'] = parameters['hosts_users'];
3895 }
3896
3897 if (parameters['location'] !== undefined) {
3898 form['location'] = parameters['location'];
3899 }
3900
3901 if (parameters['location'] === undefined) {
3902 deferred.reject(new Error('Missing required form parameter: location'));
3903 return deferred.promise;
3904 }
3905
3906 if (parameters['longitude'] !== undefined) {
3907 form['longitude'] = parameters['longitude'];
3908 }
3909
3910 if (parameters['latitude'] !== undefined) {
3911 form['latitude'] = parameters['latitude'];
3912 }
3913
3914 if (parameters['login_base'] !== undefined) {
3915 form['login_base'] = parameters['login_base'];
3916 }
3917
3918 if (parameters['login_base'] === undefined) {
3919 deferred.reject(new Error('Missing required form parameter: login_base'));
3920 return deferred.promise;
3921 }
3922
3923 if (parameters['is_public'] !== undefined) {
3924 form['is_public'] = parameters['is_public'];
3925 }
3926
3927 if (parameters['abbreviated_name'] !== undefined) {
3928 form['abbreviated_name'] = parameters['abbreviated_name'];
3929 }
3930
3931 if (parameters['abbreviated_name'] === undefined) {
3932 deferred.reject(new Error('Missing required form parameter: abbreviated_name'));
3933 return deferred.promise;
3934 }
3935
3936 if (parameters.$queryParameters) {
3937 Object.keys(parameters.$queryParameters)
3938 .forEach(function(parameterName) {
3939 var parameter = parameters.$queryParameters[parameterName];
3940 queryParameters[parameterName] = parameter;
3941 });
3942 }
3943
3944 var url = domain + path;
3945 var options = {
3946 timeout: parameters.$timeout,
3947 method: 'POST',
3948 url: url,
3949 params: queryParameters,
3950 data: body,
3951 headers: headers
3952 };
3953 if (Object.keys(form).length > 0) {
3954 options.data = form;
3955 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
3956 options.transformRequest = xos.transformRequest;
3957 }
3958 $http(options)
3959 .success(function(data, status, headers, config) {
3960 deferred.resolve(data);
3961 if (parameters.$cache !== undefined) {
3962 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
3963 }
3964 })
3965 .error(function(data, status, headers, config) {
3966 deferred.reject({
3967 status: status,
3968 headers: headers,
3969 config: config,
3970 body: data
3971 });
3972 });
3973
3974 return deferred.promise;
3975 };
3976 /**
3977 *
3978 * @method
3979 * @name xos#Site_Detail_GET
3980 * @param {string} pk -
3981 *
3982 */
3983 xos.prototype.Site_Detail_GET = function(parameters) {
3984 if (parameters === undefined) {
3985 parameters = {};
3986 }
3987 var deferred = $q.defer();
3988
3989 var domain = this.domain;
3990 var path = '/xos/sites/{pk}/';
3991
3992 var body;
3993 var queryParameters = {};
3994 var headers = {};
3995 var form = {};
3996
3997 path = path.replace('{pk}', parameters['pk']);
3998
3999 if (parameters['pk'] === undefined) {
4000 deferred.reject(new Error('Missing required path parameter: pk'));
4001 return deferred.promise;
4002 }
4003
4004 if (parameters.$queryParameters) {
4005 Object.keys(parameters.$queryParameters)
4006 .forEach(function(parameterName) {
4007 var parameter = parameters.$queryParameters[parameterName];
4008 queryParameters[parameterName] = parameter;
4009 });
4010 }
4011
4012 var url = domain + path;
4013 var cached = parameters.$cache && parameters.$cache.get(url);
4014 if (cached !== undefined && parameters.$refresh !== true) {
4015 deferred.resolve(cached);
4016 return deferred.promise;
4017 }
4018 var options = {
4019 timeout: parameters.$timeout,
4020 method: 'GET',
4021 url: url,
4022 params: queryParameters,
4023 data: body,
4024 headers: headers
4025 };
4026 if (Object.keys(form).length > 0) {
4027 options.data = form;
4028 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4029 options.transformRequest = xos.transformRequest;
4030 }
4031 $http(options)
4032 .success(function(data, status, headers, config) {
4033 deferred.resolve(data);
4034 if (parameters.$cache !== undefined) {
4035 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4036 }
4037 })
4038 .error(function(data, status, headers, config) {
4039 deferred.reject({
4040 status: status,
4041 headers: headers,
4042 config: config,
4043 body: data
4044 });
4045 });
4046
4047 return deferred.promise;
4048 };
4049 /**
4050 *
4051 * @method
4052 * @name xos#Site_Detail_PUT
4053 * @param {string} pk -
4054 * @param {string} enacted -
4055 * @param {string} policed -
4056 * @param {string} backend_register -
4057 * @param {string} backend_status -
4058 * @param {boolean} deleted -
4059 * @param {boolean} write_protect -
4060 * @param {boolean} lazy_blocked -
4061 * @param {boolean} no_sync -
4062 * @param {string} name - Name for this Site
4063 * @param {string} site_url - Site's Home URL Page
4064 * @param {boolean} enabled - Status for this Site
4065 * @param {boolean} hosts_nodes - Indicates whether or not the site host nodes
4066 * @param {boolean} hosts_users - Indicates whether or not the site manages user accounts
4067 * @param {string} location -
4068 * @param {number} longitude -
4069 * @param {number} latitude -
4070 * @param {string} login_base - Prefix for Slices associated with this Site
4071 * @param {boolean} is_public - Indicates the visibility of this site to other members
4072 * @param {string} abbreviated_name -
4073 *
4074 */
4075 xos.prototype.Site_Detail_PUT = function(parameters) {
4076 if (parameters === undefined) {
4077 parameters = {};
4078 }
4079 var deferred = $q.defer();
4080
4081 var domain = this.domain;
4082 var path = '/xos/sites/{pk}/';
4083
4084 var body;
4085 var queryParameters = {};
4086 var headers = {};
4087 var form = {};
4088
4089 path = path.replace('{pk}', parameters['pk']);
4090
4091 if (parameters['pk'] === undefined) {
4092 deferred.reject(new Error('Missing required path parameter: pk'));
4093 return deferred.promise;
4094 }
4095
4096 if (parameters['enacted'] !== undefined) {
4097 form['enacted'] = parameters['enacted'];
4098 }
4099
4100 if (parameters['policed'] !== undefined) {
4101 form['policed'] = parameters['policed'];
4102 }
4103
4104 if (parameters['backend_register'] !== undefined) {
4105 form['backend_register'] = parameters['backend_register'];
4106 }
4107
4108 if (parameters['backend_status'] !== undefined) {
4109 form['backend_status'] = parameters['backend_status'];
4110 }
4111
4112 if (parameters['backend_status'] === undefined) {
4113 deferred.reject(new Error('Missing required form parameter: backend_status'));
4114 return deferred.promise;
4115 }
4116
4117 if (parameters['deleted'] !== undefined) {
4118 form['deleted'] = parameters['deleted'];
4119 }
4120
4121 if (parameters['write_protect'] !== undefined) {
4122 form['write_protect'] = parameters['write_protect'];
4123 }
4124
4125 if (parameters['lazy_blocked'] !== undefined) {
4126 form['lazy_blocked'] = parameters['lazy_blocked'];
4127 }
4128
4129 if (parameters['no_sync'] !== undefined) {
4130 form['no_sync'] = parameters['no_sync'];
4131 }
4132
4133 if (parameters['name'] !== undefined) {
4134 form['name'] = parameters['name'];
4135 }
4136
4137 if (parameters['name'] === undefined) {
4138 deferred.reject(new Error('Missing required form parameter: name'));
4139 return deferred.promise;
4140 }
4141
4142 if (parameters['site_url'] !== undefined) {
4143 form['site_url'] = parameters['site_url'];
4144 }
4145
4146 if (parameters['enabled'] !== undefined) {
4147 form['enabled'] = parameters['enabled'];
4148 }
4149
4150 if (parameters['hosts_nodes'] !== undefined) {
4151 form['hosts_nodes'] = parameters['hosts_nodes'];
4152 }
4153
4154 if (parameters['hosts_users'] !== undefined) {
4155 form['hosts_users'] = parameters['hosts_users'];
4156 }
4157
4158 if (parameters['location'] !== undefined) {
4159 form['location'] = parameters['location'];
4160 }
4161
4162 if (parameters['location'] === undefined) {
4163 deferred.reject(new Error('Missing required form parameter: location'));
4164 return deferred.promise;
4165 }
4166
4167 if (parameters['longitude'] !== undefined) {
4168 form['longitude'] = parameters['longitude'];
4169 }
4170
4171 if (parameters['latitude'] !== undefined) {
4172 form['latitude'] = parameters['latitude'];
4173 }
4174
4175 if (parameters['login_base'] !== undefined) {
4176 form['login_base'] = parameters['login_base'];
4177 }
4178
4179 if (parameters['login_base'] === undefined) {
4180 deferred.reject(new Error('Missing required form parameter: login_base'));
4181 return deferred.promise;
4182 }
4183
4184 if (parameters['is_public'] !== undefined) {
4185 form['is_public'] = parameters['is_public'];
4186 }
4187
4188 if (parameters['abbreviated_name'] !== undefined) {
4189 form['abbreviated_name'] = parameters['abbreviated_name'];
4190 }
4191
4192 if (parameters['abbreviated_name'] === undefined) {
4193 deferred.reject(new Error('Missing required form parameter: abbreviated_name'));
4194 return deferred.promise;
4195 }
4196
4197 if (parameters.$queryParameters) {
4198 Object.keys(parameters.$queryParameters)
4199 .forEach(function(parameterName) {
4200 var parameter = parameters.$queryParameters[parameterName];
4201 queryParameters[parameterName] = parameter;
4202 });
4203 }
4204
4205 var url = domain + path;
4206 var options = {
4207 timeout: parameters.$timeout,
4208 method: 'PUT',
4209 url: url,
4210 params: queryParameters,
4211 data: body,
4212 headers: headers
4213 };
4214 if (Object.keys(form).length > 0) {
4215 options.data = form;
4216 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4217 options.transformRequest = xos.transformRequest;
4218 }
4219 $http(options)
4220 .success(function(data, status, headers, config) {
4221 deferred.resolve(data);
4222 if (parameters.$cache !== undefined) {
4223 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4224 }
4225 })
4226 .error(function(data, status, headers, config) {
4227 deferred.reject({
4228 status: status,
4229 headers: headers,
4230 config: config,
4231 body: data
4232 });
4233 });
4234
4235 return deferred.promise;
4236 };
4237 /**
4238 *
4239 * @method
4240 * @name xos#Site_Detail_PATCH
4241 * @param {string} pk -
4242 * @param {string} enacted -
4243 * @param {string} policed -
4244 * @param {string} backend_register -
4245 * @param {string} backend_status -
4246 * @param {boolean} deleted -
4247 * @param {boolean} write_protect -
4248 * @param {boolean} lazy_blocked -
4249 * @param {boolean} no_sync -
4250 * @param {string} name - Name for this Site
4251 * @param {string} site_url - Site's Home URL Page
4252 * @param {boolean} enabled - Status for this Site
4253 * @param {boolean} hosts_nodes - Indicates whether or not the site host nodes
4254 * @param {boolean} hosts_users - Indicates whether or not the site manages user accounts
4255 * @param {string} location -
4256 * @param {number} longitude -
4257 * @param {number} latitude -
4258 * @param {string} login_base - Prefix for Slices associated with this Site
4259 * @param {boolean} is_public - Indicates the visibility of this site to other members
4260 * @param {string} abbreviated_name -
4261 *
4262 */
4263 xos.prototype.Site_Detail_PATCH = function(parameters) {
4264 if (parameters === undefined) {
4265 parameters = {};
4266 }
4267 var deferred = $q.defer();
4268
4269 var domain = this.domain;
4270 var path = '/xos/sites/{pk}/';
4271
4272 var body;
4273 var queryParameters = {};
4274 var headers = {};
4275 var form = {};
4276
4277 path = path.replace('{pk}', parameters['pk']);
4278
4279 if (parameters['pk'] === undefined) {
4280 deferred.reject(new Error('Missing required path parameter: pk'));
4281 return deferred.promise;
4282 }
4283
4284 if (parameters['enacted'] !== undefined) {
4285 form['enacted'] = parameters['enacted'];
4286 }
4287
4288 if (parameters['policed'] !== undefined) {
4289 form['policed'] = parameters['policed'];
4290 }
4291
4292 if (parameters['backend_register'] !== undefined) {
4293 form['backend_register'] = parameters['backend_register'];
4294 }
4295
4296 if (parameters['backend_status'] !== undefined) {
4297 form['backend_status'] = parameters['backend_status'];
4298 }
4299
4300 if (parameters['deleted'] !== undefined) {
4301 form['deleted'] = parameters['deleted'];
4302 }
4303
4304 if (parameters['write_protect'] !== undefined) {
4305 form['write_protect'] = parameters['write_protect'];
4306 }
4307
4308 if (parameters['lazy_blocked'] !== undefined) {
4309 form['lazy_blocked'] = parameters['lazy_blocked'];
4310 }
4311
4312 if (parameters['no_sync'] !== undefined) {
4313 form['no_sync'] = parameters['no_sync'];
4314 }
4315
4316 if (parameters['name'] !== undefined) {
4317 form['name'] = parameters['name'];
4318 }
4319
4320 if (parameters['site_url'] !== undefined) {
4321 form['site_url'] = parameters['site_url'];
4322 }
4323
4324 if (parameters['enabled'] !== undefined) {
4325 form['enabled'] = parameters['enabled'];
4326 }
4327
4328 if (parameters['hosts_nodes'] !== undefined) {
4329 form['hosts_nodes'] = parameters['hosts_nodes'];
4330 }
4331
4332 if (parameters['hosts_users'] !== undefined) {
4333 form['hosts_users'] = parameters['hosts_users'];
4334 }
4335
4336 if (parameters['location'] !== undefined) {
4337 form['location'] = parameters['location'];
4338 }
4339
4340 if (parameters['longitude'] !== undefined) {
4341 form['longitude'] = parameters['longitude'];
4342 }
4343
4344 if (parameters['latitude'] !== undefined) {
4345 form['latitude'] = parameters['latitude'];
4346 }
4347
4348 if (parameters['login_base'] !== undefined) {
4349 form['login_base'] = parameters['login_base'];
4350 }
4351
4352 if (parameters['is_public'] !== undefined) {
4353 form['is_public'] = parameters['is_public'];
4354 }
4355
4356 if (parameters['abbreviated_name'] !== undefined) {
4357 form['abbreviated_name'] = parameters['abbreviated_name'];
4358 }
4359
4360 if (parameters.$queryParameters) {
4361 Object.keys(parameters.$queryParameters)
4362 .forEach(function(parameterName) {
4363 var parameter = parameters.$queryParameters[parameterName];
4364 queryParameters[parameterName] = parameter;
4365 });
4366 }
4367
4368 var url = domain + path;
4369 var options = {
4370 timeout: parameters.$timeout,
4371 method: 'PATCH',
4372 url: url,
4373 params: queryParameters,
4374 data: body,
4375 headers: headers
4376 };
4377 if (Object.keys(form).length > 0) {
4378 options.data = form;
4379 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4380 options.transformRequest = xos.transformRequest;
4381 }
4382 $http(options)
4383 .success(function(data, status, headers, config) {
4384 deferred.resolve(data);
4385 if (parameters.$cache !== undefined) {
4386 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4387 }
4388 })
4389 .error(function(data, status, headers, config) {
4390 deferred.reject({
4391 status: status,
4392 headers: headers,
4393 config: config,
4394 body: data
4395 });
4396 });
4397
4398 return deferred.promise;
4399 };
4400 /**
4401 *
4402 * @method
4403 * @name xos#Site_Detail_DELETE
4404 * @param {string} pk -
4405 *
4406 */
4407 xos.prototype.Site_Detail_DELETE = function(parameters) {
4408 if (parameters === undefined) {
4409 parameters = {};
4410 }
4411 var deferred = $q.defer();
4412
4413 var domain = this.domain;
4414 var path = '/xos/sites/{pk}/';
4415
4416 var body;
4417 var queryParameters = {};
4418 var headers = {};
4419 var form = {};
4420
4421 path = path.replace('{pk}', parameters['pk']);
4422
4423 if (parameters['pk'] === undefined) {
4424 deferred.reject(new Error('Missing required path parameter: pk'));
4425 return deferred.promise;
4426 }
4427
4428 if (parameters.$queryParameters) {
4429 Object.keys(parameters.$queryParameters)
4430 .forEach(function(parameterName) {
4431 var parameter = parameters.$queryParameters[parameterName];
4432 queryParameters[parameterName] = parameter;
4433 });
4434 }
4435
4436 var url = domain + path;
4437 var options = {
4438 timeout: parameters.$timeout,
4439 method: 'DELETE',
4440 url: url,
4441 params: queryParameters,
4442 data: body,
4443 headers: headers
4444 };
4445 if (Object.keys(form).length > 0) {
4446 options.data = form;
4447 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4448 options.transformRequest = xos.transformRequest;
4449 }
4450 $http(options)
4451 .success(function(data, status, headers, config) {
4452 deferred.resolve(data);
4453 if (parameters.$cache !== undefined) {
4454 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4455 }
4456 })
4457 .error(function(data, status, headers, config) {
4458 deferred.reject({
4459 status: status,
4460 headers: headers,
4461 config: config,
4462 body: data
4463 });
4464 });
4465
4466 return deferred.promise;
4467 };
4468 /**
4469 *
4470 * @method
4471 * @name xos#Tenant_Root_Role_List_GET
4472 *
4473 */
4474 xos.prototype.Tenant_Root_Role_List_GET = function(parameters) {
4475 if (parameters === undefined) {
4476 parameters = {};
4477 }
4478 var deferred = $q.defer();
4479
4480 var domain = this.domain;
4481 var path = '/xos/tenantrootroles/';
4482
4483 var body;
4484 var queryParameters = {};
4485 var headers = {};
4486 var form = {};
4487
4488 if (parameters.$queryParameters) {
4489 Object.keys(parameters.$queryParameters)
4490 .forEach(function(parameterName) {
4491 var parameter = parameters.$queryParameters[parameterName];
4492 queryParameters[parameterName] = parameter;
4493 });
4494 }
4495
4496 var url = domain + path;
4497 var cached = parameters.$cache && parameters.$cache.get(url);
4498 if (cached !== undefined && parameters.$refresh !== true) {
4499 deferred.resolve(cached);
4500 return deferred.promise;
4501 }
4502 var options = {
4503 timeout: parameters.$timeout,
4504 method: 'GET',
4505 url: url,
4506 params: queryParameters,
4507 data: body,
4508 headers: headers
4509 };
4510 if (Object.keys(form).length > 0) {
4511 options.data = form;
4512 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4513 options.transformRequest = xos.transformRequest;
4514 }
4515 $http(options)
4516 .success(function(data, status, headers, config) {
4517 deferred.resolve(data);
4518 if (parameters.$cache !== undefined) {
4519 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4520 }
4521 })
4522 .error(function(data, status, headers, config) {
4523 deferred.reject({
4524 status: status,
4525 headers: headers,
4526 config: config,
4527 body: data
4528 });
4529 });
4530
4531 return deferred.promise;
4532 };
4533 /**
4534 *
4535 * @method
4536 * @name xos#Tenant_Root_Role_List_POST
4537 * @param {string} enacted -
4538 * @param {string} policed -
4539 * @param {string} backend_register -
4540 * @param {string} backend_status -
4541 * @param {boolean} deleted -
4542 * @param {boolean} write_protect -
4543 * @param {boolean} lazy_blocked -
4544 * @param {boolean} no_sync -
4545 * @param {choice} role -
4546 *
4547 */
4548 xos.prototype.Tenant_Root_Role_List_POST = function(parameters) {
4549 if (parameters === undefined) {
4550 parameters = {};
4551 }
4552 var deferred = $q.defer();
4553
4554 var domain = this.domain;
4555 var path = '/xos/tenantrootroles/';
4556
4557 var body;
4558 var queryParameters = {};
4559 var headers = {};
4560 var form = {};
4561
4562 if (parameters['enacted'] !== undefined) {
4563 form['enacted'] = parameters['enacted'];
4564 }
4565
4566 if (parameters['policed'] !== undefined) {
4567 form['policed'] = parameters['policed'];
4568 }
4569
4570 if (parameters['backend_register'] !== undefined) {
4571 form['backend_register'] = parameters['backend_register'];
4572 }
4573
4574 if (parameters['backend_status'] !== undefined) {
4575 form['backend_status'] = parameters['backend_status'];
4576 }
4577
4578 if (parameters['backend_status'] === undefined) {
4579 deferred.reject(new Error('Missing required form parameter: backend_status'));
4580 return deferred.promise;
4581 }
4582
4583 if (parameters['deleted'] !== undefined) {
4584 form['deleted'] = parameters['deleted'];
4585 }
4586
4587 if (parameters['write_protect'] !== undefined) {
4588 form['write_protect'] = parameters['write_protect'];
4589 }
4590
4591 if (parameters['lazy_blocked'] !== undefined) {
4592 form['lazy_blocked'] = parameters['lazy_blocked'];
4593 }
4594
4595 if (parameters['no_sync'] !== undefined) {
4596 form['no_sync'] = parameters['no_sync'];
4597 }
4598
4599 if (parameters['role'] !== undefined) {
4600 form['role'] = parameters['role'];
4601 }
4602
4603 if (parameters['role'] === undefined) {
4604 deferred.reject(new Error('Missing required form parameter: role'));
4605 return deferred.promise;
4606 }
4607
4608 if (parameters.$queryParameters) {
4609 Object.keys(parameters.$queryParameters)
4610 .forEach(function(parameterName) {
4611 var parameter = parameters.$queryParameters[parameterName];
4612 queryParameters[parameterName] = parameter;
4613 });
4614 }
4615
4616 var url = domain + path;
4617 var options = {
4618 timeout: parameters.$timeout,
4619 method: 'POST',
4620 url: url,
4621 params: queryParameters,
4622 data: body,
4623 headers: headers
4624 };
4625 if (Object.keys(form).length > 0) {
4626 options.data = form;
4627 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4628 options.transformRequest = xos.transformRequest;
4629 }
4630 $http(options)
4631 .success(function(data, status, headers, config) {
4632 deferred.resolve(data);
4633 if (parameters.$cache !== undefined) {
4634 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4635 }
4636 })
4637 .error(function(data, status, headers, config) {
4638 deferred.reject({
4639 status: status,
4640 headers: headers,
4641 config: config,
4642 body: data
4643 });
4644 });
4645
4646 return deferred.promise;
4647 };
4648 /**
4649 *
4650 * @method
4651 * @name xos#Tenant_Root_Role_Detail_GET
4652 * @param {string} pk -
4653 *
4654 */
4655 xos.prototype.Tenant_Root_Role_Detail_GET = function(parameters) {
4656 if (parameters === undefined) {
4657 parameters = {};
4658 }
4659 var deferred = $q.defer();
4660
4661 var domain = this.domain;
4662 var path = '/xos/tenantrootroles/{pk}/';
4663
4664 var body;
4665 var queryParameters = {};
4666 var headers = {};
4667 var form = {};
4668
4669 path = path.replace('{pk}', parameters['pk']);
4670
4671 if (parameters['pk'] === undefined) {
4672 deferred.reject(new Error('Missing required path parameter: pk'));
4673 return deferred.promise;
4674 }
4675
4676 if (parameters.$queryParameters) {
4677 Object.keys(parameters.$queryParameters)
4678 .forEach(function(parameterName) {
4679 var parameter = parameters.$queryParameters[parameterName];
4680 queryParameters[parameterName] = parameter;
4681 });
4682 }
4683
4684 var url = domain + path;
4685 var cached = parameters.$cache && parameters.$cache.get(url);
4686 if (cached !== undefined && parameters.$refresh !== true) {
4687 deferred.resolve(cached);
4688 return deferred.promise;
4689 }
4690 var options = {
4691 timeout: parameters.$timeout,
4692 method: 'GET',
4693 url: url,
4694 params: queryParameters,
4695 data: body,
4696 headers: headers
4697 };
4698 if (Object.keys(form).length > 0) {
4699 options.data = form;
4700 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4701 options.transformRequest = xos.transformRequest;
4702 }
4703 $http(options)
4704 .success(function(data, status, headers, config) {
4705 deferred.resolve(data);
4706 if (parameters.$cache !== undefined) {
4707 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4708 }
4709 })
4710 .error(function(data, status, headers, config) {
4711 deferred.reject({
4712 status: status,
4713 headers: headers,
4714 config: config,
4715 body: data
4716 });
4717 });
4718
4719 return deferred.promise;
4720 };
4721 /**
4722 *
4723 * @method
4724 * @name xos#Tenant_Root_Role_Detail_PUT
4725 * @param {string} pk -
4726 * @param {string} enacted -
4727 * @param {string} policed -
4728 * @param {string} backend_register -
4729 * @param {string} backend_status -
4730 * @param {boolean} deleted -
4731 * @param {boolean} write_protect -
4732 * @param {boolean} lazy_blocked -
4733 * @param {boolean} no_sync -
4734 * @param {choice} role -
4735 *
4736 */
4737 xos.prototype.Tenant_Root_Role_Detail_PUT = function(parameters) {
4738 if (parameters === undefined) {
4739 parameters = {};
4740 }
4741 var deferred = $q.defer();
4742
4743 var domain = this.domain;
4744 var path = '/xos/tenantrootroles/{pk}/';
4745
4746 var body;
4747 var queryParameters = {};
4748 var headers = {};
4749 var form = {};
4750
4751 path = path.replace('{pk}', parameters['pk']);
4752
4753 if (parameters['pk'] === undefined) {
4754 deferred.reject(new Error('Missing required path parameter: pk'));
4755 return deferred.promise;
4756 }
4757
4758 if (parameters['enacted'] !== undefined) {
4759 form['enacted'] = parameters['enacted'];
4760 }
4761
4762 if (parameters['policed'] !== undefined) {
4763 form['policed'] = parameters['policed'];
4764 }
4765
4766 if (parameters['backend_register'] !== undefined) {
4767 form['backend_register'] = parameters['backend_register'];
4768 }
4769
4770 if (parameters['backend_status'] !== undefined) {
4771 form['backend_status'] = parameters['backend_status'];
4772 }
4773
4774 if (parameters['backend_status'] === undefined) {
4775 deferred.reject(new Error('Missing required form parameter: backend_status'));
4776 return deferred.promise;
4777 }
4778
4779 if (parameters['deleted'] !== undefined) {
4780 form['deleted'] = parameters['deleted'];
4781 }
4782
4783 if (parameters['write_protect'] !== undefined) {
4784 form['write_protect'] = parameters['write_protect'];
4785 }
4786
4787 if (parameters['lazy_blocked'] !== undefined) {
4788 form['lazy_blocked'] = parameters['lazy_blocked'];
4789 }
4790
4791 if (parameters['no_sync'] !== undefined) {
4792 form['no_sync'] = parameters['no_sync'];
4793 }
4794
4795 if (parameters['role'] !== undefined) {
4796 form['role'] = parameters['role'];
4797 }
4798
4799 if (parameters['role'] === undefined) {
4800 deferred.reject(new Error('Missing required form parameter: role'));
4801 return deferred.promise;
4802 }
4803
4804 if (parameters.$queryParameters) {
4805 Object.keys(parameters.$queryParameters)
4806 .forEach(function(parameterName) {
4807 var parameter = parameters.$queryParameters[parameterName];
4808 queryParameters[parameterName] = parameter;
4809 });
4810 }
4811
4812 var url = domain + path;
4813 var options = {
4814 timeout: parameters.$timeout,
4815 method: 'PUT',
4816 url: url,
4817 params: queryParameters,
4818 data: body,
4819 headers: headers
4820 };
4821 if (Object.keys(form).length > 0) {
4822 options.data = form;
4823 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4824 options.transformRequest = xos.transformRequest;
4825 }
4826 $http(options)
4827 .success(function(data, status, headers, config) {
4828 deferred.resolve(data);
4829 if (parameters.$cache !== undefined) {
4830 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4831 }
4832 })
4833 .error(function(data, status, headers, config) {
4834 deferred.reject({
4835 status: status,
4836 headers: headers,
4837 config: config,
4838 body: data
4839 });
4840 });
4841
4842 return deferred.promise;
4843 };
4844 /**
4845 *
4846 * @method
4847 * @name xos#Tenant_Root_Role_Detail_PATCH
4848 * @param {string} pk -
4849 * @param {string} enacted -
4850 * @param {string} policed -
4851 * @param {string} backend_register -
4852 * @param {string} backend_status -
4853 * @param {boolean} deleted -
4854 * @param {boolean} write_protect -
4855 * @param {boolean} lazy_blocked -
4856 * @param {boolean} no_sync -
4857 * @param {choice} role -
4858 *
4859 */
4860 xos.prototype.Tenant_Root_Role_Detail_PATCH = function(parameters) {
4861 if (parameters === undefined) {
4862 parameters = {};
4863 }
4864 var deferred = $q.defer();
4865
4866 var domain = this.domain;
4867 var path = '/xos/tenantrootroles/{pk}/';
4868
4869 var body;
4870 var queryParameters = {};
4871 var headers = {};
4872 var form = {};
4873
4874 path = path.replace('{pk}', parameters['pk']);
4875
4876 if (parameters['pk'] === undefined) {
4877 deferred.reject(new Error('Missing required path parameter: pk'));
4878 return deferred.promise;
4879 }
4880
4881 if (parameters['enacted'] !== undefined) {
4882 form['enacted'] = parameters['enacted'];
4883 }
4884
4885 if (parameters['policed'] !== undefined) {
4886 form['policed'] = parameters['policed'];
4887 }
4888
4889 if (parameters['backend_register'] !== undefined) {
4890 form['backend_register'] = parameters['backend_register'];
4891 }
4892
4893 if (parameters['backend_status'] !== undefined) {
4894 form['backend_status'] = parameters['backend_status'];
4895 }
4896
4897 if (parameters['deleted'] !== undefined) {
4898 form['deleted'] = parameters['deleted'];
4899 }
4900
4901 if (parameters['write_protect'] !== undefined) {
4902 form['write_protect'] = parameters['write_protect'];
4903 }
4904
4905 if (parameters['lazy_blocked'] !== undefined) {
4906 form['lazy_blocked'] = parameters['lazy_blocked'];
4907 }
4908
4909 if (parameters['no_sync'] !== undefined) {
4910 form['no_sync'] = parameters['no_sync'];
4911 }
4912
4913 if (parameters['role'] !== undefined) {
4914 form['role'] = parameters['role'];
4915 }
4916
4917 if (parameters.$queryParameters) {
4918 Object.keys(parameters.$queryParameters)
4919 .forEach(function(parameterName) {
4920 var parameter = parameters.$queryParameters[parameterName];
4921 queryParameters[parameterName] = parameter;
4922 });
4923 }
4924
4925 var url = domain + path;
4926 var options = {
4927 timeout: parameters.$timeout,
4928 method: 'PATCH',
4929 url: url,
4930 params: queryParameters,
4931 data: body,
4932 headers: headers
4933 };
4934 if (Object.keys(form).length > 0) {
4935 options.data = form;
4936 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
4937 options.transformRequest = xos.transformRequest;
4938 }
4939 $http(options)
4940 .success(function(data, status, headers, config) {
4941 deferred.resolve(data);
4942 if (parameters.$cache !== undefined) {
4943 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
4944 }
4945 })
4946 .error(function(data, status, headers, config) {
4947 deferred.reject({
4948 status: status,
4949 headers: headers,
4950 config: config,
4951 body: data
4952 });
4953 });
4954
4955 return deferred.promise;
4956 };
4957 /**
4958 *
4959 * @method
4960 * @name xos#Tenant_Root_Role_Detail_DELETE
4961 * @param {string} pk -
4962 *
4963 */
4964 xos.prototype.Tenant_Root_Role_Detail_DELETE = function(parameters) {
4965 if (parameters === undefined) {
4966 parameters = {};
4967 }
4968 var deferred = $q.defer();
4969
4970 var domain = this.domain;
4971 var path = '/xos/tenantrootroles/{pk}/';
4972
4973 var body;
4974 var queryParameters = {};
4975 var headers = {};
4976 var form = {};
4977
4978 path = path.replace('{pk}', parameters['pk']);
4979
4980 if (parameters['pk'] === undefined) {
4981 deferred.reject(new Error('Missing required path parameter: pk'));
4982 return deferred.promise;
4983 }
4984
4985 if (parameters.$queryParameters) {
4986 Object.keys(parameters.$queryParameters)
4987 .forEach(function(parameterName) {
4988 var parameter = parameters.$queryParameters[parameterName];
4989 queryParameters[parameterName] = parameter;
4990 });
4991 }
4992
4993 var url = domain + path;
4994 var options = {
4995 timeout: parameters.$timeout,
4996 method: 'DELETE',
4997 url: url,
4998 params: queryParameters,
4999 data: body,
5000 headers: headers
5001 };
5002 if (Object.keys(form).length > 0) {
5003 options.data = form;
5004 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5005 options.transformRequest = xos.transformRequest;
5006 }
5007 $http(options)
5008 .success(function(data, status, headers, config) {
5009 deferred.resolve(data);
5010 if (parameters.$cache !== undefined) {
5011 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5012 }
5013 })
5014 .error(function(data, status, headers, config) {
5015 deferred.reject({
5016 status: status,
5017 headers: headers,
5018 config: config,
5019 body: data
5020 });
5021 });
5022
5023 return deferred.promise;
5024 };
5025 /**
5026 *
5027 * @method
5028 * @name xos#Slice_Role_List_GET
5029 *
5030 */
5031 xos.prototype.Slice_Role_List_GET = function(parameters) {
5032 if (parameters === undefined) {
5033 parameters = {};
5034 }
5035 var deferred = $q.defer();
5036
5037 var domain = this.domain;
5038 var path = '/xos/slice_roles/';
5039
5040 var body;
5041 var queryParameters = {};
5042 var headers = {};
5043 var form = {};
5044
5045 if (parameters.$queryParameters) {
5046 Object.keys(parameters.$queryParameters)
5047 .forEach(function(parameterName) {
5048 var parameter = parameters.$queryParameters[parameterName];
5049 queryParameters[parameterName] = parameter;
5050 });
5051 }
5052
5053 var url = domain + path;
5054 var cached = parameters.$cache && parameters.$cache.get(url);
5055 if (cached !== undefined && parameters.$refresh !== true) {
5056 deferred.resolve(cached);
5057 return deferred.promise;
5058 }
5059 var options = {
5060 timeout: parameters.$timeout,
5061 method: 'GET',
5062 url: url,
5063 params: queryParameters,
5064 data: body,
5065 headers: headers
5066 };
5067 if (Object.keys(form).length > 0) {
5068 options.data = form;
5069 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5070 options.transformRequest = xos.transformRequest;
5071 }
5072 $http(options)
5073 .success(function(data, status, headers, config) {
5074 deferred.resolve(data);
5075 if (parameters.$cache !== undefined) {
5076 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5077 }
5078 })
5079 .error(function(data, status, headers, config) {
5080 deferred.reject({
5081 status: status,
5082 headers: headers,
5083 config: config,
5084 body: data
5085 });
5086 });
5087
5088 return deferred.promise;
5089 };
5090 /**
5091 *
5092 * @method
5093 * @name xos#Slice_Role_List_POST
5094 * @param {string} enacted -
5095 * @param {string} policed -
5096 * @param {string} backend_register -
5097 * @param {string} backend_status -
5098 * @param {boolean} deleted -
5099 * @param {boolean} write_protect -
5100 * @param {boolean} lazy_blocked -
5101 * @param {boolean} no_sync -
5102 * @param {choice} role -
5103 *
5104 */
5105 xos.prototype.Slice_Role_List_POST = function(parameters) {
5106 if (parameters === undefined) {
5107 parameters = {};
5108 }
5109 var deferred = $q.defer();
5110
5111 var domain = this.domain;
5112 var path = '/xos/slice_roles/';
5113
5114 var body;
5115 var queryParameters = {};
5116 var headers = {};
5117 var form = {};
5118
5119 if (parameters['enacted'] !== undefined) {
5120 form['enacted'] = parameters['enacted'];
5121 }
5122
5123 if (parameters['policed'] !== undefined) {
5124 form['policed'] = parameters['policed'];
5125 }
5126
5127 if (parameters['backend_register'] !== undefined) {
5128 form['backend_register'] = parameters['backend_register'];
5129 }
5130
5131 if (parameters['backend_status'] !== undefined) {
5132 form['backend_status'] = parameters['backend_status'];
5133 }
5134
5135 if (parameters['backend_status'] === undefined) {
5136 deferred.reject(new Error('Missing required form parameter: backend_status'));
5137 return deferred.promise;
5138 }
5139
5140 if (parameters['deleted'] !== undefined) {
5141 form['deleted'] = parameters['deleted'];
5142 }
5143
5144 if (parameters['write_protect'] !== undefined) {
5145 form['write_protect'] = parameters['write_protect'];
5146 }
5147
5148 if (parameters['lazy_blocked'] !== undefined) {
5149 form['lazy_blocked'] = parameters['lazy_blocked'];
5150 }
5151
5152 if (parameters['no_sync'] !== undefined) {
5153 form['no_sync'] = parameters['no_sync'];
5154 }
5155
5156 if (parameters['role'] !== undefined) {
5157 form['role'] = parameters['role'];
5158 }
5159
5160 if (parameters['role'] === undefined) {
5161 deferred.reject(new Error('Missing required form parameter: role'));
5162 return deferred.promise;
5163 }
5164
5165 if (parameters.$queryParameters) {
5166 Object.keys(parameters.$queryParameters)
5167 .forEach(function(parameterName) {
5168 var parameter = parameters.$queryParameters[parameterName];
5169 queryParameters[parameterName] = parameter;
5170 });
5171 }
5172
5173 var url = domain + path;
5174 var options = {
5175 timeout: parameters.$timeout,
5176 method: 'POST',
5177 url: url,
5178 params: queryParameters,
5179 data: body,
5180 headers: headers
5181 };
5182 if (Object.keys(form).length > 0) {
5183 options.data = form;
5184 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5185 options.transformRequest = xos.transformRequest;
5186 }
5187 $http(options)
5188 .success(function(data, status, headers, config) {
5189 deferred.resolve(data);
5190 if (parameters.$cache !== undefined) {
5191 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5192 }
5193 })
5194 .error(function(data, status, headers, config) {
5195 deferred.reject({
5196 status: status,
5197 headers: headers,
5198 config: config,
5199 body: data
5200 });
5201 });
5202
5203 return deferred.promise;
5204 };
5205 /**
5206 *
5207 * @method
5208 * @name xos#Slice_Role_Detail_GET
5209 * @param {string} pk -
5210 *
5211 */
5212 xos.prototype.Slice_Role_Detail_GET = function(parameters) {
5213 if (parameters === undefined) {
5214 parameters = {};
5215 }
5216 var deferred = $q.defer();
5217
5218 var domain = this.domain;
5219 var path = '/xos/slice_roles/{pk}/';
5220
5221 var body;
5222 var queryParameters = {};
5223 var headers = {};
5224 var form = {};
5225
5226 path = path.replace('{pk}', parameters['pk']);
5227
5228 if (parameters['pk'] === undefined) {
5229 deferred.reject(new Error('Missing required path parameter: pk'));
5230 return deferred.promise;
5231 }
5232
5233 if (parameters.$queryParameters) {
5234 Object.keys(parameters.$queryParameters)
5235 .forEach(function(parameterName) {
5236 var parameter = parameters.$queryParameters[parameterName];
5237 queryParameters[parameterName] = parameter;
5238 });
5239 }
5240
5241 var url = domain + path;
5242 var cached = parameters.$cache && parameters.$cache.get(url);
5243 if (cached !== undefined && parameters.$refresh !== true) {
5244 deferred.resolve(cached);
5245 return deferred.promise;
5246 }
5247 var options = {
5248 timeout: parameters.$timeout,
5249 method: 'GET',
5250 url: url,
5251 params: queryParameters,
5252 data: body,
5253 headers: headers
5254 };
5255 if (Object.keys(form).length > 0) {
5256 options.data = form;
5257 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5258 options.transformRequest = xos.transformRequest;
5259 }
5260 $http(options)
5261 .success(function(data, status, headers, config) {
5262 deferred.resolve(data);
5263 if (parameters.$cache !== undefined) {
5264 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5265 }
5266 })
5267 .error(function(data, status, headers, config) {
5268 deferred.reject({
5269 status: status,
5270 headers: headers,
5271 config: config,
5272 body: data
5273 });
5274 });
5275
5276 return deferred.promise;
5277 };
5278 /**
5279 *
5280 * @method
5281 * @name xos#Slice_Role_Detail_PUT
5282 * @param {string} pk -
5283 * @param {string} enacted -
5284 * @param {string} policed -
5285 * @param {string} backend_register -
5286 * @param {string} backend_status -
5287 * @param {boolean} deleted -
5288 * @param {boolean} write_protect -
5289 * @param {boolean} lazy_blocked -
5290 * @param {boolean} no_sync -
5291 * @param {choice} role -
5292 *
5293 */
5294 xos.prototype.Slice_Role_Detail_PUT = function(parameters) {
5295 if (parameters === undefined) {
5296 parameters = {};
5297 }
5298 var deferred = $q.defer();
5299
5300 var domain = this.domain;
5301 var path = '/xos/slice_roles/{pk}/';
5302
5303 var body;
5304 var queryParameters = {};
5305 var headers = {};
5306 var form = {};
5307
5308 path = path.replace('{pk}', parameters['pk']);
5309
5310 if (parameters['pk'] === undefined) {
5311 deferred.reject(new Error('Missing required path parameter: pk'));
5312 return deferred.promise;
5313 }
5314
5315 if (parameters['enacted'] !== undefined) {
5316 form['enacted'] = parameters['enacted'];
5317 }
5318
5319 if (parameters['policed'] !== undefined) {
5320 form['policed'] = parameters['policed'];
5321 }
5322
5323 if (parameters['backend_register'] !== undefined) {
5324 form['backend_register'] = parameters['backend_register'];
5325 }
5326
5327 if (parameters['backend_status'] !== undefined) {
5328 form['backend_status'] = parameters['backend_status'];
5329 }
5330
5331 if (parameters['backend_status'] === undefined) {
5332 deferred.reject(new Error('Missing required form parameter: backend_status'));
5333 return deferred.promise;
5334 }
5335
5336 if (parameters['deleted'] !== undefined) {
5337 form['deleted'] = parameters['deleted'];
5338 }
5339
5340 if (parameters['write_protect'] !== undefined) {
5341 form['write_protect'] = parameters['write_protect'];
5342 }
5343
5344 if (parameters['lazy_blocked'] !== undefined) {
5345 form['lazy_blocked'] = parameters['lazy_blocked'];
5346 }
5347
5348 if (parameters['no_sync'] !== undefined) {
5349 form['no_sync'] = parameters['no_sync'];
5350 }
5351
5352 if (parameters['role'] !== undefined) {
5353 form['role'] = parameters['role'];
5354 }
5355
5356 if (parameters['role'] === undefined) {
5357 deferred.reject(new Error('Missing required form parameter: role'));
5358 return deferred.promise;
5359 }
5360
5361 if (parameters.$queryParameters) {
5362 Object.keys(parameters.$queryParameters)
5363 .forEach(function(parameterName) {
5364 var parameter = parameters.$queryParameters[parameterName];
5365 queryParameters[parameterName] = parameter;
5366 });
5367 }
5368
5369 var url = domain + path;
5370 var options = {
5371 timeout: parameters.$timeout,
5372 method: 'PUT',
5373 url: url,
5374 params: queryParameters,
5375 data: body,
5376 headers: headers
5377 };
5378 if (Object.keys(form).length > 0) {
5379 options.data = form;
5380 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5381 options.transformRequest = xos.transformRequest;
5382 }
5383 $http(options)
5384 .success(function(data, status, headers, config) {
5385 deferred.resolve(data);
5386 if (parameters.$cache !== undefined) {
5387 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5388 }
5389 })
5390 .error(function(data, status, headers, config) {
5391 deferred.reject({
5392 status: status,
5393 headers: headers,
5394 config: config,
5395 body: data
5396 });
5397 });
5398
5399 return deferred.promise;
5400 };
5401 /**
5402 *
5403 * @method
5404 * @name xos#Slice_Role_Detail_PATCH
5405 * @param {string} pk -
5406 * @param {string} enacted -
5407 * @param {string} policed -
5408 * @param {string} backend_register -
5409 * @param {string} backend_status -
5410 * @param {boolean} deleted -
5411 * @param {boolean} write_protect -
5412 * @param {boolean} lazy_blocked -
5413 * @param {boolean} no_sync -
5414 * @param {choice} role -
5415 *
5416 */
5417 xos.prototype.Slice_Role_Detail_PATCH = function(parameters) {
5418 if (parameters === undefined) {
5419 parameters = {};
5420 }
5421 var deferred = $q.defer();
5422
5423 var domain = this.domain;
5424 var path = '/xos/slice_roles/{pk}/';
5425
5426 var body;
5427 var queryParameters = {};
5428 var headers = {};
5429 var form = {};
5430
5431 path = path.replace('{pk}', parameters['pk']);
5432
5433 if (parameters['pk'] === undefined) {
5434 deferred.reject(new Error('Missing required path parameter: pk'));
5435 return deferred.promise;
5436 }
5437
5438 if (parameters['enacted'] !== undefined) {
5439 form['enacted'] = parameters['enacted'];
5440 }
5441
5442 if (parameters['policed'] !== undefined) {
5443 form['policed'] = parameters['policed'];
5444 }
5445
5446 if (parameters['backend_register'] !== undefined) {
5447 form['backend_register'] = parameters['backend_register'];
5448 }
5449
5450 if (parameters['backend_status'] !== undefined) {
5451 form['backend_status'] = parameters['backend_status'];
5452 }
5453
5454 if (parameters['deleted'] !== undefined) {
5455 form['deleted'] = parameters['deleted'];
5456 }
5457
5458 if (parameters['write_protect'] !== undefined) {
5459 form['write_protect'] = parameters['write_protect'];
5460 }
5461
5462 if (parameters['lazy_blocked'] !== undefined) {
5463 form['lazy_blocked'] = parameters['lazy_blocked'];
5464 }
5465
5466 if (parameters['no_sync'] !== undefined) {
5467 form['no_sync'] = parameters['no_sync'];
5468 }
5469
5470 if (parameters['role'] !== undefined) {
5471 form['role'] = parameters['role'];
5472 }
5473
5474 if (parameters.$queryParameters) {
5475 Object.keys(parameters.$queryParameters)
5476 .forEach(function(parameterName) {
5477 var parameter = parameters.$queryParameters[parameterName];
5478 queryParameters[parameterName] = parameter;
5479 });
5480 }
5481
5482 var url = domain + path;
5483 var options = {
5484 timeout: parameters.$timeout,
5485 method: 'PATCH',
5486 url: url,
5487 params: queryParameters,
5488 data: body,
5489 headers: headers
5490 };
5491 if (Object.keys(form).length > 0) {
5492 options.data = form;
5493 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5494 options.transformRequest = xos.transformRequest;
5495 }
5496 $http(options)
5497 .success(function(data, status, headers, config) {
5498 deferred.resolve(data);
5499 if (parameters.$cache !== undefined) {
5500 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5501 }
5502 })
5503 .error(function(data, status, headers, config) {
5504 deferred.reject({
5505 status: status,
5506 headers: headers,
5507 config: config,
5508 body: data
5509 });
5510 });
5511
5512 return deferred.promise;
5513 };
5514 /**
5515 *
5516 * @method
5517 * @name xos#Slice_Role_Detail_DELETE
5518 * @param {string} pk -
5519 *
5520 */
5521 xos.prototype.Slice_Role_Detail_DELETE = function(parameters) {
5522 if (parameters === undefined) {
5523 parameters = {};
5524 }
5525 var deferred = $q.defer();
5526
5527 var domain = this.domain;
5528 var path = '/xos/slice_roles/{pk}/';
5529
5530 var body;
5531 var queryParameters = {};
5532 var headers = {};
5533 var form = {};
5534
5535 path = path.replace('{pk}', parameters['pk']);
5536
5537 if (parameters['pk'] === undefined) {
5538 deferred.reject(new Error('Missing required path parameter: pk'));
5539 return deferred.promise;
5540 }
5541
5542 if (parameters.$queryParameters) {
5543 Object.keys(parameters.$queryParameters)
5544 .forEach(function(parameterName) {
5545 var parameter = parameters.$queryParameters[parameterName];
5546 queryParameters[parameterName] = parameter;
5547 });
5548 }
5549
5550 var url = domain + path;
5551 var options = {
5552 timeout: parameters.$timeout,
5553 method: 'DELETE',
5554 url: url,
5555 params: queryParameters,
5556 data: body,
5557 headers: headers
5558 };
5559 if (Object.keys(form).length > 0) {
5560 options.data = form;
5561 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5562 options.transformRequest = xos.transformRequest;
5563 }
5564 $http(options)
5565 .success(function(data, status, headers, config) {
5566 deferred.resolve(data);
5567 if (parameters.$cache !== undefined) {
5568 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5569 }
5570 })
5571 .error(function(data, status, headers, config) {
5572 deferred.reject({
5573 status: status,
5574 headers: headers,
5575 config: config,
5576 body: data
5577 });
5578 });
5579
5580 return deferred.promise;
5581 };
5582 /**
5583 *
5584 * @method
5585 * @name xos#Tag_List_GET
5586 *
5587 */
5588 xos.prototype.Tag_List_GET = function(parameters) {
5589 if (parameters === undefined) {
5590 parameters = {};
5591 }
5592 var deferred = $q.defer();
5593
5594 var domain = this.domain;
5595 var path = '/xos/tags/';
5596
5597 var body;
5598 var queryParameters = {};
5599 var headers = {};
5600 var form = {};
5601
5602 if (parameters.$queryParameters) {
5603 Object.keys(parameters.$queryParameters)
5604 .forEach(function(parameterName) {
5605 var parameter = parameters.$queryParameters[parameterName];
5606 queryParameters[parameterName] = parameter;
5607 });
5608 }
5609
5610 var url = domain + path;
5611 var cached = parameters.$cache && parameters.$cache.get(url);
5612 if (cached !== undefined && parameters.$refresh !== true) {
5613 deferred.resolve(cached);
5614 return deferred.promise;
5615 }
5616 var options = {
5617 timeout: parameters.$timeout,
5618 method: 'GET',
5619 url: url,
5620 params: queryParameters,
5621 data: body,
5622 headers: headers
5623 };
5624 if (Object.keys(form).length > 0) {
5625 options.data = form;
5626 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5627 options.transformRequest = xos.transformRequest;
5628 }
5629 $http(options)
5630 .success(function(data, status, headers, config) {
5631 deferred.resolve(data);
5632 if (parameters.$cache !== undefined) {
5633 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5634 }
5635 })
5636 .error(function(data, status, headers, config) {
5637 deferred.reject({
5638 status: status,
5639 headers: headers,
5640 config: config,
5641 body: data
5642 });
5643 });
5644
5645 return deferred.promise;
5646 };
5647 /**
5648 *
5649 * @method
5650 * @name xos#Tag_List_POST
5651 * @param {string} enacted -
5652 * @param {string} policed -
5653 * @param {string} backend_register -
5654 * @param {string} backend_status -
5655 * @param {boolean} deleted -
5656 * @param {boolean} write_protect -
5657 * @param {boolean} lazy_blocked -
5658 * @param {boolean} no_sync -
5659 * @param {string} service - The Service this Tag is associated with
5660 * @param {string} name - The name of this tag
5661 * @param {string} value - The value of this tag
5662 * @param {string} content_type -
5663 * @param {integer} object_id -
5664 *
5665 */
5666 xos.prototype.Tag_List_POST = function(parameters) {
5667 if (parameters === undefined) {
5668 parameters = {};
5669 }
5670 var deferred = $q.defer();
5671
5672 var domain = this.domain;
5673 var path = '/xos/tags/';
5674
5675 var body;
5676 var queryParameters = {};
5677 var headers = {};
5678 var form = {};
5679
5680 if (parameters['enacted'] !== undefined) {
5681 form['enacted'] = parameters['enacted'];
5682 }
5683
5684 if (parameters['policed'] !== undefined) {
5685 form['policed'] = parameters['policed'];
5686 }
5687
5688 if (parameters['backend_register'] !== undefined) {
5689 form['backend_register'] = parameters['backend_register'];
5690 }
5691
5692 if (parameters['backend_status'] !== undefined) {
5693 form['backend_status'] = parameters['backend_status'];
5694 }
5695
5696 if (parameters['backend_status'] === undefined) {
5697 deferred.reject(new Error('Missing required form parameter: backend_status'));
5698 return deferred.promise;
5699 }
5700
5701 if (parameters['deleted'] !== undefined) {
5702 form['deleted'] = parameters['deleted'];
5703 }
5704
5705 if (parameters['write_protect'] !== undefined) {
5706 form['write_protect'] = parameters['write_protect'];
5707 }
5708
5709 if (parameters['lazy_blocked'] !== undefined) {
5710 form['lazy_blocked'] = parameters['lazy_blocked'];
5711 }
5712
5713 if (parameters['no_sync'] !== undefined) {
5714 form['no_sync'] = parameters['no_sync'];
5715 }
5716
5717 if (parameters['service'] !== undefined) {
5718 form['service'] = parameters['service'];
5719 }
5720
5721 if (parameters['service'] === undefined) {
5722 deferred.reject(new Error('Missing required form parameter: service'));
5723 return deferred.promise;
5724 }
5725
5726 if (parameters['name'] !== undefined) {
5727 form['name'] = parameters['name'];
5728 }
5729
5730 if (parameters['name'] === undefined) {
5731 deferred.reject(new Error('Missing required form parameter: name'));
5732 return deferred.promise;
5733 }
5734
5735 if (parameters['value'] !== undefined) {
5736 form['value'] = parameters['value'];
5737 }
5738
5739 if (parameters['value'] === undefined) {
5740 deferred.reject(new Error('Missing required form parameter: value'));
5741 return deferred.promise;
5742 }
5743
5744 if (parameters['content_type'] !== undefined) {
5745 form['content_type'] = parameters['content_type'];
5746 }
5747
5748 if (parameters['content_type'] === undefined) {
5749 deferred.reject(new Error('Missing required form parameter: content_type'));
5750 return deferred.promise;
5751 }
5752
5753 if (parameters['object_id'] !== undefined) {
5754 form['object_id'] = parameters['object_id'];
5755 }
5756
5757 if (parameters['object_id'] === undefined) {
5758 deferred.reject(new Error('Missing required form parameter: object_id'));
5759 return deferred.promise;
5760 }
5761
5762 if (parameters.$queryParameters) {
5763 Object.keys(parameters.$queryParameters)
5764 .forEach(function(parameterName) {
5765 var parameter = parameters.$queryParameters[parameterName];
5766 queryParameters[parameterName] = parameter;
5767 });
5768 }
5769
5770 var url = domain + path;
5771 var options = {
5772 timeout: parameters.$timeout,
5773 method: 'POST',
5774 url: url,
5775 params: queryParameters,
5776 data: body,
5777 headers: headers
5778 };
5779 if (Object.keys(form).length > 0) {
5780 options.data = form;
5781 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5782 options.transformRequest = xos.transformRequest;
5783 }
5784 $http(options)
5785 .success(function(data, status, headers, config) {
5786 deferred.resolve(data);
5787 if (parameters.$cache !== undefined) {
5788 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5789 }
5790 })
5791 .error(function(data, status, headers, config) {
5792 deferred.reject({
5793 status: status,
5794 headers: headers,
5795 config: config,
5796 body: data
5797 });
5798 });
5799
5800 return deferred.promise;
5801 };
5802 /**
5803 *
5804 * @method
5805 * @name xos#Tag_Detail_GET
5806 * @param {string} pk -
5807 *
5808 */
5809 xos.prototype.Tag_Detail_GET = function(parameters) {
5810 if (parameters === undefined) {
5811 parameters = {};
5812 }
5813 var deferred = $q.defer();
5814
5815 var domain = this.domain;
5816 var path = '/xos/tags/{pk}/';
5817
5818 var body;
5819 var queryParameters = {};
5820 var headers = {};
5821 var form = {};
5822
5823 path = path.replace('{pk}', parameters['pk']);
5824
5825 if (parameters['pk'] === undefined) {
5826 deferred.reject(new Error('Missing required path parameter: pk'));
5827 return deferred.promise;
5828 }
5829
5830 if (parameters.$queryParameters) {
5831 Object.keys(parameters.$queryParameters)
5832 .forEach(function(parameterName) {
5833 var parameter = parameters.$queryParameters[parameterName];
5834 queryParameters[parameterName] = parameter;
5835 });
5836 }
5837
5838 var url = domain + path;
5839 var cached = parameters.$cache && parameters.$cache.get(url);
5840 if (cached !== undefined && parameters.$refresh !== true) {
5841 deferred.resolve(cached);
5842 return deferred.promise;
5843 }
5844 var options = {
5845 timeout: parameters.$timeout,
5846 method: 'GET',
5847 url: url,
5848 params: queryParameters,
5849 data: body,
5850 headers: headers
5851 };
5852 if (Object.keys(form).length > 0) {
5853 options.data = form;
5854 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
5855 options.transformRequest = xos.transformRequest;
5856 }
5857 $http(options)
5858 .success(function(data, status, headers, config) {
5859 deferred.resolve(data);
5860 if (parameters.$cache !== undefined) {
5861 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
5862 }
5863 })
5864 .error(function(data, status, headers, config) {
5865 deferred.reject({
5866 status: status,
5867 headers: headers,
5868 config: config,
5869 body: data
5870 });
5871 });
5872
5873 return deferred.promise;
5874 };
5875 /**
5876 *
5877 * @method
5878 * @name xos#Tag_Detail_PUT
5879 * @param {string} pk -
5880 * @param {string} enacted -
5881 * @param {string} policed -
5882 * @param {string} backend_register -
5883 * @param {string} backend_status -
5884 * @param {boolean} deleted -
5885 * @param {boolean} write_protect -
5886 * @param {boolean} lazy_blocked -
5887 * @param {boolean} no_sync -
5888 * @param {string} service - The Service this Tag is associated with
5889 * @param {string} name - The name of this tag
5890 * @param {string} value - The value of this tag
5891 * @param {string} content_type -
5892 * @param {integer} object_id -
5893 *
5894 */
5895 xos.prototype.Tag_Detail_PUT = function(parameters) {
5896 if (parameters === undefined) {
5897 parameters = {};
5898 }
5899 var deferred = $q.defer();
5900
5901 var domain = this.domain;
5902 var path = '/xos/tags/{pk}/';
5903
5904 var body;
5905 var queryParameters = {};
5906 var headers = {};
5907 var form = {};
5908
5909 path = path.replace('{pk}', parameters['pk']);
5910
5911 if (parameters['pk'] === undefined) {
5912 deferred.reject(new Error('Missing required path parameter: pk'));
5913 return deferred.promise;
5914 }
5915
5916 if (parameters['enacted'] !== undefined) {
5917 form['enacted'] = parameters['enacted'];
5918 }
5919
5920 if (parameters['policed'] !== undefined) {
5921 form['policed'] = parameters['policed'];
5922 }
5923
5924 if (parameters['backend_register'] !== undefined) {
5925 form['backend_register'] = parameters['backend_register'];
5926 }
5927
5928 if (parameters['backend_status'] !== undefined) {
5929 form['backend_status'] = parameters['backend_status'];
5930 }
5931
5932 if (parameters['backend_status'] === undefined) {
5933 deferred.reject(new Error('Missing required form parameter: backend_status'));
5934 return deferred.promise;
5935 }
5936
5937 if (parameters['deleted'] !== undefined) {
5938 form['deleted'] = parameters['deleted'];
5939 }
5940
5941 if (parameters['write_protect'] !== undefined) {
5942 form['write_protect'] = parameters['write_protect'];
5943 }
5944
5945 if (parameters['lazy_blocked'] !== undefined) {
5946 form['lazy_blocked'] = parameters['lazy_blocked'];
5947 }
5948
5949 if (parameters['no_sync'] !== undefined) {
5950 form['no_sync'] = parameters['no_sync'];
5951 }
5952
5953 if (parameters['service'] !== undefined) {
5954 form['service'] = parameters['service'];
5955 }
5956
5957 if (parameters['service'] === undefined) {
5958 deferred.reject(new Error('Missing required form parameter: service'));
5959 return deferred.promise;
5960 }
5961
5962 if (parameters['name'] !== undefined) {
5963 form['name'] = parameters['name'];
5964 }
5965
5966 if (parameters['name'] === undefined) {
5967 deferred.reject(new Error('Missing required form parameter: name'));
5968 return deferred.promise;
5969 }
5970
5971 if (parameters['value'] !== undefined) {
5972 form['value'] = parameters['value'];
5973 }
5974
5975 if (parameters['value'] === undefined) {
5976 deferred.reject(new Error('Missing required form parameter: value'));
5977 return deferred.promise;
5978 }
5979
5980 if (parameters['content_type'] !== undefined) {
5981 form['content_type'] = parameters['content_type'];
5982 }
5983
5984 if (parameters['content_type'] === undefined) {
5985 deferred.reject(new Error('Missing required form parameter: content_type'));
5986 return deferred.promise;
5987 }
5988
5989 if (parameters['object_id'] !== undefined) {
5990 form['object_id'] = parameters['object_id'];
5991 }
5992
5993 if (parameters['object_id'] === undefined) {
5994 deferred.reject(new Error('Missing required form parameter: object_id'));
5995 return deferred.promise;
5996 }
5997
5998 if (parameters.$queryParameters) {
5999 Object.keys(parameters.$queryParameters)
6000 .forEach(function(parameterName) {
6001 var parameter = parameters.$queryParameters[parameterName];
6002 queryParameters[parameterName] = parameter;
6003 });
6004 }
6005
6006 var url = domain + path;
6007 var options = {
6008 timeout: parameters.$timeout,
6009 method: 'PUT',
6010 url: url,
6011 params: queryParameters,
6012 data: body,
6013 headers: headers
6014 };
6015 if (Object.keys(form).length > 0) {
6016 options.data = form;
6017 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6018 options.transformRequest = xos.transformRequest;
6019 }
6020 $http(options)
6021 .success(function(data, status, headers, config) {
6022 deferred.resolve(data);
6023 if (parameters.$cache !== undefined) {
6024 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6025 }
6026 })
6027 .error(function(data, status, headers, config) {
6028 deferred.reject({
6029 status: status,
6030 headers: headers,
6031 config: config,
6032 body: data
6033 });
6034 });
6035
6036 return deferred.promise;
6037 };
6038 /**
6039 *
6040 * @method
6041 * @name xos#Tag_Detail_PATCH
6042 * @param {string} pk -
6043 * @param {string} enacted -
6044 * @param {string} policed -
6045 * @param {string} backend_register -
6046 * @param {string} backend_status -
6047 * @param {boolean} deleted -
6048 * @param {boolean} write_protect -
6049 * @param {boolean} lazy_blocked -
6050 * @param {boolean} no_sync -
6051 * @param {string} service - The Service this Tag is associated with
6052 * @param {string} name - The name of this tag
6053 * @param {string} value - The value of this tag
6054 * @param {string} content_type -
6055 * @param {integer} object_id -
6056 *
6057 */
6058 xos.prototype.Tag_Detail_PATCH = function(parameters) {
6059 if (parameters === undefined) {
6060 parameters = {};
6061 }
6062 var deferred = $q.defer();
6063
6064 var domain = this.domain;
6065 var path = '/xos/tags/{pk}/';
6066
6067 var body;
6068 var queryParameters = {};
6069 var headers = {};
6070 var form = {};
6071
6072 path = path.replace('{pk}', parameters['pk']);
6073
6074 if (parameters['pk'] === undefined) {
6075 deferred.reject(new Error('Missing required path parameter: pk'));
6076 return deferred.promise;
6077 }
6078
6079 if (parameters['enacted'] !== undefined) {
6080 form['enacted'] = parameters['enacted'];
6081 }
6082
6083 if (parameters['policed'] !== undefined) {
6084 form['policed'] = parameters['policed'];
6085 }
6086
6087 if (parameters['backend_register'] !== undefined) {
6088 form['backend_register'] = parameters['backend_register'];
6089 }
6090
6091 if (parameters['backend_status'] !== undefined) {
6092 form['backend_status'] = parameters['backend_status'];
6093 }
6094
6095 if (parameters['deleted'] !== undefined) {
6096 form['deleted'] = parameters['deleted'];
6097 }
6098
6099 if (parameters['write_protect'] !== undefined) {
6100 form['write_protect'] = parameters['write_protect'];
6101 }
6102
6103 if (parameters['lazy_blocked'] !== undefined) {
6104 form['lazy_blocked'] = parameters['lazy_blocked'];
6105 }
6106
6107 if (parameters['no_sync'] !== undefined) {
6108 form['no_sync'] = parameters['no_sync'];
6109 }
6110
6111 if (parameters['service'] !== undefined) {
6112 form['service'] = parameters['service'];
6113 }
6114
6115 if (parameters['name'] !== undefined) {
6116 form['name'] = parameters['name'];
6117 }
6118
6119 if (parameters['value'] !== undefined) {
6120 form['value'] = parameters['value'];
6121 }
6122
6123 if (parameters['content_type'] !== undefined) {
6124 form['content_type'] = parameters['content_type'];
6125 }
6126
6127 if (parameters['object_id'] !== undefined) {
6128 form['object_id'] = parameters['object_id'];
6129 }
6130
6131 if (parameters.$queryParameters) {
6132 Object.keys(parameters.$queryParameters)
6133 .forEach(function(parameterName) {
6134 var parameter = parameters.$queryParameters[parameterName];
6135 queryParameters[parameterName] = parameter;
6136 });
6137 }
6138
6139 var url = domain + path;
6140 var options = {
6141 timeout: parameters.$timeout,
6142 method: 'PATCH',
6143 url: url,
6144 params: queryParameters,
6145 data: body,
6146 headers: headers
6147 };
6148 if (Object.keys(form).length > 0) {
6149 options.data = form;
6150 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6151 options.transformRequest = xos.transformRequest;
6152 }
6153 $http(options)
6154 .success(function(data, status, headers, config) {
6155 deferred.resolve(data);
6156 if (parameters.$cache !== undefined) {
6157 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6158 }
6159 })
6160 .error(function(data, status, headers, config) {
6161 deferred.reject({
6162 status: status,
6163 headers: headers,
6164 config: config,
6165 body: data
6166 });
6167 });
6168
6169 return deferred.promise;
6170 };
6171 /**
6172 *
6173 * @method
6174 * @name xos#Tag_Detail_DELETE
6175 * @param {string} pk -
6176 *
6177 */
6178 xos.prototype.Tag_Detail_DELETE = function(parameters) {
6179 if (parameters === undefined) {
6180 parameters = {};
6181 }
6182 var deferred = $q.defer();
6183
6184 var domain = this.domain;
6185 var path = '/xos/tags/{pk}/';
6186
6187 var body;
6188 var queryParameters = {};
6189 var headers = {};
6190 var form = {};
6191
6192 path = path.replace('{pk}', parameters['pk']);
6193
6194 if (parameters['pk'] === undefined) {
6195 deferred.reject(new Error('Missing required path parameter: pk'));
6196 return deferred.promise;
6197 }
6198
6199 if (parameters.$queryParameters) {
6200 Object.keys(parameters.$queryParameters)
6201 .forEach(function(parameterName) {
6202 var parameter = parameters.$queryParameters[parameterName];
6203 queryParameters[parameterName] = parameter;
6204 });
6205 }
6206
6207 var url = domain + path;
6208 var options = {
6209 timeout: parameters.$timeout,
6210 method: 'DELETE',
6211 url: url,
6212 params: queryParameters,
6213 data: body,
6214 headers: headers
6215 };
6216 if (Object.keys(form).length > 0) {
6217 options.data = form;
6218 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6219 options.transformRequest = xos.transformRequest;
6220 }
6221 $http(options)
6222 .success(function(data, status, headers, config) {
6223 deferred.resolve(data);
6224 if (parameters.$cache !== undefined) {
6225 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6226 }
6227 })
6228 .error(function(data, status, headers, config) {
6229 deferred.reject({
6230 status: status,
6231 headers: headers,
6232 config: config,
6233 body: data
6234 });
6235 });
6236
6237 return deferred.promise;
6238 };
6239 /**
6240 *
6241 * @method
6242 * @name xos#Invoice_List_GET
6243 *
6244 */
6245 xos.prototype.Invoice_List_GET = function(parameters) {
6246 if (parameters === undefined) {
6247 parameters = {};
6248 }
6249 var deferred = $q.defer();
6250
6251 var domain = this.domain;
6252 var path = '/xos/invoices/';
6253
6254 var body;
6255 var queryParameters = {};
6256 var headers = {};
6257 var form = {};
6258
6259 if (parameters.$queryParameters) {
6260 Object.keys(parameters.$queryParameters)
6261 .forEach(function(parameterName) {
6262 var parameter = parameters.$queryParameters[parameterName];
6263 queryParameters[parameterName] = parameter;
6264 });
6265 }
6266
6267 var url = domain + path;
6268 var cached = parameters.$cache && parameters.$cache.get(url);
6269 if (cached !== undefined && parameters.$refresh !== true) {
6270 deferred.resolve(cached);
6271 return deferred.promise;
6272 }
6273 var options = {
6274 timeout: parameters.$timeout,
6275 method: 'GET',
6276 url: url,
6277 params: queryParameters,
6278 data: body,
6279 headers: headers
6280 };
6281 if (Object.keys(form).length > 0) {
6282 options.data = form;
6283 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6284 options.transformRequest = xos.transformRequest;
6285 }
6286 $http(options)
6287 .success(function(data, status, headers, config) {
6288 deferred.resolve(data);
6289 if (parameters.$cache !== undefined) {
6290 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6291 }
6292 })
6293 .error(function(data, status, headers, config) {
6294 deferred.reject({
6295 status: status,
6296 headers: headers,
6297 config: config,
6298 body: data
6299 });
6300 });
6301
6302 return deferred.promise;
6303 };
6304 /**
6305 *
6306 * @method
6307 * @name xos#Invoice_List_POST
6308 * @param {string} enacted -
6309 * @param {string} policed -
6310 * @param {string} backend_register -
6311 * @param {string} backend_status -
6312 * @param {boolean} deleted -
6313 * @param {boolean} write_protect -
6314 * @param {boolean} lazy_blocked -
6315 * @param {boolean} no_sync -
6316 * @param {string} date -
6317 * @param {string} account -
6318 *
6319 */
6320 xos.prototype.Invoice_List_POST = function(parameters) {
6321 if (parameters === undefined) {
6322 parameters = {};
6323 }
6324 var deferred = $q.defer();
6325
6326 var domain = this.domain;
6327 var path = '/xos/invoices/';
6328
6329 var body;
6330 var queryParameters = {};
6331 var headers = {};
6332 var form = {};
6333
6334 if (parameters['enacted'] !== undefined) {
6335 form['enacted'] = parameters['enacted'];
6336 }
6337
6338 if (parameters['policed'] !== undefined) {
6339 form['policed'] = parameters['policed'];
6340 }
6341
6342 if (parameters['backend_register'] !== undefined) {
6343 form['backend_register'] = parameters['backend_register'];
6344 }
6345
6346 if (parameters['backend_status'] !== undefined) {
6347 form['backend_status'] = parameters['backend_status'];
6348 }
6349
6350 if (parameters['backend_status'] === undefined) {
6351 deferred.reject(new Error('Missing required form parameter: backend_status'));
6352 return deferred.promise;
6353 }
6354
6355 if (parameters['deleted'] !== undefined) {
6356 form['deleted'] = parameters['deleted'];
6357 }
6358
6359 if (parameters['write_protect'] !== undefined) {
6360 form['write_protect'] = parameters['write_protect'];
6361 }
6362
6363 if (parameters['lazy_blocked'] !== undefined) {
6364 form['lazy_blocked'] = parameters['lazy_blocked'];
6365 }
6366
6367 if (parameters['no_sync'] !== undefined) {
6368 form['no_sync'] = parameters['no_sync'];
6369 }
6370
6371 if (parameters['date'] !== undefined) {
6372 form['date'] = parameters['date'];
6373 }
6374
6375 if (parameters['date'] === undefined) {
6376 deferred.reject(new Error('Missing required form parameter: date'));
6377 return deferred.promise;
6378 }
6379
6380 if (parameters['account'] !== undefined) {
6381 form['account'] = parameters['account'];
6382 }
6383
6384 if (parameters['account'] === undefined) {
6385 deferred.reject(new Error('Missing required form parameter: account'));
6386 return deferred.promise;
6387 }
6388
6389 if (parameters.$queryParameters) {
6390 Object.keys(parameters.$queryParameters)
6391 .forEach(function(parameterName) {
6392 var parameter = parameters.$queryParameters[parameterName];
6393 queryParameters[parameterName] = parameter;
6394 });
6395 }
6396
6397 var url = domain + path;
6398 var options = {
6399 timeout: parameters.$timeout,
6400 method: 'POST',
6401 url: url,
6402 params: queryParameters,
6403 data: body,
6404 headers: headers
6405 };
6406 if (Object.keys(form).length > 0) {
6407 options.data = form;
6408 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6409 options.transformRequest = xos.transformRequest;
6410 }
6411 $http(options)
6412 .success(function(data, status, headers, config) {
6413 deferred.resolve(data);
6414 if (parameters.$cache !== undefined) {
6415 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6416 }
6417 })
6418 .error(function(data, status, headers, config) {
6419 deferred.reject({
6420 status: status,
6421 headers: headers,
6422 config: config,
6423 body: data
6424 });
6425 });
6426
6427 return deferred.promise;
6428 };
6429 /**
6430 *
6431 * @method
6432 * @name xos#Invoice_Detail_GET
6433 * @param {string} pk -
6434 *
6435 */
6436 xos.prototype.Invoice_Detail_GET = function(parameters) {
6437 if (parameters === undefined) {
6438 parameters = {};
6439 }
6440 var deferred = $q.defer();
6441
6442 var domain = this.domain;
6443 var path = '/xos/invoices/{pk}/';
6444
6445 var body;
6446 var queryParameters = {};
6447 var headers = {};
6448 var form = {};
6449
6450 path = path.replace('{pk}', parameters['pk']);
6451
6452 if (parameters['pk'] === undefined) {
6453 deferred.reject(new Error('Missing required path parameter: pk'));
6454 return deferred.promise;
6455 }
6456
6457 if (parameters.$queryParameters) {
6458 Object.keys(parameters.$queryParameters)
6459 .forEach(function(parameterName) {
6460 var parameter = parameters.$queryParameters[parameterName];
6461 queryParameters[parameterName] = parameter;
6462 });
6463 }
6464
6465 var url = domain + path;
6466 var cached = parameters.$cache && parameters.$cache.get(url);
6467 if (cached !== undefined && parameters.$refresh !== true) {
6468 deferred.resolve(cached);
6469 return deferred.promise;
6470 }
6471 var options = {
6472 timeout: parameters.$timeout,
6473 method: 'GET',
6474 url: url,
6475 params: queryParameters,
6476 data: body,
6477 headers: headers
6478 };
6479 if (Object.keys(form).length > 0) {
6480 options.data = form;
6481 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6482 options.transformRequest = xos.transformRequest;
6483 }
6484 $http(options)
6485 .success(function(data, status, headers, config) {
6486 deferred.resolve(data);
6487 if (parameters.$cache !== undefined) {
6488 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6489 }
6490 })
6491 .error(function(data, status, headers, config) {
6492 deferred.reject({
6493 status: status,
6494 headers: headers,
6495 config: config,
6496 body: data
6497 });
6498 });
6499
6500 return deferred.promise;
6501 };
6502 /**
6503 *
6504 * @method
6505 * @name xos#Invoice_Detail_PUT
6506 * @param {string} pk -
6507 * @param {string} enacted -
6508 * @param {string} policed -
6509 * @param {string} backend_register -
6510 * @param {string} backend_status -
6511 * @param {boolean} deleted -
6512 * @param {boolean} write_protect -
6513 * @param {boolean} lazy_blocked -
6514 * @param {boolean} no_sync -
6515 * @param {string} date -
6516 * @param {string} account -
6517 *
6518 */
6519 xos.prototype.Invoice_Detail_PUT = function(parameters) {
6520 if (parameters === undefined) {
6521 parameters = {};
6522 }
6523 var deferred = $q.defer();
6524
6525 var domain = this.domain;
6526 var path = '/xos/invoices/{pk}/';
6527
6528 var body;
6529 var queryParameters = {};
6530 var headers = {};
6531 var form = {};
6532
6533 path = path.replace('{pk}', parameters['pk']);
6534
6535 if (parameters['pk'] === undefined) {
6536 deferred.reject(new Error('Missing required path parameter: pk'));
6537 return deferred.promise;
6538 }
6539
6540 if (parameters['enacted'] !== undefined) {
6541 form['enacted'] = parameters['enacted'];
6542 }
6543
6544 if (parameters['policed'] !== undefined) {
6545 form['policed'] = parameters['policed'];
6546 }
6547
6548 if (parameters['backend_register'] !== undefined) {
6549 form['backend_register'] = parameters['backend_register'];
6550 }
6551
6552 if (parameters['backend_status'] !== undefined) {
6553 form['backend_status'] = parameters['backend_status'];
6554 }
6555
6556 if (parameters['backend_status'] === undefined) {
6557 deferred.reject(new Error('Missing required form parameter: backend_status'));
6558 return deferred.promise;
6559 }
6560
6561 if (parameters['deleted'] !== undefined) {
6562 form['deleted'] = parameters['deleted'];
6563 }
6564
6565 if (parameters['write_protect'] !== undefined) {
6566 form['write_protect'] = parameters['write_protect'];
6567 }
6568
6569 if (parameters['lazy_blocked'] !== undefined) {
6570 form['lazy_blocked'] = parameters['lazy_blocked'];
6571 }
6572
6573 if (parameters['no_sync'] !== undefined) {
6574 form['no_sync'] = parameters['no_sync'];
6575 }
6576
6577 if (parameters['date'] !== undefined) {
6578 form['date'] = parameters['date'];
6579 }
6580
6581 if (parameters['date'] === undefined) {
6582 deferred.reject(new Error('Missing required form parameter: date'));
6583 return deferred.promise;
6584 }
6585
6586 if (parameters['account'] !== undefined) {
6587 form['account'] = parameters['account'];
6588 }
6589
6590 if (parameters['account'] === undefined) {
6591 deferred.reject(new Error('Missing required form parameter: account'));
6592 return deferred.promise;
6593 }
6594
6595 if (parameters.$queryParameters) {
6596 Object.keys(parameters.$queryParameters)
6597 .forEach(function(parameterName) {
6598 var parameter = parameters.$queryParameters[parameterName];
6599 queryParameters[parameterName] = parameter;
6600 });
6601 }
6602
6603 var url = domain + path;
6604 var options = {
6605 timeout: parameters.$timeout,
6606 method: 'PUT',
6607 url: url,
6608 params: queryParameters,
6609 data: body,
6610 headers: headers
6611 };
6612 if (Object.keys(form).length > 0) {
6613 options.data = form;
6614 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6615 options.transformRequest = xos.transformRequest;
6616 }
6617 $http(options)
6618 .success(function(data, status, headers, config) {
6619 deferred.resolve(data);
6620 if (parameters.$cache !== undefined) {
6621 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6622 }
6623 })
6624 .error(function(data, status, headers, config) {
6625 deferred.reject({
6626 status: status,
6627 headers: headers,
6628 config: config,
6629 body: data
6630 });
6631 });
6632
6633 return deferred.promise;
6634 };
6635 /**
6636 *
6637 * @method
6638 * @name xos#Invoice_Detail_PATCH
6639 * @param {string} pk -
6640 * @param {string} enacted -
6641 * @param {string} policed -
6642 * @param {string} backend_register -
6643 * @param {string} backend_status -
6644 * @param {boolean} deleted -
6645 * @param {boolean} write_protect -
6646 * @param {boolean} lazy_blocked -
6647 * @param {boolean} no_sync -
6648 * @param {string} date -
6649 * @param {string} account -
6650 *
6651 */
6652 xos.prototype.Invoice_Detail_PATCH = function(parameters) {
6653 if (parameters === undefined) {
6654 parameters = {};
6655 }
6656 var deferred = $q.defer();
6657
6658 var domain = this.domain;
6659 var path = '/xos/invoices/{pk}/';
6660
6661 var body;
6662 var queryParameters = {};
6663 var headers = {};
6664 var form = {};
6665
6666 path = path.replace('{pk}', parameters['pk']);
6667
6668 if (parameters['pk'] === undefined) {
6669 deferred.reject(new Error('Missing required path parameter: pk'));
6670 return deferred.promise;
6671 }
6672
6673 if (parameters['enacted'] !== undefined) {
6674 form['enacted'] = parameters['enacted'];
6675 }
6676
6677 if (parameters['policed'] !== undefined) {
6678 form['policed'] = parameters['policed'];
6679 }
6680
6681 if (parameters['backend_register'] !== undefined) {
6682 form['backend_register'] = parameters['backend_register'];
6683 }
6684
6685 if (parameters['backend_status'] !== undefined) {
6686 form['backend_status'] = parameters['backend_status'];
6687 }
6688
6689 if (parameters['deleted'] !== undefined) {
6690 form['deleted'] = parameters['deleted'];
6691 }
6692
6693 if (parameters['write_protect'] !== undefined) {
6694 form['write_protect'] = parameters['write_protect'];
6695 }
6696
6697 if (parameters['lazy_blocked'] !== undefined) {
6698 form['lazy_blocked'] = parameters['lazy_blocked'];
6699 }
6700
6701 if (parameters['no_sync'] !== undefined) {
6702 form['no_sync'] = parameters['no_sync'];
6703 }
6704
6705 if (parameters['date'] !== undefined) {
6706 form['date'] = parameters['date'];
6707 }
6708
6709 if (parameters['account'] !== undefined) {
6710 form['account'] = parameters['account'];
6711 }
6712
6713 if (parameters.$queryParameters) {
6714 Object.keys(parameters.$queryParameters)
6715 .forEach(function(parameterName) {
6716 var parameter = parameters.$queryParameters[parameterName];
6717 queryParameters[parameterName] = parameter;
6718 });
6719 }
6720
6721 var url = domain + path;
6722 var options = {
6723 timeout: parameters.$timeout,
6724 method: 'PATCH',
6725 url: url,
6726 params: queryParameters,
6727 data: body,
6728 headers: headers
6729 };
6730 if (Object.keys(form).length > 0) {
6731 options.data = form;
6732 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6733 options.transformRequest = xos.transformRequest;
6734 }
6735 $http(options)
6736 .success(function(data, status, headers, config) {
6737 deferred.resolve(data);
6738 if (parameters.$cache !== undefined) {
6739 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6740 }
6741 })
6742 .error(function(data, status, headers, config) {
6743 deferred.reject({
6744 status: status,
6745 headers: headers,
6746 config: config,
6747 body: data
6748 });
6749 });
6750
6751 return deferred.promise;
6752 };
6753 /**
6754 *
6755 * @method
6756 * @name xos#Invoice_Detail_DELETE
6757 * @param {string} pk -
6758 *
6759 */
6760 xos.prototype.Invoice_Detail_DELETE = function(parameters) {
6761 if (parameters === undefined) {
6762 parameters = {};
6763 }
6764 var deferred = $q.defer();
6765
6766 var domain = this.domain;
6767 var path = '/xos/invoices/{pk}/';
6768
6769 var body;
6770 var queryParameters = {};
6771 var headers = {};
6772 var form = {};
6773
6774 path = path.replace('{pk}', parameters['pk']);
6775
6776 if (parameters['pk'] === undefined) {
6777 deferred.reject(new Error('Missing required path parameter: pk'));
6778 return deferred.promise;
6779 }
6780
6781 if (parameters.$queryParameters) {
6782 Object.keys(parameters.$queryParameters)
6783 .forEach(function(parameterName) {
6784 var parameter = parameters.$queryParameters[parameterName];
6785 queryParameters[parameterName] = parameter;
6786 });
6787 }
6788
6789 var url = domain + path;
6790 var options = {
6791 timeout: parameters.$timeout,
6792 method: 'DELETE',
6793 url: url,
6794 params: queryParameters,
6795 data: body,
6796 headers: headers
6797 };
6798 if (Object.keys(form).length > 0) {
6799 options.data = form;
6800 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6801 options.transformRequest = xos.transformRequest;
6802 }
6803 $http(options)
6804 .success(function(data, status, headers, config) {
6805 deferred.resolve(data);
6806 if (parameters.$cache !== undefined) {
6807 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6808 }
6809 })
6810 .error(function(data, status, headers, config) {
6811 deferred.reject({
6812 status: status,
6813 headers: headers,
6814 config: config,
6815 body: data
6816 });
6817 });
6818
6819 return deferred.promise;
6820 };
6821 /**
6822 *
6823 * @method
6824 * @name xos#Slice_Privilege_List_GET
6825 *
6826 */
6827 xos.prototype.Slice_Privilege_List_GET = function(parameters) {
6828 if (parameters === undefined) {
6829 parameters = {};
6830 }
6831 var deferred = $q.defer();
6832
6833 var domain = this.domain;
6834 var path = '/xos/slice_privileges/';
6835
6836 var body;
6837 var queryParameters = {};
6838 var headers = {};
6839 var form = {};
6840
6841 if (parameters.$queryParameters) {
6842 Object.keys(parameters.$queryParameters)
6843 .forEach(function(parameterName) {
6844 var parameter = parameters.$queryParameters[parameterName];
6845 queryParameters[parameterName] = parameter;
6846 });
6847 }
6848
6849 var url = domain + path;
6850 var cached = parameters.$cache && parameters.$cache.get(url);
6851 if (cached !== undefined && parameters.$refresh !== true) {
6852 deferred.resolve(cached);
6853 return deferred.promise;
6854 }
6855 var options = {
6856 timeout: parameters.$timeout,
6857 method: 'GET',
6858 url: url,
6859 params: queryParameters,
6860 data: body,
6861 headers: headers
6862 };
6863 if (Object.keys(form).length > 0) {
6864 options.data = form;
6865 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
6866 options.transformRequest = xos.transformRequest;
6867 }
6868 $http(options)
6869 .success(function(data, status, headers, config) {
6870 deferred.resolve(data);
6871 if (parameters.$cache !== undefined) {
6872 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
6873 }
6874 })
6875 .error(function(data, status, headers, config) {
6876 deferred.reject({
6877 status: status,
6878 headers: headers,
6879 config: config,
6880 body: data
6881 });
6882 });
6883
6884 return deferred.promise;
6885 };
6886 /**
6887 *
6888 * @method
6889 * @name xos#Slice_Privilege_List_POST
6890 * @param {string} enacted -
6891 * @param {string} policed -
6892 * @param {string} backend_register -
6893 * @param {string} backend_status -
6894 * @param {boolean} deleted -
6895 * @param {boolean} write_protect -
6896 * @param {boolean} lazy_blocked -
6897 * @param {boolean} no_sync -
6898 * @param {string} user -
6899 * @param {string} slice -
6900 * @param {string} role -
6901 *
6902 */
6903 xos.prototype.Slice_Privilege_List_POST = function(parameters) {
6904 if (parameters === undefined) {
6905 parameters = {};
6906 }
6907 var deferred = $q.defer();
6908
6909 var domain = this.domain;
6910 var path = '/xos/slice_privileges/';
6911
6912 var body;
6913 var queryParameters = {};
6914 var headers = {};
6915 var form = {};
6916
6917 if (parameters['enacted'] !== undefined) {
6918 form['enacted'] = parameters['enacted'];
6919 }
6920
6921 if (parameters['policed'] !== undefined) {
6922 form['policed'] = parameters['policed'];
6923 }
6924
6925 if (parameters['backend_register'] !== undefined) {
6926 form['backend_register'] = parameters['backend_register'];
6927 }
6928
6929 if (parameters['backend_status'] !== undefined) {
6930 form['backend_status'] = parameters['backend_status'];
6931 }
6932
6933 if (parameters['backend_status'] === undefined) {
6934 deferred.reject(new Error('Missing required form parameter: backend_status'));
6935 return deferred.promise;
6936 }
6937
6938 if (parameters['deleted'] !== undefined) {
6939 form['deleted'] = parameters['deleted'];
6940 }
6941
6942 if (parameters['write_protect'] !== undefined) {
6943 form['write_protect'] = parameters['write_protect'];
6944 }
6945
6946 if (parameters['lazy_blocked'] !== undefined) {
6947 form['lazy_blocked'] = parameters['lazy_blocked'];
6948 }
6949
6950 if (parameters['no_sync'] !== undefined) {
6951 form['no_sync'] = parameters['no_sync'];
6952 }
6953
6954 if (parameters['user'] !== undefined) {
6955 form['user'] = parameters['user'];
6956 }
6957
6958 if (parameters['user'] === undefined) {
6959 deferred.reject(new Error('Missing required form parameter: user'));
6960 return deferred.promise;
6961 }
6962
6963 if (parameters['slice'] !== undefined) {
6964 form['slice'] = parameters['slice'];
6965 }
6966
6967 if (parameters['slice'] === undefined) {
6968 deferred.reject(new Error('Missing required form parameter: slice'));
6969 return deferred.promise;
6970 }
6971
6972 if (parameters['role'] !== undefined) {
6973 form['role'] = parameters['role'];
6974 }
6975
6976 if (parameters['role'] === undefined) {
6977 deferred.reject(new Error('Missing required form parameter: role'));
6978 return deferred.promise;
6979 }
6980
6981 if (parameters.$queryParameters) {
6982 Object.keys(parameters.$queryParameters)
6983 .forEach(function(parameterName) {
6984 var parameter = parameters.$queryParameters[parameterName];
6985 queryParameters[parameterName] = parameter;
6986 });
6987 }
6988
6989 var url = domain + path;
6990 var options = {
6991 timeout: parameters.$timeout,
6992 method: 'POST',
6993 url: url,
6994 params: queryParameters,
6995 data: body,
6996 headers: headers
6997 };
6998 if (Object.keys(form).length > 0) {
6999 options.data = form;
7000 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7001 options.transformRequest = xos.transformRequest;
7002 }
7003 $http(options)
7004 .success(function(data, status, headers, config) {
7005 deferred.resolve(data);
7006 if (parameters.$cache !== undefined) {
7007 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7008 }
7009 })
7010 .error(function(data, status, headers, config) {
7011 deferred.reject({
7012 status: status,
7013 headers: headers,
7014 config: config,
7015 body: data
7016 });
7017 });
7018
7019 return deferred.promise;
7020 };
7021 /**
7022 *
7023 * @method
7024 * @name xos#Slice_Privilege_Detail_GET
7025 * @param {string} pk -
7026 *
7027 */
7028 xos.prototype.Slice_Privilege_Detail_GET = function(parameters) {
7029 if (parameters === undefined) {
7030 parameters = {};
7031 }
7032 var deferred = $q.defer();
7033
7034 var domain = this.domain;
7035 var path = '/xos/slice_privileges/{pk}/';
7036
7037 var body;
7038 var queryParameters = {};
7039 var headers = {};
7040 var form = {};
7041
7042 path = path.replace('{pk}', parameters['pk']);
7043
7044 if (parameters['pk'] === undefined) {
7045 deferred.reject(new Error('Missing required path parameter: pk'));
7046 return deferred.promise;
7047 }
7048
7049 if (parameters.$queryParameters) {
7050 Object.keys(parameters.$queryParameters)
7051 .forEach(function(parameterName) {
7052 var parameter = parameters.$queryParameters[parameterName];
7053 queryParameters[parameterName] = parameter;
7054 });
7055 }
7056
7057 var url = domain + path;
7058 var cached = parameters.$cache && parameters.$cache.get(url);
7059 if (cached !== undefined && parameters.$refresh !== true) {
7060 deferred.resolve(cached);
7061 return deferred.promise;
7062 }
7063 var options = {
7064 timeout: parameters.$timeout,
7065 method: 'GET',
7066 url: url,
7067 params: queryParameters,
7068 data: body,
7069 headers: headers
7070 };
7071 if (Object.keys(form).length > 0) {
7072 options.data = form;
7073 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7074 options.transformRequest = xos.transformRequest;
7075 }
7076 $http(options)
7077 .success(function(data, status, headers, config) {
7078 deferred.resolve(data);
7079 if (parameters.$cache !== undefined) {
7080 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7081 }
7082 })
7083 .error(function(data, status, headers, config) {
7084 deferred.reject({
7085 status: status,
7086 headers: headers,
7087 config: config,
7088 body: data
7089 });
7090 });
7091
7092 return deferred.promise;
7093 };
7094 /**
7095 *
7096 * @method
7097 * @name xos#Slice_Privilege_Detail_PUT
7098 * @param {string} pk -
7099 * @param {string} enacted -
7100 * @param {string} policed -
7101 * @param {string} backend_register -
7102 * @param {string} backend_status -
7103 * @param {boolean} deleted -
7104 * @param {boolean} write_protect -
7105 * @param {boolean} lazy_blocked -
7106 * @param {boolean} no_sync -
7107 * @param {string} user -
7108 * @param {string} slice -
7109 * @param {string} role -
7110 *
7111 */
7112 xos.prototype.Slice_Privilege_Detail_PUT = function(parameters) {
7113 if (parameters === undefined) {
7114 parameters = {};
7115 }
7116 var deferred = $q.defer();
7117
7118 var domain = this.domain;
7119 var path = '/xos/slice_privileges/{pk}/';
7120
7121 var body;
7122 var queryParameters = {};
7123 var headers = {};
7124 var form = {};
7125
7126 path = path.replace('{pk}', parameters['pk']);
7127
7128 if (parameters['pk'] === undefined) {
7129 deferred.reject(new Error('Missing required path parameter: pk'));
7130 return deferred.promise;
7131 }
7132
7133 if (parameters['enacted'] !== undefined) {
7134 form['enacted'] = parameters['enacted'];
7135 }
7136
7137 if (parameters['policed'] !== undefined) {
7138 form['policed'] = parameters['policed'];
7139 }
7140
7141 if (parameters['backend_register'] !== undefined) {
7142 form['backend_register'] = parameters['backend_register'];
7143 }
7144
7145 if (parameters['backend_status'] !== undefined) {
7146 form['backend_status'] = parameters['backend_status'];
7147 }
7148
7149 if (parameters['backend_status'] === undefined) {
7150 deferred.reject(new Error('Missing required form parameter: backend_status'));
7151 return deferred.promise;
7152 }
7153
7154 if (parameters['deleted'] !== undefined) {
7155 form['deleted'] = parameters['deleted'];
7156 }
7157
7158 if (parameters['write_protect'] !== undefined) {
7159 form['write_protect'] = parameters['write_protect'];
7160 }
7161
7162 if (parameters['lazy_blocked'] !== undefined) {
7163 form['lazy_blocked'] = parameters['lazy_blocked'];
7164 }
7165
7166 if (parameters['no_sync'] !== undefined) {
7167 form['no_sync'] = parameters['no_sync'];
7168 }
7169
7170 if (parameters['user'] !== undefined) {
7171 form['user'] = parameters['user'];
7172 }
7173
7174 if (parameters['user'] === undefined) {
7175 deferred.reject(new Error('Missing required form parameter: user'));
7176 return deferred.promise;
7177 }
7178
7179 if (parameters['slice'] !== undefined) {
7180 form['slice'] = parameters['slice'];
7181 }
7182
7183 if (parameters['slice'] === undefined) {
7184 deferred.reject(new Error('Missing required form parameter: slice'));
7185 return deferred.promise;
7186 }
7187
7188 if (parameters['role'] !== undefined) {
7189 form['role'] = parameters['role'];
7190 }
7191
7192 if (parameters['role'] === undefined) {
7193 deferred.reject(new Error('Missing required form parameter: role'));
7194 return deferred.promise;
7195 }
7196
7197 if (parameters.$queryParameters) {
7198 Object.keys(parameters.$queryParameters)
7199 .forEach(function(parameterName) {
7200 var parameter = parameters.$queryParameters[parameterName];
7201 queryParameters[parameterName] = parameter;
7202 });
7203 }
7204
7205 var url = domain + path;
7206 var options = {
7207 timeout: parameters.$timeout,
7208 method: 'PUT',
7209 url: url,
7210 params: queryParameters,
7211 data: body,
7212 headers: headers
7213 };
7214 if (Object.keys(form).length > 0) {
7215 options.data = form;
7216 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7217 options.transformRequest = xos.transformRequest;
7218 }
7219 $http(options)
7220 .success(function(data, status, headers, config) {
7221 deferred.resolve(data);
7222 if (parameters.$cache !== undefined) {
7223 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7224 }
7225 })
7226 .error(function(data, status, headers, config) {
7227 deferred.reject({
7228 status: status,
7229 headers: headers,
7230 config: config,
7231 body: data
7232 });
7233 });
7234
7235 return deferred.promise;
7236 };
7237 /**
7238 *
7239 * @method
7240 * @name xos#Slice_Privilege_Detail_PATCH
7241 * @param {string} pk -
7242 * @param {string} enacted -
7243 * @param {string} policed -
7244 * @param {string} backend_register -
7245 * @param {string} backend_status -
7246 * @param {boolean} deleted -
7247 * @param {boolean} write_protect -
7248 * @param {boolean} lazy_blocked -
7249 * @param {boolean} no_sync -
7250 * @param {string} user -
7251 * @param {string} slice -
7252 * @param {string} role -
7253 *
7254 */
7255 xos.prototype.Slice_Privilege_Detail_PATCH = function(parameters) {
7256 if (parameters === undefined) {
7257 parameters = {};
7258 }
7259 var deferred = $q.defer();
7260
7261 var domain = this.domain;
7262 var path = '/xos/slice_privileges/{pk}/';
7263
7264 var body;
7265 var queryParameters = {};
7266 var headers = {};
7267 var form = {};
7268
7269 path = path.replace('{pk}', parameters['pk']);
7270
7271 if (parameters['pk'] === undefined) {
7272 deferred.reject(new Error('Missing required path parameter: pk'));
7273 return deferred.promise;
7274 }
7275
7276 if (parameters['enacted'] !== undefined) {
7277 form['enacted'] = parameters['enacted'];
7278 }
7279
7280 if (parameters['policed'] !== undefined) {
7281 form['policed'] = parameters['policed'];
7282 }
7283
7284 if (parameters['backend_register'] !== undefined) {
7285 form['backend_register'] = parameters['backend_register'];
7286 }
7287
7288 if (parameters['backend_status'] !== undefined) {
7289 form['backend_status'] = parameters['backend_status'];
7290 }
7291
7292 if (parameters['deleted'] !== undefined) {
7293 form['deleted'] = parameters['deleted'];
7294 }
7295
7296 if (parameters['write_protect'] !== undefined) {
7297 form['write_protect'] = parameters['write_protect'];
7298 }
7299
7300 if (parameters['lazy_blocked'] !== undefined) {
7301 form['lazy_blocked'] = parameters['lazy_blocked'];
7302 }
7303
7304 if (parameters['no_sync'] !== undefined) {
7305 form['no_sync'] = parameters['no_sync'];
7306 }
7307
7308 if (parameters['user'] !== undefined) {
7309 form['user'] = parameters['user'];
7310 }
7311
7312 if (parameters['slice'] !== undefined) {
7313 form['slice'] = parameters['slice'];
7314 }
7315
7316 if (parameters['role'] !== undefined) {
7317 form['role'] = parameters['role'];
7318 }
7319
7320 if (parameters.$queryParameters) {
7321 Object.keys(parameters.$queryParameters)
7322 .forEach(function(parameterName) {
7323 var parameter = parameters.$queryParameters[parameterName];
7324 queryParameters[parameterName] = parameter;
7325 });
7326 }
7327
7328 var url = domain + path;
7329 var options = {
7330 timeout: parameters.$timeout,
7331 method: 'PATCH',
7332 url: url,
7333 params: queryParameters,
7334 data: body,
7335 headers: headers
7336 };
7337 if (Object.keys(form).length > 0) {
7338 options.data = form;
7339 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7340 options.transformRequest = xos.transformRequest;
7341 }
7342 $http(options)
7343 .success(function(data, status, headers, config) {
7344 deferred.resolve(data);
7345 if (parameters.$cache !== undefined) {
7346 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7347 }
7348 })
7349 .error(function(data, status, headers, config) {
7350 deferred.reject({
7351 status: status,
7352 headers: headers,
7353 config: config,
7354 body: data
7355 });
7356 });
7357
7358 return deferred.promise;
7359 };
7360 /**
7361 *
7362 * @method
7363 * @name xos#Slice_Privilege_Detail_DELETE
7364 * @param {string} pk -
7365 *
7366 */
7367 xos.prototype.Slice_Privilege_Detail_DELETE = function(parameters) {
7368 if (parameters === undefined) {
7369 parameters = {};
7370 }
7371 var deferred = $q.defer();
7372
7373 var domain = this.domain;
7374 var path = '/xos/slice_privileges/{pk}/';
7375
7376 var body;
7377 var queryParameters = {};
7378 var headers = {};
7379 var form = {};
7380
7381 path = path.replace('{pk}', parameters['pk']);
7382
7383 if (parameters['pk'] === undefined) {
7384 deferred.reject(new Error('Missing required path parameter: pk'));
7385 return deferred.promise;
7386 }
7387
7388 if (parameters.$queryParameters) {
7389 Object.keys(parameters.$queryParameters)
7390 .forEach(function(parameterName) {
7391 var parameter = parameters.$queryParameters[parameterName];
7392 queryParameters[parameterName] = parameter;
7393 });
7394 }
7395
7396 var url = domain + path;
7397 var options = {
7398 timeout: parameters.$timeout,
7399 method: 'DELETE',
7400 url: url,
7401 params: queryParameters,
7402 data: body,
7403 headers: headers
7404 };
7405 if (Object.keys(form).length > 0) {
7406 options.data = form;
7407 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7408 options.transformRequest = xos.transformRequest;
7409 }
7410 $http(options)
7411 .success(function(data, status, headers, config) {
7412 deferred.resolve(data);
7413 if (parameters.$cache !== undefined) {
7414 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7415 }
7416 })
7417 .error(function(data, status, headers, config) {
7418 deferred.reject({
7419 status: status,
7420 headers: headers,
7421 config: config,
7422 body: data
7423 });
7424 });
7425
7426 return deferred.promise;
7427 };
7428 /**
7429 *
7430 * @method
7431 * @name xos#Flavor_List_GET
7432 *
7433 */
7434 xos.prototype.Flavor_List_GET = function(parameters) {
7435 if (parameters === undefined) {
7436 parameters = {};
7437 }
7438 var deferred = $q.defer();
7439
7440 var domain = this.domain;
7441 var path = '/xos/flavors/';
7442
7443 var body;
7444 var queryParameters = {};
7445 var headers = {};
7446 var form = {};
7447
7448 if (parameters.$queryParameters) {
7449 Object.keys(parameters.$queryParameters)
7450 .forEach(function(parameterName) {
7451 var parameter = parameters.$queryParameters[parameterName];
7452 queryParameters[parameterName] = parameter;
7453 });
7454 }
7455
7456 var url = domain + path;
7457 var cached = parameters.$cache && parameters.$cache.get(url);
7458 if (cached !== undefined && parameters.$refresh !== true) {
7459 deferred.resolve(cached);
7460 return deferred.promise;
7461 }
7462 var options = {
7463 timeout: parameters.$timeout,
7464 method: 'GET',
7465 url: url,
7466 params: queryParameters,
7467 data: body,
7468 headers: headers
7469 };
7470 if (Object.keys(form).length > 0) {
7471 options.data = form;
7472 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7473 options.transformRequest = xos.transformRequest;
7474 }
7475 $http(options)
7476 .success(function(data, status, headers, config) {
7477 deferred.resolve(data);
7478 if (parameters.$cache !== undefined) {
7479 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7480 }
7481 })
7482 .error(function(data, status, headers, config) {
7483 deferred.reject({
7484 status: status,
7485 headers: headers,
7486 config: config,
7487 body: data
7488 });
7489 });
7490
7491 return deferred.promise;
7492 };
7493 /**
7494 *
7495 * @method
7496 * @name xos#Flavor_List_POST
7497 * @param {string} enacted -
7498 * @param {string} policed -
7499 * @param {string} backend_register -
7500 * @param {string} backend_status -
7501 * @param {boolean} deleted -
7502 * @param {boolean} write_protect -
7503 * @param {boolean} lazy_blocked -
7504 * @param {boolean} no_sync -
7505 * @param {string} name - name of this flavor, as displayed to users
7506 * @param {string} description -
7507 * @param {string} flavor - flavor string used to configure deployments
7508 * @param {integer} order - used to order flavors when displayed in a list
7509 * @param {boolean} default - make this a default flavor to use when creating new instances
7510 *
7511 */
7512 xos.prototype.Flavor_List_POST = function(parameters) {
7513 if (parameters === undefined) {
7514 parameters = {};
7515 }
7516 var deferred = $q.defer();
7517
7518 var domain = this.domain;
7519 var path = '/xos/flavors/';
7520
7521 var body;
7522 var queryParameters = {};
7523 var headers = {};
7524 var form = {};
7525
7526 if (parameters['enacted'] !== undefined) {
7527 form['enacted'] = parameters['enacted'];
7528 }
7529
7530 if (parameters['policed'] !== undefined) {
7531 form['policed'] = parameters['policed'];
7532 }
7533
7534 if (parameters['backend_register'] !== undefined) {
7535 form['backend_register'] = parameters['backend_register'];
7536 }
7537
7538 if (parameters['backend_status'] !== undefined) {
7539 form['backend_status'] = parameters['backend_status'];
7540 }
7541
7542 if (parameters['backend_status'] === undefined) {
7543 deferred.reject(new Error('Missing required form parameter: backend_status'));
7544 return deferred.promise;
7545 }
7546
7547 if (parameters['deleted'] !== undefined) {
7548 form['deleted'] = parameters['deleted'];
7549 }
7550
7551 if (parameters['write_protect'] !== undefined) {
7552 form['write_protect'] = parameters['write_protect'];
7553 }
7554
7555 if (parameters['lazy_blocked'] !== undefined) {
7556 form['lazy_blocked'] = parameters['lazy_blocked'];
7557 }
7558
7559 if (parameters['no_sync'] !== undefined) {
7560 form['no_sync'] = parameters['no_sync'];
7561 }
7562
7563 if (parameters['name'] !== undefined) {
7564 form['name'] = parameters['name'];
7565 }
7566
7567 if (parameters['name'] === undefined) {
7568 deferred.reject(new Error('Missing required form parameter: name'));
7569 return deferred.promise;
7570 }
7571
7572 if (parameters['description'] !== undefined) {
7573 form['description'] = parameters['description'];
7574 }
7575
7576 if (parameters['flavor'] !== undefined) {
7577 form['flavor'] = parameters['flavor'];
7578 }
7579
7580 if (parameters['flavor'] === undefined) {
7581 deferred.reject(new Error('Missing required form parameter: flavor'));
7582 return deferred.promise;
7583 }
7584
7585 if (parameters['order'] !== undefined) {
7586 form['order'] = parameters['order'];
7587 }
7588
7589 if (parameters['order'] === undefined) {
7590 deferred.reject(new Error('Missing required form parameter: order'));
7591 return deferred.promise;
7592 }
7593
7594 if (parameters['default'] !== undefined) {
7595 form['default'] = parameters['default'];
7596 }
7597
7598 if (parameters.$queryParameters) {
7599 Object.keys(parameters.$queryParameters)
7600 .forEach(function(parameterName) {
7601 var parameter = parameters.$queryParameters[parameterName];
7602 queryParameters[parameterName] = parameter;
7603 });
7604 }
7605
7606 var url = domain + path;
7607 var options = {
7608 timeout: parameters.$timeout,
7609 method: 'POST',
7610 url: url,
7611 params: queryParameters,
7612 data: body,
7613 headers: headers
7614 };
7615 if (Object.keys(form).length > 0) {
7616 options.data = form;
7617 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7618 options.transformRequest = xos.transformRequest;
7619 }
7620 $http(options)
7621 .success(function(data, status, headers, config) {
7622 deferred.resolve(data);
7623 if (parameters.$cache !== undefined) {
7624 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7625 }
7626 })
7627 .error(function(data, status, headers, config) {
7628 deferred.reject({
7629 status: status,
7630 headers: headers,
7631 config: config,
7632 body: data
7633 });
7634 });
7635
7636 return deferred.promise;
7637 };
7638 /**
7639 *
7640 * @method
7641 * @name xos#Flavor_Detail_GET
7642 * @param {string} pk -
7643 *
7644 */
7645 xos.prototype.Flavor_Detail_GET = function(parameters) {
7646 if (parameters === undefined) {
7647 parameters = {};
7648 }
7649 var deferred = $q.defer();
7650
7651 var domain = this.domain;
7652 var path = '/xos/flavors/{pk}/';
7653
7654 var body;
7655 var queryParameters = {};
7656 var headers = {};
7657 var form = {};
7658
7659 path = path.replace('{pk}', parameters['pk']);
7660
7661 if (parameters['pk'] === undefined) {
7662 deferred.reject(new Error('Missing required path parameter: pk'));
7663 return deferred.promise;
7664 }
7665
7666 if (parameters.$queryParameters) {
7667 Object.keys(parameters.$queryParameters)
7668 .forEach(function(parameterName) {
7669 var parameter = parameters.$queryParameters[parameterName];
7670 queryParameters[parameterName] = parameter;
7671 });
7672 }
7673
7674 var url = domain + path;
7675 var cached = parameters.$cache && parameters.$cache.get(url);
7676 if (cached !== undefined && parameters.$refresh !== true) {
7677 deferred.resolve(cached);
7678 return deferred.promise;
7679 }
7680 var options = {
7681 timeout: parameters.$timeout,
7682 method: 'GET',
7683 url: url,
7684 params: queryParameters,
7685 data: body,
7686 headers: headers
7687 };
7688 if (Object.keys(form).length > 0) {
7689 options.data = form;
7690 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7691 options.transformRequest = xos.transformRequest;
7692 }
7693 $http(options)
7694 .success(function(data, status, headers, config) {
7695 deferred.resolve(data);
7696 if (parameters.$cache !== undefined) {
7697 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7698 }
7699 })
7700 .error(function(data, status, headers, config) {
7701 deferred.reject({
7702 status: status,
7703 headers: headers,
7704 config: config,
7705 body: data
7706 });
7707 });
7708
7709 return deferred.promise;
7710 };
7711 /**
7712 *
7713 * @method
7714 * @name xos#Flavor_Detail_PUT
7715 * @param {string} pk -
7716 * @param {string} enacted -
7717 * @param {string} policed -
7718 * @param {string} backend_register -
7719 * @param {string} backend_status -
7720 * @param {boolean} deleted -
7721 * @param {boolean} write_protect -
7722 * @param {boolean} lazy_blocked -
7723 * @param {boolean} no_sync -
7724 * @param {string} name - name of this flavor, as displayed to users
7725 * @param {string} description -
7726 * @param {string} flavor - flavor string used to configure deployments
7727 * @param {integer} order - used to order flavors when displayed in a list
7728 * @param {boolean} default - make this a default flavor to use when creating new instances
7729 *
7730 */
7731 xos.prototype.Flavor_Detail_PUT = function(parameters) {
7732 if (parameters === undefined) {
7733 parameters = {};
7734 }
7735 var deferred = $q.defer();
7736
7737 var domain = this.domain;
7738 var path = '/xos/flavors/{pk}/';
7739
7740 var body;
7741 var queryParameters = {};
7742 var headers = {};
7743 var form = {};
7744
7745 path = path.replace('{pk}', parameters['pk']);
7746
7747 if (parameters['pk'] === undefined) {
7748 deferred.reject(new Error('Missing required path parameter: pk'));
7749 return deferred.promise;
7750 }
7751
7752 if (parameters['enacted'] !== undefined) {
7753 form['enacted'] = parameters['enacted'];
7754 }
7755
7756 if (parameters['policed'] !== undefined) {
7757 form['policed'] = parameters['policed'];
7758 }
7759
7760 if (parameters['backend_register'] !== undefined) {
7761 form['backend_register'] = parameters['backend_register'];
7762 }
7763
7764 if (parameters['backend_status'] !== undefined) {
7765 form['backend_status'] = parameters['backend_status'];
7766 }
7767
7768 if (parameters['backend_status'] === undefined) {
7769 deferred.reject(new Error('Missing required form parameter: backend_status'));
7770 return deferred.promise;
7771 }
7772
7773 if (parameters['deleted'] !== undefined) {
7774 form['deleted'] = parameters['deleted'];
7775 }
7776
7777 if (parameters['write_protect'] !== undefined) {
7778 form['write_protect'] = parameters['write_protect'];
7779 }
7780
7781 if (parameters['lazy_blocked'] !== undefined) {
7782 form['lazy_blocked'] = parameters['lazy_blocked'];
7783 }
7784
7785 if (parameters['no_sync'] !== undefined) {
7786 form['no_sync'] = parameters['no_sync'];
7787 }
7788
7789 if (parameters['name'] !== undefined) {
7790 form['name'] = parameters['name'];
7791 }
7792
7793 if (parameters['name'] === undefined) {
7794 deferred.reject(new Error('Missing required form parameter: name'));
7795 return deferred.promise;
7796 }
7797
7798 if (parameters['description'] !== undefined) {
7799 form['description'] = parameters['description'];
7800 }
7801
7802 if (parameters['flavor'] !== undefined) {
7803 form['flavor'] = parameters['flavor'];
7804 }
7805
7806 if (parameters['flavor'] === undefined) {
7807 deferred.reject(new Error('Missing required form parameter: flavor'));
7808 return deferred.promise;
7809 }
7810
7811 if (parameters['order'] !== undefined) {
7812 form['order'] = parameters['order'];
7813 }
7814
7815 if (parameters['order'] === undefined) {
7816 deferred.reject(new Error('Missing required form parameter: order'));
7817 return deferred.promise;
7818 }
7819
7820 if (parameters['default'] !== undefined) {
7821 form['default'] = parameters['default'];
7822 }
7823
7824 if (parameters.$queryParameters) {
7825 Object.keys(parameters.$queryParameters)
7826 .forEach(function(parameterName) {
7827 var parameter = parameters.$queryParameters[parameterName];
7828 queryParameters[parameterName] = parameter;
7829 });
7830 }
7831
7832 var url = domain + path;
7833 var options = {
7834 timeout: parameters.$timeout,
7835 method: 'PUT',
7836 url: url,
7837 params: queryParameters,
7838 data: body,
7839 headers: headers
7840 };
7841 if (Object.keys(form).length > 0) {
7842 options.data = form;
7843 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7844 options.transformRequest = xos.transformRequest;
7845 }
7846 $http(options)
7847 .success(function(data, status, headers, config) {
7848 deferred.resolve(data);
7849 if (parameters.$cache !== undefined) {
7850 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7851 }
7852 })
7853 .error(function(data, status, headers, config) {
7854 deferred.reject({
7855 status: status,
7856 headers: headers,
7857 config: config,
7858 body: data
7859 });
7860 });
7861
7862 return deferred.promise;
7863 };
7864 /**
7865 *
7866 * @method
7867 * @name xos#Flavor_Detail_PATCH
7868 * @param {string} pk -
7869 * @param {string} enacted -
7870 * @param {string} policed -
7871 * @param {string} backend_register -
7872 * @param {string} backend_status -
7873 * @param {boolean} deleted -
7874 * @param {boolean} write_protect -
7875 * @param {boolean} lazy_blocked -
7876 * @param {boolean} no_sync -
7877 * @param {string} name - name of this flavor, as displayed to users
7878 * @param {string} description -
7879 * @param {string} flavor - flavor string used to configure deployments
7880 * @param {integer} order - used to order flavors when displayed in a list
7881 * @param {boolean} default - make this a default flavor to use when creating new instances
7882 *
7883 */
7884 xos.prototype.Flavor_Detail_PATCH = function(parameters) {
7885 if (parameters === undefined) {
7886 parameters = {};
7887 }
7888 var deferred = $q.defer();
7889
7890 var domain = this.domain;
7891 var path = '/xos/flavors/{pk}/';
7892
7893 var body;
7894 var queryParameters = {};
7895 var headers = {};
7896 var form = {};
7897
7898 path = path.replace('{pk}', parameters['pk']);
7899
7900 if (parameters['pk'] === undefined) {
7901 deferred.reject(new Error('Missing required path parameter: pk'));
7902 return deferred.promise;
7903 }
7904
7905 if (parameters['enacted'] !== undefined) {
7906 form['enacted'] = parameters['enacted'];
7907 }
7908
7909 if (parameters['policed'] !== undefined) {
7910 form['policed'] = parameters['policed'];
7911 }
7912
7913 if (parameters['backend_register'] !== undefined) {
7914 form['backend_register'] = parameters['backend_register'];
7915 }
7916
7917 if (parameters['backend_status'] !== undefined) {
7918 form['backend_status'] = parameters['backend_status'];
7919 }
7920
7921 if (parameters['deleted'] !== undefined) {
7922 form['deleted'] = parameters['deleted'];
7923 }
7924
7925 if (parameters['write_protect'] !== undefined) {
7926 form['write_protect'] = parameters['write_protect'];
7927 }
7928
7929 if (parameters['lazy_blocked'] !== undefined) {
7930 form['lazy_blocked'] = parameters['lazy_blocked'];
7931 }
7932
7933 if (parameters['no_sync'] !== undefined) {
7934 form['no_sync'] = parameters['no_sync'];
7935 }
7936
7937 if (parameters['name'] !== undefined) {
7938 form['name'] = parameters['name'];
7939 }
7940
7941 if (parameters['description'] !== undefined) {
7942 form['description'] = parameters['description'];
7943 }
7944
7945 if (parameters['flavor'] !== undefined) {
7946 form['flavor'] = parameters['flavor'];
7947 }
7948
7949 if (parameters['order'] !== undefined) {
7950 form['order'] = parameters['order'];
7951 }
7952
7953 if (parameters['default'] !== undefined) {
7954 form['default'] = parameters['default'];
7955 }
7956
7957 if (parameters.$queryParameters) {
7958 Object.keys(parameters.$queryParameters)
7959 .forEach(function(parameterName) {
7960 var parameter = parameters.$queryParameters[parameterName];
7961 queryParameters[parameterName] = parameter;
7962 });
7963 }
7964
7965 var url = domain + path;
7966 var options = {
7967 timeout: parameters.$timeout,
7968 method: 'PATCH',
7969 url: url,
7970 params: queryParameters,
7971 data: body,
7972 headers: headers
7973 };
7974 if (Object.keys(form).length > 0) {
7975 options.data = form;
7976 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
7977 options.transformRequest = xos.transformRequest;
7978 }
7979 $http(options)
7980 .success(function(data, status, headers, config) {
7981 deferred.resolve(data);
7982 if (parameters.$cache !== undefined) {
7983 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
7984 }
7985 })
7986 .error(function(data, status, headers, config) {
7987 deferred.reject({
7988 status: status,
7989 headers: headers,
7990 config: config,
7991 body: data
7992 });
7993 });
7994
7995 return deferred.promise;
7996 };
7997 /**
7998 *
7999 * @method
8000 * @name xos#Flavor_Detail_DELETE
8001 * @param {string} pk -
8002 *
8003 */
8004 xos.prototype.Flavor_Detail_DELETE = function(parameters) {
8005 if (parameters === undefined) {
8006 parameters = {};
8007 }
8008 var deferred = $q.defer();
8009
8010 var domain = this.domain;
8011 var path = '/xos/flavors/{pk}/';
8012
8013 var body;
8014 var queryParameters = {};
8015 var headers = {};
8016 var form = {};
8017
8018 path = path.replace('{pk}', parameters['pk']);
8019
8020 if (parameters['pk'] === undefined) {
8021 deferred.reject(new Error('Missing required path parameter: pk'));
8022 return deferred.promise;
8023 }
8024
8025 if (parameters.$queryParameters) {
8026 Object.keys(parameters.$queryParameters)
8027 .forEach(function(parameterName) {
8028 var parameter = parameters.$queryParameters[parameterName];
8029 queryParameters[parameterName] = parameter;
8030 });
8031 }
8032
8033 var url = domain + path;
8034 var options = {
8035 timeout: parameters.$timeout,
8036 method: 'DELETE',
8037 url: url,
8038 params: queryParameters,
8039 data: body,
8040 headers: headers
8041 };
8042 if (Object.keys(form).length > 0) {
8043 options.data = form;
8044 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8045 options.transformRequest = xos.transformRequest;
8046 }
8047 $http(options)
8048 .success(function(data, status, headers, config) {
8049 deferred.resolve(data);
8050 if (parameters.$cache !== undefined) {
8051 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8052 }
8053 })
8054 .error(function(data, status, headers, config) {
8055 deferred.reject({
8056 status: status,
8057 headers: headers,
8058 config: config,
8059 body: data
8060 });
8061 });
8062
8063 return deferred.promise;
8064 };
8065 /**
8066 *
8067 * @method
8068 * @name xos#Port_List_GET
8069 *
8070 */
8071 xos.prototype.Port_List_GET = function(parameters) {
8072 if (parameters === undefined) {
8073 parameters = {};
8074 }
8075 var deferred = $q.defer();
8076
8077 var domain = this.domain;
8078 var path = '/xos/ports/';
8079
8080 var body;
8081 var queryParameters = {};
8082 var headers = {};
8083 var form = {};
8084
8085 if (parameters.$queryParameters) {
8086 Object.keys(parameters.$queryParameters)
8087 .forEach(function(parameterName) {
8088 var parameter = parameters.$queryParameters[parameterName];
8089 queryParameters[parameterName] = parameter;
8090 });
8091 }
8092
8093 var url = domain + path;
8094 var cached = parameters.$cache && parameters.$cache.get(url);
8095 if (cached !== undefined && parameters.$refresh !== true) {
8096 deferred.resolve(cached);
8097 return deferred.promise;
8098 }
8099 var options = {
8100 timeout: parameters.$timeout,
8101 method: 'GET',
8102 url: url,
8103 params: queryParameters,
8104 data: body,
8105 headers: headers
8106 };
8107 if (Object.keys(form).length > 0) {
8108 options.data = form;
8109 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8110 options.transformRequest = xos.transformRequest;
8111 }
8112 $http(options)
8113 .success(function(data, status, headers, config) {
8114 deferred.resolve(data);
8115 if (parameters.$cache !== undefined) {
8116 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8117 }
8118 })
8119 .error(function(data, status, headers, config) {
8120 deferred.reject({
8121 status: status,
8122 headers: headers,
8123 config: config,
8124 body: data
8125 });
8126 });
8127
8128 return deferred.promise;
8129 };
8130 /**
8131 *
8132 * @method
8133 * @name xos#Port_List_POST
8134 * @param {string} enacted -
8135 * @param {string} policed -
8136 * @param {string} backend_register -
8137 * @param {string} backend_status -
8138 * @param {boolean} deleted -
8139 * @param {boolean} write_protect -
8140 * @param {boolean} lazy_blocked -
8141 * @param {boolean} no_sync -
8142 * @param {string} network -
8143 * @param {string} instance -
8144 * @param {string} ip - Instance ip address
8145 * @param {string} port_id - Quantum port id
8146 * @param {string} mac - MAC address associated with this port
8147 *
8148 */
8149 xos.prototype.Port_List_POST = function(parameters) {
8150 if (parameters === undefined) {
8151 parameters = {};
8152 }
8153 var deferred = $q.defer();
8154
8155 var domain = this.domain;
8156 var path = '/xos/ports/';
8157
8158 var body;
8159 var queryParameters = {};
8160 var headers = {};
8161 var form = {};
8162
8163 if (parameters['enacted'] !== undefined) {
8164 form['enacted'] = parameters['enacted'];
8165 }
8166
8167 if (parameters['policed'] !== undefined) {
8168 form['policed'] = parameters['policed'];
8169 }
8170
8171 if (parameters['backend_register'] !== undefined) {
8172 form['backend_register'] = parameters['backend_register'];
8173 }
8174
8175 if (parameters['backend_status'] !== undefined) {
8176 form['backend_status'] = parameters['backend_status'];
8177 }
8178
8179 if (parameters['backend_status'] === undefined) {
8180 deferred.reject(new Error('Missing required form parameter: backend_status'));
8181 return deferred.promise;
8182 }
8183
8184 if (parameters['deleted'] !== undefined) {
8185 form['deleted'] = parameters['deleted'];
8186 }
8187
8188 if (parameters['write_protect'] !== undefined) {
8189 form['write_protect'] = parameters['write_protect'];
8190 }
8191
8192 if (parameters['lazy_blocked'] !== undefined) {
8193 form['lazy_blocked'] = parameters['lazy_blocked'];
8194 }
8195
8196 if (parameters['no_sync'] !== undefined) {
8197 form['no_sync'] = parameters['no_sync'];
8198 }
8199
8200 if (parameters['network'] !== undefined) {
8201 form['network'] = parameters['network'];
8202 }
8203
8204 if (parameters['network'] === undefined) {
8205 deferred.reject(new Error('Missing required form parameter: network'));
8206 return deferred.promise;
8207 }
8208
8209 if (parameters['instance'] !== undefined) {
8210 form['instance'] = parameters['instance'];
8211 }
8212
8213 if (parameters['ip'] !== undefined) {
8214 form['ip'] = parameters['ip'];
8215 }
8216
8217 if (parameters['port_id'] !== undefined) {
8218 form['port_id'] = parameters['port_id'];
8219 }
8220
8221 if (parameters['mac'] !== undefined) {
8222 form['mac'] = parameters['mac'];
8223 }
8224
8225 if (parameters.$queryParameters) {
8226 Object.keys(parameters.$queryParameters)
8227 .forEach(function(parameterName) {
8228 var parameter = parameters.$queryParameters[parameterName];
8229 queryParameters[parameterName] = parameter;
8230 });
8231 }
8232
8233 var url = domain + path;
8234 var options = {
8235 timeout: parameters.$timeout,
8236 method: 'POST',
8237 url: url,
8238 params: queryParameters,
8239 data: body,
8240 headers: headers
8241 };
8242 if (Object.keys(form).length > 0) {
8243 options.data = form;
8244 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8245 options.transformRequest = xos.transformRequest;
8246 }
8247 $http(options)
8248 .success(function(data, status, headers, config) {
8249 deferred.resolve(data);
8250 if (parameters.$cache !== undefined) {
8251 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8252 }
8253 })
8254 .error(function(data, status, headers, config) {
8255 deferred.reject({
8256 status: status,
8257 headers: headers,
8258 config: config,
8259 body: data
8260 });
8261 });
8262
8263 return deferred.promise;
8264 };
8265 /**
8266 *
8267 * @method
8268 * @name xos#Port_Detail_GET
8269 * @param {string} pk -
8270 *
8271 */
8272 xos.prototype.Port_Detail_GET = function(parameters) {
8273 if (parameters === undefined) {
8274 parameters = {};
8275 }
8276 var deferred = $q.defer();
8277
8278 var domain = this.domain;
8279 var path = '/xos/ports/{pk}/';
8280
8281 var body;
8282 var queryParameters = {};
8283 var headers = {};
8284 var form = {};
8285
8286 path = path.replace('{pk}', parameters['pk']);
8287
8288 if (parameters['pk'] === undefined) {
8289 deferred.reject(new Error('Missing required path parameter: pk'));
8290 return deferred.promise;
8291 }
8292
8293 if (parameters.$queryParameters) {
8294 Object.keys(parameters.$queryParameters)
8295 .forEach(function(parameterName) {
8296 var parameter = parameters.$queryParameters[parameterName];
8297 queryParameters[parameterName] = parameter;
8298 });
8299 }
8300
8301 var url = domain + path;
8302 var cached = parameters.$cache && parameters.$cache.get(url);
8303 if (cached !== undefined && parameters.$refresh !== true) {
8304 deferred.resolve(cached);
8305 return deferred.promise;
8306 }
8307 var options = {
8308 timeout: parameters.$timeout,
8309 method: 'GET',
8310 url: url,
8311 params: queryParameters,
8312 data: body,
8313 headers: headers
8314 };
8315 if (Object.keys(form).length > 0) {
8316 options.data = form;
8317 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8318 options.transformRequest = xos.transformRequest;
8319 }
8320 $http(options)
8321 .success(function(data, status, headers, config) {
8322 deferred.resolve(data);
8323 if (parameters.$cache !== undefined) {
8324 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8325 }
8326 })
8327 .error(function(data, status, headers, config) {
8328 deferred.reject({
8329 status: status,
8330 headers: headers,
8331 config: config,
8332 body: data
8333 });
8334 });
8335
8336 return deferred.promise;
8337 };
8338 /**
8339 *
8340 * @method
8341 * @name xos#Port_Detail_PUT
8342 * @param {string} pk -
8343 * @param {string} enacted -
8344 * @param {string} policed -
8345 * @param {string} backend_register -
8346 * @param {string} backend_status -
8347 * @param {boolean} deleted -
8348 * @param {boolean} write_protect -
8349 * @param {boolean} lazy_blocked -
8350 * @param {boolean} no_sync -
8351 * @param {string} network -
8352 * @param {string} instance -
8353 * @param {string} ip - Instance ip address
8354 * @param {string} port_id - Quantum port id
8355 * @param {string} mac - MAC address associated with this port
8356 *
8357 */
8358 xos.prototype.Port_Detail_PUT = function(parameters) {
8359 if (parameters === undefined) {
8360 parameters = {};
8361 }
8362 var deferred = $q.defer();
8363
8364 var domain = this.domain;
8365 var path = '/xos/ports/{pk}/';
8366
8367 var body;
8368 var queryParameters = {};
8369 var headers = {};
8370 var form = {};
8371
8372 path = path.replace('{pk}', parameters['pk']);
8373
8374 if (parameters['pk'] === undefined) {
8375 deferred.reject(new Error('Missing required path parameter: pk'));
8376 return deferred.promise;
8377 }
8378
8379 if (parameters['enacted'] !== undefined) {
8380 form['enacted'] = parameters['enacted'];
8381 }
8382
8383 if (parameters['policed'] !== undefined) {
8384 form['policed'] = parameters['policed'];
8385 }
8386
8387 if (parameters['backend_register'] !== undefined) {
8388 form['backend_register'] = parameters['backend_register'];
8389 }
8390
8391 if (parameters['backend_status'] !== undefined) {
8392 form['backend_status'] = parameters['backend_status'];
8393 }
8394
8395 if (parameters['backend_status'] === undefined) {
8396 deferred.reject(new Error('Missing required form parameter: backend_status'));
8397 return deferred.promise;
8398 }
8399
8400 if (parameters['deleted'] !== undefined) {
8401 form['deleted'] = parameters['deleted'];
8402 }
8403
8404 if (parameters['write_protect'] !== undefined) {
8405 form['write_protect'] = parameters['write_protect'];
8406 }
8407
8408 if (parameters['lazy_blocked'] !== undefined) {
8409 form['lazy_blocked'] = parameters['lazy_blocked'];
8410 }
8411
8412 if (parameters['no_sync'] !== undefined) {
8413 form['no_sync'] = parameters['no_sync'];
8414 }
8415
8416 if (parameters['network'] !== undefined) {
8417 form['network'] = parameters['network'];
8418 }
8419
8420 if (parameters['network'] === undefined) {
8421 deferred.reject(new Error('Missing required form parameter: network'));
8422 return deferred.promise;
8423 }
8424
8425 if (parameters['instance'] !== undefined) {
8426 form['instance'] = parameters['instance'];
8427 }
8428
8429 if (parameters['ip'] !== undefined) {
8430 form['ip'] = parameters['ip'];
8431 }
8432
8433 if (parameters['port_id'] !== undefined) {
8434 form['port_id'] = parameters['port_id'];
8435 }
8436
8437 if (parameters['mac'] !== undefined) {
8438 form['mac'] = parameters['mac'];
8439 }
8440
8441 if (parameters.$queryParameters) {
8442 Object.keys(parameters.$queryParameters)
8443 .forEach(function(parameterName) {
8444 var parameter = parameters.$queryParameters[parameterName];
8445 queryParameters[parameterName] = parameter;
8446 });
8447 }
8448
8449 var url = domain + path;
8450 var options = {
8451 timeout: parameters.$timeout,
8452 method: 'PUT',
8453 url: url,
8454 params: queryParameters,
8455 data: body,
8456 headers: headers
8457 };
8458 if (Object.keys(form).length > 0) {
8459 options.data = form;
8460 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8461 options.transformRequest = xos.transformRequest;
8462 }
8463 $http(options)
8464 .success(function(data, status, headers, config) {
8465 deferred.resolve(data);
8466 if (parameters.$cache !== undefined) {
8467 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8468 }
8469 })
8470 .error(function(data, status, headers, config) {
8471 deferred.reject({
8472 status: status,
8473 headers: headers,
8474 config: config,
8475 body: data
8476 });
8477 });
8478
8479 return deferred.promise;
8480 };
8481 /**
8482 *
8483 * @method
8484 * @name xos#Port_Detail_PATCH
8485 * @param {string} pk -
8486 * @param {string} enacted -
8487 * @param {string} policed -
8488 * @param {string} backend_register -
8489 * @param {string} backend_status -
8490 * @param {boolean} deleted -
8491 * @param {boolean} write_protect -
8492 * @param {boolean} lazy_blocked -
8493 * @param {boolean} no_sync -
8494 * @param {string} network -
8495 * @param {string} instance -
8496 * @param {string} ip - Instance ip address
8497 * @param {string} port_id - Quantum port id
8498 * @param {string} mac - MAC address associated with this port
8499 *
8500 */
8501 xos.prototype.Port_Detail_PATCH = function(parameters) {
8502 if (parameters === undefined) {
8503 parameters = {};
8504 }
8505 var deferred = $q.defer();
8506
8507 var domain = this.domain;
8508 var path = '/xos/ports/{pk}/';
8509
8510 var body;
8511 var queryParameters = {};
8512 var headers = {};
8513 var form = {};
8514
8515 path = path.replace('{pk}', parameters['pk']);
8516
8517 if (parameters['pk'] === undefined) {
8518 deferred.reject(new Error('Missing required path parameter: pk'));
8519 return deferred.promise;
8520 }
8521
8522 if (parameters['enacted'] !== undefined) {
8523 form['enacted'] = parameters['enacted'];
8524 }
8525
8526 if (parameters['policed'] !== undefined) {
8527 form['policed'] = parameters['policed'];
8528 }
8529
8530 if (parameters['backend_register'] !== undefined) {
8531 form['backend_register'] = parameters['backend_register'];
8532 }
8533
8534 if (parameters['backend_status'] !== undefined) {
8535 form['backend_status'] = parameters['backend_status'];
8536 }
8537
8538 if (parameters['deleted'] !== undefined) {
8539 form['deleted'] = parameters['deleted'];
8540 }
8541
8542 if (parameters['write_protect'] !== undefined) {
8543 form['write_protect'] = parameters['write_protect'];
8544 }
8545
8546 if (parameters['lazy_blocked'] !== undefined) {
8547 form['lazy_blocked'] = parameters['lazy_blocked'];
8548 }
8549
8550 if (parameters['no_sync'] !== undefined) {
8551 form['no_sync'] = parameters['no_sync'];
8552 }
8553
8554 if (parameters['network'] !== undefined) {
8555 form['network'] = parameters['network'];
8556 }
8557
8558 if (parameters['instance'] !== undefined) {
8559 form['instance'] = parameters['instance'];
8560 }
8561
8562 if (parameters['ip'] !== undefined) {
8563 form['ip'] = parameters['ip'];
8564 }
8565
8566 if (parameters['port_id'] !== undefined) {
8567 form['port_id'] = parameters['port_id'];
8568 }
8569
8570 if (parameters['mac'] !== undefined) {
8571 form['mac'] = parameters['mac'];
8572 }
8573
8574 if (parameters.$queryParameters) {
8575 Object.keys(parameters.$queryParameters)
8576 .forEach(function(parameterName) {
8577 var parameter = parameters.$queryParameters[parameterName];
8578 queryParameters[parameterName] = parameter;
8579 });
8580 }
8581
8582 var url = domain + path;
8583 var options = {
8584 timeout: parameters.$timeout,
8585 method: 'PATCH',
8586 url: url,
8587 params: queryParameters,
8588 data: body,
8589 headers: headers
8590 };
8591 if (Object.keys(form).length > 0) {
8592 options.data = form;
8593 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8594 options.transformRequest = xos.transformRequest;
8595 }
8596 $http(options)
8597 .success(function(data, status, headers, config) {
8598 deferred.resolve(data);
8599 if (parameters.$cache !== undefined) {
8600 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8601 }
8602 })
8603 .error(function(data, status, headers, config) {
8604 deferred.reject({
8605 status: status,
8606 headers: headers,
8607 config: config,
8608 body: data
8609 });
8610 });
8611
8612 return deferred.promise;
8613 };
8614 /**
8615 *
8616 * @method
8617 * @name xos#Port_Detail_DELETE
8618 * @param {string} pk -
8619 *
8620 */
8621 xos.prototype.Port_Detail_DELETE = function(parameters) {
8622 if (parameters === undefined) {
8623 parameters = {};
8624 }
8625 var deferred = $q.defer();
8626
8627 var domain = this.domain;
8628 var path = '/xos/ports/{pk}/';
8629
8630 var body;
8631 var queryParameters = {};
8632 var headers = {};
8633 var form = {};
8634
8635 path = path.replace('{pk}', parameters['pk']);
8636
8637 if (parameters['pk'] === undefined) {
8638 deferred.reject(new Error('Missing required path parameter: pk'));
8639 return deferred.promise;
8640 }
8641
8642 if (parameters.$queryParameters) {
8643 Object.keys(parameters.$queryParameters)
8644 .forEach(function(parameterName) {
8645 var parameter = parameters.$queryParameters[parameterName];
8646 queryParameters[parameterName] = parameter;
8647 });
8648 }
8649
8650 var url = domain + path;
8651 var options = {
8652 timeout: parameters.$timeout,
8653 method: 'DELETE',
8654 url: url,
8655 params: queryParameters,
8656 data: body,
8657 headers: headers
8658 };
8659 if (Object.keys(form).length > 0) {
8660 options.data = form;
8661 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8662 options.transformRequest = xos.transformRequest;
8663 }
8664 $http(options)
8665 .success(function(data, status, headers, config) {
8666 deferred.resolve(data);
8667 if (parameters.$cache !== undefined) {
8668 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8669 }
8670 })
8671 .error(function(data, status, headers, config) {
8672 deferred.reject({
8673 status: status,
8674 headers: headers,
8675 config: config,
8676 body: data
8677 });
8678 });
8679
8680 return deferred.promise;
8681 };
8682 /**
8683 *
8684 * @method
8685 * @name xos#Controller_Site_List_GET
8686 *
8687 */
8688 xos.prototype.Controller_Site_List_GET = function(parameters) {
8689 if (parameters === undefined) {
8690 parameters = {};
8691 }
8692 var deferred = $q.defer();
8693
8694 var domain = this.domain;
8695 var path = '/xos/controllersites/';
8696
8697 var body;
8698 var queryParameters = {};
8699 var headers = {};
8700 var form = {};
8701
8702 if (parameters.$queryParameters) {
8703 Object.keys(parameters.$queryParameters)
8704 .forEach(function(parameterName) {
8705 var parameter = parameters.$queryParameters[parameterName];
8706 queryParameters[parameterName] = parameter;
8707 });
8708 }
8709
8710 var url = domain + path;
8711 var cached = parameters.$cache && parameters.$cache.get(url);
8712 if (cached !== undefined && parameters.$refresh !== true) {
8713 deferred.resolve(cached);
8714 return deferred.promise;
8715 }
8716 var options = {
8717 timeout: parameters.$timeout,
8718 method: 'GET',
8719 url: url,
8720 params: queryParameters,
8721 data: body,
8722 headers: headers
8723 };
8724 if (Object.keys(form).length > 0) {
8725 options.data = form;
8726 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8727 options.transformRequest = xos.transformRequest;
8728 }
8729 $http(options)
8730 .success(function(data, status, headers, config) {
8731 deferred.resolve(data);
8732 if (parameters.$cache !== undefined) {
8733 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8734 }
8735 })
8736 .error(function(data, status, headers, config) {
8737 deferred.reject({
8738 status: status,
8739 headers: headers,
8740 config: config,
8741 body: data
8742 });
8743 });
8744
8745 return deferred.promise;
8746 };
8747 /**
8748 *
8749 * @method
8750 * @name xos#Controller_Site_List_POST
8751 * @param {string} enacted -
8752 * @param {string} policed -
8753 * @param {string} backend_register -
8754 * @param {string} backend_status -
8755 * @param {boolean} deleted -
8756 * @param {boolean} write_protect -
8757 * @param {boolean} lazy_blocked -
8758 * @param {boolean} no_sync -
8759 * @param {string} site -
8760 * @param {string} controller -
8761 * @param {string} tenant_id - Keystone tenant id
8762 *
8763 */
8764 xos.prototype.Controller_Site_List_POST = function(parameters) {
8765 if (parameters === undefined) {
8766 parameters = {};
8767 }
8768 var deferred = $q.defer();
8769
8770 var domain = this.domain;
8771 var path = '/xos/controllersites/';
8772
8773 var body;
8774 var queryParameters = {};
8775 var headers = {};
8776 var form = {};
8777
8778 if (parameters['enacted'] !== undefined) {
8779 form['enacted'] = parameters['enacted'];
8780 }
8781
8782 if (parameters['policed'] !== undefined) {
8783 form['policed'] = parameters['policed'];
8784 }
8785
8786 if (parameters['backend_register'] !== undefined) {
8787 form['backend_register'] = parameters['backend_register'];
8788 }
8789
8790 if (parameters['backend_status'] !== undefined) {
8791 form['backend_status'] = parameters['backend_status'];
8792 }
8793
8794 if (parameters['backend_status'] === undefined) {
8795 deferred.reject(new Error('Missing required form parameter: backend_status'));
8796 return deferred.promise;
8797 }
8798
8799 if (parameters['deleted'] !== undefined) {
8800 form['deleted'] = parameters['deleted'];
8801 }
8802
8803 if (parameters['write_protect'] !== undefined) {
8804 form['write_protect'] = parameters['write_protect'];
8805 }
8806
8807 if (parameters['lazy_blocked'] !== undefined) {
8808 form['lazy_blocked'] = parameters['lazy_blocked'];
8809 }
8810
8811 if (parameters['no_sync'] !== undefined) {
8812 form['no_sync'] = parameters['no_sync'];
8813 }
8814
8815 if (parameters['site'] !== undefined) {
8816 form['site'] = parameters['site'];
8817 }
8818
8819 if (parameters['site'] === undefined) {
8820 deferred.reject(new Error('Missing required form parameter: site'));
8821 return deferred.promise;
8822 }
8823
8824 if (parameters['controller'] !== undefined) {
8825 form['controller'] = parameters['controller'];
8826 }
8827
8828 if (parameters['tenant_id'] !== undefined) {
8829 form['tenant_id'] = parameters['tenant_id'];
8830 }
8831
8832 if (parameters.$queryParameters) {
8833 Object.keys(parameters.$queryParameters)
8834 .forEach(function(parameterName) {
8835 var parameter = parameters.$queryParameters[parameterName];
8836 queryParameters[parameterName] = parameter;
8837 });
8838 }
8839
8840 var url = domain + path;
8841 var options = {
8842 timeout: parameters.$timeout,
8843 method: 'POST',
8844 url: url,
8845 params: queryParameters,
8846 data: body,
8847 headers: headers
8848 };
8849 if (Object.keys(form).length > 0) {
8850 options.data = form;
8851 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8852 options.transformRequest = xos.transformRequest;
8853 }
8854 $http(options)
8855 .success(function(data, status, headers, config) {
8856 deferred.resolve(data);
8857 if (parameters.$cache !== undefined) {
8858 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8859 }
8860 })
8861 .error(function(data, status, headers, config) {
8862 deferred.reject({
8863 status: status,
8864 headers: headers,
8865 config: config,
8866 body: data
8867 });
8868 });
8869
8870 return deferred.promise;
8871 };
8872 /**
8873 *
8874 * @method
8875 * @name xos#Controller_Site_Detail_GET
8876 * @param {string} pk -
8877 *
8878 */
8879 xos.prototype.Controller_Site_Detail_GET = function(parameters) {
8880 if (parameters === undefined) {
8881 parameters = {};
8882 }
8883 var deferred = $q.defer();
8884
8885 var domain = this.domain;
8886 var path = '/xos/controllersites/{pk}/';
8887
8888 var body;
8889 var queryParameters = {};
8890 var headers = {};
8891 var form = {};
8892
8893 path = path.replace('{pk}', parameters['pk']);
8894
8895 if (parameters['pk'] === undefined) {
8896 deferred.reject(new Error('Missing required path parameter: pk'));
8897 return deferred.promise;
8898 }
8899
8900 if (parameters.$queryParameters) {
8901 Object.keys(parameters.$queryParameters)
8902 .forEach(function(parameterName) {
8903 var parameter = parameters.$queryParameters[parameterName];
8904 queryParameters[parameterName] = parameter;
8905 });
8906 }
8907
8908 var url = domain + path;
8909 var cached = parameters.$cache && parameters.$cache.get(url);
8910 if (cached !== undefined && parameters.$refresh !== true) {
8911 deferred.resolve(cached);
8912 return deferred.promise;
8913 }
8914 var options = {
8915 timeout: parameters.$timeout,
8916 method: 'GET',
8917 url: url,
8918 params: queryParameters,
8919 data: body,
8920 headers: headers
8921 };
8922 if (Object.keys(form).length > 0) {
8923 options.data = form;
8924 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
8925 options.transformRequest = xos.transformRequest;
8926 }
8927 $http(options)
8928 .success(function(data, status, headers, config) {
8929 deferred.resolve(data);
8930 if (parameters.$cache !== undefined) {
8931 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
8932 }
8933 })
8934 .error(function(data, status, headers, config) {
8935 deferred.reject({
8936 status: status,
8937 headers: headers,
8938 config: config,
8939 body: data
8940 });
8941 });
8942
8943 return deferred.promise;
8944 };
8945 /**
8946 *
8947 * @method
8948 * @name xos#Controller_Site_Detail_PUT
8949 * @param {string} pk -
8950 * @param {string} enacted -
8951 * @param {string} policed -
8952 * @param {string} backend_register -
8953 * @param {string} backend_status -
8954 * @param {boolean} deleted -
8955 * @param {boolean} write_protect -
8956 * @param {boolean} lazy_blocked -
8957 * @param {boolean} no_sync -
8958 * @param {string} site -
8959 * @param {string} controller -
8960 * @param {string} tenant_id - Keystone tenant id
8961 *
8962 */
8963 xos.prototype.Controller_Site_Detail_PUT = function(parameters) {
8964 if (parameters === undefined) {
8965 parameters = {};
8966 }
8967 var deferred = $q.defer();
8968
8969 var domain = this.domain;
8970 var path = '/xos/controllersites/{pk}/';
8971
8972 var body;
8973 var queryParameters = {};
8974 var headers = {};
8975 var form = {};
8976
8977 path = path.replace('{pk}', parameters['pk']);
8978
8979 if (parameters['pk'] === undefined) {
8980 deferred.reject(new Error('Missing required path parameter: pk'));
8981 return deferred.promise;
8982 }
8983
8984 if (parameters['enacted'] !== undefined) {
8985 form['enacted'] = parameters['enacted'];
8986 }
8987
8988 if (parameters['policed'] !== undefined) {
8989 form['policed'] = parameters['policed'];
8990 }
8991
8992 if (parameters['backend_register'] !== undefined) {
8993 form['backend_register'] = parameters['backend_register'];
8994 }
8995
8996 if (parameters['backend_status'] !== undefined) {
8997 form['backend_status'] = parameters['backend_status'];
8998 }
8999
9000 if (parameters['backend_status'] === undefined) {
9001 deferred.reject(new Error('Missing required form parameter: backend_status'));
9002 return deferred.promise;
9003 }
9004
9005 if (parameters['deleted'] !== undefined) {
9006 form['deleted'] = parameters['deleted'];
9007 }
9008
9009 if (parameters['write_protect'] !== undefined) {
9010 form['write_protect'] = parameters['write_protect'];
9011 }
9012
9013 if (parameters['lazy_blocked'] !== undefined) {
9014 form['lazy_blocked'] = parameters['lazy_blocked'];
9015 }
9016
9017 if (parameters['no_sync'] !== undefined) {
9018 form['no_sync'] = parameters['no_sync'];
9019 }
9020
9021 if (parameters['site'] !== undefined) {
9022 form['site'] = parameters['site'];
9023 }
9024
9025 if (parameters['site'] === undefined) {
9026 deferred.reject(new Error('Missing required form parameter: site'));
9027 return deferred.promise;
9028 }
9029
9030 if (parameters['controller'] !== undefined) {
9031 form['controller'] = parameters['controller'];
9032 }
9033
9034 if (parameters['tenant_id'] !== undefined) {
9035 form['tenant_id'] = parameters['tenant_id'];
9036 }
9037
9038 if (parameters.$queryParameters) {
9039 Object.keys(parameters.$queryParameters)
9040 .forEach(function(parameterName) {
9041 var parameter = parameters.$queryParameters[parameterName];
9042 queryParameters[parameterName] = parameter;
9043 });
9044 }
9045
9046 var url = domain + path;
9047 var options = {
9048 timeout: parameters.$timeout,
9049 method: 'PUT',
9050 url: url,
9051 params: queryParameters,
9052 data: body,
9053 headers: headers
9054 };
9055 if (Object.keys(form).length > 0) {
9056 options.data = form;
9057 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9058 options.transformRequest = xos.transformRequest;
9059 }
9060 $http(options)
9061 .success(function(data, status, headers, config) {
9062 deferred.resolve(data);
9063 if (parameters.$cache !== undefined) {
9064 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9065 }
9066 })
9067 .error(function(data, status, headers, config) {
9068 deferred.reject({
9069 status: status,
9070 headers: headers,
9071 config: config,
9072 body: data
9073 });
9074 });
9075
9076 return deferred.promise;
9077 };
9078 /**
9079 *
9080 * @method
9081 * @name xos#Controller_Site_Detail_PATCH
9082 * @param {string} pk -
9083 * @param {string} enacted -
9084 * @param {string} policed -
9085 * @param {string} backend_register -
9086 * @param {string} backend_status -
9087 * @param {boolean} deleted -
9088 * @param {boolean} write_protect -
9089 * @param {boolean} lazy_blocked -
9090 * @param {boolean} no_sync -
9091 * @param {string} site -
9092 * @param {string} controller -
9093 * @param {string} tenant_id - Keystone tenant id
9094 *
9095 */
9096 xos.prototype.Controller_Site_Detail_PATCH = function(parameters) {
9097 if (parameters === undefined) {
9098 parameters = {};
9099 }
9100 var deferred = $q.defer();
9101
9102 var domain = this.domain;
9103 var path = '/xos/controllersites/{pk}/';
9104
9105 var body;
9106 var queryParameters = {};
9107 var headers = {};
9108 var form = {};
9109
9110 path = path.replace('{pk}', parameters['pk']);
9111
9112 if (parameters['pk'] === undefined) {
9113 deferred.reject(new Error('Missing required path parameter: pk'));
9114 return deferred.promise;
9115 }
9116
9117 if (parameters['enacted'] !== undefined) {
9118 form['enacted'] = parameters['enacted'];
9119 }
9120
9121 if (parameters['policed'] !== undefined) {
9122 form['policed'] = parameters['policed'];
9123 }
9124
9125 if (parameters['backend_register'] !== undefined) {
9126 form['backend_register'] = parameters['backend_register'];
9127 }
9128
9129 if (parameters['backend_status'] !== undefined) {
9130 form['backend_status'] = parameters['backend_status'];
9131 }
9132
9133 if (parameters['deleted'] !== undefined) {
9134 form['deleted'] = parameters['deleted'];
9135 }
9136
9137 if (parameters['write_protect'] !== undefined) {
9138 form['write_protect'] = parameters['write_protect'];
9139 }
9140
9141 if (parameters['lazy_blocked'] !== undefined) {
9142 form['lazy_blocked'] = parameters['lazy_blocked'];
9143 }
9144
9145 if (parameters['no_sync'] !== undefined) {
9146 form['no_sync'] = parameters['no_sync'];
9147 }
9148
9149 if (parameters['site'] !== undefined) {
9150 form['site'] = parameters['site'];
9151 }
9152
9153 if (parameters['controller'] !== undefined) {
9154 form['controller'] = parameters['controller'];
9155 }
9156
9157 if (parameters['tenant_id'] !== undefined) {
9158 form['tenant_id'] = parameters['tenant_id'];
9159 }
9160
9161 if (parameters.$queryParameters) {
9162 Object.keys(parameters.$queryParameters)
9163 .forEach(function(parameterName) {
9164 var parameter = parameters.$queryParameters[parameterName];
9165 queryParameters[parameterName] = parameter;
9166 });
9167 }
9168
9169 var url = domain + path;
9170 var options = {
9171 timeout: parameters.$timeout,
9172 method: 'PATCH',
9173 url: url,
9174 params: queryParameters,
9175 data: body,
9176 headers: headers
9177 };
9178 if (Object.keys(form).length > 0) {
9179 options.data = form;
9180 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9181 options.transformRequest = xos.transformRequest;
9182 }
9183 $http(options)
9184 .success(function(data, status, headers, config) {
9185 deferred.resolve(data);
9186 if (parameters.$cache !== undefined) {
9187 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9188 }
9189 })
9190 .error(function(data, status, headers, config) {
9191 deferred.reject({
9192 status: status,
9193 headers: headers,
9194 config: config,
9195 body: data
9196 });
9197 });
9198
9199 return deferred.promise;
9200 };
9201 /**
9202 *
9203 * @method
9204 * @name xos#Controller_Site_Detail_DELETE
9205 * @param {string} pk -
9206 *
9207 */
9208 xos.prototype.Controller_Site_Detail_DELETE = function(parameters) {
9209 if (parameters === undefined) {
9210 parameters = {};
9211 }
9212 var deferred = $q.defer();
9213
9214 var domain = this.domain;
9215 var path = '/xos/controllersites/{pk}/';
9216
9217 var body;
9218 var queryParameters = {};
9219 var headers = {};
9220 var form = {};
9221
9222 path = path.replace('{pk}', parameters['pk']);
9223
9224 if (parameters['pk'] === undefined) {
9225 deferred.reject(new Error('Missing required path parameter: pk'));
9226 return deferred.promise;
9227 }
9228
9229 if (parameters.$queryParameters) {
9230 Object.keys(parameters.$queryParameters)
9231 .forEach(function(parameterName) {
9232 var parameter = parameters.$queryParameters[parameterName];
9233 queryParameters[parameterName] = parameter;
9234 });
9235 }
9236
9237 var url = domain + path;
9238 var options = {
9239 timeout: parameters.$timeout,
9240 method: 'DELETE',
9241 url: url,
9242 params: queryParameters,
9243 data: body,
9244 headers: headers
9245 };
9246 if (Object.keys(form).length > 0) {
9247 options.data = form;
9248 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9249 options.transformRequest = xos.transformRequest;
9250 }
9251 $http(options)
9252 .success(function(data, status, headers, config) {
9253 deferred.resolve(data);
9254 if (parameters.$cache !== undefined) {
9255 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9256 }
9257 })
9258 .error(function(data, status, headers, config) {
9259 deferred.reject({
9260 status: status,
9261 headers: headers,
9262 config: config,
9263 body: data
9264 });
9265 });
9266
9267 return deferred.promise;
9268 };
9269 /**
9270 *
9271 * @method
9272 * @name xos#Project_List_GET
9273 *
9274 */
9275 xos.prototype.Project_List_GET = function(parameters) {
9276 if (parameters === undefined) {
9277 parameters = {};
9278 }
9279 var deferred = $q.defer();
9280
9281 var domain = this.domain;
9282 var path = '/xos/projects/';
9283
9284 var body;
9285 var queryParameters = {};
9286 var headers = {};
9287 var form = {};
9288
9289 if (parameters.$queryParameters) {
9290 Object.keys(parameters.$queryParameters)
9291 .forEach(function(parameterName) {
9292 var parameter = parameters.$queryParameters[parameterName];
9293 queryParameters[parameterName] = parameter;
9294 });
9295 }
9296
9297 var url = domain + path;
9298 var cached = parameters.$cache && parameters.$cache.get(url);
9299 if (cached !== undefined && parameters.$refresh !== true) {
9300 deferred.resolve(cached);
9301 return deferred.promise;
9302 }
9303 var options = {
9304 timeout: parameters.$timeout,
9305 method: 'GET',
9306 url: url,
9307 params: queryParameters,
9308 data: body,
9309 headers: headers
9310 };
9311 if (Object.keys(form).length > 0) {
9312 options.data = form;
9313 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9314 options.transformRequest = xos.transformRequest;
9315 }
9316 $http(options)
9317 .success(function(data, status, headers, config) {
9318 deferred.resolve(data);
9319 if (parameters.$cache !== undefined) {
9320 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9321 }
9322 })
9323 .error(function(data, status, headers, config) {
9324 deferred.reject({
9325 status: status,
9326 headers: headers,
9327 config: config,
9328 body: data
9329 });
9330 });
9331
9332 return deferred.promise;
9333 };
9334 /**
9335 *
9336 * @method
9337 * @name xos#Project_List_POST
9338 * @param {string} enacted -
9339 * @param {string} policed -
9340 * @param {string} backend_register -
9341 * @param {string} backend_status -
9342 * @param {boolean} deleted -
9343 * @param {boolean} write_protect -
9344 * @param {boolean} lazy_blocked -
9345 * @param {boolean} no_sync -
9346 * @param {string} name - Name of Project
9347 *
9348 */
9349 xos.prototype.Project_List_POST = function(parameters) {
9350 if (parameters === undefined) {
9351 parameters = {};
9352 }
9353 var deferred = $q.defer();
9354
9355 var domain = this.domain;
9356 var path = '/xos/projects/';
9357
9358 var body;
9359 var queryParameters = {};
9360 var headers = {};
9361 var form = {};
9362
9363 if (parameters['enacted'] !== undefined) {
9364 form['enacted'] = parameters['enacted'];
9365 }
9366
9367 if (parameters['policed'] !== undefined) {
9368 form['policed'] = parameters['policed'];
9369 }
9370
9371 if (parameters['backend_register'] !== undefined) {
9372 form['backend_register'] = parameters['backend_register'];
9373 }
9374
9375 if (parameters['backend_status'] !== undefined) {
9376 form['backend_status'] = parameters['backend_status'];
9377 }
9378
9379 if (parameters['backend_status'] === undefined) {
9380 deferred.reject(new Error('Missing required form parameter: backend_status'));
9381 return deferred.promise;
9382 }
9383
9384 if (parameters['deleted'] !== undefined) {
9385 form['deleted'] = parameters['deleted'];
9386 }
9387
9388 if (parameters['write_protect'] !== undefined) {
9389 form['write_protect'] = parameters['write_protect'];
9390 }
9391
9392 if (parameters['lazy_blocked'] !== undefined) {
9393 form['lazy_blocked'] = parameters['lazy_blocked'];
9394 }
9395
9396 if (parameters['no_sync'] !== undefined) {
9397 form['no_sync'] = parameters['no_sync'];
9398 }
9399
9400 if (parameters['name'] !== undefined) {
9401 form['name'] = parameters['name'];
9402 }
9403
9404 if (parameters['name'] === undefined) {
9405 deferred.reject(new Error('Missing required form parameter: name'));
9406 return deferred.promise;
9407 }
9408
9409 if (parameters.$queryParameters) {
9410 Object.keys(parameters.$queryParameters)
9411 .forEach(function(parameterName) {
9412 var parameter = parameters.$queryParameters[parameterName];
9413 queryParameters[parameterName] = parameter;
9414 });
9415 }
9416
9417 var url = domain + path;
9418 var options = {
9419 timeout: parameters.$timeout,
9420 method: 'POST',
9421 url: url,
9422 params: queryParameters,
9423 data: body,
9424 headers: headers
9425 };
9426 if (Object.keys(form).length > 0) {
9427 options.data = form;
9428 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9429 options.transformRequest = xos.transformRequest;
9430 }
9431 $http(options)
9432 .success(function(data, status, headers, config) {
9433 deferred.resolve(data);
9434 if (parameters.$cache !== undefined) {
9435 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9436 }
9437 })
9438 .error(function(data, status, headers, config) {
9439 deferred.reject({
9440 status: status,
9441 headers: headers,
9442 config: config,
9443 body: data
9444 });
9445 });
9446
9447 return deferred.promise;
9448 };
9449 /**
9450 *
9451 * @method
9452 * @name xos#Project_Detail_GET
9453 * @param {string} pk -
9454 *
9455 */
9456 xos.prototype.Project_Detail_GET = function(parameters) {
9457 if (parameters === undefined) {
9458 parameters = {};
9459 }
9460 var deferred = $q.defer();
9461
9462 var domain = this.domain;
9463 var path = '/xos/projects/{pk}/';
9464
9465 var body;
9466 var queryParameters = {};
9467 var headers = {};
9468 var form = {};
9469
9470 path = path.replace('{pk}', parameters['pk']);
9471
9472 if (parameters['pk'] === undefined) {
9473 deferred.reject(new Error('Missing required path parameter: pk'));
9474 return deferred.promise;
9475 }
9476
9477 if (parameters.$queryParameters) {
9478 Object.keys(parameters.$queryParameters)
9479 .forEach(function(parameterName) {
9480 var parameter = parameters.$queryParameters[parameterName];
9481 queryParameters[parameterName] = parameter;
9482 });
9483 }
9484
9485 var url = domain + path;
9486 var cached = parameters.$cache && parameters.$cache.get(url);
9487 if (cached !== undefined && parameters.$refresh !== true) {
9488 deferred.resolve(cached);
9489 return deferred.promise;
9490 }
9491 var options = {
9492 timeout: parameters.$timeout,
9493 method: 'GET',
9494 url: url,
9495 params: queryParameters,
9496 data: body,
9497 headers: headers
9498 };
9499 if (Object.keys(form).length > 0) {
9500 options.data = form;
9501 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9502 options.transformRequest = xos.transformRequest;
9503 }
9504 $http(options)
9505 .success(function(data, status, headers, config) {
9506 deferred.resolve(data);
9507 if (parameters.$cache !== undefined) {
9508 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9509 }
9510 })
9511 .error(function(data, status, headers, config) {
9512 deferred.reject({
9513 status: status,
9514 headers: headers,
9515 config: config,
9516 body: data
9517 });
9518 });
9519
9520 return deferred.promise;
9521 };
9522 /**
9523 *
9524 * @method
9525 * @name xos#Project_Detail_PUT
9526 * @param {string} pk -
9527 * @param {string} enacted -
9528 * @param {string} policed -
9529 * @param {string} backend_register -
9530 * @param {string} backend_status -
9531 * @param {boolean} deleted -
9532 * @param {boolean} write_protect -
9533 * @param {boolean} lazy_blocked -
9534 * @param {boolean} no_sync -
9535 * @param {string} name - Name of Project
9536 *
9537 */
9538 xos.prototype.Project_Detail_PUT = function(parameters) {
9539 if (parameters === undefined) {
9540 parameters = {};
9541 }
9542 var deferred = $q.defer();
9543
9544 var domain = this.domain;
9545 var path = '/xos/projects/{pk}/';
9546
9547 var body;
9548 var queryParameters = {};
9549 var headers = {};
9550 var form = {};
9551
9552 path = path.replace('{pk}', parameters['pk']);
9553
9554 if (parameters['pk'] === undefined) {
9555 deferred.reject(new Error('Missing required path parameter: pk'));
9556 return deferred.promise;
9557 }
9558
9559 if (parameters['enacted'] !== undefined) {
9560 form['enacted'] = parameters['enacted'];
9561 }
9562
9563 if (parameters['policed'] !== undefined) {
9564 form['policed'] = parameters['policed'];
9565 }
9566
9567 if (parameters['backend_register'] !== undefined) {
9568 form['backend_register'] = parameters['backend_register'];
9569 }
9570
9571 if (parameters['backend_status'] !== undefined) {
9572 form['backend_status'] = parameters['backend_status'];
9573 }
9574
9575 if (parameters['backend_status'] === undefined) {
9576 deferred.reject(new Error('Missing required form parameter: backend_status'));
9577 return deferred.promise;
9578 }
9579
9580 if (parameters['deleted'] !== undefined) {
9581 form['deleted'] = parameters['deleted'];
9582 }
9583
9584 if (parameters['write_protect'] !== undefined) {
9585 form['write_protect'] = parameters['write_protect'];
9586 }
9587
9588 if (parameters['lazy_blocked'] !== undefined) {
9589 form['lazy_blocked'] = parameters['lazy_blocked'];
9590 }
9591
9592 if (parameters['no_sync'] !== undefined) {
9593 form['no_sync'] = parameters['no_sync'];
9594 }
9595
9596 if (parameters['name'] !== undefined) {
9597 form['name'] = parameters['name'];
9598 }
9599
9600 if (parameters['name'] === undefined) {
9601 deferred.reject(new Error('Missing required form parameter: name'));
9602 return deferred.promise;
9603 }
9604
9605 if (parameters.$queryParameters) {
9606 Object.keys(parameters.$queryParameters)
9607 .forEach(function(parameterName) {
9608 var parameter = parameters.$queryParameters[parameterName];
9609 queryParameters[parameterName] = parameter;
9610 });
9611 }
9612
9613 var url = domain + path;
9614 var options = {
9615 timeout: parameters.$timeout,
9616 method: 'PUT',
9617 url: url,
9618 params: queryParameters,
9619 data: body,
9620 headers: headers
9621 };
9622 if (Object.keys(form).length > 0) {
9623 options.data = form;
9624 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9625 options.transformRequest = xos.transformRequest;
9626 }
9627 $http(options)
9628 .success(function(data, status, headers, config) {
9629 deferred.resolve(data);
9630 if (parameters.$cache !== undefined) {
9631 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9632 }
9633 })
9634 .error(function(data, status, headers, config) {
9635 deferred.reject({
9636 status: status,
9637 headers: headers,
9638 config: config,
9639 body: data
9640 });
9641 });
9642
9643 return deferred.promise;
9644 };
9645 /**
9646 *
9647 * @method
9648 * @name xos#Project_Detail_PATCH
9649 * @param {string} pk -
9650 * @param {string} enacted -
9651 * @param {string} policed -
9652 * @param {string} backend_register -
9653 * @param {string} backend_status -
9654 * @param {boolean} deleted -
9655 * @param {boolean} write_protect -
9656 * @param {boolean} lazy_blocked -
9657 * @param {boolean} no_sync -
9658 * @param {string} name - Name of Project
9659 *
9660 */
9661 xos.prototype.Project_Detail_PATCH = function(parameters) {
9662 if (parameters === undefined) {
9663 parameters = {};
9664 }
9665 var deferred = $q.defer();
9666
9667 var domain = this.domain;
9668 var path = '/xos/projects/{pk}/';
9669
9670 var body;
9671 var queryParameters = {};
9672 var headers = {};
9673 var form = {};
9674
9675 path = path.replace('{pk}', parameters['pk']);
9676
9677 if (parameters['pk'] === undefined) {
9678 deferred.reject(new Error('Missing required path parameter: pk'));
9679 return deferred.promise;
9680 }
9681
9682 if (parameters['enacted'] !== undefined) {
9683 form['enacted'] = parameters['enacted'];
9684 }
9685
9686 if (parameters['policed'] !== undefined) {
9687 form['policed'] = parameters['policed'];
9688 }
9689
9690 if (parameters['backend_register'] !== undefined) {
9691 form['backend_register'] = parameters['backend_register'];
9692 }
9693
9694 if (parameters['backend_status'] !== undefined) {
9695 form['backend_status'] = parameters['backend_status'];
9696 }
9697
9698 if (parameters['deleted'] !== undefined) {
9699 form['deleted'] = parameters['deleted'];
9700 }
9701
9702 if (parameters['write_protect'] !== undefined) {
9703 form['write_protect'] = parameters['write_protect'];
9704 }
9705
9706 if (parameters['lazy_blocked'] !== undefined) {
9707 form['lazy_blocked'] = parameters['lazy_blocked'];
9708 }
9709
9710 if (parameters['no_sync'] !== undefined) {
9711 form['no_sync'] = parameters['no_sync'];
9712 }
9713
9714 if (parameters['name'] !== undefined) {
9715 form['name'] = parameters['name'];
9716 }
9717
9718 if (parameters.$queryParameters) {
9719 Object.keys(parameters.$queryParameters)
9720 .forEach(function(parameterName) {
9721 var parameter = parameters.$queryParameters[parameterName];
9722 queryParameters[parameterName] = parameter;
9723 });
9724 }
9725
9726 var url = domain + path;
9727 var options = {
9728 timeout: parameters.$timeout,
9729 method: 'PATCH',
9730 url: url,
9731 params: queryParameters,
9732 data: body,
9733 headers: headers
9734 };
9735 if (Object.keys(form).length > 0) {
9736 options.data = form;
9737 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9738 options.transformRequest = xos.transformRequest;
9739 }
9740 $http(options)
9741 .success(function(data, status, headers, config) {
9742 deferred.resolve(data);
9743 if (parameters.$cache !== undefined) {
9744 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9745 }
9746 })
9747 .error(function(data, status, headers, config) {
9748 deferred.reject({
9749 status: status,
9750 headers: headers,
9751 config: config,
9752 body: data
9753 });
9754 });
9755
9756 return deferred.promise;
9757 };
9758 /**
9759 *
9760 * @method
9761 * @name xos#Project_Detail_DELETE
9762 * @param {string} pk -
9763 *
9764 */
9765 xos.prototype.Project_Detail_DELETE = function(parameters) {
9766 if (parameters === undefined) {
9767 parameters = {};
9768 }
9769 var deferred = $q.defer();
9770
9771 var domain = this.domain;
9772 var path = '/xos/projects/{pk}/';
9773
9774 var body;
9775 var queryParameters = {};
9776 var headers = {};
9777 var form = {};
9778
9779 path = path.replace('{pk}', parameters['pk']);
9780
9781 if (parameters['pk'] === undefined) {
9782 deferred.reject(new Error('Missing required path parameter: pk'));
9783 return deferred.promise;
9784 }
9785
9786 if (parameters.$queryParameters) {
9787 Object.keys(parameters.$queryParameters)
9788 .forEach(function(parameterName) {
9789 var parameter = parameters.$queryParameters[parameterName];
9790 queryParameters[parameterName] = parameter;
9791 });
9792 }
9793
9794 var url = domain + path;
9795 var options = {
9796 timeout: parameters.$timeout,
9797 method: 'DELETE',
9798 url: url,
9799 params: queryParameters,
9800 data: body,
9801 headers: headers
9802 };
9803 if (Object.keys(form).length > 0) {
9804 options.data = form;
9805 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9806 options.transformRequest = xos.transformRequest;
9807 }
9808 $http(options)
9809 .success(function(data, status, headers, config) {
9810 deferred.resolve(data);
9811 if (parameters.$cache !== undefined) {
9812 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9813 }
9814 })
9815 .error(function(data, status, headers, config) {
9816 deferred.reject({
9817 status: status,
9818 headers: headers,
9819 config: config,
9820 body: data
9821 });
9822 });
9823
9824 return deferred.promise;
9825 };
9826 /**
9827 *
9828 * @method
9829 * @name xos#Slice_List_GET
9830 *
9831 */
9832 xos.prototype.Slice_List_GET = function(parameters) {
9833 if (parameters === undefined) {
9834 parameters = {};
9835 }
9836 var deferred = $q.defer();
9837
9838 var domain = this.domain;
9839 var path = '/xos/slices/';
9840
9841 var body;
9842 var queryParameters = {};
9843 var headers = {};
9844 var form = {};
9845
9846 if (parameters.$queryParameters) {
9847 Object.keys(parameters.$queryParameters)
9848 .forEach(function(parameterName) {
9849 var parameter = parameters.$queryParameters[parameterName];
9850 queryParameters[parameterName] = parameter;
9851 });
9852 }
9853
9854 var url = domain + path;
9855 var cached = parameters.$cache && parameters.$cache.get(url);
9856 if (cached !== undefined && parameters.$refresh !== true) {
9857 deferred.resolve(cached);
9858 return deferred.promise;
9859 }
9860 var options = {
9861 timeout: parameters.$timeout,
9862 method: 'GET',
9863 url: url,
9864 params: queryParameters,
9865 data: body,
9866 headers: headers
9867 };
9868 if (Object.keys(form).length > 0) {
9869 options.data = form;
9870 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
9871 options.transformRequest = xos.transformRequest;
9872 }
9873 $http(options)
9874 .success(function(data, status, headers, config) {
9875 deferred.resolve(data);
9876 if (parameters.$cache !== undefined) {
9877 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
9878 }
9879 })
9880 .error(function(data, status, headers, config) {
9881 deferred.reject({
9882 status: status,
9883 headers: headers,
9884 config: config,
9885 body: data
9886 });
9887 });
9888
9889 return deferred.promise;
9890 };
9891 /**
9892 *
9893 * @method
9894 * @name xos#Slice_List_POST
9895 * @param {string} enacted -
9896 * @param {string} policed -
9897 * @param {string} backend_register -
9898 * @param {string} backend_status -
9899 * @param {boolean} deleted -
9900 * @param {boolean} write_protect -
9901 * @param {boolean} lazy_blocked -
9902 * @param {boolean} no_sync -
9903 * @param {string} name - The Name of the Slice
9904 * @param {boolean} enabled - Status for this Slice
9905 * @param {boolean} omf_friendly -
9906 * @param {string} description - High level description of the slice and expected activities
9907 * @param {string} slice_url -
9908 * @param {string} site - The Site this Slice belongs to
9909 * @param {integer} max_instances -
9910 * @param {string} service -
9911 * @param {string} network -
9912 * @param {string} serviceClass -
9913 * @param {string} creator -
9914 * @param {string} default_flavor -
9915 * @param {string} default_image -
9916 * @param {string} mount_data_sets -
9917 *
9918 */
9919 xos.prototype.Slice_List_POST = function(parameters) {
9920 if (parameters === undefined) {
9921 parameters = {};
9922 }
9923 var deferred = $q.defer();
9924
9925 var domain = this.domain;
9926 var path = '/xos/slices/';
9927
9928 var body;
9929 var queryParameters = {};
9930 var headers = {};
9931 var form = {};
9932
9933 if (parameters['enacted'] !== undefined) {
9934 form['enacted'] = parameters['enacted'];
9935 }
9936
9937 if (parameters['policed'] !== undefined) {
9938 form['policed'] = parameters['policed'];
9939 }
9940
9941 if (parameters['backend_register'] !== undefined) {
9942 form['backend_register'] = parameters['backend_register'];
9943 }
9944
9945 if (parameters['backend_status'] !== undefined) {
9946 form['backend_status'] = parameters['backend_status'];
9947 }
9948
9949 if (parameters['backend_status'] === undefined) {
9950 deferred.reject(new Error('Missing required form parameter: backend_status'));
9951 return deferred.promise;
9952 }
9953
9954 if (parameters['deleted'] !== undefined) {
9955 form['deleted'] = parameters['deleted'];
9956 }
9957
9958 if (parameters['write_protect'] !== undefined) {
9959 form['write_protect'] = parameters['write_protect'];
9960 }
9961
9962 if (parameters['lazy_blocked'] !== undefined) {
9963 form['lazy_blocked'] = parameters['lazy_blocked'];
9964 }
9965
9966 if (parameters['no_sync'] !== undefined) {
9967 form['no_sync'] = parameters['no_sync'];
9968 }
9969
9970 if (parameters['name'] !== undefined) {
9971 form['name'] = parameters['name'];
9972 }
9973
9974 if (parameters['name'] === undefined) {
9975 deferred.reject(new Error('Missing required form parameter: name'));
9976 return deferred.promise;
9977 }
9978
9979 if (parameters['enabled'] !== undefined) {
9980 form['enabled'] = parameters['enabled'];
9981 }
9982
9983 if (parameters['omf_friendly'] !== undefined) {
9984 form['omf_friendly'] = parameters['omf_friendly'];
9985 }
9986
9987 if (parameters['description'] !== undefined) {
9988 form['description'] = parameters['description'];
9989 }
9990
9991 if (parameters['slice_url'] !== undefined) {
9992 form['slice_url'] = parameters['slice_url'];
9993 }
9994
9995 if (parameters['site'] !== undefined) {
9996 form['site'] = parameters['site'];
9997 }
9998
9999 if (parameters['site'] === undefined) {
10000 deferred.reject(new Error('Missing required form parameter: site'));
10001 return deferred.promise;
10002 }
10003
10004 if (parameters['max_instances'] !== undefined) {
10005 form['max_instances'] = parameters['max_instances'];
10006 }
10007
10008 if (parameters['max_instances'] === undefined) {
10009 deferred.reject(new Error('Missing required form parameter: max_instances'));
10010 return deferred.promise;
10011 }
10012
10013 if (parameters['service'] !== undefined) {
10014 form['service'] = parameters['service'];
10015 }
10016
10017 if (parameters['network'] !== undefined) {
10018 form['network'] = parameters['network'];
10019 }
10020
10021 if (parameters['serviceClass'] !== undefined) {
10022 form['serviceClass'] = parameters['serviceClass'];
10023 }
10024
10025 if (parameters['creator'] !== undefined) {
10026 form['creator'] = parameters['creator'];
10027 }
10028
10029 if (parameters['default_flavor'] !== undefined) {
10030 form['default_flavor'] = parameters['default_flavor'];
10031 }
10032
10033 if (parameters['default_image'] !== undefined) {
10034 form['default_image'] = parameters['default_image'];
10035 }
10036
10037 if (parameters['mount_data_sets'] !== undefined) {
10038 form['mount_data_sets'] = parameters['mount_data_sets'];
10039 }
10040
10041 if (parameters.$queryParameters) {
10042 Object.keys(parameters.$queryParameters)
10043 .forEach(function(parameterName) {
10044 var parameter = parameters.$queryParameters[parameterName];
10045 queryParameters[parameterName] = parameter;
10046 });
10047 }
10048
10049 var url = domain + path;
10050 var options = {
10051 timeout: parameters.$timeout,
10052 method: 'POST',
10053 url: url,
10054 params: queryParameters,
10055 data: body,
10056 headers: headers
10057 };
10058 if (Object.keys(form).length > 0) {
10059 options.data = form;
10060 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10061 options.transformRequest = xos.transformRequest;
10062 }
10063 $http(options)
10064 .success(function(data, status, headers, config) {
10065 deferred.resolve(data);
10066 if (parameters.$cache !== undefined) {
10067 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10068 }
10069 })
10070 .error(function(data, status, headers, config) {
10071 deferred.reject({
10072 status: status,
10073 headers: headers,
10074 config: config,
10075 body: data
10076 });
10077 });
10078
10079 return deferred.promise;
10080 };
10081 /**
10082 *
10083 * @method
10084 * @name xos#Slice_Detail_GET
10085 * @param {string} pk -
10086 *
10087 */
10088 xos.prototype.Slice_Detail_GET = function(parameters) {
10089 if (parameters === undefined) {
10090 parameters = {};
10091 }
10092 var deferred = $q.defer();
10093
10094 var domain = this.domain;
10095 var path = '/xos/slices/{pk}/';
10096
10097 var body;
10098 var queryParameters = {};
10099 var headers = {};
10100 var form = {};
10101
10102 path = path.replace('{pk}', parameters['pk']);
10103
10104 if (parameters['pk'] === undefined) {
10105 deferred.reject(new Error('Missing required path parameter: pk'));
10106 return deferred.promise;
10107 }
10108
10109 if (parameters.$queryParameters) {
10110 Object.keys(parameters.$queryParameters)
10111 .forEach(function(parameterName) {
10112 var parameter = parameters.$queryParameters[parameterName];
10113 queryParameters[parameterName] = parameter;
10114 });
10115 }
10116
10117 var url = domain + path;
10118 var cached = parameters.$cache && parameters.$cache.get(url);
10119 if (cached !== undefined && parameters.$refresh !== true) {
10120 deferred.resolve(cached);
10121 return deferred.promise;
10122 }
10123 var options = {
10124 timeout: parameters.$timeout,
10125 method: 'GET',
10126 url: url,
10127 params: queryParameters,
10128 data: body,
10129 headers: headers
10130 };
10131 if (Object.keys(form).length > 0) {
10132 options.data = form;
10133 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10134 options.transformRequest = xos.transformRequest;
10135 }
10136 $http(options)
10137 .success(function(data, status, headers, config) {
10138 deferred.resolve(data);
10139 if (parameters.$cache !== undefined) {
10140 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10141 }
10142 })
10143 .error(function(data, status, headers, config) {
10144 deferred.reject({
10145 status: status,
10146 headers: headers,
10147 config: config,
10148 body: data
10149 });
10150 });
10151
10152 return deferred.promise;
10153 };
10154 /**
10155 *
10156 * @method
10157 * @name xos#Slice_Detail_PUT
10158 * @param {string} pk -
10159 * @param {string} enacted -
10160 * @param {string} policed -
10161 * @param {string} backend_register -
10162 * @param {string} backend_status -
10163 * @param {boolean} deleted -
10164 * @param {boolean} write_protect -
10165 * @param {boolean} lazy_blocked -
10166 * @param {boolean} no_sync -
10167 * @param {string} name - The Name of the Slice
10168 * @param {boolean} enabled - Status for this Slice
10169 * @param {boolean} omf_friendly -
10170 * @param {string} description - High level description of the slice and expected activities
10171 * @param {string} slice_url -
10172 * @param {string} site - The Site this Slice belongs to
10173 * @param {integer} max_instances -
10174 * @param {string} service -
10175 * @param {string} network -
10176 * @param {string} serviceClass -
10177 * @param {string} creator -
10178 * @param {string} default_flavor -
10179 * @param {string} default_image -
10180 * @param {string} mount_data_sets -
10181 *
10182 */
10183 xos.prototype.Slice_Detail_PUT = function(parameters) {
10184 if (parameters === undefined) {
10185 parameters = {};
10186 }
10187 var deferred = $q.defer();
10188
10189 var domain = this.domain;
10190 var path = '/xos/slices/{pk}/';
10191
10192 var body;
10193 var queryParameters = {};
10194 var headers = {};
10195 var form = {};
10196
10197 path = path.replace('{pk}', parameters['pk']);
10198
10199 if (parameters['pk'] === undefined) {
10200 deferred.reject(new Error('Missing required path parameter: pk'));
10201 return deferred.promise;
10202 }
10203
10204 if (parameters['enacted'] !== undefined) {
10205 form['enacted'] = parameters['enacted'];
10206 }
10207
10208 if (parameters['policed'] !== undefined) {
10209 form['policed'] = parameters['policed'];
10210 }
10211
10212 if (parameters['backend_register'] !== undefined) {
10213 form['backend_register'] = parameters['backend_register'];
10214 }
10215
10216 if (parameters['backend_status'] !== undefined) {
10217 form['backend_status'] = parameters['backend_status'];
10218 }
10219
10220 if (parameters['backend_status'] === undefined) {
10221 deferred.reject(new Error('Missing required form parameter: backend_status'));
10222 return deferred.promise;
10223 }
10224
10225 if (parameters['deleted'] !== undefined) {
10226 form['deleted'] = parameters['deleted'];
10227 }
10228
10229 if (parameters['write_protect'] !== undefined) {
10230 form['write_protect'] = parameters['write_protect'];
10231 }
10232
10233 if (parameters['lazy_blocked'] !== undefined) {
10234 form['lazy_blocked'] = parameters['lazy_blocked'];
10235 }
10236
10237 if (parameters['no_sync'] !== undefined) {
10238 form['no_sync'] = parameters['no_sync'];
10239 }
10240
10241 if (parameters['name'] !== undefined) {
10242 form['name'] = parameters['name'];
10243 }
10244
10245 if (parameters['name'] === undefined) {
10246 deferred.reject(new Error('Missing required form parameter: name'));
10247 return deferred.promise;
10248 }
10249
10250 if (parameters['enabled'] !== undefined) {
10251 form['enabled'] = parameters['enabled'];
10252 }
10253
10254 if (parameters['omf_friendly'] !== undefined) {
10255 form['omf_friendly'] = parameters['omf_friendly'];
10256 }
10257
10258 if (parameters['description'] !== undefined) {
10259 form['description'] = parameters['description'];
10260 }
10261
10262 if (parameters['slice_url'] !== undefined) {
10263 form['slice_url'] = parameters['slice_url'];
10264 }
10265
10266 if (parameters['site'] !== undefined) {
10267 form['site'] = parameters['site'];
10268 }
10269
10270 if (parameters['site'] === undefined) {
10271 deferred.reject(new Error('Missing required form parameter: site'));
10272 return deferred.promise;
10273 }
10274
10275 if (parameters['max_instances'] !== undefined) {
10276 form['max_instances'] = parameters['max_instances'];
10277 }
10278
10279 if (parameters['max_instances'] === undefined) {
10280 deferred.reject(new Error('Missing required form parameter: max_instances'));
10281 return deferred.promise;
10282 }
10283
10284 if (parameters['service'] !== undefined) {
10285 form['service'] = parameters['service'];
10286 }
10287
10288 if (parameters['network'] !== undefined) {
10289 form['network'] = parameters['network'];
10290 }
10291
10292 if (parameters['serviceClass'] !== undefined) {
10293 form['serviceClass'] = parameters['serviceClass'];
10294 }
10295
10296 if (parameters['creator'] !== undefined) {
10297 form['creator'] = parameters['creator'];
10298 }
10299
10300 if (parameters['default_flavor'] !== undefined) {
10301 form['default_flavor'] = parameters['default_flavor'];
10302 }
10303
10304 if (parameters['default_image'] !== undefined) {
10305 form['default_image'] = parameters['default_image'];
10306 }
10307
10308 if (parameters['mount_data_sets'] !== undefined) {
10309 form['mount_data_sets'] = parameters['mount_data_sets'];
10310 }
10311
10312 if (parameters.$queryParameters) {
10313 Object.keys(parameters.$queryParameters)
10314 .forEach(function(parameterName) {
10315 var parameter = parameters.$queryParameters[parameterName];
10316 queryParameters[parameterName] = parameter;
10317 });
10318 }
10319
10320 var url = domain + path;
10321 var options = {
10322 timeout: parameters.$timeout,
10323 method: 'PUT',
10324 url: url,
10325 params: queryParameters,
10326 data: body,
10327 headers: headers
10328 };
10329 if (Object.keys(form).length > 0) {
10330 options.data = form;
10331 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10332 options.transformRequest = xos.transformRequest;
10333 }
10334 $http(options)
10335 .success(function(data, status, headers, config) {
10336 deferred.resolve(data);
10337 if (parameters.$cache !== undefined) {
10338 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10339 }
10340 })
10341 .error(function(data, status, headers, config) {
10342 deferred.reject({
10343 status: status,
10344 headers: headers,
10345 config: config,
10346 body: data
10347 });
10348 });
10349
10350 return deferred.promise;
10351 };
10352 /**
10353 *
10354 * @method
10355 * @name xos#Slice_Detail_PATCH
10356 * @param {string} pk -
10357 * @param {string} enacted -
10358 * @param {string} policed -
10359 * @param {string} backend_register -
10360 * @param {string} backend_status -
10361 * @param {boolean} deleted -
10362 * @param {boolean} write_protect -
10363 * @param {boolean} lazy_blocked -
10364 * @param {boolean} no_sync -
10365 * @param {string} name - The Name of the Slice
10366 * @param {boolean} enabled - Status for this Slice
10367 * @param {boolean} omf_friendly -
10368 * @param {string} description - High level description of the slice and expected activities
10369 * @param {string} slice_url -
10370 * @param {string} site - The Site this Slice belongs to
10371 * @param {integer} max_instances -
10372 * @param {string} service -
10373 * @param {string} network -
10374 * @param {string} serviceClass -
10375 * @param {string} creator -
10376 * @param {string} default_flavor -
10377 * @param {string} default_image -
10378 * @param {string} mount_data_sets -
10379 *
10380 */
10381 xos.prototype.Slice_Detail_PATCH = function(parameters) {
10382 if (parameters === undefined) {
10383 parameters = {};
10384 }
10385 var deferred = $q.defer();
10386
10387 var domain = this.domain;
10388 var path = '/xos/slices/{pk}/';
10389
10390 var body;
10391 var queryParameters = {};
10392 var headers = {};
10393 var form = {};
10394
10395 path = path.replace('{pk}', parameters['pk']);
10396
10397 if (parameters['pk'] === undefined) {
10398 deferred.reject(new Error('Missing required path parameter: pk'));
10399 return deferred.promise;
10400 }
10401
10402 if (parameters['enacted'] !== undefined) {
10403 form['enacted'] = parameters['enacted'];
10404 }
10405
10406 if (parameters['policed'] !== undefined) {
10407 form['policed'] = parameters['policed'];
10408 }
10409
10410 if (parameters['backend_register'] !== undefined) {
10411 form['backend_register'] = parameters['backend_register'];
10412 }
10413
10414 if (parameters['backend_status'] !== undefined) {
10415 form['backend_status'] = parameters['backend_status'];
10416 }
10417
10418 if (parameters['deleted'] !== undefined) {
10419 form['deleted'] = parameters['deleted'];
10420 }
10421
10422 if (parameters['write_protect'] !== undefined) {
10423 form['write_protect'] = parameters['write_protect'];
10424 }
10425
10426 if (parameters['lazy_blocked'] !== undefined) {
10427 form['lazy_blocked'] = parameters['lazy_blocked'];
10428 }
10429
10430 if (parameters['no_sync'] !== undefined) {
10431 form['no_sync'] = parameters['no_sync'];
10432 }
10433
10434 if (parameters['name'] !== undefined) {
10435 form['name'] = parameters['name'];
10436 }
10437
10438 if (parameters['enabled'] !== undefined) {
10439 form['enabled'] = parameters['enabled'];
10440 }
10441
10442 if (parameters['omf_friendly'] !== undefined) {
10443 form['omf_friendly'] = parameters['omf_friendly'];
10444 }
10445
10446 if (parameters['description'] !== undefined) {
10447 form['description'] = parameters['description'];
10448 }
10449
10450 if (parameters['slice_url'] !== undefined) {
10451 form['slice_url'] = parameters['slice_url'];
10452 }
10453
10454 if (parameters['site'] !== undefined) {
10455 form['site'] = parameters['site'];
10456 }
10457
10458 if (parameters['max_instances'] !== undefined) {
10459 form['max_instances'] = parameters['max_instances'];
10460 }
10461
10462 if (parameters['service'] !== undefined) {
10463 form['service'] = parameters['service'];
10464 }
10465
10466 if (parameters['network'] !== undefined) {
10467 form['network'] = parameters['network'];
10468 }
10469
10470 if (parameters['serviceClass'] !== undefined) {
10471 form['serviceClass'] = parameters['serviceClass'];
10472 }
10473
10474 if (parameters['creator'] !== undefined) {
10475 form['creator'] = parameters['creator'];
10476 }
10477
10478 if (parameters['default_flavor'] !== undefined) {
10479 form['default_flavor'] = parameters['default_flavor'];
10480 }
10481
10482 if (parameters['default_image'] !== undefined) {
10483 form['default_image'] = parameters['default_image'];
10484 }
10485
10486 if (parameters['mount_data_sets'] !== undefined) {
10487 form['mount_data_sets'] = parameters['mount_data_sets'];
10488 }
10489
10490 if (parameters.$queryParameters) {
10491 Object.keys(parameters.$queryParameters)
10492 .forEach(function(parameterName) {
10493 var parameter = parameters.$queryParameters[parameterName];
10494 queryParameters[parameterName] = parameter;
10495 });
10496 }
10497
10498 var url = domain + path;
10499 var options = {
10500 timeout: parameters.$timeout,
10501 method: 'PATCH',
10502 url: url,
10503 params: queryParameters,
10504 data: body,
10505 headers: headers
10506 };
10507 if (Object.keys(form).length > 0) {
10508 options.data = form;
10509 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10510 options.transformRequest = xos.transformRequest;
10511 }
10512 $http(options)
10513 .success(function(data, status, headers, config) {
10514 deferred.resolve(data);
10515 if (parameters.$cache !== undefined) {
10516 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10517 }
10518 })
10519 .error(function(data, status, headers, config) {
10520 deferred.reject({
10521 status: status,
10522 headers: headers,
10523 config: config,
10524 body: data
10525 });
10526 });
10527
10528 return deferred.promise;
10529 };
10530 /**
10531 *
10532 * @method
10533 * @name xos#Slice_Detail_DELETE
10534 * @param {string} pk -
10535 *
10536 */
10537 xos.prototype.Slice_Detail_DELETE = function(parameters) {
10538 if (parameters === undefined) {
10539 parameters = {};
10540 }
10541 var deferred = $q.defer();
10542
10543 var domain = this.domain;
10544 var path = '/xos/slices/{pk}/';
10545
10546 var body;
10547 var queryParameters = {};
10548 var headers = {};
10549 var form = {};
10550
10551 path = path.replace('{pk}', parameters['pk']);
10552
10553 if (parameters['pk'] === undefined) {
10554 deferred.reject(new Error('Missing required path parameter: pk'));
10555 return deferred.promise;
10556 }
10557
10558 if (parameters.$queryParameters) {
10559 Object.keys(parameters.$queryParameters)
10560 .forEach(function(parameterName) {
10561 var parameter = parameters.$queryParameters[parameterName];
10562 queryParameters[parameterName] = parameter;
10563 });
10564 }
10565
10566 var url = domain + path;
10567 var options = {
10568 timeout: parameters.$timeout,
10569 method: 'DELETE',
10570 url: url,
10571 params: queryParameters,
10572 data: body,
10573 headers: headers
10574 };
10575 if (Object.keys(form).length > 0) {
10576 options.data = form;
10577 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10578 options.transformRequest = xos.transformRequest;
10579 }
10580 $http(options)
10581 .success(function(data, status, headers, config) {
10582 deferred.resolve(data);
10583 if (parameters.$cache !== undefined) {
10584 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10585 }
10586 })
10587 .error(function(data, status, headers, config) {
10588 deferred.reject({
10589 status: status,
10590 headers: headers,
10591 config: config,
10592 body: data
10593 });
10594 });
10595
10596 return deferred.promise;
10597 };
10598 /**
10599 *
10600 * @method
10601 * @name xos#Network_List_GET
10602 *
10603 */
10604 xos.prototype.Network_List_GET = function(parameters) {
10605 if (parameters === undefined) {
10606 parameters = {};
10607 }
10608 var deferred = $q.defer();
10609
10610 var domain = this.domain;
10611 var path = '/xos/networks/';
10612
10613 var body;
10614 var queryParameters = {};
10615 var headers = {};
10616 var form = {};
10617
10618 if (parameters.$queryParameters) {
10619 Object.keys(parameters.$queryParameters)
10620 .forEach(function(parameterName) {
10621 var parameter = parameters.$queryParameters[parameterName];
10622 queryParameters[parameterName] = parameter;
10623 });
10624 }
10625
10626 var url = domain + path;
10627 var cached = parameters.$cache && parameters.$cache.get(url);
10628 if (cached !== undefined && parameters.$refresh !== true) {
10629 deferred.resolve(cached);
10630 return deferred.promise;
10631 }
10632 var options = {
10633 timeout: parameters.$timeout,
10634 method: 'GET',
10635 url: url,
10636 params: queryParameters,
10637 data: body,
10638 headers: headers
10639 };
10640 if (Object.keys(form).length > 0) {
10641 options.data = form;
10642 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10643 options.transformRequest = xos.transformRequest;
10644 }
10645 $http(options)
10646 .success(function(data, status, headers, config) {
10647 deferred.resolve(data);
10648 if (parameters.$cache !== undefined) {
10649 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10650 }
10651 })
10652 .error(function(data, status, headers, config) {
10653 deferred.reject({
10654 status: status,
10655 headers: headers,
10656 config: config,
10657 body: data
10658 });
10659 });
10660
10661 return deferred.promise;
10662 };
10663 /**
10664 *
10665 * @method
10666 * @name xos#Network_List_POST
10667 * @param {string} enacted -
10668 * @param {string} policed -
10669 * @param {string} backend_register -
10670 * @param {string} backend_status -
10671 * @param {boolean} deleted -
10672 * @param {boolean} write_protect -
10673 * @param {boolean} lazy_blocked -
10674 * @param {boolean} no_sync -
10675 * @param {string} name -
10676 * @param {string} template -
10677 * @param {string} subnet -
10678 * @param {string} ports -
10679 * @param {string} labels -
10680 * @param {string} owner - Slice that owns control of this Network
10681 * @param {integer} guaranteed_bandwidth -
10682 * @param {boolean} permit_all_slices -
10683 * @param {string} topology_parameters -
10684 * @param {string} controller_url -
10685 * @param {string} controller_parameters -
10686 * @param {string} network_id - Quantum network
10687 * @param {string} router_id - Quantum router id
10688 * @param {string} subnet_id - Quantum subnet id
10689 * @param {boolean} autoconnect - This network can be autoconnected to the slice that owns it
10690 *
10691 */
10692 xos.prototype.Network_List_POST = function(parameters) {
10693 if (parameters === undefined) {
10694 parameters = {};
10695 }
10696 var deferred = $q.defer();
10697
10698 var domain = this.domain;
10699 var path = '/xos/networks/';
10700
10701 var body;
10702 var queryParameters = {};
10703 var headers = {};
10704 var form = {};
10705
10706 if (parameters['enacted'] !== undefined) {
10707 form['enacted'] = parameters['enacted'];
10708 }
10709
10710 if (parameters['policed'] !== undefined) {
10711 form['policed'] = parameters['policed'];
10712 }
10713
10714 if (parameters['backend_register'] !== undefined) {
10715 form['backend_register'] = parameters['backend_register'];
10716 }
10717
10718 if (parameters['backend_status'] !== undefined) {
10719 form['backend_status'] = parameters['backend_status'];
10720 }
10721
10722 if (parameters['backend_status'] === undefined) {
10723 deferred.reject(new Error('Missing required form parameter: backend_status'));
10724 return deferred.promise;
10725 }
10726
10727 if (parameters['deleted'] !== undefined) {
10728 form['deleted'] = parameters['deleted'];
10729 }
10730
10731 if (parameters['write_protect'] !== undefined) {
10732 form['write_protect'] = parameters['write_protect'];
10733 }
10734
10735 if (parameters['lazy_blocked'] !== undefined) {
10736 form['lazy_blocked'] = parameters['lazy_blocked'];
10737 }
10738
10739 if (parameters['no_sync'] !== undefined) {
10740 form['no_sync'] = parameters['no_sync'];
10741 }
10742
10743 if (parameters['name'] !== undefined) {
10744 form['name'] = parameters['name'];
10745 }
10746
10747 if (parameters['name'] === undefined) {
10748 deferred.reject(new Error('Missing required form parameter: name'));
10749 return deferred.promise;
10750 }
10751
10752 if (parameters['template'] !== undefined) {
10753 form['template'] = parameters['template'];
10754 }
10755
10756 if (parameters['template'] === undefined) {
10757 deferred.reject(new Error('Missing required form parameter: template'));
10758 return deferred.promise;
10759 }
10760
10761 if (parameters['subnet'] !== undefined) {
10762 form['subnet'] = parameters['subnet'];
10763 }
10764
10765 if (parameters['ports'] !== undefined) {
10766 form['ports'] = parameters['ports'];
10767 }
10768
10769 if (parameters['labels'] !== undefined) {
10770 form['labels'] = parameters['labels'];
10771 }
10772
10773 if (parameters['owner'] !== undefined) {
10774 form['owner'] = parameters['owner'];
10775 }
10776
10777 if (parameters['owner'] === undefined) {
10778 deferred.reject(new Error('Missing required form parameter: owner'));
10779 return deferred.promise;
10780 }
10781
10782 if (parameters['guaranteed_bandwidth'] !== undefined) {
10783 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
10784 }
10785
10786 if (parameters['guaranteed_bandwidth'] === undefined) {
10787 deferred.reject(new Error('Missing required form parameter: guaranteed_bandwidth'));
10788 return deferred.promise;
10789 }
10790
10791 if (parameters['permit_all_slices'] !== undefined) {
10792 form['permit_all_slices'] = parameters['permit_all_slices'];
10793 }
10794
10795 if (parameters['topology_parameters'] !== undefined) {
10796 form['topology_parameters'] = parameters['topology_parameters'];
10797 }
10798
10799 if (parameters['controller_url'] !== undefined) {
10800 form['controller_url'] = parameters['controller_url'];
10801 }
10802
10803 if (parameters['controller_parameters'] !== undefined) {
10804 form['controller_parameters'] = parameters['controller_parameters'];
10805 }
10806
10807 if (parameters['network_id'] !== undefined) {
10808 form['network_id'] = parameters['network_id'];
10809 }
10810
10811 if (parameters['router_id'] !== undefined) {
10812 form['router_id'] = parameters['router_id'];
10813 }
10814
10815 if (parameters['subnet_id'] !== undefined) {
10816 form['subnet_id'] = parameters['subnet_id'];
10817 }
10818
10819 if (parameters['autoconnect'] !== undefined) {
10820 form['autoconnect'] = parameters['autoconnect'];
10821 }
10822
10823 if (parameters.$queryParameters) {
10824 Object.keys(parameters.$queryParameters)
10825 .forEach(function(parameterName) {
10826 var parameter = parameters.$queryParameters[parameterName];
10827 queryParameters[parameterName] = parameter;
10828 });
10829 }
10830
10831 var url = domain + path;
10832 var options = {
10833 timeout: parameters.$timeout,
10834 method: 'POST',
10835 url: url,
10836 params: queryParameters,
10837 data: body,
10838 headers: headers
10839 };
10840 if (Object.keys(form).length > 0) {
10841 options.data = form;
10842 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10843 options.transformRequest = xos.transformRequest;
10844 }
10845 $http(options)
10846 .success(function(data, status, headers, config) {
10847 deferred.resolve(data);
10848 if (parameters.$cache !== undefined) {
10849 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10850 }
10851 })
10852 .error(function(data, status, headers, config) {
10853 deferred.reject({
10854 status: status,
10855 headers: headers,
10856 config: config,
10857 body: data
10858 });
10859 });
10860
10861 return deferred.promise;
10862 };
10863 /**
10864 *
10865 * @method
10866 * @name xos#Network_Detail_GET
10867 * @param {string} pk -
10868 *
10869 */
10870 xos.prototype.Network_Detail_GET = function(parameters) {
10871 if (parameters === undefined) {
10872 parameters = {};
10873 }
10874 var deferred = $q.defer();
10875
10876 var domain = this.domain;
10877 var path = '/xos/networks/{pk}/';
10878
10879 var body;
10880 var queryParameters = {};
10881 var headers = {};
10882 var form = {};
10883
10884 path = path.replace('{pk}', parameters['pk']);
10885
10886 if (parameters['pk'] === undefined) {
10887 deferred.reject(new Error('Missing required path parameter: pk'));
10888 return deferred.promise;
10889 }
10890
10891 if (parameters.$queryParameters) {
10892 Object.keys(parameters.$queryParameters)
10893 .forEach(function(parameterName) {
10894 var parameter = parameters.$queryParameters[parameterName];
10895 queryParameters[parameterName] = parameter;
10896 });
10897 }
10898
10899 var url = domain + path;
10900 var cached = parameters.$cache && parameters.$cache.get(url);
10901 if (cached !== undefined && parameters.$refresh !== true) {
10902 deferred.resolve(cached);
10903 return deferred.promise;
10904 }
10905 var options = {
10906 timeout: parameters.$timeout,
10907 method: 'GET',
10908 url: url,
10909 params: queryParameters,
10910 data: body,
10911 headers: headers
10912 };
10913 if (Object.keys(form).length > 0) {
10914 options.data = form;
10915 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
10916 options.transformRequest = xos.transformRequest;
10917 }
10918 $http(options)
10919 .success(function(data, status, headers, config) {
10920 deferred.resolve(data);
10921 if (parameters.$cache !== undefined) {
10922 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
10923 }
10924 })
10925 .error(function(data, status, headers, config) {
10926 deferred.reject({
10927 status: status,
10928 headers: headers,
10929 config: config,
10930 body: data
10931 });
10932 });
10933
10934 return deferred.promise;
10935 };
10936 /**
10937 *
10938 * @method
10939 * @name xos#Network_Detail_PUT
10940 * @param {string} pk -
10941 * @param {string} enacted -
10942 * @param {string} policed -
10943 * @param {string} backend_register -
10944 * @param {string} backend_status -
10945 * @param {boolean} deleted -
10946 * @param {boolean} write_protect -
10947 * @param {boolean} lazy_blocked -
10948 * @param {boolean} no_sync -
10949 * @param {string} name -
10950 * @param {string} template -
10951 * @param {string} subnet -
10952 * @param {string} ports -
10953 * @param {string} labels -
10954 * @param {string} owner - Slice that owns control of this Network
10955 * @param {integer} guaranteed_bandwidth -
10956 * @param {boolean} permit_all_slices -
10957 * @param {string} topology_parameters -
10958 * @param {string} controller_url -
10959 * @param {string} controller_parameters -
10960 * @param {string} network_id - Quantum network
10961 * @param {string} router_id - Quantum router id
10962 * @param {string} subnet_id - Quantum subnet id
10963 * @param {boolean} autoconnect - This network can be autoconnected to the slice that owns it
10964 *
10965 */
10966 xos.prototype.Network_Detail_PUT = function(parameters) {
10967 if (parameters === undefined) {
10968 parameters = {};
10969 }
10970 var deferred = $q.defer();
10971
10972 var domain = this.domain;
10973 var path = '/xos/networks/{pk}/';
10974
10975 var body;
10976 var queryParameters = {};
10977 var headers = {};
10978 var form = {};
10979
10980 path = path.replace('{pk}', parameters['pk']);
10981
10982 if (parameters['pk'] === undefined) {
10983 deferred.reject(new Error('Missing required path parameter: pk'));
10984 return deferred.promise;
10985 }
10986
10987 if (parameters['enacted'] !== undefined) {
10988 form['enacted'] = parameters['enacted'];
10989 }
10990
10991 if (parameters['policed'] !== undefined) {
10992 form['policed'] = parameters['policed'];
10993 }
10994
10995 if (parameters['backend_register'] !== undefined) {
10996 form['backend_register'] = parameters['backend_register'];
10997 }
10998
10999 if (parameters['backend_status'] !== undefined) {
11000 form['backend_status'] = parameters['backend_status'];
11001 }
11002
11003 if (parameters['backend_status'] === undefined) {
11004 deferred.reject(new Error('Missing required form parameter: backend_status'));
11005 return deferred.promise;
11006 }
11007
11008 if (parameters['deleted'] !== undefined) {
11009 form['deleted'] = parameters['deleted'];
11010 }
11011
11012 if (parameters['write_protect'] !== undefined) {
11013 form['write_protect'] = parameters['write_protect'];
11014 }
11015
11016 if (parameters['lazy_blocked'] !== undefined) {
11017 form['lazy_blocked'] = parameters['lazy_blocked'];
11018 }
11019
11020 if (parameters['no_sync'] !== undefined) {
11021 form['no_sync'] = parameters['no_sync'];
11022 }
11023
11024 if (parameters['name'] !== undefined) {
11025 form['name'] = parameters['name'];
11026 }
11027
11028 if (parameters['name'] === undefined) {
11029 deferred.reject(new Error('Missing required form parameter: name'));
11030 return deferred.promise;
11031 }
11032
11033 if (parameters['template'] !== undefined) {
11034 form['template'] = parameters['template'];
11035 }
11036
11037 if (parameters['template'] === undefined) {
11038 deferred.reject(new Error('Missing required form parameter: template'));
11039 return deferred.promise;
11040 }
11041
11042 if (parameters['subnet'] !== undefined) {
11043 form['subnet'] = parameters['subnet'];
11044 }
11045
11046 if (parameters['ports'] !== undefined) {
11047 form['ports'] = parameters['ports'];
11048 }
11049
11050 if (parameters['labels'] !== undefined) {
11051 form['labels'] = parameters['labels'];
11052 }
11053
11054 if (parameters['owner'] !== undefined) {
11055 form['owner'] = parameters['owner'];
11056 }
11057
11058 if (parameters['owner'] === undefined) {
11059 deferred.reject(new Error('Missing required form parameter: owner'));
11060 return deferred.promise;
11061 }
11062
11063 if (parameters['guaranteed_bandwidth'] !== undefined) {
11064 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
11065 }
11066
11067 if (parameters['guaranteed_bandwidth'] === undefined) {
11068 deferred.reject(new Error('Missing required form parameter: guaranteed_bandwidth'));
11069 return deferred.promise;
11070 }
11071
11072 if (parameters['permit_all_slices'] !== undefined) {
11073 form['permit_all_slices'] = parameters['permit_all_slices'];
11074 }
11075
11076 if (parameters['topology_parameters'] !== undefined) {
11077 form['topology_parameters'] = parameters['topology_parameters'];
11078 }
11079
11080 if (parameters['controller_url'] !== undefined) {
11081 form['controller_url'] = parameters['controller_url'];
11082 }
11083
11084 if (parameters['controller_parameters'] !== undefined) {
11085 form['controller_parameters'] = parameters['controller_parameters'];
11086 }
11087
11088 if (parameters['network_id'] !== undefined) {
11089 form['network_id'] = parameters['network_id'];
11090 }
11091
11092 if (parameters['router_id'] !== undefined) {
11093 form['router_id'] = parameters['router_id'];
11094 }
11095
11096 if (parameters['subnet_id'] !== undefined) {
11097 form['subnet_id'] = parameters['subnet_id'];
11098 }
11099
11100 if (parameters['autoconnect'] !== undefined) {
11101 form['autoconnect'] = parameters['autoconnect'];
11102 }
11103
11104 if (parameters.$queryParameters) {
11105 Object.keys(parameters.$queryParameters)
11106 .forEach(function(parameterName) {
11107 var parameter = parameters.$queryParameters[parameterName];
11108 queryParameters[parameterName] = parameter;
11109 });
11110 }
11111
11112 var url = domain + path;
11113 var options = {
11114 timeout: parameters.$timeout,
11115 method: 'PUT',
11116 url: url,
11117 params: queryParameters,
11118 data: body,
11119 headers: headers
11120 };
11121 if (Object.keys(form).length > 0) {
11122 options.data = form;
11123 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11124 options.transformRequest = xos.transformRequest;
11125 }
11126 $http(options)
11127 .success(function(data, status, headers, config) {
11128 deferred.resolve(data);
11129 if (parameters.$cache !== undefined) {
11130 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11131 }
11132 })
11133 .error(function(data, status, headers, config) {
11134 deferred.reject({
11135 status: status,
11136 headers: headers,
11137 config: config,
11138 body: data
11139 });
11140 });
11141
11142 return deferred.promise;
11143 };
11144 /**
11145 *
11146 * @method
11147 * @name xos#Network_Detail_PATCH
11148 * @param {string} pk -
11149 * @param {string} enacted -
11150 * @param {string} policed -
11151 * @param {string} backend_register -
11152 * @param {string} backend_status -
11153 * @param {boolean} deleted -
11154 * @param {boolean} write_protect -
11155 * @param {boolean} lazy_blocked -
11156 * @param {boolean} no_sync -
11157 * @param {string} name -
11158 * @param {string} template -
11159 * @param {string} subnet -
11160 * @param {string} ports -
11161 * @param {string} labels -
11162 * @param {string} owner - Slice that owns control of this Network
11163 * @param {integer} guaranteed_bandwidth -
11164 * @param {boolean} permit_all_slices -
11165 * @param {string} topology_parameters -
11166 * @param {string} controller_url -
11167 * @param {string} controller_parameters -
11168 * @param {string} network_id - Quantum network
11169 * @param {string} router_id - Quantum router id
11170 * @param {string} subnet_id - Quantum subnet id
11171 * @param {boolean} autoconnect - This network can be autoconnected to the slice that owns it
11172 *
11173 */
11174 xos.prototype.Network_Detail_PATCH = function(parameters) {
11175 if (parameters === undefined) {
11176 parameters = {};
11177 }
11178 var deferred = $q.defer();
11179
11180 var domain = this.domain;
11181 var path = '/xos/networks/{pk}/';
11182
11183 var body;
11184 var queryParameters = {};
11185 var headers = {};
11186 var form = {};
11187
11188 path = path.replace('{pk}', parameters['pk']);
11189
11190 if (parameters['pk'] === undefined) {
11191 deferred.reject(new Error('Missing required path parameter: pk'));
11192 return deferred.promise;
11193 }
11194
11195 if (parameters['enacted'] !== undefined) {
11196 form['enacted'] = parameters['enacted'];
11197 }
11198
11199 if (parameters['policed'] !== undefined) {
11200 form['policed'] = parameters['policed'];
11201 }
11202
11203 if (parameters['backend_register'] !== undefined) {
11204 form['backend_register'] = parameters['backend_register'];
11205 }
11206
11207 if (parameters['backend_status'] !== undefined) {
11208 form['backend_status'] = parameters['backend_status'];
11209 }
11210
11211 if (parameters['deleted'] !== undefined) {
11212 form['deleted'] = parameters['deleted'];
11213 }
11214
11215 if (parameters['write_protect'] !== undefined) {
11216 form['write_protect'] = parameters['write_protect'];
11217 }
11218
11219 if (parameters['lazy_blocked'] !== undefined) {
11220 form['lazy_blocked'] = parameters['lazy_blocked'];
11221 }
11222
11223 if (parameters['no_sync'] !== undefined) {
11224 form['no_sync'] = parameters['no_sync'];
11225 }
11226
11227 if (parameters['name'] !== undefined) {
11228 form['name'] = parameters['name'];
11229 }
11230
11231 if (parameters['template'] !== undefined) {
11232 form['template'] = parameters['template'];
11233 }
11234
11235 if (parameters['subnet'] !== undefined) {
11236 form['subnet'] = parameters['subnet'];
11237 }
11238
11239 if (parameters['ports'] !== undefined) {
11240 form['ports'] = parameters['ports'];
11241 }
11242
11243 if (parameters['labels'] !== undefined) {
11244 form['labels'] = parameters['labels'];
11245 }
11246
11247 if (parameters['owner'] !== undefined) {
11248 form['owner'] = parameters['owner'];
11249 }
11250
11251 if (parameters['guaranteed_bandwidth'] !== undefined) {
11252 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
11253 }
11254
11255 if (parameters['permit_all_slices'] !== undefined) {
11256 form['permit_all_slices'] = parameters['permit_all_slices'];
11257 }
11258
11259 if (parameters['topology_parameters'] !== undefined) {
11260 form['topology_parameters'] = parameters['topology_parameters'];
11261 }
11262
11263 if (parameters['controller_url'] !== undefined) {
11264 form['controller_url'] = parameters['controller_url'];
11265 }
11266
11267 if (parameters['controller_parameters'] !== undefined) {
11268 form['controller_parameters'] = parameters['controller_parameters'];
11269 }
11270
11271 if (parameters['network_id'] !== undefined) {
11272 form['network_id'] = parameters['network_id'];
11273 }
11274
11275 if (parameters['router_id'] !== undefined) {
11276 form['router_id'] = parameters['router_id'];
11277 }
11278
11279 if (parameters['subnet_id'] !== undefined) {
11280 form['subnet_id'] = parameters['subnet_id'];
11281 }
11282
11283 if (parameters['autoconnect'] !== undefined) {
11284 form['autoconnect'] = parameters['autoconnect'];
11285 }
11286
11287 if (parameters.$queryParameters) {
11288 Object.keys(parameters.$queryParameters)
11289 .forEach(function(parameterName) {
11290 var parameter = parameters.$queryParameters[parameterName];
11291 queryParameters[parameterName] = parameter;
11292 });
11293 }
11294
11295 var url = domain + path;
11296 var options = {
11297 timeout: parameters.$timeout,
11298 method: 'PATCH',
11299 url: url,
11300 params: queryParameters,
11301 data: body,
11302 headers: headers
11303 };
11304 if (Object.keys(form).length > 0) {
11305 options.data = form;
11306 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11307 options.transformRequest = xos.transformRequest;
11308 }
11309 $http(options)
11310 .success(function(data, status, headers, config) {
11311 deferred.resolve(data);
11312 if (parameters.$cache !== undefined) {
11313 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11314 }
11315 })
11316 .error(function(data, status, headers, config) {
11317 deferred.reject({
11318 status: status,
11319 headers: headers,
11320 config: config,
11321 body: data
11322 });
11323 });
11324
11325 return deferred.promise;
11326 };
11327 /**
11328 *
11329 * @method
11330 * @name xos#Network_Detail_DELETE
11331 * @param {string} pk -
11332 *
11333 */
11334 xos.prototype.Network_Detail_DELETE = function(parameters) {
11335 if (parameters === undefined) {
11336 parameters = {};
11337 }
11338 var deferred = $q.defer();
11339
11340 var domain = this.domain;
11341 var path = '/xos/networks/{pk}/';
11342
11343 var body;
11344 var queryParameters = {};
11345 var headers = {};
11346 var form = {};
11347
11348 path = path.replace('{pk}', parameters['pk']);
11349
11350 if (parameters['pk'] === undefined) {
11351 deferred.reject(new Error('Missing required path parameter: pk'));
11352 return deferred.promise;
11353 }
11354
11355 if (parameters.$queryParameters) {
11356 Object.keys(parameters.$queryParameters)
11357 .forEach(function(parameterName) {
11358 var parameter = parameters.$queryParameters[parameterName];
11359 queryParameters[parameterName] = parameter;
11360 });
11361 }
11362
11363 var url = domain + path;
11364 var options = {
11365 timeout: parameters.$timeout,
11366 method: 'DELETE',
11367 url: url,
11368 params: queryParameters,
11369 data: body,
11370 headers: headers
11371 };
11372 if (Object.keys(form).length > 0) {
11373 options.data = form;
11374 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11375 options.transformRequest = xos.transformRequest;
11376 }
11377 $http(options)
11378 .success(function(data, status, headers, config) {
11379 deferred.resolve(data);
11380 if (parameters.$cache !== undefined) {
11381 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11382 }
11383 })
11384 .error(function(data, status, headers, config) {
11385 deferred.reject({
11386 status: status,
11387 headers: headers,
11388 config: config,
11389 body: data
11390 });
11391 });
11392
11393 return deferred.promise;
11394 };
11395 /**
11396 *
11397 * @method
11398 * @name xos#Service_List_GET
11399 *
11400 */
11401 xos.prototype.Service_List_GET = function(parameters) {
11402 if (parameters === undefined) {
11403 parameters = {};
11404 }
11405 var deferred = $q.defer();
11406
11407 var domain = this.domain;
11408 var path = '/xos/services/';
11409
11410 var body;
11411 var queryParameters = {};
11412 var headers = {};
11413 var form = {};
11414
11415 if (parameters.$queryParameters) {
11416 Object.keys(parameters.$queryParameters)
11417 .forEach(function(parameterName) {
11418 var parameter = parameters.$queryParameters[parameterName];
11419 queryParameters[parameterName] = parameter;
11420 });
11421 }
11422
11423 var url = domain + path;
11424 var cached = parameters.$cache && parameters.$cache.get(url);
11425 if (cached !== undefined && parameters.$refresh !== true) {
11426 deferred.resolve(cached);
11427 return deferred.promise;
11428 }
11429 var options = {
11430 timeout: parameters.$timeout,
11431 method: 'GET',
11432 url: url,
11433 params: queryParameters,
11434 data: body,
11435 headers: headers
11436 };
11437 if (Object.keys(form).length > 0) {
11438 options.data = form;
11439 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11440 options.transformRequest = xos.transformRequest;
11441 }
11442 $http(options)
11443 .success(function(data, status, headers, config) {
11444 deferred.resolve(data);
11445 if (parameters.$cache !== undefined) {
11446 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11447 }
11448 })
11449 .error(function(data, status, headers, config) {
11450 deferred.reject({
11451 status: status,
11452 headers: headers,
11453 config: config,
11454 body: data
11455 });
11456 });
11457
11458 return deferred.promise;
11459 };
11460 /**
11461 *
11462 * @method
11463 * @name xos#Service_List_POST
11464 * @param {string} enacted -
11465 * @param {string} policed -
11466 * @param {string} backend_register -
11467 * @param {string} backend_status -
11468 * @param {boolean} deleted -
11469 * @param {boolean} write_protect -
11470 * @param {boolean} lazy_blocked -
11471 * @param {boolean} no_sync -
11472 * @param {string} description - Description of Service
11473 * @param {boolean} enabled -
11474 * @param {string} kind - Kind of service
11475 * @param {string} name - Service Name
11476 * @param {string} versionNumber - Version of Service Definition
11477 * @param {boolean} published -
11478 * @param {string} view_url -
11479 * @param {string} icon_url -
11480 * @param {string} public_key - Public key string
11481 * @param {string} service_specific_id -
11482 * @param {string} service_specific_attribute -
11483 *
11484 */
11485 xos.prototype.Service_List_POST = function(parameters) {
11486 if (parameters === undefined) {
11487 parameters = {};
11488 }
11489 var deferred = $q.defer();
11490
11491 var domain = this.domain;
11492 var path = '/xos/services/';
11493
11494 var body;
11495 var queryParameters = {};
11496 var headers = {};
11497 var form = {};
11498
11499 if (parameters['enacted'] !== undefined) {
11500 form['enacted'] = parameters['enacted'];
11501 }
11502
11503 if (parameters['policed'] !== undefined) {
11504 form['policed'] = parameters['policed'];
11505 }
11506
11507 if (parameters['backend_register'] !== undefined) {
11508 form['backend_register'] = parameters['backend_register'];
11509 }
11510
11511 if (parameters['backend_status'] !== undefined) {
11512 form['backend_status'] = parameters['backend_status'];
11513 }
11514
11515 if (parameters['backend_status'] === undefined) {
11516 deferred.reject(new Error('Missing required form parameter: backend_status'));
11517 return deferred.promise;
11518 }
11519
11520 if (parameters['deleted'] !== undefined) {
11521 form['deleted'] = parameters['deleted'];
11522 }
11523
11524 if (parameters['write_protect'] !== undefined) {
11525 form['write_protect'] = parameters['write_protect'];
11526 }
11527
11528 if (parameters['lazy_blocked'] !== undefined) {
11529 form['lazy_blocked'] = parameters['lazy_blocked'];
11530 }
11531
11532 if (parameters['no_sync'] !== undefined) {
11533 form['no_sync'] = parameters['no_sync'];
11534 }
11535
11536 if (parameters['description'] !== undefined) {
11537 form['description'] = parameters['description'];
11538 }
11539
11540 if (parameters['enabled'] !== undefined) {
11541 form['enabled'] = parameters['enabled'];
11542 }
11543
11544 if (parameters['kind'] !== undefined) {
11545 form['kind'] = parameters['kind'];
11546 }
11547
11548 if (parameters['kind'] === undefined) {
11549 deferred.reject(new Error('Missing required form parameter: kind'));
11550 return deferred.promise;
11551 }
11552
11553 if (parameters['name'] !== undefined) {
11554 form['name'] = parameters['name'];
11555 }
11556
11557 if (parameters['name'] === undefined) {
11558 deferred.reject(new Error('Missing required form parameter: name'));
11559 return deferred.promise;
11560 }
11561
11562 if (parameters['versionNumber'] !== undefined) {
11563 form['versionNumber'] = parameters['versionNumber'];
11564 }
11565
11566 if (parameters['versionNumber'] === undefined) {
11567 deferred.reject(new Error('Missing required form parameter: versionNumber'));
11568 return deferred.promise;
11569 }
11570
11571 if (parameters['published'] !== undefined) {
11572 form['published'] = parameters['published'];
11573 }
11574
11575 if (parameters['view_url'] !== undefined) {
11576 form['view_url'] = parameters['view_url'];
11577 }
11578
11579 if (parameters['icon_url'] !== undefined) {
11580 form['icon_url'] = parameters['icon_url'];
11581 }
11582
11583 if (parameters['public_key'] !== undefined) {
11584 form['public_key'] = parameters['public_key'];
11585 }
11586
11587 if (parameters['service_specific_id'] !== undefined) {
11588 form['service_specific_id'] = parameters['service_specific_id'];
11589 }
11590
11591 if (parameters['service_specific_attribute'] !== undefined) {
11592 form['service_specific_attribute'] = parameters['service_specific_attribute'];
11593 }
11594
11595 if (parameters.$queryParameters) {
11596 Object.keys(parameters.$queryParameters)
11597 .forEach(function(parameterName) {
11598 var parameter = parameters.$queryParameters[parameterName];
11599 queryParameters[parameterName] = parameter;
11600 });
11601 }
11602
11603 var url = domain + path;
11604 var options = {
11605 timeout: parameters.$timeout,
11606 method: 'POST',
11607 url: url,
11608 params: queryParameters,
11609 data: body,
11610 headers: headers
11611 };
11612 if (Object.keys(form).length > 0) {
11613 options.data = form;
11614 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11615 options.transformRequest = xos.transformRequest;
11616 }
11617 $http(options)
11618 .success(function(data, status, headers, config) {
11619 deferred.resolve(data);
11620 if (parameters.$cache !== undefined) {
11621 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11622 }
11623 })
11624 .error(function(data, status, headers, config) {
11625 deferred.reject({
11626 status: status,
11627 headers: headers,
11628 config: config,
11629 body: data
11630 });
11631 });
11632
11633 return deferred.promise;
11634 };
11635 /**
11636 *
11637 * @method
11638 * @name xos#Service_Detail_GET
11639 * @param {string} pk -
11640 *
11641 */
11642 xos.prototype.Service_Detail_GET = function(parameters) {
11643 if (parameters === undefined) {
11644 parameters = {};
11645 }
11646 var deferred = $q.defer();
11647
11648 var domain = this.domain;
11649 var path = '/xos/services/{pk}/';
11650
11651 var body;
11652 var queryParameters = {};
11653 var headers = {};
11654 var form = {};
11655
11656 path = path.replace('{pk}', parameters['pk']);
11657
11658 if (parameters['pk'] === undefined) {
11659 deferred.reject(new Error('Missing required path parameter: pk'));
11660 return deferred.promise;
11661 }
11662
11663 if (parameters.$queryParameters) {
11664 Object.keys(parameters.$queryParameters)
11665 .forEach(function(parameterName) {
11666 var parameter = parameters.$queryParameters[parameterName];
11667 queryParameters[parameterName] = parameter;
11668 });
11669 }
11670
11671 var url = domain + path;
11672 var cached = parameters.$cache && parameters.$cache.get(url);
11673 if (cached !== undefined && parameters.$refresh !== true) {
11674 deferred.resolve(cached);
11675 return deferred.promise;
11676 }
11677 var options = {
11678 timeout: parameters.$timeout,
11679 method: 'GET',
11680 url: url,
11681 params: queryParameters,
11682 data: body,
11683 headers: headers
11684 };
11685 if (Object.keys(form).length > 0) {
11686 options.data = form;
11687 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11688 options.transformRequest = xos.transformRequest;
11689 }
11690 $http(options)
11691 .success(function(data, status, headers, config) {
11692 deferred.resolve(data);
11693 if (parameters.$cache !== undefined) {
11694 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11695 }
11696 })
11697 .error(function(data, status, headers, config) {
11698 deferred.reject({
11699 status: status,
11700 headers: headers,
11701 config: config,
11702 body: data
11703 });
11704 });
11705
11706 return deferred.promise;
11707 };
11708 /**
11709 *
11710 * @method
11711 * @name xos#Service_Detail_PUT
11712 * @param {string} pk -
11713 * @param {string} enacted -
11714 * @param {string} policed -
11715 * @param {string} backend_register -
11716 * @param {string} backend_status -
11717 * @param {boolean} deleted -
11718 * @param {boolean} write_protect -
11719 * @param {boolean} lazy_blocked -
11720 * @param {boolean} no_sync -
11721 * @param {string} description - Description of Service
11722 * @param {boolean} enabled -
11723 * @param {string} kind - Kind of service
11724 * @param {string} name - Service Name
11725 * @param {string} versionNumber - Version of Service Definition
11726 * @param {boolean} published -
11727 * @param {string} view_url -
11728 * @param {string} icon_url -
11729 * @param {string} public_key - Public key string
11730 * @param {string} service_specific_id -
11731 * @param {string} service_specific_attribute -
11732 *
11733 */
11734 xos.prototype.Service_Detail_PUT = function(parameters) {
11735 if (parameters === undefined) {
11736 parameters = {};
11737 }
11738 var deferred = $q.defer();
11739
11740 var domain = this.domain;
11741 var path = '/xos/services/{pk}/';
11742
11743 var body;
11744 var queryParameters = {};
11745 var headers = {};
11746 var form = {};
11747
11748 path = path.replace('{pk}', parameters['pk']);
11749
11750 if (parameters['pk'] === undefined) {
11751 deferred.reject(new Error('Missing required path parameter: pk'));
11752 return deferred.promise;
11753 }
11754
11755 if (parameters['enacted'] !== undefined) {
11756 form['enacted'] = parameters['enacted'];
11757 }
11758
11759 if (parameters['policed'] !== undefined) {
11760 form['policed'] = parameters['policed'];
11761 }
11762
11763 if (parameters['backend_register'] !== undefined) {
11764 form['backend_register'] = parameters['backend_register'];
11765 }
11766
11767 if (parameters['backend_status'] !== undefined) {
11768 form['backend_status'] = parameters['backend_status'];
11769 }
11770
11771 if (parameters['backend_status'] === undefined) {
11772 deferred.reject(new Error('Missing required form parameter: backend_status'));
11773 return deferred.promise;
11774 }
11775
11776 if (parameters['deleted'] !== undefined) {
11777 form['deleted'] = parameters['deleted'];
11778 }
11779
11780 if (parameters['write_protect'] !== undefined) {
11781 form['write_protect'] = parameters['write_protect'];
11782 }
11783
11784 if (parameters['lazy_blocked'] !== undefined) {
11785 form['lazy_blocked'] = parameters['lazy_blocked'];
11786 }
11787
11788 if (parameters['no_sync'] !== undefined) {
11789 form['no_sync'] = parameters['no_sync'];
11790 }
11791
11792 if (parameters['description'] !== undefined) {
11793 form['description'] = parameters['description'];
11794 }
11795
11796 if (parameters['enabled'] !== undefined) {
11797 form['enabled'] = parameters['enabled'];
11798 }
11799
11800 if (parameters['kind'] !== undefined) {
11801 form['kind'] = parameters['kind'];
11802 }
11803
11804 if (parameters['kind'] === undefined) {
11805 deferred.reject(new Error('Missing required form parameter: kind'));
11806 return deferred.promise;
11807 }
11808
11809 if (parameters['name'] !== undefined) {
11810 form['name'] = parameters['name'];
11811 }
11812
11813 if (parameters['name'] === undefined) {
11814 deferred.reject(new Error('Missing required form parameter: name'));
11815 return deferred.promise;
11816 }
11817
11818 if (parameters['versionNumber'] !== undefined) {
11819 form['versionNumber'] = parameters['versionNumber'];
11820 }
11821
11822 if (parameters['versionNumber'] === undefined) {
11823 deferred.reject(new Error('Missing required form parameter: versionNumber'));
11824 return deferred.promise;
11825 }
11826
11827 if (parameters['published'] !== undefined) {
11828 form['published'] = parameters['published'];
11829 }
11830
11831 if (parameters['view_url'] !== undefined) {
11832 form['view_url'] = parameters['view_url'];
11833 }
11834
11835 if (parameters['icon_url'] !== undefined) {
11836 form['icon_url'] = parameters['icon_url'];
11837 }
11838
11839 if (parameters['public_key'] !== undefined) {
11840 form['public_key'] = parameters['public_key'];
11841 }
11842
11843 if (parameters['service_specific_id'] !== undefined) {
11844 form['service_specific_id'] = parameters['service_specific_id'];
11845 }
11846
11847 if (parameters['service_specific_attribute'] !== undefined) {
11848 form['service_specific_attribute'] = parameters['service_specific_attribute'];
11849 }
11850
11851 if (parameters.$queryParameters) {
11852 Object.keys(parameters.$queryParameters)
11853 .forEach(function(parameterName) {
11854 var parameter = parameters.$queryParameters[parameterName];
11855 queryParameters[parameterName] = parameter;
11856 });
11857 }
11858
11859 var url = domain + path;
11860 var options = {
11861 timeout: parameters.$timeout,
11862 method: 'PUT',
11863 url: url,
11864 params: queryParameters,
11865 data: body,
11866 headers: headers
11867 };
11868 if (Object.keys(form).length > 0) {
11869 options.data = form;
11870 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
11871 options.transformRequest = xos.transformRequest;
11872 }
11873 $http(options)
11874 .success(function(data, status, headers, config) {
11875 deferred.resolve(data);
11876 if (parameters.$cache !== undefined) {
11877 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
11878 }
11879 })
11880 .error(function(data, status, headers, config) {
11881 deferred.reject({
11882 status: status,
11883 headers: headers,
11884 config: config,
11885 body: data
11886 });
11887 });
11888
11889 return deferred.promise;
11890 };
11891 /**
11892 *
11893 * @method
11894 * @name xos#Service_Detail_PATCH
11895 * @param {string} pk -
11896 * @param {string} enacted -
11897 * @param {string} policed -
11898 * @param {string} backend_register -
11899 * @param {string} backend_status -
11900 * @param {boolean} deleted -
11901 * @param {boolean} write_protect -
11902 * @param {boolean} lazy_blocked -
11903 * @param {boolean} no_sync -
11904 * @param {string} description - Description of Service
11905 * @param {boolean} enabled -
11906 * @param {string} kind - Kind of service
11907 * @param {string} name - Service Name
11908 * @param {string} versionNumber - Version of Service Definition
11909 * @param {boolean} published -
11910 * @param {string} view_url -
11911 * @param {string} icon_url -
11912 * @param {string} public_key - Public key string
11913 * @param {string} service_specific_id -
11914 * @param {string} service_specific_attribute -
11915 *
11916 */
11917 xos.prototype.Service_Detail_PATCH = function(parameters) {
11918 if (parameters === undefined) {
11919 parameters = {};
11920 }
11921 var deferred = $q.defer();
11922
11923 var domain = this.domain;
11924 var path = '/xos/services/{pk}/';
11925
11926 var body;
11927 var queryParameters = {};
11928 var headers = {};
11929 var form = {};
11930
11931 path = path.replace('{pk}', parameters['pk']);
11932
11933 if (parameters['pk'] === undefined) {
11934 deferred.reject(new Error('Missing required path parameter: pk'));
11935 return deferred.promise;
11936 }
11937
11938 if (parameters['enacted'] !== undefined) {
11939 form['enacted'] = parameters['enacted'];
11940 }
11941
11942 if (parameters['policed'] !== undefined) {
11943 form['policed'] = parameters['policed'];
11944 }
11945
11946 if (parameters['backend_register'] !== undefined) {
11947 form['backend_register'] = parameters['backend_register'];
11948 }
11949
11950 if (parameters['backend_status'] !== undefined) {
11951 form['backend_status'] = parameters['backend_status'];
11952 }
11953
11954 if (parameters['deleted'] !== undefined) {
11955 form['deleted'] = parameters['deleted'];
11956 }
11957
11958 if (parameters['write_protect'] !== undefined) {
11959 form['write_protect'] = parameters['write_protect'];
11960 }
11961
11962 if (parameters['lazy_blocked'] !== undefined) {
11963 form['lazy_blocked'] = parameters['lazy_blocked'];
11964 }
11965
11966 if (parameters['no_sync'] !== undefined) {
11967 form['no_sync'] = parameters['no_sync'];
11968 }
11969
11970 if (parameters['description'] !== undefined) {
11971 form['description'] = parameters['description'];
11972 }
11973
11974 if (parameters['enabled'] !== undefined) {
11975 form['enabled'] = parameters['enabled'];
11976 }
11977
11978 if (parameters['kind'] !== undefined) {
11979 form['kind'] = parameters['kind'];
11980 }
11981
11982 if (parameters['name'] !== undefined) {
11983 form['name'] = parameters['name'];
11984 }
11985
11986 if (parameters['versionNumber'] !== undefined) {
11987 form['versionNumber'] = parameters['versionNumber'];
11988 }
11989
11990 if (parameters['published'] !== undefined) {
11991 form['published'] = parameters['published'];
11992 }
11993
11994 if (parameters['view_url'] !== undefined) {
11995 form['view_url'] = parameters['view_url'];
11996 }
11997
11998 if (parameters['icon_url'] !== undefined) {
11999 form['icon_url'] = parameters['icon_url'];
12000 }
12001
12002 if (parameters['public_key'] !== undefined) {
12003 form['public_key'] = parameters['public_key'];
12004 }
12005
12006 if (parameters['service_specific_id'] !== undefined) {
12007 form['service_specific_id'] = parameters['service_specific_id'];
12008 }
12009
12010 if (parameters['service_specific_attribute'] !== undefined) {
12011 form['service_specific_attribute'] = parameters['service_specific_attribute'];
12012 }
12013
12014 if (parameters.$queryParameters) {
12015 Object.keys(parameters.$queryParameters)
12016 .forEach(function(parameterName) {
12017 var parameter = parameters.$queryParameters[parameterName];
12018 queryParameters[parameterName] = parameter;
12019 });
12020 }
12021
12022 var url = domain + path;
12023 var options = {
12024 timeout: parameters.$timeout,
12025 method: 'PATCH',
12026 url: url,
12027 params: queryParameters,
12028 data: body,
12029 headers: headers
12030 };
12031 if (Object.keys(form).length > 0) {
12032 options.data = form;
12033 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12034 options.transformRequest = xos.transformRequest;
12035 }
12036 $http(options)
12037 .success(function(data, status, headers, config) {
12038 deferred.resolve(data);
12039 if (parameters.$cache !== undefined) {
12040 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12041 }
12042 })
12043 .error(function(data, status, headers, config) {
12044 deferred.reject({
12045 status: status,
12046 headers: headers,
12047 config: config,
12048 body: data
12049 });
12050 });
12051
12052 return deferred.promise;
12053 };
12054 /**
12055 *
12056 * @method
12057 * @name xos#Service_Detail_DELETE
12058 * @param {string} pk -
12059 *
12060 */
12061 xos.prototype.Service_Detail_DELETE = function(parameters) {
12062 if (parameters === undefined) {
12063 parameters = {};
12064 }
12065 var deferred = $q.defer();
12066
12067 var domain = this.domain;
12068 var path = '/xos/services/{pk}/';
12069
12070 var body;
12071 var queryParameters = {};
12072 var headers = {};
12073 var form = {};
12074
12075 path = path.replace('{pk}', parameters['pk']);
12076
12077 if (parameters['pk'] === undefined) {
12078 deferred.reject(new Error('Missing required path parameter: pk'));
12079 return deferred.promise;
12080 }
12081
12082 if (parameters.$queryParameters) {
12083 Object.keys(parameters.$queryParameters)
12084 .forEach(function(parameterName) {
12085 var parameter = parameters.$queryParameters[parameterName];
12086 queryParameters[parameterName] = parameter;
12087 });
12088 }
12089
12090 var url = domain + path;
12091 var options = {
12092 timeout: parameters.$timeout,
12093 method: 'DELETE',
12094 url: url,
12095 params: queryParameters,
12096 data: body,
12097 headers: headers
12098 };
12099 if (Object.keys(form).length > 0) {
12100 options.data = form;
12101 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12102 options.transformRequest = xos.transformRequest;
12103 }
12104 $http(options)
12105 .success(function(data, status, headers, config) {
12106 deferred.resolve(data);
12107 if (parameters.$cache !== undefined) {
12108 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12109 }
12110 })
12111 .error(function(data, status, headers, config) {
12112 deferred.reject({
12113 status: status,
12114 headers: headers,
12115 config: config,
12116 body: data
12117 });
12118 });
12119
12120 return deferred.promise;
12121 };
12122 /**
12123 *
12124 * @method
12125 * @name xos#Service_Class_List_GET
12126 *
12127 */
12128 xos.prototype.Service_Class_List_GET = function(parameters) {
12129 if (parameters === undefined) {
12130 parameters = {};
12131 }
12132 var deferred = $q.defer();
12133
12134 var domain = this.domain;
12135 var path = '/xos/serviceclasses/';
12136
12137 var body;
12138 var queryParameters = {};
12139 var headers = {};
12140 var form = {};
12141
12142 if (parameters.$queryParameters) {
12143 Object.keys(parameters.$queryParameters)
12144 .forEach(function(parameterName) {
12145 var parameter = parameters.$queryParameters[parameterName];
12146 queryParameters[parameterName] = parameter;
12147 });
12148 }
12149
12150 var url = domain + path;
12151 var cached = parameters.$cache && parameters.$cache.get(url);
12152 if (cached !== undefined && parameters.$refresh !== true) {
12153 deferred.resolve(cached);
12154 return deferred.promise;
12155 }
12156 var options = {
12157 timeout: parameters.$timeout,
12158 method: 'GET',
12159 url: url,
12160 params: queryParameters,
12161 data: body,
12162 headers: headers
12163 };
12164 if (Object.keys(form).length > 0) {
12165 options.data = form;
12166 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12167 options.transformRequest = xos.transformRequest;
12168 }
12169 $http(options)
12170 .success(function(data, status, headers, config) {
12171 deferred.resolve(data);
12172 if (parameters.$cache !== undefined) {
12173 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12174 }
12175 })
12176 .error(function(data, status, headers, config) {
12177 deferred.reject({
12178 status: status,
12179 headers: headers,
12180 config: config,
12181 body: data
12182 });
12183 });
12184
12185 return deferred.promise;
12186 };
12187 /**
12188 *
12189 * @method
12190 * @name xos#Service_Class_List_POST
12191 * @param {string} enacted -
12192 * @param {string} policed -
12193 * @param {string} backend_register -
12194 * @param {string} backend_status -
12195 * @param {boolean} deleted -
12196 * @param {boolean} write_protect -
12197 * @param {boolean} lazy_blocked -
12198 * @param {boolean} no_sync -
12199 * @param {string} name -
12200 * @param {string} description -
12201 * @param {integer} commitment -
12202 * @param {integer} membershipFee -
12203 * @param {integer} membershipFeeMonths -
12204 * @param {boolean} upgradeRequiresApproval -
12205 *
12206 */
12207 xos.prototype.Service_Class_List_POST = function(parameters) {
12208 if (parameters === undefined) {
12209 parameters = {};
12210 }
12211 var deferred = $q.defer();
12212
12213 var domain = this.domain;
12214 var path = '/xos/serviceclasses/';
12215
12216 var body;
12217 var queryParameters = {};
12218 var headers = {};
12219 var form = {};
12220
12221 if (parameters['enacted'] !== undefined) {
12222 form['enacted'] = parameters['enacted'];
12223 }
12224
12225 if (parameters['policed'] !== undefined) {
12226 form['policed'] = parameters['policed'];
12227 }
12228
12229 if (parameters['backend_register'] !== undefined) {
12230 form['backend_register'] = parameters['backend_register'];
12231 }
12232
12233 if (parameters['backend_status'] !== undefined) {
12234 form['backend_status'] = parameters['backend_status'];
12235 }
12236
12237 if (parameters['backend_status'] === undefined) {
12238 deferred.reject(new Error('Missing required form parameter: backend_status'));
12239 return deferred.promise;
12240 }
12241
12242 if (parameters['deleted'] !== undefined) {
12243 form['deleted'] = parameters['deleted'];
12244 }
12245
12246 if (parameters['write_protect'] !== undefined) {
12247 form['write_protect'] = parameters['write_protect'];
12248 }
12249
12250 if (parameters['lazy_blocked'] !== undefined) {
12251 form['lazy_blocked'] = parameters['lazy_blocked'];
12252 }
12253
12254 if (parameters['no_sync'] !== undefined) {
12255 form['no_sync'] = parameters['no_sync'];
12256 }
12257
12258 if (parameters['name'] !== undefined) {
12259 form['name'] = parameters['name'];
12260 }
12261
12262 if (parameters['name'] === undefined) {
12263 deferred.reject(new Error('Missing required form parameter: name'));
12264 return deferred.promise;
12265 }
12266
12267 if (parameters['description'] !== undefined) {
12268 form['description'] = parameters['description'];
12269 }
12270
12271 if (parameters['description'] === undefined) {
12272 deferred.reject(new Error('Missing required form parameter: description'));
12273 return deferred.promise;
12274 }
12275
12276 if (parameters['commitment'] !== undefined) {
12277 form['commitment'] = parameters['commitment'];
12278 }
12279
12280 if (parameters['commitment'] === undefined) {
12281 deferred.reject(new Error('Missing required form parameter: commitment'));
12282 return deferred.promise;
12283 }
12284
12285 if (parameters['membershipFee'] !== undefined) {
12286 form['membershipFee'] = parameters['membershipFee'];
12287 }
12288
12289 if (parameters['membershipFee'] === undefined) {
12290 deferred.reject(new Error('Missing required form parameter: membershipFee'));
12291 return deferred.promise;
12292 }
12293
12294 if (parameters['membershipFeeMonths'] !== undefined) {
12295 form['membershipFeeMonths'] = parameters['membershipFeeMonths'];
12296 }
12297
12298 if (parameters['membershipFeeMonths'] === undefined) {
12299 deferred.reject(new Error('Missing required form parameter: membershipFeeMonths'));
12300 return deferred.promise;
12301 }
12302
12303 if (parameters['upgradeRequiresApproval'] !== undefined) {
12304 form['upgradeRequiresApproval'] = parameters['upgradeRequiresApproval'];
12305 }
12306
12307 if (parameters.$queryParameters) {
12308 Object.keys(parameters.$queryParameters)
12309 .forEach(function(parameterName) {
12310 var parameter = parameters.$queryParameters[parameterName];
12311 queryParameters[parameterName] = parameter;
12312 });
12313 }
12314
12315 var url = domain + path;
12316 var options = {
12317 timeout: parameters.$timeout,
12318 method: 'POST',
12319 url: url,
12320 params: queryParameters,
12321 data: body,
12322 headers: headers
12323 };
12324 if (Object.keys(form).length > 0) {
12325 options.data = form;
12326 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12327 options.transformRequest = xos.transformRequest;
12328 }
12329 $http(options)
12330 .success(function(data, status, headers, config) {
12331 deferred.resolve(data);
12332 if (parameters.$cache !== undefined) {
12333 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12334 }
12335 })
12336 .error(function(data, status, headers, config) {
12337 deferred.reject({
12338 status: status,
12339 headers: headers,
12340 config: config,
12341 body: data
12342 });
12343 });
12344
12345 return deferred.promise;
12346 };
12347 /**
12348 *
12349 * @method
12350 * @name xos#Service_Class_Detail_GET
12351 * @param {string} pk -
12352 *
12353 */
12354 xos.prototype.Service_Class_Detail_GET = function(parameters) {
12355 if (parameters === undefined) {
12356 parameters = {};
12357 }
12358 var deferred = $q.defer();
12359
12360 var domain = this.domain;
12361 var path = '/xos/serviceclasses/{pk}/';
12362
12363 var body;
12364 var queryParameters = {};
12365 var headers = {};
12366 var form = {};
12367
12368 path = path.replace('{pk}', parameters['pk']);
12369
12370 if (parameters['pk'] === undefined) {
12371 deferred.reject(new Error('Missing required path parameter: pk'));
12372 return deferred.promise;
12373 }
12374
12375 if (parameters.$queryParameters) {
12376 Object.keys(parameters.$queryParameters)
12377 .forEach(function(parameterName) {
12378 var parameter = parameters.$queryParameters[parameterName];
12379 queryParameters[parameterName] = parameter;
12380 });
12381 }
12382
12383 var url = domain + path;
12384 var cached = parameters.$cache && parameters.$cache.get(url);
12385 if (cached !== undefined && parameters.$refresh !== true) {
12386 deferred.resolve(cached);
12387 return deferred.promise;
12388 }
12389 var options = {
12390 timeout: parameters.$timeout,
12391 method: 'GET',
12392 url: url,
12393 params: queryParameters,
12394 data: body,
12395 headers: headers
12396 };
12397 if (Object.keys(form).length > 0) {
12398 options.data = form;
12399 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12400 options.transformRequest = xos.transformRequest;
12401 }
12402 $http(options)
12403 .success(function(data, status, headers, config) {
12404 deferred.resolve(data);
12405 if (parameters.$cache !== undefined) {
12406 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12407 }
12408 })
12409 .error(function(data, status, headers, config) {
12410 deferred.reject({
12411 status: status,
12412 headers: headers,
12413 config: config,
12414 body: data
12415 });
12416 });
12417
12418 return deferred.promise;
12419 };
12420 /**
12421 *
12422 * @method
12423 * @name xos#Service_Class_Detail_PUT
12424 * @param {string} pk -
12425 * @param {string} enacted -
12426 * @param {string} policed -
12427 * @param {string} backend_register -
12428 * @param {string} backend_status -
12429 * @param {boolean} deleted -
12430 * @param {boolean} write_protect -
12431 * @param {boolean} lazy_blocked -
12432 * @param {boolean} no_sync -
12433 * @param {string} name -
12434 * @param {string} description -
12435 * @param {integer} commitment -
12436 * @param {integer} membershipFee -
12437 * @param {integer} membershipFeeMonths -
12438 * @param {boolean} upgradeRequiresApproval -
12439 *
12440 */
12441 xos.prototype.Service_Class_Detail_PUT = function(parameters) {
12442 if (parameters === undefined) {
12443 parameters = {};
12444 }
12445 var deferred = $q.defer();
12446
12447 var domain = this.domain;
12448 var path = '/xos/serviceclasses/{pk}/';
12449
12450 var body;
12451 var queryParameters = {};
12452 var headers = {};
12453 var form = {};
12454
12455 path = path.replace('{pk}', parameters['pk']);
12456
12457 if (parameters['pk'] === undefined) {
12458 deferred.reject(new Error('Missing required path parameter: pk'));
12459 return deferred.promise;
12460 }
12461
12462 if (parameters['enacted'] !== undefined) {
12463 form['enacted'] = parameters['enacted'];
12464 }
12465
12466 if (parameters['policed'] !== undefined) {
12467 form['policed'] = parameters['policed'];
12468 }
12469
12470 if (parameters['backend_register'] !== undefined) {
12471 form['backend_register'] = parameters['backend_register'];
12472 }
12473
12474 if (parameters['backend_status'] !== undefined) {
12475 form['backend_status'] = parameters['backend_status'];
12476 }
12477
12478 if (parameters['backend_status'] === undefined) {
12479 deferred.reject(new Error('Missing required form parameter: backend_status'));
12480 return deferred.promise;
12481 }
12482
12483 if (parameters['deleted'] !== undefined) {
12484 form['deleted'] = parameters['deleted'];
12485 }
12486
12487 if (parameters['write_protect'] !== undefined) {
12488 form['write_protect'] = parameters['write_protect'];
12489 }
12490
12491 if (parameters['lazy_blocked'] !== undefined) {
12492 form['lazy_blocked'] = parameters['lazy_blocked'];
12493 }
12494
12495 if (parameters['no_sync'] !== undefined) {
12496 form['no_sync'] = parameters['no_sync'];
12497 }
12498
12499 if (parameters['name'] !== undefined) {
12500 form['name'] = parameters['name'];
12501 }
12502
12503 if (parameters['name'] === undefined) {
12504 deferred.reject(new Error('Missing required form parameter: name'));
12505 return deferred.promise;
12506 }
12507
12508 if (parameters['description'] !== undefined) {
12509 form['description'] = parameters['description'];
12510 }
12511
12512 if (parameters['description'] === undefined) {
12513 deferred.reject(new Error('Missing required form parameter: description'));
12514 return deferred.promise;
12515 }
12516
12517 if (parameters['commitment'] !== undefined) {
12518 form['commitment'] = parameters['commitment'];
12519 }
12520
12521 if (parameters['commitment'] === undefined) {
12522 deferred.reject(new Error('Missing required form parameter: commitment'));
12523 return deferred.promise;
12524 }
12525
12526 if (parameters['membershipFee'] !== undefined) {
12527 form['membershipFee'] = parameters['membershipFee'];
12528 }
12529
12530 if (parameters['membershipFee'] === undefined) {
12531 deferred.reject(new Error('Missing required form parameter: membershipFee'));
12532 return deferred.promise;
12533 }
12534
12535 if (parameters['membershipFeeMonths'] !== undefined) {
12536 form['membershipFeeMonths'] = parameters['membershipFeeMonths'];
12537 }
12538
12539 if (parameters['membershipFeeMonths'] === undefined) {
12540 deferred.reject(new Error('Missing required form parameter: membershipFeeMonths'));
12541 return deferred.promise;
12542 }
12543
12544 if (parameters['upgradeRequiresApproval'] !== undefined) {
12545 form['upgradeRequiresApproval'] = parameters['upgradeRequiresApproval'];
12546 }
12547
12548 if (parameters.$queryParameters) {
12549 Object.keys(parameters.$queryParameters)
12550 .forEach(function(parameterName) {
12551 var parameter = parameters.$queryParameters[parameterName];
12552 queryParameters[parameterName] = parameter;
12553 });
12554 }
12555
12556 var url = domain + path;
12557 var options = {
12558 timeout: parameters.$timeout,
12559 method: 'PUT',
12560 url: url,
12561 params: queryParameters,
12562 data: body,
12563 headers: headers
12564 };
12565 if (Object.keys(form).length > 0) {
12566 options.data = form;
12567 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12568 options.transformRequest = xos.transformRequest;
12569 }
12570 $http(options)
12571 .success(function(data, status, headers, config) {
12572 deferred.resolve(data);
12573 if (parameters.$cache !== undefined) {
12574 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12575 }
12576 })
12577 .error(function(data, status, headers, config) {
12578 deferred.reject({
12579 status: status,
12580 headers: headers,
12581 config: config,
12582 body: data
12583 });
12584 });
12585
12586 return deferred.promise;
12587 };
12588 /**
12589 *
12590 * @method
12591 * @name xos#Service_Class_Detail_PATCH
12592 * @param {string} pk -
12593 * @param {string} enacted -
12594 * @param {string} policed -
12595 * @param {string} backend_register -
12596 * @param {string} backend_status -
12597 * @param {boolean} deleted -
12598 * @param {boolean} write_protect -
12599 * @param {boolean} lazy_blocked -
12600 * @param {boolean} no_sync -
12601 * @param {string} name -
12602 * @param {string} description -
12603 * @param {integer} commitment -
12604 * @param {integer} membershipFee -
12605 * @param {integer} membershipFeeMonths -
12606 * @param {boolean} upgradeRequiresApproval -
12607 *
12608 */
12609 xos.prototype.Service_Class_Detail_PATCH = function(parameters) {
12610 if (parameters === undefined) {
12611 parameters = {};
12612 }
12613 var deferred = $q.defer();
12614
12615 var domain = this.domain;
12616 var path = '/xos/serviceclasses/{pk}/';
12617
12618 var body;
12619 var queryParameters = {};
12620 var headers = {};
12621 var form = {};
12622
12623 path = path.replace('{pk}', parameters['pk']);
12624
12625 if (parameters['pk'] === undefined) {
12626 deferred.reject(new Error('Missing required path parameter: pk'));
12627 return deferred.promise;
12628 }
12629
12630 if (parameters['enacted'] !== undefined) {
12631 form['enacted'] = parameters['enacted'];
12632 }
12633
12634 if (parameters['policed'] !== undefined) {
12635 form['policed'] = parameters['policed'];
12636 }
12637
12638 if (parameters['backend_register'] !== undefined) {
12639 form['backend_register'] = parameters['backend_register'];
12640 }
12641
12642 if (parameters['backend_status'] !== undefined) {
12643 form['backend_status'] = parameters['backend_status'];
12644 }
12645
12646 if (parameters['deleted'] !== undefined) {
12647 form['deleted'] = parameters['deleted'];
12648 }
12649
12650 if (parameters['write_protect'] !== undefined) {
12651 form['write_protect'] = parameters['write_protect'];
12652 }
12653
12654 if (parameters['lazy_blocked'] !== undefined) {
12655 form['lazy_blocked'] = parameters['lazy_blocked'];
12656 }
12657
12658 if (parameters['no_sync'] !== undefined) {
12659 form['no_sync'] = parameters['no_sync'];
12660 }
12661
12662 if (parameters['name'] !== undefined) {
12663 form['name'] = parameters['name'];
12664 }
12665
12666 if (parameters['description'] !== undefined) {
12667 form['description'] = parameters['description'];
12668 }
12669
12670 if (parameters['commitment'] !== undefined) {
12671 form['commitment'] = parameters['commitment'];
12672 }
12673
12674 if (parameters['membershipFee'] !== undefined) {
12675 form['membershipFee'] = parameters['membershipFee'];
12676 }
12677
12678 if (parameters['membershipFeeMonths'] !== undefined) {
12679 form['membershipFeeMonths'] = parameters['membershipFeeMonths'];
12680 }
12681
12682 if (parameters['upgradeRequiresApproval'] !== undefined) {
12683 form['upgradeRequiresApproval'] = parameters['upgradeRequiresApproval'];
12684 }
12685
12686 if (parameters.$queryParameters) {
12687 Object.keys(parameters.$queryParameters)
12688 .forEach(function(parameterName) {
12689 var parameter = parameters.$queryParameters[parameterName];
12690 queryParameters[parameterName] = parameter;
12691 });
12692 }
12693
12694 var url = domain + path;
12695 var options = {
12696 timeout: parameters.$timeout,
12697 method: 'PATCH',
12698 url: url,
12699 params: queryParameters,
12700 data: body,
12701 headers: headers
12702 };
12703 if (Object.keys(form).length > 0) {
12704 options.data = form;
12705 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12706 options.transformRequest = xos.transformRequest;
12707 }
12708 $http(options)
12709 .success(function(data, status, headers, config) {
12710 deferred.resolve(data);
12711 if (parameters.$cache !== undefined) {
12712 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12713 }
12714 })
12715 .error(function(data, status, headers, config) {
12716 deferred.reject({
12717 status: status,
12718 headers: headers,
12719 config: config,
12720 body: data
12721 });
12722 });
12723
12724 return deferred.promise;
12725 };
12726 /**
12727 *
12728 * @method
12729 * @name xos#Service_Class_Detail_DELETE
12730 * @param {string} pk -
12731 *
12732 */
12733 xos.prototype.Service_Class_Detail_DELETE = function(parameters) {
12734 if (parameters === undefined) {
12735 parameters = {};
12736 }
12737 var deferred = $q.defer();
12738
12739 var domain = this.domain;
12740 var path = '/xos/serviceclasses/{pk}/';
12741
12742 var body;
12743 var queryParameters = {};
12744 var headers = {};
12745 var form = {};
12746
12747 path = path.replace('{pk}', parameters['pk']);
12748
12749 if (parameters['pk'] === undefined) {
12750 deferred.reject(new Error('Missing required path parameter: pk'));
12751 return deferred.promise;
12752 }
12753
12754 if (parameters.$queryParameters) {
12755 Object.keys(parameters.$queryParameters)
12756 .forEach(function(parameterName) {
12757 var parameter = parameters.$queryParameters[parameterName];
12758 queryParameters[parameterName] = parameter;
12759 });
12760 }
12761
12762 var url = domain + path;
12763 var options = {
12764 timeout: parameters.$timeout,
12765 method: 'DELETE',
12766 url: url,
12767 params: queryParameters,
12768 data: body,
12769 headers: headers
12770 };
12771 if (Object.keys(form).length > 0) {
12772 options.data = form;
12773 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12774 options.transformRequest = xos.transformRequest;
12775 }
12776 $http(options)
12777 .success(function(data, status, headers, config) {
12778 deferred.resolve(data);
12779 if (parameters.$cache !== undefined) {
12780 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12781 }
12782 })
12783 .error(function(data, status, headers, config) {
12784 deferred.reject({
12785 status: status,
12786 headers: headers,
12787 config: config,
12788 body: data
12789 });
12790 });
12791
12792 return deferred.promise;
12793 };
12794 /**
12795 *
12796 * @method
12797 * @name xos#Payment_List_GET
12798 *
12799 */
12800 xos.prototype.Payment_List_GET = function(parameters) {
12801 if (parameters === undefined) {
12802 parameters = {};
12803 }
12804 var deferred = $q.defer();
12805
12806 var domain = this.domain;
12807 var path = '/xos/payments/';
12808
12809 var body;
12810 var queryParameters = {};
12811 var headers = {};
12812 var form = {};
12813
12814 if (parameters.$queryParameters) {
12815 Object.keys(parameters.$queryParameters)
12816 .forEach(function(parameterName) {
12817 var parameter = parameters.$queryParameters[parameterName];
12818 queryParameters[parameterName] = parameter;
12819 });
12820 }
12821
12822 var url = domain + path;
12823 var cached = parameters.$cache && parameters.$cache.get(url);
12824 if (cached !== undefined && parameters.$refresh !== true) {
12825 deferred.resolve(cached);
12826 return deferred.promise;
12827 }
12828 var options = {
12829 timeout: parameters.$timeout,
12830 method: 'GET',
12831 url: url,
12832 params: queryParameters,
12833 data: body,
12834 headers: headers
12835 };
12836 if (Object.keys(form).length > 0) {
12837 options.data = form;
12838 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12839 options.transformRequest = xos.transformRequest;
12840 }
12841 $http(options)
12842 .success(function(data, status, headers, config) {
12843 deferred.resolve(data);
12844 if (parameters.$cache !== undefined) {
12845 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12846 }
12847 })
12848 .error(function(data, status, headers, config) {
12849 deferred.reject({
12850 status: status,
12851 headers: headers,
12852 config: config,
12853 body: data
12854 });
12855 });
12856
12857 return deferred.promise;
12858 };
12859 /**
12860 *
12861 * @method
12862 * @name xos#Payment_List_POST
12863 * @param {string} enacted -
12864 * @param {string} policed -
12865 * @param {string} backend_register -
12866 * @param {string} backend_status -
12867 * @param {boolean} deleted -
12868 * @param {boolean} write_protect -
12869 * @param {boolean} lazy_blocked -
12870 * @param {boolean} no_sync -
12871 * @param {string} account -
12872 * @param {number} amount -
12873 * @param {string} date -
12874 *
12875 */
12876 xos.prototype.Payment_List_POST = function(parameters) {
12877 if (parameters === undefined) {
12878 parameters = {};
12879 }
12880 var deferred = $q.defer();
12881
12882 var domain = this.domain;
12883 var path = '/xos/payments/';
12884
12885 var body;
12886 var queryParameters = {};
12887 var headers = {};
12888 var form = {};
12889
12890 if (parameters['enacted'] !== undefined) {
12891 form['enacted'] = parameters['enacted'];
12892 }
12893
12894 if (parameters['policed'] !== undefined) {
12895 form['policed'] = parameters['policed'];
12896 }
12897
12898 if (parameters['backend_register'] !== undefined) {
12899 form['backend_register'] = parameters['backend_register'];
12900 }
12901
12902 if (parameters['backend_status'] !== undefined) {
12903 form['backend_status'] = parameters['backend_status'];
12904 }
12905
12906 if (parameters['backend_status'] === undefined) {
12907 deferred.reject(new Error('Missing required form parameter: backend_status'));
12908 return deferred.promise;
12909 }
12910
12911 if (parameters['deleted'] !== undefined) {
12912 form['deleted'] = parameters['deleted'];
12913 }
12914
12915 if (parameters['write_protect'] !== undefined) {
12916 form['write_protect'] = parameters['write_protect'];
12917 }
12918
12919 if (parameters['lazy_blocked'] !== undefined) {
12920 form['lazy_blocked'] = parameters['lazy_blocked'];
12921 }
12922
12923 if (parameters['no_sync'] !== undefined) {
12924 form['no_sync'] = parameters['no_sync'];
12925 }
12926
12927 if (parameters['account'] !== undefined) {
12928 form['account'] = parameters['account'];
12929 }
12930
12931 if (parameters['account'] === undefined) {
12932 deferred.reject(new Error('Missing required form parameter: account'));
12933 return deferred.promise;
12934 }
12935
12936 if (parameters['amount'] !== undefined) {
12937 form['amount'] = parameters['amount'];
12938 }
12939
12940 if (parameters['amount'] === undefined) {
12941 deferred.reject(new Error('Missing required form parameter: amount'));
12942 return deferred.promise;
12943 }
12944
12945 if (parameters['date'] !== undefined) {
12946 form['date'] = parameters['date'];
12947 }
12948
12949 if (parameters['date'] === undefined) {
12950 deferred.reject(new Error('Missing required form parameter: date'));
12951 return deferred.promise;
12952 }
12953
12954 if (parameters.$queryParameters) {
12955 Object.keys(parameters.$queryParameters)
12956 .forEach(function(parameterName) {
12957 var parameter = parameters.$queryParameters[parameterName];
12958 queryParameters[parameterName] = parameter;
12959 });
12960 }
12961
12962 var url = domain + path;
12963 var options = {
12964 timeout: parameters.$timeout,
12965 method: 'POST',
12966 url: url,
12967 params: queryParameters,
12968 data: body,
12969 headers: headers
12970 };
12971 if (Object.keys(form).length > 0) {
12972 options.data = form;
12973 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
12974 options.transformRequest = xos.transformRequest;
12975 }
12976 $http(options)
12977 .success(function(data, status, headers, config) {
12978 deferred.resolve(data);
12979 if (parameters.$cache !== undefined) {
12980 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
12981 }
12982 })
12983 .error(function(data, status, headers, config) {
12984 deferred.reject({
12985 status: status,
12986 headers: headers,
12987 config: config,
12988 body: data
12989 });
12990 });
12991
12992 return deferred.promise;
12993 };
12994 /**
12995 *
12996 * @method
12997 * @name xos#Payment_Detail_GET
12998 * @param {string} pk -
12999 *
13000 */
13001 xos.prototype.Payment_Detail_GET = function(parameters) {
13002 if (parameters === undefined) {
13003 parameters = {};
13004 }
13005 var deferred = $q.defer();
13006
13007 var domain = this.domain;
13008 var path = '/xos/payments/{pk}/';
13009
13010 var body;
13011 var queryParameters = {};
13012 var headers = {};
13013 var form = {};
13014
13015 path = path.replace('{pk}', parameters['pk']);
13016
13017 if (parameters['pk'] === undefined) {
13018 deferred.reject(new Error('Missing required path parameter: pk'));
13019 return deferred.promise;
13020 }
13021
13022 if (parameters.$queryParameters) {
13023 Object.keys(parameters.$queryParameters)
13024 .forEach(function(parameterName) {
13025 var parameter = parameters.$queryParameters[parameterName];
13026 queryParameters[parameterName] = parameter;
13027 });
13028 }
13029
13030 var url = domain + path;
13031 var cached = parameters.$cache && parameters.$cache.get(url);
13032 if (cached !== undefined && parameters.$refresh !== true) {
13033 deferred.resolve(cached);
13034 return deferred.promise;
13035 }
13036 var options = {
13037 timeout: parameters.$timeout,
13038 method: 'GET',
13039 url: url,
13040 params: queryParameters,
13041 data: body,
13042 headers: headers
13043 };
13044 if (Object.keys(form).length > 0) {
13045 options.data = form;
13046 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13047 options.transformRequest = xos.transformRequest;
13048 }
13049 $http(options)
13050 .success(function(data, status, headers, config) {
13051 deferred.resolve(data);
13052 if (parameters.$cache !== undefined) {
13053 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13054 }
13055 })
13056 .error(function(data, status, headers, config) {
13057 deferred.reject({
13058 status: status,
13059 headers: headers,
13060 config: config,
13061 body: data
13062 });
13063 });
13064
13065 return deferred.promise;
13066 };
13067 /**
13068 *
13069 * @method
13070 * @name xos#Payment_Detail_PUT
13071 * @param {string} pk -
13072 * @param {string} enacted -
13073 * @param {string} policed -
13074 * @param {string} backend_register -
13075 * @param {string} backend_status -
13076 * @param {boolean} deleted -
13077 * @param {boolean} write_protect -
13078 * @param {boolean} lazy_blocked -
13079 * @param {boolean} no_sync -
13080 * @param {string} account -
13081 * @param {number} amount -
13082 * @param {string} date -
13083 *
13084 */
13085 xos.prototype.Payment_Detail_PUT = function(parameters) {
13086 if (parameters === undefined) {
13087 parameters = {};
13088 }
13089 var deferred = $q.defer();
13090
13091 var domain = this.domain;
13092 var path = '/xos/payments/{pk}/';
13093
13094 var body;
13095 var queryParameters = {};
13096 var headers = {};
13097 var form = {};
13098
13099 path = path.replace('{pk}', parameters['pk']);
13100
13101 if (parameters['pk'] === undefined) {
13102 deferred.reject(new Error('Missing required path parameter: pk'));
13103 return deferred.promise;
13104 }
13105
13106 if (parameters['enacted'] !== undefined) {
13107 form['enacted'] = parameters['enacted'];
13108 }
13109
13110 if (parameters['policed'] !== undefined) {
13111 form['policed'] = parameters['policed'];
13112 }
13113
13114 if (parameters['backend_register'] !== undefined) {
13115 form['backend_register'] = parameters['backend_register'];
13116 }
13117
13118 if (parameters['backend_status'] !== undefined) {
13119 form['backend_status'] = parameters['backend_status'];
13120 }
13121
13122 if (parameters['backend_status'] === undefined) {
13123 deferred.reject(new Error('Missing required form parameter: backend_status'));
13124 return deferred.promise;
13125 }
13126
13127 if (parameters['deleted'] !== undefined) {
13128 form['deleted'] = parameters['deleted'];
13129 }
13130
13131 if (parameters['write_protect'] !== undefined) {
13132 form['write_protect'] = parameters['write_protect'];
13133 }
13134
13135 if (parameters['lazy_blocked'] !== undefined) {
13136 form['lazy_blocked'] = parameters['lazy_blocked'];
13137 }
13138
13139 if (parameters['no_sync'] !== undefined) {
13140 form['no_sync'] = parameters['no_sync'];
13141 }
13142
13143 if (parameters['account'] !== undefined) {
13144 form['account'] = parameters['account'];
13145 }
13146
13147 if (parameters['account'] === undefined) {
13148 deferred.reject(new Error('Missing required form parameter: account'));
13149 return deferred.promise;
13150 }
13151
13152 if (parameters['amount'] !== undefined) {
13153 form['amount'] = parameters['amount'];
13154 }
13155
13156 if (parameters['amount'] === undefined) {
13157 deferred.reject(new Error('Missing required form parameter: amount'));
13158 return deferred.promise;
13159 }
13160
13161 if (parameters['date'] !== undefined) {
13162 form['date'] = parameters['date'];
13163 }
13164
13165 if (parameters['date'] === undefined) {
13166 deferred.reject(new Error('Missing required form parameter: date'));
13167 return deferred.promise;
13168 }
13169
13170 if (parameters.$queryParameters) {
13171 Object.keys(parameters.$queryParameters)
13172 .forEach(function(parameterName) {
13173 var parameter = parameters.$queryParameters[parameterName];
13174 queryParameters[parameterName] = parameter;
13175 });
13176 }
13177
13178 var url = domain + path;
13179 var options = {
13180 timeout: parameters.$timeout,
13181 method: 'PUT',
13182 url: url,
13183 params: queryParameters,
13184 data: body,
13185 headers: headers
13186 };
13187 if (Object.keys(form).length > 0) {
13188 options.data = form;
13189 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13190 options.transformRequest = xos.transformRequest;
13191 }
13192 $http(options)
13193 .success(function(data, status, headers, config) {
13194 deferred.resolve(data);
13195 if (parameters.$cache !== undefined) {
13196 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13197 }
13198 })
13199 .error(function(data, status, headers, config) {
13200 deferred.reject({
13201 status: status,
13202 headers: headers,
13203 config: config,
13204 body: data
13205 });
13206 });
13207
13208 return deferred.promise;
13209 };
13210 /**
13211 *
13212 * @method
13213 * @name xos#Payment_Detail_PATCH
13214 * @param {string} pk -
13215 * @param {string} enacted -
13216 * @param {string} policed -
13217 * @param {string} backend_register -
13218 * @param {string} backend_status -
13219 * @param {boolean} deleted -
13220 * @param {boolean} write_protect -
13221 * @param {boolean} lazy_blocked -
13222 * @param {boolean} no_sync -
13223 * @param {string} account -
13224 * @param {number} amount -
13225 * @param {string} date -
13226 *
13227 */
13228 xos.prototype.Payment_Detail_PATCH = function(parameters) {
13229 if (parameters === undefined) {
13230 parameters = {};
13231 }
13232 var deferred = $q.defer();
13233
13234 var domain = this.domain;
13235 var path = '/xos/payments/{pk}/';
13236
13237 var body;
13238 var queryParameters = {};
13239 var headers = {};
13240 var form = {};
13241
13242 path = path.replace('{pk}', parameters['pk']);
13243
13244 if (parameters['pk'] === undefined) {
13245 deferred.reject(new Error('Missing required path parameter: pk'));
13246 return deferred.promise;
13247 }
13248
13249 if (parameters['enacted'] !== undefined) {
13250 form['enacted'] = parameters['enacted'];
13251 }
13252
13253 if (parameters['policed'] !== undefined) {
13254 form['policed'] = parameters['policed'];
13255 }
13256
13257 if (parameters['backend_register'] !== undefined) {
13258 form['backend_register'] = parameters['backend_register'];
13259 }
13260
13261 if (parameters['backend_status'] !== undefined) {
13262 form['backend_status'] = parameters['backend_status'];
13263 }
13264
13265 if (parameters['deleted'] !== undefined) {
13266 form['deleted'] = parameters['deleted'];
13267 }
13268
13269 if (parameters['write_protect'] !== undefined) {
13270 form['write_protect'] = parameters['write_protect'];
13271 }
13272
13273 if (parameters['lazy_blocked'] !== undefined) {
13274 form['lazy_blocked'] = parameters['lazy_blocked'];
13275 }
13276
13277 if (parameters['no_sync'] !== undefined) {
13278 form['no_sync'] = parameters['no_sync'];
13279 }
13280
13281 if (parameters['account'] !== undefined) {
13282 form['account'] = parameters['account'];
13283 }
13284
13285 if (parameters['amount'] !== undefined) {
13286 form['amount'] = parameters['amount'];
13287 }
13288
13289 if (parameters['date'] !== undefined) {
13290 form['date'] = parameters['date'];
13291 }
13292
13293 if (parameters.$queryParameters) {
13294 Object.keys(parameters.$queryParameters)
13295 .forEach(function(parameterName) {
13296 var parameter = parameters.$queryParameters[parameterName];
13297 queryParameters[parameterName] = parameter;
13298 });
13299 }
13300
13301 var url = domain + path;
13302 var options = {
13303 timeout: parameters.$timeout,
13304 method: 'PATCH',
13305 url: url,
13306 params: queryParameters,
13307 data: body,
13308 headers: headers
13309 };
13310 if (Object.keys(form).length > 0) {
13311 options.data = form;
13312 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13313 options.transformRequest = xos.transformRequest;
13314 }
13315 $http(options)
13316 .success(function(data, status, headers, config) {
13317 deferred.resolve(data);
13318 if (parameters.$cache !== undefined) {
13319 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13320 }
13321 })
13322 .error(function(data, status, headers, config) {
13323 deferred.reject({
13324 status: status,
13325 headers: headers,
13326 config: config,
13327 body: data
13328 });
13329 });
13330
13331 return deferred.promise;
13332 };
13333 /**
13334 *
13335 * @method
13336 * @name xos#Payment_Detail_DELETE
13337 * @param {string} pk -
13338 *
13339 */
13340 xos.prototype.Payment_Detail_DELETE = function(parameters) {
13341 if (parameters === undefined) {
13342 parameters = {};
13343 }
13344 var deferred = $q.defer();
13345
13346 var domain = this.domain;
13347 var path = '/xos/payments/{pk}/';
13348
13349 var body;
13350 var queryParameters = {};
13351 var headers = {};
13352 var form = {};
13353
13354 path = path.replace('{pk}', parameters['pk']);
13355
13356 if (parameters['pk'] === undefined) {
13357 deferred.reject(new Error('Missing required path parameter: pk'));
13358 return deferred.promise;
13359 }
13360
13361 if (parameters.$queryParameters) {
13362 Object.keys(parameters.$queryParameters)
13363 .forEach(function(parameterName) {
13364 var parameter = parameters.$queryParameters[parameterName];
13365 queryParameters[parameterName] = parameter;
13366 });
13367 }
13368
13369 var url = domain + path;
13370 var options = {
13371 timeout: parameters.$timeout,
13372 method: 'DELETE',
13373 url: url,
13374 params: queryParameters,
13375 data: body,
13376 headers: headers
13377 };
13378 if (Object.keys(form).length > 0) {
13379 options.data = form;
13380 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13381 options.transformRequest = xos.transformRequest;
13382 }
13383 $http(options)
13384 .success(function(data, status, headers, config) {
13385 deferred.resolve(data);
13386 if (parameters.$cache !== undefined) {
13387 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13388 }
13389 })
13390 .error(function(data, status, headers, config) {
13391 deferred.reject({
13392 status: status,
13393 headers: headers,
13394 config: config,
13395 body: data
13396 });
13397 });
13398
13399 return deferred.promise;
13400 };
13401 /**
13402 *
13403 * @method
13404 * @name xos#Subscriber_List_GET
13405 *
13406 */
13407 xos.prototype.Subscriber_List_GET = function(parameters) {
13408 if (parameters === undefined) {
13409 parameters = {};
13410 }
13411 var deferred = $q.defer();
13412
13413 var domain = this.domain;
13414 var path = '/xos/subscribers/';
13415
13416 var body;
13417 var queryParameters = {};
13418 var headers = {};
13419 var form = {};
13420
13421 if (parameters.$queryParameters) {
13422 Object.keys(parameters.$queryParameters)
13423 .forEach(function(parameterName) {
13424 var parameter = parameters.$queryParameters[parameterName];
13425 queryParameters[parameterName] = parameter;
13426 });
13427 }
13428
13429 var url = domain + path;
13430 var cached = parameters.$cache && parameters.$cache.get(url);
13431 if (cached !== undefined && parameters.$refresh !== true) {
13432 deferred.resolve(cached);
13433 return deferred.promise;
13434 }
13435 var options = {
13436 timeout: parameters.$timeout,
13437 method: 'GET',
13438 url: url,
13439 params: queryParameters,
13440 data: body,
13441 headers: headers
13442 };
13443 if (Object.keys(form).length > 0) {
13444 options.data = form;
13445 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13446 options.transformRequest = xos.transformRequest;
13447 }
13448 $http(options)
13449 .success(function(data, status, headers, config) {
13450 deferred.resolve(data);
13451 if (parameters.$cache !== undefined) {
13452 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13453 }
13454 })
13455 .error(function(data, status, headers, config) {
13456 deferred.reject({
13457 status: status,
13458 headers: headers,
13459 config: config,
13460 body: data
13461 });
13462 });
13463
13464 return deferred.promise;
13465 };
13466 /**
13467 *
13468 * @method
13469 * @name xos#Subscriber_List_POST
13470 * @param {string} enacted -
13471 * @param {string} policed -
13472 * @param {string} backend_register -
13473 * @param {string} backend_status -
13474 * @param {boolean} deleted -
13475 * @param {boolean} write_protect -
13476 * @param {boolean} lazy_blocked -
13477 * @param {boolean} no_sync -
13478 * @param {string} kind -
13479 * @param {string} name - name
13480 * @param {string} service_specific_attribute -
13481 * @param {string} service_specific_id -
13482 *
13483 */
13484 xos.prototype.Subscriber_List_POST = function(parameters) {
13485 if (parameters === undefined) {
13486 parameters = {};
13487 }
13488 var deferred = $q.defer();
13489
13490 var domain = this.domain;
13491 var path = '/xos/subscribers/';
13492
13493 var body;
13494 var queryParameters = {};
13495 var headers = {};
13496 var form = {};
13497
13498 if (parameters['enacted'] !== undefined) {
13499 form['enacted'] = parameters['enacted'];
13500 }
13501
13502 if (parameters['policed'] !== undefined) {
13503 form['policed'] = parameters['policed'];
13504 }
13505
13506 if (parameters['backend_register'] !== undefined) {
13507 form['backend_register'] = parameters['backend_register'];
13508 }
13509
13510 if (parameters['backend_status'] !== undefined) {
13511 form['backend_status'] = parameters['backend_status'];
13512 }
13513
13514 if (parameters['backend_status'] === undefined) {
13515 deferred.reject(new Error('Missing required form parameter: backend_status'));
13516 return deferred.promise;
13517 }
13518
13519 if (parameters['deleted'] !== undefined) {
13520 form['deleted'] = parameters['deleted'];
13521 }
13522
13523 if (parameters['write_protect'] !== undefined) {
13524 form['write_protect'] = parameters['write_protect'];
13525 }
13526
13527 if (parameters['lazy_blocked'] !== undefined) {
13528 form['lazy_blocked'] = parameters['lazy_blocked'];
13529 }
13530
13531 if (parameters['no_sync'] !== undefined) {
13532 form['no_sync'] = parameters['no_sync'];
13533 }
13534
13535 if (parameters['kind'] !== undefined) {
13536 form['kind'] = parameters['kind'];
13537 }
13538
13539 if (parameters['kind'] === undefined) {
13540 deferred.reject(new Error('Missing required form parameter: kind'));
13541 return deferred.promise;
13542 }
13543
13544 if (parameters['name'] !== undefined) {
13545 form['name'] = parameters['name'];
13546 }
13547
13548 if (parameters['service_specific_attribute'] !== undefined) {
13549 form['service_specific_attribute'] = parameters['service_specific_attribute'];
13550 }
13551
13552 if (parameters['service_specific_id'] !== undefined) {
13553 form['service_specific_id'] = parameters['service_specific_id'];
13554 }
13555
13556 if (parameters.$queryParameters) {
13557 Object.keys(parameters.$queryParameters)
13558 .forEach(function(parameterName) {
13559 var parameter = parameters.$queryParameters[parameterName];
13560 queryParameters[parameterName] = parameter;
13561 });
13562 }
13563
13564 var url = domain + path;
13565 var options = {
13566 timeout: parameters.$timeout,
13567 method: 'POST',
13568 url: url,
13569 params: queryParameters,
13570 data: body,
13571 headers: headers
13572 };
13573 if (Object.keys(form).length > 0) {
13574 options.data = form;
13575 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13576 options.transformRequest = xos.transformRequest;
13577 }
13578 $http(options)
13579 .success(function(data, status, headers, config) {
13580 deferred.resolve(data);
13581 if (parameters.$cache !== undefined) {
13582 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13583 }
13584 })
13585 .error(function(data, status, headers, config) {
13586 deferred.reject({
13587 status: status,
13588 headers: headers,
13589 config: config,
13590 body: data
13591 });
13592 });
13593
13594 return deferred.promise;
13595 };
13596 /**
13597 *
13598 * @method
13599 * @name xos#Subscriber_Detail_GET
13600 * @param {string} pk -
13601 *
13602 */
13603 xos.prototype.Subscriber_Detail_GET = function(parameters) {
13604 if (parameters === undefined) {
13605 parameters = {};
13606 }
13607 var deferred = $q.defer();
13608
13609 var domain = this.domain;
13610 var path = '/xos/subscribers/{pk}/';
13611
13612 var body;
13613 var queryParameters = {};
13614 var headers = {};
13615 var form = {};
13616
13617 path = path.replace('{pk}', parameters['pk']);
13618
13619 if (parameters['pk'] === undefined) {
13620 deferred.reject(new Error('Missing required path parameter: pk'));
13621 return deferred.promise;
13622 }
13623
13624 if (parameters.$queryParameters) {
13625 Object.keys(parameters.$queryParameters)
13626 .forEach(function(parameterName) {
13627 var parameter = parameters.$queryParameters[parameterName];
13628 queryParameters[parameterName] = parameter;
13629 });
13630 }
13631
13632 var url = domain + path;
13633 var cached = parameters.$cache && parameters.$cache.get(url);
13634 if (cached !== undefined && parameters.$refresh !== true) {
13635 deferred.resolve(cached);
13636 return deferred.promise;
13637 }
13638 var options = {
13639 timeout: parameters.$timeout,
13640 method: 'GET',
13641 url: url,
13642 params: queryParameters,
13643 data: body,
13644 headers: headers
13645 };
13646 if (Object.keys(form).length > 0) {
13647 options.data = form;
13648 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13649 options.transformRequest = xos.transformRequest;
13650 }
13651 $http(options)
13652 .success(function(data, status, headers, config) {
13653 deferred.resolve(data);
13654 if (parameters.$cache !== undefined) {
13655 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13656 }
13657 })
13658 .error(function(data, status, headers, config) {
13659 deferred.reject({
13660 status: status,
13661 headers: headers,
13662 config: config,
13663 body: data
13664 });
13665 });
13666
13667 return deferred.promise;
13668 };
13669 /**
13670 *
13671 * @method
13672 * @name xos#Subscriber_Detail_PUT
13673 * @param {string} pk -
13674 * @param {string} enacted -
13675 * @param {string} policed -
13676 * @param {string} backend_register -
13677 * @param {string} backend_status -
13678 * @param {boolean} deleted -
13679 * @param {boolean} write_protect -
13680 * @param {boolean} lazy_blocked -
13681 * @param {boolean} no_sync -
13682 * @param {string} kind -
13683 * @param {string} name - name
13684 * @param {string} service_specific_attribute -
13685 * @param {string} service_specific_id -
13686 *
13687 */
13688 xos.prototype.Subscriber_Detail_PUT = function(parameters) {
13689 if (parameters === undefined) {
13690 parameters = {};
13691 }
13692 var deferred = $q.defer();
13693
13694 var domain = this.domain;
13695 var path = '/xos/subscribers/{pk}/';
13696
13697 var body;
13698 var queryParameters = {};
13699 var headers = {};
13700 var form = {};
13701
13702 path = path.replace('{pk}', parameters['pk']);
13703
13704 if (parameters['pk'] === undefined) {
13705 deferred.reject(new Error('Missing required path parameter: pk'));
13706 return deferred.promise;
13707 }
13708
13709 if (parameters['enacted'] !== undefined) {
13710 form['enacted'] = parameters['enacted'];
13711 }
13712
13713 if (parameters['policed'] !== undefined) {
13714 form['policed'] = parameters['policed'];
13715 }
13716
13717 if (parameters['backend_register'] !== undefined) {
13718 form['backend_register'] = parameters['backend_register'];
13719 }
13720
13721 if (parameters['backend_status'] !== undefined) {
13722 form['backend_status'] = parameters['backend_status'];
13723 }
13724
13725 if (parameters['backend_status'] === undefined) {
13726 deferred.reject(new Error('Missing required form parameter: backend_status'));
13727 return deferred.promise;
13728 }
13729
13730 if (parameters['deleted'] !== undefined) {
13731 form['deleted'] = parameters['deleted'];
13732 }
13733
13734 if (parameters['write_protect'] !== undefined) {
13735 form['write_protect'] = parameters['write_protect'];
13736 }
13737
13738 if (parameters['lazy_blocked'] !== undefined) {
13739 form['lazy_blocked'] = parameters['lazy_blocked'];
13740 }
13741
13742 if (parameters['no_sync'] !== undefined) {
13743 form['no_sync'] = parameters['no_sync'];
13744 }
13745
13746 if (parameters['kind'] !== undefined) {
13747 form['kind'] = parameters['kind'];
13748 }
13749
13750 if (parameters['kind'] === undefined) {
13751 deferred.reject(new Error('Missing required form parameter: kind'));
13752 return deferred.promise;
13753 }
13754
13755 if (parameters['name'] !== undefined) {
13756 form['name'] = parameters['name'];
13757 }
13758
13759 if (parameters['service_specific_attribute'] !== undefined) {
13760 form['service_specific_attribute'] = parameters['service_specific_attribute'];
13761 }
13762
13763 if (parameters['service_specific_id'] !== undefined) {
13764 form['service_specific_id'] = parameters['service_specific_id'];
13765 }
13766
13767 if (parameters.$queryParameters) {
13768 Object.keys(parameters.$queryParameters)
13769 .forEach(function(parameterName) {
13770 var parameter = parameters.$queryParameters[parameterName];
13771 queryParameters[parameterName] = parameter;
13772 });
13773 }
13774
13775 var url = domain + path;
13776 var options = {
13777 timeout: parameters.$timeout,
13778 method: 'PUT',
13779 url: url,
13780 params: queryParameters,
13781 data: body,
13782 headers: headers
13783 };
13784 if (Object.keys(form).length > 0) {
13785 options.data = form;
13786 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13787 options.transformRequest = xos.transformRequest;
13788 }
13789 $http(options)
13790 .success(function(data, status, headers, config) {
13791 deferred.resolve(data);
13792 if (parameters.$cache !== undefined) {
13793 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13794 }
13795 })
13796 .error(function(data, status, headers, config) {
13797 deferred.reject({
13798 status: status,
13799 headers: headers,
13800 config: config,
13801 body: data
13802 });
13803 });
13804
13805 return deferred.promise;
13806 };
13807 /**
13808 *
13809 * @method
13810 * @name xos#Subscriber_Detail_PATCH
13811 * @param {string} pk -
13812 * @param {string} enacted -
13813 * @param {string} policed -
13814 * @param {string} backend_register -
13815 * @param {string} backend_status -
13816 * @param {boolean} deleted -
13817 * @param {boolean} write_protect -
13818 * @param {boolean} lazy_blocked -
13819 * @param {boolean} no_sync -
13820 * @param {string} kind -
13821 * @param {string} name - name
13822 * @param {string} service_specific_attribute -
13823 * @param {string} service_specific_id -
13824 *
13825 */
13826 xos.prototype.Subscriber_Detail_PATCH = function(parameters) {
13827 if (parameters === undefined) {
13828 parameters = {};
13829 }
13830 var deferred = $q.defer();
13831
13832 var domain = this.domain;
13833 var path = '/xos/subscribers/{pk}/';
13834
13835 var body;
13836 var queryParameters = {};
13837 var headers = {};
13838 var form = {};
13839
13840 path = path.replace('{pk}', parameters['pk']);
13841
13842 if (parameters['pk'] === undefined) {
13843 deferred.reject(new Error('Missing required path parameter: pk'));
13844 return deferred.promise;
13845 }
13846
13847 if (parameters['enacted'] !== undefined) {
13848 form['enacted'] = parameters['enacted'];
13849 }
13850
13851 if (parameters['policed'] !== undefined) {
13852 form['policed'] = parameters['policed'];
13853 }
13854
13855 if (parameters['backend_register'] !== undefined) {
13856 form['backend_register'] = parameters['backend_register'];
13857 }
13858
13859 if (parameters['backend_status'] !== undefined) {
13860 form['backend_status'] = parameters['backend_status'];
13861 }
13862
13863 if (parameters['deleted'] !== undefined) {
13864 form['deleted'] = parameters['deleted'];
13865 }
13866
13867 if (parameters['write_protect'] !== undefined) {
13868 form['write_protect'] = parameters['write_protect'];
13869 }
13870
13871 if (parameters['lazy_blocked'] !== undefined) {
13872 form['lazy_blocked'] = parameters['lazy_blocked'];
13873 }
13874
13875 if (parameters['no_sync'] !== undefined) {
13876 form['no_sync'] = parameters['no_sync'];
13877 }
13878
13879 if (parameters['kind'] !== undefined) {
13880 form['kind'] = parameters['kind'];
13881 }
13882
13883 if (parameters['name'] !== undefined) {
13884 form['name'] = parameters['name'];
13885 }
13886
13887 if (parameters['service_specific_attribute'] !== undefined) {
13888 form['service_specific_attribute'] = parameters['service_specific_attribute'];
13889 }
13890
13891 if (parameters['service_specific_id'] !== undefined) {
13892 form['service_specific_id'] = parameters['service_specific_id'];
13893 }
13894
13895 if (parameters.$queryParameters) {
13896 Object.keys(parameters.$queryParameters)
13897 .forEach(function(parameterName) {
13898 var parameter = parameters.$queryParameters[parameterName];
13899 queryParameters[parameterName] = parameter;
13900 });
13901 }
13902
13903 var url = domain + path;
13904 var options = {
13905 timeout: parameters.$timeout,
13906 method: 'PATCH',
13907 url: url,
13908 params: queryParameters,
13909 data: body,
13910 headers: headers
13911 };
13912 if (Object.keys(form).length > 0) {
13913 options.data = form;
13914 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13915 options.transformRequest = xos.transformRequest;
13916 }
13917 $http(options)
13918 .success(function(data, status, headers, config) {
13919 deferred.resolve(data);
13920 if (parameters.$cache !== undefined) {
13921 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13922 }
13923 })
13924 .error(function(data, status, headers, config) {
13925 deferred.reject({
13926 status: status,
13927 headers: headers,
13928 config: config,
13929 body: data
13930 });
13931 });
13932
13933 return deferred.promise;
13934 };
13935 /**
13936 *
13937 * @method
13938 * @name xos#Subscriber_Detail_DELETE
13939 * @param {string} pk -
13940 *
13941 */
13942 xos.prototype.Subscriber_Detail_DELETE = function(parameters) {
13943 if (parameters === undefined) {
13944 parameters = {};
13945 }
13946 var deferred = $q.defer();
13947
13948 var domain = this.domain;
13949 var path = '/xos/subscribers/{pk}/';
13950
13951 var body;
13952 var queryParameters = {};
13953 var headers = {};
13954 var form = {};
13955
13956 path = path.replace('{pk}', parameters['pk']);
13957
13958 if (parameters['pk'] === undefined) {
13959 deferred.reject(new Error('Missing required path parameter: pk'));
13960 return deferred.promise;
13961 }
13962
13963 if (parameters.$queryParameters) {
13964 Object.keys(parameters.$queryParameters)
13965 .forEach(function(parameterName) {
13966 var parameter = parameters.$queryParameters[parameterName];
13967 queryParameters[parameterName] = parameter;
13968 });
13969 }
13970
13971 var url = domain + path;
13972 var options = {
13973 timeout: parameters.$timeout,
13974 method: 'DELETE',
13975 url: url,
13976 params: queryParameters,
13977 data: body,
13978 headers: headers
13979 };
13980 if (Object.keys(form).length > 0) {
13981 options.data = form;
13982 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
13983 options.transformRequest = xos.transformRequest;
13984 }
13985 $http(options)
13986 .success(function(data, status, headers, config) {
13987 deferred.resolve(data);
13988 if (parameters.$cache !== undefined) {
13989 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
13990 }
13991 })
13992 .error(function(data, status, headers, config) {
13993 deferred.reject({
13994 status: status,
13995 headers: headers,
13996 config: config,
13997 body: data
13998 });
13999 });
14000
14001 return deferred.promise;
14002 };
14003 /**
14004 *
14005 * @method
14006 * @name xos#Instance_List_GET
14007 *
14008 */
14009 xos.prototype.Instance_List_GET = function(parameters) {
14010 if (parameters === undefined) {
14011 parameters = {};
14012 }
14013 var deferred = $q.defer();
14014
14015 var domain = this.domain;
14016 var path = '/xos/instances/';
14017
14018 var body;
14019 var queryParameters = {};
14020 var headers = {};
14021 var form = {};
14022
14023 if (parameters.$queryParameters) {
14024 Object.keys(parameters.$queryParameters)
14025 .forEach(function(parameterName) {
14026 var parameter = parameters.$queryParameters[parameterName];
14027 queryParameters[parameterName] = parameter;
14028 });
14029 }
14030
14031 var url = domain + path;
14032 var cached = parameters.$cache && parameters.$cache.get(url);
14033 if (cached !== undefined && parameters.$refresh !== true) {
14034 deferred.resolve(cached);
14035 return deferred.promise;
14036 }
14037 var options = {
14038 timeout: parameters.$timeout,
14039 method: 'GET',
14040 url: url,
14041 params: queryParameters,
14042 data: body,
14043 headers: headers
14044 };
14045 if (Object.keys(form).length > 0) {
14046 options.data = form;
14047 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14048 options.transformRequest = xos.transformRequest;
14049 }
14050 $http(options)
14051 .success(function(data, status, headers, config) {
14052 deferred.resolve(data);
14053 if (parameters.$cache !== undefined) {
14054 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14055 }
14056 })
14057 .error(function(data, status, headers, config) {
14058 deferred.reject({
14059 status: status,
14060 headers: headers,
14061 config: config,
14062 body: data
14063 });
14064 });
14065
14066 return deferred.promise;
14067 };
14068 /**
14069 *
14070 * @method
14071 * @name xos#Instance_List_POST
14072 * @param {string} enacted -
14073 * @param {string} policed -
14074 * @param {string} backend_register -
14075 * @param {string} backend_status -
14076 * @param {boolean} deleted -
14077 * @param {boolean} write_protect -
14078 * @param {boolean} lazy_blocked -
14079 * @param {boolean} no_sync -
14080 * @param {string} instance_id - Nova instance id
14081 * @param {string} instance_uuid - Nova instance uuid
14082 * @param {string} name - Instance name
14083 * @param {string} instance_name - OpenStack generated name
14084 * @param {string} ip - Instance ip address
14085 * @param {string} image -
14086 * @param {string} creator -
14087 * @param {string} slice -
14088 * @param {string} deployment -
14089 * @param {string} node -
14090 * @param {integer} numberCores - Number of cores for instance
14091 * @param {string} flavor - Flavor of this instance
14092 * @param {string} userData - user_data passed to instance during creation
14093 *
14094 */
14095 xos.prototype.Instance_List_POST = function(parameters) {
14096 if (parameters === undefined) {
14097 parameters = {};
14098 }
14099 var deferred = $q.defer();
14100
14101 var domain = this.domain;
14102 var path = '/xos/instances/';
14103
14104 var body;
14105 var queryParameters = {};
14106 var headers = {};
14107 var form = {};
14108
14109 if (parameters['enacted'] !== undefined) {
14110 form['enacted'] = parameters['enacted'];
14111 }
14112
14113 if (parameters['policed'] !== undefined) {
14114 form['policed'] = parameters['policed'];
14115 }
14116
14117 if (parameters['backend_register'] !== undefined) {
14118 form['backend_register'] = parameters['backend_register'];
14119 }
14120
14121 if (parameters['backend_status'] !== undefined) {
14122 form['backend_status'] = parameters['backend_status'];
14123 }
14124
14125 if (parameters['backend_status'] === undefined) {
14126 deferred.reject(new Error('Missing required form parameter: backend_status'));
14127 return deferred.promise;
14128 }
14129
14130 if (parameters['deleted'] !== undefined) {
14131 form['deleted'] = parameters['deleted'];
14132 }
14133
14134 if (parameters['write_protect'] !== undefined) {
14135 form['write_protect'] = parameters['write_protect'];
14136 }
14137
14138 if (parameters['lazy_blocked'] !== undefined) {
14139 form['lazy_blocked'] = parameters['lazy_blocked'];
14140 }
14141
14142 if (parameters['no_sync'] !== undefined) {
14143 form['no_sync'] = parameters['no_sync'];
14144 }
14145
14146 if (parameters['instance_id'] !== undefined) {
14147 form['instance_id'] = parameters['instance_id'];
14148 }
14149
14150 if (parameters['instance_uuid'] !== undefined) {
14151 form['instance_uuid'] = parameters['instance_uuid'];
14152 }
14153
14154 if (parameters['name'] !== undefined) {
14155 form['name'] = parameters['name'];
14156 }
14157
14158 if (parameters['name'] === undefined) {
14159 deferred.reject(new Error('Missing required form parameter: name'));
14160 return deferred.promise;
14161 }
14162
14163 if (parameters['instance_name'] !== undefined) {
14164 form['instance_name'] = parameters['instance_name'];
14165 }
14166
14167 if (parameters['ip'] !== undefined) {
14168 form['ip'] = parameters['ip'];
14169 }
14170
14171 if (parameters['image'] !== undefined) {
14172 form['image'] = parameters['image'];
14173 }
14174
14175 if (parameters['image'] === undefined) {
14176 deferred.reject(new Error('Missing required form parameter: image'));
14177 return deferred.promise;
14178 }
14179
14180 if (parameters['creator'] !== undefined) {
14181 form['creator'] = parameters['creator'];
14182 }
14183
14184 if (parameters['slice'] !== undefined) {
14185 form['slice'] = parameters['slice'];
14186 }
14187
14188 if (parameters['slice'] === undefined) {
14189 deferred.reject(new Error('Missing required form parameter: slice'));
14190 return deferred.promise;
14191 }
14192
14193 if (parameters['deployment'] !== undefined) {
14194 form['deployment'] = parameters['deployment'];
14195 }
14196
14197 if (parameters['deployment'] === undefined) {
14198 deferred.reject(new Error('Missing required form parameter: deployment'));
14199 return deferred.promise;
14200 }
14201
14202 if (parameters['node'] !== undefined) {
14203 form['node'] = parameters['node'];
14204 }
14205
14206 if (parameters['node'] === undefined) {
14207 deferred.reject(new Error('Missing required form parameter: node'));
14208 return deferred.promise;
14209 }
14210
14211 if (parameters['numberCores'] !== undefined) {
14212 form['numberCores'] = parameters['numberCores'];
14213 }
14214
14215 if (parameters['numberCores'] === undefined) {
14216 deferred.reject(new Error('Missing required form parameter: numberCores'));
14217 return deferred.promise;
14218 }
14219
14220 if (parameters['flavor'] !== undefined) {
14221 form['flavor'] = parameters['flavor'];
14222 }
14223
14224 if (parameters['flavor'] === undefined) {
14225 deferred.reject(new Error('Missing required form parameter: flavor'));
14226 return deferred.promise;
14227 }
14228
14229 if (parameters['userData'] !== undefined) {
14230 form['userData'] = parameters['userData'];
14231 }
14232
14233 if (parameters.$queryParameters) {
14234 Object.keys(parameters.$queryParameters)
14235 .forEach(function(parameterName) {
14236 var parameter = parameters.$queryParameters[parameterName];
14237 queryParameters[parameterName] = parameter;
14238 });
14239 }
14240
14241 var url = domain + path;
14242 var options = {
14243 timeout: parameters.$timeout,
14244 method: 'POST',
14245 url: url,
14246 params: queryParameters,
14247 data: body,
14248 headers: headers
14249 };
14250 if (Object.keys(form).length > 0) {
14251 options.data = form;
14252 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14253 options.transformRequest = xos.transformRequest;
14254 }
14255 $http(options)
14256 .success(function(data, status, headers, config) {
14257 deferred.resolve(data);
14258 if (parameters.$cache !== undefined) {
14259 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14260 }
14261 })
14262 .error(function(data, status, headers, config) {
14263 deferred.reject({
14264 status: status,
14265 headers: headers,
14266 config: config,
14267 body: data
14268 });
14269 });
14270
14271 return deferred.promise;
14272 };
14273 /**
14274 *
14275 * @method
14276 * @name xos#Instance_Detail_GET
14277 * @param {string} pk -
14278 *
14279 */
14280 xos.prototype.Instance_Detail_GET = function(parameters) {
14281 if (parameters === undefined) {
14282 parameters = {};
14283 }
14284 var deferred = $q.defer();
14285
14286 var domain = this.domain;
14287 var path = '/xos/instances/{pk}/';
14288
14289 var body;
14290 var queryParameters = {};
14291 var headers = {};
14292 var form = {};
14293
14294 path = path.replace('{pk}', parameters['pk']);
14295
14296 if (parameters['pk'] === undefined) {
14297 deferred.reject(new Error('Missing required path parameter: pk'));
14298 return deferred.promise;
14299 }
14300
14301 if (parameters.$queryParameters) {
14302 Object.keys(parameters.$queryParameters)
14303 .forEach(function(parameterName) {
14304 var parameter = parameters.$queryParameters[parameterName];
14305 queryParameters[parameterName] = parameter;
14306 });
14307 }
14308
14309 var url = domain + path;
14310 var cached = parameters.$cache && parameters.$cache.get(url);
14311 if (cached !== undefined && parameters.$refresh !== true) {
14312 deferred.resolve(cached);
14313 return deferred.promise;
14314 }
14315 var options = {
14316 timeout: parameters.$timeout,
14317 method: 'GET',
14318 url: url,
14319 params: queryParameters,
14320 data: body,
14321 headers: headers
14322 };
14323 if (Object.keys(form).length > 0) {
14324 options.data = form;
14325 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14326 options.transformRequest = xos.transformRequest;
14327 }
14328 $http(options)
14329 .success(function(data, status, headers, config) {
14330 deferred.resolve(data);
14331 if (parameters.$cache !== undefined) {
14332 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14333 }
14334 })
14335 .error(function(data, status, headers, config) {
14336 deferred.reject({
14337 status: status,
14338 headers: headers,
14339 config: config,
14340 body: data
14341 });
14342 });
14343
14344 return deferred.promise;
14345 };
14346 /**
14347 *
14348 * @method
14349 * @name xos#Instance_Detail_PUT
14350 * @param {string} pk -
14351 * @param {string} enacted -
14352 * @param {string} policed -
14353 * @param {string} backend_register -
14354 * @param {string} backend_status -
14355 * @param {boolean} deleted -
14356 * @param {boolean} write_protect -
14357 * @param {boolean} lazy_blocked -
14358 * @param {boolean} no_sync -
14359 * @param {string} instance_id - Nova instance id
14360 * @param {string} instance_uuid - Nova instance uuid
14361 * @param {string} name - Instance name
14362 * @param {string} instance_name - OpenStack generated name
14363 * @param {string} ip - Instance ip address
14364 * @param {string} image -
14365 * @param {string} creator -
14366 * @param {string} slice -
14367 * @param {string} deployment -
14368 * @param {string} node -
14369 * @param {integer} numberCores - Number of cores for instance
14370 * @param {string} flavor - Flavor of this instance
14371 * @param {string} userData - user_data passed to instance during creation
14372 *
14373 */
14374 xos.prototype.Instance_Detail_PUT = function(parameters) {
14375 if (parameters === undefined) {
14376 parameters = {};
14377 }
14378 var deferred = $q.defer();
14379
14380 var domain = this.domain;
14381 var path = '/xos/instances/{pk}/';
14382
14383 var body;
14384 var queryParameters = {};
14385 var headers = {};
14386 var form = {};
14387
14388 path = path.replace('{pk}', parameters['pk']);
14389
14390 if (parameters['pk'] === undefined) {
14391 deferred.reject(new Error('Missing required path parameter: pk'));
14392 return deferred.promise;
14393 }
14394
14395 if (parameters['enacted'] !== undefined) {
14396 form['enacted'] = parameters['enacted'];
14397 }
14398
14399 if (parameters['policed'] !== undefined) {
14400 form['policed'] = parameters['policed'];
14401 }
14402
14403 if (parameters['backend_register'] !== undefined) {
14404 form['backend_register'] = parameters['backend_register'];
14405 }
14406
14407 if (parameters['backend_status'] !== undefined) {
14408 form['backend_status'] = parameters['backend_status'];
14409 }
14410
14411 if (parameters['backend_status'] === undefined) {
14412 deferred.reject(new Error('Missing required form parameter: backend_status'));
14413 return deferred.promise;
14414 }
14415
14416 if (parameters['deleted'] !== undefined) {
14417 form['deleted'] = parameters['deleted'];
14418 }
14419
14420 if (parameters['write_protect'] !== undefined) {
14421 form['write_protect'] = parameters['write_protect'];
14422 }
14423
14424 if (parameters['lazy_blocked'] !== undefined) {
14425 form['lazy_blocked'] = parameters['lazy_blocked'];
14426 }
14427
14428 if (parameters['no_sync'] !== undefined) {
14429 form['no_sync'] = parameters['no_sync'];
14430 }
14431
14432 if (parameters['instance_id'] !== undefined) {
14433 form['instance_id'] = parameters['instance_id'];
14434 }
14435
14436 if (parameters['instance_uuid'] !== undefined) {
14437 form['instance_uuid'] = parameters['instance_uuid'];
14438 }
14439
14440 if (parameters['name'] !== undefined) {
14441 form['name'] = parameters['name'];
14442 }
14443
14444 if (parameters['name'] === undefined) {
14445 deferred.reject(new Error('Missing required form parameter: name'));
14446 return deferred.promise;
14447 }
14448
14449 if (parameters['instance_name'] !== undefined) {
14450 form['instance_name'] = parameters['instance_name'];
14451 }
14452
14453 if (parameters['ip'] !== undefined) {
14454 form['ip'] = parameters['ip'];
14455 }
14456
14457 if (parameters['image'] !== undefined) {
14458 form['image'] = parameters['image'];
14459 }
14460
14461 if (parameters['image'] === undefined) {
14462 deferred.reject(new Error('Missing required form parameter: image'));
14463 return deferred.promise;
14464 }
14465
14466 if (parameters['creator'] !== undefined) {
14467 form['creator'] = parameters['creator'];
14468 }
14469
14470 if (parameters['slice'] !== undefined) {
14471 form['slice'] = parameters['slice'];
14472 }
14473
14474 if (parameters['slice'] === undefined) {
14475 deferred.reject(new Error('Missing required form parameter: slice'));
14476 return deferred.promise;
14477 }
14478
14479 if (parameters['deployment'] !== undefined) {
14480 form['deployment'] = parameters['deployment'];
14481 }
14482
14483 if (parameters['deployment'] === undefined) {
14484 deferred.reject(new Error('Missing required form parameter: deployment'));
14485 return deferred.promise;
14486 }
14487
14488 if (parameters['node'] !== undefined) {
14489 form['node'] = parameters['node'];
14490 }
14491
14492 if (parameters['node'] === undefined) {
14493 deferred.reject(new Error('Missing required form parameter: node'));
14494 return deferred.promise;
14495 }
14496
14497 if (parameters['numberCores'] !== undefined) {
14498 form['numberCores'] = parameters['numberCores'];
14499 }
14500
14501 if (parameters['numberCores'] === undefined) {
14502 deferred.reject(new Error('Missing required form parameter: numberCores'));
14503 return deferred.promise;
14504 }
14505
14506 if (parameters['flavor'] !== undefined) {
14507 form['flavor'] = parameters['flavor'];
14508 }
14509
14510 if (parameters['flavor'] === undefined) {
14511 deferred.reject(new Error('Missing required form parameter: flavor'));
14512 return deferred.promise;
14513 }
14514
14515 if (parameters['userData'] !== undefined) {
14516 form['userData'] = parameters['userData'];
14517 }
14518
14519 if (parameters.$queryParameters) {
14520 Object.keys(parameters.$queryParameters)
14521 .forEach(function(parameterName) {
14522 var parameter = parameters.$queryParameters[parameterName];
14523 queryParameters[parameterName] = parameter;
14524 });
14525 }
14526
14527 var url = domain + path;
14528 var options = {
14529 timeout: parameters.$timeout,
14530 method: 'PUT',
14531 url: url,
14532 params: queryParameters,
14533 data: body,
14534 headers: headers
14535 };
14536 if (Object.keys(form).length > 0) {
14537 options.data = form;
14538 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14539 options.transformRequest = xos.transformRequest;
14540 }
14541 $http(options)
14542 .success(function(data, status, headers, config) {
14543 deferred.resolve(data);
14544 if (parameters.$cache !== undefined) {
14545 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14546 }
14547 })
14548 .error(function(data, status, headers, config) {
14549 deferred.reject({
14550 status: status,
14551 headers: headers,
14552 config: config,
14553 body: data
14554 });
14555 });
14556
14557 return deferred.promise;
14558 };
14559 /**
14560 *
14561 * @method
14562 * @name xos#Instance_Detail_PATCH
14563 * @param {string} pk -
14564 * @param {string} enacted -
14565 * @param {string} policed -
14566 * @param {string} backend_register -
14567 * @param {string} backend_status -
14568 * @param {boolean} deleted -
14569 * @param {boolean} write_protect -
14570 * @param {boolean} lazy_blocked -
14571 * @param {boolean} no_sync -
14572 * @param {string} instance_id - Nova instance id
14573 * @param {string} instance_uuid - Nova instance uuid
14574 * @param {string} name - Instance name
14575 * @param {string} instance_name - OpenStack generated name
14576 * @param {string} ip - Instance ip address
14577 * @param {string} image -
14578 * @param {string} creator -
14579 * @param {string} slice -
14580 * @param {string} deployment -
14581 * @param {string} node -
14582 * @param {integer} numberCores - Number of cores for instance
14583 * @param {string} flavor - Flavor of this instance
14584 * @param {string} userData - user_data passed to instance during creation
14585 *
14586 */
14587 xos.prototype.Instance_Detail_PATCH = function(parameters) {
14588 if (parameters === undefined) {
14589 parameters = {};
14590 }
14591 var deferred = $q.defer();
14592
14593 var domain = this.domain;
14594 var path = '/xos/instances/{pk}/';
14595
14596 var body;
14597 var queryParameters = {};
14598 var headers = {};
14599 var form = {};
14600
14601 path = path.replace('{pk}', parameters['pk']);
14602
14603 if (parameters['pk'] === undefined) {
14604 deferred.reject(new Error('Missing required path parameter: pk'));
14605 return deferred.promise;
14606 }
14607
14608 if (parameters['enacted'] !== undefined) {
14609 form['enacted'] = parameters['enacted'];
14610 }
14611
14612 if (parameters['policed'] !== undefined) {
14613 form['policed'] = parameters['policed'];
14614 }
14615
14616 if (parameters['backend_register'] !== undefined) {
14617 form['backend_register'] = parameters['backend_register'];
14618 }
14619
14620 if (parameters['backend_status'] !== undefined) {
14621 form['backend_status'] = parameters['backend_status'];
14622 }
14623
14624 if (parameters['deleted'] !== undefined) {
14625 form['deleted'] = parameters['deleted'];
14626 }
14627
14628 if (parameters['write_protect'] !== undefined) {
14629 form['write_protect'] = parameters['write_protect'];
14630 }
14631
14632 if (parameters['lazy_blocked'] !== undefined) {
14633 form['lazy_blocked'] = parameters['lazy_blocked'];
14634 }
14635
14636 if (parameters['no_sync'] !== undefined) {
14637 form['no_sync'] = parameters['no_sync'];
14638 }
14639
14640 if (parameters['instance_id'] !== undefined) {
14641 form['instance_id'] = parameters['instance_id'];
14642 }
14643
14644 if (parameters['instance_uuid'] !== undefined) {
14645 form['instance_uuid'] = parameters['instance_uuid'];
14646 }
14647
14648 if (parameters['name'] !== undefined) {
14649 form['name'] = parameters['name'];
14650 }
14651
14652 if (parameters['instance_name'] !== undefined) {
14653 form['instance_name'] = parameters['instance_name'];
14654 }
14655
14656 if (parameters['ip'] !== undefined) {
14657 form['ip'] = parameters['ip'];
14658 }
14659
14660 if (parameters['image'] !== undefined) {
14661 form['image'] = parameters['image'];
14662 }
14663
14664 if (parameters['creator'] !== undefined) {
14665 form['creator'] = parameters['creator'];
14666 }
14667
14668 if (parameters['slice'] !== undefined) {
14669 form['slice'] = parameters['slice'];
14670 }
14671
14672 if (parameters['deployment'] !== undefined) {
14673 form['deployment'] = parameters['deployment'];
14674 }
14675
14676 if (parameters['node'] !== undefined) {
14677 form['node'] = parameters['node'];
14678 }
14679
14680 if (parameters['numberCores'] !== undefined) {
14681 form['numberCores'] = parameters['numberCores'];
14682 }
14683
14684 if (parameters['flavor'] !== undefined) {
14685 form['flavor'] = parameters['flavor'];
14686 }
14687
14688 if (parameters['userData'] !== undefined) {
14689 form['userData'] = parameters['userData'];
14690 }
14691
14692 if (parameters.$queryParameters) {
14693 Object.keys(parameters.$queryParameters)
14694 .forEach(function(parameterName) {
14695 var parameter = parameters.$queryParameters[parameterName];
14696 queryParameters[parameterName] = parameter;
14697 });
14698 }
14699
14700 var url = domain + path;
14701 var options = {
14702 timeout: parameters.$timeout,
14703 method: 'PATCH',
14704 url: url,
14705 params: queryParameters,
14706 data: body,
14707 headers: headers
14708 };
14709 if (Object.keys(form).length > 0) {
14710 options.data = form;
14711 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14712 options.transformRequest = xos.transformRequest;
14713 }
14714 $http(options)
14715 .success(function(data, status, headers, config) {
14716 deferred.resolve(data);
14717 if (parameters.$cache !== undefined) {
14718 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14719 }
14720 })
14721 .error(function(data, status, headers, config) {
14722 deferred.reject({
14723 status: status,
14724 headers: headers,
14725 config: config,
14726 body: data
14727 });
14728 });
14729
14730 return deferred.promise;
14731 };
14732 /**
14733 *
14734 * @method
14735 * @name xos#Instance_Detail_DELETE
14736 * @param {string} pk -
14737 *
14738 */
14739 xos.prototype.Instance_Detail_DELETE = function(parameters) {
14740 if (parameters === undefined) {
14741 parameters = {};
14742 }
14743 var deferred = $q.defer();
14744
14745 var domain = this.domain;
14746 var path = '/xos/instances/{pk}/';
14747
14748 var body;
14749 var queryParameters = {};
14750 var headers = {};
14751 var form = {};
14752
14753 path = path.replace('{pk}', parameters['pk']);
14754
14755 if (parameters['pk'] === undefined) {
14756 deferred.reject(new Error('Missing required path parameter: pk'));
14757 return deferred.promise;
14758 }
14759
14760 if (parameters.$queryParameters) {
14761 Object.keys(parameters.$queryParameters)
14762 .forEach(function(parameterName) {
14763 var parameter = parameters.$queryParameters[parameterName];
14764 queryParameters[parameterName] = parameter;
14765 });
14766 }
14767
14768 var url = domain + path;
14769 var options = {
14770 timeout: parameters.$timeout,
14771 method: 'DELETE',
14772 url: url,
14773 params: queryParameters,
14774 data: body,
14775 headers: headers
14776 };
14777 if (Object.keys(form).length > 0) {
14778 options.data = form;
14779 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14780 options.transformRequest = xos.transformRequest;
14781 }
14782 $http(options)
14783 .success(function(data, status, headers, config) {
14784 deferred.resolve(data);
14785 if (parameters.$cache !== undefined) {
14786 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14787 }
14788 })
14789 .error(function(data, status, headers, config) {
14790 deferred.reject({
14791 status: status,
14792 headers: headers,
14793 config: config,
14794 body: data
14795 });
14796 });
14797
14798 return deferred.promise;
14799 };
14800 /**
14801 *
14802 * @method
14803 * @name xos#Charge_List_GET
14804 *
14805 */
14806 xos.prototype.Charge_List_GET = function(parameters) {
14807 if (parameters === undefined) {
14808 parameters = {};
14809 }
14810 var deferred = $q.defer();
14811
14812 var domain = this.domain;
14813 var path = '/xos/charges/';
14814
14815 var body;
14816 var queryParameters = {};
14817 var headers = {};
14818 var form = {};
14819
14820 if (parameters.$queryParameters) {
14821 Object.keys(parameters.$queryParameters)
14822 .forEach(function(parameterName) {
14823 var parameter = parameters.$queryParameters[parameterName];
14824 queryParameters[parameterName] = parameter;
14825 });
14826 }
14827
14828 var url = domain + path;
14829 var cached = parameters.$cache && parameters.$cache.get(url);
14830 if (cached !== undefined && parameters.$refresh !== true) {
14831 deferred.resolve(cached);
14832 return deferred.promise;
14833 }
14834 var options = {
14835 timeout: parameters.$timeout,
14836 method: 'GET',
14837 url: url,
14838 params: queryParameters,
14839 data: body,
14840 headers: headers
14841 };
14842 if (Object.keys(form).length > 0) {
14843 options.data = form;
14844 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
14845 options.transformRequest = xos.transformRequest;
14846 }
14847 $http(options)
14848 .success(function(data, status, headers, config) {
14849 deferred.resolve(data);
14850 if (parameters.$cache !== undefined) {
14851 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
14852 }
14853 })
14854 .error(function(data, status, headers, config) {
14855 deferred.reject({
14856 status: status,
14857 headers: headers,
14858 config: config,
14859 body: data
14860 });
14861 });
14862
14863 return deferred.promise;
14864 };
14865 /**
14866 *
14867 * @method
14868 * @name xos#Charge_List_POST
14869 * @param {string} enacted -
14870 * @param {string} policed -
14871 * @param {string} backend_register -
14872 * @param {string} backend_status -
14873 * @param {boolean} deleted -
14874 * @param {boolean} write_protect -
14875 * @param {boolean} lazy_blocked -
14876 * @param {boolean} no_sync -
14877 * @param {string} account -
14878 * @param {string} slice -
14879 * @param {choice} kind -
14880 * @param {choice} state -
14881 * @param {string} date -
14882 * @param {string} object -
14883 * @param {number} amount -
14884 * @param {number} coreHours -
14885 * @param {string} invoice -
14886 *
14887 */
14888 xos.prototype.Charge_List_POST = function(parameters) {
14889 if (parameters === undefined) {
14890 parameters = {};
14891 }
14892 var deferred = $q.defer();
14893
14894 var domain = this.domain;
14895 var path = '/xos/charges/';
14896
14897 var body;
14898 var queryParameters = {};
14899 var headers = {};
14900 var form = {};
14901
14902 if (parameters['enacted'] !== undefined) {
14903 form['enacted'] = parameters['enacted'];
14904 }
14905
14906 if (parameters['policed'] !== undefined) {
14907 form['policed'] = parameters['policed'];
14908 }
14909
14910 if (parameters['backend_register'] !== undefined) {
14911 form['backend_register'] = parameters['backend_register'];
14912 }
14913
14914 if (parameters['backend_status'] !== undefined) {
14915 form['backend_status'] = parameters['backend_status'];
14916 }
14917
14918 if (parameters['backend_status'] === undefined) {
14919 deferred.reject(new Error('Missing required form parameter: backend_status'));
14920 return deferred.promise;
14921 }
14922
14923 if (parameters['deleted'] !== undefined) {
14924 form['deleted'] = parameters['deleted'];
14925 }
14926
14927 if (parameters['write_protect'] !== undefined) {
14928 form['write_protect'] = parameters['write_protect'];
14929 }
14930
14931 if (parameters['lazy_blocked'] !== undefined) {
14932 form['lazy_blocked'] = parameters['lazy_blocked'];
14933 }
14934
14935 if (parameters['no_sync'] !== undefined) {
14936 form['no_sync'] = parameters['no_sync'];
14937 }
14938
14939 if (parameters['account'] !== undefined) {
14940 form['account'] = parameters['account'];
14941 }
14942
14943 if (parameters['account'] === undefined) {
14944 deferred.reject(new Error('Missing required form parameter: account'));
14945 return deferred.promise;
14946 }
14947
14948 if (parameters['slice'] !== undefined) {
14949 form['slice'] = parameters['slice'];
14950 }
14951
14952 if (parameters['kind'] !== undefined) {
14953 form['kind'] = parameters['kind'];
14954 }
14955
14956 if (parameters['kind'] === undefined) {
14957 deferred.reject(new Error('Missing required form parameter: kind'));
14958 return deferred.promise;
14959 }
14960
14961 if (parameters['state'] !== undefined) {
14962 form['state'] = parameters['state'];
14963 }
14964
14965 if (parameters['state'] === undefined) {
14966 deferred.reject(new Error('Missing required form parameter: state'));
14967 return deferred.promise;
14968 }
14969
14970 if (parameters['date'] !== undefined) {
14971 form['date'] = parameters['date'];
14972 }
14973
14974 if (parameters['date'] === undefined) {
14975 deferred.reject(new Error('Missing required form parameter: date'));
14976 return deferred.promise;
14977 }
14978
14979 if (parameters['object'] !== undefined) {
14980 form['object'] = parameters['object'];
14981 }
14982
14983 if (parameters['object'] === undefined) {
14984 deferred.reject(new Error('Missing required form parameter: object'));
14985 return deferred.promise;
14986 }
14987
14988 if (parameters['amount'] !== undefined) {
14989 form['amount'] = parameters['amount'];
14990 }
14991
14992 if (parameters['amount'] === undefined) {
14993 deferred.reject(new Error('Missing required form parameter: amount'));
14994 return deferred.promise;
14995 }
14996
14997 if (parameters['coreHours'] !== undefined) {
14998 form['coreHours'] = parameters['coreHours'];
14999 }
15000
15001 if (parameters['coreHours'] === undefined) {
15002 deferred.reject(new Error('Missing required form parameter: coreHours'));
15003 return deferred.promise;
15004 }
15005
15006 if (parameters['invoice'] !== undefined) {
15007 form['invoice'] = parameters['invoice'];
15008 }
15009
15010 if (parameters.$queryParameters) {
15011 Object.keys(parameters.$queryParameters)
15012 .forEach(function(parameterName) {
15013 var parameter = parameters.$queryParameters[parameterName];
15014 queryParameters[parameterName] = parameter;
15015 });
15016 }
15017
15018 var url = domain + path;
15019 var options = {
15020 timeout: parameters.$timeout,
15021 method: 'POST',
15022 url: url,
15023 params: queryParameters,
15024 data: body,
15025 headers: headers
15026 };
15027 if (Object.keys(form).length > 0) {
15028 options.data = form;
15029 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15030 options.transformRequest = xos.transformRequest;
15031 }
15032 $http(options)
15033 .success(function(data, status, headers, config) {
15034 deferred.resolve(data);
15035 if (parameters.$cache !== undefined) {
15036 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15037 }
15038 })
15039 .error(function(data, status, headers, config) {
15040 deferred.reject({
15041 status: status,
15042 headers: headers,
15043 config: config,
15044 body: data
15045 });
15046 });
15047
15048 return deferred.promise;
15049 };
15050 /**
15051 *
15052 * @method
15053 * @name xos#Charge_Detail_GET
15054 * @param {string} pk -
15055 *
15056 */
15057 xos.prototype.Charge_Detail_GET = function(parameters) {
15058 if (parameters === undefined) {
15059 parameters = {};
15060 }
15061 var deferred = $q.defer();
15062
15063 var domain = this.domain;
15064 var path = '/xos/charges/{pk}/';
15065
15066 var body;
15067 var queryParameters = {};
15068 var headers = {};
15069 var form = {};
15070
15071 path = path.replace('{pk}', parameters['pk']);
15072
15073 if (parameters['pk'] === undefined) {
15074 deferred.reject(new Error('Missing required path parameter: pk'));
15075 return deferred.promise;
15076 }
15077
15078 if (parameters.$queryParameters) {
15079 Object.keys(parameters.$queryParameters)
15080 .forEach(function(parameterName) {
15081 var parameter = parameters.$queryParameters[parameterName];
15082 queryParameters[parameterName] = parameter;
15083 });
15084 }
15085
15086 var url = domain + path;
15087 var cached = parameters.$cache && parameters.$cache.get(url);
15088 if (cached !== undefined && parameters.$refresh !== true) {
15089 deferred.resolve(cached);
15090 return deferred.promise;
15091 }
15092 var options = {
15093 timeout: parameters.$timeout,
15094 method: 'GET',
15095 url: url,
15096 params: queryParameters,
15097 data: body,
15098 headers: headers
15099 };
15100 if (Object.keys(form).length > 0) {
15101 options.data = form;
15102 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15103 options.transformRequest = xos.transformRequest;
15104 }
15105 $http(options)
15106 .success(function(data, status, headers, config) {
15107 deferred.resolve(data);
15108 if (parameters.$cache !== undefined) {
15109 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15110 }
15111 })
15112 .error(function(data, status, headers, config) {
15113 deferred.reject({
15114 status: status,
15115 headers: headers,
15116 config: config,
15117 body: data
15118 });
15119 });
15120
15121 return deferred.promise;
15122 };
15123 /**
15124 *
15125 * @method
15126 * @name xos#Charge_Detail_PUT
15127 * @param {string} pk -
15128 * @param {string} enacted -
15129 * @param {string} policed -
15130 * @param {string} backend_register -
15131 * @param {string} backend_status -
15132 * @param {boolean} deleted -
15133 * @param {boolean} write_protect -
15134 * @param {boolean} lazy_blocked -
15135 * @param {boolean} no_sync -
15136 * @param {string} account -
15137 * @param {string} slice -
15138 * @param {choice} kind -
15139 * @param {choice} state -
15140 * @param {string} date -
15141 * @param {string} object -
15142 * @param {number} amount -
15143 * @param {number} coreHours -
15144 * @param {string} invoice -
15145 *
15146 */
15147 xos.prototype.Charge_Detail_PUT = function(parameters) {
15148 if (parameters === undefined) {
15149 parameters = {};
15150 }
15151 var deferred = $q.defer();
15152
15153 var domain = this.domain;
15154 var path = '/xos/charges/{pk}/';
15155
15156 var body;
15157 var queryParameters = {};
15158 var headers = {};
15159 var form = {};
15160
15161 path = path.replace('{pk}', parameters['pk']);
15162
15163 if (parameters['pk'] === undefined) {
15164 deferred.reject(new Error('Missing required path parameter: pk'));
15165 return deferred.promise;
15166 }
15167
15168 if (parameters['enacted'] !== undefined) {
15169 form['enacted'] = parameters['enacted'];
15170 }
15171
15172 if (parameters['policed'] !== undefined) {
15173 form['policed'] = parameters['policed'];
15174 }
15175
15176 if (parameters['backend_register'] !== undefined) {
15177 form['backend_register'] = parameters['backend_register'];
15178 }
15179
15180 if (parameters['backend_status'] !== undefined) {
15181 form['backend_status'] = parameters['backend_status'];
15182 }
15183
15184 if (parameters['backend_status'] === undefined) {
15185 deferred.reject(new Error('Missing required form parameter: backend_status'));
15186 return deferred.promise;
15187 }
15188
15189 if (parameters['deleted'] !== undefined) {
15190 form['deleted'] = parameters['deleted'];
15191 }
15192
15193 if (parameters['write_protect'] !== undefined) {
15194 form['write_protect'] = parameters['write_protect'];
15195 }
15196
15197 if (parameters['lazy_blocked'] !== undefined) {
15198 form['lazy_blocked'] = parameters['lazy_blocked'];
15199 }
15200
15201 if (parameters['no_sync'] !== undefined) {
15202 form['no_sync'] = parameters['no_sync'];
15203 }
15204
15205 if (parameters['account'] !== undefined) {
15206 form['account'] = parameters['account'];
15207 }
15208
15209 if (parameters['account'] === undefined) {
15210 deferred.reject(new Error('Missing required form parameter: account'));
15211 return deferred.promise;
15212 }
15213
15214 if (parameters['slice'] !== undefined) {
15215 form['slice'] = parameters['slice'];
15216 }
15217
15218 if (parameters['kind'] !== undefined) {
15219 form['kind'] = parameters['kind'];
15220 }
15221
15222 if (parameters['kind'] === undefined) {
15223 deferred.reject(new Error('Missing required form parameter: kind'));
15224 return deferred.promise;
15225 }
15226
15227 if (parameters['state'] !== undefined) {
15228 form['state'] = parameters['state'];
15229 }
15230
15231 if (parameters['state'] === undefined) {
15232 deferred.reject(new Error('Missing required form parameter: state'));
15233 return deferred.promise;
15234 }
15235
15236 if (parameters['date'] !== undefined) {
15237 form['date'] = parameters['date'];
15238 }
15239
15240 if (parameters['date'] === undefined) {
15241 deferred.reject(new Error('Missing required form parameter: date'));
15242 return deferred.promise;
15243 }
15244
15245 if (parameters['object'] !== undefined) {
15246 form['object'] = parameters['object'];
15247 }
15248
15249 if (parameters['object'] === undefined) {
15250 deferred.reject(new Error('Missing required form parameter: object'));
15251 return deferred.promise;
15252 }
15253
15254 if (parameters['amount'] !== undefined) {
15255 form['amount'] = parameters['amount'];
15256 }
15257
15258 if (parameters['amount'] === undefined) {
15259 deferred.reject(new Error('Missing required form parameter: amount'));
15260 return deferred.promise;
15261 }
15262
15263 if (parameters['coreHours'] !== undefined) {
15264 form['coreHours'] = parameters['coreHours'];
15265 }
15266
15267 if (parameters['coreHours'] === undefined) {
15268 deferred.reject(new Error('Missing required form parameter: coreHours'));
15269 return deferred.promise;
15270 }
15271
15272 if (parameters['invoice'] !== undefined) {
15273 form['invoice'] = parameters['invoice'];
15274 }
15275
15276 if (parameters.$queryParameters) {
15277 Object.keys(parameters.$queryParameters)
15278 .forEach(function(parameterName) {
15279 var parameter = parameters.$queryParameters[parameterName];
15280 queryParameters[parameterName] = parameter;
15281 });
15282 }
15283
15284 var url = domain + path;
15285 var options = {
15286 timeout: parameters.$timeout,
15287 method: 'PUT',
15288 url: url,
15289 params: queryParameters,
15290 data: body,
15291 headers: headers
15292 };
15293 if (Object.keys(form).length > 0) {
15294 options.data = form;
15295 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15296 options.transformRequest = xos.transformRequest;
15297 }
15298 $http(options)
15299 .success(function(data, status, headers, config) {
15300 deferred.resolve(data);
15301 if (parameters.$cache !== undefined) {
15302 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15303 }
15304 })
15305 .error(function(data, status, headers, config) {
15306 deferred.reject({
15307 status: status,
15308 headers: headers,
15309 config: config,
15310 body: data
15311 });
15312 });
15313
15314 return deferred.promise;
15315 };
15316 /**
15317 *
15318 * @method
15319 * @name xos#Charge_Detail_PATCH
15320 * @param {string} pk -
15321 * @param {string} enacted -
15322 * @param {string} policed -
15323 * @param {string} backend_register -
15324 * @param {string} backend_status -
15325 * @param {boolean} deleted -
15326 * @param {boolean} write_protect -
15327 * @param {boolean} lazy_blocked -
15328 * @param {boolean} no_sync -
15329 * @param {string} account -
15330 * @param {string} slice -
15331 * @param {choice} kind -
15332 * @param {choice} state -
15333 * @param {string} date -
15334 * @param {string} object -
15335 * @param {number} amount -
15336 * @param {number} coreHours -
15337 * @param {string} invoice -
15338 *
15339 */
15340 xos.prototype.Charge_Detail_PATCH = function(parameters) {
15341 if (parameters === undefined) {
15342 parameters = {};
15343 }
15344 var deferred = $q.defer();
15345
15346 var domain = this.domain;
15347 var path = '/xos/charges/{pk}/';
15348
15349 var body;
15350 var queryParameters = {};
15351 var headers = {};
15352 var form = {};
15353
15354 path = path.replace('{pk}', parameters['pk']);
15355
15356 if (parameters['pk'] === undefined) {
15357 deferred.reject(new Error('Missing required path parameter: pk'));
15358 return deferred.promise;
15359 }
15360
15361 if (parameters['enacted'] !== undefined) {
15362 form['enacted'] = parameters['enacted'];
15363 }
15364
15365 if (parameters['policed'] !== undefined) {
15366 form['policed'] = parameters['policed'];
15367 }
15368
15369 if (parameters['backend_register'] !== undefined) {
15370 form['backend_register'] = parameters['backend_register'];
15371 }
15372
15373 if (parameters['backend_status'] !== undefined) {
15374 form['backend_status'] = parameters['backend_status'];
15375 }
15376
15377 if (parameters['deleted'] !== undefined) {
15378 form['deleted'] = parameters['deleted'];
15379 }
15380
15381 if (parameters['write_protect'] !== undefined) {
15382 form['write_protect'] = parameters['write_protect'];
15383 }
15384
15385 if (parameters['lazy_blocked'] !== undefined) {
15386 form['lazy_blocked'] = parameters['lazy_blocked'];
15387 }
15388
15389 if (parameters['no_sync'] !== undefined) {
15390 form['no_sync'] = parameters['no_sync'];
15391 }
15392
15393 if (parameters['account'] !== undefined) {
15394 form['account'] = parameters['account'];
15395 }
15396
15397 if (parameters['slice'] !== undefined) {
15398 form['slice'] = parameters['slice'];
15399 }
15400
15401 if (parameters['kind'] !== undefined) {
15402 form['kind'] = parameters['kind'];
15403 }
15404
15405 if (parameters['state'] !== undefined) {
15406 form['state'] = parameters['state'];
15407 }
15408
15409 if (parameters['date'] !== undefined) {
15410 form['date'] = parameters['date'];
15411 }
15412
15413 if (parameters['object'] !== undefined) {
15414 form['object'] = parameters['object'];
15415 }
15416
15417 if (parameters['amount'] !== undefined) {
15418 form['amount'] = parameters['amount'];
15419 }
15420
15421 if (parameters['coreHours'] !== undefined) {
15422 form['coreHours'] = parameters['coreHours'];
15423 }
15424
15425 if (parameters['invoice'] !== undefined) {
15426 form['invoice'] = parameters['invoice'];
15427 }
15428
15429 if (parameters.$queryParameters) {
15430 Object.keys(parameters.$queryParameters)
15431 .forEach(function(parameterName) {
15432 var parameter = parameters.$queryParameters[parameterName];
15433 queryParameters[parameterName] = parameter;
15434 });
15435 }
15436
15437 var url = domain + path;
15438 var options = {
15439 timeout: parameters.$timeout,
15440 method: 'PATCH',
15441 url: url,
15442 params: queryParameters,
15443 data: body,
15444 headers: headers
15445 };
15446 if (Object.keys(form).length > 0) {
15447 options.data = form;
15448 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15449 options.transformRequest = xos.transformRequest;
15450 }
15451 $http(options)
15452 .success(function(data, status, headers, config) {
15453 deferred.resolve(data);
15454 if (parameters.$cache !== undefined) {
15455 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15456 }
15457 })
15458 .error(function(data, status, headers, config) {
15459 deferred.reject({
15460 status: status,
15461 headers: headers,
15462 config: config,
15463 body: data
15464 });
15465 });
15466
15467 return deferred.promise;
15468 };
15469 /**
15470 *
15471 * @method
15472 * @name xos#Charge_Detail_DELETE
15473 * @param {string} pk -
15474 *
15475 */
15476 xos.prototype.Charge_Detail_DELETE = function(parameters) {
15477 if (parameters === undefined) {
15478 parameters = {};
15479 }
15480 var deferred = $q.defer();
15481
15482 var domain = this.domain;
15483 var path = '/xos/charges/{pk}/';
15484
15485 var body;
15486 var queryParameters = {};
15487 var headers = {};
15488 var form = {};
15489
15490 path = path.replace('{pk}', parameters['pk']);
15491
15492 if (parameters['pk'] === undefined) {
15493 deferred.reject(new Error('Missing required path parameter: pk'));
15494 return deferred.promise;
15495 }
15496
15497 if (parameters.$queryParameters) {
15498 Object.keys(parameters.$queryParameters)
15499 .forEach(function(parameterName) {
15500 var parameter = parameters.$queryParameters[parameterName];
15501 queryParameters[parameterName] = parameter;
15502 });
15503 }
15504
15505 var url = domain + path;
15506 var options = {
15507 timeout: parameters.$timeout,
15508 method: 'DELETE',
15509 url: url,
15510 params: queryParameters,
15511 data: body,
15512 headers: headers
15513 };
15514 if (Object.keys(form).length > 0) {
15515 options.data = form;
15516 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15517 options.transformRequest = xos.transformRequest;
15518 }
15519 $http(options)
15520 .success(function(data, status, headers, config) {
15521 deferred.resolve(data);
15522 if (parameters.$cache !== undefined) {
15523 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15524 }
15525 })
15526 .error(function(data, status, headers, config) {
15527 deferred.reject({
15528 status: status,
15529 headers: headers,
15530 config: config,
15531 body: data
15532 });
15533 });
15534
15535 return deferred.promise;
15536 };
15537 /**
15538 *
15539 * @method
15540 * @name xos#Program_List_GET
15541 *
15542 */
15543 xos.prototype.Program_List_GET = function(parameters) {
15544 if (parameters === undefined) {
15545 parameters = {};
15546 }
15547 var deferred = $q.defer();
15548
15549 var domain = this.domain;
15550 var path = '/xos/programs/';
15551
15552 var body;
15553 var queryParameters = {};
15554 var headers = {};
15555 var form = {};
15556
15557 if (parameters.$queryParameters) {
15558 Object.keys(parameters.$queryParameters)
15559 .forEach(function(parameterName) {
15560 var parameter = parameters.$queryParameters[parameterName];
15561 queryParameters[parameterName] = parameter;
15562 });
15563 }
15564
15565 var url = domain + path;
15566 var cached = parameters.$cache && parameters.$cache.get(url);
15567 if (cached !== undefined && parameters.$refresh !== true) {
15568 deferred.resolve(cached);
15569 return deferred.promise;
15570 }
15571 var options = {
15572 timeout: parameters.$timeout,
15573 method: 'GET',
15574 url: url,
15575 params: queryParameters,
15576 data: body,
15577 headers: headers
15578 };
15579 if (Object.keys(form).length > 0) {
15580 options.data = form;
15581 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15582 options.transformRequest = xos.transformRequest;
15583 }
15584 $http(options)
15585 .success(function(data, status, headers, config) {
15586 deferred.resolve(data);
15587 if (parameters.$cache !== undefined) {
15588 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15589 }
15590 })
15591 .error(function(data, status, headers, config) {
15592 deferred.reject({
15593 status: status,
15594 headers: headers,
15595 config: config,
15596 body: data
15597 });
15598 });
15599
15600 return deferred.promise;
15601 };
15602 /**
15603 *
15604 * @method
15605 * @name xos#Program_List_POST
15606 * @param {string} enacted -
15607 * @param {string} policed -
15608 * @param {string} backend_register -
15609 * @param {string} backend_status -
15610 * @param {boolean} deleted -
15611 * @param {boolean} write_protect -
15612 * @param {boolean} lazy_blocked -
15613 * @param {boolean} no_sync -
15614 * @param {string} name - Service Name
15615 * @param {string} description - Description of Service
15616
15617 * @param {choice} command - Command to run
15618 * @param {string} owner -
15619 * @param {string} contents - Contents of Program
15620 * @param {string} output - Output of Program
15621 * @param {string} messages - Debug messages
15622 * @param {string} status - Status of program
15623 *
15624 */
15625 xos.prototype.Program_List_POST = function(parameters) {
15626 if (parameters === undefined) {
15627 parameters = {};
15628 }
15629 var deferred = $q.defer();
15630
15631 var domain = this.domain;
15632 var path = '/xos/programs/';
15633
15634 var body;
15635 var queryParameters = {};
15636 var headers = {};
15637 var form = {};
15638
15639 if (parameters['enacted'] !== undefined) {
15640 form['enacted'] = parameters['enacted'];
15641 }
15642
15643 if (parameters['policed'] !== undefined) {
15644 form['policed'] = parameters['policed'];
15645 }
15646
15647 if (parameters['backend_register'] !== undefined) {
15648 form['backend_register'] = parameters['backend_register'];
15649 }
15650
15651 if (parameters['backend_status'] !== undefined) {
15652 form['backend_status'] = parameters['backend_status'];
15653 }
15654
15655 if (parameters['backend_status'] === undefined) {
15656 deferred.reject(new Error('Missing required form parameter: backend_status'));
15657 return deferred.promise;
15658 }
15659
15660 if (parameters['deleted'] !== undefined) {
15661 form['deleted'] = parameters['deleted'];
15662 }
15663
15664 if (parameters['write_protect'] !== undefined) {
15665 form['write_protect'] = parameters['write_protect'];
15666 }
15667
15668 if (parameters['lazy_blocked'] !== undefined) {
15669 form['lazy_blocked'] = parameters['lazy_blocked'];
15670 }
15671
15672 if (parameters['no_sync'] !== undefined) {
15673 form['no_sync'] = parameters['no_sync'];
15674 }
15675
15676 if (parameters['name'] !== undefined) {
15677 form['name'] = parameters['name'];
15678 }
15679
15680 if (parameters['name'] === undefined) {
15681 deferred.reject(new Error('Missing required form parameter: name'));
15682 return deferred.promise;
15683 }
15684
15685 if (parameters['description'] !== undefined) {
15686 form['description'] = parameters['description'];
15687 }
15688
15689 form['kind'] = 'tosca';
15690
15691 if (parameters['kind'] === undefined) {
15692 deferred.reject(new Error('Missing required form parameter: kind'));
15693 return deferred.promise;
15694 }
15695
15696 if (parameters['command'] !== undefined) {
15697 form['command'] = parameters['command'];
15698 }
15699
15700 if (parameters['owner'] !== undefined) {
15701 form['owner'] = parameters['owner'];
15702 }
15703
15704 if (parameters['contents'] !== undefined) {
15705 form['contents'] = parameters['contents'];
15706 }
15707
15708 if (parameters['output'] !== undefined) {
15709 form['output'] = parameters['output'];
15710 }
15711
15712 if (parameters['messages'] !== undefined) {
15713 form['messages'] = parameters['messages'];
15714 }
15715
15716 if (parameters['status'] !== undefined) {
15717 form['status'] = parameters['status'];
15718 }
15719
15720 if (parameters.$queryParameters) {
15721 Object.keys(parameters.$queryParameters)
15722 .forEach(function(parameterName) {
15723 var parameter = parameters.$queryParameters[parameterName];
15724 queryParameters[parameterName] = parameter;
15725 });
15726 }
15727
15728 var url = domain + path;
15729 var options = {
15730 timeout: parameters.$timeout,
15731 method: 'POST',
15732 url: url,
15733 params: queryParameters,
15734 data: body,
15735 headers: headers
15736 };
15737 if (Object.keys(form).length > 0) {
15738 options.data = form;
15739 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15740 options.transformRequest = xos.transformRequest;
15741 }
15742 $http(options)
15743 .success(function(data, status, headers, config) {
15744 deferred.resolve(data);
15745 if (parameters.$cache !== undefined) {
15746 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15747 }
15748 })
15749 .error(function(data, status, headers, config) {
15750 deferred.reject({
15751 status: status,
15752 headers: headers,
15753 config: config,
15754 body: data
15755 });
15756 });
15757
15758 return deferred.promise;
15759 };
15760 /**
15761 *
15762 * @method
15763 * @name xos#Program_Detail_GET
15764 * @param {string} pk -
15765 *
15766 */
15767 xos.prototype.Program_Detail_GET = function(parameters) {
15768 if (parameters === undefined) {
15769 parameters = {};
15770 }
15771 var deferred = $q.defer();
15772
15773 var domain = this.domain;
15774 var path = '/xos/programs/{pk}/';
15775
15776 var body;
15777 var queryParameters = {};
15778 var headers = {};
15779 var form = {};
15780
15781 path = path.replace('{pk}', parameters['pk']);
15782
15783 if (parameters['pk'] === undefined) {
15784 deferred.reject(new Error('Missing required path parameter: pk'));
15785 return deferred.promise;
15786 }
15787
15788 if (parameters.$queryParameters) {
15789 Object.keys(parameters.$queryParameters)
15790 .forEach(function(parameterName) {
15791 var parameter = parameters.$queryParameters[parameterName];
15792 queryParameters[parameterName] = parameter;
15793 });
15794 }
15795
15796 var url = domain + path;
15797 var cached = parameters.$cache && parameters.$cache.get(url);
15798 if (cached !== undefined && parameters.$refresh !== true) {
15799 deferred.resolve(cached);
15800 return deferred.promise;
15801 }
15802 var options = {
15803 timeout: parameters.$timeout,
15804 method: 'GET',
15805 url: url,
15806 params: queryParameters,
15807 data: body,
15808 headers: headers
15809 };
15810 if (Object.keys(form).length > 0) {
15811 options.data = form;
15812 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15813 options.transformRequest = xos.transformRequest;
15814 }
15815 $http(options)
15816 .success(function(data, status, headers, config) {
15817 deferred.resolve(data);
15818 if (parameters.$cache !== undefined) {
15819 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15820 }
15821 })
15822 .error(function(data, status, headers, config) {
15823 deferred.reject({
15824 status: status,
15825 headers: headers,
15826 config: config,
15827 body: data
15828 });
15829 });
15830
15831 return deferred.promise;
15832 };
15833 /**
15834 *
15835 * @method
15836 * @name xos#Program_Detail_PUT
15837 * @param {string} pk -
15838 * @param {string} enacted -
15839 * @param {string} policed -
15840 * @param {string} backend_register -
15841 * @param {string} backend_status -
15842 * @param {boolean} deleted -
15843 * @param {boolean} write_protect -
15844 * @param {boolean} lazy_blocked -
15845 * @param {boolean} no_sync -
15846 * @param {string} name - Service Name
15847 * @param {string} description - Description of Service
15848
15849 * @param {choice} command - Command to run
15850 * @param {string} owner -
15851 * @param {string} contents - Contents of Program
15852 * @param {string} output - Output of Program
15853 * @param {string} messages - Debug messages
15854 * @param {string} status - Status of program
15855 *
15856 */
15857 xos.prototype.Program_Detail_PUT = function(parameters) {
15858 if (parameters === undefined) {
15859 parameters = {};
15860 }
15861 var deferred = $q.defer();
15862
15863 var domain = this.domain;
15864 var path = '/xos/programs/{pk}/';
15865
15866 var body;
15867 var queryParameters = {};
15868 var headers = {};
15869 var form = {};
15870
15871 path = path.replace('{pk}', parameters['pk']);
15872
15873 if (parameters['pk'] === undefined) {
15874 deferred.reject(new Error('Missing required path parameter: pk'));
15875 return deferred.promise;
15876 }
15877
15878 if (parameters['enacted'] !== undefined) {
15879 form['enacted'] = parameters['enacted'];
15880 }
15881
15882 if (parameters['policed'] !== undefined) {
15883 form['policed'] = parameters['policed'];
15884 }
15885
15886 if (parameters['backend_register'] !== undefined) {
15887 form['backend_register'] = parameters['backend_register'];
15888 }
15889
15890 if (parameters['backend_status'] !== undefined) {
15891 form['backend_status'] = parameters['backend_status'];
15892 }
15893
15894 if (parameters['backend_status'] === undefined) {
15895 deferred.reject(new Error('Missing required form parameter: backend_status'));
15896 return deferred.promise;
15897 }
15898
15899 if (parameters['deleted'] !== undefined) {
15900 form['deleted'] = parameters['deleted'];
15901 }
15902
15903 if (parameters['write_protect'] !== undefined) {
15904 form['write_protect'] = parameters['write_protect'];
15905 }
15906
15907 if (parameters['lazy_blocked'] !== undefined) {
15908 form['lazy_blocked'] = parameters['lazy_blocked'];
15909 }
15910
15911 if (parameters['no_sync'] !== undefined) {
15912 form['no_sync'] = parameters['no_sync'];
15913 }
15914
15915 if (parameters['name'] !== undefined) {
15916 form['name'] = parameters['name'];
15917 }
15918
15919 if (parameters['name'] === undefined) {
15920 deferred.reject(new Error('Missing required form parameter: name'));
15921 return deferred.promise;
15922 }
15923
15924 if (parameters['description'] !== undefined) {
15925 form['description'] = parameters['description'];
15926 }
15927
15928 form['kind'] = 'tosca';
15929
15930 if (parameters['kind'] === undefined) {
15931 deferred.reject(new Error('Missing required form parameter: kind'));
15932 return deferred.promise;
15933 }
15934
15935 if (parameters['command'] !== undefined) {
15936 form['command'] = parameters['command'];
15937 }
15938
15939 if (parameters['owner'] !== undefined) {
15940 form['owner'] = parameters['owner'];
15941 }
15942
15943 if (parameters['contents'] !== undefined) {
15944 form['contents'] = parameters['contents'];
15945 }
15946
15947 if (parameters['output'] !== undefined) {
15948 form['output'] = parameters['output'];
15949 }
15950
15951 if (parameters['messages'] !== undefined) {
15952 form['messages'] = parameters['messages'];
15953 }
15954
15955 if (parameters['status'] !== undefined) {
15956 form['status'] = parameters['status'];
15957 }
15958
15959 if (parameters.$queryParameters) {
15960 Object.keys(parameters.$queryParameters)
15961 .forEach(function(parameterName) {
15962 var parameter = parameters.$queryParameters[parameterName];
15963 queryParameters[parameterName] = parameter;
15964 });
15965 }
15966
15967 var url = domain + path;
15968 var options = {
15969 timeout: parameters.$timeout,
15970 method: 'PUT',
15971 url: url,
15972 params: queryParameters,
15973 data: body,
15974 headers: headers
15975 };
15976 if (Object.keys(form).length > 0) {
15977 options.data = form;
15978 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
15979 options.transformRequest = xos.transformRequest;
15980 }
15981 $http(options)
15982 .success(function(data, status, headers, config) {
15983 deferred.resolve(data);
15984 if (parameters.$cache !== undefined) {
15985 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
15986 }
15987 })
15988 .error(function(data, status, headers, config) {
15989 deferred.reject({
15990 status: status,
15991 headers: headers,
15992 config: config,
15993 body: data
15994 });
15995 });
15996
15997 return deferred.promise;
15998 };
15999 /**
16000 *
16001 * @method
16002 * @name xos#Program_Detail_PATCH
16003 * @param {string} pk -
16004 * @param {string} enacted -
16005 * @param {string} policed -
16006 * @param {string} backend_register -
16007 * @param {string} backend_status -
16008 * @param {boolean} deleted -
16009 * @param {boolean} write_protect -
16010 * @param {boolean} lazy_blocked -
16011 * @param {boolean} no_sync -
16012 * @param {string} name - Service Name
16013 * @param {string} description - Description of Service
16014
16015 * @param {choice} command - Command to run
16016 * @param {string} owner -
16017 * @param {string} contents - Contents of Program
16018 * @param {string} output - Output of Program
16019 * @param {string} messages - Debug messages
16020 * @param {string} status - Status of program
16021 *
16022 */
16023 xos.prototype.Program_Detail_PATCH = function(parameters) {
16024 if (parameters === undefined) {
16025 parameters = {};
16026 }
16027 var deferred = $q.defer();
16028
16029 var domain = this.domain;
16030 var path = '/xos/programs/{pk}/';
16031
16032 var body;
16033 var queryParameters = {};
16034 var headers = {};
16035 var form = {};
16036
16037 path = path.replace('{pk}', parameters['pk']);
16038
16039 if (parameters['pk'] === undefined) {
16040 deferred.reject(new Error('Missing required path parameter: pk'));
16041 return deferred.promise;
16042 }
16043
16044 if (parameters['enacted'] !== undefined) {
16045 form['enacted'] = parameters['enacted'];
16046 }
16047
16048 if (parameters['policed'] !== undefined) {
16049 form['policed'] = parameters['policed'];
16050 }
16051
16052 if (parameters['backend_register'] !== undefined) {
16053 form['backend_register'] = parameters['backend_register'];
16054 }
16055
16056 if (parameters['backend_status'] !== undefined) {
16057 form['backend_status'] = parameters['backend_status'];
16058 }
16059
16060 if (parameters['deleted'] !== undefined) {
16061 form['deleted'] = parameters['deleted'];
16062 }
16063
16064 if (parameters['write_protect'] !== undefined) {
16065 form['write_protect'] = parameters['write_protect'];
16066 }
16067
16068 if (parameters['lazy_blocked'] !== undefined) {
16069 form['lazy_blocked'] = parameters['lazy_blocked'];
16070 }
16071
16072 if (parameters['no_sync'] !== undefined) {
16073 form['no_sync'] = parameters['no_sync'];
16074 }
16075
16076 if (parameters['name'] !== undefined) {
16077 form['name'] = parameters['name'];
16078 }
16079
16080 if (parameters['description'] !== undefined) {
16081 form['description'] = parameters['description'];
16082 }
16083
16084 form['kind'] = 'tosca';
16085
16086 if (parameters['command'] !== undefined) {
16087 form['command'] = parameters['command'];
16088 }
16089
16090 if (parameters['owner'] !== undefined) {
16091 form['owner'] = parameters['owner'];
16092 }
16093
16094 if (parameters['contents'] !== undefined) {
16095 form['contents'] = parameters['contents'];
16096 }
16097
16098 if (parameters['output'] !== undefined) {
16099 form['output'] = parameters['output'];
16100 }
16101
16102 if (parameters['messages'] !== undefined) {
16103 form['messages'] = parameters['messages'];
16104 }
16105
16106 if (parameters['status'] !== undefined) {
16107 form['status'] = parameters['status'];
16108 }
16109
16110 if (parameters.$queryParameters) {
16111 Object.keys(parameters.$queryParameters)
16112 .forEach(function(parameterName) {
16113 var parameter = parameters.$queryParameters[parameterName];
16114 queryParameters[parameterName] = parameter;
16115 });
16116 }
16117
16118 var url = domain + path;
16119 var options = {
16120 timeout: parameters.$timeout,
16121 method: 'PATCH',
16122 url: url,
16123 params: queryParameters,
16124 data: body,
16125 headers: headers
16126 };
16127 if (Object.keys(form).length > 0) {
16128 options.data = form;
16129 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16130 options.transformRequest = xos.transformRequest;
16131 }
16132 $http(options)
16133 .success(function(data, status, headers, config) {
16134 deferred.resolve(data);
16135 if (parameters.$cache !== undefined) {
16136 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16137 }
16138 })
16139 .error(function(data, status, headers, config) {
16140 deferred.reject({
16141 status: status,
16142 headers: headers,
16143 config: config,
16144 body: data
16145 });
16146 });
16147
16148 return deferred.promise;
16149 };
16150 /**
16151 *
16152 * @method
16153 * @name xos#Program_Detail_DELETE
16154 * @param {string} pk -
16155 *
16156 */
16157 xos.prototype.Program_Detail_DELETE = function(parameters) {
16158 if (parameters === undefined) {
16159 parameters = {};
16160 }
16161 var deferred = $q.defer();
16162
16163 var domain = this.domain;
16164 var path = '/xos/programs/{pk}/';
16165
16166 var body;
16167 var queryParameters = {};
16168 var headers = {};
16169 var form = {};
16170
16171 path = path.replace('{pk}', parameters['pk']);
16172
16173 if (parameters['pk'] === undefined) {
16174 deferred.reject(new Error('Missing required path parameter: pk'));
16175 return deferred.promise;
16176 }
16177
16178 if (parameters.$queryParameters) {
16179 Object.keys(parameters.$queryParameters)
16180 .forEach(function(parameterName) {
16181 var parameter = parameters.$queryParameters[parameterName];
16182 queryParameters[parameterName] = parameter;
16183 });
16184 }
16185
16186 var url = domain + path;
16187 var options = {
16188 timeout: parameters.$timeout,
16189 method: 'DELETE',
16190 url: url,
16191 params: queryParameters,
16192 data: body,
16193 headers: headers
16194 };
16195 if (Object.keys(form).length > 0) {
16196 options.data = form;
16197 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16198 options.transformRequest = xos.transformRequest;
16199 }
16200 $http(options)
16201 .success(function(data, status, headers, config) {
16202 deferred.resolve(data);
16203 if (parameters.$cache !== undefined) {
16204 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16205 }
16206 })
16207 .error(function(data, status, headers, config) {
16208 deferred.reject({
16209 status: status,
16210 headers: headers,
16211 config: config,
16212 body: data
16213 });
16214 });
16215
16216 return deferred.promise;
16217 };
16218 /**
16219 *
16220 * @method
16221 * @name xos#Role_List_GET
16222 *
16223 */
16224 xos.prototype.Role_List_GET = function(parameters) {
16225 if (parameters === undefined) {
16226 parameters = {};
16227 }
16228 var deferred = $q.defer();
16229
16230 var domain = this.domain;
16231 var path = '/xos/roles/';
16232
16233 var body;
16234 var queryParameters = {};
16235 var headers = {};
16236 var form = {};
16237
16238 if (parameters.$queryParameters) {
16239 Object.keys(parameters.$queryParameters)
16240 .forEach(function(parameterName) {
16241 var parameter = parameters.$queryParameters[parameterName];
16242 queryParameters[parameterName] = parameter;
16243 });
16244 }
16245
16246 var url = domain + path;
16247 var cached = parameters.$cache && parameters.$cache.get(url);
16248 if (cached !== undefined && parameters.$refresh !== true) {
16249 deferred.resolve(cached);
16250 return deferred.promise;
16251 }
16252 var options = {
16253 timeout: parameters.$timeout,
16254 method: 'GET',
16255 url: url,
16256 params: queryParameters,
16257 data: body,
16258 headers: headers
16259 };
16260 if (Object.keys(form).length > 0) {
16261 options.data = form;
16262 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16263 options.transformRequest = xos.transformRequest;
16264 }
16265 $http(options)
16266 .success(function(data, status, headers, config) {
16267 deferred.resolve(data);
16268 if (parameters.$cache !== undefined) {
16269 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16270 }
16271 })
16272 .error(function(data, status, headers, config) {
16273 deferred.reject({
16274 status: status,
16275 headers: headers,
16276 config: config,
16277 body: data
16278 });
16279 });
16280
16281 return deferred.promise;
16282 };
16283 /**
16284 *
16285 * @method
16286 * @name xos#Role_List_POST
16287 * @param {string} enacted -
16288 * @param {string} policed -
16289 * @param {string} backend_register -
16290 * @param {string} backend_status -
16291 * @param {boolean} deleted -
16292 * @param {boolean} write_protect -
16293 * @param {boolean} lazy_blocked -
16294 * @param {boolean} no_sync -
16295 * @param {string} role_type -
16296 * @param {string} role -
16297 * @param {string} description -
16298 * @param {string} content_type -
16299 *
16300 */
16301 xos.prototype.Role_List_POST = function(parameters) {
16302 if (parameters === undefined) {
16303 parameters = {};
16304 }
16305 var deferred = $q.defer();
16306
16307 var domain = this.domain;
16308 var path = '/xos/roles/';
16309
16310 var body;
16311 var queryParameters = {};
16312 var headers = {};
16313 var form = {};
16314
16315 if (parameters['enacted'] !== undefined) {
16316 form['enacted'] = parameters['enacted'];
16317 }
16318
16319 if (parameters['policed'] !== undefined) {
16320 form['policed'] = parameters['policed'];
16321 }
16322
16323 if (parameters['backend_register'] !== undefined) {
16324 form['backend_register'] = parameters['backend_register'];
16325 }
16326
16327 if (parameters['backend_status'] !== undefined) {
16328 form['backend_status'] = parameters['backend_status'];
16329 }
16330
16331 if (parameters['backend_status'] === undefined) {
16332 deferred.reject(new Error('Missing required form parameter: backend_status'));
16333 return deferred.promise;
16334 }
16335
16336 if (parameters['deleted'] !== undefined) {
16337 form['deleted'] = parameters['deleted'];
16338 }
16339
16340 if (parameters['write_protect'] !== undefined) {
16341 form['write_protect'] = parameters['write_protect'];
16342 }
16343
16344 if (parameters['lazy_blocked'] !== undefined) {
16345 form['lazy_blocked'] = parameters['lazy_blocked'];
16346 }
16347
16348 if (parameters['no_sync'] !== undefined) {
16349 form['no_sync'] = parameters['no_sync'];
16350 }
16351
16352 if (parameters['role_type'] !== undefined) {
16353 form['role_type'] = parameters['role_type'];
16354 }
16355
16356 if (parameters['role_type'] === undefined) {
16357 deferred.reject(new Error('Missing required form parameter: role_type'));
16358 return deferred.promise;
16359 }
16360
16361 if (parameters['role'] !== undefined) {
16362 form['role'] = parameters['role'];
16363 }
16364
16365 if (parameters['description'] !== undefined) {
16366 form['description'] = parameters['description'];
16367 }
16368
16369 if (parameters['description'] === undefined) {
16370 deferred.reject(new Error('Missing required form parameter: description'));
16371 return deferred.promise;
16372 }
16373
16374 if (parameters['content_type'] !== undefined) {
16375 form['content_type'] = parameters['content_type'];
16376 }
16377
16378 if (parameters['content_type'] === undefined) {
16379 deferred.reject(new Error('Missing required form parameter: content_type'));
16380 return deferred.promise;
16381 }
16382
16383 if (parameters.$queryParameters) {
16384 Object.keys(parameters.$queryParameters)
16385 .forEach(function(parameterName) {
16386 var parameter = parameters.$queryParameters[parameterName];
16387 queryParameters[parameterName] = parameter;
16388 });
16389 }
16390
16391 var url = domain + path;
16392 var options = {
16393 timeout: parameters.$timeout,
16394 method: 'POST',
16395 url: url,
16396 params: queryParameters,
16397 data: body,
16398 headers: headers
16399 };
16400 if (Object.keys(form).length > 0) {
16401 options.data = form;
16402 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16403 options.transformRequest = xos.transformRequest;
16404 }
16405 $http(options)
16406 .success(function(data, status, headers, config) {
16407 deferred.resolve(data);
16408 if (parameters.$cache !== undefined) {
16409 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16410 }
16411 })
16412 .error(function(data, status, headers, config) {
16413 deferred.reject({
16414 status: status,
16415 headers: headers,
16416 config: config,
16417 body: data
16418 });
16419 });
16420
16421 return deferred.promise;
16422 };
16423 /**
16424 *
16425 * @method
16426 * @name xos#Role_Detail_GET
16427 * @param {string} pk -
16428 *
16429 */
16430 xos.prototype.Role_Detail_GET = function(parameters) {
16431 if (parameters === undefined) {
16432 parameters = {};
16433 }
16434 var deferred = $q.defer();
16435
16436 var domain = this.domain;
16437 var path = '/xos/roles/{pk}/';
16438
16439 var body;
16440 var queryParameters = {};
16441 var headers = {};
16442 var form = {};
16443
16444 path = path.replace('{pk}', parameters['pk']);
16445
16446 if (parameters['pk'] === undefined) {
16447 deferred.reject(new Error('Missing required path parameter: pk'));
16448 return deferred.promise;
16449 }
16450
16451 if (parameters.$queryParameters) {
16452 Object.keys(parameters.$queryParameters)
16453 .forEach(function(parameterName) {
16454 var parameter = parameters.$queryParameters[parameterName];
16455 queryParameters[parameterName] = parameter;
16456 });
16457 }
16458
16459 var url = domain + path;
16460 var cached = parameters.$cache && parameters.$cache.get(url);
16461 if (cached !== undefined && parameters.$refresh !== true) {
16462 deferred.resolve(cached);
16463 return deferred.promise;
16464 }
16465 var options = {
16466 timeout: parameters.$timeout,
16467 method: 'GET',
16468 url: url,
16469 params: queryParameters,
16470 data: body,
16471 headers: headers
16472 };
16473 if (Object.keys(form).length > 0) {
16474 options.data = form;
16475 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16476 options.transformRequest = xos.transformRequest;
16477 }
16478 $http(options)
16479 .success(function(data, status, headers, config) {
16480 deferred.resolve(data);
16481 if (parameters.$cache !== undefined) {
16482 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16483 }
16484 })
16485 .error(function(data, status, headers, config) {
16486 deferred.reject({
16487 status: status,
16488 headers: headers,
16489 config: config,
16490 body: data
16491 });
16492 });
16493
16494 return deferred.promise;
16495 };
16496 /**
16497 *
16498 * @method
16499 * @name xos#Role_Detail_PUT
16500 * @param {string} pk -
16501 * @param {string} enacted -
16502 * @param {string} policed -
16503 * @param {string} backend_register -
16504 * @param {string} backend_status -
16505 * @param {boolean} deleted -
16506 * @param {boolean} write_protect -
16507 * @param {boolean} lazy_blocked -
16508 * @param {boolean} no_sync -
16509 * @param {string} role_type -
16510 * @param {string} role -
16511 * @param {string} description -
16512 * @param {string} content_type -
16513 *
16514 */
16515 xos.prototype.Role_Detail_PUT = function(parameters) {
16516 if (parameters === undefined) {
16517 parameters = {};
16518 }
16519 var deferred = $q.defer();
16520
16521 var domain = this.domain;
16522 var path = '/xos/roles/{pk}/';
16523
16524 var body;
16525 var queryParameters = {};
16526 var headers = {};
16527 var form = {};
16528
16529 path = path.replace('{pk}', parameters['pk']);
16530
16531 if (parameters['pk'] === undefined) {
16532 deferred.reject(new Error('Missing required path parameter: pk'));
16533 return deferred.promise;
16534 }
16535
16536 if (parameters['enacted'] !== undefined) {
16537 form['enacted'] = parameters['enacted'];
16538 }
16539
16540 if (parameters['policed'] !== undefined) {
16541 form['policed'] = parameters['policed'];
16542 }
16543
16544 if (parameters['backend_register'] !== undefined) {
16545 form['backend_register'] = parameters['backend_register'];
16546 }
16547
16548 if (parameters['backend_status'] !== undefined) {
16549 form['backend_status'] = parameters['backend_status'];
16550 }
16551
16552 if (parameters['backend_status'] === undefined) {
16553 deferred.reject(new Error('Missing required form parameter: backend_status'));
16554 return deferred.promise;
16555 }
16556
16557 if (parameters['deleted'] !== undefined) {
16558 form['deleted'] = parameters['deleted'];
16559 }
16560
16561 if (parameters['write_protect'] !== undefined) {
16562 form['write_protect'] = parameters['write_protect'];
16563 }
16564
16565 if (parameters['lazy_blocked'] !== undefined) {
16566 form['lazy_blocked'] = parameters['lazy_blocked'];
16567 }
16568
16569 if (parameters['no_sync'] !== undefined) {
16570 form['no_sync'] = parameters['no_sync'];
16571 }
16572
16573 if (parameters['role_type'] !== undefined) {
16574 form['role_type'] = parameters['role_type'];
16575 }
16576
16577 if (parameters['role_type'] === undefined) {
16578 deferred.reject(new Error('Missing required form parameter: role_type'));
16579 return deferred.promise;
16580 }
16581
16582 if (parameters['role'] !== undefined) {
16583 form['role'] = parameters['role'];
16584 }
16585
16586 if (parameters['description'] !== undefined) {
16587 form['description'] = parameters['description'];
16588 }
16589
16590 if (parameters['description'] === undefined) {
16591 deferred.reject(new Error('Missing required form parameter: description'));
16592 return deferred.promise;
16593 }
16594
16595 if (parameters['content_type'] !== undefined) {
16596 form['content_type'] = parameters['content_type'];
16597 }
16598
16599 if (parameters['content_type'] === undefined) {
16600 deferred.reject(new Error('Missing required form parameter: content_type'));
16601 return deferred.promise;
16602 }
16603
16604 if (parameters.$queryParameters) {
16605 Object.keys(parameters.$queryParameters)
16606 .forEach(function(parameterName) {
16607 var parameter = parameters.$queryParameters[parameterName];
16608 queryParameters[parameterName] = parameter;
16609 });
16610 }
16611
16612 var url = domain + path;
16613 var options = {
16614 timeout: parameters.$timeout,
16615 method: 'PUT',
16616 url: url,
16617 params: queryParameters,
16618 data: body,
16619 headers: headers
16620 };
16621 if (Object.keys(form).length > 0) {
16622 options.data = form;
16623 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16624 options.transformRequest = xos.transformRequest;
16625 }
16626 $http(options)
16627 .success(function(data, status, headers, config) {
16628 deferred.resolve(data);
16629 if (parameters.$cache !== undefined) {
16630 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16631 }
16632 })
16633 .error(function(data, status, headers, config) {
16634 deferred.reject({
16635 status: status,
16636 headers: headers,
16637 config: config,
16638 body: data
16639 });
16640 });
16641
16642 return deferred.promise;
16643 };
16644 /**
16645 *
16646 * @method
16647 * @name xos#Role_Detail_PATCH
16648 * @param {string} pk -
16649 * @param {string} enacted -
16650 * @param {string} policed -
16651 * @param {string} backend_register -
16652 * @param {string} backend_status -
16653 * @param {boolean} deleted -
16654 * @param {boolean} write_protect -
16655 * @param {boolean} lazy_blocked -
16656 * @param {boolean} no_sync -
16657 * @param {string} role_type -
16658 * @param {string} role -
16659 * @param {string} description -
16660 * @param {string} content_type -
16661 *
16662 */
16663 xos.prototype.Role_Detail_PATCH = function(parameters) {
16664 if (parameters === undefined) {
16665 parameters = {};
16666 }
16667 var deferred = $q.defer();
16668
16669 var domain = this.domain;
16670 var path = '/xos/roles/{pk}/';
16671
16672 var body;
16673 var queryParameters = {};
16674 var headers = {};
16675 var form = {};
16676
16677 path = path.replace('{pk}', parameters['pk']);
16678
16679 if (parameters['pk'] === undefined) {
16680 deferred.reject(new Error('Missing required path parameter: pk'));
16681 return deferred.promise;
16682 }
16683
16684 if (parameters['enacted'] !== undefined) {
16685 form['enacted'] = parameters['enacted'];
16686 }
16687
16688 if (parameters['policed'] !== undefined) {
16689 form['policed'] = parameters['policed'];
16690 }
16691
16692 if (parameters['backend_register'] !== undefined) {
16693 form['backend_register'] = parameters['backend_register'];
16694 }
16695
16696 if (parameters['backend_status'] !== undefined) {
16697 form['backend_status'] = parameters['backend_status'];
16698 }
16699
16700 if (parameters['deleted'] !== undefined) {
16701 form['deleted'] = parameters['deleted'];
16702 }
16703
16704 if (parameters['write_protect'] !== undefined) {
16705 form['write_protect'] = parameters['write_protect'];
16706 }
16707
16708 if (parameters['lazy_blocked'] !== undefined) {
16709 form['lazy_blocked'] = parameters['lazy_blocked'];
16710 }
16711
16712 if (parameters['no_sync'] !== undefined) {
16713 form['no_sync'] = parameters['no_sync'];
16714 }
16715
16716 if (parameters['role_type'] !== undefined) {
16717 form['role_type'] = parameters['role_type'];
16718 }
16719
16720 if (parameters['role'] !== undefined) {
16721 form['role'] = parameters['role'];
16722 }
16723
16724 if (parameters['description'] !== undefined) {
16725 form['description'] = parameters['description'];
16726 }
16727
16728 if (parameters['content_type'] !== undefined) {
16729 form['content_type'] = parameters['content_type'];
16730 }
16731
16732 if (parameters.$queryParameters) {
16733 Object.keys(parameters.$queryParameters)
16734 .forEach(function(parameterName) {
16735 var parameter = parameters.$queryParameters[parameterName];
16736 queryParameters[parameterName] = parameter;
16737 });
16738 }
16739
16740 var url = domain + path;
16741 var options = {
16742 timeout: parameters.$timeout,
16743 method: 'PATCH',
16744 url: url,
16745 params: queryParameters,
16746 data: body,
16747 headers: headers
16748 };
16749 if (Object.keys(form).length > 0) {
16750 options.data = form;
16751 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16752 options.transformRequest = xos.transformRequest;
16753 }
16754 $http(options)
16755 .success(function(data, status, headers, config) {
16756 deferred.resolve(data);
16757 if (parameters.$cache !== undefined) {
16758 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16759 }
16760 })
16761 .error(function(data, status, headers, config) {
16762 deferred.reject({
16763 status: status,
16764 headers: headers,
16765 config: config,
16766 body: data
16767 });
16768 });
16769
16770 return deferred.promise;
16771 };
16772 /**
16773 *
16774 * @method
16775 * @name xos#Role_Detail_DELETE
16776 * @param {string} pk -
16777 *
16778 */
16779 xos.prototype.Role_Detail_DELETE = function(parameters) {
16780 if (parameters === undefined) {
16781 parameters = {};
16782 }
16783 var deferred = $q.defer();
16784
16785 var domain = this.domain;
16786 var path = '/xos/roles/{pk}/';
16787
16788 var body;
16789 var queryParameters = {};
16790 var headers = {};
16791 var form = {};
16792
16793 path = path.replace('{pk}', parameters['pk']);
16794
16795 if (parameters['pk'] === undefined) {
16796 deferred.reject(new Error('Missing required path parameter: pk'));
16797 return deferred.promise;
16798 }
16799
16800 if (parameters.$queryParameters) {
16801 Object.keys(parameters.$queryParameters)
16802 .forEach(function(parameterName) {
16803 var parameter = parameters.$queryParameters[parameterName];
16804 queryParameters[parameterName] = parameter;
16805 });
16806 }
16807
16808 var url = domain + path;
16809 var options = {
16810 timeout: parameters.$timeout,
16811 method: 'DELETE',
16812 url: url,
16813 params: queryParameters,
16814 data: body,
16815 headers: headers
16816 };
16817 if (Object.keys(form).length > 0) {
16818 options.data = form;
16819 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16820 options.transformRequest = xos.transformRequest;
16821 }
16822 $http(options)
16823 .success(function(data, status, headers, config) {
16824 deferred.resolve(data);
16825 if (parameters.$cache !== undefined) {
16826 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16827 }
16828 })
16829 .error(function(data, status, headers, config) {
16830 deferred.reject({
16831 status: status,
16832 headers: headers,
16833 config: config,
16834 body: data
16835 });
16836 });
16837
16838 return deferred.promise;
16839 };
16840 /**
16841 *
16842 * @method
16843 * @name xos#Usable_Object_List_GET
16844 *
16845 */
16846 xos.prototype.Usable_Object_List_GET = function(parameters) {
16847 if (parameters === undefined) {
16848 parameters = {};
16849 }
16850 var deferred = $q.defer();
16851
16852 var domain = this.domain;
16853 var path = '/xos/usableobjects/';
16854
16855 var body;
16856 var queryParameters = {};
16857 var headers = {};
16858 var form = {};
16859
16860 if (parameters.$queryParameters) {
16861 Object.keys(parameters.$queryParameters)
16862 .forEach(function(parameterName) {
16863 var parameter = parameters.$queryParameters[parameterName];
16864 queryParameters[parameterName] = parameter;
16865 });
16866 }
16867
16868 var url = domain + path;
16869 var cached = parameters.$cache && parameters.$cache.get(url);
16870 if (cached !== undefined && parameters.$refresh !== true) {
16871 deferred.resolve(cached);
16872 return deferred.promise;
16873 }
16874 var options = {
16875 timeout: parameters.$timeout,
16876 method: 'GET',
16877 url: url,
16878 params: queryParameters,
16879 data: body,
16880 headers: headers
16881 };
16882 if (Object.keys(form).length > 0) {
16883 options.data = form;
16884 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
16885 options.transformRequest = xos.transformRequest;
16886 }
16887 $http(options)
16888 .success(function(data, status, headers, config) {
16889 deferred.resolve(data);
16890 if (parameters.$cache !== undefined) {
16891 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
16892 }
16893 })
16894 .error(function(data, status, headers, config) {
16895 deferred.reject({
16896 status: status,
16897 headers: headers,
16898 config: config,
16899 body: data
16900 });
16901 });
16902
16903 return deferred.promise;
16904 };
16905 /**
16906 *
16907 * @method
16908 * @name xos#Usable_Object_List_POST
16909 * @param {string} enacted -
16910 * @param {string} policed -
16911 * @param {string} backend_register -
16912 * @param {string} backend_status -
16913 * @param {boolean} deleted -
16914 * @param {boolean} write_protect -
16915 * @param {boolean} lazy_blocked -
16916 * @param {boolean} no_sync -
16917 * @param {string} name -
16918 *
16919 */
16920 xos.prototype.Usable_Object_List_POST = function(parameters) {
16921 if (parameters === undefined) {
16922 parameters = {};
16923 }
16924 var deferred = $q.defer();
16925
16926 var domain = this.domain;
16927 var path = '/xos/usableobjects/';
16928
16929 var body;
16930 var queryParameters = {};
16931 var headers = {};
16932 var form = {};
16933
16934 if (parameters['enacted'] !== undefined) {
16935 form['enacted'] = parameters['enacted'];
16936 }
16937
16938 if (parameters['policed'] !== undefined) {
16939 form['policed'] = parameters['policed'];
16940 }
16941
16942 if (parameters['backend_register'] !== undefined) {
16943 form['backend_register'] = parameters['backend_register'];
16944 }
16945
16946 if (parameters['backend_status'] !== undefined) {
16947 form['backend_status'] = parameters['backend_status'];
16948 }
16949
16950 if (parameters['backend_status'] === undefined) {
16951 deferred.reject(new Error('Missing required form parameter: backend_status'));
16952 return deferred.promise;
16953 }
16954
16955 if (parameters['deleted'] !== undefined) {
16956 form['deleted'] = parameters['deleted'];
16957 }
16958
16959 if (parameters['write_protect'] !== undefined) {
16960 form['write_protect'] = parameters['write_protect'];
16961 }
16962
16963 if (parameters['lazy_blocked'] !== undefined) {
16964 form['lazy_blocked'] = parameters['lazy_blocked'];
16965 }
16966
16967 if (parameters['no_sync'] !== undefined) {
16968 form['no_sync'] = parameters['no_sync'];
16969 }
16970
16971 if (parameters['name'] !== undefined) {
16972 form['name'] = parameters['name'];
16973 }
16974
16975 if (parameters['name'] === undefined) {
16976 deferred.reject(new Error('Missing required form parameter: name'));
16977 return deferred.promise;
16978 }
16979
16980 if (parameters.$queryParameters) {
16981 Object.keys(parameters.$queryParameters)
16982 .forEach(function(parameterName) {
16983 var parameter = parameters.$queryParameters[parameterName];
16984 queryParameters[parameterName] = parameter;
16985 });
16986 }
16987
16988 var url = domain + path;
16989 var options = {
16990 timeout: parameters.$timeout,
16991 method: 'POST',
16992 url: url,
16993 params: queryParameters,
16994 data: body,
16995 headers: headers
16996 };
16997 if (Object.keys(form).length > 0) {
16998 options.data = form;
16999 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17000 options.transformRequest = xos.transformRequest;
17001 }
17002 $http(options)
17003 .success(function(data, status, headers, config) {
17004 deferred.resolve(data);
17005 if (parameters.$cache !== undefined) {
17006 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17007 }
17008 })
17009 .error(function(data, status, headers, config) {
17010 deferred.reject({
17011 status: status,
17012 headers: headers,
17013 config: config,
17014 body: data
17015 });
17016 });
17017
17018 return deferred.promise;
17019 };
17020 /**
17021 *
17022 * @method
17023 * @name xos#Usable_Object_Detail_GET
17024 * @param {string} pk -
17025 *
17026 */
17027 xos.prototype.Usable_Object_Detail_GET = function(parameters) {
17028 if (parameters === undefined) {
17029 parameters = {};
17030 }
17031 var deferred = $q.defer();
17032
17033 var domain = this.domain;
17034 var path = '/xos/usableobjects/{pk}/';
17035
17036 var body;
17037 var queryParameters = {};
17038 var headers = {};
17039 var form = {};
17040
17041 path = path.replace('{pk}', parameters['pk']);
17042
17043 if (parameters['pk'] === undefined) {
17044 deferred.reject(new Error('Missing required path parameter: pk'));
17045 return deferred.promise;
17046 }
17047
17048 if (parameters.$queryParameters) {
17049 Object.keys(parameters.$queryParameters)
17050 .forEach(function(parameterName) {
17051 var parameter = parameters.$queryParameters[parameterName];
17052 queryParameters[parameterName] = parameter;
17053 });
17054 }
17055
17056 var url = domain + path;
17057 var cached = parameters.$cache && parameters.$cache.get(url);
17058 if (cached !== undefined && parameters.$refresh !== true) {
17059 deferred.resolve(cached);
17060 return deferred.promise;
17061 }
17062 var options = {
17063 timeout: parameters.$timeout,
17064 method: 'GET',
17065 url: url,
17066 params: queryParameters,
17067 data: body,
17068 headers: headers
17069 };
17070 if (Object.keys(form).length > 0) {
17071 options.data = form;
17072 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17073 options.transformRequest = xos.transformRequest;
17074 }
17075 $http(options)
17076 .success(function(data, status, headers, config) {
17077 deferred.resolve(data);
17078 if (parameters.$cache !== undefined) {
17079 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17080 }
17081 })
17082 .error(function(data, status, headers, config) {
17083 deferred.reject({
17084 status: status,
17085 headers: headers,
17086 config: config,
17087 body: data
17088 });
17089 });
17090
17091 return deferred.promise;
17092 };
17093 /**
17094 *
17095 * @method
17096 * @name xos#Usable_Object_Detail_PUT
17097 * @param {string} pk -
17098 * @param {string} enacted -
17099 * @param {string} policed -
17100 * @param {string} backend_register -
17101 * @param {string} backend_status -
17102 * @param {boolean} deleted -
17103 * @param {boolean} write_protect -
17104 * @param {boolean} lazy_blocked -
17105 * @param {boolean} no_sync -
17106 * @param {string} name -
17107 *
17108 */
17109 xos.prototype.Usable_Object_Detail_PUT = function(parameters) {
17110 if (parameters === undefined) {
17111 parameters = {};
17112 }
17113 var deferred = $q.defer();
17114
17115 var domain = this.domain;
17116 var path = '/xos/usableobjects/{pk}/';
17117
17118 var body;
17119 var queryParameters = {};
17120 var headers = {};
17121 var form = {};
17122
17123 path = path.replace('{pk}', parameters['pk']);
17124
17125 if (parameters['pk'] === undefined) {
17126 deferred.reject(new Error('Missing required path parameter: pk'));
17127 return deferred.promise;
17128 }
17129
17130 if (parameters['enacted'] !== undefined) {
17131 form['enacted'] = parameters['enacted'];
17132 }
17133
17134 if (parameters['policed'] !== undefined) {
17135 form['policed'] = parameters['policed'];
17136 }
17137
17138 if (parameters['backend_register'] !== undefined) {
17139 form['backend_register'] = parameters['backend_register'];
17140 }
17141
17142 if (parameters['backend_status'] !== undefined) {
17143 form['backend_status'] = parameters['backend_status'];
17144 }
17145
17146 if (parameters['backend_status'] === undefined) {
17147 deferred.reject(new Error('Missing required form parameter: backend_status'));
17148 return deferred.promise;
17149 }
17150
17151 if (parameters['deleted'] !== undefined) {
17152 form['deleted'] = parameters['deleted'];
17153 }
17154
17155 if (parameters['write_protect'] !== undefined) {
17156 form['write_protect'] = parameters['write_protect'];
17157 }
17158
17159 if (parameters['lazy_blocked'] !== undefined) {
17160 form['lazy_blocked'] = parameters['lazy_blocked'];
17161 }
17162
17163 if (parameters['no_sync'] !== undefined) {
17164 form['no_sync'] = parameters['no_sync'];
17165 }
17166
17167 if (parameters['name'] !== undefined) {
17168 form['name'] = parameters['name'];
17169 }
17170
17171 if (parameters['name'] === undefined) {
17172 deferred.reject(new Error('Missing required form parameter: name'));
17173 return deferred.promise;
17174 }
17175
17176 if (parameters.$queryParameters) {
17177 Object.keys(parameters.$queryParameters)
17178 .forEach(function(parameterName) {
17179 var parameter = parameters.$queryParameters[parameterName];
17180 queryParameters[parameterName] = parameter;
17181 });
17182 }
17183
17184 var url = domain + path;
17185 var options = {
17186 timeout: parameters.$timeout,
17187 method: 'PUT',
17188 url: url,
17189 params: queryParameters,
17190 data: body,
17191 headers: headers
17192 };
17193 if (Object.keys(form).length > 0) {
17194 options.data = form;
17195 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17196 options.transformRequest = xos.transformRequest;
17197 }
17198 $http(options)
17199 .success(function(data, status, headers, config) {
17200 deferred.resolve(data);
17201 if (parameters.$cache !== undefined) {
17202 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17203 }
17204 })
17205 .error(function(data, status, headers, config) {
17206 deferred.reject({
17207 status: status,
17208 headers: headers,
17209 config: config,
17210 body: data
17211 });
17212 });
17213
17214 return deferred.promise;
17215 };
17216 /**
17217 *
17218 * @method
17219 * @name xos#Usable_Object_Detail_PATCH
17220 * @param {string} pk -
17221 * @param {string} enacted -
17222 * @param {string} policed -
17223 * @param {string} backend_register -
17224 * @param {string} backend_status -
17225 * @param {boolean} deleted -
17226 * @param {boolean} write_protect -
17227 * @param {boolean} lazy_blocked -
17228 * @param {boolean} no_sync -
17229 * @param {string} name -
17230 *
17231 */
17232 xos.prototype.Usable_Object_Detail_PATCH = function(parameters) {
17233 if (parameters === undefined) {
17234 parameters = {};
17235 }
17236 var deferred = $q.defer();
17237
17238 var domain = this.domain;
17239 var path = '/xos/usableobjects/{pk}/';
17240
17241 var body;
17242 var queryParameters = {};
17243 var headers = {};
17244 var form = {};
17245
17246 path = path.replace('{pk}', parameters['pk']);
17247
17248 if (parameters['pk'] === undefined) {
17249 deferred.reject(new Error('Missing required path parameter: pk'));
17250 return deferred.promise;
17251 }
17252
17253 if (parameters['enacted'] !== undefined) {
17254 form['enacted'] = parameters['enacted'];
17255 }
17256
17257 if (parameters['policed'] !== undefined) {
17258 form['policed'] = parameters['policed'];
17259 }
17260
17261 if (parameters['backend_register'] !== undefined) {
17262 form['backend_register'] = parameters['backend_register'];
17263 }
17264
17265 if (parameters['backend_status'] !== undefined) {
17266 form['backend_status'] = parameters['backend_status'];
17267 }
17268
17269 if (parameters['deleted'] !== undefined) {
17270 form['deleted'] = parameters['deleted'];
17271 }
17272
17273 if (parameters['write_protect'] !== undefined) {
17274 form['write_protect'] = parameters['write_protect'];
17275 }
17276
17277 if (parameters['lazy_blocked'] !== undefined) {
17278 form['lazy_blocked'] = parameters['lazy_blocked'];
17279 }
17280
17281 if (parameters['no_sync'] !== undefined) {
17282 form['no_sync'] = parameters['no_sync'];
17283 }
17284
17285 if (parameters['name'] !== undefined) {
17286 form['name'] = parameters['name'];
17287 }
17288
17289 if (parameters.$queryParameters) {
17290 Object.keys(parameters.$queryParameters)
17291 .forEach(function(parameterName) {
17292 var parameter = parameters.$queryParameters[parameterName];
17293 queryParameters[parameterName] = parameter;
17294 });
17295 }
17296
17297 var url = domain + path;
17298 var options = {
17299 timeout: parameters.$timeout,
17300 method: 'PATCH',
17301 url: url,
17302 params: queryParameters,
17303 data: body,
17304 headers: headers
17305 };
17306 if (Object.keys(form).length > 0) {
17307 options.data = form;
17308 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17309 options.transformRequest = xos.transformRequest;
17310 }
17311 $http(options)
17312 .success(function(data, status, headers, config) {
17313 deferred.resolve(data);
17314 if (parameters.$cache !== undefined) {
17315 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17316 }
17317 })
17318 .error(function(data, status, headers, config) {
17319 deferred.reject({
17320 status: status,
17321 headers: headers,
17322 config: config,
17323 body: data
17324 });
17325 });
17326
17327 return deferred.promise;
17328 };
17329 /**
17330 *
17331 * @method
17332 * @name xos#Usable_Object_Detail_DELETE
17333 * @param {string} pk -
17334 *
17335 */
17336 xos.prototype.Usable_Object_Detail_DELETE = function(parameters) {
17337 if (parameters === undefined) {
17338 parameters = {};
17339 }
17340 var deferred = $q.defer();
17341
17342 var domain = this.domain;
17343 var path = '/xos/usableobjects/{pk}/';
17344
17345 var body;
17346 var queryParameters = {};
17347 var headers = {};
17348 var form = {};
17349
17350 path = path.replace('{pk}', parameters['pk']);
17351
17352 if (parameters['pk'] === undefined) {
17353 deferred.reject(new Error('Missing required path parameter: pk'));
17354 return deferred.promise;
17355 }
17356
17357 if (parameters.$queryParameters) {
17358 Object.keys(parameters.$queryParameters)
17359 .forEach(function(parameterName) {
17360 var parameter = parameters.$queryParameters[parameterName];
17361 queryParameters[parameterName] = parameter;
17362 });
17363 }
17364
17365 var url = domain + path;
17366 var options = {
17367 timeout: parameters.$timeout,
17368 method: 'DELETE',
17369 url: url,
17370 params: queryParameters,
17371 data: body,
17372 headers: headers
17373 };
17374 if (Object.keys(form).length > 0) {
17375 options.data = form;
17376 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17377 options.transformRequest = xos.transformRequest;
17378 }
17379 $http(options)
17380 .success(function(data, status, headers, config) {
17381 deferred.resolve(data);
17382 if (parameters.$cache !== undefined) {
17383 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17384 }
17385 })
17386 .error(function(data, status, headers, config) {
17387 deferred.reject({
17388 status: status,
17389 headers: headers,
17390 config: config,
17391 body: data
17392 });
17393 });
17394
17395 return deferred.promise;
17396 };
17397 /**
17398 *
17399 * @method
17400 * @name xos#Provider_List_GET
17401 *
17402 */
17403 xos.prototype.Provider_List_GET = function(parameters) {
17404 if (parameters === undefined) {
17405 parameters = {};
17406 }
17407 var deferred = $q.defer();
17408
17409 var domain = this.domain;
17410 var path = '/xos/providers/';
17411
17412 var body;
17413 var queryParameters = {};
17414 var headers = {};
17415 var form = {};
17416
17417 if (parameters.$queryParameters) {
17418 Object.keys(parameters.$queryParameters)
17419 .forEach(function(parameterName) {
17420 var parameter = parameters.$queryParameters[parameterName];
17421 queryParameters[parameterName] = parameter;
17422 });
17423 }
17424
17425 var url = domain + path;
17426 var cached = parameters.$cache && parameters.$cache.get(url);
17427 if (cached !== undefined && parameters.$refresh !== true) {
17428 deferred.resolve(cached);
17429 return deferred.promise;
17430 }
17431 var options = {
17432 timeout: parameters.$timeout,
17433 method: 'GET',
17434 url: url,
17435 params: queryParameters,
17436 data: body,
17437 headers: headers
17438 };
17439 if (Object.keys(form).length > 0) {
17440 options.data = form;
17441 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17442 options.transformRequest = xos.transformRequest;
17443 }
17444 $http(options)
17445 .success(function(data, status, headers, config) {
17446 deferred.resolve(data);
17447 if (parameters.$cache !== undefined) {
17448 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17449 }
17450 })
17451 .error(function(data, status, headers, config) {
17452 deferred.reject({
17453 status: status,
17454 headers: headers,
17455 config: config,
17456 body: data
17457 });
17458 });
17459
17460 return deferred.promise;
17461 };
17462 /**
17463 *
17464 * @method
17465 * @name xos#Provider_List_POST
17466 * @param {string} enacted -
17467 * @param {string} policed -
17468 * @param {string} backend_register -
17469 * @param {string} backend_status -
17470 * @param {boolean} deleted -
17471 * @param {boolean} write_protect -
17472 * @param {boolean} lazy_blocked -
17473 * @param {boolean} no_sync -
17474 * @param {string} kind -
17475 * @param {string} name - name
17476 * @param {string} service_specific_attribute -
17477 * @param {string} service_specific_id -
17478 *
17479 */
17480 xos.prototype.Provider_List_POST = function(parameters) {
17481 if (parameters === undefined) {
17482 parameters = {};
17483 }
17484 var deferred = $q.defer();
17485
17486 var domain = this.domain;
17487 var path = '/xos/providers/';
17488
17489 var body;
17490 var queryParameters = {};
17491 var headers = {};
17492 var form = {};
17493
17494 if (parameters['enacted'] !== undefined) {
17495 form['enacted'] = parameters['enacted'];
17496 }
17497
17498 if (parameters['policed'] !== undefined) {
17499 form['policed'] = parameters['policed'];
17500 }
17501
17502 if (parameters['backend_register'] !== undefined) {
17503 form['backend_register'] = parameters['backend_register'];
17504 }
17505
17506 if (parameters['backend_status'] !== undefined) {
17507 form['backend_status'] = parameters['backend_status'];
17508 }
17509
17510 if (parameters['backend_status'] === undefined) {
17511 deferred.reject(new Error('Missing required form parameter: backend_status'));
17512 return deferred.promise;
17513 }
17514
17515 if (parameters['deleted'] !== undefined) {
17516 form['deleted'] = parameters['deleted'];
17517 }
17518
17519 if (parameters['write_protect'] !== undefined) {
17520 form['write_protect'] = parameters['write_protect'];
17521 }
17522
17523 if (parameters['lazy_blocked'] !== undefined) {
17524 form['lazy_blocked'] = parameters['lazy_blocked'];
17525 }
17526
17527 if (parameters['no_sync'] !== undefined) {
17528 form['no_sync'] = parameters['no_sync'];
17529 }
17530
17531 if (parameters['kind'] !== undefined) {
17532 form['kind'] = parameters['kind'];
17533 }
17534
17535 if (parameters['kind'] === undefined) {
17536 deferred.reject(new Error('Missing required form parameter: kind'));
17537 return deferred.promise;
17538 }
17539
17540 if (parameters['name'] !== undefined) {
17541 form['name'] = parameters['name'];
17542 }
17543
17544 if (parameters['service_specific_attribute'] !== undefined) {
17545 form['service_specific_attribute'] = parameters['service_specific_attribute'];
17546 }
17547
17548 if (parameters['service_specific_id'] !== undefined) {
17549 form['service_specific_id'] = parameters['service_specific_id'];
17550 }
17551
17552 if (parameters.$queryParameters) {
17553 Object.keys(parameters.$queryParameters)
17554 .forEach(function(parameterName) {
17555 var parameter = parameters.$queryParameters[parameterName];
17556 queryParameters[parameterName] = parameter;
17557 });
17558 }
17559
17560 var url = domain + path;
17561 var options = {
17562 timeout: parameters.$timeout,
17563 method: 'POST',
17564 url: url,
17565 params: queryParameters,
17566 data: body,
17567 headers: headers
17568 };
17569 if (Object.keys(form).length > 0) {
17570 options.data = form;
17571 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17572 options.transformRequest = xos.transformRequest;
17573 }
17574 $http(options)
17575 .success(function(data, status, headers, config) {
17576 deferred.resolve(data);
17577 if (parameters.$cache !== undefined) {
17578 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17579 }
17580 })
17581 .error(function(data, status, headers, config) {
17582 deferred.reject({
17583 status: status,
17584 headers: headers,
17585 config: config,
17586 body: data
17587 });
17588 });
17589
17590 return deferred.promise;
17591 };
17592 /**
17593 *
17594 * @method
17595 * @name xos#Provider_Detail_GET
17596 * @param {string} pk -
17597 *
17598 */
17599 xos.prototype.Provider_Detail_GET = function(parameters) {
17600 if (parameters === undefined) {
17601 parameters = {};
17602 }
17603 var deferred = $q.defer();
17604
17605 var domain = this.domain;
17606 var path = '/xos/providers/{pk}/';
17607
17608 var body;
17609 var queryParameters = {};
17610 var headers = {};
17611 var form = {};
17612
17613 path = path.replace('{pk}', parameters['pk']);
17614
17615 if (parameters['pk'] === undefined) {
17616 deferred.reject(new Error('Missing required path parameter: pk'));
17617 return deferred.promise;
17618 }
17619
17620 if (parameters.$queryParameters) {
17621 Object.keys(parameters.$queryParameters)
17622 .forEach(function(parameterName) {
17623 var parameter = parameters.$queryParameters[parameterName];
17624 queryParameters[parameterName] = parameter;
17625 });
17626 }
17627
17628 var url = domain + path;
17629 var cached = parameters.$cache && parameters.$cache.get(url);
17630 if (cached !== undefined && parameters.$refresh !== true) {
17631 deferred.resolve(cached);
17632 return deferred.promise;
17633 }
17634 var options = {
17635 timeout: parameters.$timeout,
17636 method: 'GET',
17637 url: url,
17638 params: queryParameters,
17639 data: body,
17640 headers: headers
17641 };
17642 if (Object.keys(form).length > 0) {
17643 options.data = form;
17644 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17645 options.transformRequest = xos.transformRequest;
17646 }
17647 $http(options)
17648 .success(function(data, status, headers, config) {
17649 deferred.resolve(data);
17650 if (parameters.$cache !== undefined) {
17651 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17652 }
17653 })
17654 .error(function(data, status, headers, config) {
17655 deferred.reject({
17656 status: status,
17657 headers: headers,
17658 config: config,
17659 body: data
17660 });
17661 });
17662
17663 return deferred.promise;
17664 };
17665 /**
17666 *
17667 * @method
17668 * @name xos#Provider_Detail_PUT
17669 * @param {string} pk -
17670 * @param {string} enacted -
17671 * @param {string} policed -
17672 * @param {string} backend_register -
17673 * @param {string} backend_status -
17674 * @param {boolean} deleted -
17675 * @param {boolean} write_protect -
17676 * @param {boolean} lazy_blocked -
17677 * @param {boolean} no_sync -
17678 * @param {string} kind -
17679 * @param {string} name - name
17680 * @param {string} service_specific_attribute -
17681 * @param {string} service_specific_id -
17682 *
17683 */
17684 xos.prototype.Provider_Detail_PUT = function(parameters) {
17685 if (parameters === undefined) {
17686 parameters = {};
17687 }
17688 var deferred = $q.defer();
17689
17690 var domain = this.domain;
17691 var path = '/xos/providers/{pk}/';
17692
17693 var body;
17694 var queryParameters = {};
17695 var headers = {};
17696 var form = {};
17697
17698 path = path.replace('{pk}', parameters['pk']);
17699
17700 if (parameters['pk'] === undefined) {
17701 deferred.reject(new Error('Missing required path parameter: pk'));
17702 return deferred.promise;
17703 }
17704
17705 if (parameters['enacted'] !== undefined) {
17706 form['enacted'] = parameters['enacted'];
17707 }
17708
17709 if (parameters['policed'] !== undefined) {
17710 form['policed'] = parameters['policed'];
17711 }
17712
17713 if (parameters['backend_register'] !== undefined) {
17714 form['backend_register'] = parameters['backend_register'];
17715 }
17716
17717 if (parameters['backend_status'] !== undefined) {
17718 form['backend_status'] = parameters['backend_status'];
17719 }
17720
17721 if (parameters['backend_status'] === undefined) {
17722 deferred.reject(new Error('Missing required form parameter: backend_status'));
17723 return deferred.promise;
17724 }
17725
17726 if (parameters['deleted'] !== undefined) {
17727 form['deleted'] = parameters['deleted'];
17728 }
17729
17730 if (parameters['write_protect'] !== undefined) {
17731 form['write_protect'] = parameters['write_protect'];
17732 }
17733
17734 if (parameters['lazy_blocked'] !== undefined) {
17735 form['lazy_blocked'] = parameters['lazy_blocked'];
17736 }
17737
17738 if (parameters['no_sync'] !== undefined) {
17739 form['no_sync'] = parameters['no_sync'];
17740 }
17741
17742 if (parameters['kind'] !== undefined) {
17743 form['kind'] = parameters['kind'];
17744 }
17745
17746 if (parameters['kind'] === undefined) {
17747 deferred.reject(new Error('Missing required form parameter: kind'));
17748 return deferred.promise;
17749 }
17750
17751 if (parameters['name'] !== undefined) {
17752 form['name'] = parameters['name'];
17753 }
17754
17755 if (parameters['service_specific_attribute'] !== undefined) {
17756 form['service_specific_attribute'] = parameters['service_specific_attribute'];
17757 }
17758
17759 if (parameters['service_specific_id'] !== undefined) {
17760 form['service_specific_id'] = parameters['service_specific_id'];
17761 }
17762
17763 if (parameters.$queryParameters) {
17764 Object.keys(parameters.$queryParameters)
17765 .forEach(function(parameterName) {
17766 var parameter = parameters.$queryParameters[parameterName];
17767 queryParameters[parameterName] = parameter;
17768 });
17769 }
17770
17771 var url = domain + path;
17772 var options = {
17773 timeout: parameters.$timeout,
17774 method: 'PUT',
17775 url: url,
17776 params: queryParameters,
17777 data: body,
17778 headers: headers
17779 };
17780 if (Object.keys(form).length > 0) {
17781 options.data = form;
17782 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17783 options.transformRequest = xos.transformRequest;
17784 }
17785 $http(options)
17786 .success(function(data, status, headers, config) {
17787 deferred.resolve(data);
17788 if (parameters.$cache !== undefined) {
17789 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17790 }
17791 })
17792 .error(function(data, status, headers, config) {
17793 deferred.reject({
17794 status: status,
17795 headers: headers,
17796 config: config,
17797 body: data
17798 });
17799 });
17800
17801 return deferred.promise;
17802 };
17803 /**
17804 *
17805 * @method
17806 * @name xos#Provider_Detail_PATCH
17807 * @param {string} pk -
17808 * @param {string} enacted -
17809 * @param {string} policed -
17810 * @param {string} backend_register -
17811 * @param {string} backend_status -
17812 * @param {boolean} deleted -
17813 * @param {boolean} write_protect -
17814 * @param {boolean} lazy_blocked -
17815 * @param {boolean} no_sync -
17816 * @param {string} kind -
17817 * @param {string} name - name
17818 * @param {string} service_specific_attribute -
17819 * @param {string} service_specific_id -
17820 *
17821 */
17822 xos.prototype.Provider_Detail_PATCH = function(parameters) {
17823 if (parameters === undefined) {
17824 parameters = {};
17825 }
17826 var deferred = $q.defer();
17827
17828 var domain = this.domain;
17829 var path = '/xos/providers/{pk}/';
17830
17831 var body;
17832 var queryParameters = {};
17833 var headers = {};
17834 var form = {};
17835
17836 path = path.replace('{pk}', parameters['pk']);
17837
17838 if (parameters['pk'] === undefined) {
17839 deferred.reject(new Error('Missing required path parameter: pk'));
17840 return deferred.promise;
17841 }
17842
17843 if (parameters['enacted'] !== undefined) {
17844 form['enacted'] = parameters['enacted'];
17845 }
17846
17847 if (parameters['policed'] !== undefined) {
17848 form['policed'] = parameters['policed'];
17849 }
17850
17851 if (parameters['backend_register'] !== undefined) {
17852 form['backend_register'] = parameters['backend_register'];
17853 }
17854
17855 if (parameters['backend_status'] !== undefined) {
17856 form['backend_status'] = parameters['backend_status'];
17857 }
17858
17859 if (parameters['deleted'] !== undefined) {
17860 form['deleted'] = parameters['deleted'];
17861 }
17862
17863 if (parameters['write_protect'] !== undefined) {
17864 form['write_protect'] = parameters['write_protect'];
17865 }
17866
17867 if (parameters['lazy_blocked'] !== undefined) {
17868 form['lazy_blocked'] = parameters['lazy_blocked'];
17869 }
17870
17871 if (parameters['no_sync'] !== undefined) {
17872 form['no_sync'] = parameters['no_sync'];
17873 }
17874
17875 if (parameters['kind'] !== undefined) {
17876 form['kind'] = parameters['kind'];
17877 }
17878
17879 if (parameters['name'] !== undefined) {
17880 form['name'] = parameters['name'];
17881 }
17882
17883 if (parameters['service_specific_attribute'] !== undefined) {
17884 form['service_specific_attribute'] = parameters['service_specific_attribute'];
17885 }
17886
17887 if (parameters['service_specific_id'] !== undefined) {
17888 form['service_specific_id'] = parameters['service_specific_id'];
17889 }
17890
17891 if (parameters.$queryParameters) {
17892 Object.keys(parameters.$queryParameters)
17893 .forEach(function(parameterName) {
17894 var parameter = parameters.$queryParameters[parameterName];
17895 queryParameters[parameterName] = parameter;
17896 });
17897 }
17898
17899 var url = domain + path;
17900 var options = {
17901 timeout: parameters.$timeout,
17902 method: 'PATCH',
17903 url: url,
17904 params: queryParameters,
17905 data: body,
17906 headers: headers
17907 };
17908 if (Object.keys(form).length > 0) {
17909 options.data = form;
17910 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17911 options.transformRequest = xos.transformRequest;
17912 }
17913 $http(options)
17914 .success(function(data, status, headers, config) {
17915 deferred.resolve(data);
17916 if (parameters.$cache !== undefined) {
17917 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17918 }
17919 })
17920 .error(function(data, status, headers, config) {
17921 deferred.reject({
17922 status: status,
17923 headers: headers,
17924 config: config,
17925 body: data
17926 });
17927 });
17928
17929 return deferred.promise;
17930 };
17931 /**
17932 *
17933 * @method
17934 * @name xos#Provider_Detail_DELETE
17935 * @param {string} pk -
17936 *
17937 */
17938 xos.prototype.Provider_Detail_DELETE = function(parameters) {
17939 if (parameters === undefined) {
17940 parameters = {};
17941 }
17942 var deferred = $q.defer();
17943
17944 var domain = this.domain;
17945 var path = '/xos/providers/{pk}/';
17946
17947 var body;
17948 var queryParameters = {};
17949 var headers = {};
17950 var form = {};
17951
17952 path = path.replace('{pk}', parameters['pk']);
17953
17954 if (parameters['pk'] === undefined) {
17955 deferred.reject(new Error('Missing required path parameter: pk'));
17956 return deferred.promise;
17957 }
17958
17959 if (parameters.$queryParameters) {
17960 Object.keys(parameters.$queryParameters)
17961 .forEach(function(parameterName) {
17962 var parameter = parameters.$queryParameters[parameterName];
17963 queryParameters[parameterName] = parameter;
17964 });
17965 }
17966
17967 var url = domain + path;
17968 var options = {
17969 timeout: parameters.$timeout,
17970 method: 'DELETE',
17971 url: url,
17972 params: queryParameters,
17973 data: body,
17974 headers: headers
17975 };
17976 if (Object.keys(form).length > 0) {
17977 options.data = form;
17978 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
17979 options.transformRequest = xos.transformRequest;
17980 }
17981 $http(options)
17982 .success(function(data, status, headers, config) {
17983 deferred.resolve(data);
17984 if (parameters.$cache !== undefined) {
17985 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
17986 }
17987 })
17988 .error(function(data, status, headers, config) {
17989 deferred.reject({
17990 status: status,
17991 headers: headers,
17992 config: config,
17993 body: data
17994 });
17995 });
17996
17997 return deferred.promise;
17998 };
17999 /**
18000 *
18001 * @method
18002 * @name xos#Slice_Credential_List_GET
18003 *
18004 */
18005 xos.prototype.Slice_Credential_List_GET = function(parameters) {
18006 if (parameters === undefined) {
18007 parameters = {};
18008 }
18009 var deferred = $q.defer();
18010
18011 var domain = this.domain;
18012 var path = '/xos/slicecredentials/';
18013
18014 var body;
18015 var queryParameters = {};
18016 var headers = {};
18017 var form = {};
18018
18019 if (parameters.$queryParameters) {
18020 Object.keys(parameters.$queryParameters)
18021 .forEach(function(parameterName) {
18022 var parameter = parameters.$queryParameters[parameterName];
18023 queryParameters[parameterName] = parameter;
18024 });
18025 }
18026
18027 var url = domain + path;
18028 var cached = parameters.$cache && parameters.$cache.get(url);
18029 if (cached !== undefined && parameters.$refresh !== true) {
18030 deferred.resolve(cached);
18031 return deferred.promise;
18032 }
18033 var options = {
18034 timeout: parameters.$timeout,
18035 method: 'GET',
18036 url: url,
18037 params: queryParameters,
18038 data: body,
18039 headers: headers
18040 };
18041 if (Object.keys(form).length > 0) {
18042 options.data = form;
18043 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18044 options.transformRequest = xos.transformRequest;
18045 }
18046 $http(options)
18047 .success(function(data, status, headers, config) {
18048 deferred.resolve(data);
18049 if (parameters.$cache !== undefined) {
18050 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18051 }
18052 })
18053 .error(function(data, status, headers, config) {
18054 deferred.reject({
18055 status: status,
18056 headers: headers,
18057 config: config,
18058 body: data
18059 });
18060 });
18061
18062 return deferred.promise;
18063 };
18064 /**
18065 *
18066 * @method
18067 * @name xos#Slice_Credential_List_POST
18068 * @param {string} enacted -
18069 * @param {string} policed -
18070 * @param {string} backend_register -
18071 * @param {string} backend_status -
18072 * @param {boolean} deleted -
18073 * @param {boolean} write_protect -
18074 * @param {boolean} lazy_blocked -
18075 * @param {boolean} no_sync -
18076 * @param {string} slice - The User this credential is associated with
18077 * @param {string} name - The credential type, e.g. ec2
18078 * @param {string} key_id - The backend id of this credential
18079 * @param {string} enc_value - The key value of this credential
18080 *
18081 */
18082 xos.prototype.Slice_Credential_List_POST = function(parameters) {
18083 if (parameters === undefined) {
18084 parameters = {};
18085 }
18086 var deferred = $q.defer();
18087
18088 var domain = this.domain;
18089 var path = '/xos/slicecredentials/';
18090
18091 var body;
18092 var queryParameters = {};
18093 var headers = {};
18094 var form = {};
18095
18096 if (parameters['enacted'] !== undefined) {
18097 form['enacted'] = parameters['enacted'];
18098 }
18099
18100 if (parameters['policed'] !== undefined) {
18101 form['policed'] = parameters['policed'];
18102 }
18103
18104 if (parameters['backend_register'] !== undefined) {
18105 form['backend_register'] = parameters['backend_register'];
18106 }
18107
18108 if (parameters['backend_status'] !== undefined) {
18109 form['backend_status'] = parameters['backend_status'];
18110 }
18111
18112 if (parameters['backend_status'] === undefined) {
18113 deferred.reject(new Error('Missing required form parameter: backend_status'));
18114 return deferred.promise;
18115 }
18116
18117 if (parameters['deleted'] !== undefined) {
18118 form['deleted'] = parameters['deleted'];
18119 }
18120
18121 if (parameters['write_protect'] !== undefined) {
18122 form['write_protect'] = parameters['write_protect'];
18123 }
18124
18125 if (parameters['lazy_blocked'] !== undefined) {
18126 form['lazy_blocked'] = parameters['lazy_blocked'];
18127 }
18128
18129 if (parameters['no_sync'] !== undefined) {
18130 form['no_sync'] = parameters['no_sync'];
18131 }
18132
18133 if (parameters['slice'] !== undefined) {
18134 form['slice'] = parameters['slice'];
18135 }
18136
18137 if (parameters['slice'] === undefined) {
18138 deferred.reject(new Error('Missing required form parameter: slice'));
18139 return deferred.promise;
18140 }
18141
18142 if (parameters['name'] !== undefined) {
18143 form['name'] = parameters['name'];
18144 }
18145
18146 if (parameters['name'] === undefined) {
18147 deferred.reject(new Error('Missing required form parameter: name'));
18148 return deferred.promise;
18149 }
18150
18151 if (parameters['key_id'] !== undefined) {
18152 form['key_id'] = parameters['key_id'];
18153 }
18154
18155 if (parameters['key_id'] === undefined) {
18156 deferred.reject(new Error('Missing required form parameter: key_id'));
18157 return deferred.promise;
18158 }
18159
18160 if (parameters['enc_value'] !== undefined) {
18161 form['enc_value'] = parameters['enc_value'];
18162 }
18163
18164 if (parameters['enc_value'] === undefined) {
18165 deferred.reject(new Error('Missing required form parameter: enc_value'));
18166 return deferred.promise;
18167 }
18168
18169 if (parameters.$queryParameters) {
18170 Object.keys(parameters.$queryParameters)
18171 .forEach(function(parameterName) {
18172 var parameter = parameters.$queryParameters[parameterName];
18173 queryParameters[parameterName] = parameter;
18174 });
18175 }
18176
18177 var url = domain + path;
18178 var options = {
18179 timeout: parameters.$timeout,
18180 method: 'POST',
18181 url: url,
18182 params: queryParameters,
18183 data: body,
18184 headers: headers
18185 };
18186 if (Object.keys(form).length > 0) {
18187 options.data = form;
18188 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18189 options.transformRequest = xos.transformRequest;
18190 }
18191 $http(options)
18192 .success(function(data, status, headers, config) {
18193 deferred.resolve(data);
18194 if (parameters.$cache !== undefined) {
18195 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18196 }
18197 })
18198 .error(function(data, status, headers, config) {
18199 deferred.reject({
18200 status: status,
18201 headers: headers,
18202 config: config,
18203 body: data
18204 });
18205 });
18206
18207 return deferred.promise;
18208 };
18209 /**
18210 *
18211 * @method
18212 * @name xos#Slice_Credential_Detail_GET
18213 * @param {string} pk -
18214 *
18215 */
18216 xos.prototype.Slice_Credential_Detail_GET = function(parameters) {
18217 if (parameters === undefined) {
18218 parameters = {};
18219 }
18220 var deferred = $q.defer();
18221
18222 var domain = this.domain;
18223 var path = '/xos/slicecredentials/{pk}/';
18224
18225 var body;
18226 var queryParameters = {};
18227 var headers = {};
18228 var form = {};
18229
18230 path = path.replace('{pk}', parameters['pk']);
18231
18232 if (parameters['pk'] === undefined) {
18233 deferred.reject(new Error('Missing required path parameter: pk'));
18234 return deferred.promise;
18235 }
18236
18237 if (parameters.$queryParameters) {
18238 Object.keys(parameters.$queryParameters)
18239 .forEach(function(parameterName) {
18240 var parameter = parameters.$queryParameters[parameterName];
18241 queryParameters[parameterName] = parameter;
18242 });
18243 }
18244
18245 var url = domain + path;
18246 var cached = parameters.$cache && parameters.$cache.get(url);
18247 if (cached !== undefined && parameters.$refresh !== true) {
18248 deferred.resolve(cached);
18249 return deferred.promise;
18250 }
18251 var options = {
18252 timeout: parameters.$timeout,
18253 method: 'GET',
18254 url: url,
18255 params: queryParameters,
18256 data: body,
18257 headers: headers
18258 };
18259 if (Object.keys(form).length > 0) {
18260 options.data = form;
18261 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18262 options.transformRequest = xos.transformRequest;
18263 }
18264 $http(options)
18265 .success(function(data, status, headers, config) {
18266 deferred.resolve(data);
18267 if (parameters.$cache !== undefined) {
18268 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18269 }
18270 })
18271 .error(function(data, status, headers, config) {
18272 deferred.reject({
18273 status: status,
18274 headers: headers,
18275 config: config,
18276 body: data
18277 });
18278 });
18279
18280 return deferred.promise;
18281 };
18282 /**
18283 *
18284 * @method
18285 * @name xos#Slice_Credential_Detail_PUT
18286 * @param {string} pk -
18287 * @param {string} enacted -
18288 * @param {string} policed -
18289 * @param {string} backend_register -
18290 * @param {string} backend_status -
18291 * @param {boolean} deleted -
18292 * @param {boolean} write_protect -
18293 * @param {boolean} lazy_blocked -
18294 * @param {boolean} no_sync -
18295 * @param {string} slice - The User this credential is associated with
18296 * @param {string} name - The credential type, e.g. ec2
18297 * @param {string} key_id - The backend id of this credential
18298 * @param {string} enc_value - The key value of this credential
18299 *
18300 */
18301 xos.prototype.Slice_Credential_Detail_PUT = function(parameters) {
18302 if (parameters === undefined) {
18303 parameters = {};
18304 }
18305 var deferred = $q.defer();
18306
18307 var domain = this.domain;
18308 var path = '/xos/slicecredentials/{pk}/';
18309
18310 var body;
18311 var queryParameters = {};
18312 var headers = {};
18313 var form = {};
18314
18315 path = path.replace('{pk}', parameters['pk']);
18316
18317 if (parameters['pk'] === undefined) {
18318 deferred.reject(new Error('Missing required path parameter: pk'));
18319 return deferred.promise;
18320 }
18321
18322 if (parameters['enacted'] !== undefined) {
18323 form['enacted'] = parameters['enacted'];
18324 }
18325
18326 if (parameters['policed'] !== undefined) {
18327 form['policed'] = parameters['policed'];
18328 }
18329
18330 if (parameters['backend_register'] !== undefined) {
18331 form['backend_register'] = parameters['backend_register'];
18332 }
18333
18334 if (parameters['backend_status'] !== undefined) {
18335 form['backend_status'] = parameters['backend_status'];
18336 }
18337
18338 if (parameters['backend_status'] === undefined) {
18339 deferred.reject(new Error('Missing required form parameter: backend_status'));
18340 return deferred.promise;
18341 }
18342
18343 if (parameters['deleted'] !== undefined) {
18344 form['deleted'] = parameters['deleted'];
18345 }
18346
18347 if (parameters['write_protect'] !== undefined) {
18348 form['write_protect'] = parameters['write_protect'];
18349 }
18350
18351 if (parameters['lazy_blocked'] !== undefined) {
18352 form['lazy_blocked'] = parameters['lazy_blocked'];
18353 }
18354
18355 if (parameters['no_sync'] !== undefined) {
18356 form['no_sync'] = parameters['no_sync'];
18357 }
18358
18359 if (parameters['slice'] !== undefined) {
18360 form['slice'] = parameters['slice'];
18361 }
18362
18363 if (parameters['slice'] === undefined) {
18364 deferred.reject(new Error('Missing required form parameter: slice'));
18365 return deferred.promise;
18366 }
18367
18368 if (parameters['name'] !== undefined) {
18369 form['name'] = parameters['name'];
18370 }
18371
18372 if (parameters['name'] === undefined) {
18373 deferred.reject(new Error('Missing required form parameter: name'));
18374 return deferred.promise;
18375 }
18376
18377 if (parameters['key_id'] !== undefined) {
18378 form['key_id'] = parameters['key_id'];
18379 }
18380
18381 if (parameters['key_id'] === undefined) {
18382 deferred.reject(new Error('Missing required form parameter: key_id'));
18383 return deferred.promise;
18384 }
18385
18386 if (parameters['enc_value'] !== undefined) {
18387 form['enc_value'] = parameters['enc_value'];
18388 }
18389
18390 if (parameters['enc_value'] === undefined) {
18391 deferred.reject(new Error('Missing required form parameter: enc_value'));
18392 return deferred.promise;
18393 }
18394
18395 if (parameters.$queryParameters) {
18396 Object.keys(parameters.$queryParameters)
18397 .forEach(function(parameterName) {
18398 var parameter = parameters.$queryParameters[parameterName];
18399 queryParameters[parameterName] = parameter;
18400 });
18401 }
18402
18403 var url = domain + path;
18404 var options = {
18405 timeout: parameters.$timeout,
18406 method: 'PUT',
18407 url: url,
18408 params: queryParameters,
18409 data: body,
18410 headers: headers
18411 };
18412 if (Object.keys(form).length > 0) {
18413 options.data = form;
18414 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18415 options.transformRequest = xos.transformRequest;
18416 }
18417 $http(options)
18418 .success(function(data, status, headers, config) {
18419 deferred.resolve(data);
18420 if (parameters.$cache !== undefined) {
18421 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18422 }
18423 })
18424 .error(function(data, status, headers, config) {
18425 deferred.reject({
18426 status: status,
18427 headers: headers,
18428 config: config,
18429 body: data
18430 });
18431 });
18432
18433 return deferred.promise;
18434 };
18435 /**
18436 *
18437 * @method
18438 * @name xos#Slice_Credential_Detail_PATCH
18439 * @param {string} pk -
18440 * @param {string} enacted -
18441 * @param {string} policed -
18442 * @param {string} backend_register -
18443 * @param {string} backend_status -
18444 * @param {boolean} deleted -
18445 * @param {boolean} write_protect -
18446 * @param {boolean} lazy_blocked -
18447 * @param {boolean} no_sync -
18448 * @param {string} slice - The User this credential is associated with
18449 * @param {string} name - The credential type, e.g. ec2
18450 * @param {string} key_id - The backend id of this credential
18451 * @param {string} enc_value - The key value of this credential
18452 *
18453 */
18454 xos.prototype.Slice_Credential_Detail_PATCH = function(parameters) {
18455 if (parameters === undefined) {
18456 parameters = {};
18457 }
18458 var deferred = $q.defer();
18459
18460 var domain = this.domain;
18461 var path = '/xos/slicecredentials/{pk}/';
18462
18463 var body;
18464 var queryParameters = {};
18465 var headers = {};
18466 var form = {};
18467
18468 path = path.replace('{pk}', parameters['pk']);
18469
18470 if (parameters['pk'] === undefined) {
18471 deferred.reject(new Error('Missing required path parameter: pk'));
18472 return deferred.promise;
18473 }
18474
18475 if (parameters['enacted'] !== undefined) {
18476 form['enacted'] = parameters['enacted'];
18477 }
18478
18479 if (parameters['policed'] !== undefined) {
18480 form['policed'] = parameters['policed'];
18481 }
18482
18483 if (parameters['backend_register'] !== undefined) {
18484 form['backend_register'] = parameters['backend_register'];
18485 }
18486
18487 if (parameters['backend_status'] !== undefined) {
18488 form['backend_status'] = parameters['backend_status'];
18489 }
18490
18491 if (parameters['deleted'] !== undefined) {
18492 form['deleted'] = parameters['deleted'];
18493 }
18494
18495 if (parameters['write_protect'] !== undefined) {
18496 form['write_protect'] = parameters['write_protect'];
18497 }
18498
18499 if (parameters['lazy_blocked'] !== undefined) {
18500 form['lazy_blocked'] = parameters['lazy_blocked'];
18501 }
18502
18503 if (parameters['no_sync'] !== undefined) {
18504 form['no_sync'] = parameters['no_sync'];
18505 }
18506
18507 if (parameters['slice'] !== undefined) {
18508 form['slice'] = parameters['slice'];
18509 }
18510
18511 if (parameters['name'] !== undefined) {
18512 form['name'] = parameters['name'];
18513 }
18514
18515 if (parameters['key_id'] !== undefined) {
18516 form['key_id'] = parameters['key_id'];
18517 }
18518
18519 if (parameters['enc_value'] !== undefined) {
18520 form['enc_value'] = parameters['enc_value'];
18521 }
18522
18523 if (parameters.$queryParameters) {
18524 Object.keys(parameters.$queryParameters)
18525 .forEach(function(parameterName) {
18526 var parameter = parameters.$queryParameters[parameterName];
18527 queryParameters[parameterName] = parameter;
18528 });
18529 }
18530
18531 var url = domain + path;
18532 var options = {
18533 timeout: parameters.$timeout,
18534 method: 'PATCH',
18535 url: url,
18536 params: queryParameters,
18537 data: body,
18538 headers: headers
18539 };
18540 if (Object.keys(form).length > 0) {
18541 options.data = form;
18542 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18543 options.transformRequest = xos.transformRequest;
18544 }
18545 $http(options)
18546 .success(function(data, status, headers, config) {
18547 deferred.resolve(data);
18548 if (parameters.$cache !== undefined) {
18549 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18550 }
18551 })
18552 .error(function(data, status, headers, config) {
18553 deferred.reject({
18554 status: status,
18555 headers: headers,
18556 config: config,
18557 body: data
18558 });
18559 });
18560
18561 return deferred.promise;
18562 };
18563 /**
18564 *
18565 * @method
18566 * @name xos#Slice_Credential_Detail_DELETE
18567 * @param {string} pk -
18568 *
18569 */
18570 xos.prototype.Slice_Credential_Detail_DELETE = function(parameters) {
18571 if (parameters === undefined) {
18572 parameters = {};
18573 }
18574 var deferred = $q.defer();
18575
18576 var domain = this.domain;
18577 var path = '/xos/slicecredentials/{pk}/';
18578
18579 var body;
18580 var queryParameters = {};
18581 var headers = {};
18582 var form = {};
18583
18584 path = path.replace('{pk}', parameters['pk']);
18585
18586 if (parameters['pk'] === undefined) {
18587 deferred.reject(new Error('Missing required path parameter: pk'));
18588 return deferred.promise;
18589 }
18590
18591 if (parameters.$queryParameters) {
18592 Object.keys(parameters.$queryParameters)
18593 .forEach(function(parameterName) {
18594 var parameter = parameters.$queryParameters[parameterName];
18595 queryParameters[parameterName] = parameter;
18596 });
18597 }
18598
18599 var url = domain + path;
18600 var options = {
18601 timeout: parameters.$timeout,
18602 method: 'DELETE',
18603 url: url,
18604 params: queryParameters,
18605 data: body,
18606 headers: headers
18607 };
18608 if (Object.keys(form).length > 0) {
18609 options.data = form;
18610 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18611 options.transformRequest = xos.transformRequest;
18612 }
18613 $http(options)
18614 .success(function(data, status, headers, config) {
18615 deferred.resolve(data);
18616 if (parameters.$cache !== undefined) {
18617 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18618 }
18619 })
18620 .error(function(data, status, headers, config) {
18621 deferred.reject({
18622 status: status,
18623 headers: headers,
18624 config: config,
18625 body: data
18626 });
18627 });
18628
18629 return deferred.promise;
18630 };
18631 /**
18632 *
18633 * @method
18634 * @name xos#Node_List_GET
18635 *
18636 */
18637 xos.prototype.Node_List_GET = function(parameters) {
18638 if (parameters === undefined) {
18639 parameters = {};
18640 }
18641 var deferred = $q.defer();
18642
18643 var domain = this.domain;
18644 var path = '/xos/nodes/';
18645
18646 var body;
18647 var queryParameters = {};
18648 var headers = {};
18649 var form = {};
18650
18651 if (parameters.$queryParameters) {
18652 Object.keys(parameters.$queryParameters)
18653 .forEach(function(parameterName) {
18654 var parameter = parameters.$queryParameters[parameterName];
18655 queryParameters[parameterName] = parameter;
18656 });
18657 }
18658
18659 var url = domain + path;
18660 var cached = parameters.$cache && parameters.$cache.get(url);
18661 if (cached !== undefined && parameters.$refresh !== true) {
18662 deferred.resolve(cached);
18663 return deferred.promise;
18664 }
18665 var options = {
18666 timeout: parameters.$timeout,
18667 method: 'GET',
18668 url: url,
18669 params: queryParameters,
18670 data: body,
18671 headers: headers
18672 };
18673 if (Object.keys(form).length > 0) {
18674 options.data = form;
18675 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18676 options.transformRequest = xos.transformRequest;
18677 }
18678 $http(options)
18679 .success(function(data, status, headers, config) {
18680 deferred.resolve(data);
18681 if (parameters.$cache !== undefined) {
18682 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18683 }
18684 })
18685 .error(function(data, status, headers, config) {
18686 deferred.reject({
18687 status: status,
18688 headers: headers,
18689 config: config,
18690 body: data
18691 });
18692 });
18693
18694 return deferred.promise;
18695 };
18696 /**
18697 *
18698 * @method
18699 * @name xos#Node_List_POST
18700 * @param {string} enacted -
18701 * @param {string} policed -
18702 * @param {string} backend_register -
18703 * @param {string} backend_status -
18704 * @param {boolean} deleted -
18705 * @param {boolean} write_protect -
18706 * @param {boolean} lazy_blocked -
18707 * @param {boolean} no_sync -
18708 * @param {string} name - Name of the Node
18709 * @param {string} site_deployment -
18710 * @param {string} site -
18711 *
18712 */
18713 xos.prototype.Node_List_POST = function(parameters) {
18714 if (parameters === undefined) {
18715 parameters = {};
18716 }
18717 var deferred = $q.defer();
18718
18719 var domain = this.domain;
18720 var path = '/xos/nodes/';
18721
18722 var body;
18723 var queryParameters = {};
18724 var headers = {};
18725 var form = {};
18726
18727 if (parameters['enacted'] !== undefined) {
18728 form['enacted'] = parameters['enacted'];
18729 }
18730
18731 if (parameters['policed'] !== undefined) {
18732 form['policed'] = parameters['policed'];
18733 }
18734
18735 if (parameters['backend_register'] !== undefined) {
18736 form['backend_register'] = parameters['backend_register'];
18737 }
18738
18739 if (parameters['backend_status'] !== undefined) {
18740 form['backend_status'] = parameters['backend_status'];
18741 }
18742
18743 if (parameters['backend_status'] === undefined) {
18744 deferred.reject(new Error('Missing required form parameter: backend_status'));
18745 return deferred.promise;
18746 }
18747
18748 if (parameters['deleted'] !== undefined) {
18749 form['deleted'] = parameters['deleted'];
18750 }
18751
18752 if (parameters['write_protect'] !== undefined) {
18753 form['write_protect'] = parameters['write_protect'];
18754 }
18755
18756 if (parameters['lazy_blocked'] !== undefined) {
18757 form['lazy_blocked'] = parameters['lazy_blocked'];
18758 }
18759
18760 if (parameters['no_sync'] !== undefined) {
18761 form['no_sync'] = parameters['no_sync'];
18762 }
18763
18764 if (parameters['name'] !== undefined) {
18765 form['name'] = parameters['name'];
18766 }
18767
18768 if (parameters['name'] === undefined) {
18769 deferred.reject(new Error('Missing required form parameter: name'));
18770 return deferred.promise;
18771 }
18772
18773 if (parameters['site_deployment'] !== undefined) {
18774 form['site_deployment'] = parameters['site_deployment'];
18775 }
18776
18777 if (parameters['site_deployment'] === undefined) {
18778 deferred.reject(new Error('Missing required form parameter: site_deployment'));
18779 return deferred.promise;
18780 }
18781
18782 if (parameters['site'] !== undefined) {
18783 form['site'] = parameters['site'];
18784 }
18785
18786 if (parameters.$queryParameters) {
18787 Object.keys(parameters.$queryParameters)
18788 .forEach(function(parameterName) {
18789 var parameter = parameters.$queryParameters[parameterName];
18790 queryParameters[parameterName] = parameter;
18791 });
18792 }
18793
18794 var url = domain + path;
18795 var options = {
18796 timeout: parameters.$timeout,
18797 method: 'POST',
18798 url: url,
18799 params: queryParameters,
18800 data: body,
18801 headers: headers
18802 };
18803 if (Object.keys(form).length > 0) {
18804 options.data = form;
18805 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18806 options.transformRequest = xos.transformRequest;
18807 }
18808 $http(options)
18809 .success(function(data, status, headers, config) {
18810 deferred.resolve(data);
18811 if (parameters.$cache !== undefined) {
18812 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18813 }
18814 })
18815 .error(function(data, status, headers, config) {
18816 deferred.reject({
18817 status: status,
18818 headers: headers,
18819 config: config,
18820 body: data
18821 });
18822 });
18823
18824 return deferred.promise;
18825 };
18826 /**
18827 *
18828 * @method
18829 * @name xos#Node_Detail_GET
18830 * @param {string} pk -
18831 *
18832 */
18833 xos.prototype.Node_Detail_GET = function(parameters) {
18834 if (parameters === undefined) {
18835 parameters = {};
18836 }
18837 var deferred = $q.defer();
18838
18839 var domain = this.domain;
18840 var path = '/xos/nodes/{pk}/';
18841
18842 var body;
18843 var queryParameters = {};
18844 var headers = {};
18845 var form = {};
18846
18847 path = path.replace('{pk}', parameters['pk']);
18848
18849 if (parameters['pk'] === undefined) {
18850 deferred.reject(new Error('Missing required path parameter: pk'));
18851 return deferred.promise;
18852 }
18853
18854 if (parameters.$queryParameters) {
18855 Object.keys(parameters.$queryParameters)
18856 .forEach(function(parameterName) {
18857 var parameter = parameters.$queryParameters[parameterName];
18858 queryParameters[parameterName] = parameter;
18859 });
18860 }
18861
18862 var url = domain + path;
18863 var cached = parameters.$cache && parameters.$cache.get(url);
18864 if (cached !== undefined && parameters.$refresh !== true) {
18865 deferred.resolve(cached);
18866 return deferred.promise;
18867 }
18868 var options = {
18869 timeout: parameters.$timeout,
18870 method: 'GET',
18871 url: url,
18872 params: queryParameters,
18873 data: body,
18874 headers: headers
18875 };
18876 if (Object.keys(form).length > 0) {
18877 options.data = form;
18878 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
18879 options.transformRequest = xos.transformRequest;
18880 }
18881 $http(options)
18882 .success(function(data, status, headers, config) {
18883 deferred.resolve(data);
18884 if (parameters.$cache !== undefined) {
18885 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
18886 }
18887 })
18888 .error(function(data, status, headers, config) {
18889 deferred.reject({
18890 status: status,
18891 headers: headers,
18892 config: config,
18893 body: data
18894 });
18895 });
18896
18897 return deferred.promise;
18898 };
18899 /**
18900 *
18901 * @method
18902 * @name xos#Node_Detail_PUT
18903 * @param {string} pk -
18904 * @param {string} enacted -
18905 * @param {string} policed -
18906 * @param {string} backend_register -
18907 * @param {string} backend_status -
18908 * @param {boolean} deleted -
18909 * @param {boolean} write_protect -
18910 * @param {boolean} lazy_blocked -
18911 * @param {boolean} no_sync -
18912 * @param {string} name - Name of the Node
18913 * @param {string} site_deployment -
18914 * @param {string} site -
18915 *
18916 */
18917 xos.prototype.Node_Detail_PUT = function(parameters) {
18918 if (parameters === undefined) {
18919 parameters = {};
18920 }
18921 var deferred = $q.defer();
18922
18923 var domain = this.domain;
18924 var path = '/xos/nodes/{pk}/';
18925
18926 var body;
18927 var queryParameters = {};
18928 var headers = {};
18929 var form = {};
18930
18931 path = path.replace('{pk}', parameters['pk']);
18932
18933 if (parameters['pk'] === undefined) {
18934 deferred.reject(new Error('Missing required path parameter: pk'));
18935 return deferred.promise;
18936 }
18937
18938 if (parameters['enacted'] !== undefined) {
18939 form['enacted'] = parameters['enacted'];
18940 }
18941
18942 if (parameters['policed'] !== undefined) {
18943 form['policed'] = parameters['policed'];
18944 }
18945
18946 if (parameters['backend_register'] !== undefined) {
18947 form['backend_register'] = parameters['backend_register'];
18948 }
18949
18950 if (parameters['backend_status'] !== undefined) {
18951 form['backend_status'] = parameters['backend_status'];
18952 }
18953
18954 if (parameters['backend_status'] === undefined) {
18955 deferred.reject(new Error('Missing required form parameter: backend_status'));
18956 return deferred.promise;
18957 }
18958
18959 if (parameters['deleted'] !== undefined) {
18960 form['deleted'] = parameters['deleted'];
18961 }
18962
18963 if (parameters['write_protect'] !== undefined) {
18964 form['write_protect'] = parameters['write_protect'];
18965 }
18966
18967 if (parameters['lazy_blocked'] !== undefined) {
18968 form['lazy_blocked'] = parameters['lazy_blocked'];
18969 }
18970
18971 if (parameters['no_sync'] !== undefined) {
18972 form['no_sync'] = parameters['no_sync'];
18973 }
18974
18975 if (parameters['name'] !== undefined) {
18976 form['name'] = parameters['name'];
18977 }
18978
18979 if (parameters['name'] === undefined) {
18980 deferred.reject(new Error('Missing required form parameter: name'));
18981 return deferred.promise;
18982 }
18983
18984 if (parameters['site_deployment'] !== undefined) {
18985 form['site_deployment'] = parameters['site_deployment'];
18986 }
18987
18988 if (parameters['site_deployment'] === undefined) {
18989 deferred.reject(new Error('Missing required form parameter: site_deployment'));
18990 return deferred.promise;
18991 }
18992
18993 if (parameters['site'] !== undefined) {
18994 form['site'] = parameters['site'];
18995 }
18996
18997 if (parameters.$queryParameters) {
18998 Object.keys(parameters.$queryParameters)
18999 .forEach(function(parameterName) {
19000 var parameter = parameters.$queryParameters[parameterName];
19001 queryParameters[parameterName] = parameter;
19002 });
19003 }
19004
19005 var url = domain + path;
19006 var options = {
19007 timeout: parameters.$timeout,
19008 method: 'PUT',
19009 url: url,
19010 params: queryParameters,
19011 data: body,
19012 headers: headers
19013 };
19014 if (Object.keys(form).length > 0) {
19015 options.data = form;
19016 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19017 options.transformRequest = xos.transformRequest;
19018 }
19019 $http(options)
19020 .success(function(data, status, headers, config) {
19021 deferred.resolve(data);
19022 if (parameters.$cache !== undefined) {
19023 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19024 }
19025 })
19026 .error(function(data, status, headers, config) {
19027 deferred.reject({
19028 status: status,
19029 headers: headers,
19030 config: config,
19031 body: data
19032 });
19033 });
19034
19035 return deferred.promise;
19036 };
19037 /**
19038 *
19039 * @method
19040 * @name xos#Node_Detail_PATCH
19041 * @param {string} pk -
19042 * @param {string} enacted -
19043 * @param {string} policed -
19044 * @param {string} backend_register -
19045 * @param {string} backend_status -
19046 * @param {boolean} deleted -
19047 * @param {boolean} write_protect -
19048 * @param {boolean} lazy_blocked -
19049 * @param {boolean} no_sync -
19050 * @param {string} name - Name of the Node
19051 * @param {string} site_deployment -
19052 * @param {string} site -
19053 *
19054 */
19055 xos.prototype.Node_Detail_PATCH = function(parameters) {
19056 if (parameters === undefined) {
19057 parameters = {};
19058 }
19059 var deferred = $q.defer();
19060
19061 var domain = this.domain;
19062 var path = '/xos/nodes/{pk}/';
19063
19064 var body;
19065 var queryParameters = {};
19066 var headers = {};
19067 var form = {};
19068
19069 path = path.replace('{pk}', parameters['pk']);
19070
19071 if (parameters['pk'] === undefined) {
19072 deferred.reject(new Error('Missing required path parameter: pk'));
19073 return deferred.promise;
19074 }
19075
19076 if (parameters['enacted'] !== undefined) {
19077 form['enacted'] = parameters['enacted'];
19078 }
19079
19080 if (parameters['policed'] !== undefined) {
19081 form['policed'] = parameters['policed'];
19082 }
19083
19084 if (parameters['backend_register'] !== undefined) {
19085 form['backend_register'] = parameters['backend_register'];
19086 }
19087
19088 if (parameters['backend_status'] !== undefined) {
19089 form['backend_status'] = parameters['backend_status'];
19090 }
19091
19092 if (parameters['deleted'] !== undefined) {
19093 form['deleted'] = parameters['deleted'];
19094 }
19095
19096 if (parameters['write_protect'] !== undefined) {
19097 form['write_protect'] = parameters['write_protect'];
19098 }
19099
19100 if (parameters['lazy_blocked'] !== undefined) {
19101 form['lazy_blocked'] = parameters['lazy_blocked'];
19102 }
19103
19104 if (parameters['no_sync'] !== undefined) {
19105 form['no_sync'] = parameters['no_sync'];
19106 }
19107
19108 if (parameters['name'] !== undefined) {
19109 form['name'] = parameters['name'];
19110 }
19111
19112 if (parameters['site_deployment'] !== undefined) {
19113 form['site_deployment'] = parameters['site_deployment'];
19114 }
19115
19116 if (parameters['site'] !== undefined) {
19117 form['site'] = parameters['site'];
19118 }
19119
19120 if (parameters.$queryParameters) {
19121 Object.keys(parameters.$queryParameters)
19122 .forEach(function(parameterName) {
19123 var parameter = parameters.$queryParameters[parameterName];
19124 queryParameters[parameterName] = parameter;
19125 });
19126 }
19127
19128 var url = domain + path;
19129 var options = {
19130 timeout: parameters.$timeout,
19131 method: 'PATCH',
19132 url: url,
19133 params: queryParameters,
19134 data: body,
19135 headers: headers
19136 };
19137 if (Object.keys(form).length > 0) {
19138 options.data = form;
19139 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19140 options.transformRequest = xos.transformRequest;
19141 }
19142 $http(options)
19143 .success(function(data, status, headers, config) {
19144 deferred.resolve(data);
19145 if (parameters.$cache !== undefined) {
19146 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19147 }
19148 })
19149 .error(function(data, status, headers, config) {
19150 deferred.reject({
19151 status: status,
19152 headers: headers,
19153 config: config,
19154 body: data
19155 });
19156 });
19157
19158 return deferred.promise;
19159 };
19160 /**
19161 *
19162 * @method
19163 * @name xos#Node_Detail_DELETE
19164 * @param {string} pk -
19165 *
19166 */
19167 xos.prototype.Node_Detail_DELETE = function(parameters) {
19168 if (parameters === undefined) {
19169 parameters = {};
19170 }
19171 var deferred = $q.defer();
19172
19173 var domain = this.domain;
19174 var path = '/xos/nodes/{pk}/';
19175
19176 var body;
19177 var queryParameters = {};
19178 var headers = {};
19179 var form = {};
19180
19181 path = path.replace('{pk}', parameters['pk']);
19182
19183 if (parameters['pk'] === undefined) {
19184 deferred.reject(new Error('Missing required path parameter: pk'));
19185 return deferred.promise;
19186 }
19187
19188 if (parameters.$queryParameters) {
19189 Object.keys(parameters.$queryParameters)
19190 .forEach(function(parameterName) {
19191 var parameter = parameters.$queryParameters[parameterName];
19192 queryParameters[parameterName] = parameter;
19193 });
19194 }
19195
19196 var url = domain + path;
19197 var options = {
19198 timeout: parameters.$timeout,
19199 method: 'DELETE',
19200 url: url,
19201 params: queryParameters,
19202 data: body,
19203 headers: headers
19204 };
19205 if (Object.keys(form).length > 0) {
19206 options.data = form;
19207 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19208 options.transformRequest = xos.transformRequest;
19209 }
19210 $http(options)
19211 .success(function(data, status, headers, config) {
19212 deferred.resolve(data);
19213 if (parameters.$cache !== undefined) {
19214 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19215 }
19216 })
19217 .error(function(data, status, headers, config) {
19218 deferred.reject({
19219 status: status,
19220 headers: headers,
19221 config: config,
19222 body: data
19223 });
19224 });
19225
19226 return deferred.promise;
19227 };
19228 /**
19229 *
19230 * @method
19231 * @name xos#Dashboard_View_List_GET
19232 *
19233 */
19234 xos.prototype.Dashboard_View_List_GET = function(parameters) {
19235 if (parameters === undefined) {
19236 parameters = {};
19237 }
19238 var deferred = $q.defer();
19239
19240 var domain = this.domain;
19241 var path = '/xos/dashboardviews/';
19242
19243 var body;
19244 var queryParameters = {};
19245 var headers = {};
19246 var form = {};
19247
19248 if (parameters.$queryParameters) {
19249 Object.keys(parameters.$queryParameters)
19250 .forEach(function(parameterName) {
19251 var parameter = parameters.$queryParameters[parameterName];
19252 queryParameters[parameterName] = parameter;
19253 });
19254 }
19255
19256 var url = domain + path;
19257 var cached = parameters.$cache && parameters.$cache.get(url);
19258 if (cached !== undefined && parameters.$refresh !== true) {
19259 deferred.resolve(cached);
19260 return deferred.promise;
19261 }
19262 var options = {
19263 timeout: parameters.$timeout,
19264 method: 'GET',
19265 url: url,
19266 params: queryParameters,
19267 data: body,
19268 headers: headers
19269 };
19270 if (Object.keys(form).length > 0) {
19271 options.data = form;
19272 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19273 options.transformRequest = xos.transformRequest;
19274 }
19275 $http(options)
19276 .success(function(data, status, headers, config) {
19277 deferred.resolve(data);
19278 if (parameters.$cache !== undefined) {
19279 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19280 }
19281 })
19282 .error(function(data, status, headers, config) {
19283 deferred.reject({
19284 status: status,
19285 headers: headers,
19286 config: config,
19287 body: data
19288 });
19289 });
19290
19291 return deferred.promise;
19292 };
19293 /**
19294 *
19295 * @method
19296 * @name xos#Dashboard_View_List_POST
19297 * @param {string} enacted -
19298 * @param {string} policed -
19299 * @param {string} backend_register -
19300 * @param {string} backend_status -
19301 * @param {boolean} deleted -
19302 * @param {boolean} write_protect -
19303 * @param {boolean} lazy_blocked -
19304 * @param {boolean} no_sync -
19305 * @param {string} name - Name of the View
19306 * @param {string} url - URL of Dashboard
19307 * @param {boolean} enabled -
19308 *
19309 */
19310 xos.prototype.Dashboard_View_List_POST = function(parameters) {
19311 if (parameters === undefined) {
19312 parameters = {};
19313 }
19314 var deferred = $q.defer();
19315
19316 var domain = this.domain;
19317 var path = '/xos/dashboardviews/';
19318
19319 var body;
19320 var queryParameters = {};
19321 var headers = {};
19322 var form = {};
19323
19324 if (parameters['enacted'] !== undefined) {
19325 form['enacted'] = parameters['enacted'];
19326 }
19327
19328 if (parameters['policed'] !== undefined) {
19329 form['policed'] = parameters['policed'];
19330 }
19331
19332 if (parameters['backend_register'] !== undefined) {
19333 form['backend_register'] = parameters['backend_register'];
19334 }
19335
19336 if (parameters['backend_status'] !== undefined) {
19337 form['backend_status'] = parameters['backend_status'];
19338 }
19339
19340 if (parameters['backend_status'] === undefined) {
19341 deferred.reject(new Error('Missing required form parameter: backend_status'));
19342 return deferred.promise;
19343 }
19344
19345 if (parameters['deleted'] !== undefined) {
19346 form['deleted'] = parameters['deleted'];
19347 }
19348
19349 if (parameters['write_protect'] !== undefined) {
19350 form['write_protect'] = parameters['write_protect'];
19351 }
19352
19353 if (parameters['lazy_blocked'] !== undefined) {
19354 form['lazy_blocked'] = parameters['lazy_blocked'];
19355 }
19356
19357 if (parameters['no_sync'] !== undefined) {
19358 form['no_sync'] = parameters['no_sync'];
19359 }
19360
19361 if (parameters['name'] !== undefined) {
19362 form['name'] = parameters['name'];
19363 }
19364
19365 if (parameters['name'] === undefined) {
19366 deferred.reject(new Error('Missing required form parameter: name'));
19367 return deferred.promise;
19368 }
19369
19370 if (parameters['url'] !== undefined) {
19371 form['url'] = parameters['url'];
19372 }
19373
19374 if (parameters['url'] === undefined) {
19375 deferred.reject(new Error('Missing required form parameter: url'));
19376 return deferred.promise;
19377 }
19378
19379 if (parameters['enabled'] !== undefined) {
19380 form['enabled'] = parameters['enabled'];
19381 }
19382
19383 if (parameters.$queryParameters) {
19384 Object.keys(parameters.$queryParameters)
19385 .forEach(function(parameterName) {
19386 var parameter = parameters.$queryParameters[parameterName];
19387 queryParameters[parameterName] = parameter;
19388 });
19389 }
19390
19391 var url = domain + path;
19392 var options = {
19393 timeout: parameters.$timeout,
19394 method: 'POST',
19395 url: url,
19396 params: queryParameters,
19397 data: body,
19398 headers: headers
19399 };
19400 if (Object.keys(form).length > 0) {
19401 options.data = form;
19402 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19403 options.transformRequest = xos.transformRequest;
19404 }
19405 $http(options)
19406 .success(function(data, status, headers, config) {
19407 deferred.resolve(data);
19408 if (parameters.$cache !== undefined) {
19409 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19410 }
19411 })
19412 .error(function(data, status, headers, config) {
19413 deferred.reject({
19414 status: status,
19415 headers: headers,
19416 config: config,
19417 body: data
19418 });
19419 });
19420
19421 return deferred.promise;
19422 };
19423 /**
19424 *
19425 * @method
19426 * @name xos#Dashboard_View_Detail_GET
19427 * @param {string} pk -
19428 *
19429 */
19430 xos.prototype.Dashboard_View_Detail_GET = function(parameters) {
19431 if (parameters === undefined) {
19432 parameters = {};
19433 }
19434 var deferred = $q.defer();
19435
19436 var domain = this.domain;
19437 var path = '/xos/dashboardviews/{pk}/';
19438
19439 var body;
19440 var queryParameters = {};
19441 var headers = {};
19442 var form = {};
19443
19444 path = path.replace('{pk}', parameters['pk']);
19445
19446 if (parameters['pk'] === undefined) {
19447 deferred.reject(new Error('Missing required path parameter: pk'));
19448 return deferred.promise;
19449 }
19450
19451 if (parameters.$queryParameters) {
19452 Object.keys(parameters.$queryParameters)
19453 .forEach(function(parameterName) {
19454 var parameter = parameters.$queryParameters[parameterName];
19455 queryParameters[parameterName] = parameter;
19456 });
19457 }
19458
19459 var url = domain + path;
19460 var cached = parameters.$cache && parameters.$cache.get(url);
19461 if (cached !== undefined && parameters.$refresh !== true) {
19462 deferred.resolve(cached);
19463 return deferred.promise;
19464 }
19465 var options = {
19466 timeout: parameters.$timeout,
19467 method: 'GET',
19468 url: url,
19469 params: queryParameters,
19470 data: body,
19471 headers: headers
19472 };
19473 if (Object.keys(form).length > 0) {
19474 options.data = form;
19475 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19476 options.transformRequest = xos.transformRequest;
19477 }
19478 $http(options)
19479 .success(function(data, status, headers, config) {
19480 deferred.resolve(data);
19481 if (parameters.$cache !== undefined) {
19482 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19483 }
19484 })
19485 .error(function(data, status, headers, config) {
19486 deferred.reject({
19487 status: status,
19488 headers: headers,
19489 config: config,
19490 body: data
19491 });
19492 });
19493
19494 return deferred.promise;
19495 };
19496 /**
19497 *
19498 * @method
19499 * @name xos#Dashboard_View_Detail_PUT
19500 * @param {string} pk -
19501 * @param {string} enacted -
19502 * @param {string} policed -
19503 * @param {string} backend_register -
19504 * @param {string} backend_status -
19505 * @param {boolean} deleted -
19506 * @param {boolean} write_protect -
19507 * @param {boolean} lazy_blocked -
19508 * @param {boolean} no_sync -
19509 * @param {string} name - Name of the View
19510 * @param {string} url - URL of Dashboard
19511 * @param {boolean} enabled -
19512 *
19513 */
19514 xos.prototype.Dashboard_View_Detail_PUT = function(parameters) {
19515 if (parameters === undefined) {
19516 parameters = {};
19517 }
19518 var deferred = $q.defer();
19519
19520 var domain = this.domain;
19521 var path = '/xos/dashboardviews/{pk}/';
19522
19523 var body;
19524 var queryParameters = {};
19525 var headers = {};
19526 var form = {};
19527
19528 path = path.replace('{pk}', parameters['pk']);
19529
19530 if (parameters['pk'] === undefined) {
19531 deferred.reject(new Error('Missing required path parameter: pk'));
19532 return deferred.promise;
19533 }
19534
19535 if (parameters['enacted'] !== undefined) {
19536 form['enacted'] = parameters['enacted'];
19537 }
19538
19539 if (parameters['policed'] !== undefined) {
19540 form['policed'] = parameters['policed'];
19541 }
19542
19543 if (parameters['backend_register'] !== undefined) {
19544 form['backend_register'] = parameters['backend_register'];
19545 }
19546
19547 if (parameters['backend_status'] !== undefined) {
19548 form['backend_status'] = parameters['backend_status'];
19549 }
19550
19551 if (parameters['backend_status'] === undefined) {
19552 deferred.reject(new Error('Missing required form parameter: backend_status'));
19553 return deferred.promise;
19554 }
19555
19556 if (parameters['deleted'] !== undefined) {
19557 form['deleted'] = parameters['deleted'];
19558 }
19559
19560 if (parameters['write_protect'] !== undefined) {
19561 form['write_protect'] = parameters['write_protect'];
19562 }
19563
19564 if (parameters['lazy_blocked'] !== undefined) {
19565 form['lazy_blocked'] = parameters['lazy_blocked'];
19566 }
19567
19568 if (parameters['no_sync'] !== undefined) {
19569 form['no_sync'] = parameters['no_sync'];
19570 }
19571
19572 if (parameters['name'] !== undefined) {
19573 form['name'] = parameters['name'];
19574 }
19575
19576 if (parameters['name'] === undefined) {
19577 deferred.reject(new Error('Missing required form parameter: name'));
19578 return deferred.promise;
19579 }
19580
19581 if (parameters['url'] !== undefined) {
19582 form['url'] = parameters['url'];
19583 }
19584
19585 if (parameters['url'] === undefined) {
19586 deferred.reject(new Error('Missing required form parameter: url'));
19587 return deferred.promise;
19588 }
19589
19590 if (parameters['enabled'] !== undefined) {
19591 form['enabled'] = parameters['enabled'];
19592 }
19593
19594 if (parameters.$queryParameters) {
19595 Object.keys(parameters.$queryParameters)
19596 .forEach(function(parameterName) {
19597 var parameter = parameters.$queryParameters[parameterName];
19598 queryParameters[parameterName] = parameter;
19599 });
19600 }
19601
19602 var url = domain + path;
19603 var options = {
19604 timeout: parameters.$timeout,
19605 method: 'PUT',
19606 url: url,
19607 params: queryParameters,
19608 data: body,
19609 headers: headers
19610 };
19611 if (Object.keys(form).length > 0) {
19612 options.data = form;
19613 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19614 options.transformRequest = xos.transformRequest;
19615 }
19616 $http(options)
19617 .success(function(data, status, headers, config) {
19618 deferred.resolve(data);
19619 if (parameters.$cache !== undefined) {
19620 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19621 }
19622 })
19623 .error(function(data, status, headers, config) {
19624 deferred.reject({
19625 status: status,
19626 headers: headers,
19627 config: config,
19628 body: data
19629 });
19630 });
19631
19632 return deferred.promise;
19633 };
19634 /**
19635 *
19636 * @method
19637 * @name xos#Dashboard_View_Detail_PATCH
19638 * @param {string} pk -
19639 * @param {string} enacted -
19640 * @param {string} policed -
19641 * @param {string} backend_register -
19642 * @param {string} backend_status -
19643 * @param {boolean} deleted -
19644 * @param {boolean} write_protect -
19645 * @param {boolean} lazy_blocked -
19646 * @param {boolean} no_sync -
19647 * @param {string} name - Name of the View
19648 * @param {string} url - URL of Dashboard
19649 * @param {boolean} enabled -
19650 *
19651 */
19652 xos.prototype.Dashboard_View_Detail_PATCH = function(parameters) {
19653 if (parameters === undefined) {
19654 parameters = {};
19655 }
19656 var deferred = $q.defer();
19657
19658 var domain = this.domain;
19659 var path = '/xos/dashboardviews/{pk}/';
19660
19661 var body;
19662 var queryParameters = {};
19663 var headers = {};
19664 var form = {};
19665
19666 path = path.replace('{pk}', parameters['pk']);
19667
19668 if (parameters['pk'] === undefined) {
19669 deferred.reject(new Error('Missing required path parameter: pk'));
19670 return deferred.promise;
19671 }
19672
19673 if (parameters['enacted'] !== undefined) {
19674 form['enacted'] = parameters['enacted'];
19675 }
19676
19677 if (parameters['policed'] !== undefined) {
19678 form['policed'] = parameters['policed'];
19679 }
19680
19681 if (parameters['backend_register'] !== undefined) {
19682 form['backend_register'] = parameters['backend_register'];
19683 }
19684
19685 if (parameters['backend_status'] !== undefined) {
19686 form['backend_status'] = parameters['backend_status'];
19687 }
19688
19689 if (parameters['deleted'] !== undefined) {
19690 form['deleted'] = parameters['deleted'];
19691 }
19692
19693 if (parameters['write_protect'] !== undefined) {
19694 form['write_protect'] = parameters['write_protect'];
19695 }
19696
19697 if (parameters['lazy_blocked'] !== undefined) {
19698 form['lazy_blocked'] = parameters['lazy_blocked'];
19699 }
19700
19701 if (parameters['no_sync'] !== undefined) {
19702 form['no_sync'] = parameters['no_sync'];
19703 }
19704
19705 if (parameters['name'] !== undefined) {
19706 form['name'] = parameters['name'];
19707 }
19708
19709 if (parameters['url'] !== undefined) {
19710 form['url'] = parameters['url'];
19711 }
19712
19713 if (parameters['enabled'] !== undefined) {
19714 form['enabled'] = parameters['enabled'];
19715 }
19716
19717 if (parameters.$queryParameters) {
19718 Object.keys(parameters.$queryParameters)
19719 .forEach(function(parameterName) {
19720 var parameter = parameters.$queryParameters[parameterName];
19721 queryParameters[parameterName] = parameter;
19722 });
19723 }
19724
19725 var url = domain + path;
19726 var options = {
19727 timeout: parameters.$timeout,
19728 method: 'PATCH',
19729 url: url,
19730 params: queryParameters,
19731 data: body,
19732 headers: headers
19733 };
19734 if (Object.keys(form).length > 0) {
19735 options.data = form;
19736 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19737 options.transformRequest = xos.transformRequest;
19738 }
19739 $http(options)
19740 .success(function(data, status, headers, config) {
19741 deferred.resolve(data);
19742 if (parameters.$cache !== undefined) {
19743 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19744 }
19745 })
19746 .error(function(data, status, headers, config) {
19747 deferred.reject({
19748 status: status,
19749 headers: headers,
19750 config: config,
19751 body: data
19752 });
19753 });
19754
19755 return deferred.promise;
19756 };
19757 /**
19758 *
19759 * @method
19760 * @name xos#Dashboard_View_Detail_DELETE
19761 * @param {string} pk -
19762 *
19763 */
19764 xos.prototype.Dashboard_View_Detail_DELETE = function(parameters) {
19765 if (parameters === undefined) {
19766 parameters = {};
19767 }
19768 var deferred = $q.defer();
19769
19770 var domain = this.domain;
19771 var path = '/xos/dashboardviews/{pk}/';
19772
19773 var body;
19774 var queryParameters = {};
19775 var headers = {};
19776 var form = {};
19777
19778 path = path.replace('{pk}', parameters['pk']);
19779
19780 if (parameters['pk'] === undefined) {
19781 deferred.reject(new Error('Missing required path parameter: pk'));
19782 return deferred.promise;
19783 }
19784
19785 if (parameters.$queryParameters) {
19786 Object.keys(parameters.$queryParameters)
19787 .forEach(function(parameterName) {
19788 var parameter = parameters.$queryParameters[parameterName];
19789 queryParameters[parameterName] = parameter;
19790 });
19791 }
19792
19793 var url = domain + path;
19794 var options = {
19795 timeout: parameters.$timeout,
19796 method: 'DELETE',
19797 url: url,
19798 params: queryParameters,
19799 data: body,
19800 headers: headers
19801 };
19802 if (Object.keys(form).length > 0) {
19803 options.data = form;
19804 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19805 options.transformRequest = xos.transformRequest;
19806 }
19807 $http(options)
19808 .success(function(data, status, headers, config) {
19809 deferred.resolve(data);
19810 if (parameters.$cache !== undefined) {
19811 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19812 }
19813 })
19814 .error(function(data, status, headers, config) {
19815 deferred.reject({
19816 status: status,
19817 headers: headers,
19818 config: config,
19819 body: data
19820 });
19821 });
19822
19823 return deferred.promise;
19824 };
19825 /**
19826 *
19827 * @method
19828 * @name xos#Controller_Network_List_GET
19829 *
19830 */
19831 xos.prototype.Controller_Network_List_GET = function(parameters) {
19832 if (parameters === undefined) {
19833 parameters = {};
19834 }
19835 var deferred = $q.defer();
19836
19837 var domain = this.domain;
19838 var path = '/xos/controllernetworks/';
19839
19840 var body;
19841 var queryParameters = {};
19842 var headers = {};
19843 var form = {};
19844
19845 if (parameters.$queryParameters) {
19846 Object.keys(parameters.$queryParameters)
19847 .forEach(function(parameterName) {
19848 var parameter = parameters.$queryParameters[parameterName];
19849 queryParameters[parameterName] = parameter;
19850 });
19851 }
19852
19853 var url = domain + path;
19854 var cached = parameters.$cache && parameters.$cache.get(url);
19855 if (cached !== undefined && parameters.$refresh !== true) {
19856 deferred.resolve(cached);
19857 return deferred.promise;
19858 }
19859 var options = {
19860 timeout: parameters.$timeout,
19861 method: 'GET',
19862 url: url,
19863 params: queryParameters,
19864 data: body,
19865 headers: headers
19866 };
19867 if (Object.keys(form).length > 0) {
19868 options.data = form;
19869 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
19870 options.transformRequest = xos.transformRequest;
19871 }
19872 $http(options)
19873 .success(function(data, status, headers, config) {
19874 deferred.resolve(data);
19875 if (parameters.$cache !== undefined) {
19876 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
19877 }
19878 })
19879 .error(function(data, status, headers, config) {
19880 deferred.reject({
19881 status: status,
19882 headers: headers,
19883 config: config,
19884 body: data
19885 });
19886 });
19887
19888 return deferred.promise;
19889 };
19890 /**
19891 *
19892 * @method
19893 * @name xos#Controller_Network_List_POST
19894 * @param {string} enacted -
19895 * @param {string} policed -
19896 * @param {string} backend_register -
19897 * @param {string} backend_status -
19898 * @param {boolean} deleted -
19899 * @param {boolean} write_protect -
19900 * @param {boolean} lazy_blocked -
19901 * @param {boolean} no_sync -
19902 * @param {string} network -
19903 * @param {string} controller -
19904 * @param {string} net_id - Quantum network
19905 * @param {string} router_id - Quantum router id
19906 * @param {string} subnet_id - Quantum subnet id
19907 * @param {string} subnet -
19908 *
19909 */
19910 xos.prototype.Controller_Network_List_POST = function(parameters) {
19911 if (parameters === undefined) {
19912 parameters = {};
19913 }
19914 var deferred = $q.defer();
19915
19916 var domain = this.domain;
19917 var path = '/xos/controllernetworks/';
19918
19919 var body;
19920 var queryParameters = {};
19921 var headers = {};
19922 var form = {};
19923
19924 if (parameters['enacted'] !== undefined) {
19925 form['enacted'] = parameters['enacted'];
19926 }
19927
19928 if (parameters['policed'] !== undefined) {
19929 form['policed'] = parameters['policed'];
19930 }
19931
19932 if (parameters['backend_register'] !== undefined) {
19933 form['backend_register'] = parameters['backend_register'];
19934 }
19935
19936 if (parameters['backend_status'] !== undefined) {
19937 form['backend_status'] = parameters['backend_status'];
19938 }
19939
19940 if (parameters['backend_status'] === undefined) {
19941 deferred.reject(new Error('Missing required form parameter: backend_status'));
19942 return deferred.promise;
19943 }
19944
19945 if (parameters['deleted'] !== undefined) {
19946 form['deleted'] = parameters['deleted'];
19947 }
19948
19949 if (parameters['write_protect'] !== undefined) {
19950 form['write_protect'] = parameters['write_protect'];
19951 }
19952
19953 if (parameters['lazy_blocked'] !== undefined) {
19954 form['lazy_blocked'] = parameters['lazy_blocked'];
19955 }
19956
19957 if (parameters['no_sync'] !== undefined) {
19958 form['no_sync'] = parameters['no_sync'];
19959 }
19960
19961 if (parameters['network'] !== undefined) {
19962 form['network'] = parameters['network'];
19963 }
19964
19965 if (parameters['network'] === undefined) {
19966 deferred.reject(new Error('Missing required form parameter: network'));
19967 return deferred.promise;
19968 }
19969
19970 if (parameters['controller'] !== undefined) {
19971 form['controller'] = parameters['controller'];
19972 }
19973
19974 if (parameters['controller'] === undefined) {
19975 deferred.reject(new Error('Missing required form parameter: controller'));
19976 return deferred.promise;
19977 }
19978
19979 if (parameters['net_id'] !== undefined) {
19980 form['net_id'] = parameters['net_id'];
19981 }
19982
19983 if (parameters['router_id'] !== undefined) {
19984 form['router_id'] = parameters['router_id'];
19985 }
19986
19987 if (parameters['subnet_id'] !== undefined) {
19988 form['subnet_id'] = parameters['subnet_id'];
19989 }
19990
19991 if (parameters['subnet'] !== undefined) {
19992 form['subnet'] = parameters['subnet'];
19993 }
19994
19995 if (parameters.$queryParameters) {
19996 Object.keys(parameters.$queryParameters)
19997 .forEach(function(parameterName) {
19998 var parameter = parameters.$queryParameters[parameterName];
19999 queryParameters[parameterName] = parameter;
20000 });
20001 }
20002
20003 var url = domain + path;
20004 var options = {
20005 timeout: parameters.$timeout,
20006 method: 'POST',
20007 url: url,
20008 params: queryParameters,
20009 data: body,
20010 headers: headers
20011 };
20012 if (Object.keys(form).length > 0) {
20013 options.data = form;
20014 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20015 options.transformRequest = xos.transformRequest;
20016 }
20017 $http(options)
20018 .success(function(data, status, headers, config) {
20019 deferred.resolve(data);
20020 if (parameters.$cache !== undefined) {
20021 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20022 }
20023 })
20024 .error(function(data, status, headers, config) {
20025 deferred.reject({
20026 status: status,
20027 headers: headers,
20028 config: config,
20029 body: data
20030 });
20031 });
20032
20033 return deferred.promise;
20034 };
20035 /**
20036 *
20037 * @method
20038 * @name xos#Controller_Network_Detail_GET
20039 * @param {string} pk -
20040 *
20041 */
20042 xos.prototype.Controller_Network_Detail_GET = function(parameters) {
20043 if (parameters === undefined) {
20044 parameters = {};
20045 }
20046 var deferred = $q.defer();
20047
20048 var domain = this.domain;
20049 var path = '/xos/controllernetworks/{pk}/';
20050
20051 var body;
20052 var queryParameters = {};
20053 var headers = {};
20054 var form = {};
20055
20056 path = path.replace('{pk}', parameters['pk']);
20057
20058 if (parameters['pk'] === undefined) {
20059 deferred.reject(new Error('Missing required path parameter: pk'));
20060 return deferred.promise;
20061 }
20062
20063 if (parameters.$queryParameters) {
20064 Object.keys(parameters.$queryParameters)
20065 .forEach(function(parameterName) {
20066 var parameter = parameters.$queryParameters[parameterName];
20067 queryParameters[parameterName] = parameter;
20068 });
20069 }
20070
20071 var url = domain + path;
20072 var cached = parameters.$cache && parameters.$cache.get(url);
20073 if (cached !== undefined && parameters.$refresh !== true) {
20074 deferred.resolve(cached);
20075 return deferred.promise;
20076 }
20077 var options = {
20078 timeout: parameters.$timeout,
20079 method: 'GET',
20080 url: url,
20081 params: queryParameters,
20082 data: body,
20083 headers: headers
20084 };
20085 if (Object.keys(form).length > 0) {
20086 options.data = form;
20087 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20088 options.transformRequest = xos.transformRequest;
20089 }
20090 $http(options)
20091 .success(function(data, status, headers, config) {
20092 deferred.resolve(data);
20093 if (parameters.$cache !== undefined) {
20094 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20095 }
20096 })
20097 .error(function(data, status, headers, config) {
20098 deferred.reject({
20099 status: status,
20100 headers: headers,
20101 config: config,
20102 body: data
20103 });
20104 });
20105
20106 return deferred.promise;
20107 };
20108 /**
20109 *
20110 * @method
20111 * @name xos#Controller_Network_Detail_PUT
20112 * @param {string} pk -
20113 * @param {string} enacted -
20114 * @param {string} policed -
20115 * @param {string} backend_register -
20116 * @param {string} backend_status -
20117 * @param {boolean} deleted -
20118 * @param {boolean} write_protect -
20119 * @param {boolean} lazy_blocked -
20120 * @param {boolean} no_sync -
20121 * @param {string} network -
20122 * @param {string} controller -
20123 * @param {string} net_id - Quantum network
20124 * @param {string} router_id - Quantum router id
20125 * @param {string} subnet_id - Quantum subnet id
20126 * @param {string} subnet -
20127 *
20128 */
20129 xos.prototype.Controller_Network_Detail_PUT = function(parameters) {
20130 if (parameters === undefined) {
20131 parameters = {};
20132 }
20133 var deferred = $q.defer();
20134
20135 var domain = this.domain;
20136 var path = '/xos/controllernetworks/{pk}/';
20137
20138 var body;
20139 var queryParameters = {};
20140 var headers = {};
20141 var form = {};
20142
20143 path = path.replace('{pk}', parameters['pk']);
20144
20145 if (parameters['pk'] === undefined) {
20146 deferred.reject(new Error('Missing required path parameter: pk'));
20147 return deferred.promise;
20148 }
20149
20150 if (parameters['enacted'] !== undefined) {
20151 form['enacted'] = parameters['enacted'];
20152 }
20153
20154 if (parameters['policed'] !== undefined) {
20155 form['policed'] = parameters['policed'];
20156 }
20157
20158 if (parameters['backend_register'] !== undefined) {
20159 form['backend_register'] = parameters['backend_register'];
20160 }
20161
20162 if (parameters['backend_status'] !== undefined) {
20163 form['backend_status'] = parameters['backend_status'];
20164 }
20165
20166 if (parameters['backend_status'] === undefined) {
20167 deferred.reject(new Error('Missing required form parameter: backend_status'));
20168 return deferred.promise;
20169 }
20170
20171 if (parameters['deleted'] !== undefined) {
20172 form['deleted'] = parameters['deleted'];
20173 }
20174
20175 if (parameters['write_protect'] !== undefined) {
20176 form['write_protect'] = parameters['write_protect'];
20177 }
20178
20179 if (parameters['lazy_blocked'] !== undefined) {
20180 form['lazy_blocked'] = parameters['lazy_blocked'];
20181 }
20182
20183 if (parameters['no_sync'] !== undefined) {
20184 form['no_sync'] = parameters['no_sync'];
20185 }
20186
20187 if (parameters['network'] !== undefined) {
20188 form['network'] = parameters['network'];
20189 }
20190
20191 if (parameters['network'] === undefined) {
20192 deferred.reject(new Error('Missing required form parameter: network'));
20193 return deferred.promise;
20194 }
20195
20196 if (parameters['controller'] !== undefined) {
20197 form['controller'] = parameters['controller'];
20198 }
20199
20200 if (parameters['controller'] === undefined) {
20201 deferred.reject(new Error('Missing required form parameter: controller'));
20202 return deferred.promise;
20203 }
20204
20205 if (parameters['net_id'] !== undefined) {
20206 form['net_id'] = parameters['net_id'];
20207 }
20208
20209 if (parameters['router_id'] !== undefined) {
20210 form['router_id'] = parameters['router_id'];
20211 }
20212
20213 if (parameters['subnet_id'] !== undefined) {
20214 form['subnet_id'] = parameters['subnet_id'];
20215 }
20216
20217 if (parameters['subnet'] !== undefined) {
20218 form['subnet'] = parameters['subnet'];
20219 }
20220
20221 if (parameters.$queryParameters) {
20222 Object.keys(parameters.$queryParameters)
20223 .forEach(function(parameterName) {
20224 var parameter = parameters.$queryParameters[parameterName];
20225 queryParameters[parameterName] = parameter;
20226 });
20227 }
20228
20229 var url = domain + path;
20230 var options = {
20231 timeout: parameters.$timeout,
20232 method: 'PUT',
20233 url: url,
20234 params: queryParameters,
20235 data: body,
20236 headers: headers
20237 };
20238 if (Object.keys(form).length > 0) {
20239 options.data = form;
20240 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20241 options.transformRequest = xos.transformRequest;
20242 }
20243 $http(options)
20244 .success(function(data, status, headers, config) {
20245 deferred.resolve(data);
20246 if (parameters.$cache !== undefined) {
20247 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20248 }
20249 })
20250 .error(function(data, status, headers, config) {
20251 deferred.reject({
20252 status: status,
20253 headers: headers,
20254 config: config,
20255 body: data
20256 });
20257 });
20258
20259 return deferred.promise;
20260 };
20261 /**
20262 *
20263 * @method
20264 * @name xos#Controller_Network_Detail_PATCH
20265 * @param {string} pk -
20266 * @param {string} enacted -
20267 * @param {string} policed -
20268 * @param {string} backend_register -
20269 * @param {string} backend_status -
20270 * @param {boolean} deleted -
20271 * @param {boolean} write_protect -
20272 * @param {boolean} lazy_blocked -
20273 * @param {boolean} no_sync -
20274 * @param {string} network -
20275 * @param {string} controller -
20276 * @param {string} net_id - Quantum network
20277 * @param {string} router_id - Quantum router id
20278 * @param {string} subnet_id - Quantum subnet id
20279 * @param {string} subnet -
20280 *
20281 */
20282 xos.prototype.Controller_Network_Detail_PATCH = function(parameters) {
20283 if (parameters === undefined) {
20284 parameters = {};
20285 }
20286 var deferred = $q.defer();
20287
20288 var domain = this.domain;
20289 var path = '/xos/controllernetworks/{pk}/';
20290
20291 var body;
20292 var queryParameters = {};
20293 var headers = {};
20294 var form = {};
20295
20296 path = path.replace('{pk}', parameters['pk']);
20297
20298 if (parameters['pk'] === undefined) {
20299 deferred.reject(new Error('Missing required path parameter: pk'));
20300 return deferred.promise;
20301 }
20302
20303 if (parameters['enacted'] !== undefined) {
20304 form['enacted'] = parameters['enacted'];
20305 }
20306
20307 if (parameters['policed'] !== undefined) {
20308 form['policed'] = parameters['policed'];
20309 }
20310
20311 if (parameters['backend_register'] !== undefined) {
20312 form['backend_register'] = parameters['backend_register'];
20313 }
20314
20315 if (parameters['backend_status'] !== undefined) {
20316 form['backend_status'] = parameters['backend_status'];
20317 }
20318
20319 if (parameters['deleted'] !== undefined) {
20320 form['deleted'] = parameters['deleted'];
20321 }
20322
20323 if (parameters['write_protect'] !== undefined) {
20324 form['write_protect'] = parameters['write_protect'];
20325 }
20326
20327 if (parameters['lazy_blocked'] !== undefined) {
20328 form['lazy_blocked'] = parameters['lazy_blocked'];
20329 }
20330
20331 if (parameters['no_sync'] !== undefined) {
20332 form['no_sync'] = parameters['no_sync'];
20333 }
20334
20335 if (parameters['network'] !== undefined) {
20336 form['network'] = parameters['network'];
20337 }
20338
20339 if (parameters['controller'] !== undefined) {
20340 form['controller'] = parameters['controller'];
20341 }
20342
20343 if (parameters['net_id'] !== undefined) {
20344 form['net_id'] = parameters['net_id'];
20345 }
20346
20347 if (parameters['router_id'] !== undefined) {
20348 form['router_id'] = parameters['router_id'];
20349 }
20350
20351 if (parameters['subnet_id'] !== undefined) {
20352 form['subnet_id'] = parameters['subnet_id'];
20353 }
20354
20355 if (parameters['subnet'] !== undefined) {
20356 form['subnet'] = parameters['subnet'];
20357 }
20358
20359 if (parameters.$queryParameters) {
20360 Object.keys(parameters.$queryParameters)
20361 .forEach(function(parameterName) {
20362 var parameter = parameters.$queryParameters[parameterName];
20363 queryParameters[parameterName] = parameter;
20364 });
20365 }
20366
20367 var url = domain + path;
20368 var options = {
20369 timeout: parameters.$timeout,
20370 method: 'PATCH',
20371 url: url,
20372 params: queryParameters,
20373 data: body,
20374 headers: headers
20375 };
20376 if (Object.keys(form).length > 0) {
20377 options.data = form;
20378 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20379 options.transformRequest = xos.transformRequest;
20380 }
20381 $http(options)
20382 .success(function(data, status, headers, config) {
20383 deferred.resolve(data);
20384 if (parameters.$cache !== undefined) {
20385 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20386 }
20387 })
20388 .error(function(data, status, headers, config) {
20389 deferred.reject({
20390 status: status,
20391 headers: headers,
20392 config: config,
20393 body: data
20394 });
20395 });
20396
20397 return deferred.promise;
20398 };
20399 /**
20400 *
20401 * @method
20402 * @name xos#Controller_Network_Detail_DELETE
20403 * @param {string} pk -
20404 *
20405 */
20406 xos.prototype.Controller_Network_Detail_DELETE = function(parameters) {
20407 if (parameters === undefined) {
20408 parameters = {};
20409 }
20410 var deferred = $q.defer();
20411
20412 var domain = this.domain;
20413 var path = '/xos/controllernetworks/{pk}/';
20414
20415 var body;
20416 var queryParameters = {};
20417 var headers = {};
20418 var form = {};
20419
20420 path = path.replace('{pk}', parameters['pk']);
20421
20422 if (parameters['pk'] === undefined) {
20423 deferred.reject(new Error('Missing required path parameter: pk'));
20424 return deferred.promise;
20425 }
20426
20427 if (parameters.$queryParameters) {
20428 Object.keys(parameters.$queryParameters)
20429 .forEach(function(parameterName) {
20430 var parameter = parameters.$queryParameters[parameterName];
20431 queryParameters[parameterName] = parameter;
20432 });
20433 }
20434
20435 var url = domain + path;
20436 var options = {
20437 timeout: parameters.$timeout,
20438 method: 'DELETE',
20439 url: url,
20440 params: queryParameters,
20441 data: body,
20442 headers: headers
20443 };
20444 if (Object.keys(form).length > 0) {
20445 options.data = form;
20446 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20447 options.transformRequest = xos.transformRequest;
20448 }
20449 $http(options)
20450 .success(function(data, status, headers, config) {
20451 deferred.resolve(data);
20452 if (parameters.$cache !== undefined) {
20453 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20454 }
20455 })
20456 .error(function(data, status, headers, config) {
20457 deferred.reject({
20458 status: status,
20459 headers: headers,
20460 config: config,
20461 body: data
20462 });
20463 });
20464
20465 return deferred.promise;
20466 };
20467 /**
20468 *
20469 * @method
20470 * @name xos#Image_Deployments_List_GET
20471 *
20472 */
20473 xos.prototype.Image_Deployments_List_GET = function(parameters) {
20474 if (parameters === undefined) {
20475 parameters = {};
20476 }
20477 var deferred = $q.defer();
20478
20479 var domain = this.domain;
20480 var path = '/xos/imagedeploymentses/';
20481
20482 var body;
20483 var queryParameters = {};
20484 var headers = {};
20485 var form = {};
20486
20487 if (parameters.$queryParameters) {
20488 Object.keys(parameters.$queryParameters)
20489 .forEach(function(parameterName) {
20490 var parameter = parameters.$queryParameters[parameterName];
20491 queryParameters[parameterName] = parameter;
20492 });
20493 }
20494
20495 var url = domain + path;
20496 var cached = parameters.$cache && parameters.$cache.get(url);
20497 if (cached !== undefined && parameters.$refresh !== true) {
20498 deferred.resolve(cached);
20499 return deferred.promise;
20500 }
20501 var options = {
20502 timeout: parameters.$timeout,
20503 method: 'GET',
20504 url: url,
20505 params: queryParameters,
20506 data: body,
20507 headers: headers
20508 };
20509 if (Object.keys(form).length > 0) {
20510 options.data = form;
20511 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20512 options.transformRequest = xos.transformRequest;
20513 }
20514 $http(options)
20515 .success(function(data, status, headers, config) {
20516 deferred.resolve(data);
20517 if (parameters.$cache !== undefined) {
20518 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20519 }
20520 })
20521 .error(function(data, status, headers, config) {
20522 deferred.reject({
20523 status: status,
20524 headers: headers,
20525 config: config,
20526 body: data
20527 });
20528 });
20529
20530 return deferred.promise;
20531 };
20532 /**
20533 *
20534 * @method
20535 * @name xos#Image_Deployments_List_POST
20536 * @param {string} enacted -
20537 * @param {string} policed -
20538 * @param {string} backend_register -
20539 * @param {string} backend_status -
20540 * @param {boolean} deleted -
20541 * @param {boolean} write_protect -
20542 * @param {boolean} lazy_blocked -
20543 * @param {boolean} no_sync -
20544 * @param {string} image -
20545 * @param {string} deployment -
20546 *
20547 */
20548 xos.prototype.Image_Deployments_List_POST = function(parameters) {
20549 if (parameters === undefined) {
20550 parameters = {};
20551 }
20552 var deferred = $q.defer();
20553
20554 var domain = this.domain;
20555 var path = '/xos/imagedeploymentses/';
20556
20557 var body;
20558 var queryParameters = {};
20559 var headers = {};
20560 var form = {};
20561
20562 if (parameters['enacted'] !== undefined) {
20563 form['enacted'] = parameters['enacted'];
20564 }
20565
20566 if (parameters['policed'] !== undefined) {
20567 form['policed'] = parameters['policed'];
20568 }
20569
20570 if (parameters['backend_register'] !== undefined) {
20571 form['backend_register'] = parameters['backend_register'];
20572 }
20573
20574 if (parameters['backend_status'] !== undefined) {
20575 form['backend_status'] = parameters['backend_status'];
20576 }
20577
20578 if (parameters['backend_status'] === undefined) {
20579 deferred.reject(new Error('Missing required form parameter: backend_status'));
20580 return deferred.promise;
20581 }
20582
20583 if (parameters['deleted'] !== undefined) {
20584 form['deleted'] = parameters['deleted'];
20585 }
20586
20587 if (parameters['write_protect'] !== undefined) {
20588 form['write_protect'] = parameters['write_protect'];
20589 }
20590
20591 if (parameters['lazy_blocked'] !== undefined) {
20592 form['lazy_blocked'] = parameters['lazy_blocked'];
20593 }
20594
20595 if (parameters['no_sync'] !== undefined) {
20596 form['no_sync'] = parameters['no_sync'];
20597 }
20598
20599 if (parameters['image'] !== undefined) {
20600 form['image'] = parameters['image'];
20601 }
20602
20603 if (parameters['image'] === undefined) {
20604 deferred.reject(new Error('Missing required form parameter: image'));
20605 return deferred.promise;
20606 }
20607
20608 if (parameters['deployment'] !== undefined) {
20609 form['deployment'] = parameters['deployment'];
20610 }
20611
20612 if (parameters['deployment'] === undefined) {
20613 deferred.reject(new Error('Missing required form parameter: deployment'));
20614 return deferred.promise;
20615 }
20616
20617 if (parameters.$queryParameters) {
20618 Object.keys(parameters.$queryParameters)
20619 .forEach(function(parameterName) {
20620 var parameter = parameters.$queryParameters[parameterName];
20621 queryParameters[parameterName] = parameter;
20622 });
20623 }
20624
20625 var url = domain + path;
20626 var options = {
20627 timeout: parameters.$timeout,
20628 method: 'POST',
20629 url: url,
20630 params: queryParameters,
20631 data: body,
20632 headers: headers
20633 };
20634 if (Object.keys(form).length > 0) {
20635 options.data = form;
20636 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20637 options.transformRequest = xos.transformRequest;
20638 }
20639 $http(options)
20640 .success(function(data, status, headers, config) {
20641 deferred.resolve(data);
20642 if (parameters.$cache !== undefined) {
20643 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20644 }
20645 })
20646 .error(function(data, status, headers, config) {
20647 deferred.reject({
20648 status: status,
20649 headers: headers,
20650 config: config,
20651 body: data
20652 });
20653 });
20654
20655 return deferred.promise;
20656 };
20657 /**
20658 *
20659 * @method
20660 * @name xos#Image_Deployments_Detail_GET
20661 * @param {string} pk -
20662 *
20663 */
20664 xos.prototype.Image_Deployments_Detail_GET = function(parameters) {
20665 if (parameters === undefined) {
20666 parameters = {};
20667 }
20668 var deferred = $q.defer();
20669
20670 var domain = this.domain;
20671 var path = '/xos/imagedeploymentses/{pk}/';
20672
20673 var body;
20674 var queryParameters = {};
20675 var headers = {};
20676 var form = {};
20677
20678 path = path.replace('{pk}', parameters['pk']);
20679
20680 if (parameters['pk'] === undefined) {
20681 deferred.reject(new Error('Missing required path parameter: pk'));
20682 return deferred.promise;
20683 }
20684
20685 if (parameters.$queryParameters) {
20686 Object.keys(parameters.$queryParameters)
20687 .forEach(function(parameterName) {
20688 var parameter = parameters.$queryParameters[parameterName];
20689 queryParameters[parameterName] = parameter;
20690 });
20691 }
20692
20693 var url = domain + path;
20694 var cached = parameters.$cache && parameters.$cache.get(url);
20695 if (cached !== undefined && parameters.$refresh !== true) {
20696 deferred.resolve(cached);
20697 return deferred.promise;
20698 }
20699 var options = {
20700 timeout: parameters.$timeout,
20701 method: 'GET',
20702 url: url,
20703 params: queryParameters,
20704 data: body,
20705 headers: headers
20706 };
20707 if (Object.keys(form).length > 0) {
20708 options.data = form;
20709 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20710 options.transformRequest = xos.transformRequest;
20711 }
20712 $http(options)
20713 .success(function(data, status, headers, config) {
20714 deferred.resolve(data);
20715 if (parameters.$cache !== undefined) {
20716 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20717 }
20718 })
20719 .error(function(data, status, headers, config) {
20720 deferred.reject({
20721 status: status,
20722 headers: headers,
20723 config: config,
20724 body: data
20725 });
20726 });
20727
20728 return deferred.promise;
20729 };
20730 /**
20731 *
20732 * @method
20733 * @name xos#Image_Deployments_Detail_PUT
20734 * @param {string} pk -
20735 * @param {string} enacted -
20736 * @param {string} policed -
20737 * @param {string} backend_register -
20738 * @param {string} backend_status -
20739 * @param {boolean} deleted -
20740 * @param {boolean} write_protect -
20741 * @param {boolean} lazy_blocked -
20742 * @param {boolean} no_sync -
20743 * @param {string} image -
20744 * @param {string} deployment -
20745 *
20746 */
20747 xos.prototype.Image_Deployments_Detail_PUT = function(parameters) {
20748 if (parameters === undefined) {
20749 parameters = {};
20750 }
20751 var deferred = $q.defer();
20752
20753 var domain = this.domain;
20754 var path = '/xos/imagedeploymentses/{pk}/';
20755
20756 var body;
20757 var queryParameters = {};
20758 var headers = {};
20759 var form = {};
20760
20761 path = path.replace('{pk}', parameters['pk']);
20762
20763 if (parameters['pk'] === undefined) {
20764 deferred.reject(new Error('Missing required path parameter: pk'));
20765 return deferred.promise;
20766 }
20767
20768 if (parameters['enacted'] !== undefined) {
20769 form['enacted'] = parameters['enacted'];
20770 }
20771
20772 if (parameters['policed'] !== undefined) {
20773 form['policed'] = parameters['policed'];
20774 }
20775
20776 if (parameters['backend_register'] !== undefined) {
20777 form['backend_register'] = parameters['backend_register'];
20778 }
20779
20780 if (parameters['backend_status'] !== undefined) {
20781 form['backend_status'] = parameters['backend_status'];
20782 }
20783
20784 if (parameters['backend_status'] === undefined) {
20785 deferred.reject(new Error('Missing required form parameter: backend_status'));
20786 return deferred.promise;
20787 }
20788
20789 if (parameters['deleted'] !== undefined) {
20790 form['deleted'] = parameters['deleted'];
20791 }
20792
20793 if (parameters['write_protect'] !== undefined) {
20794 form['write_protect'] = parameters['write_protect'];
20795 }
20796
20797 if (parameters['lazy_blocked'] !== undefined) {
20798 form['lazy_blocked'] = parameters['lazy_blocked'];
20799 }
20800
20801 if (parameters['no_sync'] !== undefined) {
20802 form['no_sync'] = parameters['no_sync'];
20803 }
20804
20805 if (parameters['image'] !== undefined) {
20806 form['image'] = parameters['image'];
20807 }
20808
20809 if (parameters['image'] === undefined) {
20810 deferred.reject(new Error('Missing required form parameter: image'));
20811 return deferred.promise;
20812 }
20813
20814 if (parameters['deployment'] !== undefined) {
20815 form['deployment'] = parameters['deployment'];
20816 }
20817
20818 if (parameters['deployment'] === undefined) {
20819 deferred.reject(new Error('Missing required form parameter: deployment'));
20820 return deferred.promise;
20821 }
20822
20823 if (parameters.$queryParameters) {
20824 Object.keys(parameters.$queryParameters)
20825 .forEach(function(parameterName) {
20826 var parameter = parameters.$queryParameters[parameterName];
20827 queryParameters[parameterName] = parameter;
20828 });
20829 }
20830
20831 var url = domain + path;
20832 var options = {
20833 timeout: parameters.$timeout,
20834 method: 'PUT',
20835 url: url,
20836 params: queryParameters,
20837 data: body,
20838 headers: headers
20839 };
20840 if (Object.keys(form).length > 0) {
20841 options.data = form;
20842 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20843 options.transformRequest = xos.transformRequest;
20844 }
20845 $http(options)
20846 .success(function(data, status, headers, config) {
20847 deferred.resolve(data);
20848 if (parameters.$cache !== undefined) {
20849 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20850 }
20851 })
20852 .error(function(data, status, headers, config) {
20853 deferred.reject({
20854 status: status,
20855 headers: headers,
20856 config: config,
20857 body: data
20858 });
20859 });
20860
20861 return deferred.promise;
20862 };
20863 /**
20864 *
20865 * @method
20866 * @name xos#Image_Deployments_Detail_PATCH
20867 * @param {string} pk -
20868 * @param {string} enacted -
20869 * @param {string} policed -
20870 * @param {string} backend_register -
20871 * @param {string} backend_status -
20872 * @param {boolean} deleted -
20873 * @param {boolean} write_protect -
20874 * @param {boolean} lazy_blocked -
20875 * @param {boolean} no_sync -
20876 * @param {string} image -
20877 * @param {string} deployment -
20878 *
20879 */
20880 xos.prototype.Image_Deployments_Detail_PATCH = function(parameters) {
20881 if (parameters === undefined) {
20882 parameters = {};
20883 }
20884 var deferred = $q.defer();
20885
20886 var domain = this.domain;
20887 var path = '/xos/imagedeploymentses/{pk}/';
20888
20889 var body;
20890 var queryParameters = {};
20891 var headers = {};
20892 var form = {};
20893
20894 path = path.replace('{pk}', parameters['pk']);
20895
20896 if (parameters['pk'] === undefined) {
20897 deferred.reject(new Error('Missing required path parameter: pk'));
20898 return deferred.promise;
20899 }
20900
20901 if (parameters['enacted'] !== undefined) {
20902 form['enacted'] = parameters['enacted'];
20903 }
20904
20905 if (parameters['policed'] !== undefined) {
20906 form['policed'] = parameters['policed'];
20907 }
20908
20909 if (parameters['backend_register'] !== undefined) {
20910 form['backend_register'] = parameters['backend_register'];
20911 }
20912
20913 if (parameters['backend_status'] !== undefined) {
20914 form['backend_status'] = parameters['backend_status'];
20915 }
20916
20917 if (parameters['deleted'] !== undefined) {
20918 form['deleted'] = parameters['deleted'];
20919 }
20920
20921 if (parameters['write_protect'] !== undefined) {
20922 form['write_protect'] = parameters['write_protect'];
20923 }
20924
20925 if (parameters['lazy_blocked'] !== undefined) {
20926 form['lazy_blocked'] = parameters['lazy_blocked'];
20927 }
20928
20929 if (parameters['no_sync'] !== undefined) {
20930 form['no_sync'] = parameters['no_sync'];
20931 }
20932
20933 if (parameters['image'] !== undefined) {
20934 form['image'] = parameters['image'];
20935 }
20936
20937 if (parameters['deployment'] !== undefined) {
20938 form['deployment'] = parameters['deployment'];
20939 }
20940
20941 if (parameters.$queryParameters) {
20942 Object.keys(parameters.$queryParameters)
20943 .forEach(function(parameterName) {
20944 var parameter = parameters.$queryParameters[parameterName];
20945 queryParameters[parameterName] = parameter;
20946 });
20947 }
20948
20949 var url = domain + path;
20950 var options = {
20951 timeout: parameters.$timeout,
20952 method: 'PATCH',
20953 url: url,
20954 params: queryParameters,
20955 data: body,
20956 headers: headers
20957 };
20958 if (Object.keys(form).length > 0) {
20959 options.data = form;
20960 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
20961 options.transformRequest = xos.transformRequest;
20962 }
20963 $http(options)
20964 .success(function(data, status, headers, config) {
20965 deferred.resolve(data);
20966 if (parameters.$cache !== undefined) {
20967 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
20968 }
20969 })
20970 .error(function(data, status, headers, config) {
20971 deferred.reject({
20972 status: status,
20973 headers: headers,
20974 config: config,
20975 body: data
20976 });
20977 });
20978
20979 return deferred.promise;
20980 };
20981 /**
20982 *
20983 * @method
20984 * @name xos#Image_Deployments_Detail_DELETE
20985 * @param {string} pk -
20986 *
20987 */
20988 xos.prototype.Image_Deployments_Detail_DELETE = function(parameters) {
20989 if (parameters === undefined) {
20990 parameters = {};
20991 }
20992 var deferred = $q.defer();
20993
20994 var domain = this.domain;
20995 var path = '/xos/imagedeploymentses/{pk}/';
20996
20997 var body;
20998 var queryParameters = {};
20999 var headers = {};
21000 var form = {};
21001
21002 path = path.replace('{pk}', parameters['pk']);
21003
21004 if (parameters['pk'] === undefined) {
21005 deferred.reject(new Error('Missing required path parameter: pk'));
21006 return deferred.promise;
21007 }
21008
21009 if (parameters.$queryParameters) {
21010 Object.keys(parameters.$queryParameters)
21011 .forEach(function(parameterName) {
21012 var parameter = parameters.$queryParameters[parameterName];
21013 queryParameters[parameterName] = parameter;
21014 });
21015 }
21016
21017 var url = domain + path;
21018 var options = {
21019 timeout: parameters.$timeout,
21020 method: 'DELETE',
21021 url: url,
21022 params: queryParameters,
21023 data: body,
21024 headers: headers
21025 };
21026 if (Object.keys(form).length > 0) {
21027 options.data = form;
21028 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21029 options.transformRequest = xos.transformRequest;
21030 }
21031 $http(options)
21032 .success(function(data, status, headers, config) {
21033 deferred.resolve(data);
21034 if (parameters.$cache !== undefined) {
21035 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21036 }
21037 })
21038 .error(function(data, status, headers, config) {
21039 deferred.reject({
21040 status: status,
21041 headers: headers,
21042 config: config,
21043 body: data
21044 });
21045 });
21046
21047 return deferred.promise;
21048 };
21049 /**
21050 *
21051 * @method
21052 * @name xos#Controller_User_List_GET
21053 *
21054 */
21055 xos.prototype.Controller_User_List_GET = function(parameters) {
21056 if (parameters === undefined) {
21057 parameters = {};
21058 }
21059 var deferred = $q.defer();
21060
21061 var domain = this.domain;
21062 var path = '/xos/controllerusers/';
21063
21064 var body;
21065 var queryParameters = {};
21066 var headers = {};
21067 var form = {};
21068
21069 if (parameters.$queryParameters) {
21070 Object.keys(parameters.$queryParameters)
21071 .forEach(function(parameterName) {
21072 var parameter = parameters.$queryParameters[parameterName];
21073 queryParameters[parameterName] = parameter;
21074 });
21075 }
21076
21077 var url = domain + path;
21078 var cached = parameters.$cache && parameters.$cache.get(url);
21079 if (cached !== undefined && parameters.$refresh !== true) {
21080 deferred.resolve(cached);
21081 return deferred.promise;
21082 }
21083 var options = {
21084 timeout: parameters.$timeout,
21085 method: 'GET',
21086 url: url,
21087 params: queryParameters,
21088 data: body,
21089 headers: headers
21090 };
21091 if (Object.keys(form).length > 0) {
21092 options.data = form;
21093 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21094 options.transformRequest = xos.transformRequest;
21095 }
21096 $http(options)
21097 .success(function(data, status, headers, config) {
21098 deferred.resolve(data);
21099 if (parameters.$cache !== undefined) {
21100 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21101 }
21102 })
21103 .error(function(data, status, headers, config) {
21104 deferred.reject({
21105 status: status,
21106 headers: headers,
21107 config: config,
21108 body: data
21109 });
21110 });
21111
21112 return deferred.promise;
21113 };
21114 /**
21115 *
21116 * @method
21117 * @name xos#Controller_User_List_POST
21118 * @param {string} enacted -
21119 * @param {string} policed -
21120 * @param {string} backend_register -
21121 * @param {string} backend_status -
21122 * @param {boolean} deleted -
21123 * @param {boolean} write_protect -
21124 * @param {boolean} lazy_blocked -
21125 * @param {boolean} no_sync -
21126 * @param {string} user -
21127 * @param {string} controller -
21128 * @param {string} kuser_id - Keystone user id
21129 *
21130 */
21131 xos.prototype.Controller_User_List_POST = function(parameters) {
21132 if (parameters === undefined) {
21133 parameters = {};
21134 }
21135 var deferred = $q.defer();
21136
21137 var domain = this.domain;
21138 var path = '/xos/controllerusers/';
21139
21140 var body;
21141 var queryParameters = {};
21142 var headers = {};
21143 var form = {};
21144
21145 if (parameters['enacted'] !== undefined) {
21146 form['enacted'] = parameters['enacted'];
21147 }
21148
21149 if (parameters['policed'] !== undefined) {
21150 form['policed'] = parameters['policed'];
21151 }
21152
21153 if (parameters['backend_register'] !== undefined) {
21154 form['backend_register'] = parameters['backend_register'];
21155 }
21156
21157 if (parameters['backend_status'] !== undefined) {
21158 form['backend_status'] = parameters['backend_status'];
21159 }
21160
21161 if (parameters['backend_status'] === undefined) {
21162 deferred.reject(new Error('Missing required form parameter: backend_status'));
21163 return deferred.promise;
21164 }
21165
21166 if (parameters['deleted'] !== undefined) {
21167 form['deleted'] = parameters['deleted'];
21168 }
21169
21170 if (parameters['write_protect'] !== undefined) {
21171 form['write_protect'] = parameters['write_protect'];
21172 }
21173
21174 if (parameters['lazy_blocked'] !== undefined) {
21175 form['lazy_blocked'] = parameters['lazy_blocked'];
21176 }
21177
21178 if (parameters['no_sync'] !== undefined) {
21179 form['no_sync'] = parameters['no_sync'];
21180 }
21181
21182 if (parameters['user'] !== undefined) {
21183 form['user'] = parameters['user'];
21184 }
21185
21186 if (parameters['user'] === undefined) {
21187 deferred.reject(new Error('Missing required form parameter: user'));
21188 return deferred.promise;
21189 }
21190
21191 if (parameters['controller'] !== undefined) {
21192 form['controller'] = parameters['controller'];
21193 }
21194
21195 if (parameters['controller'] === undefined) {
21196 deferred.reject(new Error('Missing required form parameter: controller'));
21197 return deferred.promise;
21198 }
21199
21200 if (parameters['kuser_id'] !== undefined) {
21201 form['kuser_id'] = parameters['kuser_id'];
21202 }
21203
21204 if (parameters.$queryParameters) {
21205 Object.keys(parameters.$queryParameters)
21206 .forEach(function(parameterName) {
21207 var parameter = parameters.$queryParameters[parameterName];
21208 queryParameters[parameterName] = parameter;
21209 });
21210 }
21211
21212 var url = domain + path;
21213 var options = {
21214 timeout: parameters.$timeout,
21215 method: 'POST',
21216 url: url,
21217 params: queryParameters,
21218 data: body,
21219 headers: headers
21220 };
21221 if (Object.keys(form).length > 0) {
21222 options.data = form;
21223 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21224 options.transformRequest = xos.transformRequest;
21225 }
21226 $http(options)
21227 .success(function(data, status, headers, config) {
21228 deferred.resolve(data);
21229 if (parameters.$cache !== undefined) {
21230 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21231 }
21232 })
21233 .error(function(data, status, headers, config) {
21234 deferred.reject({
21235 status: status,
21236 headers: headers,
21237 config: config,
21238 body: data
21239 });
21240 });
21241
21242 return deferred.promise;
21243 };
21244 /**
21245 *
21246 * @method
21247 * @name xos#Controller_User_Detail_GET
21248 * @param {string} pk -
21249 *
21250 */
21251 xos.prototype.Controller_User_Detail_GET = function(parameters) {
21252 if (parameters === undefined) {
21253 parameters = {};
21254 }
21255 var deferred = $q.defer();
21256
21257 var domain = this.domain;
21258 var path = '/xos/controllerusers/{pk}/';
21259
21260 var body;
21261 var queryParameters = {};
21262 var headers = {};
21263 var form = {};
21264
21265 path = path.replace('{pk}', parameters['pk']);
21266
21267 if (parameters['pk'] === undefined) {
21268 deferred.reject(new Error('Missing required path parameter: pk'));
21269 return deferred.promise;
21270 }
21271
21272 if (parameters.$queryParameters) {
21273 Object.keys(parameters.$queryParameters)
21274 .forEach(function(parameterName) {
21275 var parameter = parameters.$queryParameters[parameterName];
21276 queryParameters[parameterName] = parameter;
21277 });
21278 }
21279
21280 var url = domain + path;
21281 var cached = parameters.$cache && parameters.$cache.get(url);
21282 if (cached !== undefined && parameters.$refresh !== true) {
21283 deferred.resolve(cached);
21284 return deferred.promise;
21285 }
21286 var options = {
21287 timeout: parameters.$timeout,
21288 method: 'GET',
21289 url: url,
21290 params: queryParameters,
21291 data: body,
21292 headers: headers
21293 };
21294 if (Object.keys(form).length > 0) {
21295 options.data = form;
21296 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21297 options.transformRequest = xos.transformRequest;
21298 }
21299 $http(options)
21300 .success(function(data, status, headers, config) {
21301 deferred.resolve(data);
21302 if (parameters.$cache !== undefined) {
21303 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21304 }
21305 })
21306 .error(function(data, status, headers, config) {
21307 deferred.reject({
21308 status: status,
21309 headers: headers,
21310 config: config,
21311 body: data
21312 });
21313 });
21314
21315 return deferred.promise;
21316 };
21317 /**
21318 *
21319 * @method
21320 * @name xos#Controller_User_Detail_PUT
21321 * @param {string} pk -
21322 * @param {string} enacted -
21323 * @param {string} policed -
21324 * @param {string} backend_register -
21325 * @param {string} backend_status -
21326 * @param {boolean} deleted -
21327 * @param {boolean} write_protect -
21328 * @param {boolean} lazy_blocked -
21329 * @param {boolean} no_sync -
21330 * @param {string} user -
21331 * @param {string} controller -
21332 * @param {string} kuser_id - Keystone user id
21333 *
21334 */
21335 xos.prototype.Controller_User_Detail_PUT = function(parameters) {
21336 if (parameters === undefined) {
21337 parameters = {};
21338 }
21339 var deferred = $q.defer();
21340
21341 var domain = this.domain;
21342 var path = '/xos/controllerusers/{pk}/';
21343
21344 var body;
21345 var queryParameters = {};
21346 var headers = {};
21347 var form = {};
21348
21349 path = path.replace('{pk}', parameters['pk']);
21350
21351 if (parameters['pk'] === undefined) {
21352 deferred.reject(new Error('Missing required path parameter: pk'));
21353 return deferred.promise;
21354 }
21355
21356 if (parameters['enacted'] !== undefined) {
21357 form['enacted'] = parameters['enacted'];
21358 }
21359
21360 if (parameters['policed'] !== undefined) {
21361 form['policed'] = parameters['policed'];
21362 }
21363
21364 if (parameters['backend_register'] !== undefined) {
21365 form['backend_register'] = parameters['backend_register'];
21366 }
21367
21368 if (parameters['backend_status'] !== undefined) {
21369 form['backend_status'] = parameters['backend_status'];
21370 }
21371
21372 if (parameters['backend_status'] === undefined) {
21373 deferred.reject(new Error('Missing required form parameter: backend_status'));
21374 return deferred.promise;
21375 }
21376
21377 if (parameters['deleted'] !== undefined) {
21378 form['deleted'] = parameters['deleted'];
21379 }
21380
21381 if (parameters['write_protect'] !== undefined) {
21382 form['write_protect'] = parameters['write_protect'];
21383 }
21384
21385 if (parameters['lazy_blocked'] !== undefined) {
21386 form['lazy_blocked'] = parameters['lazy_blocked'];
21387 }
21388
21389 if (parameters['no_sync'] !== undefined) {
21390 form['no_sync'] = parameters['no_sync'];
21391 }
21392
21393 if (parameters['user'] !== undefined) {
21394 form['user'] = parameters['user'];
21395 }
21396
21397 if (parameters['user'] === undefined) {
21398 deferred.reject(new Error('Missing required form parameter: user'));
21399 return deferred.promise;
21400 }
21401
21402 if (parameters['controller'] !== undefined) {
21403 form['controller'] = parameters['controller'];
21404 }
21405
21406 if (parameters['controller'] === undefined) {
21407 deferred.reject(new Error('Missing required form parameter: controller'));
21408 return deferred.promise;
21409 }
21410
21411 if (parameters['kuser_id'] !== undefined) {
21412 form['kuser_id'] = parameters['kuser_id'];
21413 }
21414
21415 if (parameters.$queryParameters) {
21416 Object.keys(parameters.$queryParameters)
21417 .forEach(function(parameterName) {
21418 var parameter = parameters.$queryParameters[parameterName];
21419 queryParameters[parameterName] = parameter;
21420 });
21421 }
21422
21423 var url = domain + path;
21424 var options = {
21425 timeout: parameters.$timeout,
21426 method: 'PUT',
21427 url: url,
21428 params: queryParameters,
21429 data: body,
21430 headers: headers
21431 };
21432 if (Object.keys(form).length > 0) {
21433 options.data = form;
21434 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21435 options.transformRequest = xos.transformRequest;
21436 }
21437 $http(options)
21438 .success(function(data, status, headers, config) {
21439 deferred.resolve(data);
21440 if (parameters.$cache !== undefined) {
21441 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21442 }
21443 })
21444 .error(function(data, status, headers, config) {
21445 deferred.reject({
21446 status: status,
21447 headers: headers,
21448 config: config,
21449 body: data
21450 });
21451 });
21452
21453 return deferred.promise;
21454 };
21455 /**
21456 *
21457 * @method
21458 * @name xos#Controller_User_Detail_PATCH
21459 * @param {string} pk -
21460 * @param {string} enacted -
21461 * @param {string} policed -
21462 * @param {string} backend_register -
21463 * @param {string} backend_status -
21464 * @param {boolean} deleted -
21465 * @param {boolean} write_protect -
21466 * @param {boolean} lazy_blocked -
21467 * @param {boolean} no_sync -
21468 * @param {string} user -
21469 * @param {string} controller -
21470 * @param {string} kuser_id - Keystone user id
21471 *
21472 */
21473 xos.prototype.Controller_User_Detail_PATCH = function(parameters) {
21474 if (parameters === undefined) {
21475 parameters = {};
21476 }
21477 var deferred = $q.defer();
21478
21479 var domain = this.domain;
21480 var path = '/xos/controllerusers/{pk}/';
21481
21482 var body;
21483 var queryParameters = {};
21484 var headers = {};
21485 var form = {};
21486
21487 path = path.replace('{pk}', parameters['pk']);
21488
21489 if (parameters['pk'] === undefined) {
21490 deferred.reject(new Error('Missing required path parameter: pk'));
21491 return deferred.promise;
21492 }
21493
21494 if (parameters['enacted'] !== undefined) {
21495 form['enacted'] = parameters['enacted'];
21496 }
21497
21498 if (parameters['policed'] !== undefined) {
21499 form['policed'] = parameters['policed'];
21500 }
21501
21502 if (parameters['backend_register'] !== undefined) {
21503 form['backend_register'] = parameters['backend_register'];
21504 }
21505
21506 if (parameters['backend_status'] !== undefined) {
21507 form['backend_status'] = parameters['backend_status'];
21508 }
21509
21510 if (parameters['deleted'] !== undefined) {
21511 form['deleted'] = parameters['deleted'];
21512 }
21513
21514 if (parameters['write_protect'] !== undefined) {
21515 form['write_protect'] = parameters['write_protect'];
21516 }
21517
21518 if (parameters['lazy_blocked'] !== undefined) {
21519 form['lazy_blocked'] = parameters['lazy_blocked'];
21520 }
21521
21522 if (parameters['no_sync'] !== undefined) {
21523 form['no_sync'] = parameters['no_sync'];
21524 }
21525
21526 if (parameters['user'] !== undefined) {
21527 form['user'] = parameters['user'];
21528 }
21529
21530 if (parameters['controller'] !== undefined) {
21531 form['controller'] = parameters['controller'];
21532 }
21533
21534 if (parameters['kuser_id'] !== undefined) {
21535 form['kuser_id'] = parameters['kuser_id'];
21536 }
21537
21538 if (parameters.$queryParameters) {
21539 Object.keys(parameters.$queryParameters)
21540 .forEach(function(parameterName) {
21541 var parameter = parameters.$queryParameters[parameterName];
21542 queryParameters[parameterName] = parameter;
21543 });
21544 }
21545
21546 var url = domain + path;
21547 var options = {
21548 timeout: parameters.$timeout,
21549 method: 'PATCH',
21550 url: url,
21551 params: queryParameters,
21552 data: body,
21553 headers: headers
21554 };
21555 if (Object.keys(form).length > 0) {
21556 options.data = form;
21557 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21558 options.transformRequest = xos.transformRequest;
21559 }
21560 $http(options)
21561 .success(function(data, status, headers, config) {
21562 deferred.resolve(data);
21563 if (parameters.$cache !== undefined) {
21564 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21565 }
21566 })
21567 .error(function(data, status, headers, config) {
21568 deferred.reject({
21569 status: status,
21570 headers: headers,
21571 config: config,
21572 body: data
21573 });
21574 });
21575
21576 return deferred.promise;
21577 };
21578 /**
21579 *
21580 * @method
21581 * @name xos#Controller_User_Detail_DELETE
21582 * @param {string} pk -
21583 *
21584 */
21585 xos.prototype.Controller_User_Detail_DELETE = function(parameters) {
21586 if (parameters === undefined) {
21587 parameters = {};
21588 }
21589 var deferred = $q.defer();
21590
21591 var domain = this.domain;
21592 var path = '/xos/controllerusers/{pk}/';
21593
21594 var body;
21595 var queryParameters = {};
21596 var headers = {};
21597 var form = {};
21598
21599 path = path.replace('{pk}', parameters['pk']);
21600
21601 if (parameters['pk'] === undefined) {
21602 deferred.reject(new Error('Missing required path parameter: pk'));
21603 return deferred.promise;
21604 }
21605
21606 if (parameters.$queryParameters) {
21607 Object.keys(parameters.$queryParameters)
21608 .forEach(function(parameterName) {
21609 var parameter = parameters.$queryParameters[parameterName];
21610 queryParameters[parameterName] = parameter;
21611 });
21612 }
21613
21614 var url = domain + path;
21615 var options = {
21616 timeout: parameters.$timeout,
21617 method: 'DELETE',
21618 url: url,
21619 params: queryParameters,
21620 data: body,
21621 headers: headers
21622 };
21623 if (Object.keys(form).length > 0) {
21624 options.data = form;
21625 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21626 options.transformRequest = xos.transformRequest;
21627 }
21628 $http(options)
21629 .success(function(data, status, headers, config) {
21630 deferred.resolve(data);
21631 if (parameters.$cache !== undefined) {
21632 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21633 }
21634 })
21635 .error(function(data, status, headers, config) {
21636 deferred.reject({
21637 status: status,
21638 headers: headers,
21639 config: config,
21640 body: data
21641 });
21642 });
21643
21644 return deferred.promise;
21645 };
21646 /**
21647 *
21648 * @method
21649 * @name xos#Reserved_Resource_List_GET
21650 *
21651 */
21652 xos.prototype.Reserved_Resource_List_GET = function(parameters) {
21653 if (parameters === undefined) {
21654 parameters = {};
21655 }
21656 var deferred = $q.defer();
21657
21658 var domain = this.domain;
21659 var path = '/xos/reservedresources/';
21660
21661 var body;
21662 var queryParameters = {};
21663 var headers = {};
21664 var form = {};
21665
21666 if (parameters.$queryParameters) {
21667 Object.keys(parameters.$queryParameters)
21668 .forEach(function(parameterName) {
21669 var parameter = parameters.$queryParameters[parameterName];
21670 queryParameters[parameterName] = parameter;
21671 });
21672 }
21673
21674 var url = domain + path;
21675 var cached = parameters.$cache && parameters.$cache.get(url);
21676 if (cached !== undefined && parameters.$refresh !== true) {
21677 deferred.resolve(cached);
21678 return deferred.promise;
21679 }
21680 var options = {
21681 timeout: parameters.$timeout,
21682 method: 'GET',
21683 url: url,
21684 params: queryParameters,
21685 data: body,
21686 headers: headers
21687 };
21688 if (Object.keys(form).length > 0) {
21689 options.data = form;
21690 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21691 options.transformRequest = xos.transformRequest;
21692 }
21693 $http(options)
21694 .success(function(data, status, headers, config) {
21695 deferred.resolve(data);
21696 if (parameters.$cache !== undefined) {
21697 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21698 }
21699 })
21700 .error(function(data, status, headers, config) {
21701 deferred.reject({
21702 status: status,
21703 headers: headers,
21704 config: config,
21705 body: data
21706 });
21707 });
21708
21709 return deferred.promise;
21710 };
21711 /**
21712 *
21713 * @method
21714 * @name xos#Reserved_Resource_List_POST
21715 * @param {string} enacted -
21716 * @param {string} policed -
21717 * @param {string} backend_register -
21718 * @param {string} backend_status -
21719 * @param {boolean} deleted -
21720 * @param {boolean} write_protect -
21721 * @param {boolean} lazy_blocked -
21722 * @param {boolean} no_sync -
21723 * @param {string} instance -
21724 * @param {string} resource -
21725 * @param {integer} quantity -
21726 * @param {string} reservationSet -
21727 *
21728 */
21729 xos.prototype.Reserved_Resource_List_POST = function(parameters) {
21730 if (parameters === undefined) {
21731 parameters = {};
21732 }
21733 var deferred = $q.defer();
21734
21735 var domain = this.domain;
21736 var path = '/xos/reservedresources/';
21737
21738 var body;
21739 var queryParameters = {};
21740 var headers = {};
21741 var form = {};
21742
21743 if (parameters['enacted'] !== undefined) {
21744 form['enacted'] = parameters['enacted'];
21745 }
21746
21747 if (parameters['policed'] !== undefined) {
21748 form['policed'] = parameters['policed'];
21749 }
21750
21751 if (parameters['backend_register'] !== undefined) {
21752 form['backend_register'] = parameters['backend_register'];
21753 }
21754
21755 if (parameters['backend_status'] !== undefined) {
21756 form['backend_status'] = parameters['backend_status'];
21757 }
21758
21759 if (parameters['backend_status'] === undefined) {
21760 deferred.reject(new Error('Missing required form parameter: backend_status'));
21761 return deferred.promise;
21762 }
21763
21764 if (parameters['deleted'] !== undefined) {
21765 form['deleted'] = parameters['deleted'];
21766 }
21767
21768 if (parameters['write_protect'] !== undefined) {
21769 form['write_protect'] = parameters['write_protect'];
21770 }
21771
21772 if (parameters['lazy_blocked'] !== undefined) {
21773 form['lazy_blocked'] = parameters['lazy_blocked'];
21774 }
21775
21776 if (parameters['no_sync'] !== undefined) {
21777 form['no_sync'] = parameters['no_sync'];
21778 }
21779
21780 if (parameters['instance'] !== undefined) {
21781 form['instance'] = parameters['instance'];
21782 }
21783
21784 if (parameters['instance'] === undefined) {
21785 deferred.reject(new Error('Missing required form parameter: instance'));
21786 return deferred.promise;
21787 }
21788
21789 if (parameters['resource'] !== undefined) {
21790 form['resource'] = parameters['resource'];
21791 }
21792
21793 if (parameters['resource'] === undefined) {
21794 deferred.reject(new Error('Missing required form parameter: resource'));
21795 return deferred.promise;
21796 }
21797
21798 if (parameters['quantity'] !== undefined) {
21799 form['quantity'] = parameters['quantity'];
21800 }
21801
21802 if (parameters['quantity'] === undefined) {
21803 deferred.reject(new Error('Missing required form parameter: quantity'));
21804 return deferred.promise;
21805 }
21806
21807 if (parameters['reservationSet'] !== undefined) {
21808 form['reservationSet'] = parameters['reservationSet'];
21809 }
21810
21811 if (parameters['reservationSet'] === undefined) {
21812 deferred.reject(new Error('Missing required form parameter: reservationSet'));
21813 return deferred.promise;
21814 }
21815
21816 if (parameters.$queryParameters) {
21817 Object.keys(parameters.$queryParameters)
21818 .forEach(function(parameterName) {
21819 var parameter = parameters.$queryParameters[parameterName];
21820 queryParameters[parameterName] = parameter;
21821 });
21822 }
21823
21824 var url = domain + path;
21825 var options = {
21826 timeout: parameters.$timeout,
21827 method: 'POST',
21828 url: url,
21829 params: queryParameters,
21830 data: body,
21831 headers: headers
21832 };
21833 if (Object.keys(form).length > 0) {
21834 options.data = form;
21835 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21836 options.transformRequest = xos.transformRequest;
21837 }
21838 $http(options)
21839 .success(function(data, status, headers, config) {
21840 deferred.resolve(data);
21841 if (parameters.$cache !== undefined) {
21842 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21843 }
21844 })
21845 .error(function(data, status, headers, config) {
21846 deferred.reject({
21847 status: status,
21848 headers: headers,
21849 config: config,
21850 body: data
21851 });
21852 });
21853
21854 return deferred.promise;
21855 };
21856 /**
21857 *
21858 * @method
21859 * @name xos#Reserved_Resource_Detail_GET
21860 * @param {string} pk -
21861 *
21862 */
21863 xos.prototype.Reserved_Resource_Detail_GET = function(parameters) {
21864 if (parameters === undefined) {
21865 parameters = {};
21866 }
21867 var deferred = $q.defer();
21868
21869 var domain = this.domain;
21870 var path = '/xos/reservedresources/{pk}/';
21871
21872 var body;
21873 var queryParameters = {};
21874 var headers = {};
21875 var form = {};
21876
21877 path = path.replace('{pk}', parameters['pk']);
21878
21879 if (parameters['pk'] === undefined) {
21880 deferred.reject(new Error('Missing required path parameter: pk'));
21881 return deferred.promise;
21882 }
21883
21884 if (parameters.$queryParameters) {
21885 Object.keys(parameters.$queryParameters)
21886 .forEach(function(parameterName) {
21887 var parameter = parameters.$queryParameters[parameterName];
21888 queryParameters[parameterName] = parameter;
21889 });
21890 }
21891
21892 var url = domain + path;
21893 var cached = parameters.$cache && parameters.$cache.get(url);
21894 if (cached !== undefined && parameters.$refresh !== true) {
21895 deferred.resolve(cached);
21896 return deferred.promise;
21897 }
21898 var options = {
21899 timeout: parameters.$timeout,
21900 method: 'GET',
21901 url: url,
21902 params: queryParameters,
21903 data: body,
21904 headers: headers
21905 };
21906 if (Object.keys(form).length > 0) {
21907 options.data = form;
21908 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
21909 options.transformRequest = xos.transformRequest;
21910 }
21911 $http(options)
21912 .success(function(data, status, headers, config) {
21913 deferred.resolve(data);
21914 if (parameters.$cache !== undefined) {
21915 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
21916 }
21917 })
21918 .error(function(data, status, headers, config) {
21919 deferred.reject({
21920 status: status,
21921 headers: headers,
21922 config: config,
21923 body: data
21924 });
21925 });
21926
21927 return deferred.promise;
21928 };
21929 /**
21930 *
21931 * @method
21932 * @name xos#Reserved_Resource_Detail_PUT
21933 * @param {string} pk -
21934 * @param {string} enacted -
21935 * @param {string} policed -
21936 * @param {string} backend_register -
21937 * @param {string} backend_status -
21938 * @param {boolean} deleted -
21939 * @param {boolean} write_protect -
21940 * @param {boolean} lazy_blocked -
21941 * @param {boolean} no_sync -
21942 * @param {string} instance -
21943 * @param {string} resource -
21944 * @param {integer} quantity -
21945 * @param {string} reservationSet -
21946 *
21947 */
21948 xos.prototype.Reserved_Resource_Detail_PUT = function(parameters) {
21949 if (parameters === undefined) {
21950 parameters = {};
21951 }
21952 var deferred = $q.defer();
21953
21954 var domain = this.domain;
21955 var path = '/xos/reservedresources/{pk}/';
21956
21957 var body;
21958 var queryParameters = {};
21959 var headers = {};
21960 var form = {};
21961
21962 path = path.replace('{pk}', parameters['pk']);
21963
21964 if (parameters['pk'] === undefined) {
21965 deferred.reject(new Error('Missing required path parameter: pk'));
21966 return deferred.promise;
21967 }
21968
21969 if (parameters['enacted'] !== undefined) {
21970 form['enacted'] = parameters['enacted'];
21971 }
21972
21973 if (parameters['policed'] !== undefined) {
21974 form['policed'] = parameters['policed'];
21975 }
21976
21977 if (parameters['backend_register'] !== undefined) {
21978 form['backend_register'] = parameters['backend_register'];
21979 }
21980
21981 if (parameters['backend_status'] !== undefined) {
21982 form['backend_status'] = parameters['backend_status'];
21983 }
21984
21985 if (parameters['backend_status'] === undefined) {
21986 deferred.reject(new Error('Missing required form parameter: backend_status'));
21987 return deferred.promise;
21988 }
21989
21990 if (parameters['deleted'] !== undefined) {
21991 form['deleted'] = parameters['deleted'];
21992 }
21993
21994 if (parameters['write_protect'] !== undefined) {
21995 form['write_protect'] = parameters['write_protect'];
21996 }
21997
21998 if (parameters['lazy_blocked'] !== undefined) {
21999 form['lazy_blocked'] = parameters['lazy_blocked'];
22000 }
22001
22002 if (parameters['no_sync'] !== undefined) {
22003 form['no_sync'] = parameters['no_sync'];
22004 }
22005
22006 if (parameters['instance'] !== undefined) {
22007 form['instance'] = parameters['instance'];
22008 }
22009
22010 if (parameters['instance'] === undefined) {
22011 deferred.reject(new Error('Missing required form parameter: instance'));
22012 return deferred.promise;
22013 }
22014
22015 if (parameters['resource'] !== undefined) {
22016 form['resource'] = parameters['resource'];
22017 }
22018
22019 if (parameters['resource'] === undefined) {
22020 deferred.reject(new Error('Missing required form parameter: resource'));
22021 return deferred.promise;
22022 }
22023
22024 if (parameters['quantity'] !== undefined) {
22025 form['quantity'] = parameters['quantity'];
22026 }
22027
22028 if (parameters['quantity'] === undefined) {
22029 deferred.reject(new Error('Missing required form parameter: quantity'));
22030 return deferred.promise;
22031 }
22032
22033 if (parameters['reservationSet'] !== undefined) {
22034 form['reservationSet'] = parameters['reservationSet'];
22035 }
22036
22037 if (parameters['reservationSet'] === undefined) {
22038 deferred.reject(new Error('Missing required form parameter: reservationSet'));
22039 return deferred.promise;
22040 }
22041
22042 if (parameters.$queryParameters) {
22043 Object.keys(parameters.$queryParameters)
22044 .forEach(function(parameterName) {
22045 var parameter = parameters.$queryParameters[parameterName];
22046 queryParameters[parameterName] = parameter;
22047 });
22048 }
22049
22050 var url = domain + path;
22051 var options = {
22052 timeout: parameters.$timeout,
22053 method: 'PUT',
22054 url: url,
22055 params: queryParameters,
22056 data: body,
22057 headers: headers
22058 };
22059 if (Object.keys(form).length > 0) {
22060 options.data = form;
22061 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22062 options.transformRequest = xos.transformRequest;
22063 }
22064 $http(options)
22065 .success(function(data, status, headers, config) {
22066 deferred.resolve(data);
22067 if (parameters.$cache !== undefined) {
22068 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22069 }
22070 })
22071 .error(function(data, status, headers, config) {
22072 deferred.reject({
22073 status: status,
22074 headers: headers,
22075 config: config,
22076 body: data
22077 });
22078 });
22079
22080 return deferred.promise;
22081 };
22082 /**
22083 *
22084 * @method
22085 * @name xos#Reserved_Resource_Detail_PATCH
22086 * @param {string} pk -
22087 * @param {string} enacted -
22088 * @param {string} policed -
22089 * @param {string} backend_register -
22090 * @param {string} backend_status -
22091 * @param {boolean} deleted -
22092 * @param {boolean} write_protect -
22093 * @param {boolean} lazy_blocked -
22094 * @param {boolean} no_sync -
22095 * @param {string} instance -
22096 * @param {string} resource -
22097 * @param {integer} quantity -
22098 * @param {string} reservationSet -
22099 *
22100 */
22101 xos.prototype.Reserved_Resource_Detail_PATCH = function(parameters) {
22102 if (parameters === undefined) {
22103 parameters = {};
22104 }
22105 var deferred = $q.defer();
22106
22107 var domain = this.domain;
22108 var path = '/xos/reservedresources/{pk}/';
22109
22110 var body;
22111 var queryParameters = {};
22112 var headers = {};
22113 var form = {};
22114
22115 path = path.replace('{pk}', parameters['pk']);
22116
22117 if (parameters['pk'] === undefined) {
22118 deferred.reject(new Error('Missing required path parameter: pk'));
22119 return deferred.promise;
22120 }
22121
22122 if (parameters['enacted'] !== undefined) {
22123 form['enacted'] = parameters['enacted'];
22124 }
22125
22126 if (parameters['policed'] !== undefined) {
22127 form['policed'] = parameters['policed'];
22128 }
22129
22130 if (parameters['backend_register'] !== undefined) {
22131 form['backend_register'] = parameters['backend_register'];
22132 }
22133
22134 if (parameters['backend_status'] !== undefined) {
22135 form['backend_status'] = parameters['backend_status'];
22136 }
22137
22138 if (parameters['deleted'] !== undefined) {
22139 form['deleted'] = parameters['deleted'];
22140 }
22141
22142 if (parameters['write_protect'] !== undefined) {
22143 form['write_protect'] = parameters['write_protect'];
22144 }
22145
22146 if (parameters['lazy_blocked'] !== undefined) {
22147 form['lazy_blocked'] = parameters['lazy_blocked'];
22148 }
22149
22150 if (parameters['no_sync'] !== undefined) {
22151 form['no_sync'] = parameters['no_sync'];
22152 }
22153
22154 if (parameters['instance'] !== undefined) {
22155 form['instance'] = parameters['instance'];
22156 }
22157
22158 if (parameters['resource'] !== undefined) {
22159 form['resource'] = parameters['resource'];
22160 }
22161
22162 if (parameters['quantity'] !== undefined) {
22163 form['quantity'] = parameters['quantity'];
22164 }
22165
22166 if (parameters['reservationSet'] !== undefined) {
22167 form['reservationSet'] = parameters['reservationSet'];
22168 }
22169
22170 if (parameters.$queryParameters) {
22171 Object.keys(parameters.$queryParameters)
22172 .forEach(function(parameterName) {
22173 var parameter = parameters.$queryParameters[parameterName];
22174 queryParameters[parameterName] = parameter;
22175 });
22176 }
22177
22178 var url = domain + path;
22179 var options = {
22180 timeout: parameters.$timeout,
22181 method: 'PATCH',
22182 url: url,
22183 params: queryParameters,
22184 data: body,
22185 headers: headers
22186 };
22187 if (Object.keys(form).length > 0) {
22188 options.data = form;
22189 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22190 options.transformRequest = xos.transformRequest;
22191 }
22192 $http(options)
22193 .success(function(data, status, headers, config) {
22194 deferred.resolve(data);
22195 if (parameters.$cache !== undefined) {
22196 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22197 }
22198 })
22199 .error(function(data, status, headers, config) {
22200 deferred.reject({
22201 status: status,
22202 headers: headers,
22203 config: config,
22204 body: data
22205 });
22206 });
22207
22208 return deferred.promise;
22209 };
22210 /**
22211 *
22212 * @method
22213 * @name xos#Reserved_Resource_Detail_DELETE
22214 * @param {string} pk -
22215 *
22216 */
22217 xos.prototype.Reserved_Resource_Detail_DELETE = function(parameters) {
22218 if (parameters === undefined) {
22219 parameters = {};
22220 }
22221 var deferred = $q.defer();
22222
22223 var domain = this.domain;
22224 var path = '/xos/reservedresources/{pk}/';
22225
22226 var body;
22227 var queryParameters = {};
22228 var headers = {};
22229 var form = {};
22230
22231 path = path.replace('{pk}', parameters['pk']);
22232
22233 if (parameters['pk'] === undefined) {
22234 deferred.reject(new Error('Missing required path parameter: pk'));
22235 return deferred.promise;
22236 }
22237
22238 if (parameters.$queryParameters) {
22239 Object.keys(parameters.$queryParameters)
22240 .forEach(function(parameterName) {
22241 var parameter = parameters.$queryParameters[parameterName];
22242 queryParameters[parameterName] = parameter;
22243 });
22244 }
22245
22246 var url = domain + path;
22247 var options = {
22248 timeout: parameters.$timeout,
22249 method: 'DELETE',
22250 url: url,
22251 params: queryParameters,
22252 data: body,
22253 headers: headers
22254 };
22255 if (Object.keys(form).length > 0) {
22256 options.data = form;
22257 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22258 options.transformRequest = xos.transformRequest;
22259 }
22260 $http(options)
22261 .success(function(data, status, headers, config) {
22262 deferred.resolve(data);
22263 if (parameters.$cache !== undefined) {
22264 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22265 }
22266 })
22267 .error(function(data, status, headers, config) {
22268 deferred.reject({
22269 status: status,
22270 headers: headers,
22271 config: config,
22272 body: data
22273 });
22274 });
22275
22276 return deferred.promise;
22277 };
22278 /**
22279 *
22280 * @method
22281 * @name xos#Network_Template_List_GET
22282 *
22283 */
22284 xos.prototype.Network_Template_List_GET = function(parameters) {
22285 if (parameters === undefined) {
22286 parameters = {};
22287 }
22288 var deferred = $q.defer();
22289
22290 var domain = this.domain;
22291 var path = '/xos/networktemplates/';
22292
22293 var body;
22294 var queryParameters = {};
22295 var headers = {};
22296 var form = {};
22297
22298 if (parameters.$queryParameters) {
22299 Object.keys(parameters.$queryParameters)
22300 .forEach(function(parameterName) {
22301 var parameter = parameters.$queryParameters[parameterName];
22302 queryParameters[parameterName] = parameter;
22303 });
22304 }
22305
22306 var url = domain + path;
22307 var cached = parameters.$cache && parameters.$cache.get(url);
22308 if (cached !== undefined && parameters.$refresh !== true) {
22309 deferred.resolve(cached);
22310 return deferred.promise;
22311 }
22312 var options = {
22313 timeout: parameters.$timeout,
22314 method: 'GET',
22315 url: url,
22316 params: queryParameters,
22317 data: body,
22318 headers: headers
22319 };
22320 if (Object.keys(form).length > 0) {
22321 options.data = form;
22322 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22323 options.transformRequest = xos.transformRequest;
22324 }
22325 $http(options)
22326 .success(function(data, status, headers, config) {
22327 deferred.resolve(data);
22328 if (parameters.$cache !== undefined) {
22329 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22330 }
22331 })
22332 .error(function(data, status, headers, config) {
22333 deferred.reject({
22334 status: status,
22335 headers: headers,
22336 config: config,
22337 body: data
22338 });
22339 });
22340
22341 return deferred.promise;
22342 };
22343 /**
22344 *
22345 * @method
22346 * @name xos#Network_Template_List_POST
22347 * @param {string} enacted -
22348 * @param {string} policed -
22349 * @param {string} backend_register -
22350 * @param {string} backend_status -
22351 * @param {boolean} deleted -
22352 * @param {boolean} write_protect -
22353 * @param {boolean} lazy_blocked -
22354 * @param {boolean} no_sync -
22355 * @param {string} name -
22356 * @param {string} description -
22357 * @param {integer} guaranteed_bandwidth -
22358 * @param {choice} visibility -
22359 * @param {choice} translation -
22360 * @param {string} shared_network_name -
22361 * @param {string} shared_network_id - Quantum network
22362 * @param {choice} topology_kind -
22363 * @param {choice} controller_kind -
22364 *
22365 */
22366 xos.prototype.Network_Template_List_POST = function(parameters) {
22367 if (parameters === undefined) {
22368 parameters = {};
22369 }
22370 var deferred = $q.defer();
22371
22372 var domain = this.domain;
22373 var path = '/xos/networktemplates/';
22374
22375 var body;
22376 var queryParameters = {};
22377 var headers = {};
22378 var form = {};
22379
22380 if (parameters['enacted'] !== undefined) {
22381 form['enacted'] = parameters['enacted'];
22382 }
22383
22384 if (parameters['policed'] !== undefined) {
22385 form['policed'] = parameters['policed'];
22386 }
22387
22388 if (parameters['backend_register'] !== undefined) {
22389 form['backend_register'] = parameters['backend_register'];
22390 }
22391
22392 if (parameters['backend_status'] !== undefined) {
22393 form['backend_status'] = parameters['backend_status'];
22394 }
22395
22396 if (parameters['backend_status'] === undefined) {
22397 deferred.reject(new Error('Missing required form parameter: backend_status'));
22398 return deferred.promise;
22399 }
22400
22401 if (parameters['deleted'] !== undefined) {
22402 form['deleted'] = parameters['deleted'];
22403 }
22404
22405 if (parameters['write_protect'] !== undefined) {
22406 form['write_protect'] = parameters['write_protect'];
22407 }
22408
22409 if (parameters['lazy_blocked'] !== undefined) {
22410 form['lazy_blocked'] = parameters['lazy_blocked'];
22411 }
22412
22413 if (parameters['no_sync'] !== undefined) {
22414 form['no_sync'] = parameters['no_sync'];
22415 }
22416
22417 if (parameters['name'] !== undefined) {
22418 form['name'] = parameters['name'];
22419 }
22420
22421 if (parameters['name'] === undefined) {
22422 deferred.reject(new Error('Missing required form parameter: name'));
22423 return deferred.promise;
22424 }
22425
22426 if (parameters['description'] !== undefined) {
22427 form['description'] = parameters['description'];
22428 }
22429
22430 if (parameters['guaranteed_bandwidth'] !== undefined) {
22431 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
22432 }
22433
22434 if (parameters['guaranteed_bandwidth'] === undefined) {
22435 deferred.reject(new Error('Missing required form parameter: guaranteed_bandwidth'));
22436 return deferred.promise;
22437 }
22438
22439 if (parameters['visibility'] !== undefined) {
22440 form['visibility'] = parameters['visibility'];
22441 }
22442
22443 if (parameters['visibility'] === undefined) {
22444 deferred.reject(new Error('Missing required form parameter: visibility'));
22445 return deferred.promise;
22446 }
22447
22448 if (parameters['translation'] !== undefined) {
22449 form['translation'] = parameters['translation'];
22450 }
22451
22452 if (parameters['translation'] === undefined) {
22453 deferred.reject(new Error('Missing required form parameter: translation'));
22454 return deferred.promise;
22455 }
22456
22457 if (parameters['shared_network_name'] !== undefined) {
22458 form['shared_network_name'] = parameters['shared_network_name'];
22459 }
22460
22461 if (parameters['shared_network_id'] !== undefined) {
22462 form['shared_network_id'] = parameters['shared_network_id'];
22463 }
22464
22465 if (parameters['topology_kind'] !== undefined) {
22466 form['topology_kind'] = parameters['topology_kind'];
22467 }
22468
22469 if (parameters['topology_kind'] === undefined) {
22470 deferred.reject(new Error('Missing required form parameter: topology_kind'));
22471 return deferred.promise;
22472 }
22473
22474 if (parameters['controller_kind'] !== undefined) {
22475 form['controller_kind'] = parameters['controller_kind'];
22476 }
22477
22478 if (parameters.$queryParameters) {
22479 Object.keys(parameters.$queryParameters)
22480 .forEach(function(parameterName) {
22481 var parameter = parameters.$queryParameters[parameterName];
22482 queryParameters[parameterName] = parameter;
22483 });
22484 }
22485
22486 var url = domain + path;
22487 var options = {
22488 timeout: parameters.$timeout,
22489 method: 'POST',
22490 url: url,
22491 params: queryParameters,
22492 data: body,
22493 headers: headers
22494 };
22495 if (Object.keys(form).length > 0) {
22496 options.data = form;
22497 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22498 options.transformRequest = xos.transformRequest;
22499 }
22500 $http(options)
22501 .success(function(data, status, headers, config) {
22502 deferred.resolve(data);
22503 if (parameters.$cache !== undefined) {
22504 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22505 }
22506 })
22507 .error(function(data, status, headers, config) {
22508 deferred.reject({
22509 status: status,
22510 headers: headers,
22511 config: config,
22512 body: data
22513 });
22514 });
22515
22516 return deferred.promise;
22517 };
22518 /**
22519 *
22520 * @method
22521 * @name xos#Network_Template_Detail_GET
22522 * @param {string} pk -
22523 *
22524 */
22525 xos.prototype.Network_Template_Detail_GET = function(parameters) {
22526 if (parameters === undefined) {
22527 parameters = {};
22528 }
22529 var deferred = $q.defer();
22530
22531 var domain = this.domain;
22532 var path = '/xos/networktemplates/{pk}/';
22533
22534 var body;
22535 var queryParameters = {};
22536 var headers = {};
22537 var form = {};
22538
22539 path = path.replace('{pk}', parameters['pk']);
22540
22541 if (parameters['pk'] === undefined) {
22542 deferred.reject(new Error('Missing required path parameter: pk'));
22543 return deferred.promise;
22544 }
22545
22546 if (parameters.$queryParameters) {
22547 Object.keys(parameters.$queryParameters)
22548 .forEach(function(parameterName) {
22549 var parameter = parameters.$queryParameters[parameterName];
22550 queryParameters[parameterName] = parameter;
22551 });
22552 }
22553
22554 var url = domain + path;
22555 var cached = parameters.$cache && parameters.$cache.get(url);
22556 if (cached !== undefined && parameters.$refresh !== true) {
22557 deferred.resolve(cached);
22558 return deferred.promise;
22559 }
22560 var options = {
22561 timeout: parameters.$timeout,
22562 method: 'GET',
22563 url: url,
22564 params: queryParameters,
22565 data: body,
22566 headers: headers
22567 };
22568 if (Object.keys(form).length > 0) {
22569 options.data = form;
22570 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22571 options.transformRequest = xos.transformRequest;
22572 }
22573 $http(options)
22574 .success(function(data, status, headers, config) {
22575 deferred.resolve(data);
22576 if (parameters.$cache !== undefined) {
22577 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22578 }
22579 })
22580 .error(function(data, status, headers, config) {
22581 deferred.reject({
22582 status: status,
22583 headers: headers,
22584 config: config,
22585 body: data
22586 });
22587 });
22588
22589 return deferred.promise;
22590 };
22591 /**
22592 *
22593 * @method
22594 * @name xos#Network_Template_Detail_PUT
22595 * @param {string} pk -
22596 * @param {string} enacted -
22597 * @param {string} policed -
22598 * @param {string} backend_register -
22599 * @param {string} backend_status -
22600 * @param {boolean} deleted -
22601 * @param {boolean} write_protect -
22602 * @param {boolean} lazy_blocked -
22603 * @param {boolean} no_sync -
22604 * @param {string} name -
22605 * @param {string} description -
22606 * @param {integer} guaranteed_bandwidth -
22607 * @param {choice} visibility -
22608 * @param {choice} translation -
22609 * @param {string} shared_network_name -
22610 * @param {string} shared_network_id - Quantum network
22611 * @param {choice} topology_kind -
22612 * @param {choice} controller_kind -
22613 *
22614 */
22615 xos.prototype.Network_Template_Detail_PUT = function(parameters) {
22616 if (parameters === undefined) {
22617 parameters = {};
22618 }
22619 var deferred = $q.defer();
22620
22621 var domain = this.domain;
22622 var path = '/xos/networktemplates/{pk}/';
22623
22624 var body;
22625 var queryParameters = {};
22626 var headers = {};
22627 var form = {};
22628
22629 path = path.replace('{pk}', parameters['pk']);
22630
22631 if (parameters['pk'] === undefined) {
22632 deferred.reject(new Error('Missing required path parameter: pk'));
22633 return deferred.promise;
22634 }
22635
22636 if (parameters['enacted'] !== undefined) {
22637 form['enacted'] = parameters['enacted'];
22638 }
22639
22640 if (parameters['policed'] !== undefined) {
22641 form['policed'] = parameters['policed'];
22642 }
22643
22644 if (parameters['backend_register'] !== undefined) {
22645 form['backend_register'] = parameters['backend_register'];
22646 }
22647
22648 if (parameters['backend_status'] !== undefined) {
22649 form['backend_status'] = parameters['backend_status'];
22650 }
22651
22652 if (parameters['backend_status'] === undefined) {
22653 deferred.reject(new Error('Missing required form parameter: backend_status'));
22654 return deferred.promise;
22655 }
22656
22657 if (parameters['deleted'] !== undefined) {
22658 form['deleted'] = parameters['deleted'];
22659 }
22660
22661 if (parameters['write_protect'] !== undefined) {
22662 form['write_protect'] = parameters['write_protect'];
22663 }
22664
22665 if (parameters['lazy_blocked'] !== undefined) {
22666 form['lazy_blocked'] = parameters['lazy_blocked'];
22667 }
22668
22669 if (parameters['no_sync'] !== undefined) {
22670 form['no_sync'] = parameters['no_sync'];
22671 }
22672
22673 if (parameters['name'] !== undefined) {
22674 form['name'] = parameters['name'];
22675 }
22676
22677 if (parameters['name'] === undefined) {
22678 deferred.reject(new Error('Missing required form parameter: name'));
22679 return deferred.promise;
22680 }
22681
22682 if (parameters['description'] !== undefined) {
22683 form['description'] = parameters['description'];
22684 }
22685
22686 if (parameters['guaranteed_bandwidth'] !== undefined) {
22687 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
22688 }
22689
22690 if (parameters['guaranteed_bandwidth'] === undefined) {
22691 deferred.reject(new Error('Missing required form parameter: guaranteed_bandwidth'));
22692 return deferred.promise;
22693 }
22694
22695 if (parameters['visibility'] !== undefined) {
22696 form['visibility'] = parameters['visibility'];
22697 }
22698
22699 if (parameters['visibility'] === undefined) {
22700 deferred.reject(new Error('Missing required form parameter: visibility'));
22701 return deferred.promise;
22702 }
22703
22704 if (parameters['translation'] !== undefined) {
22705 form['translation'] = parameters['translation'];
22706 }
22707
22708 if (parameters['translation'] === undefined) {
22709 deferred.reject(new Error('Missing required form parameter: translation'));
22710 return deferred.promise;
22711 }
22712
22713 if (parameters['shared_network_name'] !== undefined) {
22714 form['shared_network_name'] = parameters['shared_network_name'];
22715 }
22716
22717 if (parameters['shared_network_id'] !== undefined) {
22718 form['shared_network_id'] = parameters['shared_network_id'];
22719 }
22720
22721 if (parameters['topology_kind'] !== undefined) {
22722 form['topology_kind'] = parameters['topology_kind'];
22723 }
22724
22725 if (parameters['topology_kind'] === undefined) {
22726 deferred.reject(new Error('Missing required form parameter: topology_kind'));
22727 return deferred.promise;
22728 }
22729
22730 if (parameters['controller_kind'] !== undefined) {
22731 form['controller_kind'] = parameters['controller_kind'];
22732 }
22733
22734 if (parameters.$queryParameters) {
22735 Object.keys(parameters.$queryParameters)
22736 .forEach(function(parameterName) {
22737 var parameter = parameters.$queryParameters[parameterName];
22738 queryParameters[parameterName] = parameter;
22739 });
22740 }
22741
22742 var url = domain + path;
22743 var options = {
22744 timeout: parameters.$timeout,
22745 method: 'PUT',
22746 url: url,
22747 params: queryParameters,
22748 data: body,
22749 headers: headers
22750 };
22751 if (Object.keys(form).length > 0) {
22752 options.data = form;
22753 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22754 options.transformRequest = xos.transformRequest;
22755 }
22756 $http(options)
22757 .success(function(data, status, headers, config) {
22758 deferred.resolve(data);
22759 if (parameters.$cache !== undefined) {
22760 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22761 }
22762 })
22763 .error(function(data, status, headers, config) {
22764 deferred.reject({
22765 status: status,
22766 headers: headers,
22767 config: config,
22768 body: data
22769 });
22770 });
22771
22772 return deferred.promise;
22773 };
22774 /**
22775 *
22776 * @method
22777 * @name xos#Network_Template_Detail_PATCH
22778 * @param {string} pk -
22779 * @param {string} enacted -
22780 * @param {string} policed -
22781 * @param {string} backend_register -
22782 * @param {string} backend_status -
22783 * @param {boolean} deleted -
22784 * @param {boolean} write_protect -
22785 * @param {boolean} lazy_blocked -
22786 * @param {boolean} no_sync -
22787 * @param {string} name -
22788 * @param {string} description -
22789 * @param {integer} guaranteed_bandwidth -
22790 * @param {choice} visibility -
22791 * @param {choice} translation -
22792 * @param {string} shared_network_name -
22793 * @param {string} shared_network_id - Quantum network
22794 * @param {choice} topology_kind -
22795 * @param {choice} controller_kind -
22796 *
22797 */
22798 xos.prototype.Network_Template_Detail_PATCH = function(parameters) {
22799 if (parameters === undefined) {
22800 parameters = {};
22801 }
22802 var deferred = $q.defer();
22803
22804 var domain = this.domain;
22805 var path = '/xos/networktemplates/{pk}/';
22806
22807 var body;
22808 var queryParameters = {};
22809 var headers = {};
22810 var form = {};
22811
22812 path = path.replace('{pk}', parameters['pk']);
22813
22814 if (parameters['pk'] === undefined) {
22815 deferred.reject(new Error('Missing required path parameter: pk'));
22816 return deferred.promise;
22817 }
22818
22819 if (parameters['enacted'] !== undefined) {
22820 form['enacted'] = parameters['enacted'];
22821 }
22822
22823 if (parameters['policed'] !== undefined) {
22824 form['policed'] = parameters['policed'];
22825 }
22826
22827 if (parameters['backend_register'] !== undefined) {
22828 form['backend_register'] = parameters['backend_register'];
22829 }
22830
22831 if (parameters['backend_status'] !== undefined) {
22832 form['backend_status'] = parameters['backend_status'];
22833 }
22834
22835 if (parameters['deleted'] !== undefined) {
22836 form['deleted'] = parameters['deleted'];
22837 }
22838
22839 if (parameters['write_protect'] !== undefined) {
22840 form['write_protect'] = parameters['write_protect'];
22841 }
22842
22843 if (parameters['lazy_blocked'] !== undefined) {
22844 form['lazy_blocked'] = parameters['lazy_blocked'];
22845 }
22846
22847 if (parameters['no_sync'] !== undefined) {
22848 form['no_sync'] = parameters['no_sync'];
22849 }
22850
22851 if (parameters['name'] !== undefined) {
22852 form['name'] = parameters['name'];
22853 }
22854
22855 if (parameters['description'] !== undefined) {
22856 form['description'] = parameters['description'];
22857 }
22858
22859 if (parameters['guaranteed_bandwidth'] !== undefined) {
22860 form['guaranteed_bandwidth'] = parameters['guaranteed_bandwidth'];
22861 }
22862
22863 if (parameters['visibility'] !== undefined) {
22864 form['visibility'] = parameters['visibility'];
22865 }
22866
22867 if (parameters['translation'] !== undefined) {
22868 form['translation'] = parameters['translation'];
22869 }
22870
22871 if (parameters['shared_network_name'] !== undefined) {
22872 form['shared_network_name'] = parameters['shared_network_name'];
22873 }
22874
22875 if (parameters['shared_network_id'] !== undefined) {
22876 form['shared_network_id'] = parameters['shared_network_id'];
22877 }
22878
22879 if (parameters['topology_kind'] !== undefined) {
22880 form['topology_kind'] = parameters['topology_kind'];
22881 }
22882
22883 if (parameters['controller_kind'] !== undefined) {
22884 form['controller_kind'] = parameters['controller_kind'];
22885 }
22886
22887 if (parameters.$queryParameters) {
22888 Object.keys(parameters.$queryParameters)
22889 .forEach(function(parameterName) {
22890 var parameter = parameters.$queryParameters[parameterName];
22891 queryParameters[parameterName] = parameter;
22892 });
22893 }
22894
22895 var url = domain + path;
22896 var options = {
22897 timeout: parameters.$timeout,
22898 method: 'PATCH',
22899 url: url,
22900 params: queryParameters,
22901 data: body,
22902 headers: headers
22903 };
22904 if (Object.keys(form).length > 0) {
22905 options.data = form;
22906 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22907 options.transformRequest = xos.transformRequest;
22908 }
22909 $http(options)
22910 .success(function(data, status, headers, config) {
22911 deferred.resolve(data);
22912 if (parameters.$cache !== undefined) {
22913 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22914 }
22915 })
22916 .error(function(data, status, headers, config) {
22917 deferred.reject({
22918 status: status,
22919 headers: headers,
22920 config: config,
22921 body: data
22922 });
22923 });
22924
22925 return deferred.promise;
22926 };
22927 /**
22928 *
22929 * @method
22930 * @name xos#Network_Template_Detail_DELETE
22931 * @param {string} pk -
22932 *
22933 */
22934 xos.prototype.Network_Template_Detail_DELETE = function(parameters) {
22935 if (parameters === undefined) {
22936 parameters = {};
22937 }
22938 var deferred = $q.defer();
22939
22940 var domain = this.domain;
22941 var path = '/xos/networktemplates/{pk}/';
22942
22943 var body;
22944 var queryParameters = {};
22945 var headers = {};
22946 var form = {};
22947
22948 path = path.replace('{pk}', parameters['pk']);
22949
22950 if (parameters['pk'] === undefined) {
22951 deferred.reject(new Error('Missing required path parameter: pk'));
22952 return deferred.promise;
22953 }
22954
22955 if (parameters.$queryParameters) {
22956 Object.keys(parameters.$queryParameters)
22957 .forEach(function(parameterName) {
22958 var parameter = parameters.$queryParameters[parameterName];
22959 queryParameters[parameterName] = parameter;
22960 });
22961 }
22962
22963 var url = domain + path;
22964 var options = {
22965 timeout: parameters.$timeout,
22966 method: 'DELETE',
22967 url: url,
22968 params: queryParameters,
22969 data: body,
22970 headers: headers
22971 };
22972 if (Object.keys(form).length > 0) {
22973 options.data = form;
22974 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
22975 options.transformRequest = xos.transformRequest;
22976 }
22977 $http(options)
22978 .success(function(data, status, headers, config) {
22979 deferred.resolve(data);
22980 if (parameters.$cache !== undefined) {
22981 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
22982 }
22983 })
22984 .error(function(data, status, headers, config) {
22985 deferred.reject({
22986 status: status,
22987 headers: headers,
22988 config: config,
22989 body: data
22990 });
22991 });
22992
22993 return deferred.promise;
22994 };
22995 /**
22996 *
22997 * @method
22998 * @name xos#Network_Slice_List_GET
22999 *
23000 */
23001 xos.prototype.Network_Slice_List_GET = function(parameters) {
23002 if (parameters === undefined) {
23003 parameters = {};
23004 }
23005 var deferred = $q.defer();
23006
23007 var domain = this.domain;
23008 var path = '/xos/networkslices/';
23009
23010 var body;
23011 var queryParameters = {};
23012 var headers = {};
23013 var form = {};
23014
23015 if (parameters.$queryParameters) {
23016 Object.keys(parameters.$queryParameters)
23017 .forEach(function(parameterName) {
23018 var parameter = parameters.$queryParameters[parameterName];
23019 queryParameters[parameterName] = parameter;
23020 });
23021 }
23022
23023 var url = domain + path;
23024 var cached = parameters.$cache && parameters.$cache.get(url);
23025 if (cached !== undefined && parameters.$refresh !== true) {
23026 deferred.resolve(cached);
23027 return deferred.promise;
23028 }
23029 var options = {
23030 timeout: parameters.$timeout,
23031 method: 'GET',
23032 url: url,
23033 params: queryParameters,
23034 data: body,
23035 headers: headers
23036 };
23037 if (Object.keys(form).length > 0) {
23038 options.data = form;
23039 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23040 options.transformRequest = xos.transformRequest;
23041 }
23042 $http(options)
23043 .success(function(data, status, headers, config) {
23044 deferred.resolve(data);
23045 if (parameters.$cache !== undefined) {
23046 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23047 }
23048 })
23049 .error(function(data, status, headers, config) {
23050 deferred.reject({
23051 status: status,
23052 headers: headers,
23053 config: config,
23054 body: data
23055 });
23056 });
23057
23058 return deferred.promise;
23059 };
23060 /**
23061 *
23062 * @method
23063 * @name xos#Network_Slice_List_POST
23064 * @param {string} enacted -
23065 * @param {string} policed -
23066 * @param {string} backend_register -
23067 * @param {string} backend_status -
23068 * @param {boolean} deleted -
23069 * @param {boolean} write_protect -
23070 * @param {boolean} lazy_blocked -
23071 * @param {boolean} no_sync -
23072 * @param {string} network -
23073 * @param {string} slice -
23074 *
23075 */
23076 xos.prototype.Network_Slice_List_POST = function(parameters) {
23077 if (parameters === undefined) {
23078 parameters = {};
23079 }
23080 var deferred = $q.defer();
23081
23082 var domain = this.domain;
23083 var path = '/xos/networkslices/';
23084
23085 var body;
23086 var queryParameters = {};
23087 var headers = {};
23088 var form = {};
23089
23090 if (parameters['enacted'] !== undefined) {
23091 form['enacted'] = parameters['enacted'];
23092 }
23093
23094 if (parameters['policed'] !== undefined) {
23095 form['policed'] = parameters['policed'];
23096 }
23097
23098 if (parameters['backend_register'] !== undefined) {
23099 form['backend_register'] = parameters['backend_register'];
23100 }
23101
23102 if (parameters['backend_status'] !== undefined) {
23103 form['backend_status'] = parameters['backend_status'];
23104 }
23105
23106 if (parameters['backend_status'] === undefined) {
23107 deferred.reject(new Error('Missing required form parameter: backend_status'));
23108 return deferred.promise;
23109 }
23110
23111 if (parameters['deleted'] !== undefined) {
23112 form['deleted'] = parameters['deleted'];
23113 }
23114
23115 if (parameters['write_protect'] !== undefined) {
23116 form['write_protect'] = parameters['write_protect'];
23117 }
23118
23119 if (parameters['lazy_blocked'] !== undefined) {
23120 form['lazy_blocked'] = parameters['lazy_blocked'];
23121 }
23122
23123 if (parameters['no_sync'] !== undefined) {
23124 form['no_sync'] = parameters['no_sync'];
23125 }
23126
23127 if (parameters['network'] !== undefined) {
23128 form['network'] = parameters['network'];
23129 }
23130
23131 if (parameters['network'] === undefined) {
23132 deferred.reject(new Error('Missing required form parameter: network'));
23133 return deferred.promise;
23134 }
23135
23136 if (parameters['slice'] !== undefined) {
23137 form['slice'] = parameters['slice'];
23138 }
23139
23140 if (parameters['slice'] === undefined) {
23141 deferred.reject(new Error('Missing required form parameter: slice'));
23142 return deferred.promise;
23143 }
23144
23145 if (parameters.$queryParameters) {
23146 Object.keys(parameters.$queryParameters)
23147 .forEach(function(parameterName) {
23148 var parameter = parameters.$queryParameters[parameterName];
23149 queryParameters[parameterName] = parameter;
23150 });
23151 }
23152
23153 var url = domain + path;
23154 var options = {
23155 timeout: parameters.$timeout,
23156 method: 'POST',
23157 url: url,
23158 params: queryParameters,
23159 data: body,
23160 headers: headers
23161 };
23162 if (Object.keys(form).length > 0) {
23163 options.data = form;
23164 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23165 options.transformRequest = xos.transformRequest;
23166 }
23167 $http(options)
23168 .success(function(data, status, headers, config) {
23169 deferred.resolve(data);
23170 if (parameters.$cache !== undefined) {
23171 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23172 }
23173 })
23174 .error(function(data, status, headers, config) {
23175 deferred.reject({
23176 status: status,
23177 headers: headers,
23178 config: config,
23179 body: data
23180 });
23181 });
23182
23183 return deferred.promise;
23184 };
23185 /**
23186 *
23187 * @method
23188 * @name xos#Network_Slice_Detail_GET
23189 * @param {string} pk -
23190 *
23191 */
23192 xos.prototype.Network_Slice_Detail_GET = function(parameters) {
23193 if (parameters === undefined) {
23194 parameters = {};
23195 }
23196 var deferred = $q.defer();
23197
23198 var domain = this.domain;
23199 var path = '/xos/networkslices/{pk}/';
23200
23201 var body;
23202 var queryParameters = {};
23203 var headers = {};
23204 var form = {};
23205
23206 path = path.replace('{pk}', parameters['pk']);
23207
23208 if (parameters['pk'] === undefined) {
23209 deferred.reject(new Error('Missing required path parameter: pk'));
23210 return deferred.promise;
23211 }
23212
23213 if (parameters.$queryParameters) {
23214 Object.keys(parameters.$queryParameters)
23215 .forEach(function(parameterName) {
23216 var parameter = parameters.$queryParameters[parameterName];
23217 queryParameters[parameterName] = parameter;
23218 });
23219 }
23220
23221 var url = domain + path;
23222 var cached = parameters.$cache && parameters.$cache.get(url);
23223 if (cached !== undefined && parameters.$refresh !== true) {
23224 deferred.resolve(cached);
23225 return deferred.promise;
23226 }
23227 var options = {
23228 timeout: parameters.$timeout,
23229 method: 'GET',
23230 url: url,
23231 params: queryParameters,
23232 data: body,
23233 headers: headers
23234 };
23235 if (Object.keys(form).length > 0) {
23236 options.data = form;
23237 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23238 options.transformRequest = xos.transformRequest;
23239 }
23240 $http(options)
23241 .success(function(data, status, headers, config) {
23242 deferred.resolve(data);
23243 if (parameters.$cache !== undefined) {
23244 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23245 }
23246 })
23247 .error(function(data, status, headers, config) {
23248 deferred.reject({
23249 status: status,
23250 headers: headers,
23251 config: config,
23252 body: data
23253 });
23254 });
23255
23256 return deferred.promise;
23257 };
23258 /**
23259 *
23260 * @method
23261 * @name xos#Network_Slice_Detail_PUT
23262 * @param {string} pk -
23263 * @param {string} enacted -
23264 * @param {string} policed -
23265 * @param {string} backend_register -
23266 * @param {string} backend_status -
23267 * @param {boolean} deleted -
23268 * @param {boolean} write_protect -
23269 * @param {boolean} lazy_blocked -
23270 * @param {boolean} no_sync -
23271 * @param {string} network -
23272 * @param {string} slice -
23273 *
23274 */
23275 xos.prototype.Network_Slice_Detail_PUT = function(parameters) {
23276 if (parameters === undefined) {
23277 parameters = {};
23278 }
23279 var deferred = $q.defer();
23280
23281 var domain = this.domain;
23282 var path = '/xos/networkslices/{pk}/';
23283
23284 var body;
23285 var queryParameters = {};
23286 var headers = {};
23287 var form = {};
23288
23289 path = path.replace('{pk}', parameters['pk']);
23290
23291 if (parameters['pk'] === undefined) {
23292 deferred.reject(new Error('Missing required path parameter: pk'));
23293 return deferred.promise;
23294 }
23295
23296 if (parameters['enacted'] !== undefined) {
23297 form['enacted'] = parameters['enacted'];
23298 }
23299
23300 if (parameters['policed'] !== undefined) {
23301 form['policed'] = parameters['policed'];
23302 }
23303
23304 if (parameters['backend_register'] !== undefined) {
23305 form['backend_register'] = parameters['backend_register'];
23306 }
23307
23308 if (parameters['backend_status'] !== undefined) {
23309 form['backend_status'] = parameters['backend_status'];
23310 }
23311
23312 if (parameters['backend_status'] === undefined) {
23313 deferred.reject(new Error('Missing required form parameter: backend_status'));
23314 return deferred.promise;
23315 }
23316
23317 if (parameters['deleted'] !== undefined) {
23318 form['deleted'] = parameters['deleted'];
23319 }
23320
23321 if (parameters['write_protect'] !== undefined) {
23322 form['write_protect'] = parameters['write_protect'];
23323 }
23324
23325 if (parameters['lazy_blocked'] !== undefined) {
23326 form['lazy_blocked'] = parameters['lazy_blocked'];
23327 }
23328
23329 if (parameters['no_sync'] !== undefined) {
23330 form['no_sync'] = parameters['no_sync'];
23331 }
23332
23333 if (parameters['network'] !== undefined) {
23334 form['network'] = parameters['network'];
23335 }
23336
23337 if (parameters['network'] === undefined) {
23338 deferred.reject(new Error('Missing required form parameter: network'));
23339 return deferred.promise;
23340 }
23341
23342 if (parameters['slice'] !== undefined) {
23343 form['slice'] = parameters['slice'];
23344 }
23345
23346 if (parameters['slice'] === undefined) {
23347 deferred.reject(new Error('Missing required form parameter: slice'));
23348 return deferred.promise;
23349 }
23350
23351 if (parameters.$queryParameters) {
23352 Object.keys(parameters.$queryParameters)
23353 .forEach(function(parameterName) {
23354 var parameter = parameters.$queryParameters[parameterName];
23355 queryParameters[parameterName] = parameter;
23356 });
23357 }
23358
23359 var url = domain + path;
23360 var options = {
23361 timeout: parameters.$timeout,
23362 method: 'PUT',
23363 url: url,
23364 params: queryParameters,
23365 data: body,
23366 headers: headers
23367 };
23368 if (Object.keys(form).length > 0) {
23369 options.data = form;
23370 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23371 options.transformRequest = xos.transformRequest;
23372 }
23373 $http(options)
23374 .success(function(data, status, headers, config) {
23375 deferred.resolve(data);
23376 if (parameters.$cache !== undefined) {
23377 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23378 }
23379 })
23380 .error(function(data, status, headers, config) {
23381 deferred.reject({
23382 status: status,
23383 headers: headers,
23384 config: config,
23385 body: data
23386 });
23387 });
23388
23389 return deferred.promise;
23390 };
23391 /**
23392 *
23393 * @method
23394 * @name xos#Network_Slice_Detail_PATCH
23395 * @param {string} pk -
23396 * @param {string} enacted -
23397 * @param {string} policed -
23398 * @param {string} backend_register -
23399 * @param {string} backend_status -
23400 * @param {boolean} deleted -
23401 * @param {boolean} write_protect -
23402 * @param {boolean} lazy_blocked -
23403 * @param {boolean} no_sync -
23404 * @param {string} network -
23405 * @param {string} slice -
23406 *
23407 */
23408 xos.prototype.Network_Slice_Detail_PATCH = function(parameters) {
23409 if (parameters === undefined) {
23410 parameters = {};
23411 }
23412 var deferred = $q.defer();
23413
23414 var domain = this.domain;
23415 var path = '/xos/networkslices/{pk}/';
23416
23417 var body;
23418 var queryParameters = {};
23419 var headers = {};
23420 var form = {};
23421
23422 path = path.replace('{pk}', parameters['pk']);
23423
23424 if (parameters['pk'] === undefined) {
23425 deferred.reject(new Error('Missing required path parameter: pk'));
23426 return deferred.promise;
23427 }
23428
23429 if (parameters['enacted'] !== undefined) {
23430 form['enacted'] = parameters['enacted'];
23431 }
23432
23433 if (parameters['policed'] !== undefined) {
23434 form['policed'] = parameters['policed'];
23435 }
23436
23437 if (parameters['backend_register'] !== undefined) {
23438 form['backend_register'] = parameters['backend_register'];
23439 }
23440
23441 if (parameters['backend_status'] !== undefined) {
23442 form['backend_status'] = parameters['backend_status'];
23443 }
23444
23445 if (parameters['deleted'] !== undefined) {
23446 form['deleted'] = parameters['deleted'];
23447 }
23448
23449 if (parameters['write_protect'] !== undefined) {
23450 form['write_protect'] = parameters['write_protect'];
23451 }
23452
23453 if (parameters['lazy_blocked'] !== undefined) {
23454 form['lazy_blocked'] = parameters['lazy_blocked'];
23455 }
23456
23457 if (parameters['no_sync'] !== undefined) {
23458 form['no_sync'] = parameters['no_sync'];
23459 }
23460
23461 if (parameters['network'] !== undefined) {
23462 form['network'] = parameters['network'];
23463 }
23464
23465 if (parameters['slice'] !== undefined) {
23466 form['slice'] = parameters['slice'];
23467 }
23468
23469 if (parameters.$queryParameters) {
23470 Object.keys(parameters.$queryParameters)
23471 .forEach(function(parameterName) {
23472 var parameter = parameters.$queryParameters[parameterName];
23473 queryParameters[parameterName] = parameter;
23474 });
23475 }
23476
23477 var url = domain + path;
23478 var options = {
23479 timeout: parameters.$timeout,
23480 method: 'PATCH',
23481 url: url,
23482 params: queryParameters,
23483 data: body,
23484 headers: headers
23485 };
23486 if (Object.keys(form).length > 0) {
23487 options.data = form;
23488 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23489 options.transformRequest = xos.transformRequest;
23490 }
23491 $http(options)
23492 .success(function(data, status, headers, config) {
23493 deferred.resolve(data);
23494 if (parameters.$cache !== undefined) {
23495 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23496 }
23497 })
23498 .error(function(data, status, headers, config) {
23499 deferred.reject({
23500 status: status,
23501 headers: headers,
23502 config: config,
23503 body: data
23504 });
23505 });
23506
23507 return deferred.promise;
23508 };
23509 /**
23510 *
23511 * @method
23512 * @name xos#Network_Slice_Detail_DELETE
23513 * @param {string} pk -
23514 *
23515 */
23516 xos.prototype.Network_Slice_Detail_DELETE = function(parameters) {
23517 if (parameters === undefined) {
23518 parameters = {};
23519 }
23520 var deferred = $q.defer();
23521
23522 var domain = this.domain;
23523 var path = '/xos/networkslices/{pk}/';
23524
23525 var body;
23526 var queryParameters = {};
23527 var headers = {};
23528 var form = {};
23529
23530 path = path.replace('{pk}', parameters['pk']);
23531
23532 if (parameters['pk'] === undefined) {
23533 deferred.reject(new Error('Missing required path parameter: pk'));
23534 return deferred.promise;
23535 }
23536
23537 if (parameters.$queryParameters) {
23538 Object.keys(parameters.$queryParameters)
23539 .forEach(function(parameterName) {
23540 var parameter = parameters.$queryParameters[parameterName];
23541 queryParameters[parameterName] = parameter;
23542 });
23543 }
23544
23545 var url = domain + path;
23546 var options = {
23547 timeout: parameters.$timeout,
23548 method: 'DELETE',
23549 url: url,
23550 params: queryParameters,
23551 data: body,
23552 headers: headers
23553 };
23554 if (Object.keys(form).length > 0) {
23555 options.data = form;
23556 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23557 options.transformRequest = xos.transformRequest;
23558 }
23559 $http(options)
23560 .success(function(data, status, headers, config) {
23561 deferred.resolve(data);
23562 if (parameters.$cache !== undefined) {
23563 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23564 }
23565 })
23566 .error(function(data, status, headers, config) {
23567 deferred.reject({
23568 status: status,
23569 headers: headers,
23570 config: config,
23571 body: data
23572 });
23573 });
23574
23575 return deferred.promise;
23576 };
23577 /**
23578 *
23579 * @method
23580 * @name xos#User_Dashboard_View_List_GET
23581 *
23582 */
23583 xos.prototype.User_Dashboard_View_List_GET = function(parameters) {
23584 if (parameters === undefined) {
23585 parameters = {};
23586 }
23587 var deferred = $q.defer();
23588
23589 var domain = this.domain;
23590 var path = '/xos/userdashboardviews/';
23591
23592 var body;
23593 var queryParameters = {};
23594 var headers = {};
23595 var form = {};
23596
23597 if (parameters.$queryParameters) {
23598 Object.keys(parameters.$queryParameters)
23599 .forEach(function(parameterName) {
23600 var parameter = parameters.$queryParameters[parameterName];
23601 queryParameters[parameterName] = parameter;
23602 });
23603 }
23604
23605 var url = domain + path;
23606 var cached = parameters.$cache && parameters.$cache.get(url);
23607 if (cached !== undefined && parameters.$refresh !== true) {
23608 deferred.resolve(cached);
23609 return deferred.promise;
23610 }
23611 var options = {
23612 timeout: parameters.$timeout,
23613 method: 'GET',
23614 url: url,
23615 params: queryParameters,
23616 data: body,
23617 headers: headers
23618 };
23619 if (Object.keys(form).length > 0) {
23620 options.data = form;
23621 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23622 options.transformRequest = xos.transformRequest;
23623 }
23624 $http(options)
23625 .success(function(data, status, headers, config) {
23626 deferred.resolve(data);
23627 if (parameters.$cache !== undefined) {
23628 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23629 }
23630 })
23631 .error(function(data, status, headers, config) {
23632 deferred.reject({
23633 status: status,
23634 headers: headers,
23635 config: config,
23636 body: data
23637 });
23638 });
23639
23640 return deferred.promise;
23641 };
23642 /**
23643 *
23644 * @method
23645 * @name xos#User_Dashboard_View_List_POST
23646 * @param {string} enacted -
23647 * @param {string} policed -
23648 * @param {string} backend_register -
23649 * @param {string} backend_status -
23650 * @param {boolean} deleted -
23651 * @param {boolean} write_protect -
23652 * @param {boolean} lazy_blocked -
23653 * @param {boolean} no_sync -
23654 * @param {string} user -
23655 * @param {string} dashboardView -
23656 * @param {integer} order -
23657 *
23658 */
23659 xos.prototype.User_Dashboard_View_List_POST = function(parameters) {
23660 if (parameters === undefined) {
23661 parameters = {};
23662 }
23663 var deferred = $q.defer();
23664
23665 var domain = this.domain;
23666 var path = '/xos/userdashboardviews/';
23667
23668 var body;
23669 var queryParameters = {};
23670 var headers = {};
23671 var form = {};
23672
23673 if (parameters['enacted'] !== undefined) {
23674 form['enacted'] = parameters['enacted'];
23675 }
23676
23677 if (parameters['policed'] !== undefined) {
23678 form['policed'] = parameters['policed'];
23679 }
23680
23681 if (parameters['backend_register'] !== undefined) {
23682 form['backend_register'] = parameters['backend_register'];
23683 }
23684
23685 if (parameters['backend_status'] !== undefined) {
23686 form['backend_status'] = parameters['backend_status'];
23687 }
23688
23689 if (parameters['backend_status'] === undefined) {
23690 deferred.reject(new Error('Missing required form parameter: backend_status'));
23691 return deferred.promise;
23692 }
23693
23694 if (parameters['deleted'] !== undefined) {
23695 form['deleted'] = parameters['deleted'];
23696 }
23697
23698 if (parameters['write_protect'] !== undefined) {
23699 form['write_protect'] = parameters['write_protect'];
23700 }
23701
23702 if (parameters['lazy_blocked'] !== undefined) {
23703 form['lazy_blocked'] = parameters['lazy_blocked'];
23704 }
23705
23706 if (parameters['no_sync'] !== undefined) {
23707 form['no_sync'] = parameters['no_sync'];
23708 }
23709
23710 if (parameters['user'] !== undefined) {
23711 form['user'] = parameters['user'];
23712 }
23713
23714 if (parameters['user'] === undefined) {
23715 deferred.reject(new Error('Missing required form parameter: user'));
23716 return deferred.promise;
23717 }
23718
23719 if (parameters['dashboardView'] !== undefined) {
23720 form['dashboardView'] = parameters['dashboardView'];
23721 }
23722
23723 if (parameters['dashboardView'] === undefined) {
23724 deferred.reject(new Error('Missing required form parameter: dashboardView'));
23725 return deferred.promise;
23726 }
23727
23728 if (parameters['order'] !== undefined) {
23729 form['order'] = parameters['order'];
23730 }
23731
23732 if (parameters['order'] === undefined) {
23733 deferred.reject(new Error('Missing required form parameter: order'));
23734 return deferred.promise;
23735 }
23736
23737 if (parameters.$queryParameters) {
23738 Object.keys(parameters.$queryParameters)
23739 .forEach(function(parameterName) {
23740 var parameter = parameters.$queryParameters[parameterName];
23741 queryParameters[parameterName] = parameter;
23742 });
23743 }
23744
23745 var url = domain + path;
23746 var options = {
23747 timeout: parameters.$timeout,
23748 method: 'POST',
23749 url: url,
23750 params: queryParameters,
23751 data: body,
23752 headers: headers
23753 };
23754 if (Object.keys(form).length > 0) {
23755 options.data = form;
23756 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23757 options.transformRequest = xos.transformRequest;
23758 }
23759 $http(options)
23760 .success(function(data, status, headers, config) {
23761 deferred.resolve(data);
23762 if (parameters.$cache !== undefined) {
23763 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23764 }
23765 })
23766 .error(function(data, status, headers, config) {
23767 deferred.reject({
23768 status: status,
23769 headers: headers,
23770 config: config,
23771 body: data
23772 });
23773 });
23774
23775 return deferred.promise;
23776 };
23777 /**
23778 *
23779 * @method
23780 * @name xos#User_Dashboard_View_Detail_GET
23781 * @param {string} pk -
23782 *
23783 */
23784 xos.prototype.User_Dashboard_View_Detail_GET = function(parameters) {
23785 if (parameters === undefined) {
23786 parameters = {};
23787 }
23788 var deferred = $q.defer();
23789
23790 var domain = this.domain;
23791 var path = '/xos/userdashboardviews/{pk}/';
23792
23793 var body;
23794 var queryParameters = {};
23795 var headers = {};
23796 var form = {};
23797
23798 path = path.replace('{pk}', parameters['pk']);
23799
23800 if (parameters['pk'] === undefined) {
23801 deferred.reject(new Error('Missing required path parameter: pk'));
23802 return deferred.promise;
23803 }
23804
23805 if (parameters.$queryParameters) {
23806 Object.keys(parameters.$queryParameters)
23807 .forEach(function(parameterName) {
23808 var parameter = parameters.$queryParameters[parameterName];
23809 queryParameters[parameterName] = parameter;
23810 });
23811 }
23812
23813 var url = domain + path;
23814 var cached = parameters.$cache && parameters.$cache.get(url);
23815 if (cached !== undefined && parameters.$refresh !== true) {
23816 deferred.resolve(cached);
23817 return deferred.promise;
23818 }
23819 var options = {
23820 timeout: parameters.$timeout,
23821 method: 'GET',
23822 url: url,
23823 params: queryParameters,
23824 data: body,
23825 headers: headers
23826 };
23827 if (Object.keys(form).length > 0) {
23828 options.data = form;
23829 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23830 options.transformRequest = xos.transformRequest;
23831 }
23832 $http(options)
23833 .success(function(data, status, headers, config) {
23834 deferred.resolve(data);
23835 if (parameters.$cache !== undefined) {
23836 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23837 }
23838 })
23839 .error(function(data, status, headers, config) {
23840 deferred.reject({
23841 status: status,
23842 headers: headers,
23843 config: config,
23844 body: data
23845 });
23846 });
23847
23848 return deferred.promise;
23849 };
23850 /**
23851 *
23852 * @method
23853 * @name xos#User_Dashboard_View_Detail_PUT
23854 * @param {string} pk -
23855 * @param {string} enacted -
23856 * @param {string} policed -
23857 * @param {string} backend_register -
23858 * @param {string} backend_status -
23859 * @param {boolean} deleted -
23860 * @param {boolean} write_protect -
23861 * @param {boolean} lazy_blocked -
23862 * @param {boolean} no_sync -
23863 * @param {string} user -
23864 * @param {string} dashboardView -
23865 * @param {integer} order -
23866 *
23867 */
23868 xos.prototype.User_Dashboard_View_Detail_PUT = function(parameters) {
23869 if (parameters === undefined) {
23870 parameters = {};
23871 }
23872 var deferred = $q.defer();
23873
23874 var domain = this.domain;
23875 var path = '/xos/userdashboardviews/{pk}/';
23876
23877 var body;
23878 var queryParameters = {};
23879 var headers = {};
23880 var form = {};
23881
23882 path = path.replace('{pk}', parameters['pk']);
23883
23884 if (parameters['pk'] === undefined) {
23885 deferred.reject(new Error('Missing required path parameter: pk'));
23886 return deferred.promise;
23887 }
23888
23889 if (parameters['enacted'] !== undefined) {
23890 form['enacted'] = parameters['enacted'];
23891 }
23892
23893 if (parameters['policed'] !== undefined) {
23894 form['policed'] = parameters['policed'];
23895 }
23896
23897 if (parameters['backend_register'] !== undefined) {
23898 form['backend_register'] = parameters['backend_register'];
23899 }
23900
23901 if (parameters['backend_status'] !== undefined) {
23902 form['backend_status'] = parameters['backend_status'];
23903 }
23904
23905 if (parameters['backend_status'] === undefined) {
23906 deferred.reject(new Error('Missing required form parameter: backend_status'));
23907 return deferred.promise;
23908 }
23909
23910 if (parameters['deleted'] !== undefined) {
23911 form['deleted'] = parameters['deleted'];
23912 }
23913
23914 if (parameters['write_protect'] !== undefined) {
23915 form['write_protect'] = parameters['write_protect'];
23916 }
23917
23918 if (parameters['lazy_blocked'] !== undefined) {
23919 form['lazy_blocked'] = parameters['lazy_blocked'];
23920 }
23921
23922 if (parameters['no_sync'] !== undefined) {
23923 form['no_sync'] = parameters['no_sync'];
23924 }
23925
23926 if (parameters['user'] !== undefined) {
23927 form['user'] = parameters['user'];
23928 }
23929
23930 if (parameters['user'] === undefined) {
23931 deferred.reject(new Error('Missing required form parameter: user'));
23932 return deferred.promise;
23933 }
23934
23935 if (parameters['dashboardView'] !== undefined) {
23936 form['dashboardView'] = parameters['dashboardView'];
23937 }
23938
23939 if (parameters['dashboardView'] === undefined) {
23940 deferred.reject(new Error('Missing required form parameter: dashboardView'));
23941 return deferred.promise;
23942 }
23943
23944 if (parameters['order'] !== undefined) {
23945 form['order'] = parameters['order'];
23946 }
23947
23948 if (parameters['order'] === undefined) {
23949 deferred.reject(new Error('Missing required form parameter: order'));
23950 return deferred.promise;
23951 }
23952
23953 if (parameters.$queryParameters) {
23954 Object.keys(parameters.$queryParameters)
23955 .forEach(function(parameterName) {
23956 var parameter = parameters.$queryParameters[parameterName];
23957 queryParameters[parameterName] = parameter;
23958 });
23959 }
23960
23961 var url = domain + path;
23962 var options = {
23963 timeout: parameters.$timeout,
23964 method: 'PUT',
23965 url: url,
23966 params: queryParameters,
23967 data: body,
23968 headers: headers
23969 };
23970 if (Object.keys(form).length > 0) {
23971 options.data = form;
23972 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
23973 options.transformRequest = xos.transformRequest;
23974 }
23975 $http(options)
23976 .success(function(data, status, headers, config) {
23977 deferred.resolve(data);
23978 if (parameters.$cache !== undefined) {
23979 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
23980 }
23981 })
23982 .error(function(data, status, headers, config) {
23983 deferred.reject({
23984 status: status,
23985 headers: headers,
23986 config: config,
23987 body: data
23988 });
23989 });
23990
23991 return deferred.promise;
23992 };
23993 /**
23994 *
23995 * @method
23996 * @name xos#User_Dashboard_View_Detail_PATCH
23997 * @param {string} pk -
23998 * @param {string} enacted -
23999 * @param {string} policed -
24000 * @param {string} backend_register -
24001 * @param {string} backend_status -
24002 * @param {boolean} deleted -
24003 * @param {boolean} write_protect -
24004 * @param {boolean} lazy_blocked -
24005 * @param {boolean} no_sync -
24006 * @param {string} user -
24007 * @param {string} dashboardView -
24008 * @param {integer} order -
24009 *
24010 */
24011 xos.prototype.User_Dashboard_View_Detail_PATCH = function(parameters) {
24012 if (parameters === undefined) {
24013 parameters = {};
24014 }
24015 var deferred = $q.defer();
24016
24017 var domain = this.domain;
24018 var path = '/xos/userdashboardviews/{pk}/';
24019
24020 var body;
24021 var queryParameters = {};
24022 var headers = {};
24023 var form = {};
24024
24025 path = path.replace('{pk}', parameters['pk']);
24026
24027 if (parameters['pk'] === undefined) {
24028 deferred.reject(new Error('Missing required path parameter: pk'));
24029 return deferred.promise;
24030 }
24031
24032 if (parameters['enacted'] !== undefined) {
24033 form['enacted'] = parameters['enacted'];
24034 }
24035
24036 if (parameters['policed'] !== undefined) {
24037 form['policed'] = parameters['policed'];
24038 }
24039
24040 if (parameters['backend_register'] !== undefined) {
24041 form['backend_register'] = parameters['backend_register'];
24042 }
24043
24044 if (parameters['backend_status'] !== undefined) {
24045 form['backend_status'] = parameters['backend_status'];
24046 }
24047
24048 if (parameters['deleted'] !== undefined) {
24049 form['deleted'] = parameters['deleted'];
24050 }
24051
24052 if (parameters['write_protect'] !== undefined) {
24053 form['write_protect'] = parameters['write_protect'];
24054 }
24055
24056 if (parameters['lazy_blocked'] !== undefined) {
24057 form['lazy_blocked'] = parameters['lazy_blocked'];
24058 }
24059
24060 if (parameters['no_sync'] !== undefined) {
24061 form['no_sync'] = parameters['no_sync'];
24062 }
24063
24064 if (parameters['user'] !== undefined) {
24065 form['user'] = parameters['user'];
24066 }
24067
24068 if (parameters['dashboardView'] !== undefined) {
24069 form['dashboardView'] = parameters['dashboardView'];
24070 }
24071
24072 if (parameters['order'] !== undefined) {
24073 form['order'] = parameters['order'];
24074 }
24075
24076 if (parameters.$queryParameters) {
24077 Object.keys(parameters.$queryParameters)
24078 .forEach(function(parameterName) {
24079 var parameter = parameters.$queryParameters[parameterName];
24080 queryParameters[parameterName] = parameter;
24081 });
24082 }
24083
24084 var url = domain + path;
24085 var options = {
24086 timeout: parameters.$timeout,
24087 method: 'PATCH',
24088 url: url,
24089 params: queryParameters,
24090 data: body,
24091 headers: headers
24092 };
24093 if (Object.keys(form).length > 0) {
24094 options.data = form;
24095 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24096 options.transformRequest = xos.transformRequest;
24097 }
24098 $http(options)
24099 .success(function(data, status, headers, config) {
24100 deferred.resolve(data);
24101 if (parameters.$cache !== undefined) {
24102 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24103 }
24104 })
24105 .error(function(data, status, headers, config) {
24106 deferred.reject({
24107 status: status,
24108 headers: headers,
24109 config: config,
24110 body: data
24111 });
24112 });
24113
24114 return deferred.promise;
24115 };
24116 /**
24117 *
24118 * @method
24119 * @name xos#User_Dashboard_View_Detail_DELETE
24120 * @param {string} pk -
24121 *
24122 */
24123 xos.prototype.User_Dashboard_View_Detail_DELETE = function(parameters) {
24124 if (parameters === undefined) {
24125 parameters = {};
24126 }
24127 var deferred = $q.defer();
24128
24129 var domain = this.domain;
24130 var path = '/xos/userdashboardviews/{pk}/';
24131
24132 var body;
24133 var queryParameters = {};
24134 var headers = {};
24135 var form = {};
24136
24137 path = path.replace('{pk}', parameters['pk']);
24138
24139 if (parameters['pk'] === undefined) {
24140 deferred.reject(new Error('Missing required path parameter: pk'));
24141 return deferred.promise;
24142 }
24143
24144 if (parameters.$queryParameters) {
24145 Object.keys(parameters.$queryParameters)
24146 .forEach(function(parameterName) {
24147 var parameter = parameters.$queryParameters[parameterName];
24148 queryParameters[parameterName] = parameter;
24149 });
24150 }
24151
24152 var url = domain + path;
24153 var options = {
24154 timeout: parameters.$timeout,
24155 method: 'DELETE',
24156 url: url,
24157 params: queryParameters,
24158 data: body,
24159 headers: headers
24160 };
24161 if (Object.keys(form).length > 0) {
24162 options.data = form;
24163 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24164 options.transformRequest = xos.transformRequest;
24165 }
24166 $http(options)
24167 .success(function(data, status, headers, config) {
24168 deferred.resolve(data);
24169 if (parameters.$cache !== undefined) {
24170 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24171 }
24172 })
24173 .error(function(data, status, headers, config) {
24174 deferred.reject({
24175 status: status,
24176 headers: headers,
24177 config: config,
24178 body: data
24179 });
24180 });
24181
24182 return deferred.promise;
24183 };
24184 /**
24185 *
24186 * @method
24187 * @name xos#Controller_List_GET
24188 *
24189 */
24190 xos.prototype.Controller_List_GET = function(parameters) {
24191 if (parameters === undefined) {
24192 parameters = {};
24193 }
24194 var deferred = $q.defer();
24195
24196 var domain = this.domain;
24197 var path = '/xos/controllers/';
24198
24199 var body;
24200 var queryParameters = {};
24201 var headers = {};
24202 var form = {};
24203
24204 if (parameters.$queryParameters) {
24205 Object.keys(parameters.$queryParameters)
24206 .forEach(function(parameterName) {
24207 var parameter = parameters.$queryParameters[parameterName];
24208 queryParameters[parameterName] = parameter;
24209 });
24210 }
24211
24212 var url = domain + path;
24213 var cached = parameters.$cache && parameters.$cache.get(url);
24214 if (cached !== undefined && parameters.$refresh !== true) {
24215 deferred.resolve(cached);
24216 return deferred.promise;
24217 }
24218 var options = {
24219 timeout: parameters.$timeout,
24220 method: 'GET',
24221 url: url,
24222 params: queryParameters,
24223 data: body,
24224 headers: headers
24225 };
24226 if (Object.keys(form).length > 0) {
24227 options.data = form;
24228 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24229 options.transformRequest = xos.transformRequest;
24230 }
24231 $http(options)
24232 .success(function(data, status, headers, config) {
24233 deferred.resolve(data);
24234 if (parameters.$cache !== undefined) {
24235 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24236 }
24237 })
24238 .error(function(data, status, headers, config) {
24239 deferred.reject({
24240 status: status,
24241 headers: headers,
24242 config: config,
24243 body: data
24244 });
24245 });
24246
24247 return deferred.promise;
24248 };
24249 /**
24250 *
24251 * @method
24252 * @name xos#Controller_List_POST
24253 * @param {string} enacted -
24254 * @param {string} policed -
24255 * @param {string} backend_register -
24256 * @param {string} backend_status -
24257 * @param {boolean} deleted -
24258 * @param {boolean} write_protect -
24259 * @param {boolean} lazy_blocked -
24260 * @param {boolean} no_sync -
24261 * @param {string} name - Name of the Controller
24262 * @param {string} backend_type - Type of compute controller, e.g. EC2, OpenStack, or OpenStack version
24263 * @param {string} version - Controller version
24264 * @param {string} auth_url - Auth url for the compute controller
24265 * @param {string} admin_user - Username of an admin user at this controller
24266 * @param {string} admin_password - Password of theadmin user at this controller
24267 * @param {string} admin_tenant - Name of the tenant the admin user belongs to
24268 * @param {string} domain - Name of the domain this controller belongs to
24269 * @param {string} rabbit_host - IP address of rabbitmq server at this controller
24270 * @param {string} rabbit_user - Username of rabbitmq server at this controller
24271 * @param {string} rabbit_password - Password of rabbitmq server at this controller
24272 * @param {string} deployment -
24273 *
24274 */
24275 xos.prototype.Controller_List_POST = function(parameters) {
24276 if (parameters === undefined) {
24277 parameters = {};
24278 }
24279 var deferred = $q.defer();
24280
24281 var domain = this.domain;
24282 var path = '/xos/controllers/';
24283
24284 var body;
24285 var queryParameters = {};
24286 var headers = {};
24287 var form = {};
24288
24289 if (parameters['enacted'] !== undefined) {
24290 form['enacted'] = parameters['enacted'];
24291 }
24292
24293 if (parameters['policed'] !== undefined) {
24294 form['policed'] = parameters['policed'];
24295 }
24296
24297 if (parameters['backend_register'] !== undefined) {
24298 form['backend_register'] = parameters['backend_register'];
24299 }
24300
24301 if (parameters['backend_status'] !== undefined) {
24302 form['backend_status'] = parameters['backend_status'];
24303 }
24304
24305 if (parameters['backend_status'] === undefined) {
24306 deferred.reject(new Error('Missing required form parameter: backend_status'));
24307 return deferred.promise;
24308 }
24309
24310 if (parameters['deleted'] !== undefined) {
24311 form['deleted'] = parameters['deleted'];
24312 }
24313
24314 if (parameters['write_protect'] !== undefined) {
24315 form['write_protect'] = parameters['write_protect'];
24316 }
24317
24318 if (parameters['lazy_blocked'] !== undefined) {
24319 form['lazy_blocked'] = parameters['lazy_blocked'];
24320 }
24321
24322 if (parameters['no_sync'] !== undefined) {
24323 form['no_sync'] = parameters['no_sync'];
24324 }
24325
24326 if (parameters['name'] !== undefined) {
24327 form['name'] = parameters['name'];
24328 }
24329
24330 if (parameters['name'] === undefined) {
24331 deferred.reject(new Error('Missing required form parameter: name'));
24332 return deferred.promise;
24333 }
24334
24335 if (parameters['backend_type'] !== undefined) {
24336 form['backend_type'] = parameters['backend_type'];
24337 }
24338
24339 if (parameters['backend_type'] === undefined) {
24340 deferred.reject(new Error('Missing required form parameter: backend_type'));
24341 return deferred.promise;
24342 }
24343
24344 if (parameters['version'] !== undefined) {
24345 form['version'] = parameters['version'];
24346 }
24347
24348 if (parameters['version'] === undefined) {
24349 deferred.reject(new Error('Missing required form parameter: version'));
24350 return deferred.promise;
24351 }
24352
24353 if (parameters['auth_url'] !== undefined) {
24354 form['auth_url'] = parameters['auth_url'];
24355 }
24356
24357 if (parameters['admin_user'] !== undefined) {
24358 form['admin_user'] = parameters['admin_user'];
24359 }
24360
24361 if (parameters['admin_password'] !== undefined) {
24362 form['admin_password'] = parameters['admin_password'];
24363 }
24364
24365 if (parameters['admin_tenant'] !== undefined) {
24366 form['admin_tenant'] = parameters['admin_tenant'];
24367 }
24368
24369 if (parameters['domain'] !== undefined) {
24370 form['domain'] = parameters['domain'];
24371 }
24372
24373 if (parameters['rabbit_host'] !== undefined) {
24374 form['rabbit_host'] = parameters['rabbit_host'];
24375 }
24376
24377 if (parameters['rabbit_user'] !== undefined) {
24378 form['rabbit_user'] = parameters['rabbit_user'];
24379 }
24380
24381 if (parameters['rabbit_password'] !== undefined) {
24382 form['rabbit_password'] = parameters['rabbit_password'];
24383 }
24384
24385 if (parameters['deployment'] !== undefined) {
24386 form['deployment'] = parameters['deployment'];
24387 }
24388
24389 if (parameters['deployment'] === undefined) {
24390 deferred.reject(new Error('Missing required form parameter: deployment'));
24391 return deferred.promise;
24392 }
24393
24394 if (parameters.$queryParameters) {
24395 Object.keys(parameters.$queryParameters)
24396 .forEach(function(parameterName) {
24397 var parameter = parameters.$queryParameters[parameterName];
24398 queryParameters[parameterName] = parameter;
24399 });
24400 }
24401
24402 var url = domain + path;
24403 var options = {
24404 timeout: parameters.$timeout,
24405 method: 'POST',
24406 url: url,
24407 params: queryParameters,
24408 data: body,
24409 headers: headers
24410 };
24411 if (Object.keys(form).length > 0) {
24412 options.data = form;
24413 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24414 options.transformRequest = xos.transformRequest;
24415 }
24416 $http(options)
24417 .success(function(data, status, headers, config) {
24418 deferred.resolve(data);
24419 if (parameters.$cache !== undefined) {
24420 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24421 }
24422 })
24423 .error(function(data, status, headers, config) {
24424 deferred.reject({
24425 status: status,
24426 headers: headers,
24427 config: config,
24428 body: data
24429 });
24430 });
24431
24432 return deferred.promise;
24433 };
24434 /**
24435 *
24436 * @method
24437 * @name xos#Controller_Detail_GET
24438 * @param {string} pk -
24439 *
24440 */
24441 xos.prototype.Controller_Detail_GET = function(parameters) {
24442 if (parameters === undefined) {
24443 parameters = {};
24444 }
24445 var deferred = $q.defer();
24446
24447 var domain = this.domain;
24448 var path = '/xos/controllers/{pk}/';
24449
24450 var body;
24451 var queryParameters = {};
24452 var headers = {};
24453 var form = {};
24454
24455 path = path.replace('{pk}', parameters['pk']);
24456
24457 if (parameters['pk'] === undefined) {
24458 deferred.reject(new Error('Missing required path parameter: pk'));
24459 return deferred.promise;
24460 }
24461
24462 if (parameters.$queryParameters) {
24463 Object.keys(parameters.$queryParameters)
24464 .forEach(function(parameterName) {
24465 var parameter = parameters.$queryParameters[parameterName];
24466 queryParameters[parameterName] = parameter;
24467 });
24468 }
24469
24470 var url = domain + path;
24471 var cached = parameters.$cache && parameters.$cache.get(url);
24472 if (cached !== undefined && parameters.$refresh !== true) {
24473 deferred.resolve(cached);
24474 return deferred.promise;
24475 }
24476 var options = {
24477 timeout: parameters.$timeout,
24478 method: 'GET',
24479 url: url,
24480 params: queryParameters,
24481 data: body,
24482 headers: headers
24483 };
24484 if (Object.keys(form).length > 0) {
24485 options.data = form;
24486 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24487 options.transformRequest = xos.transformRequest;
24488 }
24489 $http(options)
24490 .success(function(data, status, headers, config) {
24491 deferred.resolve(data);
24492 if (parameters.$cache !== undefined) {
24493 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24494 }
24495 })
24496 .error(function(data, status, headers, config) {
24497 deferred.reject({
24498 status: status,
24499 headers: headers,
24500 config: config,
24501 body: data
24502 });
24503 });
24504
24505 return deferred.promise;
24506 };
24507 /**
24508 *
24509 * @method
24510 * @name xos#Controller_Detail_PUT
24511 * @param {string} pk -
24512 * @param {string} enacted -
24513 * @param {string} policed -
24514 * @param {string} backend_register -
24515 * @param {string} backend_status -
24516 * @param {boolean} deleted -
24517 * @param {boolean} write_protect -
24518 * @param {boolean} lazy_blocked -
24519 * @param {boolean} no_sync -
24520 * @param {string} name - Name of the Controller
24521 * @param {string} backend_type - Type of compute controller, e.g. EC2, OpenStack, or OpenStack version
24522 * @param {string} version - Controller version
24523 * @param {string} auth_url - Auth url for the compute controller
24524 * @param {string} admin_user - Username of an admin user at this controller
24525 * @param {string} admin_password - Password of theadmin user at this controller
24526 * @param {string} admin_tenant - Name of the tenant the admin user belongs to
24527 * @param {string} domain - Name of the domain this controller belongs to
24528 * @param {string} rabbit_host - IP address of rabbitmq server at this controller
24529 * @param {string} rabbit_user - Username of rabbitmq server at this controller
24530 * @param {string} rabbit_password - Password of rabbitmq server at this controller
24531 * @param {string} deployment -
24532 *
24533 */
24534 xos.prototype.Controller_Detail_PUT = function(parameters) {
24535 if (parameters === undefined) {
24536 parameters = {};
24537 }
24538 var deferred = $q.defer();
24539
24540 var domain = this.domain;
24541 var path = '/xos/controllers/{pk}/';
24542
24543 var body;
24544 var queryParameters = {};
24545 var headers = {};
24546 var form = {};
24547
24548 path = path.replace('{pk}', parameters['pk']);
24549
24550 if (parameters['pk'] === undefined) {
24551 deferred.reject(new Error('Missing required path parameter: pk'));
24552 return deferred.promise;
24553 }
24554
24555 if (parameters['enacted'] !== undefined) {
24556 form['enacted'] = parameters['enacted'];
24557 }
24558
24559 if (parameters['policed'] !== undefined) {
24560 form['policed'] = parameters['policed'];
24561 }
24562
24563 if (parameters['backend_register'] !== undefined) {
24564 form['backend_register'] = parameters['backend_register'];
24565 }
24566
24567 if (parameters['backend_status'] !== undefined) {
24568 form['backend_status'] = parameters['backend_status'];
24569 }
24570
24571 if (parameters['backend_status'] === undefined) {
24572 deferred.reject(new Error('Missing required form parameter: backend_status'));
24573 return deferred.promise;
24574 }
24575
24576 if (parameters['deleted'] !== undefined) {
24577 form['deleted'] = parameters['deleted'];
24578 }
24579
24580 if (parameters['write_protect'] !== undefined) {
24581 form['write_protect'] = parameters['write_protect'];
24582 }
24583
24584 if (parameters['lazy_blocked'] !== undefined) {
24585 form['lazy_blocked'] = parameters['lazy_blocked'];
24586 }
24587
24588 if (parameters['no_sync'] !== undefined) {
24589 form['no_sync'] = parameters['no_sync'];
24590 }
24591
24592 if (parameters['name'] !== undefined) {
24593 form['name'] = parameters['name'];
24594 }
24595
24596 if (parameters['name'] === undefined) {
24597 deferred.reject(new Error('Missing required form parameter: name'));
24598 return deferred.promise;
24599 }
24600
24601 if (parameters['backend_type'] !== undefined) {
24602 form['backend_type'] = parameters['backend_type'];
24603 }
24604
24605 if (parameters['backend_type'] === undefined) {
24606 deferred.reject(new Error('Missing required form parameter: backend_type'));
24607 return deferred.promise;
24608 }
24609
24610 if (parameters['version'] !== undefined) {
24611 form['version'] = parameters['version'];
24612 }
24613
24614 if (parameters['version'] === undefined) {
24615 deferred.reject(new Error('Missing required form parameter: version'));
24616 return deferred.promise;
24617 }
24618
24619 if (parameters['auth_url'] !== undefined) {
24620 form['auth_url'] = parameters['auth_url'];
24621 }
24622
24623 if (parameters['admin_user'] !== undefined) {
24624 form['admin_user'] = parameters['admin_user'];
24625 }
24626
24627 if (parameters['admin_password'] !== undefined) {
24628 form['admin_password'] = parameters['admin_password'];
24629 }
24630
24631 if (parameters['admin_tenant'] !== undefined) {
24632 form['admin_tenant'] = parameters['admin_tenant'];
24633 }
24634
24635 if (parameters['domain'] !== undefined) {
24636 form['domain'] = parameters['domain'];
24637 }
24638
24639 if (parameters['rabbit_host'] !== undefined) {
24640 form['rabbit_host'] = parameters['rabbit_host'];
24641 }
24642
24643 if (parameters['rabbit_user'] !== undefined) {
24644 form['rabbit_user'] = parameters['rabbit_user'];
24645 }
24646
24647 if (parameters['rabbit_password'] !== undefined) {
24648 form['rabbit_password'] = parameters['rabbit_password'];
24649 }
24650
24651 if (parameters['deployment'] !== undefined) {
24652 form['deployment'] = parameters['deployment'];
24653 }
24654
24655 if (parameters['deployment'] === undefined) {
24656 deferred.reject(new Error('Missing required form parameter: deployment'));
24657 return deferred.promise;
24658 }
24659
24660 if (parameters.$queryParameters) {
24661 Object.keys(parameters.$queryParameters)
24662 .forEach(function(parameterName) {
24663 var parameter = parameters.$queryParameters[parameterName];
24664 queryParameters[parameterName] = parameter;
24665 });
24666 }
24667
24668 var url = domain + path;
24669 var options = {
24670 timeout: parameters.$timeout,
24671 method: 'PUT',
24672 url: url,
24673 params: queryParameters,
24674 data: body,
24675 headers: headers
24676 };
24677 if (Object.keys(form).length > 0) {
24678 options.data = form;
24679 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24680 options.transformRequest = xos.transformRequest;
24681 }
24682 $http(options)
24683 .success(function(data, status, headers, config) {
24684 deferred.resolve(data);
24685 if (parameters.$cache !== undefined) {
24686 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24687 }
24688 })
24689 .error(function(data, status, headers, config) {
24690 deferred.reject({
24691 status: status,
24692 headers: headers,
24693 config: config,
24694 body: data
24695 });
24696 });
24697
24698 return deferred.promise;
24699 };
24700 /**
24701 *
24702 * @method
24703 * @name xos#Controller_Detail_PATCH
24704 * @param {string} pk -
24705 * @param {string} enacted -
24706 * @param {string} policed -
24707 * @param {string} backend_register -
24708 * @param {string} backend_status -
24709 * @param {boolean} deleted -
24710 * @param {boolean} write_protect -
24711 * @param {boolean} lazy_blocked -
24712 * @param {boolean} no_sync -
24713 * @param {string} name - Name of the Controller
24714 * @param {string} backend_type - Type of compute controller, e.g. EC2, OpenStack, or OpenStack version
24715 * @param {string} version - Controller version
24716 * @param {string} auth_url - Auth url for the compute controller
24717 * @param {string} admin_user - Username of an admin user at this controller
24718 * @param {string} admin_password - Password of theadmin user at this controller
24719 * @param {string} admin_tenant - Name of the tenant the admin user belongs to
24720 * @param {string} domain - Name of the domain this controller belongs to
24721 * @param {string} rabbit_host - IP address of rabbitmq server at this controller
24722 * @param {string} rabbit_user - Username of rabbitmq server at this controller
24723 * @param {string} rabbit_password - Password of rabbitmq server at this controller
24724 * @param {string} deployment -
24725 *
24726 */
24727 xos.prototype.Controller_Detail_PATCH = function(parameters) {
24728 if (parameters === undefined) {
24729 parameters = {};
24730 }
24731 var deferred = $q.defer();
24732
24733 var domain = this.domain;
24734 var path = '/xos/controllers/{pk}/';
24735
24736 var body;
24737 var queryParameters = {};
24738 var headers = {};
24739 var form = {};
24740
24741 path = path.replace('{pk}', parameters['pk']);
24742
24743 if (parameters['pk'] === undefined) {
24744 deferred.reject(new Error('Missing required path parameter: pk'));
24745 return deferred.promise;
24746 }
24747
24748 if (parameters['enacted'] !== undefined) {
24749 form['enacted'] = parameters['enacted'];
24750 }
24751
24752 if (parameters['policed'] !== undefined) {
24753 form['policed'] = parameters['policed'];
24754 }
24755
24756 if (parameters['backend_register'] !== undefined) {
24757 form['backend_register'] = parameters['backend_register'];
24758 }
24759
24760 if (parameters['backend_status'] !== undefined) {
24761 form['backend_status'] = parameters['backend_status'];
24762 }
24763
24764 if (parameters['deleted'] !== undefined) {
24765 form['deleted'] = parameters['deleted'];
24766 }
24767
24768 if (parameters['write_protect'] !== undefined) {
24769 form['write_protect'] = parameters['write_protect'];
24770 }
24771
24772 if (parameters['lazy_blocked'] !== undefined) {
24773 form['lazy_blocked'] = parameters['lazy_blocked'];
24774 }
24775
24776 if (parameters['no_sync'] !== undefined) {
24777 form['no_sync'] = parameters['no_sync'];
24778 }
24779
24780 if (parameters['name'] !== undefined) {
24781 form['name'] = parameters['name'];
24782 }
24783
24784 if (parameters['backend_type'] !== undefined) {
24785 form['backend_type'] = parameters['backend_type'];
24786 }
24787
24788 if (parameters['version'] !== undefined) {
24789 form['version'] = parameters['version'];
24790 }
24791
24792 if (parameters['auth_url'] !== undefined) {
24793 form['auth_url'] = parameters['auth_url'];
24794 }
24795
24796 if (parameters['admin_user'] !== undefined) {
24797 form['admin_user'] = parameters['admin_user'];
24798 }
24799
24800 if (parameters['admin_password'] !== undefined) {
24801 form['admin_password'] = parameters['admin_password'];
24802 }
24803
24804 if (parameters['admin_tenant'] !== undefined) {
24805 form['admin_tenant'] = parameters['admin_tenant'];
24806 }
24807
24808 if (parameters['domain'] !== undefined) {
24809 form['domain'] = parameters['domain'];
24810 }
24811
24812 if (parameters['rabbit_host'] !== undefined) {
24813 form['rabbit_host'] = parameters['rabbit_host'];
24814 }
24815
24816 if (parameters['rabbit_user'] !== undefined) {
24817 form['rabbit_user'] = parameters['rabbit_user'];
24818 }
24819
24820 if (parameters['rabbit_password'] !== undefined) {
24821 form['rabbit_password'] = parameters['rabbit_password'];
24822 }
24823
24824 if (parameters['deployment'] !== undefined) {
24825 form['deployment'] = parameters['deployment'];
24826 }
24827
24828 if (parameters.$queryParameters) {
24829 Object.keys(parameters.$queryParameters)
24830 .forEach(function(parameterName) {
24831 var parameter = parameters.$queryParameters[parameterName];
24832 queryParameters[parameterName] = parameter;
24833 });
24834 }
24835
24836 var url = domain + path;
24837 var options = {
24838 timeout: parameters.$timeout,
24839 method: 'PATCH',
24840 url: url,
24841 params: queryParameters,
24842 data: body,
24843 headers: headers
24844 };
24845 if (Object.keys(form).length > 0) {
24846 options.data = form;
24847 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24848 options.transformRequest = xos.transformRequest;
24849 }
24850 $http(options)
24851 .success(function(data, status, headers, config) {
24852 deferred.resolve(data);
24853 if (parameters.$cache !== undefined) {
24854 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24855 }
24856 })
24857 .error(function(data, status, headers, config) {
24858 deferred.reject({
24859 status: status,
24860 headers: headers,
24861 config: config,
24862 body: data
24863 });
24864 });
24865
24866 return deferred.promise;
24867 };
24868 /**
24869 *
24870 * @method
24871 * @name xos#Controller_Detail_DELETE
24872 * @param {string} pk -
24873 *
24874 */
24875 xos.prototype.Controller_Detail_DELETE = function(parameters) {
24876 if (parameters === undefined) {
24877 parameters = {};
24878 }
24879 var deferred = $q.defer();
24880
24881 var domain = this.domain;
24882 var path = '/xos/controllers/{pk}/';
24883
24884 var body;
24885 var queryParameters = {};
24886 var headers = {};
24887 var form = {};
24888
24889 path = path.replace('{pk}', parameters['pk']);
24890
24891 if (parameters['pk'] === undefined) {
24892 deferred.reject(new Error('Missing required path parameter: pk'));
24893 return deferred.promise;
24894 }
24895
24896 if (parameters.$queryParameters) {
24897 Object.keys(parameters.$queryParameters)
24898 .forEach(function(parameterName) {
24899 var parameter = parameters.$queryParameters[parameterName];
24900 queryParameters[parameterName] = parameter;
24901 });
24902 }
24903
24904 var url = domain + path;
24905 var options = {
24906 timeout: parameters.$timeout,
24907 method: 'DELETE',
24908 url: url,
24909 params: queryParameters,
24910 data: body,
24911 headers: headers
24912 };
24913 if (Object.keys(form).length > 0) {
24914 options.data = form;
24915 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24916 options.transformRequest = xos.transformRequest;
24917 }
24918 $http(options)
24919 .success(function(data, status, headers, config) {
24920 deferred.resolve(data);
24921 if (parameters.$cache !== undefined) {
24922 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24923 }
24924 })
24925 .error(function(data, status, headers, config) {
24926 deferred.reject({
24927 status: status,
24928 headers: headers,
24929 config: config,
24930 body: data
24931 });
24932 });
24933
24934 return deferred.promise;
24935 };
24936 /**
24937 *
24938 * @method
24939 * @name xos#User_List_GET
24940 *
24941 */
24942 xos.prototype.User_List_GET = function(parameters) {
24943 if (parameters === undefined) {
24944 parameters = {};
24945 }
24946 var deferred = $q.defer();
24947
24948 var domain = this.domain;
24949 var path = '/xos/users/';
24950
24951 var body;
24952 var queryParameters = {};
24953 var headers = {};
24954 var form = {};
24955
24956 if (parameters.$queryParameters) {
24957 Object.keys(parameters.$queryParameters)
24958 .forEach(function(parameterName) {
24959 var parameter = parameters.$queryParameters[parameterName];
24960 queryParameters[parameterName] = parameter;
24961 });
24962 }
24963
24964 var url = domain + path;
24965 var cached = parameters.$cache && parameters.$cache.get(url);
24966 if (cached !== undefined && parameters.$refresh !== true) {
24967 deferred.resolve(cached);
24968 return deferred.promise;
24969 }
24970 var options = {
24971 timeout: parameters.$timeout,
24972 method: 'GET',
24973 url: url,
24974 params: queryParameters,
24975 data: body,
24976 headers: headers
24977 };
24978 if (Object.keys(form).length > 0) {
24979 options.data = form;
24980 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
24981 options.transformRequest = xos.transformRequest;
24982 }
24983 $http(options)
24984 .success(function(data, status, headers, config) {
24985 deferred.resolve(data);
24986 if (parameters.$cache !== undefined) {
24987 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
24988 }
24989 })
24990 .error(function(data, status, headers, config) {
24991 deferred.reject({
24992 status: status,
24993 headers: headers,
24994 config: config,
24995 body: data
24996 });
24997 });
24998
24999 return deferred.promise;
25000 };
25001 /**
25002 *
25003 * @method
25004 * @name xos#User_List_POST
25005 * @param {string} password -
25006 * @param {string} last_login -
25007 * @param {string} email -
25008 * @param {string} username -
25009 * @param {string} firstname - person's given name
25010 * @param {string} lastname - person's surname
25011 * @param {string} phone - phone number contact
25012 * @param {string} user_url -
25013 * @param {string} site - Site this user will be homed too
25014 * @param {string} public_key - Public key string
25015 * @param {boolean} is_active -
25016 * @param {boolean} is_admin -
25017 * @param {boolean} is_staff -
25018 * @param {boolean} is_readonly -
25019 * @param {boolean} is_registering -
25020 * @param {boolean} is_appuser -
25021 * @param {string} login_page - send this user to a specific page on login
25022 * @param {string} enacted -
25023 * @param {string} policed -
25024 * @param {string} backend_status -
25025 * @param {boolean} deleted -
25026 * @param {boolean} write_protect -
25027 * @param {choice} timezone -
25028 *
25029 */
25030 xos.prototype.User_List_POST = function(parameters) {
25031 if (parameters === undefined) {
25032 parameters = {};
25033 }
25034 var deferred = $q.defer();
25035
25036 var domain = this.domain;
25037 var path = '/xos/users/';
25038
25039 var body;
25040 var queryParameters = {};
25041 var headers = {};
25042 var form = {};
25043
25044 if (parameters['password'] !== undefined) {
25045 form['password'] = parameters['password'];
25046 }
25047
25048 if (parameters['password'] === undefined) {
25049 deferred.reject(new Error('Missing required form parameter: password'));
25050 return deferred.promise;
25051 }
25052
25053 if (parameters['last_login'] !== undefined) {
25054 form['last_login'] = parameters['last_login'];
25055 }
25056
25057 if (parameters['last_login'] === undefined) {
25058 deferred.reject(new Error('Missing required form parameter: last_login'));
25059 return deferred.promise;
25060 }
25061
25062 if (parameters['email'] !== undefined) {
25063 form['email'] = parameters['email'];
25064 }
25065
25066 if (parameters['email'] === undefined) {
25067 deferred.reject(new Error('Missing required form parameter: email'));
25068 return deferred.promise;
25069 }
25070
25071 if (parameters['username'] !== undefined) {
25072 form['username'] = parameters['username'];
25073 }
25074
25075 if (parameters['username'] === undefined) {
25076 deferred.reject(new Error('Missing required form parameter: username'));
25077 return deferred.promise;
25078 }
25079
25080 if (parameters['firstname'] !== undefined) {
25081 form['firstname'] = parameters['firstname'];
25082 }
25083
25084 if (parameters['firstname'] === undefined) {
25085 deferred.reject(new Error('Missing required form parameter: firstname'));
25086 return deferred.promise;
25087 }
25088
25089 if (parameters['lastname'] !== undefined) {
25090 form['lastname'] = parameters['lastname'];
25091 }
25092
25093 if (parameters['lastname'] === undefined) {
25094 deferred.reject(new Error('Missing required form parameter: lastname'));
25095 return deferred.promise;
25096 }
25097
25098 if (parameters['phone'] !== undefined) {
25099 form['phone'] = parameters['phone'];
25100 }
25101
25102 if (parameters['user_url'] !== undefined) {
25103 form['user_url'] = parameters['user_url'];
25104 }
25105
25106 if (parameters['site'] !== undefined) {
25107 form['site'] = parameters['site'];
25108 }
25109
25110 if (parameters['site'] === undefined) {
25111 deferred.reject(new Error('Missing required form parameter: site'));
25112 return deferred.promise;
25113 }
25114
25115 if (parameters['public_key'] !== undefined) {
25116 form['public_key'] = parameters['public_key'];
25117 }
25118
25119 if (parameters['is_active'] !== undefined) {
25120 form['is_active'] = parameters['is_active'];
25121 }
25122
25123 if (parameters['is_admin'] !== undefined) {
25124 form['is_admin'] = parameters['is_admin'];
25125 }
25126
25127 if (parameters['is_staff'] !== undefined) {
25128 form['is_staff'] = parameters['is_staff'];
25129 }
25130
25131 if (parameters['is_readonly'] !== undefined) {
25132 form['is_readonly'] = parameters['is_readonly'];
25133 }
25134
25135 if (parameters['is_registering'] !== undefined) {
25136 form['is_registering'] = parameters['is_registering'];
25137 }
25138
25139 if (parameters['is_appuser'] !== undefined) {
25140 form['is_appuser'] = parameters['is_appuser'];
25141 }
25142
25143 if (parameters['login_page'] !== undefined) {
25144 form['login_page'] = parameters['login_page'];
25145 }
25146
25147 if (parameters['enacted'] !== undefined) {
25148 form['enacted'] = parameters['enacted'];
25149 }
25150
25151 if (parameters['policed'] !== undefined) {
25152 form['policed'] = parameters['policed'];
25153 }
25154
25155 if (parameters['backend_status'] !== undefined) {
25156 form['backend_status'] = parameters['backend_status'];
25157 }
25158
25159 if (parameters['backend_status'] === undefined) {
25160 deferred.reject(new Error('Missing required form parameter: backend_status'));
25161 return deferred.promise;
25162 }
25163
25164 if (parameters['deleted'] !== undefined) {
25165 form['deleted'] = parameters['deleted'];
25166 }
25167
25168 if (parameters['write_protect'] !== undefined) {
25169 form['write_protect'] = parameters['write_protect'];
25170 }
25171
25172 if (parameters['timezone'] !== undefined) {
25173 form['timezone'] = parameters['timezone'];
25174 }
25175
25176 if (parameters['timezone'] === undefined) {
25177 deferred.reject(new Error('Missing required form parameter: timezone'));
25178 return deferred.promise;
25179 }
25180
25181 if (parameters.$queryParameters) {
25182 Object.keys(parameters.$queryParameters)
25183 .forEach(function(parameterName) {
25184 var parameter = parameters.$queryParameters[parameterName];
25185 queryParameters[parameterName] = parameter;
25186 });
25187 }
25188
25189 var url = domain + path;
25190 var options = {
25191 timeout: parameters.$timeout,
25192 method: 'POST',
25193 url: url,
25194 params: queryParameters,
25195 data: body,
25196 headers: headers
25197 };
25198 if (Object.keys(form).length > 0) {
25199 options.data = form;
25200 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25201 options.transformRequest = xos.transformRequest;
25202 }
25203 $http(options)
25204 .success(function(data, status, headers, config) {
25205 deferred.resolve(data);
25206 if (parameters.$cache !== undefined) {
25207 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25208 }
25209 })
25210 .error(function(data, status, headers, config) {
25211 deferred.reject({
25212 status: status,
25213 headers: headers,
25214 config: config,
25215 body: data
25216 });
25217 });
25218
25219 return deferred.promise;
25220 };
25221 /**
25222 *
25223 * @method
25224 * @name xos#User_Detail_GET
25225 * @param {string} pk -
25226 *
25227 */
25228 xos.prototype.User_Detail_GET = function(parameters) {
25229 if (parameters === undefined) {
25230 parameters = {};
25231 }
25232 var deferred = $q.defer();
25233
25234 var domain = this.domain;
25235 var path = '/xos/users/{pk}/';
25236
25237 var body;
25238 var queryParameters = {};
25239 var headers = {};
25240 var form = {};
25241
25242 path = path.replace('{pk}', parameters['pk']);
25243
25244 if (parameters['pk'] === undefined) {
25245 deferred.reject(new Error('Missing required path parameter: pk'));
25246 return deferred.promise;
25247 }
25248
25249 if (parameters.$queryParameters) {
25250 Object.keys(parameters.$queryParameters)
25251 .forEach(function(parameterName) {
25252 var parameter = parameters.$queryParameters[parameterName];
25253 queryParameters[parameterName] = parameter;
25254 });
25255 }
25256
25257 var url = domain + path;
25258 var cached = parameters.$cache && parameters.$cache.get(url);
25259 if (cached !== undefined && parameters.$refresh !== true) {
25260 deferred.resolve(cached);
25261 return deferred.promise;
25262 }
25263 var options = {
25264 timeout: parameters.$timeout,
25265 method: 'GET',
25266 url: url,
25267 params: queryParameters,
25268 data: body,
25269 headers: headers
25270 };
25271 if (Object.keys(form).length > 0) {
25272 options.data = form;
25273 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25274 options.transformRequest = xos.transformRequest;
25275 }
25276 $http(options)
25277 .success(function(data, status, headers, config) {
25278 deferred.resolve(data);
25279 if (parameters.$cache !== undefined) {
25280 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25281 }
25282 })
25283 .error(function(data, status, headers, config) {
25284 deferred.reject({
25285 status: status,
25286 headers: headers,
25287 config: config,
25288 body: data
25289 });
25290 });
25291
25292 return deferred.promise;
25293 };
25294 /**
25295 *
25296 * @method
25297 * @name xos#User_Detail_PUT
25298 * @param {string} pk -
25299 * @param {string} password -
25300 * @param {string} last_login -
25301 * @param {string} email -
25302 * @param {string} username -
25303 * @param {string} firstname - person's given name
25304 * @param {string} lastname - person's surname
25305 * @param {string} phone - phone number contact
25306 * @param {string} user_url -
25307 * @param {string} site - Site this user will be homed too
25308 * @param {string} public_key - Public key string
25309 * @param {boolean} is_active -
25310 * @param {boolean} is_admin -
25311 * @param {boolean} is_staff -
25312 * @param {boolean} is_readonly -
25313 * @param {boolean} is_registering -
25314 * @param {boolean} is_appuser -
25315 * @param {string} login_page - send this user to a specific page on login
25316 * @param {string} enacted -
25317 * @param {string} policed -
25318 * @param {string} backend_status -
25319 * @param {boolean} deleted -
25320 * @param {boolean} write_protect -
25321 * @param {choice} timezone -
25322 *
25323 */
25324 xos.prototype.User_Detail_PUT = function(parameters) {
25325 if (parameters === undefined) {
25326 parameters = {};
25327 }
25328 var deferred = $q.defer();
25329
25330 var domain = this.domain;
25331 var path = '/xos/users/{pk}/';
25332
25333 var body;
25334 var queryParameters = {};
25335 var headers = {};
25336 var form = {};
25337
25338 path = path.replace('{pk}', parameters['pk']);
25339
25340 if (parameters['pk'] === undefined) {
25341 deferred.reject(new Error('Missing required path parameter: pk'));
25342 return deferred.promise;
25343 }
25344
25345 if (parameters['password'] !== undefined) {
25346 form['password'] = parameters['password'];
25347 }
25348
25349 if (parameters['password'] === undefined) {
25350 deferred.reject(new Error('Missing required form parameter: password'));
25351 return deferred.promise;
25352 }
25353
25354 if (parameters['last_login'] !== undefined) {
25355 form['last_login'] = parameters['last_login'];
25356 }
25357
25358 if (parameters['last_login'] === undefined) {
25359 deferred.reject(new Error('Missing required form parameter: last_login'));
25360 return deferred.promise;
25361 }
25362
25363 if (parameters['email'] !== undefined) {
25364 form['email'] = parameters['email'];
25365 }
25366
25367 if (parameters['email'] === undefined) {
25368 deferred.reject(new Error('Missing required form parameter: email'));
25369 return deferred.promise;
25370 }
25371
25372 if (parameters['username'] !== undefined) {
25373 form['username'] = parameters['username'];
25374 }
25375
25376 if (parameters['username'] === undefined) {
25377 deferred.reject(new Error('Missing required form parameter: username'));
25378 return deferred.promise;
25379 }
25380
25381 if (parameters['firstname'] !== undefined) {
25382 form['firstname'] = parameters['firstname'];
25383 }
25384
25385 if (parameters['firstname'] === undefined) {
25386 deferred.reject(new Error('Missing required form parameter: firstname'));
25387 return deferred.promise;
25388 }
25389
25390 if (parameters['lastname'] !== undefined) {
25391 form['lastname'] = parameters['lastname'];
25392 }
25393
25394 if (parameters['lastname'] === undefined) {
25395 deferred.reject(new Error('Missing required form parameter: lastname'));
25396 return deferred.promise;
25397 }
25398
25399 if (parameters['phone'] !== undefined) {
25400 form['phone'] = parameters['phone'];
25401 }
25402
25403 if (parameters['user_url'] !== undefined) {
25404 form['user_url'] = parameters['user_url'];
25405 }
25406
25407 if (parameters['site'] !== undefined) {
25408 form['site'] = parameters['site'];
25409 }
25410
25411 if (parameters['site'] === undefined) {
25412 deferred.reject(new Error('Missing required form parameter: site'));
25413 return deferred.promise;
25414 }
25415
25416 if (parameters['public_key'] !== undefined) {
25417 form['public_key'] = parameters['public_key'];
25418 }
25419
25420 if (parameters['is_active'] !== undefined) {
25421 form['is_active'] = parameters['is_active'];
25422 }
25423
25424 if (parameters['is_admin'] !== undefined) {
25425 form['is_admin'] = parameters['is_admin'];
25426 }
25427
25428 if (parameters['is_staff'] !== undefined) {
25429 form['is_staff'] = parameters['is_staff'];
25430 }
25431
25432 if (parameters['is_readonly'] !== undefined) {
25433 form['is_readonly'] = parameters['is_readonly'];
25434 }
25435
25436 if (parameters['is_registering'] !== undefined) {
25437 form['is_registering'] = parameters['is_registering'];
25438 }
25439
25440 if (parameters['is_appuser'] !== undefined) {
25441 form['is_appuser'] = parameters['is_appuser'];
25442 }
25443
25444 if (parameters['login_page'] !== undefined) {
25445 form['login_page'] = parameters['login_page'];
25446 }
25447
25448 if (parameters['enacted'] !== undefined) {
25449 form['enacted'] = parameters['enacted'];
25450 }
25451
25452 if (parameters['policed'] !== undefined) {
25453 form['policed'] = parameters['policed'];
25454 }
25455
25456 if (parameters['backend_status'] !== undefined) {
25457 form['backend_status'] = parameters['backend_status'];
25458 }
25459
25460 if (parameters['backend_status'] === undefined) {
25461 deferred.reject(new Error('Missing required form parameter: backend_status'));
25462 return deferred.promise;
25463 }
25464
25465 if (parameters['deleted'] !== undefined) {
25466 form['deleted'] = parameters['deleted'];
25467 }
25468
25469 if (parameters['write_protect'] !== undefined) {
25470 form['write_protect'] = parameters['write_protect'];
25471 }
25472
25473 if (parameters['timezone'] !== undefined) {
25474 form['timezone'] = parameters['timezone'];
25475 }
25476
25477 if (parameters['timezone'] === undefined) {
25478 deferred.reject(new Error('Missing required form parameter: timezone'));
25479 return deferred.promise;
25480 }
25481
25482 if (parameters.$queryParameters) {
25483 Object.keys(parameters.$queryParameters)
25484 .forEach(function(parameterName) {
25485 var parameter = parameters.$queryParameters[parameterName];
25486 queryParameters[parameterName] = parameter;
25487 });
25488 }
25489
25490 var url = domain + path;
25491 var options = {
25492 timeout: parameters.$timeout,
25493 method: 'PUT',
25494 url: url,
25495 params: queryParameters,
25496 data: body,
25497 headers: headers
25498 };
25499 if (Object.keys(form).length > 0) {
25500 options.data = form;
25501 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25502 options.transformRequest = xos.transformRequest;
25503 }
25504 $http(options)
25505 .success(function(data, status, headers, config) {
25506 deferred.resolve(data);
25507 if (parameters.$cache !== undefined) {
25508 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25509 }
25510 })
25511 .error(function(data, status, headers, config) {
25512 deferred.reject({
25513 status: status,
25514 headers: headers,
25515 config: config,
25516 body: data
25517 });
25518 });
25519
25520 return deferred.promise;
25521 };
25522 /**
25523 *
25524 * @method
25525 * @name xos#User_Detail_PATCH
25526 * @param {string} pk -
25527 * @param {string} password -
25528 * @param {string} last_login -
25529 * @param {string} email -
25530 * @param {string} username -
25531 * @param {string} firstname - person's given name
25532 * @param {string} lastname - person's surname
25533 * @param {string} phone - phone number contact
25534 * @param {string} user_url -
25535 * @param {string} site - Site this user will be homed too
25536 * @param {string} public_key - Public key string
25537 * @param {boolean} is_active -
25538 * @param {boolean} is_admin -
25539 * @param {boolean} is_staff -
25540 * @param {boolean} is_readonly -
25541 * @param {boolean} is_registering -
25542 * @param {boolean} is_appuser -
25543 * @param {string} login_page - send this user to a specific page on login
25544 * @param {string} enacted -
25545 * @param {string} policed -
25546 * @param {string} backend_status -
25547 * @param {boolean} deleted -
25548 * @param {boolean} write_protect -
25549 * @param {choice} timezone -
25550 *
25551 */
25552 xos.prototype.User_Detail_PATCH = function(parameters) {
25553 if (parameters === undefined) {
25554 parameters = {};
25555 }
25556 var deferred = $q.defer();
25557
25558 var domain = this.domain;
25559 var path = '/xos/users/{pk}/';
25560
25561 var body;
25562 var queryParameters = {};
25563 var headers = {};
25564 var form = {};
25565
25566 path = path.replace('{pk}', parameters['pk']);
25567
25568 if (parameters['pk'] === undefined) {
25569 deferred.reject(new Error('Missing required path parameter: pk'));
25570 return deferred.promise;
25571 }
25572
25573 if (parameters['password'] !== undefined) {
25574 form['password'] = parameters['password'];
25575 }
25576
25577 if (parameters['last_login'] !== undefined) {
25578 form['last_login'] = parameters['last_login'];
25579 }
25580
25581 if (parameters['email'] !== undefined) {
25582 form['email'] = parameters['email'];
25583 }
25584
25585 if (parameters['username'] !== undefined) {
25586 form['username'] = parameters['username'];
25587 }
25588
25589 if (parameters['firstname'] !== undefined) {
25590 form['firstname'] = parameters['firstname'];
25591 }
25592
25593 if (parameters['lastname'] !== undefined) {
25594 form['lastname'] = parameters['lastname'];
25595 }
25596
25597 if (parameters['phone'] !== undefined) {
25598 form['phone'] = parameters['phone'];
25599 }
25600
25601 if (parameters['user_url'] !== undefined) {
25602 form['user_url'] = parameters['user_url'];
25603 }
25604
25605 if (parameters['site'] !== undefined) {
25606 form['site'] = parameters['site'];
25607 }
25608
25609 if (parameters['public_key'] !== undefined) {
25610 form['public_key'] = parameters['public_key'];
25611 }
25612
25613 if (parameters['is_active'] !== undefined) {
25614 form['is_active'] = parameters['is_active'];
25615 }
25616
25617 if (parameters['is_admin'] !== undefined) {
25618 form['is_admin'] = parameters['is_admin'];
25619 }
25620
25621 if (parameters['is_staff'] !== undefined) {
25622 form['is_staff'] = parameters['is_staff'];
25623 }
25624
25625 if (parameters['is_readonly'] !== undefined) {
25626 form['is_readonly'] = parameters['is_readonly'];
25627 }
25628
25629 if (parameters['is_registering'] !== undefined) {
25630 form['is_registering'] = parameters['is_registering'];
25631 }
25632
25633 if (parameters['is_appuser'] !== undefined) {
25634 form['is_appuser'] = parameters['is_appuser'];
25635 }
25636
25637 if (parameters['login_page'] !== undefined) {
25638 form['login_page'] = parameters['login_page'];
25639 }
25640
25641 if (parameters['enacted'] !== undefined) {
25642 form['enacted'] = parameters['enacted'];
25643 }
25644
25645 if (parameters['policed'] !== undefined) {
25646 form['policed'] = parameters['policed'];
25647 }
25648
25649 if (parameters['backend_status'] !== undefined) {
25650 form['backend_status'] = parameters['backend_status'];
25651 }
25652
25653 if (parameters['deleted'] !== undefined) {
25654 form['deleted'] = parameters['deleted'];
25655 }
25656
25657 if (parameters['write_protect'] !== undefined) {
25658 form['write_protect'] = parameters['write_protect'];
25659 }
25660
25661 if (parameters['timezone'] !== undefined) {
25662 form['timezone'] = parameters['timezone'];
25663 }
25664
25665 if (parameters.$queryParameters) {
25666 Object.keys(parameters.$queryParameters)
25667 .forEach(function(parameterName) {
25668 var parameter = parameters.$queryParameters[parameterName];
25669 queryParameters[parameterName] = parameter;
25670 });
25671 }
25672
25673 var url = domain + path;
25674 var options = {
25675 timeout: parameters.$timeout,
25676 method: 'PATCH',
25677 url: url,
25678 params: queryParameters,
25679 data: body,
25680 headers: headers
25681 };
25682 if (Object.keys(form).length > 0) {
25683 options.data = form;
25684 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25685 options.transformRequest = xos.transformRequest;
25686 }
25687 $http(options)
25688 .success(function(data, status, headers, config) {
25689 deferred.resolve(data);
25690 if (parameters.$cache !== undefined) {
25691 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25692 }
25693 })
25694 .error(function(data, status, headers, config) {
25695 deferred.reject({
25696 status: status,
25697 headers: headers,
25698 config: config,
25699 body: data
25700 });
25701 });
25702
25703 return deferred.promise;
25704 };
25705 /**
25706 *
25707 * @method
25708 * @name xos#User_Detail_DELETE
25709 * @param {string} pk -
25710 *
25711 */
25712 xos.prototype.User_Detail_DELETE = function(parameters) {
25713 if (parameters === undefined) {
25714 parameters = {};
25715 }
25716 var deferred = $q.defer();
25717
25718 var domain = this.domain;
25719 var path = '/xos/users/{pk}/';
25720
25721 var body;
25722 var queryParameters = {};
25723 var headers = {};
25724 var form = {};
25725
25726 path = path.replace('{pk}', parameters['pk']);
25727
25728 if (parameters['pk'] === undefined) {
25729 deferred.reject(new Error('Missing required path parameter: pk'));
25730 return deferred.promise;
25731 }
25732
25733 if (parameters.$queryParameters) {
25734 Object.keys(parameters.$queryParameters)
25735 .forEach(function(parameterName) {
25736 var parameter = parameters.$queryParameters[parameterName];
25737 queryParameters[parameterName] = parameter;
25738 });
25739 }
25740
25741 var url = domain + path;
25742 var options = {
25743 timeout: parameters.$timeout,
25744 method: 'DELETE',
25745 url: url,
25746 params: queryParameters,
25747 data: body,
25748 headers: headers
25749 };
25750 if (Object.keys(form).length > 0) {
25751 options.data = form;
25752 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25753 options.transformRequest = xos.transformRequest;
25754 }
25755 $http(options)
25756 .success(function(data, status, headers, config) {
25757 deferred.resolve(data);
25758 if (parameters.$cache !== undefined) {
25759 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25760 }
25761 })
25762 .error(function(data, status, headers, config) {
25763 deferred.reject({
25764 status: status,
25765 headers: headers,
25766 config: config,
25767 body: data
25768 });
25769 });
25770
25771 return deferred.promise;
25772 };
25773 /**
25774 *
25775 * @method
25776 * @name xos#Deployment_List_GET
25777 *
25778 */
25779 xos.prototype.Deployment_List_GET = function(parameters) {
25780 if (parameters === undefined) {
25781 parameters = {};
25782 }
25783 var deferred = $q.defer();
25784
25785 var domain = this.domain;
25786 var path = '/xos/deployments/';
25787
25788 var body;
25789 var queryParameters = {};
25790 var headers = {};
25791 var form = {};
25792
25793 if (parameters.$queryParameters) {
25794 Object.keys(parameters.$queryParameters)
25795 .forEach(function(parameterName) {
25796 var parameter = parameters.$queryParameters[parameterName];
25797 queryParameters[parameterName] = parameter;
25798 });
25799 }
25800
25801 var url = domain + path;
25802 var cached = parameters.$cache && parameters.$cache.get(url);
25803 if (cached !== undefined && parameters.$refresh !== true) {
25804 deferred.resolve(cached);
25805 return deferred.promise;
25806 }
25807 var options = {
25808 timeout: parameters.$timeout,
25809 method: 'GET',
25810 url: url,
25811 params: queryParameters,
25812 data: body,
25813 headers: headers
25814 };
25815 if (Object.keys(form).length > 0) {
25816 options.data = form;
25817 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25818 options.transformRequest = xos.transformRequest;
25819 }
25820 $http(options)
25821 .success(function(data, status, headers, config) {
25822 deferred.resolve(data);
25823 if (parameters.$cache !== undefined) {
25824 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25825 }
25826 })
25827 .error(function(data, status, headers, config) {
25828 deferred.reject({
25829 status: status,
25830 headers: headers,
25831 config: config,
25832 body: data
25833 });
25834 });
25835
25836 return deferred.promise;
25837 };
25838 /**
25839 *
25840 * @method
25841 * @name xos#Deployment_List_POST
25842 * @param {string} enacted -
25843 * @param {string} policed -
25844 * @param {string} backend_register -
25845 * @param {string} backend_status -
25846 * @param {boolean} deleted -
25847 * @param {boolean} write_protect -
25848 * @param {boolean} lazy_blocked -
25849 * @param {boolean} no_sync -
25850 * @param {string} name - Name of the Deployment
25851 * @param {string} accessControl - Access control list that specifies which sites/users may use nodes in this deployment
25852 *
25853 */
25854 xos.prototype.Deployment_List_POST = function(parameters) {
25855 if (parameters === undefined) {
25856 parameters = {};
25857 }
25858 var deferred = $q.defer();
25859
25860 var domain = this.domain;
25861 var path = '/xos/deployments/';
25862
25863 var body;
25864 var queryParameters = {};
25865 var headers = {};
25866 var form = {};
25867
25868 if (parameters['enacted'] !== undefined) {
25869 form['enacted'] = parameters['enacted'];
25870 }
25871
25872 if (parameters['policed'] !== undefined) {
25873 form['policed'] = parameters['policed'];
25874 }
25875
25876 if (parameters['backend_register'] !== undefined) {
25877 form['backend_register'] = parameters['backend_register'];
25878 }
25879
25880 if (parameters['backend_status'] !== undefined) {
25881 form['backend_status'] = parameters['backend_status'];
25882 }
25883
25884 if (parameters['backend_status'] === undefined) {
25885 deferred.reject(new Error('Missing required form parameter: backend_status'));
25886 return deferred.promise;
25887 }
25888
25889 if (parameters['deleted'] !== undefined) {
25890 form['deleted'] = parameters['deleted'];
25891 }
25892
25893 if (parameters['write_protect'] !== undefined) {
25894 form['write_protect'] = parameters['write_protect'];
25895 }
25896
25897 if (parameters['lazy_blocked'] !== undefined) {
25898 form['lazy_blocked'] = parameters['lazy_blocked'];
25899 }
25900
25901 if (parameters['no_sync'] !== undefined) {
25902 form['no_sync'] = parameters['no_sync'];
25903 }
25904
25905 if (parameters['name'] !== undefined) {
25906 form['name'] = parameters['name'];
25907 }
25908
25909 if (parameters['name'] === undefined) {
25910 deferred.reject(new Error('Missing required form parameter: name'));
25911 return deferred.promise;
25912 }
25913
25914 if (parameters['accessControl'] !== undefined) {
25915 form['accessControl'] = parameters['accessControl'];
25916 }
25917
25918 if (parameters['accessControl'] === undefined) {
25919 deferred.reject(new Error('Missing required form parameter: accessControl'));
25920 return deferred.promise;
25921 }
25922
25923 if (parameters.$queryParameters) {
25924 Object.keys(parameters.$queryParameters)
25925 .forEach(function(parameterName) {
25926 var parameter = parameters.$queryParameters[parameterName];
25927 queryParameters[parameterName] = parameter;
25928 });
25929 }
25930
25931 var url = domain + path;
25932 var options = {
25933 timeout: parameters.$timeout,
25934 method: 'POST',
25935 url: url,
25936 params: queryParameters,
25937 data: body,
25938 headers: headers
25939 };
25940 if (Object.keys(form).length > 0) {
25941 options.data = form;
25942 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
25943 options.transformRequest = xos.transformRequest;
25944 }
25945 $http(options)
25946 .success(function(data, status, headers, config) {
25947 deferred.resolve(data);
25948 if (parameters.$cache !== undefined) {
25949 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
25950 }
25951 })
25952 .error(function(data, status, headers, config) {
25953 deferred.reject({
25954 status: status,
25955 headers: headers,
25956 config: config,
25957 body: data
25958 });
25959 });
25960
25961 return deferred.promise;
25962 };
25963 /**
25964 *
25965 * @method
25966 * @name xos#Deployment_Detail_GET
25967 * @param {string} pk -
25968 *
25969 */
25970 xos.prototype.Deployment_Detail_GET = function(parameters) {
25971 if (parameters === undefined) {
25972 parameters = {};
25973 }
25974 var deferred = $q.defer();
25975
25976 var domain = this.domain;
25977 var path = '/xos/deployments/{pk}/';
25978
25979 var body;
25980 var queryParameters = {};
25981 var headers = {};
25982 var form = {};
25983
25984 path = path.replace('{pk}', parameters['pk']);
25985
25986 if (parameters['pk'] === undefined) {
25987 deferred.reject(new Error('Missing required path parameter: pk'));
25988 return deferred.promise;
25989 }
25990
25991 if (parameters.$queryParameters) {
25992 Object.keys(parameters.$queryParameters)
25993 .forEach(function(parameterName) {
25994 var parameter = parameters.$queryParameters[parameterName];
25995 queryParameters[parameterName] = parameter;
25996 });
25997 }
25998
25999 var url = domain + path;
26000 var cached = parameters.$cache && parameters.$cache.get(url);
26001 if (cached !== undefined && parameters.$refresh !== true) {
26002 deferred.resolve(cached);
26003 return deferred.promise;
26004 }
26005 var options = {
26006 timeout: parameters.$timeout,
26007 method: 'GET',
26008 url: url,
26009 params: queryParameters,
26010 data: body,
26011 headers: headers
26012 };
26013 if (Object.keys(form).length > 0) {
26014 options.data = form;
26015 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26016 options.transformRequest = xos.transformRequest;
26017 }
26018 $http(options)
26019 .success(function(data, status, headers, config) {
26020 deferred.resolve(data);
26021 if (parameters.$cache !== undefined) {
26022 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26023 }
26024 })
26025 .error(function(data, status, headers, config) {
26026 deferred.reject({
26027 status: status,
26028 headers: headers,
26029 config: config,
26030 body: data
26031 });
26032 });
26033
26034 return deferred.promise;
26035 };
26036 /**
26037 *
26038 * @method
26039 * @name xos#Deployment_Detail_PUT
26040 * @param {string} pk -
26041 * @param {string} enacted -
26042 * @param {string} policed -
26043 * @param {string} backend_register -
26044 * @param {string} backend_status -
26045 * @param {boolean} deleted -
26046 * @param {boolean} write_protect -
26047 * @param {boolean} lazy_blocked -
26048 * @param {boolean} no_sync -
26049 * @param {string} name - Name of the Deployment
26050 * @param {string} accessControl - Access control list that specifies which sites/users may use nodes in this deployment
26051 *
26052 */
26053 xos.prototype.Deployment_Detail_PUT = function(parameters) {
26054 if (parameters === undefined) {
26055 parameters = {};
26056 }
26057 var deferred = $q.defer();
26058
26059 var domain = this.domain;
26060 var path = '/xos/deployments/{pk}/';
26061
26062 var body;
26063 var queryParameters = {};
26064 var headers = {};
26065 var form = {};
26066
26067 path = path.replace('{pk}', parameters['pk']);
26068
26069 if (parameters['pk'] === undefined) {
26070 deferred.reject(new Error('Missing required path parameter: pk'));
26071 return deferred.promise;
26072 }
26073
26074 if (parameters['enacted'] !== undefined) {
26075 form['enacted'] = parameters['enacted'];
26076 }
26077
26078 if (parameters['policed'] !== undefined) {
26079 form['policed'] = parameters['policed'];
26080 }
26081
26082 if (parameters['backend_register'] !== undefined) {
26083 form['backend_register'] = parameters['backend_register'];
26084 }
26085
26086 if (parameters['backend_status'] !== undefined) {
26087 form['backend_status'] = parameters['backend_status'];
26088 }
26089
26090 if (parameters['backend_status'] === undefined) {
26091 deferred.reject(new Error('Missing required form parameter: backend_status'));
26092 return deferred.promise;
26093 }
26094
26095 if (parameters['deleted'] !== undefined) {
26096 form['deleted'] = parameters['deleted'];
26097 }
26098
26099 if (parameters['write_protect'] !== undefined) {
26100 form['write_protect'] = parameters['write_protect'];
26101 }
26102
26103 if (parameters['lazy_blocked'] !== undefined) {
26104 form['lazy_blocked'] = parameters['lazy_blocked'];
26105 }
26106
26107 if (parameters['no_sync'] !== undefined) {
26108 form['no_sync'] = parameters['no_sync'];
26109 }
26110
26111 if (parameters['name'] !== undefined) {
26112 form['name'] = parameters['name'];
26113 }
26114
26115 if (parameters['name'] === undefined) {
26116 deferred.reject(new Error('Missing required form parameter: name'));
26117 return deferred.promise;
26118 }
26119
26120 if (parameters['accessControl'] !== undefined) {
26121 form['accessControl'] = parameters['accessControl'];
26122 }
26123
26124 if (parameters['accessControl'] === undefined) {
26125 deferred.reject(new Error('Missing required form parameter: accessControl'));
26126 return deferred.promise;
26127 }
26128
26129 if (parameters.$queryParameters) {
26130 Object.keys(parameters.$queryParameters)
26131 .forEach(function(parameterName) {
26132 var parameter = parameters.$queryParameters[parameterName];
26133 queryParameters[parameterName] = parameter;
26134 });
26135 }
26136
26137 var url = domain + path;
26138 var options = {
26139 timeout: parameters.$timeout,
26140 method: 'PUT',
26141 url: url,
26142 params: queryParameters,
26143 data: body,
26144 headers: headers
26145 };
26146 if (Object.keys(form).length > 0) {
26147 options.data = form;
26148 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26149 options.transformRequest = xos.transformRequest;
26150 }
26151 $http(options)
26152 .success(function(data, status, headers, config) {
26153 deferred.resolve(data);
26154 if (parameters.$cache !== undefined) {
26155 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26156 }
26157 })
26158 .error(function(data, status, headers, config) {
26159 deferred.reject({
26160 status: status,
26161 headers: headers,
26162 config: config,
26163 body: data
26164 });
26165 });
26166
26167 return deferred.promise;
26168 };
26169 /**
26170 *
26171 * @method
26172 * @name xos#Deployment_Detail_PATCH
26173 * @param {string} pk -
26174 * @param {string} enacted -
26175 * @param {string} policed -
26176 * @param {string} backend_register -
26177 * @param {string} backend_status -
26178 * @param {boolean} deleted -
26179 * @param {boolean} write_protect -
26180 * @param {boolean} lazy_blocked -
26181 * @param {boolean} no_sync -
26182 * @param {string} name - Name of the Deployment
26183 * @param {string} accessControl - Access control list that specifies which sites/users may use nodes in this deployment
26184 *
26185 */
26186 xos.prototype.Deployment_Detail_PATCH = function(parameters) {
26187 if (parameters === undefined) {
26188 parameters = {};
26189 }
26190 var deferred = $q.defer();
26191
26192 var domain = this.domain;
26193 var path = '/xos/deployments/{pk}/';
26194
26195 var body;
26196 var queryParameters = {};
26197 var headers = {};
26198 var form = {};
26199
26200 path = path.replace('{pk}', parameters['pk']);
26201
26202 if (parameters['pk'] === undefined) {
26203 deferred.reject(new Error('Missing required path parameter: pk'));
26204 return deferred.promise;
26205 }
26206
26207 if (parameters['enacted'] !== undefined) {
26208 form['enacted'] = parameters['enacted'];
26209 }
26210
26211 if (parameters['policed'] !== undefined) {
26212 form['policed'] = parameters['policed'];
26213 }
26214
26215 if (parameters['backend_register'] !== undefined) {
26216 form['backend_register'] = parameters['backend_register'];
26217 }
26218
26219 if (parameters['backend_status'] !== undefined) {
26220 form['backend_status'] = parameters['backend_status'];
26221 }
26222
26223 if (parameters['deleted'] !== undefined) {
26224 form['deleted'] = parameters['deleted'];
26225 }
26226
26227 if (parameters['write_protect'] !== undefined) {
26228 form['write_protect'] = parameters['write_protect'];
26229 }
26230
26231 if (parameters['lazy_blocked'] !== undefined) {
26232 form['lazy_blocked'] = parameters['lazy_blocked'];
26233 }
26234
26235 if (parameters['no_sync'] !== undefined) {
26236 form['no_sync'] = parameters['no_sync'];
26237 }
26238
26239 if (parameters['name'] !== undefined) {
26240 form['name'] = parameters['name'];
26241 }
26242
26243 if (parameters['accessControl'] !== undefined) {
26244 form['accessControl'] = parameters['accessControl'];
26245 }
26246
26247 if (parameters.$queryParameters) {
26248 Object.keys(parameters.$queryParameters)
26249 .forEach(function(parameterName) {
26250 var parameter = parameters.$queryParameters[parameterName];
26251 queryParameters[parameterName] = parameter;
26252 });
26253 }
26254
26255 var url = domain + path;
26256 var options = {
26257 timeout: parameters.$timeout,
26258 method: 'PATCH',
26259 url: url,
26260 params: queryParameters,
26261 data: body,
26262 headers: headers
26263 };
26264 if (Object.keys(form).length > 0) {
26265 options.data = form;
26266 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26267 options.transformRequest = xos.transformRequest;
26268 }
26269 $http(options)
26270 .success(function(data, status, headers, config) {
26271 deferred.resolve(data);
26272 if (parameters.$cache !== undefined) {
26273 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26274 }
26275 })
26276 .error(function(data, status, headers, config) {
26277 deferred.reject({
26278 status: status,
26279 headers: headers,
26280 config: config,
26281 body: data
26282 });
26283 });
26284
26285 return deferred.promise;
26286 };
26287 /**
26288 *
26289 * @method
26290 * @name xos#Deployment_Detail_DELETE
26291 * @param {string} pk -
26292 *
26293 */
26294 xos.prototype.Deployment_Detail_DELETE = function(parameters) {
26295 if (parameters === undefined) {
26296 parameters = {};
26297 }
26298 var deferred = $q.defer();
26299
26300 var domain = this.domain;
26301 var path = '/xos/deployments/{pk}/';
26302
26303 var body;
26304 var queryParameters = {};
26305 var headers = {};
26306 var form = {};
26307
26308 path = path.replace('{pk}', parameters['pk']);
26309
26310 if (parameters['pk'] === undefined) {
26311 deferred.reject(new Error('Missing required path parameter: pk'));
26312 return deferred.promise;
26313 }
26314
26315 if (parameters.$queryParameters) {
26316 Object.keys(parameters.$queryParameters)
26317 .forEach(function(parameterName) {
26318 var parameter = parameters.$queryParameters[parameterName];
26319 queryParameters[parameterName] = parameter;
26320 });
26321 }
26322
26323 var url = domain + path;
26324 var options = {
26325 timeout: parameters.$timeout,
26326 method: 'DELETE',
26327 url: url,
26328 params: queryParameters,
26329 data: body,
26330 headers: headers
26331 };
26332 if (Object.keys(form).length > 0) {
26333 options.data = form;
26334 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26335 options.transformRequest = xos.transformRequest;
26336 }
26337 $http(options)
26338 .success(function(data, status, headers, config) {
26339 deferred.resolve(data);
26340 if (parameters.$cache !== undefined) {
26341 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26342 }
26343 })
26344 .error(function(data, status, headers, config) {
26345 deferred.reject({
26346 status: status,
26347 headers: headers,
26348 config: config,
26349 body: data
26350 });
26351 });
26352
26353 return deferred.promise;
26354 };
26355 /**
26356 *
26357 * @method
26358 * @name xos#Reservation_List_GET
26359 *
26360 */
26361 xos.prototype.Reservation_List_GET = function(parameters) {
26362 if (parameters === undefined) {
26363 parameters = {};
26364 }
26365 var deferred = $q.defer();
26366
26367 var domain = this.domain;
26368 var path = '/xos/reservations/';
26369
26370 var body;
26371 var queryParameters = {};
26372 var headers = {};
26373 var form = {};
26374
26375 if (parameters.$queryParameters) {
26376 Object.keys(parameters.$queryParameters)
26377 .forEach(function(parameterName) {
26378 var parameter = parameters.$queryParameters[parameterName];
26379 queryParameters[parameterName] = parameter;
26380 });
26381 }
26382
26383 var url = domain + path;
26384 var cached = parameters.$cache && parameters.$cache.get(url);
26385 if (cached !== undefined && parameters.$refresh !== true) {
26386 deferred.resolve(cached);
26387 return deferred.promise;
26388 }
26389 var options = {
26390 timeout: parameters.$timeout,
26391 method: 'GET',
26392 url: url,
26393 params: queryParameters,
26394 data: body,
26395 headers: headers
26396 };
26397 if (Object.keys(form).length > 0) {
26398 options.data = form;
26399 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26400 options.transformRequest = xos.transformRequest;
26401 }
26402 $http(options)
26403 .success(function(data, status, headers, config) {
26404 deferred.resolve(data);
26405 if (parameters.$cache !== undefined) {
26406 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26407 }
26408 })
26409 .error(function(data, status, headers, config) {
26410 deferred.reject({
26411 status: status,
26412 headers: headers,
26413 config: config,
26414 body: data
26415 });
26416 });
26417
26418 return deferred.promise;
26419 };
26420 /**
26421 *
26422 * @method
26423 * @name xos#Reservation_List_POST
26424 * @param {string} enacted -
26425 * @param {string} policed -
26426 * @param {string} backend_register -
26427 * @param {string} backend_status -
26428 * @param {boolean} deleted -
26429 * @param {boolean} write_protect -
26430 * @param {boolean} lazy_blocked -
26431 * @param {boolean} no_sync -
26432 * @param {string} startTime -
26433 * @param {string} slice -
26434 * @param {integer} duration -
26435 *
26436 */
26437 xos.prototype.Reservation_List_POST = function(parameters) {
26438 if (parameters === undefined) {
26439 parameters = {};
26440 }
26441 var deferred = $q.defer();
26442
26443 var domain = this.domain;
26444 var path = '/xos/reservations/';
26445
26446 var body;
26447 var queryParameters = {};
26448 var headers = {};
26449 var form = {};
26450
26451 if (parameters['enacted'] !== undefined) {
26452 form['enacted'] = parameters['enacted'];
26453 }
26454
26455 if (parameters['policed'] !== undefined) {
26456 form['policed'] = parameters['policed'];
26457 }
26458
26459 if (parameters['backend_register'] !== undefined) {
26460 form['backend_register'] = parameters['backend_register'];
26461 }
26462
26463 if (parameters['backend_status'] !== undefined) {
26464 form['backend_status'] = parameters['backend_status'];
26465 }
26466
26467 if (parameters['backend_status'] === undefined) {
26468 deferred.reject(new Error('Missing required form parameter: backend_status'));
26469 return deferred.promise;
26470 }
26471
26472 if (parameters['deleted'] !== undefined) {
26473 form['deleted'] = parameters['deleted'];
26474 }
26475
26476 if (parameters['write_protect'] !== undefined) {
26477 form['write_protect'] = parameters['write_protect'];
26478 }
26479
26480 if (parameters['lazy_blocked'] !== undefined) {
26481 form['lazy_blocked'] = parameters['lazy_blocked'];
26482 }
26483
26484 if (parameters['no_sync'] !== undefined) {
26485 form['no_sync'] = parameters['no_sync'];
26486 }
26487
26488 if (parameters['startTime'] !== undefined) {
26489 form['startTime'] = parameters['startTime'];
26490 }
26491
26492 if (parameters['startTime'] === undefined) {
26493 deferred.reject(new Error('Missing required form parameter: startTime'));
26494 return deferred.promise;
26495 }
26496
26497 if (parameters['slice'] !== undefined) {
26498 form['slice'] = parameters['slice'];
26499 }
26500
26501 if (parameters['slice'] === undefined) {
26502 deferred.reject(new Error('Missing required form parameter: slice'));
26503 return deferred.promise;
26504 }
26505
26506 if (parameters['duration'] !== undefined) {
26507 form['duration'] = parameters['duration'];
26508 }
26509
26510 if (parameters['duration'] === undefined) {
26511 deferred.reject(new Error('Missing required form parameter: duration'));
26512 return deferred.promise;
26513 }
26514
26515 if (parameters.$queryParameters) {
26516 Object.keys(parameters.$queryParameters)
26517 .forEach(function(parameterName) {
26518 var parameter = parameters.$queryParameters[parameterName];
26519 queryParameters[parameterName] = parameter;
26520 });
26521 }
26522
26523 var url = domain + path;
26524 var options = {
26525 timeout: parameters.$timeout,
26526 method: 'POST',
26527 url: url,
26528 params: queryParameters,
26529 data: body,
26530 headers: headers
26531 };
26532 if (Object.keys(form).length > 0) {
26533 options.data = form;
26534 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26535 options.transformRequest = xos.transformRequest;
26536 }
26537 $http(options)
26538 .success(function(data, status, headers, config) {
26539 deferred.resolve(data);
26540 if (parameters.$cache !== undefined) {
26541 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26542 }
26543 })
26544 .error(function(data, status, headers, config) {
26545 deferred.reject({
26546 status: status,
26547 headers: headers,
26548 config: config,
26549 body: data
26550 });
26551 });
26552
26553 return deferred.promise;
26554 };
26555 /**
26556 *
26557 * @method
26558 * @name xos#Reservation_Detail_GET
26559 * @param {string} pk -
26560 *
26561 */
26562 xos.prototype.Reservation_Detail_GET = function(parameters) {
26563 if (parameters === undefined) {
26564 parameters = {};
26565 }
26566 var deferred = $q.defer();
26567
26568 var domain = this.domain;
26569 var path = '/xos/reservations/{pk}/';
26570
26571 var body;
26572 var queryParameters = {};
26573 var headers = {};
26574 var form = {};
26575
26576 path = path.replace('{pk}', parameters['pk']);
26577
26578 if (parameters['pk'] === undefined) {
26579 deferred.reject(new Error('Missing required path parameter: pk'));
26580 return deferred.promise;
26581 }
26582
26583 if (parameters.$queryParameters) {
26584 Object.keys(parameters.$queryParameters)
26585 .forEach(function(parameterName) {
26586 var parameter = parameters.$queryParameters[parameterName];
26587 queryParameters[parameterName] = parameter;
26588 });
26589 }
26590
26591 var url = domain + path;
26592 var cached = parameters.$cache && parameters.$cache.get(url);
26593 if (cached !== undefined && parameters.$refresh !== true) {
26594 deferred.resolve(cached);
26595 return deferred.promise;
26596 }
26597 var options = {
26598 timeout: parameters.$timeout,
26599 method: 'GET',
26600 url: url,
26601 params: queryParameters,
26602 data: body,
26603 headers: headers
26604 };
26605 if (Object.keys(form).length > 0) {
26606 options.data = form;
26607 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26608 options.transformRequest = xos.transformRequest;
26609 }
26610 $http(options)
26611 .success(function(data, status, headers, config) {
26612 deferred.resolve(data);
26613 if (parameters.$cache !== undefined) {
26614 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26615 }
26616 })
26617 .error(function(data, status, headers, config) {
26618 deferred.reject({
26619 status: status,
26620 headers: headers,
26621 config: config,
26622 body: data
26623 });
26624 });
26625
26626 return deferred.promise;
26627 };
26628 /**
26629 *
26630 * @method
26631 * @name xos#Reservation_Detail_PUT
26632 * @param {string} pk -
26633 * @param {string} enacted -
26634 * @param {string} policed -
26635 * @param {string} backend_register -
26636 * @param {string} backend_status -
26637 * @param {boolean} deleted -
26638 * @param {boolean} write_protect -
26639 * @param {boolean} lazy_blocked -
26640 * @param {boolean} no_sync -
26641 * @param {string} startTime -
26642 * @param {string} slice -
26643 * @param {integer} duration -
26644 *
26645 */
26646 xos.prototype.Reservation_Detail_PUT = function(parameters) {
26647 if (parameters === undefined) {
26648 parameters = {};
26649 }
26650 var deferred = $q.defer();
26651
26652 var domain = this.domain;
26653 var path = '/xos/reservations/{pk}/';
26654
26655 var body;
26656 var queryParameters = {};
26657 var headers = {};
26658 var form = {};
26659
26660 path = path.replace('{pk}', parameters['pk']);
26661
26662 if (parameters['pk'] === undefined) {
26663 deferred.reject(new Error('Missing required path parameter: pk'));
26664 return deferred.promise;
26665 }
26666
26667 if (parameters['enacted'] !== undefined) {
26668 form['enacted'] = parameters['enacted'];
26669 }
26670
26671 if (parameters['policed'] !== undefined) {
26672 form['policed'] = parameters['policed'];
26673 }
26674
26675 if (parameters['backend_register'] !== undefined) {
26676 form['backend_register'] = parameters['backend_register'];
26677 }
26678
26679 if (parameters['backend_status'] !== undefined) {
26680 form['backend_status'] = parameters['backend_status'];
26681 }
26682
26683 if (parameters['backend_status'] === undefined) {
26684 deferred.reject(new Error('Missing required form parameter: backend_status'));
26685 return deferred.promise;
26686 }
26687
26688 if (parameters['deleted'] !== undefined) {
26689 form['deleted'] = parameters['deleted'];
26690 }
26691
26692 if (parameters['write_protect'] !== undefined) {
26693 form['write_protect'] = parameters['write_protect'];
26694 }
26695
26696 if (parameters['lazy_blocked'] !== undefined) {
26697 form['lazy_blocked'] = parameters['lazy_blocked'];
26698 }
26699
26700 if (parameters['no_sync'] !== undefined) {
26701 form['no_sync'] = parameters['no_sync'];
26702 }
26703
26704 if (parameters['startTime'] !== undefined) {
26705 form['startTime'] = parameters['startTime'];
26706 }
26707
26708 if (parameters['startTime'] === undefined) {
26709 deferred.reject(new Error('Missing required form parameter: startTime'));
26710 return deferred.promise;
26711 }
26712
26713 if (parameters['slice'] !== undefined) {
26714 form['slice'] = parameters['slice'];
26715 }
26716
26717 if (parameters['slice'] === undefined) {
26718 deferred.reject(new Error('Missing required form parameter: slice'));
26719 return deferred.promise;
26720 }
26721
26722 if (parameters['duration'] !== undefined) {
26723 form['duration'] = parameters['duration'];
26724 }
26725
26726 if (parameters['duration'] === undefined) {
26727 deferred.reject(new Error('Missing required form parameter: duration'));
26728 return deferred.promise;
26729 }
26730
26731 if (parameters.$queryParameters) {
26732 Object.keys(parameters.$queryParameters)
26733 .forEach(function(parameterName) {
26734 var parameter = parameters.$queryParameters[parameterName];
26735 queryParameters[parameterName] = parameter;
26736 });
26737 }
26738
26739 var url = domain + path;
26740 var options = {
26741 timeout: parameters.$timeout,
26742 method: 'PUT',
26743 url: url,
26744 params: queryParameters,
26745 data: body,
26746 headers: headers
26747 };
26748 if (Object.keys(form).length > 0) {
26749 options.data = form;
26750 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26751 options.transformRequest = xos.transformRequest;
26752 }
26753 $http(options)
26754 .success(function(data, status, headers, config) {
26755 deferred.resolve(data);
26756 if (parameters.$cache !== undefined) {
26757 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26758 }
26759 })
26760 .error(function(data, status, headers, config) {
26761 deferred.reject({
26762 status: status,
26763 headers: headers,
26764 config: config,
26765 body: data
26766 });
26767 });
26768
26769 return deferred.promise;
26770 };
26771 /**
26772 *
26773 * @method
26774 * @name xos#Reservation_Detail_PATCH
26775 * @param {string} pk -
26776 * @param {string} enacted -
26777 * @param {string} policed -
26778 * @param {string} backend_register -
26779 * @param {string} backend_status -
26780 * @param {boolean} deleted -
26781 * @param {boolean} write_protect -
26782 * @param {boolean} lazy_blocked -
26783 * @param {boolean} no_sync -
26784 * @param {string} startTime -
26785 * @param {string} slice -
26786 * @param {integer} duration -
26787 *
26788 */
26789 xos.prototype.Reservation_Detail_PATCH = function(parameters) {
26790 if (parameters === undefined) {
26791 parameters = {};
26792 }
26793 var deferred = $q.defer();
26794
26795 var domain = this.domain;
26796 var path = '/xos/reservations/{pk}/';
26797
26798 var body;
26799 var queryParameters = {};
26800 var headers = {};
26801 var form = {};
26802
26803 path = path.replace('{pk}', parameters['pk']);
26804
26805 if (parameters['pk'] === undefined) {
26806 deferred.reject(new Error('Missing required path parameter: pk'));
26807 return deferred.promise;
26808 }
26809
26810 if (parameters['enacted'] !== undefined) {
26811 form['enacted'] = parameters['enacted'];
26812 }
26813
26814 if (parameters['policed'] !== undefined) {
26815 form['policed'] = parameters['policed'];
26816 }
26817
26818 if (parameters['backend_register'] !== undefined) {
26819 form['backend_register'] = parameters['backend_register'];
26820 }
26821
26822 if (parameters['backend_status'] !== undefined) {
26823 form['backend_status'] = parameters['backend_status'];
26824 }
26825
26826 if (parameters['deleted'] !== undefined) {
26827 form['deleted'] = parameters['deleted'];
26828 }
26829
26830 if (parameters['write_protect'] !== undefined) {
26831 form['write_protect'] = parameters['write_protect'];
26832 }
26833
26834 if (parameters['lazy_blocked'] !== undefined) {
26835 form['lazy_blocked'] = parameters['lazy_blocked'];
26836 }
26837
26838 if (parameters['no_sync'] !== undefined) {
26839 form['no_sync'] = parameters['no_sync'];
26840 }
26841
26842 if (parameters['startTime'] !== undefined) {
26843 form['startTime'] = parameters['startTime'];
26844 }
26845
26846 if (parameters['slice'] !== undefined) {
26847 form['slice'] = parameters['slice'];
26848 }
26849
26850 if (parameters['duration'] !== undefined) {
26851 form['duration'] = parameters['duration'];
26852 }
26853
26854 if (parameters.$queryParameters) {
26855 Object.keys(parameters.$queryParameters)
26856 .forEach(function(parameterName) {
26857 var parameter = parameters.$queryParameters[parameterName];
26858 queryParameters[parameterName] = parameter;
26859 });
26860 }
26861
26862 var url = domain + path;
26863 var options = {
26864 timeout: parameters.$timeout,
26865 method: 'PATCH',
26866 url: url,
26867 params: queryParameters,
26868 data: body,
26869 headers: headers
26870 };
26871 if (Object.keys(form).length > 0) {
26872 options.data = form;
26873 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26874 options.transformRequest = xos.transformRequest;
26875 }
26876 $http(options)
26877 .success(function(data, status, headers, config) {
26878 deferred.resolve(data);
26879 if (parameters.$cache !== undefined) {
26880 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26881 }
26882 })
26883 .error(function(data, status, headers, config) {
26884 deferred.reject({
26885 status: status,
26886 headers: headers,
26887 config: config,
26888 body: data
26889 });
26890 });
26891
26892 return deferred.promise;
26893 };
26894 /**
26895 *
26896 * @method
26897 * @name xos#Reservation_Detail_DELETE
26898 * @param {string} pk -
26899 *
26900 */
26901 xos.prototype.Reservation_Detail_DELETE = function(parameters) {
26902 if (parameters === undefined) {
26903 parameters = {};
26904 }
26905 var deferred = $q.defer();
26906
26907 var domain = this.domain;
26908 var path = '/xos/reservations/{pk}/';
26909
26910 var body;
26911 var queryParameters = {};
26912 var headers = {};
26913 var form = {};
26914
26915 path = path.replace('{pk}', parameters['pk']);
26916
26917 if (parameters['pk'] === undefined) {
26918 deferred.reject(new Error('Missing required path parameter: pk'));
26919 return deferred.promise;
26920 }
26921
26922 if (parameters.$queryParameters) {
26923 Object.keys(parameters.$queryParameters)
26924 .forEach(function(parameterName) {
26925 var parameter = parameters.$queryParameters[parameterName];
26926 queryParameters[parameterName] = parameter;
26927 });
26928 }
26929
26930 var url = domain + path;
26931 var options = {
26932 timeout: parameters.$timeout,
26933 method: 'DELETE',
26934 url: url,
26935 params: queryParameters,
26936 data: body,
26937 headers: headers
26938 };
26939 if (Object.keys(form).length > 0) {
26940 options.data = form;
26941 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
26942 options.transformRequest = xos.transformRequest;
26943 }
26944 $http(options)
26945 .success(function(data, status, headers, config) {
26946 deferred.resolve(data);
26947 if (parameters.$cache !== undefined) {
26948 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
26949 }
26950 })
26951 .error(function(data, status, headers, config) {
26952 deferred.reject({
26953 status: status,
26954 headers: headers,
26955 config: config,
26956 body: data
26957 });
26958 });
26959
26960 return deferred.promise;
26961 };
26962 /**
26963 *
26964 * @method
26965 * @name xos#Site_Privilege_List_GET
26966 *
26967 */
26968 xos.prototype.Site_Privilege_List_GET = function(parameters) {
26969 if (parameters === undefined) {
26970 parameters = {};
26971 }
26972 var deferred = $q.defer();
26973
26974 var domain = this.domain;
26975 var path = '/xos/siteprivileges/';
26976
26977 var body;
26978 var queryParameters = {};
26979 var headers = {};
26980 var form = {};
26981
26982 if (parameters.$queryParameters) {
26983 Object.keys(parameters.$queryParameters)
26984 .forEach(function(parameterName) {
26985 var parameter = parameters.$queryParameters[parameterName];
26986 queryParameters[parameterName] = parameter;
26987 });
26988 }
26989
26990 var url = domain + path;
26991 var cached = parameters.$cache && parameters.$cache.get(url);
26992 if (cached !== undefined && parameters.$refresh !== true) {
26993 deferred.resolve(cached);
26994 return deferred.promise;
26995 }
26996 var options = {
26997 timeout: parameters.$timeout,
26998 method: 'GET',
26999 url: url,
27000 params: queryParameters,
27001 data: body,
27002 headers: headers
27003 };
27004 if (Object.keys(form).length > 0) {
27005 options.data = form;
27006 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27007 options.transformRequest = xos.transformRequest;
27008 }
27009 $http(options)
27010 .success(function(data, status, headers, config) {
27011 deferred.resolve(data);
27012 if (parameters.$cache !== undefined) {
27013 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27014 }
27015 })
27016 .error(function(data, status, headers, config) {
27017 deferred.reject({
27018 status: status,
27019 headers: headers,
27020 config: config,
27021 body: data
27022 });
27023 });
27024
27025 return deferred.promise;
27026 };
27027 /**
27028 *
27029 * @method
27030 * @name xos#Site_Privilege_List_POST
27031 * @param {string} enacted -
27032 * @param {string} policed -
27033 * @param {string} backend_register -
27034 * @param {string} backend_status -
27035 * @param {boolean} deleted -
27036 * @param {boolean} write_protect -
27037 * @param {boolean} lazy_blocked -
27038 * @param {boolean} no_sync -
27039 * @param {string} user -
27040 * @param {string} site -
27041 * @param {string} role -
27042 *
27043 */
27044 xos.prototype.Site_Privilege_List_POST = function(parameters) {
27045 if (parameters === undefined) {
27046 parameters = {};
27047 }
27048 var deferred = $q.defer();
27049
27050 var domain = this.domain;
27051 var path = '/xos/siteprivileges/';
27052
27053 var body;
27054 var queryParameters = {};
27055 var headers = {};
27056 var form = {};
27057
27058 if (parameters['enacted'] !== undefined) {
27059 form['enacted'] = parameters['enacted'];
27060 }
27061
27062 if (parameters['policed'] !== undefined) {
27063 form['policed'] = parameters['policed'];
27064 }
27065
27066 if (parameters['backend_register'] !== undefined) {
27067 form['backend_register'] = parameters['backend_register'];
27068 }
27069
27070 if (parameters['backend_status'] !== undefined) {
27071 form['backend_status'] = parameters['backend_status'];
27072 }
27073
27074 if (parameters['backend_status'] === undefined) {
27075 deferred.reject(new Error('Missing required form parameter: backend_status'));
27076 return deferred.promise;
27077 }
27078
27079 if (parameters['deleted'] !== undefined) {
27080 form['deleted'] = parameters['deleted'];
27081 }
27082
27083 if (parameters['write_protect'] !== undefined) {
27084 form['write_protect'] = parameters['write_protect'];
27085 }
27086
27087 if (parameters['lazy_blocked'] !== undefined) {
27088 form['lazy_blocked'] = parameters['lazy_blocked'];
27089 }
27090
27091 if (parameters['no_sync'] !== undefined) {
27092 form['no_sync'] = parameters['no_sync'];
27093 }
27094
27095 if (parameters['user'] !== undefined) {
27096 form['user'] = parameters['user'];
27097 }
27098
27099 if (parameters['user'] === undefined) {
27100 deferred.reject(new Error('Missing required form parameter: user'));
27101 return deferred.promise;
27102 }
27103
27104 if (parameters['site'] !== undefined) {
27105 form['site'] = parameters['site'];
27106 }
27107
27108 if (parameters['site'] === undefined) {
27109 deferred.reject(new Error('Missing required form parameter: site'));
27110 return deferred.promise;
27111 }
27112
27113 if (parameters['role'] !== undefined) {
27114 form['role'] = parameters['role'];
27115 }
27116
27117 if (parameters['role'] === undefined) {
27118 deferred.reject(new Error('Missing required form parameter: role'));
27119 return deferred.promise;
27120 }
27121
27122 if (parameters.$queryParameters) {
27123 Object.keys(parameters.$queryParameters)
27124 .forEach(function(parameterName) {
27125 var parameter = parameters.$queryParameters[parameterName];
27126 queryParameters[parameterName] = parameter;
27127 });
27128 }
27129
27130 var url = domain + path;
27131 var options = {
27132 timeout: parameters.$timeout,
27133 method: 'POST',
27134 url: url,
27135 params: queryParameters,
27136 data: body,
27137 headers: headers
27138 };
27139 if (Object.keys(form).length > 0) {
27140 options.data = form;
27141 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27142 options.transformRequest = xos.transformRequest;
27143 }
27144 $http(options)
27145 .success(function(data, status, headers, config) {
27146 deferred.resolve(data);
27147 if (parameters.$cache !== undefined) {
27148 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27149 }
27150 })
27151 .error(function(data, status, headers, config) {
27152 deferred.reject({
27153 status: status,
27154 headers: headers,
27155 config: config,
27156 body: data
27157 });
27158 });
27159
27160 return deferred.promise;
27161 };
27162 /**
27163 *
27164 * @method
27165 * @name xos#Site_Privilege_Detail_GET
27166 * @param {string} pk -
27167 *
27168 */
27169 xos.prototype.Site_Privilege_Detail_GET = function(parameters) {
27170 if (parameters === undefined) {
27171 parameters = {};
27172 }
27173 var deferred = $q.defer();
27174
27175 var domain = this.domain;
27176 var path = '/xos/siteprivileges/{pk}/';
27177
27178 var body;
27179 var queryParameters = {};
27180 var headers = {};
27181 var form = {};
27182
27183 path = path.replace('{pk}', parameters['pk']);
27184
27185 if (parameters['pk'] === undefined) {
27186 deferred.reject(new Error('Missing required path parameter: pk'));
27187 return deferred.promise;
27188 }
27189
27190 if (parameters.$queryParameters) {
27191 Object.keys(parameters.$queryParameters)
27192 .forEach(function(parameterName) {
27193 var parameter = parameters.$queryParameters[parameterName];
27194 queryParameters[parameterName] = parameter;
27195 });
27196 }
27197
27198 var url = domain + path;
27199 var cached = parameters.$cache && parameters.$cache.get(url);
27200 if (cached !== undefined && parameters.$refresh !== true) {
27201 deferred.resolve(cached);
27202 return deferred.promise;
27203 }
27204 var options = {
27205 timeout: parameters.$timeout,
27206 method: 'GET',
27207 url: url,
27208 params: queryParameters,
27209 data: body,
27210 headers: headers
27211 };
27212 if (Object.keys(form).length > 0) {
27213 options.data = form;
27214 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27215 options.transformRequest = xos.transformRequest;
27216 }
27217 $http(options)
27218 .success(function(data, status, headers, config) {
27219 deferred.resolve(data);
27220 if (parameters.$cache !== undefined) {
27221 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27222 }
27223 })
27224 .error(function(data, status, headers, config) {
27225 deferred.reject({
27226 status: status,
27227 headers: headers,
27228 config: config,
27229 body: data
27230 });
27231 });
27232
27233 return deferred.promise;
27234 };
27235 /**
27236 *
27237 * @method
27238 * @name xos#Site_Privilege_Detail_PUT
27239 * @param {string} pk -
27240 * @param {string} enacted -
27241 * @param {string} policed -
27242 * @param {string} backend_register -
27243 * @param {string} backend_status -
27244 * @param {boolean} deleted -
27245 * @param {boolean} write_protect -
27246 * @param {boolean} lazy_blocked -
27247 * @param {boolean} no_sync -
27248 * @param {string} user -
27249 * @param {string} site -
27250 * @param {string} role -
27251 *
27252 */
27253 xos.prototype.Site_Privilege_Detail_PUT = function(parameters) {
27254 if (parameters === undefined) {
27255 parameters = {};
27256 }
27257 var deferred = $q.defer();
27258
27259 var domain = this.domain;
27260 var path = '/xos/siteprivileges/{pk}/';
27261
27262 var body;
27263 var queryParameters = {};
27264 var headers = {};
27265 var form = {};
27266
27267 path = path.replace('{pk}', parameters['pk']);
27268
27269 if (parameters['pk'] === undefined) {
27270 deferred.reject(new Error('Missing required path parameter: pk'));
27271 return deferred.promise;
27272 }
27273
27274 if (parameters['enacted'] !== undefined) {
27275 form['enacted'] = parameters['enacted'];
27276 }
27277
27278 if (parameters['policed'] !== undefined) {
27279 form['policed'] = parameters['policed'];
27280 }
27281
27282 if (parameters['backend_register'] !== undefined) {
27283 form['backend_register'] = parameters['backend_register'];
27284 }
27285
27286 if (parameters['backend_status'] !== undefined) {
27287 form['backend_status'] = parameters['backend_status'];
27288 }
27289
27290 if (parameters['backend_status'] === undefined) {
27291 deferred.reject(new Error('Missing required form parameter: backend_status'));
27292 return deferred.promise;
27293 }
27294
27295 if (parameters['deleted'] !== undefined) {
27296 form['deleted'] = parameters['deleted'];
27297 }
27298
27299 if (parameters['write_protect'] !== undefined) {
27300 form['write_protect'] = parameters['write_protect'];
27301 }
27302
27303 if (parameters['lazy_blocked'] !== undefined) {
27304 form['lazy_blocked'] = parameters['lazy_blocked'];
27305 }
27306
27307 if (parameters['no_sync'] !== undefined) {
27308 form['no_sync'] = parameters['no_sync'];
27309 }
27310
27311 if (parameters['user'] !== undefined) {
27312 form['user'] = parameters['user'];
27313 }
27314
27315 if (parameters['user'] === undefined) {
27316 deferred.reject(new Error('Missing required form parameter: user'));
27317 return deferred.promise;
27318 }
27319
27320 if (parameters['site'] !== undefined) {
27321 form['site'] = parameters['site'];
27322 }
27323
27324 if (parameters['site'] === undefined) {
27325 deferred.reject(new Error('Missing required form parameter: site'));
27326 return deferred.promise;
27327 }
27328
27329 if (parameters['role'] !== undefined) {
27330 form['role'] = parameters['role'];
27331 }
27332
27333 if (parameters['role'] === undefined) {
27334 deferred.reject(new Error('Missing required form parameter: role'));
27335 return deferred.promise;
27336 }
27337
27338 if (parameters.$queryParameters) {
27339 Object.keys(parameters.$queryParameters)
27340 .forEach(function(parameterName) {
27341 var parameter = parameters.$queryParameters[parameterName];
27342 queryParameters[parameterName] = parameter;
27343 });
27344 }
27345
27346 var url = domain + path;
27347 var options = {
27348 timeout: parameters.$timeout,
27349 method: 'PUT',
27350 url: url,
27351 params: queryParameters,
27352 data: body,
27353 headers: headers
27354 };
27355 if (Object.keys(form).length > 0) {
27356 options.data = form;
27357 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27358 options.transformRequest = xos.transformRequest;
27359 }
27360 $http(options)
27361 .success(function(data, status, headers, config) {
27362 deferred.resolve(data);
27363 if (parameters.$cache !== undefined) {
27364 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27365 }
27366 })
27367 .error(function(data, status, headers, config) {
27368 deferred.reject({
27369 status: status,
27370 headers: headers,
27371 config: config,
27372 body: data
27373 });
27374 });
27375
27376 return deferred.promise;
27377 };
27378 /**
27379 *
27380 * @method
27381 * @name xos#Site_Privilege_Detail_PATCH
27382 * @param {string} pk -
27383 * @param {string} enacted -
27384 * @param {string} policed -
27385 * @param {string} backend_register -
27386 * @param {string} backend_status -
27387 * @param {boolean} deleted -
27388 * @param {boolean} write_protect -
27389 * @param {boolean} lazy_blocked -
27390 * @param {boolean} no_sync -
27391 * @param {string} user -
27392 * @param {string} site -
27393 * @param {string} role -
27394 *
27395 */
27396 xos.prototype.Site_Privilege_Detail_PATCH = function(parameters) {
27397 if (parameters === undefined) {
27398 parameters = {};
27399 }
27400 var deferred = $q.defer();
27401
27402 var domain = this.domain;
27403 var path = '/xos/siteprivileges/{pk}/';
27404
27405 var body;
27406 var queryParameters = {};
27407 var headers = {};
27408 var form = {};
27409
27410 path = path.replace('{pk}', parameters['pk']);
27411
27412 if (parameters['pk'] === undefined) {
27413 deferred.reject(new Error('Missing required path parameter: pk'));
27414 return deferred.promise;
27415 }
27416
27417 if (parameters['enacted'] !== undefined) {
27418 form['enacted'] = parameters['enacted'];
27419 }
27420
27421 if (parameters['policed'] !== undefined) {
27422 form['policed'] = parameters['policed'];
27423 }
27424
27425 if (parameters['backend_register'] !== undefined) {
27426 form['backend_register'] = parameters['backend_register'];
27427 }
27428
27429 if (parameters['backend_status'] !== undefined) {
27430 form['backend_status'] = parameters['backend_status'];
27431 }
27432
27433 if (parameters['deleted'] !== undefined) {
27434 form['deleted'] = parameters['deleted'];
27435 }
27436
27437 if (parameters['write_protect'] !== undefined) {
27438 form['write_protect'] = parameters['write_protect'];
27439 }
27440
27441 if (parameters['lazy_blocked'] !== undefined) {
27442 form['lazy_blocked'] = parameters['lazy_blocked'];
27443 }
27444
27445 if (parameters['no_sync'] !== undefined) {
27446 form['no_sync'] = parameters['no_sync'];
27447 }
27448
27449 if (parameters['user'] !== undefined) {
27450 form['user'] = parameters['user'];
27451 }
27452
27453 if (parameters['site'] !== undefined) {
27454 form['site'] = parameters['site'];
27455 }
27456
27457 if (parameters['role'] !== undefined) {
27458 form['role'] = parameters['role'];
27459 }
27460
27461 if (parameters.$queryParameters) {
27462 Object.keys(parameters.$queryParameters)
27463 .forEach(function(parameterName) {
27464 var parameter = parameters.$queryParameters[parameterName];
27465 queryParameters[parameterName] = parameter;
27466 });
27467 }
27468
27469 var url = domain + path;
27470 var options = {
27471 timeout: parameters.$timeout,
27472 method: 'PATCH',
27473 url: url,
27474 params: queryParameters,
27475 data: body,
27476 headers: headers
27477 };
27478 if (Object.keys(form).length > 0) {
27479 options.data = form;
27480 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27481 options.transformRequest = xos.transformRequest;
27482 }
27483 $http(options)
27484 .success(function(data, status, headers, config) {
27485 deferred.resolve(data);
27486 if (parameters.$cache !== undefined) {
27487 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27488 }
27489 })
27490 .error(function(data, status, headers, config) {
27491 deferred.reject({
27492 status: status,
27493 headers: headers,
27494 config: config,
27495 body: data
27496 });
27497 });
27498
27499 return deferred.promise;
27500 };
27501 /**
27502 *
27503 * @method
27504 * @name xos#Site_Privilege_Detail_DELETE
27505 * @param {string} pk -
27506 *
27507 */
27508 xos.prototype.Site_Privilege_Detail_DELETE = function(parameters) {
27509 if (parameters === undefined) {
27510 parameters = {};
27511 }
27512 var deferred = $q.defer();
27513
27514 var domain = this.domain;
27515 var path = '/xos/siteprivileges/{pk}/';
27516
27517 var body;
27518 var queryParameters = {};
27519 var headers = {};
27520 var form = {};
27521
27522 path = path.replace('{pk}', parameters['pk']);
27523
27524 if (parameters['pk'] === undefined) {
27525 deferred.reject(new Error('Missing required path parameter: pk'));
27526 return deferred.promise;
27527 }
27528
27529 if (parameters.$queryParameters) {
27530 Object.keys(parameters.$queryParameters)
27531 .forEach(function(parameterName) {
27532 var parameter = parameters.$queryParameters[parameterName];
27533 queryParameters[parameterName] = parameter;
27534 });
27535 }
27536
27537 var url = domain + path;
27538 var options = {
27539 timeout: parameters.$timeout,
27540 method: 'DELETE',
27541 url: url,
27542 params: queryParameters,
27543 data: body,
27544 headers: headers
27545 };
27546 if (Object.keys(form).length > 0) {
27547 options.data = form;
27548 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27549 options.transformRequest = xos.transformRequest;
27550 }
27551 $http(options)
27552 .success(function(data, status, headers, config) {
27553 deferred.resolve(data);
27554 if (parameters.$cache !== undefined) {
27555 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27556 }
27557 })
27558 .error(function(data, status, headers, config) {
27559 deferred.reject({
27560 status: status,
27561 headers: headers,
27562 config: config,
27563 body: data
27564 });
27565 });
27566
27567 return deferred.promise;
27568 };
27569 /**
27570 *
27571 * @method
27572 * @name xos#Controller_Slice_List_GET
27573 *
27574 */
27575 xos.prototype.Controller_Slice_List_GET = function(parameters) {
27576 if (parameters === undefined) {
27577 parameters = {};
27578 }
27579 var deferred = $q.defer();
27580
27581 var domain = this.domain;
27582 var path = '/xos/controllerslices/';
27583
27584 var body;
27585 var queryParameters = {};
27586 var headers = {};
27587 var form = {};
27588
27589 if (parameters.$queryParameters) {
27590 Object.keys(parameters.$queryParameters)
27591 .forEach(function(parameterName) {
27592 var parameter = parameters.$queryParameters[parameterName];
27593 queryParameters[parameterName] = parameter;
27594 });
27595 }
27596
27597 var url = domain + path;
27598 var cached = parameters.$cache && parameters.$cache.get(url);
27599 if (cached !== undefined && parameters.$refresh !== true) {
27600 deferred.resolve(cached);
27601 return deferred.promise;
27602 }
27603 var options = {
27604 timeout: parameters.$timeout,
27605 method: 'GET',
27606 url: url,
27607 params: queryParameters,
27608 data: body,
27609 headers: headers
27610 };
27611 if (Object.keys(form).length > 0) {
27612 options.data = form;
27613 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27614 options.transformRequest = xos.transformRequest;
27615 }
27616 $http(options)
27617 .success(function(data, status, headers, config) {
27618 deferred.resolve(data);
27619 if (parameters.$cache !== undefined) {
27620 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27621 }
27622 })
27623 .error(function(data, status, headers, config) {
27624 deferred.reject({
27625 status: status,
27626 headers: headers,
27627 config: config,
27628 body: data
27629 });
27630 });
27631
27632 return deferred.promise;
27633 };
27634 /**
27635 *
27636 * @method
27637 * @name xos#Controller_Slice_List_POST
27638 * @param {string} enacted -
27639 * @param {string} policed -
27640 * @param {string} backend_register -
27641 * @param {string} backend_status -
27642 * @param {boolean} deleted -
27643 * @param {boolean} write_protect -
27644 * @param {boolean} lazy_blocked -
27645 * @param {boolean} no_sync -
27646 * @param {string} controller -
27647 * @param {string} slice -
27648 * @param {string} tenant_id - Keystone tenant id
27649 *
27650 */
27651 xos.prototype.Controller_Slice_List_POST = function(parameters) {
27652 if (parameters === undefined) {
27653 parameters = {};
27654 }
27655 var deferred = $q.defer();
27656
27657 var domain = this.domain;
27658 var path = '/xos/controllerslices/';
27659
27660 var body;
27661 var queryParameters = {};
27662 var headers = {};
27663 var form = {};
27664
27665 if (parameters['enacted'] !== undefined) {
27666 form['enacted'] = parameters['enacted'];
27667 }
27668
27669 if (parameters['policed'] !== undefined) {
27670 form['policed'] = parameters['policed'];
27671 }
27672
27673 if (parameters['backend_register'] !== undefined) {
27674 form['backend_register'] = parameters['backend_register'];
27675 }
27676
27677 if (parameters['backend_status'] !== undefined) {
27678 form['backend_status'] = parameters['backend_status'];
27679 }
27680
27681 if (parameters['backend_status'] === undefined) {
27682 deferred.reject(new Error('Missing required form parameter: backend_status'));
27683 return deferred.promise;
27684 }
27685
27686 if (parameters['deleted'] !== undefined) {
27687 form['deleted'] = parameters['deleted'];
27688 }
27689
27690 if (parameters['write_protect'] !== undefined) {
27691 form['write_protect'] = parameters['write_protect'];
27692 }
27693
27694 if (parameters['lazy_blocked'] !== undefined) {
27695 form['lazy_blocked'] = parameters['lazy_blocked'];
27696 }
27697
27698 if (parameters['no_sync'] !== undefined) {
27699 form['no_sync'] = parameters['no_sync'];
27700 }
27701
27702 if (parameters['controller'] !== undefined) {
27703 form['controller'] = parameters['controller'];
27704 }
27705
27706 if (parameters['controller'] === undefined) {
27707 deferred.reject(new Error('Missing required form parameter: controller'));
27708 return deferred.promise;
27709 }
27710
27711 if (parameters['slice'] !== undefined) {
27712 form['slice'] = parameters['slice'];
27713 }
27714
27715 if (parameters['slice'] === undefined) {
27716 deferred.reject(new Error('Missing required form parameter: slice'));
27717 return deferred.promise;
27718 }
27719
27720 if (parameters['tenant_id'] !== undefined) {
27721 form['tenant_id'] = parameters['tenant_id'];
27722 }
27723
27724 if (parameters.$queryParameters) {
27725 Object.keys(parameters.$queryParameters)
27726 .forEach(function(parameterName) {
27727 var parameter = parameters.$queryParameters[parameterName];
27728 queryParameters[parameterName] = parameter;
27729 });
27730 }
27731
27732 var url = domain + path;
27733 var options = {
27734 timeout: parameters.$timeout,
27735 method: 'POST',
27736 url: url,
27737 params: queryParameters,
27738 data: body,
27739 headers: headers
27740 };
27741 if (Object.keys(form).length > 0) {
27742 options.data = form;
27743 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27744 options.transformRequest = xos.transformRequest;
27745 }
27746 $http(options)
27747 .success(function(data, status, headers, config) {
27748 deferred.resolve(data);
27749 if (parameters.$cache !== undefined) {
27750 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27751 }
27752 })
27753 .error(function(data, status, headers, config) {
27754 deferred.reject({
27755 status: status,
27756 headers: headers,
27757 config: config,
27758 body: data
27759 });
27760 });
27761
27762 return deferred.promise;
27763 };
27764 /**
27765 *
27766 * @method
27767 * @name xos#Controller_Slice_Detail_GET
27768 * @param {string} pk -
27769 *
27770 */
27771 xos.prototype.Controller_Slice_Detail_GET = function(parameters) {
27772 if (parameters === undefined) {
27773 parameters = {};
27774 }
27775 var deferred = $q.defer();
27776
27777 var domain = this.domain;
27778 var path = '/xos/controllerslices/{pk}/';
27779
27780 var body;
27781 var queryParameters = {};
27782 var headers = {};
27783 var form = {};
27784
27785 path = path.replace('{pk}', parameters['pk']);
27786
27787 if (parameters['pk'] === undefined) {
27788 deferred.reject(new Error('Missing required path parameter: pk'));
27789 return deferred.promise;
27790 }
27791
27792 if (parameters.$queryParameters) {
27793 Object.keys(parameters.$queryParameters)
27794 .forEach(function(parameterName) {
27795 var parameter = parameters.$queryParameters[parameterName];
27796 queryParameters[parameterName] = parameter;
27797 });
27798 }
27799
27800 var url = domain + path;
27801 var cached = parameters.$cache && parameters.$cache.get(url);
27802 if (cached !== undefined && parameters.$refresh !== true) {
27803 deferred.resolve(cached);
27804 return deferred.promise;
27805 }
27806 var options = {
27807 timeout: parameters.$timeout,
27808 method: 'GET',
27809 url: url,
27810 params: queryParameters,
27811 data: body,
27812 headers: headers
27813 };
27814 if (Object.keys(form).length > 0) {
27815 options.data = form;
27816 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27817 options.transformRequest = xos.transformRequest;
27818 }
27819 $http(options)
27820 .success(function(data, status, headers, config) {
27821 deferred.resolve(data);
27822 if (parameters.$cache !== undefined) {
27823 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27824 }
27825 })
27826 .error(function(data, status, headers, config) {
27827 deferred.reject({
27828 status: status,
27829 headers: headers,
27830 config: config,
27831 body: data
27832 });
27833 });
27834
27835 return deferred.promise;
27836 };
27837 /**
27838 *
27839 * @method
27840 * @name xos#Controller_Slice_Detail_PUT
27841 * @param {string} pk -
27842 * @param {string} enacted -
27843 * @param {string} policed -
27844 * @param {string} backend_register -
27845 * @param {string} backend_status -
27846 * @param {boolean} deleted -
27847 * @param {boolean} write_protect -
27848 * @param {boolean} lazy_blocked -
27849 * @param {boolean} no_sync -
27850 * @param {string} controller -
27851 * @param {string} slice -
27852 * @param {string} tenant_id - Keystone tenant id
27853 *
27854 */
27855 xos.prototype.Controller_Slice_Detail_PUT = function(parameters) {
27856 if (parameters === undefined) {
27857 parameters = {};
27858 }
27859 var deferred = $q.defer();
27860
27861 var domain = this.domain;
27862 var path = '/xos/controllerslices/{pk}/';
27863
27864 var body;
27865 var queryParameters = {};
27866 var headers = {};
27867 var form = {};
27868
27869 path = path.replace('{pk}', parameters['pk']);
27870
27871 if (parameters['pk'] === undefined) {
27872 deferred.reject(new Error('Missing required path parameter: pk'));
27873 return deferred.promise;
27874 }
27875
27876 if (parameters['enacted'] !== undefined) {
27877 form['enacted'] = parameters['enacted'];
27878 }
27879
27880 if (parameters['policed'] !== undefined) {
27881 form['policed'] = parameters['policed'];
27882 }
27883
27884 if (parameters['backend_register'] !== undefined) {
27885 form['backend_register'] = parameters['backend_register'];
27886 }
27887
27888 if (parameters['backend_status'] !== undefined) {
27889 form['backend_status'] = parameters['backend_status'];
27890 }
27891
27892 if (parameters['backend_status'] === undefined) {
27893 deferred.reject(new Error('Missing required form parameter: backend_status'));
27894 return deferred.promise;
27895 }
27896
27897 if (parameters['deleted'] !== undefined) {
27898 form['deleted'] = parameters['deleted'];
27899 }
27900
27901 if (parameters['write_protect'] !== undefined) {
27902 form['write_protect'] = parameters['write_protect'];
27903 }
27904
27905 if (parameters['lazy_blocked'] !== undefined) {
27906 form['lazy_blocked'] = parameters['lazy_blocked'];
27907 }
27908
27909 if (parameters['no_sync'] !== undefined) {
27910 form['no_sync'] = parameters['no_sync'];
27911 }
27912
27913 if (parameters['controller'] !== undefined) {
27914 form['controller'] = parameters['controller'];
27915 }
27916
27917 if (parameters['controller'] === undefined) {
27918 deferred.reject(new Error('Missing required form parameter: controller'));
27919 return deferred.promise;
27920 }
27921
27922 if (parameters['slice'] !== undefined) {
27923 form['slice'] = parameters['slice'];
27924 }
27925
27926 if (parameters['slice'] === undefined) {
27927 deferred.reject(new Error('Missing required form parameter: slice'));
27928 return deferred.promise;
27929 }
27930
27931 if (parameters['tenant_id'] !== undefined) {
27932 form['tenant_id'] = parameters['tenant_id'];
27933 }
27934
27935 if (parameters.$queryParameters) {
27936 Object.keys(parameters.$queryParameters)
27937 .forEach(function(parameterName) {
27938 var parameter = parameters.$queryParameters[parameterName];
27939 queryParameters[parameterName] = parameter;
27940 });
27941 }
27942
27943 var url = domain + path;
27944 var options = {
27945 timeout: parameters.$timeout,
27946 method: 'PUT',
27947 url: url,
27948 params: queryParameters,
27949 data: body,
27950 headers: headers
27951 };
27952 if (Object.keys(form).length > 0) {
27953 options.data = form;
27954 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
27955 options.transformRequest = xos.transformRequest;
27956 }
27957 $http(options)
27958 .success(function(data, status, headers, config) {
27959 deferred.resolve(data);
27960 if (parameters.$cache !== undefined) {
27961 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
27962 }
27963 })
27964 .error(function(data, status, headers, config) {
27965 deferred.reject({
27966 status: status,
27967 headers: headers,
27968 config: config,
27969 body: data
27970 });
27971 });
27972
27973 return deferred.promise;
27974 };
27975 /**
27976 *
27977 * @method
27978 * @name xos#Controller_Slice_Detail_PATCH
27979 * @param {string} pk -
27980 * @param {string} enacted -
27981 * @param {string} policed -
27982 * @param {string} backend_register -
27983 * @param {string} backend_status -
27984 * @param {boolean} deleted -
27985 * @param {boolean} write_protect -
27986 * @param {boolean} lazy_blocked -
27987 * @param {boolean} no_sync -
27988 * @param {string} controller -
27989 * @param {string} slice -
27990 * @param {string} tenant_id - Keystone tenant id
27991 *
27992 */
27993 xos.prototype.Controller_Slice_Detail_PATCH = function(parameters) {
27994 if (parameters === undefined) {
27995 parameters = {};
27996 }
27997 var deferred = $q.defer();
27998
27999 var domain = this.domain;
28000 var path = '/xos/controllerslices/{pk}/';
28001
28002 var body;
28003 var queryParameters = {};
28004 var headers = {};
28005 var form = {};
28006
28007 path = path.replace('{pk}', parameters['pk']);
28008
28009 if (parameters['pk'] === undefined) {
28010 deferred.reject(new Error('Missing required path parameter: pk'));
28011 return deferred.promise;
28012 }
28013
28014 if (parameters['enacted'] !== undefined) {
28015 form['enacted'] = parameters['enacted'];
28016 }
28017
28018 if (parameters['policed'] !== undefined) {
28019 form['policed'] = parameters['policed'];
28020 }
28021
28022 if (parameters['backend_register'] !== undefined) {
28023 form['backend_register'] = parameters['backend_register'];
28024 }
28025
28026 if (parameters['backend_status'] !== undefined) {
28027 form['backend_status'] = parameters['backend_status'];
28028 }
28029
28030 if (parameters['deleted'] !== undefined) {
28031 form['deleted'] = parameters['deleted'];
28032 }
28033
28034 if (parameters['write_protect'] !== undefined) {
28035 form['write_protect'] = parameters['write_protect'];
28036 }
28037
28038 if (parameters['lazy_blocked'] !== undefined) {
28039 form['lazy_blocked'] = parameters['lazy_blocked'];
28040 }
28041
28042 if (parameters['no_sync'] !== undefined) {
28043 form['no_sync'] = parameters['no_sync'];
28044 }
28045
28046 if (parameters['controller'] !== undefined) {
28047 form['controller'] = parameters['controller'];
28048 }
28049
28050 if (parameters['slice'] !== undefined) {
28051 form['slice'] = parameters['slice'];
28052 }
28053
28054 if (parameters['tenant_id'] !== undefined) {
28055 form['tenant_id'] = parameters['tenant_id'];
28056 }
28057
28058 if (parameters.$queryParameters) {
28059 Object.keys(parameters.$queryParameters)
28060 .forEach(function(parameterName) {
28061 var parameter = parameters.$queryParameters[parameterName];
28062 queryParameters[parameterName] = parameter;
28063 });
28064 }
28065
28066 var url = domain + path;
28067 var options = {
28068 timeout: parameters.$timeout,
28069 method: 'PATCH',
28070 url: url,
28071 params: queryParameters,
28072 data: body,
28073 headers: headers
28074 };
28075 if (Object.keys(form).length > 0) {
28076 options.data = form;
28077 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28078 options.transformRequest = xos.transformRequest;
28079 }
28080 $http(options)
28081 .success(function(data, status, headers, config) {
28082 deferred.resolve(data);
28083 if (parameters.$cache !== undefined) {
28084 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28085 }
28086 })
28087 .error(function(data, status, headers, config) {
28088 deferred.reject({
28089 status: status,
28090 headers: headers,
28091 config: config,
28092 body: data
28093 });
28094 });
28095
28096 return deferred.promise;
28097 };
28098 /**
28099 *
28100 * @method
28101 * @name xos#Controller_Slice_Detail_DELETE
28102 * @param {string} pk -
28103 *
28104 */
28105 xos.prototype.Controller_Slice_Detail_DELETE = function(parameters) {
28106 if (parameters === undefined) {
28107 parameters = {};
28108 }
28109 var deferred = $q.defer();
28110
28111 var domain = this.domain;
28112 var path = '/xos/controllerslices/{pk}/';
28113
28114 var body;
28115 var queryParameters = {};
28116 var headers = {};
28117 var form = {};
28118
28119 path = path.replace('{pk}', parameters['pk']);
28120
28121 if (parameters['pk'] === undefined) {
28122 deferred.reject(new Error('Missing required path parameter: pk'));
28123 return deferred.promise;
28124 }
28125
28126 if (parameters.$queryParameters) {
28127 Object.keys(parameters.$queryParameters)
28128 .forEach(function(parameterName) {
28129 var parameter = parameters.$queryParameters[parameterName];
28130 queryParameters[parameterName] = parameter;
28131 });
28132 }
28133
28134 var url = domain + path;
28135 var options = {
28136 timeout: parameters.$timeout,
28137 method: 'DELETE',
28138 url: url,
28139 params: queryParameters,
28140 data: body,
28141 headers: headers
28142 };
28143 if (Object.keys(form).length > 0) {
28144 options.data = form;
28145 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28146 options.transformRequest = xos.transformRequest;
28147 }
28148 $http(options)
28149 .success(function(data, status, headers, config) {
28150 deferred.resolve(data);
28151 if (parameters.$cache !== undefined) {
28152 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28153 }
28154 })
28155 .error(function(data, status, headers, config) {
28156 deferred.reject({
28157 status: status,
28158 headers: headers,
28159 config: config,
28160 body: data
28161 });
28162 });
28163
28164 return deferred.promise;
28165 };
28166 /**
28167 *
28168 * @method
28169 * @name xos#Tenant_List_GET
28170 *
28171 */
28172 xos.prototype.Tenant_List_GET = function(parameters) {
28173 if (parameters === undefined) {
28174 parameters = {};
28175 }
28176 var deferred = $q.defer();
28177
28178 var domain = this.domain;
28179 var path = '/xos/tenants/';
28180
28181 var body;
28182 var queryParameters = {};
28183 var headers = {};
28184 var form = {};
28185
28186 if (parameters.$queryParameters) {
28187 Object.keys(parameters.$queryParameters)
28188 .forEach(function(parameterName) {
28189 var parameter = parameters.$queryParameters[parameterName];
28190 queryParameters[parameterName] = parameter;
28191 });
28192 }
28193
28194 var url = domain + path;
28195 var cached = parameters.$cache && parameters.$cache.get(url);
28196 if (cached !== undefined && parameters.$refresh !== true) {
28197 deferred.resolve(cached);
28198 return deferred.promise;
28199 }
28200 var options = {
28201 timeout: parameters.$timeout,
28202 method: 'GET',
28203 url: url,
28204 params: queryParameters,
28205 data: body,
28206 headers: headers
28207 };
28208 if (Object.keys(form).length > 0) {
28209 options.data = form;
28210 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28211 options.transformRequest = xos.transformRequest;
28212 }
28213 $http(options)
28214 .success(function(data, status, headers, config) {
28215 deferred.resolve(data);
28216 if (parameters.$cache !== undefined) {
28217 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28218 }
28219 })
28220 .error(function(data, status, headers, config) {
28221 deferred.reject({
28222 status: status,
28223 headers: headers,
28224 config: config,
28225 body: data
28226 });
28227 });
28228
28229 return deferred.promise;
28230 };
28231 /**
28232 *
28233 * @method
28234 * @name xos#Tenant_List_POST
28235 * @param {string} enacted -
28236 * @param {string} policed -
28237 * @param {string} backend_register -
28238 * @param {string} backend_status -
28239 * @param {boolean} deleted -
28240 * @param {boolean} write_protect -
28241 * @param {boolean} lazy_blocked -
28242 * @param {boolean} no_sync -
28243 * @param {string} kind -
28244 * @param {string} provider_service -
28245 * @param {string} subscriber_service -
28246 * @param {string} subscriber_tenant -
28247 * @param {string} subscriber_user -
28248 * @param {string} subscriber_root -
28249 * @param {string} service_specific_id -
28250 * @param {string} service_specific_attribute -
28251 * @param {choice} connect_method -
28252 *
28253 */
28254 xos.prototype.Tenant_List_POST = function(parameters) {
28255 if (parameters === undefined) {
28256 parameters = {};
28257 }
28258 var deferred = $q.defer();
28259
28260 var domain = this.domain;
28261 var path = '/xos/tenants/';
28262
28263 var body;
28264 var queryParameters = {};
28265 var headers = {};
28266 var form = {};
28267
28268 if (parameters['enacted'] !== undefined) {
28269 form['enacted'] = parameters['enacted'];
28270 }
28271
28272 if (parameters['policed'] !== undefined) {
28273 form['policed'] = parameters['policed'];
28274 }
28275
28276 if (parameters['backend_register'] !== undefined) {
28277 form['backend_register'] = parameters['backend_register'];
28278 }
28279
28280 if (parameters['backend_status'] !== undefined) {
28281 form['backend_status'] = parameters['backend_status'];
28282 }
28283
28284 if (parameters['backend_status'] === undefined) {
28285 deferred.reject(new Error('Missing required form parameter: backend_status'));
28286 return deferred.promise;
28287 }
28288
28289 if (parameters['deleted'] !== undefined) {
28290 form['deleted'] = parameters['deleted'];
28291 }
28292
28293 if (parameters['write_protect'] !== undefined) {
28294 form['write_protect'] = parameters['write_protect'];
28295 }
28296
28297 if (parameters['lazy_blocked'] !== undefined) {
28298 form['lazy_blocked'] = parameters['lazy_blocked'];
28299 }
28300
28301 if (parameters['no_sync'] !== undefined) {
28302 form['no_sync'] = parameters['no_sync'];
28303 }
28304
28305 if (parameters['kind'] !== undefined) {
28306 form['kind'] = parameters['kind'];
28307 }
28308
28309 if (parameters['kind'] === undefined) {
28310 deferred.reject(new Error('Missing required form parameter: kind'));
28311 return deferred.promise;
28312 }
28313
28314 if (parameters['provider_service'] !== undefined) {
28315 form['provider_service'] = parameters['provider_service'];
28316 }
28317
28318 if (parameters['provider_service'] === undefined) {
28319 deferred.reject(new Error('Missing required form parameter: provider_service'));
28320 return deferred.promise;
28321 }
28322
28323 if (parameters['subscriber_service'] !== undefined) {
28324 form['subscriber_service'] = parameters['subscriber_service'];
28325 }
28326
28327 if (parameters['subscriber_tenant'] !== undefined) {
28328 form['subscriber_tenant'] = parameters['subscriber_tenant'];
28329 }
28330
28331 if (parameters['subscriber_user'] !== undefined) {
28332 form['subscriber_user'] = parameters['subscriber_user'];
28333 }
28334
28335 if (parameters['subscriber_root'] !== undefined) {
28336 form['subscriber_root'] = parameters['subscriber_root'];
28337 }
28338
28339 if (parameters['service_specific_id'] !== undefined) {
28340 form['service_specific_id'] = parameters['service_specific_id'];
28341 }
28342
28343 if (parameters['service_specific_attribute'] !== undefined) {
28344 form['service_specific_attribute'] = parameters['service_specific_attribute'];
28345 }
28346
28347 if (parameters['connect_method'] !== undefined) {
28348 form['connect_method'] = parameters['connect_method'];
28349 }
28350
28351 if (parameters['connect_method'] === undefined) {
28352 deferred.reject(new Error('Missing required form parameter: connect_method'));
28353 return deferred.promise;
28354 }
28355
28356 if (parameters.$queryParameters) {
28357 Object.keys(parameters.$queryParameters)
28358 .forEach(function(parameterName) {
28359 var parameter = parameters.$queryParameters[parameterName];
28360 queryParameters[parameterName] = parameter;
28361 });
28362 }
28363
28364 var url = domain + path;
28365 var options = {
28366 timeout: parameters.$timeout,
28367 method: 'POST',
28368 url: url,
28369 params: queryParameters,
28370 data: body,
28371 headers: headers
28372 };
28373 if (Object.keys(form).length > 0) {
28374 options.data = form;
28375 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28376 options.transformRequest = xos.transformRequest;
28377 }
28378 $http(options)
28379 .success(function(data, status, headers, config) {
28380 deferred.resolve(data);
28381 if (parameters.$cache !== undefined) {
28382 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28383 }
28384 })
28385 .error(function(data, status, headers, config) {
28386 deferred.reject({
28387 status: status,
28388 headers: headers,
28389 config: config,
28390 body: data
28391 });
28392 });
28393
28394 return deferred.promise;
28395 };
28396 /**
28397 *
28398 * @method
28399 * @name xos#Tenant_Detail_GET
28400 * @param {string} pk -
28401 *
28402 */
28403 xos.prototype.Tenant_Detail_GET = function(parameters) {
28404 if (parameters === undefined) {
28405 parameters = {};
28406 }
28407 var deferred = $q.defer();
28408
28409 var domain = this.domain;
28410 var path = '/xos/tenants/{pk}/';
28411
28412 var body;
28413 var queryParameters = {};
28414 var headers = {};
28415 var form = {};
28416
28417 path = path.replace('{pk}', parameters['pk']);
28418
28419 if (parameters['pk'] === undefined) {
28420 deferred.reject(new Error('Missing required path parameter: pk'));
28421 return deferred.promise;
28422 }
28423
28424 if (parameters.$queryParameters) {
28425 Object.keys(parameters.$queryParameters)
28426 .forEach(function(parameterName) {
28427 var parameter = parameters.$queryParameters[parameterName];
28428 queryParameters[parameterName] = parameter;
28429 });
28430 }
28431
28432 var url = domain + path;
28433 var cached = parameters.$cache && parameters.$cache.get(url);
28434 if (cached !== undefined && parameters.$refresh !== true) {
28435 deferred.resolve(cached);
28436 return deferred.promise;
28437 }
28438 var options = {
28439 timeout: parameters.$timeout,
28440 method: 'GET',
28441 url: url,
28442 params: queryParameters,
28443 data: body,
28444 headers: headers
28445 };
28446 if (Object.keys(form).length > 0) {
28447 options.data = form;
28448 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28449 options.transformRequest = xos.transformRequest;
28450 }
28451 $http(options)
28452 .success(function(data, status, headers, config) {
28453 deferred.resolve(data);
28454 if (parameters.$cache !== undefined) {
28455 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28456 }
28457 })
28458 .error(function(data, status, headers, config) {
28459 deferred.reject({
28460 status: status,
28461 headers: headers,
28462 config: config,
28463 body: data
28464 });
28465 });
28466
28467 return deferred.promise;
28468 };
28469 /**
28470 *
28471 * @method
28472 * @name xos#Tenant_Detail_PUT
28473 * @param {string} pk -
28474 * @param {string} enacted -
28475 * @param {string} policed -
28476 * @param {string} backend_register -
28477 * @param {string} backend_status -
28478 * @param {boolean} deleted -
28479 * @param {boolean} write_protect -
28480 * @param {boolean} lazy_blocked -
28481 * @param {boolean} no_sync -
28482 * @param {string} kind -
28483 * @param {string} provider_service -
28484 * @param {string} subscriber_service -
28485 * @param {string} subscriber_tenant -
28486 * @param {string} subscriber_user -
28487 * @param {string} subscriber_root -
28488 * @param {string} service_specific_id -
28489 * @param {string} service_specific_attribute -
28490 * @param {choice} connect_method -
28491 *
28492 */
28493 xos.prototype.Tenant_Detail_PUT = function(parameters) {
28494 if (parameters === undefined) {
28495 parameters = {};
28496 }
28497 var deferred = $q.defer();
28498
28499 var domain = this.domain;
28500 var path = '/xos/tenants/{pk}/';
28501
28502 var body;
28503 var queryParameters = {};
28504 var headers = {};
28505 var form = {};
28506
28507 path = path.replace('{pk}', parameters['pk']);
28508
28509 if (parameters['pk'] === undefined) {
28510 deferred.reject(new Error('Missing required path parameter: pk'));
28511 return deferred.promise;
28512 }
28513
28514 if (parameters['enacted'] !== undefined) {
28515 form['enacted'] = parameters['enacted'];
28516 }
28517
28518 if (parameters['policed'] !== undefined) {
28519 form['policed'] = parameters['policed'];
28520 }
28521
28522 if (parameters['backend_register'] !== undefined) {
28523 form['backend_register'] = parameters['backend_register'];
28524 }
28525
28526 if (parameters['backend_status'] !== undefined) {
28527 form['backend_status'] = parameters['backend_status'];
28528 }
28529
28530 if (parameters['backend_status'] === undefined) {
28531 deferred.reject(new Error('Missing required form parameter: backend_status'));
28532 return deferred.promise;
28533 }
28534
28535 if (parameters['deleted'] !== undefined) {
28536 form['deleted'] = parameters['deleted'];
28537 }
28538
28539 if (parameters['write_protect'] !== undefined) {
28540 form['write_protect'] = parameters['write_protect'];
28541 }
28542
28543 if (parameters['lazy_blocked'] !== undefined) {
28544 form['lazy_blocked'] = parameters['lazy_blocked'];
28545 }
28546
28547 if (parameters['no_sync'] !== undefined) {
28548 form['no_sync'] = parameters['no_sync'];
28549 }
28550
28551 if (parameters['kind'] !== undefined) {
28552 form['kind'] = parameters['kind'];
28553 }
28554
28555 if (parameters['kind'] === undefined) {
28556 deferred.reject(new Error('Missing required form parameter: kind'));
28557 return deferred.promise;
28558 }
28559
28560 if (parameters['provider_service'] !== undefined) {
28561 form['provider_service'] = parameters['provider_service'];
28562 }
28563
28564 if (parameters['provider_service'] === undefined) {
28565 deferred.reject(new Error('Missing required form parameter: provider_service'));
28566 return deferred.promise;
28567 }
28568
28569 if (parameters['subscriber_service'] !== undefined) {
28570 form['subscriber_service'] = parameters['subscriber_service'];
28571 }
28572
28573 if (parameters['subscriber_tenant'] !== undefined) {
28574 form['subscriber_tenant'] = parameters['subscriber_tenant'];
28575 }
28576
28577 if (parameters['subscriber_user'] !== undefined) {
28578 form['subscriber_user'] = parameters['subscriber_user'];
28579 }
28580
28581 if (parameters['subscriber_root'] !== undefined) {
28582 form['subscriber_root'] = parameters['subscriber_root'];
28583 }
28584
28585 if (parameters['service_specific_id'] !== undefined) {
28586 form['service_specific_id'] = parameters['service_specific_id'];
28587 }
28588
28589 if (parameters['service_specific_attribute'] !== undefined) {
28590 form['service_specific_attribute'] = parameters['service_specific_attribute'];
28591 }
28592
28593 if (parameters['connect_method'] !== undefined) {
28594 form['connect_method'] = parameters['connect_method'];
28595 }
28596
28597 if (parameters['connect_method'] === undefined) {
28598 deferred.reject(new Error('Missing required form parameter: connect_method'));
28599 return deferred.promise;
28600 }
28601
28602 if (parameters.$queryParameters) {
28603 Object.keys(parameters.$queryParameters)
28604 .forEach(function(parameterName) {
28605 var parameter = parameters.$queryParameters[parameterName];
28606 queryParameters[parameterName] = parameter;
28607 });
28608 }
28609
28610 var url = domain + path;
28611 var options = {
28612 timeout: parameters.$timeout,
28613 method: 'PUT',
28614 url: url,
28615 params: queryParameters,
28616 data: body,
28617 headers: headers
28618 };
28619 if (Object.keys(form).length > 0) {
28620 options.data = form;
28621 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28622 options.transformRequest = xos.transformRequest;
28623 }
28624 $http(options)
28625 .success(function(data, status, headers, config) {
28626 deferred.resolve(data);
28627 if (parameters.$cache !== undefined) {
28628 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28629 }
28630 })
28631 .error(function(data, status, headers, config) {
28632 deferred.reject({
28633 status: status,
28634 headers: headers,
28635 config: config,
28636 body: data
28637 });
28638 });
28639
28640 return deferred.promise;
28641 };
28642 /**
28643 *
28644 * @method
28645 * @name xos#Tenant_Detail_PATCH
28646 * @param {string} pk -
28647 * @param {string} enacted -
28648 * @param {string} policed -
28649 * @param {string} backend_register -
28650 * @param {string} backend_status -
28651 * @param {boolean} deleted -
28652 * @param {boolean} write_protect -
28653 * @param {boolean} lazy_blocked -
28654 * @param {boolean} no_sync -
28655 * @param {string} kind -
28656 * @param {string} provider_service -
28657 * @param {string} subscriber_service -
28658 * @param {string} subscriber_tenant -
28659 * @param {string} subscriber_user -
28660 * @param {string} subscriber_root -
28661 * @param {string} service_specific_id -
28662 * @param {string} service_specific_attribute -
28663 * @param {choice} connect_method -
28664 *
28665 */
28666 xos.prototype.Tenant_Detail_PATCH = function(parameters) {
28667 if (parameters === undefined) {
28668 parameters = {};
28669 }
28670 var deferred = $q.defer();
28671
28672 var domain = this.domain;
28673 var path = '/xos/tenants/{pk}/';
28674
28675 var body;
28676 var queryParameters = {};
28677 var headers = {};
28678 var form = {};
28679
28680 path = path.replace('{pk}', parameters['pk']);
28681
28682 if (parameters['pk'] === undefined) {
28683 deferred.reject(new Error('Missing required path parameter: pk'));
28684 return deferred.promise;
28685 }
28686
28687 if (parameters['enacted'] !== undefined) {
28688 form['enacted'] = parameters['enacted'];
28689 }
28690
28691 if (parameters['policed'] !== undefined) {
28692 form['policed'] = parameters['policed'];
28693 }
28694
28695 if (parameters['backend_register'] !== undefined) {
28696 form['backend_register'] = parameters['backend_register'];
28697 }
28698
28699 if (parameters['backend_status'] !== undefined) {
28700 form['backend_status'] = parameters['backend_status'];
28701 }
28702
28703 if (parameters['deleted'] !== undefined) {
28704 form['deleted'] = parameters['deleted'];
28705 }
28706
28707 if (parameters['write_protect'] !== undefined) {
28708 form['write_protect'] = parameters['write_protect'];
28709 }
28710
28711 if (parameters['lazy_blocked'] !== undefined) {
28712 form['lazy_blocked'] = parameters['lazy_blocked'];
28713 }
28714
28715 if (parameters['no_sync'] !== undefined) {
28716 form['no_sync'] = parameters['no_sync'];
28717 }
28718
28719 if (parameters['kind'] !== undefined) {
28720 form['kind'] = parameters['kind'];
28721 }
28722
28723 if (parameters['provider_service'] !== undefined) {
28724 form['provider_service'] = parameters['provider_service'];
28725 }
28726
28727 if (parameters['subscriber_service'] !== undefined) {
28728 form['subscriber_service'] = parameters['subscriber_service'];
28729 }
28730
28731 if (parameters['subscriber_tenant'] !== undefined) {
28732 form['subscriber_tenant'] = parameters['subscriber_tenant'];
28733 }
28734
28735 if (parameters['subscriber_user'] !== undefined) {
28736 form['subscriber_user'] = parameters['subscriber_user'];
28737 }
28738
28739 if (parameters['subscriber_root'] !== undefined) {
28740 form['subscriber_root'] = parameters['subscriber_root'];
28741 }
28742
28743 if (parameters['service_specific_id'] !== undefined) {
28744 form['service_specific_id'] = parameters['service_specific_id'];
28745 }
28746
28747 if (parameters['service_specific_attribute'] !== undefined) {
28748 form['service_specific_attribute'] = parameters['service_specific_attribute'];
28749 }
28750
28751 if (parameters['connect_method'] !== undefined) {
28752 form['connect_method'] = parameters['connect_method'];
28753 }
28754
28755 if (parameters.$queryParameters) {
28756 Object.keys(parameters.$queryParameters)
28757 .forEach(function(parameterName) {
28758 var parameter = parameters.$queryParameters[parameterName];
28759 queryParameters[parameterName] = parameter;
28760 });
28761 }
28762
28763 var url = domain + path;
28764 var options = {
28765 timeout: parameters.$timeout,
28766 method: 'PATCH',
28767 url: url,
28768 params: queryParameters,
28769 data: body,
28770 headers: headers
28771 };
28772 if (Object.keys(form).length > 0) {
28773 options.data = form;
28774 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28775 options.transformRequest = xos.transformRequest;
28776 }
28777 $http(options)
28778 .success(function(data, status, headers, config) {
28779 deferred.resolve(data);
28780 if (parameters.$cache !== undefined) {
28781 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28782 }
28783 })
28784 .error(function(data, status, headers, config) {
28785 deferred.reject({
28786 status: status,
28787 headers: headers,
28788 config: config,
28789 body: data
28790 });
28791 });
28792
28793 return deferred.promise;
28794 };
28795 /**
28796 *
28797 * @method
28798 * @name xos#Tenant_Detail_DELETE
28799 * @param {string} pk -
28800 *
28801 */
28802 xos.prototype.Tenant_Detail_DELETE = function(parameters) {
28803 if (parameters === undefined) {
28804 parameters = {};
28805 }
28806 var deferred = $q.defer();
28807
28808 var domain = this.domain;
28809 var path = '/xos/tenants/{pk}/';
28810
28811 var body;
28812 var queryParameters = {};
28813 var headers = {};
28814 var form = {};
28815
28816 path = path.replace('{pk}', parameters['pk']);
28817
28818 if (parameters['pk'] === undefined) {
28819 deferred.reject(new Error('Missing required path parameter: pk'));
28820 return deferred.promise;
28821 }
28822
28823 if (parameters.$queryParameters) {
28824 Object.keys(parameters.$queryParameters)
28825 .forEach(function(parameterName) {
28826 var parameter = parameters.$queryParameters[parameterName];
28827 queryParameters[parameterName] = parameter;
28828 });
28829 }
28830
28831 var url = domain + path;
28832 var options = {
28833 timeout: parameters.$timeout,
28834 method: 'DELETE',
28835 url: url,
28836 params: queryParameters,
28837 data: body,
28838 headers: headers
28839 };
28840 if (Object.keys(form).length > 0) {
28841 options.data = form;
28842 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28843 options.transformRequest = xos.transformRequest;
28844 }
28845 $http(options)
28846 .success(function(data, status, headers, config) {
28847 deferred.resolve(data);
28848 if (parameters.$cache !== undefined) {
28849 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28850 }
28851 })
28852 .error(function(data, status, headers, config) {
28853 deferred.reject({
28854 status: status,
28855 headers: headers,
28856 config: config,
28857 body: data
28858 });
28859 });
28860
28861 return deferred.promise;
28862 };
28863 /**
28864 *
28865 * @method
28866 * @name xos#Controller_Dashboard_View_List_GET
28867 *
28868 */
28869 xos.prototype.Controller_Dashboard_View_List_GET = function(parameters) {
28870 if (parameters === undefined) {
28871 parameters = {};
28872 }
28873 var deferred = $q.defer();
28874
28875 var domain = this.domain;
28876 var path = '/xos/controllerdashboardviews/';
28877
28878 var body;
28879 var queryParameters = {};
28880 var headers = {};
28881 var form = {};
28882
28883 if (parameters.$queryParameters) {
28884 Object.keys(parameters.$queryParameters)
28885 .forEach(function(parameterName) {
28886 var parameter = parameters.$queryParameters[parameterName];
28887 queryParameters[parameterName] = parameter;
28888 });
28889 }
28890
28891 var url = domain + path;
28892 var cached = parameters.$cache && parameters.$cache.get(url);
28893 if (cached !== undefined && parameters.$refresh !== true) {
28894 deferred.resolve(cached);
28895 return deferred.promise;
28896 }
28897 var options = {
28898 timeout: parameters.$timeout,
28899 method: 'GET',
28900 url: url,
28901 params: queryParameters,
28902 data: body,
28903 headers: headers
28904 };
28905 if (Object.keys(form).length > 0) {
28906 options.data = form;
28907 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
28908 options.transformRequest = xos.transformRequest;
28909 }
28910 $http(options)
28911 .success(function(data, status, headers, config) {
28912 deferred.resolve(data);
28913 if (parameters.$cache !== undefined) {
28914 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
28915 }
28916 })
28917 .error(function(data, status, headers, config) {
28918 deferred.reject({
28919 status: status,
28920 headers: headers,
28921 config: config,
28922 body: data
28923 });
28924 });
28925
28926 return deferred.promise;
28927 };
28928 /**
28929 *
28930 * @method
28931 * @name xos#Controller_Dashboard_View_List_POST
28932 * @param {string} enacted -
28933 * @param {string} policed -
28934 * @param {string} backend_register -
28935 * @param {string} backend_status -
28936 * @param {boolean} deleted -
28937 * @param {boolean} write_protect -
28938 * @param {boolean} lazy_blocked -
28939 * @param {boolean} no_sync -
28940 * @param {string} controller -
28941 * @param {string} dashboardView -
28942 * @param {boolean} enabled -
28943 * @param {string} url - URL of Dashboard
28944 *
28945 */
28946 xos.prototype.Controller_Dashboard_View_List_POST = function(parameters) {
28947 if (parameters === undefined) {
28948 parameters = {};
28949 }
28950 var deferred = $q.defer();
28951
28952 var domain = this.domain;
28953 var path = '/xos/controllerdashboardviews/';
28954
28955 var body;
28956 var queryParameters = {};
28957 var headers = {};
28958 var form = {};
28959
28960 if (parameters['enacted'] !== undefined) {
28961 form['enacted'] = parameters['enacted'];
28962 }
28963
28964 if (parameters['policed'] !== undefined) {
28965 form['policed'] = parameters['policed'];
28966 }
28967
28968 if (parameters['backend_register'] !== undefined) {
28969 form['backend_register'] = parameters['backend_register'];
28970 }
28971
28972 if (parameters['backend_status'] !== undefined) {
28973 form['backend_status'] = parameters['backend_status'];
28974 }
28975
28976 if (parameters['backend_status'] === undefined) {
28977 deferred.reject(new Error('Missing required form parameter: backend_status'));
28978 return deferred.promise;
28979 }
28980
28981 if (parameters['deleted'] !== undefined) {
28982 form['deleted'] = parameters['deleted'];
28983 }
28984
28985 if (parameters['write_protect'] !== undefined) {
28986 form['write_protect'] = parameters['write_protect'];
28987 }
28988
28989 if (parameters['lazy_blocked'] !== undefined) {
28990 form['lazy_blocked'] = parameters['lazy_blocked'];
28991 }
28992
28993 if (parameters['no_sync'] !== undefined) {
28994 form['no_sync'] = parameters['no_sync'];
28995 }
28996
28997 if (parameters['controller'] !== undefined) {
28998 form['controller'] = parameters['controller'];
28999 }
29000
29001 if (parameters['controller'] === undefined) {
29002 deferred.reject(new Error('Missing required form parameter: controller'));
29003 return deferred.promise;
29004 }
29005
29006 if (parameters['dashboardView'] !== undefined) {
29007 form['dashboardView'] = parameters['dashboardView'];
29008 }
29009
29010 if (parameters['dashboardView'] === undefined) {
29011 deferred.reject(new Error('Missing required form parameter: dashboardView'));
29012 return deferred.promise;
29013 }
29014
29015 if (parameters['enabled'] !== undefined) {
29016 form['enabled'] = parameters['enabled'];
29017 }
29018
29019 if (parameters['url'] !== undefined) {
29020 form['url'] = parameters['url'];
29021 }
29022
29023 if (parameters['url'] === undefined) {
29024 deferred.reject(new Error('Missing required form parameter: url'));
29025 return deferred.promise;
29026 }
29027
29028 if (parameters.$queryParameters) {
29029 Object.keys(parameters.$queryParameters)
29030 .forEach(function(parameterName) {
29031 var parameter = parameters.$queryParameters[parameterName];
29032 queryParameters[parameterName] = parameter;
29033 });
29034 }
29035
29036 var url = domain + path;
29037 var options = {
29038 timeout: parameters.$timeout,
29039 method: 'POST',
29040 url: url,
29041 params: queryParameters,
29042 data: body,
29043 headers: headers
29044 };
29045 if (Object.keys(form).length > 0) {
29046 options.data = form;
29047 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29048 options.transformRequest = xos.transformRequest;
29049 }
29050 $http(options)
29051 .success(function(data, status, headers, config) {
29052 deferred.resolve(data);
29053 if (parameters.$cache !== undefined) {
29054 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29055 }
29056 })
29057 .error(function(data, status, headers, config) {
29058 deferred.reject({
29059 status: status,
29060 headers: headers,
29061 config: config,
29062 body: data
29063 });
29064 });
29065
29066 return deferred.promise;
29067 };
29068 /**
29069 *
29070 * @method
29071 * @name xos#Controller_Dashboard_View_Detail_GET
29072 * @param {string} pk -
29073 *
29074 */
29075 xos.prototype.Controller_Dashboard_View_Detail_GET = function(parameters) {
29076 if (parameters === undefined) {
29077 parameters = {};
29078 }
29079 var deferred = $q.defer();
29080
29081 var domain = this.domain;
29082 var path = '/xos/controllerdashboardviews/{pk}/';
29083
29084 var body;
29085 var queryParameters = {};
29086 var headers = {};
29087 var form = {};
29088
29089 path = path.replace('{pk}', parameters['pk']);
29090
29091 if (parameters['pk'] === undefined) {
29092 deferred.reject(new Error('Missing required path parameter: pk'));
29093 return deferred.promise;
29094 }
29095
29096 if (parameters.$queryParameters) {
29097 Object.keys(parameters.$queryParameters)
29098 .forEach(function(parameterName) {
29099 var parameter = parameters.$queryParameters[parameterName];
29100 queryParameters[parameterName] = parameter;
29101 });
29102 }
29103
29104 var url = domain + path;
29105 var cached = parameters.$cache && parameters.$cache.get(url);
29106 if (cached !== undefined && parameters.$refresh !== true) {
29107 deferred.resolve(cached);
29108 return deferred.promise;
29109 }
29110 var options = {
29111 timeout: parameters.$timeout,
29112 method: 'GET',
29113 url: url,
29114 params: queryParameters,
29115 data: body,
29116 headers: headers
29117 };
29118 if (Object.keys(form).length > 0) {
29119 options.data = form;
29120 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29121 options.transformRequest = xos.transformRequest;
29122 }
29123 $http(options)
29124 .success(function(data, status, headers, config) {
29125 deferred.resolve(data);
29126 if (parameters.$cache !== undefined) {
29127 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29128 }
29129 })
29130 .error(function(data, status, headers, config) {
29131 deferred.reject({
29132 status: status,
29133 headers: headers,
29134 config: config,
29135 body: data
29136 });
29137 });
29138
29139 return deferred.promise;
29140 };
29141 /**
29142 *
29143 * @method
29144 * @name xos#Controller_Dashboard_View_Detail_PUT
29145 * @param {string} pk -
29146 * @param {string} enacted -
29147 * @param {string} policed -
29148 * @param {string} backend_register -
29149 * @param {string} backend_status -
29150 * @param {boolean} deleted -
29151 * @param {boolean} write_protect -
29152 * @param {boolean} lazy_blocked -
29153 * @param {boolean} no_sync -
29154 * @param {string} controller -
29155 * @param {string} dashboardView -
29156 * @param {boolean} enabled -
29157 * @param {string} url - URL of Dashboard
29158 *
29159 */
29160 xos.prototype.Controller_Dashboard_View_Detail_PUT = function(parameters) {
29161 if (parameters === undefined) {
29162 parameters = {};
29163 }
29164 var deferred = $q.defer();
29165
29166 var domain = this.domain;
29167 var path = '/xos/controllerdashboardviews/{pk}/';
29168
29169 var body;
29170 var queryParameters = {};
29171 var headers = {};
29172 var form = {};
29173
29174 path = path.replace('{pk}', parameters['pk']);
29175
29176 if (parameters['pk'] === undefined) {
29177 deferred.reject(new Error('Missing required path parameter: pk'));
29178 return deferred.promise;
29179 }
29180
29181 if (parameters['enacted'] !== undefined) {
29182 form['enacted'] = parameters['enacted'];
29183 }
29184
29185 if (parameters['policed'] !== undefined) {
29186 form['policed'] = parameters['policed'];
29187 }
29188
29189 if (parameters['backend_register'] !== undefined) {
29190 form['backend_register'] = parameters['backend_register'];
29191 }
29192
29193 if (parameters['backend_status'] !== undefined) {
29194 form['backend_status'] = parameters['backend_status'];
29195 }
29196
29197 if (parameters['backend_status'] === undefined) {
29198 deferred.reject(new Error('Missing required form parameter: backend_status'));
29199 return deferred.promise;
29200 }
29201
29202 if (parameters['deleted'] !== undefined) {
29203 form['deleted'] = parameters['deleted'];
29204 }
29205
29206 if (parameters['write_protect'] !== undefined) {
29207 form['write_protect'] = parameters['write_protect'];
29208 }
29209
29210 if (parameters['lazy_blocked'] !== undefined) {
29211 form['lazy_blocked'] = parameters['lazy_blocked'];
29212 }
29213
29214 if (parameters['no_sync'] !== undefined) {
29215 form['no_sync'] = parameters['no_sync'];
29216 }
29217
29218 if (parameters['controller'] !== undefined) {
29219 form['controller'] = parameters['controller'];
29220 }
29221
29222 if (parameters['controller'] === undefined) {
29223 deferred.reject(new Error('Missing required form parameter: controller'));
29224 return deferred.promise;
29225 }
29226
29227 if (parameters['dashboardView'] !== undefined) {
29228 form['dashboardView'] = parameters['dashboardView'];
29229 }
29230
29231 if (parameters['dashboardView'] === undefined) {
29232 deferred.reject(new Error('Missing required form parameter: dashboardView'));
29233 return deferred.promise;
29234 }
29235
29236 if (parameters['enabled'] !== undefined) {
29237 form['enabled'] = parameters['enabled'];
29238 }
29239
29240 if (parameters['url'] !== undefined) {
29241 form['url'] = parameters['url'];
29242 }
29243
29244 if (parameters['url'] === undefined) {
29245 deferred.reject(new Error('Missing required form parameter: url'));
29246 return deferred.promise;
29247 }
29248
29249 if (parameters.$queryParameters) {
29250 Object.keys(parameters.$queryParameters)
29251 .forEach(function(parameterName) {
29252 var parameter = parameters.$queryParameters[parameterName];
29253 queryParameters[parameterName] = parameter;
29254 });
29255 }
29256
29257 var url = domain + path;
29258 var options = {
29259 timeout: parameters.$timeout,
29260 method: 'PUT',
29261 url: url,
29262 params: queryParameters,
29263 data: body,
29264 headers: headers
29265 };
29266 if (Object.keys(form).length > 0) {
29267 options.data = form;
29268 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29269 options.transformRequest = xos.transformRequest;
29270 }
29271 $http(options)
29272 .success(function(data, status, headers, config) {
29273 deferred.resolve(data);
29274 if (parameters.$cache !== undefined) {
29275 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29276 }
29277 })
29278 .error(function(data, status, headers, config) {
29279 deferred.reject({
29280 status: status,
29281 headers: headers,
29282 config: config,
29283 body: data
29284 });
29285 });
29286
29287 return deferred.promise;
29288 };
29289 /**
29290 *
29291 * @method
29292 * @name xos#Controller_Dashboard_View_Detail_PATCH
29293 * @param {string} pk -
29294 * @param {string} enacted -
29295 * @param {string} policed -
29296 * @param {string} backend_register -
29297 * @param {string} backend_status -
29298 * @param {boolean} deleted -
29299 * @param {boolean} write_protect -
29300 * @param {boolean} lazy_blocked -
29301 * @param {boolean} no_sync -
29302 * @param {string} controller -
29303 * @param {string} dashboardView -
29304 * @param {boolean} enabled -
29305 * @param {string} url - URL of Dashboard
29306 *
29307 */
29308 xos.prototype.Controller_Dashboard_View_Detail_PATCH = function(parameters) {
29309 if (parameters === undefined) {
29310 parameters = {};
29311 }
29312 var deferred = $q.defer();
29313
29314 var domain = this.domain;
29315 var path = '/xos/controllerdashboardviews/{pk}/';
29316
29317 var body;
29318 var queryParameters = {};
29319 var headers = {};
29320 var form = {};
29321
29322 path = path.replace('{pk}', parameters['pk']);
29323
29324 if (parameters['pk'] === undefined) {
29325 deferred.reject(new Error('Missing required path parameter: pk'));
29326 return deferred.promise;
29327 }
29328
29329 if (parameters['enacted'] !== undefined) {
29330 form['enacted'] = parameters['enacted'];
29331 }
29332
29333 if (parameters['policed'] !== undefined) {
29334 form['policed'] = parameters['policed'];
29335 }
29336
29337 if (parameters['backend_register'] !== undefined) {
29338 form['backend_register'] = parameters['backend_register'];
29339 }
29340
29341 if (parameters['backend_status'] !== undefined) {
29342 form['backend_status'] = parameters['backend_status'];
29343 }
29344
29345 if (parameters['deleted'] !== undefined) {
29346 form['deleted'] = parameters['deleted'];
29347 }
29348
29349 if (parameters['write_protect'] !== undefined) {
29350 form['write_protect'] = parameters['write_protect'];
29351 }
29352
29353 if (parameters['lazy_blocked'] !== undefined) {
29354 form['lazy_blocked'] = parameters['lazy_blocked'];
29355 }
29356
29357 if (parameters['no_sync'] !== undefined) {
29358 form['no_sync'] = parameters['no_sync'];
29359 }
29360
29361 if (parameters['controller'] !== undefined) {
29362 form['controller'] = parameters['controller'];
29363 }
29364
29365 if (parameters['dashboardView'] !== undefined) {
29366 form['dashboardView'] = parameters['dashboardView'];
29367 }
29368
29369 if (parameters['enabled'] !== undefined) {
29370 form['enabled'] = parameters['enabled'];
29371 }
29372
29373 if (parameters['url'] !== undefined) {
29374 form['url'] = parameters['url'];
29375 }
29376
29377 if (parameters.$queryParameters) {
29378 Object.keys(parameters.$queryParameters)
29379 .forEach(function(parameterName) {
29380 var parameter = parameters.$queryParameters[parameterName];
29381 queryParameters[parameterName] = parameter;
29382 });
29383 }
29384
29385 var url = domain + path;
29386 var options = {
29387 timeout: parameters.$timeout,
29388 method: 'PATCH',
29389 url: url,
29390 params: queryParameters,
29391 data: body,
29392 headers: headers
29393 };
29394 if (Object.keys(form).length > 0) {
29395 options.data = form;
29396 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29397 options.transformRequest = xos.transformRequest;
29398 }
29399 $http(options)
29400 .success(function(data, status, headers, config) {
29401 deferred.resolve(data);
29402 if (parameters.$cache !== undefined) {
29403 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29404 }
29405 })
29406 .error(function(data, status, headers, config) {
29407 deferred.reject({
29408 status: status,
29409 headers: headers,
29410 config: config,
29411 body: data
29412 });
29413 });
29414
29415 return deferred.promise;
29416 };
29417 /**
29418 *
29419 * @method
29420 * @name xos#Controller_Dashboard_View_Detail_DELETE
29421 * @param {string} pk -
29422 *
29423 */
29424 xos.prototype.Controller_Dashboard_View_Detail_DELETE = function(parameters) {
29425 if (parameters === undefined) {
29426 parameters = {};
29427 }
29428 var deferred = $q.defer();
29429
29430 var domain = this.domain;
29431 var path = '/xos/controllerdashboardviews/{pk}/';
29432
29433 var body;
29434 var queryParameters = {};
29435 var headers = {};
29436 var form = {};
29437
29438 path = path.replace('{pk}', parameters['pk']);
29439
29440 if (parameters['pk'] === undefined) {
29441 deferred.reject(new Error('Missing required path parameter: pk'));
29442 return deferred.promise;
29443 }
29444
29445 if (parameters.$queryParameters) {
29446 Object.keys(parameters.$queryParameters)
29447 .forEach(function(parameterName) {
29448 var parameter = parameters.$queryParameters[parameterName];
29449 queryParameters[parameterName] = parameter;
29450 });
29451 }
29452
29453 var url = domain + path;
29454 var options = {
29455 timeout: parameters.$timeout,
29456 method: 'DELETE',
29457 url: url,
29458 params: queryParameters,
29459 data: body,
29460 headers: headers
29461 };
29462 if (Object.keys(form).length > 0) {
29463 options.data = form;
29464 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29465 options.transformRequest = xos.transformRequest;
29466 }
29467 $http(options)
29468 .success(function(data, status, headers, config) {
29469 deferred.resolve(data);
29470 if (parameters.$cache !== undefined) {
29471 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29472 }
29473 })
29474 .error(function(data, status, headers, config) {
29475 deferred.reject({
29476 status: status,
29477 headers: headers,
29478 config: config,
29479 body: data
29480 });
29481 });
29482
29483 return deferred.promise;
29484 };
29485 /**
29486 *
29487 * @method
29488 * @name xos#Account_List_GET
29489 *
29490 */
29491 xos.prototype.Account_List_GET = function(parameters) {
29492 if (parameters === undefined) {
29493 parameters = {};
29494 }
29495 var deferred = $q.defer();
29496
29497 var domain = this.domain;
29498 var path = '/xos/accounts/';
29499
29500 var body;
29501 var queryParameters = {};
29502 var headers = {};
29503 var form = {};
29504
29505 if (parameters.$queryParameters) {
29506 Object.keys(parameters.$queryParameters)
29507 .forEach(function(parameterName) {
29508 var parameter = parameters.$queryParameters[parameterName];
29509 queryParameters[parameterName] = parameter;
29510 });
29511 }
29512
29513 var url = domain + path;
29514 var cached = parameters.$cache && parameters.$cache.get(url);
29515 if (cached !== undefined && parameters.$refresh !== true) {
29516 deferred.resolve(cached);
29517 return deferred.promise;
29518 }
29519 var options = {
29520 timeout: parameters.$timeout,
29521 method: 'GET',
29522 url: url,
29523 params: queryParameters,
29524 data: body,
29525 headers: headers
29526 };
29527 if (Object.keys(form).length > 0) {
29528 options.data = form;
29529 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29530 options.transformRequest = xos.transformRequest;
29531 }
29532 $http(options)
29533 .success(function(data, status, headers, config) {
29534 deferred.resolve(data);
29535 if (parameters.$cache !== undefined) {
29536 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29537 }
29538 })
29539 .error(function(data, status, headers, config) {
29540 deferred.reject({
29541 status: status,
29542 headers: headers,
29543 config: config,
29544 body: data
29545 });
29546 });
29547
29548 return deferred.promise;
29549 };
29550 /**
29551 *
29552 * @method
29553 * @name xos#Account_List_POST
29554 * @param {string} enacted -
29555 * @param {string} policed -
29556 * @param {string} backend_register -
29557 * @param {string} backend_status -
29558 * @param {boolean} deleted -
29559 * @param {boolean} write_protect -
29560 * @param {boolean} lazy_blocked -
29561 * @param {boolean} no_sync -
29562 * @param {string} site - Site for this account
29563 *
29564 */
29565 xos.prototype.Account_List_POST = function(parameters) {
29566 if (parameters === undefined) {
29567 parameters = {};
29568 }
29569 var deferred = $q.defer();
29570
29571 var domain = this.domain;
29572 var path = '/xos/accounts/';
29573
29574 var body;
29575 var queryParameters = {};
29576 var headers = {};
29577 var form = {};
29578
29579 if (parameters['enacted'] !== undefined) {
29580 form['enacted'] = parameters['enacted'];
29581 }
29582
29583 if (parameters['policed'] !== undefined) {
29584 form['policed'] = parameters['policed'];
29585 }
29586
29587 if (parameters['backend_register'] !== undefined) {
29588 form['backend_register'] = parameters['backend_register'];
29589 }
29590
29591 if (parameters['backend_status'] !== undefined) {
29592 form['backend_status'] = parameters['backend_status'];
29593 }
29594
29595 if (parameters['backend_status'] === undefined) {
29596 deferred.reject(new Error('Missing required form parameter: backend_status'));
29597 return deferred.promise;
29598 }
29599
29600 if (parameters['deleted'] !== undefined) {
29601 form['deleted'] = parameters['deleted'];
29602 }
29603
29604 if (parameters['write_protect'] !== undefined) {
29605 form['write_protect'] = parameters['write_protect'];
29606 }
29607
29608 if (parameters['lazy_blocked'] !== undefined) {
29609 form['lazy_blocked'] = parameters['lazy_blocked'];
29610 }
29611
29612 if (parameters['no_sync'] !== undefined) {
29613 form['no_sync'] = parameters['no_sync'];
29614 }
29615
29616 if (parameters['site'] !== undefined) {
29617 form['site'] = parameters['site'];
29618 }
29619
29620 if (parameters['site'] === undefined) {
29621 deferred.reject(new Error('Missing required form parameter: site'));
29622 return deferred.promise;
29623 }
29624
29625 if (parameters.$queryParameters) {
29626 Object.keys(parameters.$queryParameters)
29627 .forEach(function(parameterName) {
29628 var parameter = parameters.$queryParameters[parameterName];
29629 queryParameters[parameterName] = parameter;
29630 });
29631 }
29632
29633 var url = domain + path;
29634 var options = {
29635 timeout: parameters.$timeout,
29636 method: 'POST',
29637 url: url,
29638 params: queryParameters,
29639 data: body,
29640 headers: headers
29641 };
29642 if (Object.keys(form).length > 0) {
29643 options.data = form;
29644 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29645 options.transformRequest = xos.transformRequest;
29646 }
29647 $http(options)
29648 .success(function(data, status, headers, config) {
29649 deferred.resolve(data);
29650 if (parameters.$cache !== undefined) {
29651 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29652 }
29653 })
29654 .error(function(data, status, headers, config) {
29655 deferred.reject({
29656 status: status,
29657 headers: headers,
29658 config: config,
29659 body: data
29660 });
29661 });
29662
29663 return deferred.promise;
29664 };
29665 /**
29666 *
29667 * @method
29668 * @name xos#Account_Detail_GET
29669 * @param {string} pk -
29670 *
29671 */
29672 xos.prototype.Account_Detail_GET = function(parameters) {
29673 if (parameters === undefined) {
29674 parameters = {};
29675 }
29676 var deferred = $q.defer();
29677
29678 var domain = this.domain;
29679 var path = '/xos/accounts/{pk}/';
29680
29681 var body;
29682 var queryParameters = {};
29683 var headers = {};
29684 var form = {};
29685
29686 path = path.replace('{pk}', parameters['pk']);
29687
29688 if (parameters['pk'] === undefined) {
29689 deferred.reject(new Error('Missing required path parameter: pk'));
29690 return deferred.promise;
29691 }
29692
29693 if (parameters.$queryParameters) {
29694 Object.keys(parameters.$queryParameters)
29695 .forEach(function(parameterName) {
29696 var parameter = parameters.$queryParameters[parameterName];
29697 queryParameters[parameterName] = parameter;
29698 });
29699 }
29700
29701 var url = domain + path;
29702 var cached = parameters.$cache && parameters.$cache.get(url);
29703 if (cached !== undefined && parameters.$refresh !== true) {
29704 deferred.resolve(cached);
29705 return deferred.promise;
29706 }
29707 var options = {
29708 timeout: parameters.$timeout,
29709 method: 'GET',
29710 url: url,
29711 params: queryParameters,
29712 data: body,
29713 headers: headers
29714 };
29715 if (Object.keys(form).length > 0) {
29716 options.data = form;
29717 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29718 options.transformRequest = xos.transformRequest;
29719 }
29720 $http(options)
29721 .success(function(data, status, headers, config) {
29722 deferred.resolve(data);
29723 if (parameters.$cache !== undefined) {
29724 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29725 }
29726 })
29727 .error(function(data, status, headers, config) {
29728 deferred.reject({
29729 status: status,
29730 headers: headers,
29731 config: config,
29732 body: data
29733 });
29734 });
29735
29736 return deferred.promise;
29737 };
29738 /**
29739 *
29740 * @method
29741 * @name xos#Account_Detail_PUT
29742 * @param {string} pk -
29743 * @param {string} enacted -
29744 * @param {string} policed -
29745 * @param {string} backend_register -
29746 * @param {string} backend_status -
29747 * @param {boolean} deleted -
29748 * @param {boolean} write_protect -
29749 * @param {boolean} lazy_blocked -
29750 * @param {boolean} no_sync -
29751 * @param {string} site - Site for this account
29752 *
29753 */
29754 xos.prototype.Account_Detail_PUT = function(parameters) {
29755 if (parameters === undefined) {
29756 parameters = {};
29757 }
29758 var deferred = $q.defer();
29759
29760 var domain = this.domain;
29761 var path = '/xos/accounts/{pk}/';
29762
29763 var body;
29764 var queryParameters = {};
29765 var headers = {};
29766 var form = {};
29767
29768 path = path.replace('{pk}', parameters['pk']);
29769
29770 if (parameters['pk'] === undefined) {
29771 deferred.reject(new Error('Missing required path parameter: pk'));
29772 return deferred.promise;
29773 }
29774
29775 if (parameters['enacted'] !== undefined) {
29776 form['enacted'] = parameters['enacted'];
29777 }
29778
29779 if (parameters['policed'] !== undefined) {
29780 form['policed'] = parameters['policed'];
29781 }
29782
29783 if (parameters['backend_register'] !== undefined) {
29784 form['backend_register'] = parameters['backend_register'];
29785 }
29786
29787 if (parameters['backend_status'] !== undefined) {
29788 form['backend_status'] = parameters['backend_status'];
29789 }
29790
29791 if (parameters['backend_status'] === undefined) {
29792 deferred.reject(new Error('Missing required form parameter: backend_status'));
29793 return deferred.promise;
29794 }
29795
29796 if (parameters['deleted'] !== undefined) {
29797 form['deleted'] = parameters['deleted'];
29798 }
29799
29800 if (parameters['write_protect'] !== undefined) {
29801 form['write_protect'] = parameters['write_protect'];
29802 }
29803
29804 if (parameters['lazy_blocked'] !== undefined) {
29805 form['lazy_blocked'] = parameters['lazy_blocked'];
29806 }
29807
29808 if (parameters['no_sync'] !== undefined) {
29809 form['no_sync'] = parameters['no_sync'];
29810 }
29811
29812 if (parameters['site'] !== undefined) {
29813 form['site'] = parameters['site'];
29814 }
29815
29816 if (parameters['site'] === undefined) {
29817 deferred.reject(new Error('Missing required form parameter: site'));
29818 return deferred.promise;
29819 }
29820
29821 if (parameters.$queryParameters) {
29822 Object.keys(parameters.$queryParameters)
29823 .forEach(function(parameterName) {
29824 var parameter = parameters.$queryParameters[parameterName];
29825 queryParameters[parameterName] = parameter;
29826 });
29827 }
29828
29829 var url = domain + path;
29830 var options = {
29831 timeout: parameters.$timeout,
29832 method: 'PUT',
29833 url: url,
29834 params: queryParameters,
29835 data: body,
29836 headers: headers
29837 };
29838 if (Object.keys(form).length > 0) {
29839 options.data = form;
29840 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29841 options.transformRequest = xos.transformRequest;
29842 }
29843 $http(options)
29844 .success(function(data, status, headers, config) {
29845 deferred.resolve(data);
29846 if (parameters.$cache !== undefined) {
29847 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29848 }
29849 })
29850 .error(function(data, status, headers, config) {
29851 deferred.reject({
29852 status: status,
29853 headers: headers,
29854 config: config,
29855 body: data
29856 });
29857 });
29858
29859 return deferred.promise;
29860 };
29861 /**
29862 *
29863 * @method
29864 * @name xos#Account_Detail_PATCH
29865 * @param {string} pk -
29866 * @param {string} enacted -
29867 * @param {string} policed -
29868 * @param {string} backend_register -
29869 * @param {string} backend_status -
29870 * @param {boolean} deleted -
29871 * @param {boolean} write_protect -
29872 * @param {boolean} lazy_blocked -
29873 * @param {boolean} no_sync -
29874 * @param {string} site - Site for this account
29875 *
29876 */
29877 xos.prototype.Account_Detail_PATCH = function(parameters) {
29878 if (parameters === undefined) {
29879 parameters = {};
29880 }
29881 var deferred = $q.defer();
29882
29883 var domain = this.domain;
29884 var path = '/xos/accounts/{pk}/';
29885
29886 var body;
29887 var queryParameters = {};
29888 var headers = {};
29889 var form = {};
29890
29891 path = path.replace('{pk}', parameters['pk']);
29892
29893 if (parameters['pk'] === undefined) {
29894 deferred.reject(new Error('Missing required path parameter: pk'));
29895 return deferred.promise;
29896 }
29897
29898 if (parameters['enacted'] !== undefined) {
29899 form['enacted'] = parameters['enacted'];
29900 }
29901
29902 if (parameters['policed'] !== undefined) {
29903 form['policed'] = parameters['policed'];
29904 }
29905
29906 if (parameters['backend_register'] !== undefined) {
29907 form['backend_register'] = parameters['backend_register'];
29908 }
29909
29910 if (parameters['backend_status'] !== undefined) {
29911 form['backend_status'] = parameters['backend_status'];
29912 }
29913
29914 if (parameters['deleted'] !== undefined) {
29915 form['deleted'] = parameters['deleted'];
29916 }
29917
29918 if (parameters['write_protect'] !== undefined) {
29919 form['write_protect'] = parameters['write_protect'];
29920 }
29921
29922 if (parameters['lazy_blocked'] !== undefined) {
29923 form['lazy_blocked'] = parameters['lazy_blocked'];
29924 }
29925
29926 if (parameters['no_sync'] !== undefined) {
29927 form['no_sync'] = parameters['no_sync'];
29928 }
29929
29930 if (parameters['site'] !== undefined) {
29931 form['site'] = parameters['site'];
29932 }
29933
29934 if (parameters.$queryParameters) {
29935 Object.keys(parameters.$queryParameters)
29936 .forEach(function(parameterName) {
29937 var parameter = parameters.$queryParameters[parameterName];
29938 queryParameters[parameterName] = parameter;
29939 });
29940 }
29941
29942 var url = domain + path;
29943 var options = {
29944 timeout: parameters.$timeout,
29945 method: 'PATCH',
29946 url: url,
29947 params: queryParameters,
29948 data: body,
29949 headers: headers
29950 };
29951 if (Object.keys(form).length > 0) {
29952 options.data = form;
29953 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
29954 options.transformRequest = xos.transformRequest;
29955 }
29956 $http(options)
29957 .success(function(data, status, headers, config) {
29958 deferred.resolve(data);
29959 if (parameters.$cache !== undefined) {
29960 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
29961 }
29962 })
29963 .error(function(data, status, headers, config) {
29964 deferred.reject({
29965 status: status,
29966 headers: headers,
29967 config: config,
29968 body: data
29969 });
29970 });
29971
29972 return deferred.promise;
29973 };
29974 /**
29975 *
29976 * @method
29977 * @name xos#Account_Detail_DELETE
29978 * @param {string} pk -
29979 *
29980 */
29981 xos.prototype.Account_Detail_DELETE = function(parameters) {
29982 if (parameters === undefined) {
29983 parameters = {};
29984 }
29985 var deferred = $q.defer();
29986
29987 var domain = this.domain;
29988 var path = '/xos/accounts/{pk}/';
29989
29990 var body;
29991 var queryParameters = {};
29992 var headers = {};
29993 var form = {};
29994
29995 path = path.replace('{pk}', parameters['pk']);
29996
29997 if (parameters['pk'] === undefined) {
29998 deferred.reject(new Error('Missing required path parameter: pk'));
29999 return deferred.promise;
30000 }
30001
30002 if (parameters.$queryParameters) {
30003 Object.keys(parameters.$queryParameters)
30004 .forEach(function(parameterName) {
30005 var parameter = parameters.$queryParameters[parameterName];
30006 queryParameters[parameterName] = parameter;
30007 });
30008 }
30009
30010 var url = domain + path;
30011 var options = {
30012 timeout: parameters.$timeout,
30013 method: 'DELETE',
30014 url: url,
30015 params: queryParameters,
30016 data: body,
30017 headers: headers
30018 };
30019 if (Object.keys(form).length > 0) {
30020 options.data = form;
30021 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30022 options.transformRequest = xos.transformRequest;
30023 }
30024 $http(options)
30025 .success(function(data, status, headers, config) {
30026 deferred.resolve(data);
30027 if (parameters.$cache !== undefined) {
30028 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30029 }
30030 })
30031 .error(function(data, status, headers, config) {
30032 deferred.reject({
30033 status: status,
30034 headers: headers,
30035 config: config,
30036 body: data
30037 });
30038 });
30039
30040 return deferred.promise;
30041 };
30042 /**
30043 *
30044 * @method
30045 * @name xos#Tenant_Root_List_GET
30046 *
30047 */
30048 xos.prototype.Tenant_Root_List_GET = function(parameters) {
30049 if (parameters === undefined) {
30050 parameters = {};
30051 }
30052 var deferred = $q.defer();
30053
30054 var domain = this.domain;
30055 var path = '/xos/tenantroots/';
30056
30057 var body;
30058 var queryParameters = {};
30059 var headers = {};
30060 var form = {};
30061
30062 if (parameters.$queryParameters) {
30063 Object.keys(parameters.$queryParameters)
30064 .forEach(function(parameterName) {
30065 var parameter = parameters.$queryParameters[parameterName];
30066 queryParameters[parameterName] = parameter;
30067 });
30068 }
30069
30070 var url = domain + path;
30071 var cached = parameters.$cache && parameters.$cache.get(url);
30072 if (cached !== undefined && parameters.$refresh !== true) {
30073 deferred.resolve(cached);
30074 return deferred.promise;
30075 }
30076 var options = {
30077 timeout: parameters.$timeout,
30078 method: 'GET',
30079 url: url,
30080 params: queryParameters,
30081 data: body,
30082 headers: headers
30083 };
30084 if (Object.keys(form).length > 0) {
30085 options.data = form;
30086 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30087 options.transformRequest = xos.transformRequest;
30088 }
30089 $http(options)
30090 .success(function(data, status, headers, config) {
30091 deferred.resolve(data);
30092 if (parameters.$cache !== undefined) {
30093 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30094 }
30095 })
30096 .error(function(data, status, headers, config) {
30097 deferred.reject({
30098 status: status,
30099 headers: headers,
30100 config: config,
30101 body: data
30102 });
30103 });
30104
30105 return deferred.promise;
30106 };
30107 /**
30108 *
30109 * @method
30110 * @name xos#Tenant_Root_List_POST
30111 * @param {string} enacted -
30112 * @param {string} policed -
30113 * @param {string} backend_register -
30114 * @param {string} backend_status -
30115 * @param {boolean} deleted -
30116 * @param {boolean} write_protect -
30117 * @param {boolean} lazy_blocked -
30118 * @param {boolean} no_sync -
30119 * @param {string} kind -
30120 * @param {string} name - name
30121 * @param {string} service_specific_attribute -
30122 * @param {string} service_specific_id -
30123 *
30124 */
30125 xos.prototype.Tenant_Root_List_POST = function(parameters) {
30126 if (parameters === undefined) {
30127 parameters = {};
30128 }
30129 var deferred = $q.defer();
30130
30131 var domain = this.domain;
30132 var path = '/xos/tenantroots/';
30133
30134 var body;
30135 var queryParameters = {};
30136 var headers = {};
30137 var form = {};
30138
30139 if (parameters['enacted'] !== undefined) {
30140 form['enacted'] = parameters['enacted'];
30141 }
30142
30143 if (parameters['policed'] !== undefined) {
30144 form['policed'] = parameters['policed'];
30145 }
30146
30147 if (parameters['backend_register'] !== undefined) {
30148 form['backend_register'] = parameters['backend_register'];
30149 }
30150
30151 if (parameters['backend_status'] !== undefined) {
30152 form['backend_status'] = parameters['backend_status'];
30153 }
30154
30155 if (parameters['backend_status'] === undefined) {
30156 deferred.reject(new Error('Missing required form parameter: backend_status'));
30157 return deferred.promise;
30158 }
30159
30160 if (parameters['deleted'] !== undefined) {
30161 form['deleted'] = parameters['deleted'];
30162 }
30163
30164 if (parameters['write_protect'] !== undefined) {
30165 form['write_protect'] = parameters['write_protect'];
30166 }
30167
30168 if (parameters['lazy_blocked'] !== undefined) {
30169 form['lazy_blocked'] = parameters['lazy_blocked'];
30170 }
30171
30172 if (parameters['no_sync'] !== undefined) {
30173 form['no_sync'] = parameters['no_sync'];
30174 }
30175
30176 if (parameters['kind'] !== undefined) {
30177 form['kind'] = parameters['kind'];
30178 }
30179
30180 if (parameters['kind'] === undefined) {
30181 deferred.reject(new Error('Missing required form parameter: kind'));
30182 return deferred.promise;
30183 }
30184
30185 if (parameters['name'] !== undefined) {
30186 form['name'] = parameters['name'];
30187 }
30188
30189 if (parameters['service_specific_attribute'] !== undefined) {
30190 form['service_specific_attribute'] = parameters['service_specific_attribute'];
30191 }
30192
30193 if (parameters['service_specific_id'] !== undefined) {
30194 form['service_specific_id'] = parameters['service_specific_id'];
30195 }
30196
30197 if (parameters.$queryParameters) {
30198 Object.keys(parameters.$queryParameters)
30199 .forEach(function(parameterName) {
30200 var parameter = parameters.$queryParameters[parameterName];
30201 queryParameters[parameterName] = parameter;
30202 });
30203 }
30204
30205 var url = domain + path;
30206 var options = {
30207 timeout: parameters.$timeout,
30208 method: 'POST',
30209 url: url,
30210 params: queryParameters,
30211 data: body,
30212 headers: headers
30213 };
30214 if (Object.keys(form).length > 0) {
30215 options.data = form;
30216 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30217 options.transformRequest = xos.transformRequest;
30218 }
30219 $http(options)
30220 .success(function(data, status, headers, config) {
30221 deferred.resolve(data);
30222 if (parameters.$cache !== undefined) {
30223 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30224 }
30225 })
30226 .error(function(data, status, headers, config) {
30227 deferred.reject({
30228 status: status,
30229 headers: headers,
30230 config: config,
30231 body: data
30232 });
30233 });
30234
30235 return deferred.promise;
30236 };
30237 /**
30238 *
30239 * @method
30240 * @name xos#Tenant_Root_Detail_GET
30241 * @param {string} pk -
30242 *
30243 */
30244 xos.prototype.Tenant_Root_Detail_GET = function(parameters) {
30245 if (parameters === undefined) {
30246 parameters = {};
30247 }
30248 var deferred = $q.defer();
30249
30250 var domain = this.domain;
30251 var path = '/xos/tenantroots/{pk}/';
30252
30253 var body;
30254 var queryParameters = {};
30255 var headers = {};
30256 var form = {};
30257
30258 path = path.replace('{pk}', parameters['pk']);
30259
30260 if (parameters['pk'] === undefined) {
30261 deferred.reject(new Error('Missing required path parameter: pk'));
30262 return deferred.promise;
30263 }
30264
30265 if (parameters.$queryParameters) {
30266 Object.keys(parameters.$queryParameters)
30267 .forEach(function(parameterName) {
30268 var parameter = parameters.$queryParameters[parameterName];
30269 queryParameters[parameterName] = parameter;
30270 });
30271 }
30272
30273 var url = domain + path;
30274 var cached = parameters.$cache && parameters.$cache.get(url);
30275 if (cached !== undefined && parameters.$refresh !== true) {
30276 deferred.resolve(cached);
30277 return deferred.promise;
30278 }
30279 var options = {
30280 timeout: parameters.$timeout,
30281 method: 'GET',
30282 url: url,
30283 params: queryParameters,
30284 data: body,
30285 headers: headers
30286 };
30287 if (Object.keys(form).length > 0) {
30288 options.data = form;
30289 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30290 options.transformRequest = xos.transformRequest;
30291 }
30292 $http(options)
30293 .success(function(data, status, headers, config) {
30294 deferred.resolve(data);
30295 if (parameters.$cache !== undefined) {
30296 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30297 }
30298 })
30299 .error(function(data, status, headers, config) {
30300 deferred.reject({
30301 status: status,
30302 headers: headers,
30303 config: config,
30304 body: data
30305 });
30306 });
30307
30308 return deferred.promise;
30309 };
30310 /**
30311 *
30312 * @method
30313 * @name xos#Tenant_Root_Detail_PUT
30314 * @param {string} pk -
30315 * @param {string} enacted -
30316 * @param {string} policed -
30317 * @param {string} backend_register -
30318 * @param {string} backend_status -
30319 * @param {boolean} deleted -
30320 * @param {boolean} write_protect -
30321 * @param {boolean} lazy_blocked -
30322 * @param {boolean} no_sync -
30323 * @param {string} kind -
30324 * @param {string} name - name
30325 * @param {string} service_specific_attribute -
30326 * @param {string} service_specific_id -
30327 *
30328 */
30329 xos.prototype.Tenant_Root_Detail_PUT = function(parameters) {
30330 if (parameters === undefined) {
30331 parameters = {};
30332 }
30333 var deferred = $q.defer();
30334
30335 var domain = this.domain;
30336 var path = '/xos/tenantroots/{pk}/';
30337
30338 var body;
30339 var queryParameters = {};
30340 var headers = {};
30341 var form = {};
30342
30343 path = path.replace('{pk}', parameters['pk']);
30344
30345 if (parameters['pk'] === undefined) {
30346 deferred.reject(new Error('Missing required path parameter: pk'));
30347 return deferred.promise;
30348 }
30349
30350 if (parameters['enacted'] !== undefined) {
30351 form['enacted'] = parameters['enacted'];
30352 }
30353
30354 if (parameters['policed'] !== undefined) {
30355 form['policed'] = parameters['policed'];
30356 }
30357
30358 if (parameters['backend_register'] !== undefined) {
30359 form['backend_register'] = parameters['backend_register'];
30360 }
30361
30362 if (parameters['backend_status'] !== undefined) {
30363 form['backend_status'] = parameters['backend_status'];
30364 }
30365
30366 if (parameters['backend_status'] === undefined) {
30367 deferred.reject(new Error('Missing required form parameter: backend_status'));
30368 return deferred.promise;
30369 }
30370
30371 if (parameters['deleted'] !== undefined) {
30372 form['deleted'] = parameters['deleted'];
30373 }
30374
30375 if (parameters['write_protect'] !== undefined) {
30376 form['write_protect'] = parameters['write_protect'];
30377 }
30378
30379 if (parameters['lazy_blocked'] !== undefined) {
30380 form['lazy_blocked'] = parameters['lazy_blocked'];
30381 }
30382
30383 if (parameters['no_sync'] !== undefined) {
30384 form['no_sync'] = parameters['no_sync'];
30385 }
30386
30387 if (parameters['kind'] !== undefined) {
30388 form['kind'] = parameters['kind'];
30389 }
30390
30391 if (parameters['kind'] === undefined) {
30392 deferred.reject(new Error('Missing required form parameter: kind'));
30393 return deferred.promise;
30394 }
30395
30396 if (parameters['name'] !== undefined) {
30397 form['name'] = parameters['name'];
30398 }
30399
30400 if (parameters['service_specific_attribute'] !== undefined) {
30401 form['service_specific_attribute'] = parameters['service_specific_attribute'];
30402 }
30403
30404 if (parameters['service_specific_id'] !== undefined) {
30405 form['service_specific_id'] = parameters['service_specific_id'];
30406 }
30407
30408 if (parameters.$queryParameters) {
30409 Object.keys(parameters.$queryParameters)
30410 .forEach(function(parameterName) {
30411 var parameter = parameters.$queryParameters[parameterName];
30412 queryParameters[parameterName] = parameter;
30413 });
30414 }
30415
30416 var url = domain + path;
30417 var options = {
30418 timeout: parameters.$timeout,
30419 method: 'PUT',
30420 url: url,
30421 params: queryParameters,
30422 data: body,
30423 headers: headers
30424 };
30425 if (Object.keys(form).length > 0) {
30426 options.data = form;
30427 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30428 options.transformRequest = xos.transformRequest;
30429 }
30430 $http(options)
30431 .success(function(data, status, headers, config) {
30432 deferred.resolve(data);
30433 if (parameters.$cache !== undefined) {
30434 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30435 }
30436 })
30437 .error(function(data, status, headers, config) {
30438 deferred.reject({
30439 status: status,
30440 headers: headers,
30441 config: config,
30442 body: data
30443 });
30444 });
30445
30446 return deferred.promise;
30447 };
30448 /**
30449 *
30450 * @method
30451 * @name xos#Tenant_Root_Detail_PATCH
30452 * @param {string} pk -
30453 * @param {string} enacted -
30454 * @param {string} policed -
30455 * @param {string} backend_register -
30456 * @param {string} backend_status -
30457 * @param {boolean} deleted -
30458 * @param {boolean} write_protect -
30459 * @param {boolean} lazy_blocked -
30460 * @param {boolean} no_sync -
30461 * @param {string} kind -
30462 * @param {string} name - name
30463 * @param {string} service_specific_attribute -
30464 * @param {string} service_specific_id -
30465 *
30466 */
30467 xos.prototype.Tenant_Root_Detail_PATCH = function(parameters) {
30468 if (parameters === undefined) {
30469 parameters = {};
30470 }
30471 var deferred = $q.defer();
30472
30473 var domain = this.domain;
30474 var path = '/xos/tenantroots/{pk}/';
30475
30476 var body;
30477 var queryParameters = {};
30478 var headers = {};
30479 var form = {};
30480
30481 path = path.replace('{pk}', parameters['pk']);
30482
30483 if (parameters['pk'] === undefined) {
30484 deferred.reject(new Error('Missing required path parameter: pk'));
30485 return deferred.promise;
30486 }
30487
30488 if (parameters['enacted'] !== undefined) {
30489 form['enacted'] = parameters['enacted'];
30490 }
30491
30492 if (parameters['policed'] !== undefined) {
30493 form['policed'] = parameters['policed'];
30494 }
30495
30496 if (parameters['backend_register'] !== undefined) {
30497 form['backend_register'] = parameters['backend_register'];
30498 }
30499
30500 if (parameters['backend_status'] !== undefined) {
30501 form['backend_status'] = parameters['backend_status'];
30502 }
30503
30504 if (parameters['deleted'] !== undefined) {
30505 form['deleted'] = parameters['deleted'];
30506 }
30507
30508 if (parameters['write_protect'] !== undefined) {
30509 form['write_protect'] = parameters['write_protect'];
30510 }
30511
30512 if (parameters['lazy_blocked'] !== undefined) {
30513 form['lazy_blocked'] = parameters['lazy_blocked'];
30514 }
30515
30516 if (parameters['no_sync'] !== undefined) {
30517 form['no_sync'] = parameters['no_sync'];
30518 }
30519
30520 if (parameters['kind'] !== undefined) {
30521 form['kind'] = parameters['kind'];
30522 }
30523
30524 if (parameters['name'] !== undefined) {
30525 form['name'] = parameters['name'];
30526 }
30527
30528 if (parameters['service_specific_attribute'] !== undefined) {
30529 form['service_specific_attribute'] = parameters['service_specific_attribute'];
30530 }
30531
30532 if (parameters['service_specific_id'] !== undefined) {
30533 form['service_specific_id'] = parameters['service_specific_id'];
30534 }
30535
30536 if (parameters.$queryParameters) {
30537 Object.keys(parameters.$queryParameters)
30538 .forEach(function(parameterName) {
30539 var parameter = parameters.$queryParameters[parameterName];
30540 queryParameters[parameterName] = parameter;
30541 });
30542 }
30543
30544 var url = domain + path;
30545 var options = {
30546 timeout: parameters.$timeout,
30547 method: 'PATCH',
30548 url: url,
30549 params: queryParameters,
30550 data: body,
30551 headers: headers
30552 };
30553 if (Object.keys(form).length > 0) {
30554 options.data = form;
30555 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30556 options.transformRequest = xos.transformRequest;
30557 }
30558 $http(options)
30559 .success(function(data, status, headers, config) {
30560 deferred.resolve(data);
30561 if (parameters.$cache !== undefined) {
30562 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30563 }
30564 })
30565 .error(function(data, status, headers, config) {
30566 deferred.reject({
30567 status: status,
30568 headers: headers,
30569 config: config,
30570 body: data
30571 });
30572 });
30573
30574 return deferred.promise;
30575 };
30576 /**
30577 *
30578 * @method
30579 * @name xos#Tenant_Root_Detail_DELETE
30580 * @param {string} pk -
30581 *
30582 */
30583 xos.prototype.Tenant_Root_Detail_DELETE = function(parameters) {
30584 if (parameters === undefined) {
30585 parameters = {};
30586 }
30587 var deferred = $q.defer();
30588
30589 var domain = this.domain;
30590 var path = '/xos/tenantroots/{pk}/';
30591
30592 var body;
30593 var queryParameters = {};
30594 var headers = {};
30595 var form = {};
30596
30597 path = path.replace('{pk}', parameters['pk']);
30598
30599 if (parameters['pk'] === undefined) {
30600 deferred.reject(new Error('Missing required path parameter: pk'));
30601 return deferred.promise;
30602 }
30603
30604 if (parameters.$queryParameters) {
30605 Object.keys(parameters.$queryParameters)
30606 .forEach(function(parameterName) {
30607 var parameter = parameters.$queryParameters[parameterName];
30608 queryParameters[parameterName] = parameter;
30609 });
30610 }
30611
30612 var url = domain + path;
30613 var options = {
30614 timeout: parameters.$timeout,
30615 method: 'DELETE',
30616 url: url,
30617 params: queryParameters,
30618 data: body,
30619 headers: headers
30620 };
30621 if (Object.keys(form).length > 0) {
30622 options.data = form;
30623 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30624 options.transformRequest = xos.transformRequest;
30625 }
30626 $http(options)
30627 .success(function(data, status, headers, config) {
30628 deferred.resolve(data);
30629 if (parameters.$cache !== undefined) {
30630 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30631 }
30632 })
30633 .error(function(data, status, headers, config) {
30634 deferred.reject({
30635 status: status,
30636 headers: headers,
30637 config: config,
30638 body: data
30639 });
30640 });
30641
30642 return deferred.promise;
30643 };
30644 /**
30645 *
30646 * @method
30647 * @name xos#Controller_Role_List_GET
30648 *
30649 */
30650 xos.prototype.Controller_Role_List_GET = function(parameters) {
30651 if (parameters === undefined) {
30652 parameters = {};
30653 }
30654 var deferred = $q.defer();
30655
30656 var domain = this.domain;
30657 var path = '/xos/controllerroles/';
30658
30659 var body;
30660 var queryParameters = {};
30661 var headers = {};
30662 var form = {};
30663
30664 if (parameters.$queryParameters) {
30665 Object.keys(parameters.$queryParameters)
30666 .forEach(function(parameterName) {
30667 var parameter = parameters.$queryParameters[parameterName];
30668 queryParameters[parameterName] = parameter;
30669 });
30670 }
30671
30672 var url = domain + path;
30673 var cached = parameters.$cache && parameters.$cache.get(url);
30674 if (cached !== undefined && parameters.$refresh !== true) {
30675 deferred.resolve(cached);
30676 return deferred.promise;
30677 }
30678 var options = {
30679 timeout: parameters.$timeout,
30680 method: 'GET',
30681 url: url,
30682 params: queryParameters,
30683 data: body,
30684 headers: headers
30685 };
30686 if (Object.keys(form).length > 0) {
30687 options.data = form;
30688 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30689 options.transformRequest = xos.transformRequest;
30690 }
30691 $http(options)
30692 .success(function(data, status, headers, config) {
30693 deferred.resolve(data);
30694 if (parameters.$cache !== undefined) {
30695 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30696 }
30697 })
30698 .error(function(data, status, headers, config) {
30699 deferred.reject({
30700 status: status,
30701 headers: headers,
30702 config: config,
30703 body: data
30704 });
30705 });
30706
30707 return deferred.promise;
30708 };
30709 /**
30710 *
30711 * @method
30712 * @name xos#Controller_Role_List_POST
30713 * @param {string} enacted -
30714 * @param {string} policed -
30715 * @param {string} backend_register -
30716 * @param {string} backend_status -
30717 * @param {boolean} deleted -
30718 * @param {boolean} write_protect -
30719 * @param {boolean} lazy_blocked -
30720 * @param {boolean} no_sync -
30721
30722 *
30723 */
30724 xos.prototype.Controller_Role_List_POST = function(parameters) {
30725 if (parameters === undefined) {
30726 parameters = {};
30727 }
30728 var deferred = $q.defer();
30729
30730 var domain = this.domain;
30731 var path = '/xos/controllerroles/';
30732
30733 var body;
30734 var queryParameters = {};
30735 var headers = {};
30736 var form = {};
30737
30738 if (parameters['enacted'] !== undefined) {
30739 form['enacted'] = parameters['enacted'];
30740 }
30741
30742 if (parameters['policed'] !== undefined) {
30743 form['policed'] = parameters['policed'];
30744 }
30745
30746 if (parameters['backend_register'] !== undefined) {
30747 form['backend_register'] = parameters['backend_register'];
30748 }
30749
30750 if (parameters['backend_status'] !== undefined) {
30751 form['backend_status'] = parameters['backend_status'];
30752 }
30753
30754 if (parameters['backend_status'] === undefined) {
30755 deferred.reject(new Error('Missing required form parameter: backend_status'));
30756 return deferred.promise;
30757 }
30758
30759 if (parameters['deleted'] !== undefined) {
30760 form['deleted'] = parameters['deleted'];
30761 }
30762
30763 if (parameters['write_protect'] !== undefined) {
30764 form['write_protect'] = parameters['write_protect'];
30765 }
30766
30767 if (parameters['lazy_blocked'] !== undefined) {
30768 form['lazy_blocked'] = parameters['lazy_blocked'];
30769 }
30770
30771 if (parameters['no_sync'] !== undefined) {
30772 form['no_sync'] = parameters['no_sync'];
30773 }
30774
30775 form['role'] = 'admin';
30776
30777 if (parameters['role'] === undefined) {
30778 deferred.reject(new Error('Missing required form parameter: role'));
30779 return deferred.promise;
30780 }
30781
30782 if (parameters.$queryParameters) {
30783 Object.keys(parameters.$queryParameters)
30784 .forEach(function(parameterName) {
30785 var parameter = parameters.$queryParameters[parameterName];
30786 queryParameters[parameterName] = parameter;
30787 });
30788 }
30789
30790 var url = domain + path;
30791 var options = {
30792 timeout: parameters.$timeout,
30793 method: 'POST',
30794 url: url,
30795 params: queryParameters,
30796 data: body,
30797 headers: headers
30798 };
30799 if (Object.keys(form).length > 0) {
30800 options.data = form;
30801 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30802 options.transformRequest = xos.transformRequest;
30803 }
30804 $http(options)
30805 .success(function(data, status, headers, config) {
30806 deferred.resolve(data);
30807 if (parameters.$cache !== undefined) {
30808 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30809 }
30810 })
30811 .error(function(data, status, headers, config) {
30812 deferred.reject({
30813 status: status,
30814 headers: headers,
30815 config: config,
30816 body: data
30817 });
30818 });
30819
30820 return deferred.promise;
30821 };
30822 /**
30823 *
30824 * @method
30825 * @name xos#Controller_Role_Detail_GET
30826 * @param {string} pk -
30827 *
30828 */
30829 xos.prototype.Controller_Role_Detail_GET = function(parameters) {
30830 if (parameters === undefined) {
30831 parameters = {};
30832 }
30833 var deferred = $q.defer();
30834
30835 var domain = this.domain;
30836 var path = '/xos/controllerroles/{pk}/';
30837
30838 var body;
30839 var queryParameters = {};
30840 var headers = {};
30841 var form = {};
30842
30843 path = path.replace('{pk}', parameters['pk']);
30844
30845 if (parameters['pk'] === undefined) {
30846 deferred.reject(new Error('Missing required path parameter: pk'));
30847 return deferred.promise;
30848 }
30849
30850 if (parameters.$queryParameters) {
30851 Object.keys(parameters.$queryParameters)
30852 .forEach(function(parameterName) {
30853 var parameter = parameters.$queryParameters[parameterName];
30854 queryParameters[parameterName] = parameter;
30855 });
30856 }
30857
30858 var url = domain + path;
30859 var cached = parameters.$cache && parameters.$cache.get(url);
30860 if (cached !== undefined && parameters.$refresh !== true) {
30861 deferred.resolve(cached);
30862 return deferred.promise;
30863 }
30864 var options = {
30865 timeout: parameters.$timeout,
30866 method: 'GET',
30867 url: url,
30868 params: queryParameters,
30869 data: body,
30870 headers: headers
30871 };
30872 if (Object.keys(form).length > 0) {
30873 options.data = form;
30874 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30875 options.transformRequest = xos.transformRequest;
30876 }
30877 $http(options)
30878 .success(function(data, status, headers, config) {
30879 deferred.resolve(data);
30880 if (parameters.$cache !== undefined) {
30881 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
30882 }
30883 })
30884 .error(function(data, status, headers, config) {
30885 deferred.reject({
30886 status: status,
30887 headers: headers,
30888 config: config,
30889 body: data
30890 });
30891 });
30892
30893 return deferred.promise;
30894 };
30895 /**
30896 *
30897 * @method
30898 * @name xos#Controller_Role_Detail_PUT
30899 * @param {string} pk -
30900 * @param {string} enacted -
30901 * @param {string} policed -
30902 * @param {string} backend_register -
30903 * @param {string} backend_status -
30904 * @param {boolean} deleted -
30905 * @param {boolean} write_protect -
30906 * @param {boolean} lazy_blocked -
30907 * @param {boolean} no_sync -
30908
30909 *
30910 */
30911 xos.prototype.Controller_Role_Detail_PUT = function(parameters) {
30912 if (parameters === undefined) {
30913 parameters = {};
30914 }
30915 var deferred = $q.defer();
30916
30917 var domain = this.domain;
30918 var path = '/xos/controllerroles/{pk}/';
30919
30920 var body;
30921 var queryParameters = {};
30922 var headers = {};
30923 var form = {};
30924
30925 path = path.replace('{pk}', parameters['pk']);
30926
30927 if (parameters['pk'] === undefined) {
30928 deferred.reject(new Error('Missing required path parameter: pk'));
30929 return deferred.promise;
30930 }
30931
30932 if (parameters['enacted'] !== undefined) {
30933 form['enacted'] = parameters['enacted'];
30934 }
30935
30936 if (parameters['policed'] !== undefined) {
30937 form['policed'] = parameters['policed'];
30938 }
30939
30940 if (parameters['backend_register'] !== undefined) {
30941 form['backend_register'] = parameters['backend_register'];
30942 }
30943
30944 if (parameters['backend_status'] !== undefined) {
30945 form['backend_status'] = parameters['backend_status'];
30946 }
30947
30948 if (parameters['backend_status'] === undefined) {
30949 deferred.reject(new Error('Missing required form parameter: backend_status'));
30950 return deferred.promise;
30951 }
30952
30953 if (parameters['deleted'] !== undefined) {
30954 form['deleted'] = parameters['deleted'];
30955 }
30956
30957 if (parameters['write_protect'] !== undefined) {
30958 form['write_protect'] = parameters['write_protect'];
30959 }
30960
30961 if (parameters['lazy_blocked'] !== undefined) {
30962 form['lazy_blocked'] = parameters['lazy_blocked'];
30963 }
30964
30965 if (parameters['no_sync'] !== undefined) {
30966 form['no_sync'] = parameters['no_sync'];
30967 }
30968
30969 form['role'] = 'admin';
30970
30971 if (parameters['role'] === undefined) {
30972 deferred.reject(new Error('Missing required form parameter: role'));
30973 return deferred.promise;
30974 }
30975
30976 if (parameters.$queryParameters) {
30977 Object.keys(parameters.$queryParameters)
30978 .forEach(function(parameterName) {
30979 var parameter = parameters.$queryParameters[parameterName];
30980 queryParameters[parameterName] = parameter;
30981 });
30982 }
30983
30984 var url = domain + path;
30985 var options = {
30986 timeout: parameters.$timeout,
30987 method: 'PUT',
30988 url: url,
30989 params: queryParameters,
30990 data: body,
30991 headers: headers
30992 };
30993 if (Object.keys(form).length > 0) {
30994 options.data = form;
30995 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
30996 options.transformRequest = xos.transformRequest;
30997 }
30998 $http(options)
30999 .success(function(data, status, headers, config) {
31000 deferred.resolve(data);
31001 if (parameters.$cache !== undefined) {
31002 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31003 }
31004 })
31005 .error(function(data, status, headers, config) {
31006 deferred.reject({
31007 status: status,
31008 headers: headers,
31009 config: config,
31010 body: data
31011 });
31012 });
31013
31014 return deferred.promise;
31015 };
31016 /**
31017 *
31018 * @method
31019 * @name xos#Controller_Role_Detail_PATCH
31020 * @param {string} pk -
31021 * @param {string} enacted -
31022 * @param {string} policed -
31023 * @param {string} backend_register -
31024 * @param {string} backend_status -
31025 * @param {boolean} deleted -
31026 * @param {boolean} write_protect -
31027 * @param {boolean} lazy_blocked -
31028 * @param {boolean} no_sync -
31029
31030 *
31031 */
31032 xos.prototype.Controller_Role_Detail_PATCH = function(parameters) {
31033 if (parameters === undefined) {
31034 parameters = {};
31035 }
31036 var deferred = $q.defer();
31037
31038 var domain = this.domain;
31039 var path = '/xos/controllerroles/{pk}/';
31040
31041 var body;
31042 var queryParameters = {};
31043 var headers = {};
31044 var form = {};
31045
31046 path = path.replace('{pk}', parameters['pk']);
31047
31048 if (parameters['pk'] === undefined) {
31049 deferred.reject(new Error('Missing required path parameter: pk'));
31050 return deferred.promise;
31051 }
31052
31053 if (parameters['enacted'] !== undefined) {
31054 form['enacted'] = parameters['enacted'];
31055 }
31056
31057 if (parameters['policed'] !== undefined) {
31058 form['policed'] = parameters['policed'];
31059 }
31060
31061 if (parameters['backend_register'] !== undefined) {
31062 form['backend_register'] = parameters['backend_register'];
31063 }
31064
31065 if (parameters['backend_status'] !== undefined) {
31066 form['backend_status'] = parameters['backend_status'];
31067 }
31068
31069 if (parameters['deleted'] !== undefined) {
31070 form['deleted'] = parameters['deleted'];
31071 }
31072
31073 if (parameters['write_protect'] !== undefined) {
31074 form['write_protect'] = parameters['write_protect'];
31075 }
31076
31077 if (parameters['lazy_blocked'] !== undefined) {
31078 form['lazy_blocked'] = parameters['lazy_blocked'];
31079 }
31080
31081 if (parameters['no_sync'] !== undefined) {
31082 form['no_sync'] = parameters['no_sync'];
31083 }
31084
31085 form['role'] = 'admin';
31086
31087 if (parameters.$queryParameters) {
31088 Object.keys(parameters.$queryParameters)
31089 .forEach(function(parameterName) {
31090 var parameter = parameters.$queryParameters[parameterName];
31091 queryParameters[parameterName] = parameter;
31092 });
31093 }
31094
31095 var url = domain + path;
31096 var options = {
31097 timeout: parameters.$timeout,
31098 method: 'PATCH',
31099 url: url,
31100 params: queryParameters,
31101 data: body,
31102 headers: headers
31103 };
31104 if (Object.keys(form).length > 0) {
31105 options.data = form;
31106 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31107 options.transformRequest = xos.transformRequest;
31108 }
31109 $http(options)
31110 .success(function(data, status, headers, config) {
31111 deferred.resolve(data);
31112 if (parameters.$cache !== undefined) {
31113 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31114 }
31115 })
31116 .error(function(data, status, headers, config) {
31117 deferred.reject({
31118 status: status,
31119 headers: headers,
31120 config: config,
31121 body: data
31122 });
31123 });
31124
31125 return deferred.promise;
31126 };
31127 /**
31128 *
31129 * @method
31130 * @name xos#Controller_Role_Detail_DELETE
31131 * @param {string} pk -
31132 *
31133 */
31134 xos.prototype.Controller_Role_Detail_DELETE = function(parameters) {
31135 if (parameters === undefined) {
31136 parameters = {};
31137 }
31138 var deferred = $q.defer();
31139
31140 var domain = this.domain;
31141 var path = '/xos/controllerroles/{pk}/';
31142
31143 var body;
31144 var queryParameters = {};
31145 var headers = {};
31146 var form = {};
31147
31148 path = path.replace('{pk}', parameters['pk']);
31149
31150 if (parameters['pk'] === undefined) {
31151 deferred.reject(new Error('Missing required path parameter: pk'));
31152 return deferred.promise;
31153 }
31154
31155 if (parameters.$queryParameters) {
31156 Object.keys(parameters.$queryParameters)
31157 .forEach(function(parameterName) {
31158 var parameter = parameters.$queryParameters[parameterName];
31159 queryParameters[parameterName] = parameter;
31160 });
31161 }
31162
31163 var url = domain + path;
31164 var options = {
31165 timeout: parameters.$timeout,
31166 method: 'DELETE',
31167 url: url,
31168 params: queryParameters,
31169 data: body,
31170 headers: headers
31171 };
31172 if (Object.keys(form).length > 0) {
31173 options.data = form;
31174 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31175 options.transformRequest = xos.transformRequest;
31176 }
31177 $http(options)
31178 .success(function(data, status, headers, config) {
31179 deferred.resolve(data);
31180 if (parameters.$cache !== undefined) {
31181 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31182 }
31183 })
31184 .error(function(data, status, headers, config) {
31185 deferred.reject({
31186 status: status,
31187 headers: headers,
31188 config: config,
31189 body: data
31190 });
31191 });
31192
31193 return deferred.promise;
31194 };
31195 /**
31196 *
31197 * @method
31198 * @name xos#Network_Parameter_Type_List_GET
31199 *
31200 */
31201 xos.prototype.Network_Parameter_Type_List_GET = function(parameters) {
31202 if (parameters === undefined) {
31203 parameters = {};
31204 }
31205 var deferred = $q.defer();
31206
31207 var domain = this.domain;
31208 var path = '/xos/networkparametertypes/';
31209
31210 var body;
31211 var queryParameters = {};
31212 var headers = {};
31213 var form = {};
31214
31215 if (parameters.$queryParameters) {
31216 Object.keys(parameters.$queryParameters)
31217 .forEach(function(parameterName) {
31218 var parameter = parameters.$queryParameters[parameterName];
31219 queryParameters[parameterName] = parameter;
31220 });
31221 }
31222
31223 var url = domain + path;
31224 var cached = parameters.$cache && parameters.$cache.get(url);
31225 if (cached !== undefined && parameters.$refresh !== true) {
31226 deferred.resolve(cached);
31227 return deferred.promise;
31228 }
31229 var options = {
31230 timeout: parameters.$timeout,
31231 method: 'GET',
31232 url: url,
31233 params: queryParameters,
31234 data: body,
31235 headers: headers
31236 };
31237 if (Object.keys(form).length > 0) {
31238 options.data = form;
31239 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31240 options.transformRequest = xos.transformRequest;
31241 }
31242 $http(options)
31243 .success(function(data, status, headers, config) {
31244 deferred.resolve(data);
31245 if (parameters.$cache !== undefined) {
31246 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31247 }
31248 })
31249 .error(function(data, status, headers, config) {
31250 deferred.reject({
31251 status: status,
31252 headers: headers,
31253 config: config,
31254 body: data
31255 });
31256 });
31257
31258 return deferred.promise;
31259 };
31260 /**
31261 *
31262 * @method
31263 * @name xos#Network_Parameter_Type_List_POST
31264 * @param {string} enacted -
31265 * @param {string} policed -
31266 * @param {string} backend_register -
31267 * @param {string} backend_status -
31268 * @param {boolean} deleted -
31269 * @param {boolean} write_protect -
31270 * @param {boolean} lazy_blocked -
31271 * @param {boolean} no_sync -
31272 * @param {string} name - The name of this parameter
31273 * @param {string} description -
31274 *
31275 */
31276 xos.prototype.Network_Parameter_Type_List_POST = function(parameters) {
31277 if (parameters === undefined) {
31278 parameters = {};
31279 }
31280 var deferred = $q.defer();
31281
31282 var domain = this.domain;
31283 var path = '/xos/networkparametertypes/';
31284
31285 var body;
31286 var queryParameters = {};
31287 var headers = {};
31288 var form = {};
31289
31290 if (parameters['enacted'] !== undefined) {
31291 form['enacted'] = parameters['enacted'];
31292 }
31293
31294 if (parameters['policed'] !== undefined) {
31295 form['policed'] = parameters['policed'];
31296 }
31297
31298 if (parameters['backend_register'] !== undefined) {
31299 form['backend_register'] = parameters['backend_register'];
31300 }
31301
31302 if (parameters['backend_status'] !== undefined) {
31303 form['backend_status'] = parameters['backend_status'];
31304 }
31305
31306 if (parameters['backend_status'] === undefined) {
31307 deferred.reject(new Error('Missing required form parameter: backend_status'));
31308 return deferred.promise;
31309 }
31310
31311 if (parameters['deleted'] !== undefined) {
31312 form['deleted'] = parameters['deleted'];
31313 }
31314
31315 if (parameters['write_protect'] !== undefined) {
31316 form['write_protect'] = parameters['write_protect'];
31317 }
31318
31319 if (parameters['lazy_blocked'] !== undefined) {
31320 form['lazy_blocked'] = parameters['lazy_blocked'];
31321 }
31322
31323 if (parameters['no_sync'] !== undefined) {
31324 form['no_sync'] = parameters['no_sync'];
31325 }
31326
31327 if (parameters['name'] !== undefined) {
31328 form['name'] = parameters['name'];
31329 }
31330
31331 if (parameters['name'] === undefined) {
31332 deferred.reject(new Error('Missing required form parameter: name'));
31333 return deferred.promise;
31334 }
31335
31336 if (parameters['description'] !== undefined) {
31337 form['description'] = parameters['description'];
31338 }
31339
31340 if (parameters['description'] === undefined) {
31341 deferred.reject(new Error('Missing required form parameter: description'));
31342 return deferred.promise;
31343 }
31344
31345 if (parameters.$queryParameters) {
31346 Object.keys(parameters.$queryParameters)
31347 .forEach(function(parameterName) {
31348 var parameter = parameters.$queryParameters[parameterName];
31349 queryParameters[parameterName] = parameter;
31350 });
31351 }
31352
31353 var url = domain + path;
31354 var options = {
31355 timeout: parameters.$timeout,
31356 method: 'POST',
31357 url: url,
31358 params: queryParameters,
31359 data: body,
31360 headers: headers
31361 };
31362 if (Object.keys(form).length > 0) {
31363 options.data = form;
31364 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31365 options.transformRequest = xos.transformRequest;
31366 }
31367 $http(options)
31368 .success(function(data, status, headers, config) {
31369 deferred.resolve(data);
31370 if (parameters.$cache !== undefined) {
31371 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31372 }
31373 })
31374 .error(function(data, status, headers, config) {
31375 deferred.reject({
31376 status: status,
31377 headers: headers,
31378 config: config,
31379 body: data
31380 });
31381 });
31382
31383 return deferred.promise;
31384 };
31385 /**
31386 *
31387 * @method
31388 * @name xos#Network_Parameter_Type_Detail_GET
31389 * @param {string} pk -
31390 *
31391 */
31392 xos.prototype.Network_Parameter_Type_Detail_GET = function(parameters) {
31393 if (parameters === undefined) {
31394 parameters = {};
31395 }
31396 var deferred = $q.defer();
31397
31398 var domain = this.domain;
31399 var path = '/xos/networkparametertypes/{pk}/';
31400
31401 var body;
31402 var queryParameters = {};
31403 var headers = {};
31404 var form = {};
31405
31406 path = path.replace('{pk}', parameters['pk']);
31407
31408 if (parameters['pk'] === undefined) {
31409 deferred.reject(new Error('Missing required path parameter: pk'));
31410 return deferred.promise;
31411 }
31412
31413 if (parameters.$queryParameters) {
31414 Object.keys(parameters.$queryParameters)
31415 .forEach(function(parameterName) {
31416 var parameter = parameters.$queryParameters[parameterName];
31417 queryParameters[parameterName] = parameter;
31418 });
31419 }
31420
31421 var url = domain + path;
31422 var cached = parameters.$cache && parameters.$cache.get(url);
31423 if (cached !== undefined && parameters.$refresh !== true) {
31424 deferred.resolve(cached);
31425 return deferred.promise;
31426 }
31427 var options = {
31428 timeout: parameters.$timeout,
31429 method: 'GET',
31430 url: url,
31431 params: queryParameters,
31432 data: body,
31433 headers: headers
31434 };
31435 if (Object.keys(form).length > 0) {
31436 options.data = form;
31437 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31438 options.transformRequest = xos.transformRequest;
31439 }
31440 $http(options)
31441 .success(function(data, status, headers, config) {
31442 deferred.resolve(data);
31443 if (parameters.$cache !== undefined) {
31444 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31445 }
31446 })
31447 .error(function(data, status, headers, config) {
31448 deferred.reject({
31449 status: status,
31450 headers: headers,
31451 config: config,
31452 body: data
31453 });
31454 });
31455
31456 return deferred.promise;
31457 };
31458 /**
31459 *
31460 * @method
31461 * @name xos#Network_Parameter_Type_Detail_PUT
31462 * @param {string} pk -
31463 * @param {string} enacted -
31464 * @param {string} policed -
31465 * @param {string} backend_register -
31466 * @param {string} backend_status -
31467 * @param {boolean} deleted -
31468 * @param {boolean} write_protect -
31469 * @param {boolean} lazy_blocked -
31470 * @param {boolean} no_sync -
31471 * @param {string} name - The name of this parameter
31472 * @param {string} description -
31473 *
31474 */
31475 xos.prototype.Network_Parameter_Type_Detail_PUT = function(parameters) {
31476 if (parameters === undefined) {
31477 parameters = {};
31478 }
31479 var deferred = $q.defer();
31480
31481 var domain = this.domain;
31482 var path = '/xos/networkparametertypes/{pk}/';
31483
31484 var body;
31485 var queryParameters = {};
31486 var headers = {};
31487 var form = {};
31488
31489 path = path.replace('{pk}', parameters['pk']);
31490
31491 if (parameters['pk'] === undefined) {
31492 deferred.reject(new Error('Missing required path parameter: pk'));
31493 return deferred.promise;
31494 }
31495
31496 if (parameters['enacted'] !== undefined) {
31497 form['enacted'] = parameters['enacted'];
31498 }
31499
31500 if (parameters['policed'] !== undefined) {
31501 form['policed'] = parameters['policed'];
31502 }
31503
31504 if (parameters['backend_register'] !== undefined) {
31505 form['backend_register'] = parameters['backend_register'];
31506 }
31507
31508 if (parameters['backend_status'] !== undefined) {
31509 form['backend_status'] = parameters['backend_status'];
31510 }
31511
31512 if (parameters['backend_status'] === undefined) {
31513 deferred.reject(new Error('Missing required form parameter: backend_status'));
31514 return deferred.promise;
31515 }
31516
31517 if (parameters['deleted'] !== undefined) {
31518 form['deleted'] = parameters['deleted'];
31519 }
31520
31521 if (parameters['write_protect'] !== undefined) {
31522 form['write_protect'] = parameters['write_protect'];
31523 }
31524
31525 if (parameters['lazy_blocked'] !== undefined) {
31526 form['lazy_blocked'] = parameters['lazy_blocked'];
31527 }
31528
31529 if (parameters['no_sync'] !== undefined) {
31530 form['no_sync'] = parameters['no_sync'];
31531 }
31532
31533 if (parameters['name'] !== undefined) {
31534 form['name'] = parameters['name'];
31535 }
31536
31537 if (parameters['name'] === undefined) {
31538 deferred.reject(new Error('Missing required form parameter: name'));
31539 return deferred.promise;
31540 }
31541
31542 if (parameters['description'] !== undefined) {
31543 form['description'] = parameters['description'];
31544 }
31545
31546 if (parameters['description'] === undefined) {
31547 deferred.reject(new Error('Missing required form parameter: description'));
31548 return deferred.promise;
31549 }
31550
31551 if (parameters.$queryParameters) {
31552 Object.keys(parameters.$queryParameters)
31553 .forEach(function(parameterName) {
31554 var parameter = parameters.$queryParameters[parameterName];
31555 queryParameters[parameterName] = parameter;
31556 });
31557 }
31558
31559 var url = domain + path;
31560 var options = {
31561 timeout: parameters.$timeout,
31562 method: 'PUT',
31563 url: url,
31564 params: queryParameters,
31565 data: body,
31566 headers: headers
31567 };
31568 if (Object.keys(form).length > 0) {
31569 options.data = form;
31570 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31571 options.transformRequest = xos.transformRequest;
31572 }
31573 $http(options)
31574 .success(function(data, status, headers, config) {
31575 deferred.resolve(data);
31576 if (parameters.$cache !== undefined) {
31577 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31578 }
31579 })
31580 .error(function(data, status, headers, config) {
31581 deferred.reject({
31582 status: status,
31583 headers: headers,
31584 config: config,
31585 body: data
31586 });
31587 });
31588
31589 return deferred.promise;
31590 };
31591 /**
31592 *
31593 * @method
31594 * @name xos#Network_Parameter_Type_Detail_PATCH
31595 * @param {string} pk -
31596 * @param {string} enacted -
31597 * @param {string} policed -
31598 * @param {string} backend_register -
31599 * @param {string} backend_status -
31600 * @param {boolean} deleted -
31601 * @param {boolean} write_protect -
31602 * @param {boolean} lazy_blocked -
31603 * @param {boolean} no_sync -
31604 * @param {string} name - The name of this parameter
31605 * @param {string} description -
31606 *
31607 */
31608 xos.prototype.Network_Parameter_Type_Detail_PATCH = function(parameters) {
31609 if (parameters === undefined) {
31610 parameters = {};
31611 }
31612 var deferred = $q.defer();
31613
31614 var domain = this.domain;
31615 var path = '/xos/networkparametertypes/{pk}/';
31616
31617 var body;
31618 var queryParameters = {};
31619 var headers = {};
31620 var form = {};
31621
31622 path = path.replace('{pk}', parameters['pk']);
31623
31624 if (parameters['pk'] === undefined) {
31625 deferred.reject(new Error('Missing required path parameter: pk'));
31626 return deferred.promise;
31627 }
31628
31629 if (parameters['enacted'] !== undefined) {
31630 form['enacted'] = parameters['enacted'];
31631 }
31632
31633 if (parameters['policed'] !== undefined) {
31634 form['policed'] = parameters['policed'];
31635 }
31636
31637 if (parameters['backend_register'] !== undefined) {
31638 form['backend_register'] = parameters['backend_register'];
31639 }
31640
31641 if (parameters['backend_status'] !== undefined) {
31642 form['backend_status'] = parameters['backend_status'];
31643 }
31644
31645 if (parameters['deleted'] !== undefined) {
31646 form['deleted'] = parameters['deleted'];
31647 }
31648
31649 if (parameters['write_protect'] !== undefined) {
31650 form['write_protect'] = parameters['write_protect'];
31651 }
31652
31653 if (parameters['lazy_blocked'] !== undefined) {
31654 form['lazy_blocked'] = parameters['lazy_blocked'];
31655 }
31656
31657 if (parameters['no_sync'] !== undefined) {
31658 form['no_sync'] = parameters['no_sync'];
31659 }
31660
31661 if (parameters['name'] !== undefined) {
31662 form['name'] = parameters['name'];
31663 }
31664
31665 if (parameters['description'] !== undefined) {
31666 form['description'] = parameters['description'];
31667 }
31668
31669 if (parameters.$queryParameters) {
31670 Object.keys(parameters.$queryParameters)
31671 .forEach(function(parameterName) {
31672 var parameter = parameters.$queryParameters[parameterName];
31673 queryParameters[parameterName] = parameter;
31674 });
31675 }
31676
31677 var url = domain + path;
31678 var options = {
31679 timeout: parameters.$timeout,
31680 method: 'PATCH',
31681 url: url,
31682 params: queryParameters,
31683 data: body,
31684 headers: headers
31685 };
31686 if (Object.keys(form).length > 0) {
31687 options.data = form;
31688 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31689 options.transformRequest = xos.transformRequest;
31690 }
31691 $http(options)
31692 .success(function(data, status, headers, config) {
31693 deferred.resolve(data);
31694 if (parameters.$cache !== undefined) {
31695 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31696 }
31697 })
31698 .error(function(data, status, headers, config) {
31699 deferred.reject({
31700 status: status,
31701 headers: headers,
31702 config: config,
31703 body: data
31704 });
31705 });
31706
31707 return deferred.promise;
31708 };
31709 /**
31710 *
31711 * @method
31712 * @name xos#Network_Parameter_Type_Detail_DELETE
31713 * @param {string} pk -
31714 *
31715 */
31716 xos.prototype.Network_Parameter_Type_Detail_DELETE = function(parameters) {
31717 if (parameters === undefined) {
31718 parameters = {};
31719 }
31720 var deferred = $q.defer();
31721
31722 var domain = this.domain;
31723 var path = '/xos/networkparametertypes/{pk}/';
31724
31725 var body;
31726 var queryParameters = {};
31727 var headers = {};
31728 var form = {};
31729
31730 path = path.replace('{pk}', parameters['pk']);
31731
31732 if (parameters['pk'] === undefined) {
31733 deferred.reject(new Error('Missing required path parameter: pk'));
31734 return deferred.promise;
31735 }
31736
31737 if (parameters.$queryParameters) {
31738 Object.keys(parameters.$queryParameters)
31739 .forEach(function(parameterName) {
31740 var parameter = parameters.$queryParameters[parameterName];
31741 queryParameters[parameterName] = parameter;
31742 });
31743 }
31744
31745 var url = domain + path;
31746 var options = {
31747 timeout: parameters.$timeout,
31748 method: 'DELETE',
31749 url: url,
31750 params: queryParameters,
31751 data: body,
31752 headers: headers
31753 };
31754 if (Object.keys(form).length > 0) {
31755 options.data = form;
31756 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31757 options.transformRequest = xos.transformRequest;
31758 }
31759 $http(options)
31760 .success(function(data, status, headers, config) {
31761 deferred.resolve(data);
31762 if (parameters.$cache !== undefined) {
31763 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31764 }
31765 })
31766 .error(function(data, status, headers, config) {
31767 deferred.reject({
31768 status: status,
31769 headers: headers,
31770 config: config,
31771 body: data
31772 });
31773 });
31774
31775 return deferred.promise;
31776 };
31777 /**
31778 *
31779 * @method
31780 * @name xos#Site_Credential_List_GET
31781 *
31782 */
31783 xos.prototype.Site_Credential_List_GET = function(parameters) {
31784 if (parameters === undefined) {
31785 parameters = {};
31786 }
31787 var deferred = $q.defer();
31788
31789 var domain = this.domain;
31790 var path = '/xos/sitecredentials/';
31791
31792 var body;
31793 var queryParameters = {};
31794 var headers = {};
31795 var form = {};
31796
31797 if (parameters.$queryParameters) {
31798 Object.keys(parameters.$queryParameters)
31799 .forEach(function(parameterName) {
31800 var parameter = parameters.$queryParameters[parameterName];
31801 queryParameters[parameterName] = parameter;
31802 });
31803 }
31804
31805 var url = domain + path;
31806 var cached = parameters.$cache && parameters.$cache.get(url);
31807 if (cached !== undefined && parameters.$refresh !== true) {
31808 deferred.resolve(cached);
31809 return deferred.promise;
31810 }
31811 var options = {
31812 timeout: parameters.$timeout,
31813 method: 'GET',
31814 url: url,
31815 params: queryParameters,
31816 data: body,
31817 headers: headers
31818 };
31819 if (Object.keys(form).length > 0) {
31820 options.data = form;
31821 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31822 options.transformRequest = xos.transformRequest;
31823 }
31824 $http(options)
31825 .success(function(data, status, headers, config) {
31826 deferred.resolve(data);
31827 if (parameters.$cache !== undefined) {
31828 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31829 }
31830 })
31831 .error(function(data, status, headers, config) {
31832 deferred.reject({
31833 status: status,
31834 headers: headers,
31835 config: config,
31836 body: data
31837 });
31838 });
31839
31840 return deferred.promise;
31841 };
31842 /**
31843 *
31844 * @method
31845 * @name xos#Site_Credential_List_POST
31846 * @param {string} enacted -
31847 * @param {string} policed -
31848 * @param {string} backend_register -
31849 * @param {string} backend_status -
31850 * @param {boolean} deleted -
31851 * @param {boolean} write_protect -
31852 * @param {boolean} lazy_blocked -
31853 * @param {boolean} no_sync -
31854 * @param {string} site - The User this credential is associated with
31855 * @param {string} name - The credential type, e.g. ec2
31856 * @param {string} key_id - The backend id of this credential
31857 * @param {string} enc_value - The key value of this credential
31858 *
31859 */
31860 xos.prototype.Site_Credential_List_POST = function(parameters) {
31861 if (parameters === undefined) {
31862 parameters = {};
31863 }
31864 var deferred = $q.defer();
31865
31866 var domain = this.domain;
31867 var path = '/xos/sitecredentials/';
31868
31869 var body;
31870 var queryParameters = {};
31871 var headers = {};
31872 var form = {};
31873
31874 if (parameters['enacted'] !== undefined) {
31875 form['enacted'] = parameters['enacted'];
31876 }
31877
31878 if (parameters['policed'] !== undefined) {
31879 form['policed'] = parameters['policed'];
31880 }
31881
31882 if (parameters['backend_register'] !== undefined) {
31883 form['backend_register'] = parameters['backend_register'];
31884 }
31885
31886 if (parameters['backend_status'] !== undefined) {
31887 form['backend_status'] = parameters['backend_status'];
31888 }
31889
31890 if (parameters['backend_status'] === undefined) {
31891 deferred.reject(new Error('Missing required form parameter: backend_status'));
31892 return deferred.promise;
31893 }
31894
31895 if (parameters['deleted'] !== undefined) {
31896 form['deleted'] = parameters['deleted'];
31897 }
31898
31899 if (parameters['write_protect'] !== undefined) {
31900 form['write_protect'] = parameters['write_protect'];
31901 }
31902
31903 if (parameters['lazy_blocked'] !== undefined) {
31904 form['lazy_blocked'] = parameters['lazy_blocked'];
31905 }
31906
31907 if (parameters['no_sync'] !== undefined) {
31908 form['no_sync'] = parameters['no_sync'];
31909 }
31910
31911 if (parameters['site'] !== undefined) {
31912 form['site'] = parameters['site'];
31913 }
31914
31915 if (parameters['site'] === undefined) {
31916 deferred.reject(new Error('Missing required form parameter: site'));
31917 return deferred.promise;
31918 }
31919
31920 if (parameters['name'] !== undefined) {
31921 form['name'] = parameters['name'];
31922 }
31923
31924 if (parameters['name'] === undefined) {
31925 deferred.reject(new Error('Missing required form parameter: name'));
31926 return deferred.promise;
31927 }
31928
31929 if (parameters['key_id'] !== undefined) {
31930 form['key_id'] = parameters['key_id'];
31931 }
31932
31933 if (parameters['key_id'] === undefined) {
31934 deferred.reject(new Error('Missing required form parameter: key_id'));
31935 return deferred.promise;
31936 }
31937
31938 if (parameters['enc_value'] !== undefined) {
31939 form['enc_value'] = parameters['enc_value'];
31940 }
31941
31942 if (parameters['enc_value'] === undefined) {
31943 deferred.reject(new Error('Missing required form parameter: enc_value'));
31944 return deferred.promise;
31945 }
31946
31947 if (parameters.$queryParameters) {
31948 Object.keys(parameters.$queryParameters)
31949 .forEach(function(parameterName) {
31950 var parameter = parameters.$queryParameters[parameterName];
31951 queryParameters[parameterName] = parameter;
31952 });
31953 }
31954
31955 var url = domain + path;
31956 var options = {
31957 timeout: parameters.$timeout,
31958 method: 'POST',
31959 url: url,
31960 params: queryParameters,
31961 data: body,
31962 headers: headers
31963 };
31964 if (Object.keys(form).length > 0) {
31965 options.data = form;
31966 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
31967 options.transformRequest = xos.transformRequest;
31968 }
31969 $http(options)
31970 .success(function(data, status, headers, config) {
31971 deferred.resolve(data);
31972 if (parameters.$cache !== undefined) {
31973 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
31974 }
31975 })
31976 .error(function(data, status, headers, config) {
31977 deferred.reject({
31978 status: status,
31979 headers: headers,
31980 config: config,
31981 body: data
31982 });
31983 });
31984
31985 return deferred.promise;
31986 };
31987 /**
31988 *
31989 * @method
31990 * @name xos#Site_Credential_Detail_GET
31991 * @param {string} pk -
31992 *
31993 */
31994 xos.prototype.Site_Credential_Detail_GET = function(parameters) {
31995 if (parameters === undefined) {
31996 parameters = {};
31997 }
31998 var deferred = $q.defer();
31999
32000 var domain = this.domain;
32001 var path = '/xos/sitecredentials/{pk}/';
32002
32003 var body;
32004 var queryParameters = {};
32005 var headers = {};
32006 var form = {};
32007
32008 path = path.replace('{pk}', parameters['pk']);
32009
32010 if (parameters['pk'] === undefined) {
32011 deferred.reject(new Error('Missing required path parameter: pk'));
32012 return deferred.promise;
32013 }
32014
32015 if (parameters.$queryParameters) {
32016 Object.keys(parameters.$queryParameters)
32017 .forEach(function(parameterName) {
32018 var parameter = parameters.$queryParameters[parameterName];
32019 queryParameters[parameterName] = parameter;
32020 });
32021 }
32022
32023 var url = domain + path;
32024 var cached = parameters.$cache && parameters.$cache.get(url);
32025 if (cached !== undefined && parameters.$refresh !== true) {
32026 deferred.resolve(cached);
32027 return deferred.promise;
32028 }
32029 var options = {
32030 timeout: parameters.$timeout,
32031 method: 'GET',
32032 url: url,
32033 params: queryParameters,
32034 data: body,
32035 headers: headers
32036 };
32037 if (Object.keys(form).length > 0) {
32038 options.data = form;
32039 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32040 options.transformRequest = xos.transformRequest;
32041 }
32042 $http(options)
32043 .success(function(data, status, headers, config) {
32044 deferred.resolve(data);
32045 if (parameters.$cache !== undefined) {
32046 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32047 }
32048 })
32049 .error(function(data, status, headers, config) {
32050 deferred.reject({
32051 status: status,
32052 headers: headers,
32053 config: config,
32054 body: data
32055 });
32056 });
32057
32058 return deferred.promise;
32059 };
32060 /**
32061 *
32062 * @method
32063 * @name xos#Site_Credential_Detail_PUT
32064 * @param {string} pk -
32065 * @param {string} enacted -
32066 * @param {string} policed -
32067 * @param {string} backend_register -
32068 * @param {string} backend_status -
32069 * @param {boolean} deleted -
32070 * @param {boolean} write_protect -
32071 * @param {boolean} lazy_blocked -
32072 * @param {boolean} no_sync -
32073 * @param {string} site - The User this credential is associated with
32074 * @param {string} name - The credential type, e.g. ec2
32075 * @param {string} key_id - The backend id of this credential
32076 * @param {string} enc_value - The key value of this credential
32077 *
32078 */
32079 xos.prototype.Site_Credential_Detail_PUT = function(parameters) {
32080 if (parameters === undefined) {
32081 parameters = {};
32082 }
32083 var deferred = $q.defer();
32084
32085 var domain = this.domain;
32086 var path = '/xos/sitecredentials/{pk}/';
32087
32088 var body;
32089 var queryParameters = {};
32090 var headers = {};
32091 var form = {};
32092
32093 path = path.replace('{pk}', parameters['pk']);
32094
32095 if (parameters['pk'] === undefined) {
32096 deferred.reject(new Error('Missing required path parameter: pk'));
32097 return deferred.promise;
32098 }
32099
32100 if (parameters['enacted'] !== undefined) {
32101 form['enacted'] = parameters['enacted'];
32102 }
32103
32104 if (parameters['policed'] !== undefined) {
32105 form['policed'] = parameters['policed'];
32106 }
32107
32108 if (parameters['backend_register'] !== undefined) {
32109 form['backend_register'] = parameters['backend_register'];
32110 }
32111
32112 if (parameters['backend_status'] !== undefined) {
32113 form['backend_status'] = parameters['backend_status'];
32114 }
32115
32116 if (parameters['backend_status'] === undefined) {
32117 deferred.reject(new Error('Missing required form parameter: backend_status'));
32118 return deferred.promise;
32119 }
32120
32121 if (parameters['deleted'] !== undefined) {
32122 form['deleted'] = parameters['deleted'];
32123 }
32124
32125 if (parameters['write_protect'] !== undefined) {
32126 form['write_protect'] = parameters['write_protect'];
32127 }
32128
32129 if (parameters['lazy_blocked'] !== undefined) {
32130 form['lazy_blocked'] = parameters['lazy_blocked'];
32131 }
32132
32133 if (parameters['no_sync'] !== undefined) {
32134 form['no_sync'] = parameters['no_sync'];
32135 }
32136
32137 if (parameters['site'] !== undefined) {
32138 form['site'] = parameters['site'];
32139 }
32140
32141 if (parameters['site'] === undefined) {
32142 deferred.reject(new Error('Missing required form parameter: site'));
32143 return deferred.promise;
32144 }
32145
32146 if (parameters['name'] !== undefined) {
32147 form['name'] = parameters['name'];
32148 }
32149
32150 if (parameters['name'] === undefined) {
32151 deferred.reject(new Error('Missing required form parameter: name'));
32152 return deferred.promise;
32153 }
32154
32155 if (parameters['key_id'] !== undefined) {
32156 form['key_id'] = parameters['key_id'];
32157 }
32158
32159 if (parameters['key_id'] === undefined) {
32160 deferred.reject(new Error('Missing required form parameter: key_id'));
32161 return deferred.promise;
32162 }
32163
32164 if (parameters['enc_value'] !== undefined) {
32165 form['enc_value'] = parameters['enc_value'];
32166 }
32167
32168 if (parameters['enc_value'] === undefined) {
32169 deferred.reject(new Error('Missing required form parameter: enc_value'));
32170 return deferred.promise;
32171 }
32172
32173 if (parameters.$queryParameters) {
32174 Object.keys(parameters.$queryParameters)
32175 .forEach(function(parameterName) {
32176 var parameter = parameters.$queryParameters[parameterName];
32177 queryParameters[parameterName] = parameter;
32178 });
32179 }
32180
32181 var url = domain + path;
32182 var options = {
32183 timeout: parameters.$timeout,
32184 method: 'PUT',
32185 url: url,
32186 params: queryParameters,
32187 data: body,
32188 headers: headers
32189 };
32190 if (Object.keys(form).length > 0) {
32191 options.data = form;
32192 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32193 options.transformRequest = xos.transformRequest;
32194 }
32195 $http(options)
32196 .success(function(data, status, headers, config) {
32197 deferred.resolve(data);
32198 if (parameters.$cache !== undefined) {
32199 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32200 }
32201 })
32202 .error(function(data, status, headers, config) {
32203 deferred.reject({
32204 status: status,
32205 headers: headers,
32206 config: config,
32207 body: data
32208 });
32209 });
32210
32211 return deferred.promise;
32212 };
32213 /**
32214 *
32215 * @method
32216 * @name xos#Site_Credential_Detail_PATCH
32217 * @param {string} pk -
32218 * @param {string} enacted -
32219 * @param {string} policed -
32220 * @param {string} backend_register -
32221 * @param {string} backend_status -
32222 * @param {boolean} deleted -
32223 * @param {boolean} write_protect -
32224 * @param {boolean} lazy_blocked -
32225 * @param {boolean} no_sync -
32226 * @param {string} site - The User this credential is associated with
32227 * @param {string} name - The credential type, e.g. ec2
32228 * @param {string} key_id - The backend id of this credential
32229 * @param {string} enc_value - The key value of this credential
32230 *
32231 */
32232 xos.prototype.Site_Credential_Detail_PATCH = function(parameters) {
32233 if (parameters === undefined) {
32234 parameters = {};
32235 }
32236 var deferred = $q.defer();
32237
32238 var domain = this.domain;
32239 var path = '/xos/sitecredentials/{pk}/';
32240
32241 var body;
32242 var queryParameters = {};
32243 var headers = {};
32244 var form = {};
32245
32246 path = path.replace('{pk}', parameters['pk']);
32247
32248 if (parameters['pk'] === undefined) {
32249 deferred.reject(new Error('Missing required path parameter: pk'));
32250 return deferred.promise;
32251 }
32252
32253 if (parameters['enacted'] !== undefined) {
32254 form['enacted'] = parameters['enacted'];
32255 }
32256
32257 if (parameters['policed'] !== undefined) {
32258 form['policed'] = parameters['policed'];
32259 }
32260
32261 if (parameters['backend_register'] !== undefined) {
32262 form['backend_register'] = parameters['backend_register'];
32263 }
32264
32265 if (parameters['backend_status'] !== undefined) {
32266 form['backend_status'] = parameters['backend_status'];
32267 }
32268
32269 if (parameters['deleted'] !== undefined) {
32270 form['deleted'] = parameters['deleted'];
32271 }
32272
32273 if (parameters['write_protect'] !== undefined) {
32274 form['write_protect'] = parameters['write_protect'];
32275 }
32276
32277 if (parameters['lazy_blocked'] !== undefined) {
32278 form['lazy_blocked'] = parameters['lazy_blocked'];
32279 }
32280
32281 if (parameters['no_sync'] !== undefined) {
32282 form['no_sync'] = parameters['no_sync'];
32283 }
32284
32285 if (parameters['site'] !== undefined) {
32286 form['site'] = parameters['site'];
32287 }
32288
32289 if (parameters['name'] !== undefined) {
32290 form['name'] = parameters['name'];
32291 }
32292
32293 if (parameters['key_id'] !== undefined) {
32294 form['key_id'] = parameters['key_id'];
32295 }
32296
32297 if (parameters['enc_value'] !== undefined) {
32298 form['enc_value'] = parameters['enc_value'];
32299 }
32300
32301 if (parameters.$queryParameters) {
32302 Object.keys(parameters.$queryParameters)
32303 .forEach(function(parameterName) {
32304 var parameter = parameters.$queryParameters[parameterName];
32305 queryParameters[parameterName] = parameter;
32306 });
32307 }
32308
32309 var url = domain + path;
32310 var options = {
32311 timeout: parameters.$timeout,
32312 method: 'PATCH',
32313 url: url,
32314 params: queryParameters,
32315 data: body,
32316 headers: headers
32317 };
32318 if (Object.keys(form).length > 0) {
32319 options.data = form;
32320 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32321 options.transformRequest = xos.transformRequest;
32322 }
32323 $http(options)
32324 .success(function(data, status, headers, config) {
32325 deferred.resolve(data);
32326 if (parameters.$cache !== undefined) {
32327 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32328 }
32329 })
32330 .error(function(data, status, headers, config) {
32331 deferred.reject({
32332 status: status,
32333 headers: headers,
32334 config: config,
32335 body: data
32336 });
32337 });
32338
32339 return deferred.promise;
32340 };
32341 /**
32342 *
32343 * @method
32344 * @name xos#Site_Credential_Detail_DELETE
32345 * @param {string} pk -
32346 *
32347 */
32348 xos.prototype.Site_Credential_Detail_DELETE = function(parameters) {
32349 if (parameters === undefined) {
32350 parameters = {};
32351 }
32352 var deferred = $q.defer();
32353
32354 var domain = this.domain;
32355 var path = '/xos/sitecredentials/{pk}/';
32356
32357 var body;
32358 var queryParameters = {};
32359 var headers = {};
32360 var form = {};
32361
32362 path = path.replace('{pk}', parameters['pk']);
32363
32364 if (parameters['pk'] === undefined) {
32365 deferred.reject(new Error('Missing required path parameter: pk'));
32366 return deferred.promise;
32367 }
32368
32369 if (parameters.$queryParameters) {
32370 Object.keys(parameters.$queryParameters)
32371 .forEach(function(parameterName) {
32372 var parameter = parameters.$queryParameters[parameterName];
32373 queryParameters[parameterName] = parameter;
32374 });
32375 }
32376
32377 var url = domain + path;
32378 var options = {
32379 timeout: parameters.$timeout,
32380 method: 'DELETE',
32381 url: url,
32382 params: queryParameters,
32383 data: body,
32384 headers: headers
32385 };
32386 if (Object.keys(form).length > 0) {
32387 options.data = form;
32388 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32389 options.transformRequest = xos.transformRequest;
32390 }
32391 $http(options)
32392 .success(function(data, status, headers, config) {
32393 deferred.resolve(data);
32394 if (parameters.$cache !== undefined) {
32395 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32396 }
32397 })
32398 .error(function(data, status, headers, config) {
32399 deferred.reject({
32400 status: status,
32401 headers: headers,
32402 config: config,
32403 body: data
32404 });
32405 });
32406
32407 return deferred.promise;
32408 };
32409 /**
32410 *
32411 * @method
32412 * @name xos#Deployment_Privilege_List_GET
32413 *
32414 */
32415 xos.prototype.Deployment_Privilege_List_GET = function(parameters) {
32416 if (parameters === undefined) {
32417 parameters = {};
32418 }
32419 var deferred = $q.defer();
32420
32421 var domain = this.domain;
32422 var path = '/xos/deploymentprivileges/';
32423
32424 var body;
32425 var queryParameters = {};
32426 var headers = {};
32427 var form = {};
32428
32429 if (parameters.$queryParameters) {
32430 Object.keys(parameters.$queryParameters)
32431 .forEach(function(parameterName) {
32432 var parameter = parameters.$queryParameters[parameterName];
32433 queryParameters[parameterName] = parameter;
32434 });
32435 }
32436
32437 var url = domain + path;
32438 var cached = parameters.$cache && parameters.$cache.get(url);
32439 if (cached !== undefined && parameters.$refresh !== true) {
32440 deferred.resolve(cached);
32441 return deferred.promise;
32442 }
32443 var options = {
32444 timeout: parameters.$timeout,
32445 method: 'GET',
32446 url: url,
32447 params: queryParameters,
32448 data: body,
32449 headers: headers
32450 };
32451 if (Object.keys(form).length > 0) {
32452 options.data = form;
32453 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32454 options.transformRequest = xos.transformRequest;
32455 }
32456 $http(options)
32457 .success(function(data, status, headers, config) {
32458 deferred.resolve(data);
32459 if (parameters.$cache !== undefined) {
32460 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32461 }
32462 })
32463 .error(function(data, status, headers, config) {
32464 deferred.reject({
32465 status: status,
32466 headers: headers,
32467 config: config,
32468 body: data
32469 });
32470 });
32471
32472 return deferred.promise;
32473 };
32474 /**
32475 *
32476 * @method
32477 * @name xos#Deployment_Privilege_List_POST
32478 * @param {string} enacted -
32479 * @param {string} policed -
32480 * @param {string} backend_register -
32481 * @param {string} backend_status -
32482 * @param {boolean} deleted -
32483 * @param {boolean} write_protect -
32484 * @param {boolean} lazy_blocked -
32485 * @param {boolean} no_sync -
32486 * @param {string} user -
32487 * @param {string} deployment -
32488 * @param {string} role -
32489 *
32490 */
32491 xos.prototype.Deployment_Privilege_List_POST = function(parameters) {
32492 if (parameters === undefined) {
32493 parameters = {};
32494 }
32495 var deferred = $q.defer();
32496
32497 var domain = this.domain;
32498 var path = '/xos/deploymentprivileges/';
32499
32500 var body;
32501 var queryParameters = {};
32502 var headers = {};
32503 var form = {};
32504
32505 if (parameters['enacted'] !== undefined) {
32506 form['enacted'] = parameters['enacted'];
32507 }
32508
32509 if (parameters['policed'] !== undefined) {
32510 form['policed'] = parameters['policed'];
32511 }
32512
32513 if (parameters['backend_register'] !== undefined) {
32514 form['backend_register'] = parameters['backend_register'];
32515 }
32516
32517 if (parameters['backend_status'] !== undefined) {
32518 form['backend_status'] = parameters['backend_status'];
32519 }
32520
32521 if (parameters['backend_status'] === undefined) {
32522 deferred.reject(new Error('Missing required form parameter: backend_status'));
32523 return deferred.promise;
32524 }
32525
32526 if (parameters['deleted'] !== undefined) {
32527 form['deleted'] = parameters['deleted'];
32528 }
32529
32530 if (parameters['write_protect'] !== undefined) {
32531 form['write_protect'] = parameters['write_protect'];
32532 }
32533
32534 if (parameters['lazy_blocked'] !== undefined) {
32535 form['lazy_blocked'] = parameters['lazy_blocked'];
32536 }
32537
32538 if (parameters['no_sync'] !== undefined) {
32539 form['no_sync'] = parameters['no_sync'];
32540 }
32541
32542 if (parameters['user'] !== undefined) {
32543 form['user'] = parameters['user'];
32544 }
32545
32546 if (parameters['user'] === undefined) {
32547 deferred.reject(new Error('Missing required form parameter: user'));
32548 return deferred.promise;
32549 }
32550
32551 if (parameters['deployment'] !== undefined) {
32552 form['deployment'] = parameters['deployment'];
32553 }
32554
32555 if (parameters['deployment'] === undefined) {
32556 deferred.reject(new Error('Missing required form parameter: deployment'));
32557 return deferred.promise;
32558 }
32559
32560 if (parameters['role'] !== undefined) {
32561 form['role'] = parameters['role'];
32562 }
32563
32564 if (parameters['role'] === undefined) {
32565 deferred.reject(new Error('Missing required form parameter: role'));
32566 return deferred.promise;
32567 }
32568
32569 if (parameters.$queryParameters) {
32570 Object.keys(parameters.$queryParameters)
32571 .forEach(function(parameterName) {
32572 var parameter = parameters.$queryParameters[parameterName];
32573 queryParameters[parameterName] = parameter;
32574 });
32575 }
32576
32577 var url = domain + path;
32578 var options = {
32579 timeout: parameters.$timeout,
32580 method: 'POST',
32581 url: url,
32582 params: queryParameters,
32583 data: body,
32584 headers: headers
32585 };
32586 if (Object.keys(form).length > 0) {
32587 options.data = form;
32588 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32589 options.transformRequest = xos.transformRequest;
32590 }
32591 $http(options)
32592 .success(function(data, status, headers, config) {
32593 deferred.resolve(data);
32594 if (parameters.$cache !== undefined) {
32595 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32596 }
32597 })
32598 .error(function(data, status, headers, config) {
32599 deferred.reject({
32600 status: status,
32601 headers: headers,
32602 config: config,
32603 body: data
32604 });
32605 });
32606
32607 return deferred.promise;
32608 };
32609 /**
32610 *
32611 * @method
32612 * @name xos#Deployment_Privilege_Detail_GET
32613 * @param {string} pk -
32614 *
32615 */
32616 xos.prototype.Deployment_Privilege_Detail_GET = function(parameters) {
32617 if (parameters === undefined) {
32618 parameters = {};
32619 }
32620 var deferred = $q.defer();
32621
32622 var domain = this.domain;
32623 var path = '/xos/deploymentprivileges/{pk}/';
32624
32625 var body;
32626 var queryParameters = {};
32627 var headers = {};
32628 var form = {};
32629
32630 path = path.replace('{pk}', parameters['pk']);
32631
32632 if (parameters['pk'] === undefined) {
32633 deferred.reject(new Error('Missing required path parameter: pk'));
32634 return deferred.promise;
32635 }
32636
32637 if (parameters.$queryParameters) {
32638 Object.keys(parameters.$queryParameters)
32639 .forEach(function(parameterName) {
32640 var parameter = parameters.$queryParameters[parameterName];
32641 queryParameters[parameterName] = parameter;
32642 });
32643 }
32644
32645 var url = domain + path;
32646 var cached = parameters.$cache && parameters.$cache.get(url);
32647 if (cached !== undefined && parameters.$refresh !== true) {
32648 deferred.resolve(cached);
32649 return deferred.promise;
32650 }
32651 var options = {
32652 timeout: parameters.$timeout,
32653 method: 'GET',
32654 url: url,
32655 params: queryParameters,
32656 data: body,
32657 headers: headers
32658 };
32659 if (Object.keys(form).length > 0) {
32660 options.data = form;
32661 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32662 options.transformRequest = xos.transformRequest;
32663 }
32664 $http(options)
32665 .success(function(data, status, headers, config) {
32666 deferred.resolve(data);
32667 if (parameters.$cache !== undefined) {
32668 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32669 }
32670 })
32671 .error(function(data, status, headers, config) {
32672 deferred.reject({
32673 status: status,
32674 headers: headers,
32675 config: config,
32676 body: data
32677 });
32678 });
32679
32680 return deferred.promise;
32681 };
32682 /**
32683 *
32684 * @method
32685 * @name xos#Deployment_Privilege_Detail_PUT
32686 * @param {string} pk -
32687 * @param {string} enacted -
32688 * @param {string} policed -
32689 * @param {string} backend_register -
32690 * @param {string} backend_status -
32691 * @param {boolean} deleted -
32692 * @param {boolean} write_protect -
32693 * @param {boolean} lazy_blocked -
32694 * @param {boolean} no_sync -
32695 * @param {string} user -
32696 * @param {string} deployment -
32697 * @param {string} role -
32698 *
32699 */
32700 xos.prototype.Deployment_Privilege_Detail_PUT = function(parameters) {
32701 if (parameters === undefined) {
32702 parameters = {};
32703 }
32704 var deferred = $q.defer();
32705
32706 var domain = this.domain;
32707 var path = '/xos/deploymentprivileges/{pk}/';
32708
32709 var body;
32710 var queryParameters = {};
32711 var headers = {};
32712 var form = {};
32713
32714 path = path.replace('{pk}', parameters['pk']);
32715
32716 if (parameters['pk'] === undefined) {
32717 deferred.reject(new Error('Missing required path parameter: pk'));
32718 return deferred.promise;
32719 }
32720
32721 if (parameters['enacted'] !== undefined) {
32722 form['enacted'] = parameters['enacted'];
32723 }
32724
32725 if (parameters['policed'] !== undefined) {
32726 form['policed'] = parameters['policed'];
32727 }
32728
32729 if (parameters['backend_register'] !== undefined) {
32730 form['backend_register'] = parameters['backend_register'];
32731 }
32732
32733 if (parameters['backend_status'] !== undefined) {
32734 form['backend_status'] = parameters['backend_status'];
32735 }
32736
32737 if (parameters['backend_status'] === undefined) {
32738 deferred.reject(new Error('Missing required form parameter: backend_status'));
32739 return deferred.promise;
32740 }
32741
32742 if (parameters['deleted'] !== undefined) {
32743 form['deleted'] = parameters['deleted'];
32744 }
32745
32746 if (parameters['write_protect'] !== undefined) {
32747 form['write_protect'] = parameters['write_protect'];
32748 }
32749
32750 if (parameters['lazy_blocked'] !== undefined) {
32751 form['lazy_blocked'] = parameters['lazy_blocked'];
32752 }
32753
32754 if (parameters['no_sync'] !== undefined) {
32755 form['no_sync'] = parameters['no_sync'];
32756 }
32757
32758 if (parameters['user'] !== undefined) {
32759 form['user'] = parameters['user'];
32760 }
32761
32762 if (parameters['user'] === undefined) {
32763 deferred.reject(new Error('Missing required form parameter: user'));
32764 return deferred.promise;
32765 }
32766
32767 if (parameters['deployment'] !== undefined) {
32768 form['deployment'] = parameters['deployment'];
32769 }
32770
32771 if (parameters['deployment'] === undefined) {
32772 deferred.reject(new Error('Missing required form parameter: deployment'));
32773 return deferred.promise;
32774 }
32775
32776 if (parameters['role'] !== undefined) {
32777 form['role'] = parameters['role'];
32778 }
32779
32780 if (parameters['role'] === undefined) {
32781 deferred.reject(new Error('Missing required form parameter: role'));
32782 return deferred.promise;
32783 }
32784
32785 if (parameters.$queryParameters) {
32786 Object.keys(parameters.$queryParameters)
32787 .forEach(function(parameterName) {
32788 var parameter = parameters.$queryParameters[parameterName];
32789 queryParameters[parameterName] = parameter;
32790 });
32791 }
32792
32793 var url = domain + path;
32794 var options = {
32795 timeout: parameters.$timeout,
32796 method: 'PUT',
32797 url: url,
32798 params: queryParameters,
32799 data: body,
32800 headers: headers
32801 };
32802 if (Object.keys(form).length > 0) {
32803 options.data = form;
32804 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32805 options.transformRequest = xos.transformRequest;
32806 }
32807 $http(options)
32808 .success(function(data, status, headers, config) {
32809 deferred.resolve(data);
32810 if (parameters.$cache !== undefined) {
32811 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32812 }
32813 })
32814 .error(function(data, status, headers, config) {
32815 deferred.reject({
32816 status: status,
32817 headers: headers,
32818 config: config,
32819 body: data
32820 });
32821 });
32822
32823 return deferred.promise;
32824 };
32825 /**
32826 *
32827 * @method
32828 * @name xos#Deployment_Privilege_Detail_PATCH
32829 * @param {string} pk -
32830 * @param {string} enacted -
32831 * @param {string} policed -
32832 * @param {string} backend_register -
32833 * @param {string} backend_status -
32834 * @param {boolean} deleted -
32835 * @param {boolean} write_protect -
32836 * @param {boolean} lazy_blocked -
32837 * @param {boolean} no_sync -
32838 * @param {string} user -
32839 * @param {string} deployment -
32840 * @param {string} role -
32841 *
32842 */
32843 xos.prototype.Deployment_Privilege_Detail_PATCH = function(parameters) {
32844 if (parameters === undefined) {
32845 parameters = {};
32846 }
32847 var deferred = $q.defer();
32848
32849 var domain = this.domain;
32850 var path = '/xos/deploymentprivileges/{pk}/';
32851
32852 var body;
32853 var queryParameters = {};
32854 var headers = {};
32855 var form = {};
32856
32857 path = path.replace('{pk}', parameters['pk']);
32858
32859 if (parameters['pk'] === undefined) {
32860 deferred.reject(new Error('Missing required path parameter: pk'));
32861 return deferred.promise;
32862 }
32863
32864 if (parameters['enacted'] !== undefined) {
32865 form['enacted'] = parameters['enacted'];
32866 }
32867
32868 if (parameters['policed'] !== undefined) {
32869 form['policed'] = parameters['policed'];
32870 }
32871
32872 if (parameters['backend_register'] !== undefined) {
32873 form['backend_register'] = parameters['backend_register'];
32874 }
32875
32876 if (parameters['backend_status'] !== undefined) {
32877 form['backend_status'] = parameters['backend_status'];
32878 }
32879
32880 if (parameters['deleted'] !== undefined) {
32881 form['deleted'] = parameters['deleted'];
32882 }
32883
32884 if (parameters['write_protect'] !== undefined) {
32885 form['write_protect'] = parameters['write_protect'];
32886 }
32887
32888 if (parameters['lazy_blocked'] !== undefined) {
32889 form['lazy_blocked'] = parameters['lazy_blocked'];
32890 }
32891
32892 if (parameters['no_sync'] !== undefined) {
32893 form['no_sync'] = parameters['no_sync'];
32894 }
32895
32896 if (parameters['user'] !== undefined) {
32897 form['user'] = parameters['user'];
32898 }
32899
32900 if (parameters['deployment'] !== undefined) {
32901 form['deployment'] = parameters['deployment'];
32902 }
32903
32904 if (parameters['role'] !== undefined) {
32905 form['role'] = parameters['role'];
32906 }
32907
32908 if (parameters.$queryParameters) {
32909 Object.keys(parameters.$queryParameters)
32910 .forEach(function(parameterName) {
32911 var parameter = parameters.$queryParameters[parameterName];
32912 queryParameters[parameterName] = parameter;
32913 });
32914 }
32915
32916 var url = domain + path;
32917 var options = {
32918 timeout: parameters.$timeout,
32919 method: 'PATCH',
32920 url: url,
32921 params: queryParameters,
32922 data: body,
32923 headers: headers
32924 };
32925 if (Object.keys(form).length > 0) {
32926 options.data = form;
32927 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32928 options.transformRequest = xos.transformRequest;
32929 }
32930 $http(options)
32931 .success(function(data, status, headers, config) {
32932 deferred.resolve(data);
32933 if (parameters.$cache !== undefined) {
32934 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
32935 }
32936 })
32937 .error(function(data, status, headers, config) {
32938 deferred.reject({
32939 status: status,
32940 headers: headers,
32941 config: config,
32942 body: data
32943 });
32944 });
32945
32946 return deferred.promise;
32947 };
32948 /**
32949 *
32950 * @method
32951 * @name xos#Deployment_Privilege_Detail_DELETE
32952 * @param {string} pk -
32953 *
32954 */
32955 xos.prototype.Deployment_Privilege_Detail_DELETE = function(parameters) {
32956 if (parameters === undefined) {
32957 parameters = {};
32958 }
32959 var deferred = $q.defer();
32960
32961 var domain = this.domain;
32962 var path = '/xos/deploymentprivileges/{pk}/';
32963
32964 var body;
32965 var queryParameters = {};
32966 var headers = {};
32967 var form = {};
32968
32969 path = path.replace('{pk}', parameters['pk']);
32970
32971 if (parameters['pk'] === undefined) {
32972 deferred.reject(new Error('Missing required path parameter: pk'));
32973 return deferred.promise;
32974 }
32975
32976 if (parameters.$queryParameters) {
32977 Object.keys(parameters.$queryParameters)
32978 .forEach(function(parameterName) {
32979 var parameter = parameters.$queryParameters[parameterName];
32980 queryParameters[parameterName] = parameter;
32981 });
32982 }
32983
32984 var url = domain + path;
32985 var options = {
32986 timeout: parameters.$timeout,
32987 method: 'DELETE',
32988 url: url,
32989 params: queryParameters,
32990 data: body,
32991 headers: headers
32992 };
32993 if (Object.keys(form).length > 0) {
32994 options.data = form;
32995 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
32996 options.transformRequest = xos.transformRequest;
32997 }
32998 $http(options)
32999 .success(function(data, status, headers, config) {
33000 deferred.resolve(data);
33001 if (parameters.$cache !== undefined) {
33002 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33003 }
33004 })
33005 .error(function(data, status, headers, config) {
33006 deferred.reject({
33007 status: status,
33008 headers: headers,
33009 config: config,
33010 body: data
33011 });
33012 });
33013
33014 return deferred.promise;
33015 };
33016 /**
33017 *
33018 * @method
33019 * @name xos#Controller_Slice_Privilege_List_GET
33020 *
33021 */
33022 xos.prototype.Controller_Slice_Privilege_List_GET = function(parameters) {
33023 if (parameters === undefined) {
33024 parameters = {};
33025 }
33026 var deferred = $q.defer();
33027
33028 var domain = this.domain;
33029 var path = '/xos/controllersliceprivileges/';
33030
33031 var body;
33032 var queryParameters = {};
33033 var headers = {};
33034 var form = {};
33035
33036 if (parameters.$queryParameters) {
33037 Object.keys(parameters.$queryParameters)
33038 .forEach(function(parameterName) {
33039 var parameter = parameters.$queryParameters[parameterName];
33040 queryParameters[parameterName] = parameter;
33041 });
33042 }
33043
33044 var url = domain + path;
33045 var cached = parameters.$cache && parameters.$cache.get(url);
33046 if (cached !== undefined && parameters.$refresh !== true) {
33047 deferred.resolve(cached);
33048 return deferred.promise;
33049 }
33050 var options = {
33051 timeout: parameters.$timeout,
33052 method: 'GET',
33053 url: url,
33054 params: queryParameters,
33055 data: body,
33056 headers: headers
33057 };
33058 if (Object.keys(form).length > 0) {
33059 options.data = form;
33060 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33061 options.transformRequest = xos.transformRequest;
33062 }
33063 $http(options)
33064 .success(function(data, status, headers, config) {
33065 deferred.resolve(data);
33066 if (parameters.$cache !== undefined) {
33067 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33068 }
33069 })
33070 .error(function(data, status, headers, config) {
33071 deferred.reject({
33072 status: status,
33073 headers: headers,
33074 config: config,
33075 body: data
33076 });
33077 });
33078
33079 return deferred.promise;
33080 };
33081 /**
33082 *
33083 * @method
33084 * @name xos#Controller_Slice_Privilege_List_POST
33085 * @param {string} enacted -
33086 * @param {string} policed -
33087 * @param {string} backend_register -
33088 * @param {string} backend_status -
33089 * @param {boolean} deleted -
33090 * @param {boolean} write_protect -
33091 * @param {boolean} lazy_blocked -
33092 * @param {boolean} no_sync -
33093 * @param {string} controller -
33094 * @param {string} slice_privilege -
33095 * @param {string} role_id - Keystone id
33096 *
33097 */
33098 xos.prototype.Controller_Slice_Privilege_List_POST = function(parameters) {
33099 if (parameters === undefined) {
33100 parameters = {};
33101 }
33102 var deferred = $q.defer();
33103
33104 var domain = this.domain;
33105 var path = '/xos/controllersliceprivileges/';
33106
33107 var body;
33108 var queryParameters = {};
33109 var headers = {};
33110 var form = {};
33111
33112 if (parameters['enacted'] !== undefined) {
33113 form['enacted'] = parameters['enacted'];
33114 }
33115
33116 if (parameters['policed'] !== undefined) {
33117 form['policed'] = parameters['policed'];
33118 }
33119
33120 if (parameters['backend_register'] !== undefined) {
33121 form['backend_register'] = parameters['backend_register'];
33122 }
33123
33124 if (parameters['backend_status'] !== undefined) {
33125 form['backend_status'] = parameters['backend_status'];
33126 }
33127
33128 if (parameters['backend_status'] === undefined) {
33129 deferred.reject(new Error('Missing required form parameter: backend_status'));
33130 return deferred.promise;
33131 }
33132
33133 if (parameters['deleted'] !== undefined) {
33134 form['deleted'] = parameters['deleted'];
33135 }
33136
33137 if (parameters['write_protect'] !== undefined) {
33138 form['write_protect'] = parameters['write_protect'];
33139 }
33140
33141 if (parameters['lazy_blocked'] !== undefined) {
33142 form['lazy_blocked'] = parameters['lazy_blocked'];
33143 }
33144
33145 if (parameters['no_sync'] !== undefined) {
33146 form['no_sync'] = parameters['no_sync'];
33147 }
33148
33149 if (parameters['controller'] !== undefined) {
33150 form['controller'] = parameters['controller'];
33151 }
33152
33153 if (parameters['controller'] === undefined) {
33154 deferred.reject(new Error('Missing required form parameter: controller'));
33155 return deferred.promise;
33156 }
33157
33158 if (parameters['slice_privilege'] !== undefined) {
33159 form['slice_privilege'] = parameters['slice_privilege'];
33160 }
33161
33162 if (parameters['slice_privilege'] === undefined) {
33163 deferred.reject(new Error('Missing required form parameter: slice_privilege'));
33164 return deferred.promise;
33165 }
33166
33167 if (parameters['role_id'] !== undefined) {
33168 form['role_id'] = parameters['role_id'];
33169 }
33170
33171 if (parameters.$queryParameters) {
33172 Object.keys(parameters.$queryParameters)
33173 .forEach(function(parameterName) {
33174 var parameter = parameters.$queryParameters[parameterName];
33175 queryParameters[parameterName] = parameter;
33176 });
33177 }
33178
33179 var url = domain + path;
33180 var options = {
33181 timeout: parameters.$timeout,
33182 method: 'POST',
33183 url: url,
33184 params: queryParameters,
33185 data: body,
33186 headers: headers
33187 };
33188 if (Object.keys(form).length > 0) {
33189 options.data = form;
33190 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33191 options.transformRequest = xos.transformRequest;
33192 }
33193 $http(options)
33194 .success(function(data, status, headers, config) {
33195 deferred.resolve(data);
33196 if (parameters.$cache !== undefined) {
33197 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33198 }
33199 })
33200 .error(function(data, status, headers, config) {
33201 deferred.reject({
33202 status: status,
33203 headers: headers,
33204 config: config,
33205 body: data
33206 });
33207 });
33208
33209 return deferred.promise;
33210 };
33211 /**
33212 *
33213 * @method
33214 * @name xos#Controller_Slice_Privilege_Detail_GET
33215 * @param {string} pk -
33216 *
33217 */
33218 xos.prototype.Controller_Slice_Privilege_Detail_GET = function(parameters) {
33219 if (parameters === undefined) {
33220 parameters = {};
33221 }
33222 var deferred = $q.defer();
33223
33224 var domain = this.domain;
33225 var path = '/xos/controllersliceprivileges/{pk}/';
33226
33227 var body;
33228 var queryParameters = {};
33229 var headers = {};
33230 var form = {};
33231
33232 path = path.replace('{pk}', parameters['pk']);
33233
33234 if (parameters['pk'] === undefined) {
33235 deferred.reject(new Error('Missing required path parameter: pk'));
33236 return deferred.promise;
33237 }
33238
33239 if (parameters.$queryParameters) {
33240 Object.keys(parameters.$queryParameters)
33241 .forEach(function(parameterName) {
33242 var parameter = parameters.$queryParameters[parameterName];
33243 queryParameters[parameterName] = parameter;
33244 });
33245 }
33246
33247 var url = domain + path;
33248 var cached = parameters.$cache && parameters.$cache.get(url);
33249 if (cached !== undefined && parameters.$refresh !== true) {
33250 deferred.resolve(cached);
33251 return deferred.promise;
33252 }
33253 var options = {
33254 timeout: parameters.$timeout,
33255 method: 'GET',
33256 url: url,
33257 params: queryParameters,
33258 data: body,
33259 headers: headers
33260 };
33261 if (Object.keys(form).length > 0) {
33262 options.data = form;
33263 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33264 options.transformRequest = xos.transformRequest;
33265 }
33266 $http(options)
33267 .success(function(data, status, headers, config) {
33268 deferred.resolve(data);
33269 if (parameters.$cache !== undefined) {
33270 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33271 }
33272 })
33273 .error(function(data, status, headers, config) {
33274 deferred.reject({
33275 status: status,
33276 headers: headers,
33277 config: config,
33278 body: data
33279 });
33280 });
33281
33282 return deferred.promise;
33283 };
33284 /**
33285 *
33286 * @method
33287 * @name xos#Controller_Slice_Privilege_Detail_PUT
33288 * @param {string} pk -
33289 * @param {string} enacted -
33290 * @param {string} policed -
33291 * @param {string} backend_register -
33292 * @param {string} backend_status -
33293 * @param {boolean} deleted -
33294 * @param {boolean} write_protect -
33295 * @param {boolean} lazy_blocked -
33296 * @param {boolean} no_sync -
33297 * @param {string} controller -
33298 * @param {string} slice_privilege -
33299 * @param {string} role_id - Keystone id
33300 *
33301 */
33302 xos.prototype.Controller_Slice_Privilege_Detail_PUT = function(parameters) {
33303 if (parameters === undefined) {
33304 parameters = {};
33305 }
33306 var deferred = $q.defer();
33307
33308 var domain = this.domain;
33309 var path = '/xos/controllersliceprivileges/{pk}/';
33310
33311 var body;
33312 var queryParameters = {};
33313 var headers = {};
33314 var form = {};
33315
33316 path = path.replace('{pk}', parameters['pk']);
33317
33318 if (parameters['pk'] === undefined) {
33319 deferred.reject(new Error('Missing required path parameter: pk'));
33320 return deferred.promise;
33321 }
33322
33323 if (parameters['enacted'] !== undefined) {
33324 form['enacted'] = parameters['enacted'];
33325 }
33326
33327 if (parameters['policed'] !== undefined) {
33328 form['policed'] = parameters['policed'];
33329 }
33330
33331 if (parameters['backend_register'] !== undefined) {
33332 form['backend_register'] = parameters['backend_register'];
33333 }
33334
33335 if (parameters['backend_status'] !== undefined) {
33336 form['backend_status'] = parameters['backend_status'];
33337 }
33338
33339 if (parameters['backend_status'] === undefined) {
33340 deferred.reject(new Error('Missing required form parameter: backend_status'));
33341 return deferred.promise;
33342 }
33343
33344 if (parameters['deleted'] !== undefined) {
33345 form['deleted'] = parameters['deleted'];
33346 }
33347
33348 if (parameters['write_protect'] !== undefined) {
33349 form['write_protect'] = parameters['write_protect'];
33350 }
33351
33352 if (parameters['lazy_blocked'] !== undefined) {
33353 form['lazy_blocked'] = parameters['lazy_blocked'];
33354 }
33355
33356 if (parameters['no_sync'] !== undefined) {
33357 form['no_sync'] = parameters['no_sync'];
33358 }
33359
33360 if (parameters['controller'] !== undefined) {
33361 form['controller'] = parameters['controller'];
33362 }
33363
33364 if (parameters['controller'] === undefined) {
33365 deferred.reject(new Error('Missing required form parameter: controller'));
33366 return deferred.promise;
33367 }
33368
33369 if (parameters['slice_privilege'] !== undefined) {
33370 form['slice_privilege'] = parameters['slice_privilege'];
33371 }
33372
33373 if (parameters['slice_privilege'] === undefined) {
33374 deferred.reject(new Error('Missing required form parameter: slice_privilege'));
33375 return deferred.promise;
33376 }
33377
33378 if (parameters['role_id'] !== undefined) {
33379 form['role_id'] = parameters['role_id'];
33380 }
33381
33382 if (parameters.$queryParameters) {
33383 Object.keys(parameters.$queryParameters)
33384 .forEach(function(parameterName) {
33385 var parameter = parameters.$queryParameters[parameterName];
33386 queryParameters[parameterName] = parameter;
33387 });
33388 }
33389
33390 var url = domain + path;
33391 var options = {
33392 timeout: parameters.$timeout,
33393 method: 'PUT',
33394 url: url,
33395 params: queryParameters,
33396 data: body,
33397 headers: headers
33398 };
33399 if (Object.keys(form).length > 0) {
33400 options.data = form;
33401 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33402 options.transformRequest = xos.transformRequest;
33403 }
33404 $http(options)
33405 .success(function(data, status, headers, config) {
33406 deferred.resolve(data);
33407 if (parameters.$cache !== undefined) {
33408 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33409 }
33410 })
33411 .error(function(data, status, headers, config) {
33412 deferred.reject({
33413 status: status,
33414 headers: headers,
33415 config: config,
33416 body: data
33417 });
33418 });
33419
33420 return deferred.promise;
33421 };
33422 /**
33423 *
33424 * @method
33425 * @name xos#Controller_Slice_Privilege_Detail_PATCH
33426 * @param {string} pk -
33427 * @param {string} enacted -
33428 * @param {string} policed -
33429 * @param {string} backend_register -
33430 * @param {string} backend_status -
33431 * @param {boolean} deleted -
33432 * @param {boolean} write_protect -
33433 * @param {boolean} lazy_blocked -
33434 * @param {boolean} no_sync -
33435 * @param {string} controller -
33436 * @param {string} slice_privilege -
33437 * @param {string} role_id - Keystone id
33438 *
33439 */
33440 xos.prototype.Controller_Slice_Privilege_Detail_PATCH = function(parameters) {
33441 if (parameters === undefined) {
33442 parameters = {};
33443 }
33444 var deferred = $q.defer();
33445
33446 var domain = this.domain;
33447 var path = '/xos/controllersliceprivileges/{pk}/';
33448
33449 var body;
33450 var queryParameters = {};
33451 var headers = {};
33452 var form = {};
33453
33454 path = path.replace('{pk}', parameters['pk']);
33455
33456 if (parameters['pk'] === undefined) {
33457 deferred.reject(new Error('Missing required path parameter: pk'));
33458 return deferred.promise;
33459 }
33460
33461 if (parameters['enacted'] !== undefined) {
33462 form['enacted'] = parameters['enacted'];
33463 }
33464
33465 if (parameters['policed'] !== undefined) {
33466 form['policed'] = parameters['policed'];
33467 }
33468
33469 if (parameters['backend_register'] !== undefined) {
33470 form['backend_register'] = parameters['backend_register'];
33471 }
33472
33473 if (parameters['backend_status'] !== undefined) {
33474 form['backend_status'] = parameters['backend_status'];
33475 }
33476
33477 if (parameters['deleted'] !== undefined) {
33478 form['deleted'] = parameters['deleted'];
33479 }
33480
33481 if (parameters['write_protect'] !== undefined) {
33482 form['write_protect'] = parameters['write_protect'];
33483 }
33484
33485 if (parameters['lazy_blocked'] !== undefined) {
33486 form['lazy_blocked'] = parameters['lazy_blocked'];
33487 }
33488
33489 if (parameters['no_sync'] !== undefined) {
33490 form['no_sync'] = parameters['no_sync'];
33491 }
33492
33493 if (parameters['controller'] !== undefined) {
33494 form['controller'] = parameters['controller'];
33495 }
33496
33497 if (parameters['slice_privilege'] !== undefined) {
33498 form['slice_privilege'] = parameters['slice_privilege'];
33499 }
33500
33501 if (parameters['role_id'] !== undefined) {
33502 form['role_id'] = parameters['role_id'];
33503 }
33504
33505 if (parameters.$queryParameters) {
33506 Object.keys(parameters.$queryParameters)
33507 .forEach(function(parameterName) {
33508 var parameter = parameters.$queryParameters[parameterName];
33509 queryParameters[parameterName] = parameter;
33510 });
33511 }
33512
33513 var url = domain + path;
33514 var options = {
33515 timeout: parameters.$timeout,
33516 method: 'PATCH',
33517 url: url,
33518 params: queryParameters,
33519 data: body,
33520 headers: headers
33521 };
33522 if (Object.keys(form).length > 0) {
33523 options.data = form;
33524 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33525 options.transformRequest = xos.transformRequest;
33526 }
33527 $http(options)
33528 .success(function(data, status, headers, config) {
33529 deferred.resolve(data);
33530 if (parameters.$cache !== undefined) {
33531 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33532 }
33533 })
33534 .error(function(data, status, headers, config) {
33535 deferred.reject({
33536 status: status,
33537 headers: headers,
33538 config: config,
33539 body: data
33540 });
33541 });
33542
33543 return deferred.promise;
33544 };
33545 /**
33546 *
33547 * @method
33548 * @name xos#Controller_Slice_Privilege_Detail_DELETE
33549 * @param {string} pk -
33550 *
33551 */
33552 xos.prototype.Controller_Slice_Privilege_Detail_DELETE = function(parameters) {
33553 if (parameters === undefined) {
33554 parameters = {};
33555 }
33556 var deferred = $q.defer();
33557
33558 var domain = this.domain;
33559 var path = '/xos/controllersliceprivileges/{pk}/';
33560
33561 var body;
33562 var queryParameters = {};
33563 var headers = {};
33564 var form = {};
33565
33566 path = path.replace('{pk}', parameters['pk']);
33567
33568 if (parameters['pk'] === undefined) {
33569 deferred.reject(new Error('Missing required path parameter: pk'));
33570 return deferred.promise;
33571 }
33572
33573 if (parameters.$queryParameters) {
33574 Object.keys(parameters.$queryParameters)
33575 .forEach(function(parameterName) {
33576 var parameter = parameters.$queryParameters[parameterName];
33577 queryParameters[parameterName] = parameter;
33578 });
33579 }
33580
33581 var url = domain + path;
33582 var options = {
33583 timeout: parameters.$timeout,
33584 method: 'DELETE',
33585 url: url,
33586 params: queryParameters,
33587 data: body,
33588 headers: headers
33589 };
33590 if (Object.keys(form).length > 0) {
33591 options.data = form;
33592 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33593 options.transformRequest = xos.transformRequest;
33594 }
33595 $http(options)
33596 .success(function(data, status, headers, config) {
33597 deferred.resolve(data);
33598 if (parameters.$cache !== undefined) {
33599 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33600 }
33601 })
33602 .error(function(data, status, headers, config) {
33603 deferred.reject({
33604 status: status,
33605 headers: headers,
33606 config: config,
33607 body: data
33608 });
33609 });
33610
33611 return deferred.promise;
33612 };
33613 /**
33614 *
33615 * @method
33616 * @name xos#Site_Deployment_List_GET
33617 *
33618 */
33619 xos.prototype.Site_Deployment_List_GET = function(parameters) {
33620 if (parameters === undefined) {
33621 parameters = {};
33622 }
33623 var deferred = $q.defer();
33624
33625 var domain = this.domain;
33626 var path = '/xos/sitedeployments/';
33627
33628 var body;
33629 var queryParameters = {};
33630 var headers = {};
33631 var form = {};
33632
33633 if (parameters.$queryParameters) {
33634 Object.keys(parameters.$queryParameters)
33635 .forEach(function(parameterName) {
33636 var parameter = parameters.$queryParameters[parameterName];
33637 queryParameters[parameterName] = parameter;
33638 });
33639 }
33640
33641 var url = domain + path;
33642 var cached = parameters.$cache && parameters.$cache.get(url);
33643 if (cached !== undefined && parameters.$refresh !== true) {
33644 deferred.resolve(cached);
33645 return deferred.promise;
33646 }
33647 var options = {
33648 timeout: parameters.$timeout,
33649 method: 'GET',
33650 url: url,
33651 params: queryParameters,
33652 data: body,
33653 headers: headers
33654 };
33655 if (Object.keys(form).length > 0) {
33656 options.data = form;
33657 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33658 options.transformRequest = xos.transformRequest;
33659 }
33660 $http(options)
33661 .success(function(data, status, headers, config) {
33662 deferred.resolve(data);
33663 if (parameters.$cache !== undefined) {
33664 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33665 }
33666 })
33667 .error(function(data, status, headers, config) {
33668 deferred.reject({
33669 status: status,
33670 headers: headers,
33671 config: config,
33672 body: data
33673 });
33674 });
33675
33676 return deferred.promise;
33677 };
33678 /**
33679 *
33680 * @method
33681 * @name xos#Site_Deployment_List_POST
33682 * @param {string} enacted -
33683 * @param {string} policed -
33684 * @param {string} backend_register -
33685 * @param {string} backend_status -
33686 * @param {boolean} deleted -
33687 * @param {boolean} write_protect -
33688 * @param {boolean} lazy_blocked -
33689 * @param {boolean} no_sync -
33690 * @param {string} site -
33691 * @param {string} deployment -
33692 * @param {string} controller -
33693 * @param {string} availability_zone - OpenStack availability zone
33694 *
33695 */
33696 xos.prototype.Site_Deployment_List_POST = function(parameters) {
33697 if (parameters === undefined) {
33698 parameters = {};
33699 }
33700 var deferred = $q.defer();
33701
33702 var domain = this.domain;
33703 var path = '/xos/sitedeployments/';
33704
33705 var body;
33706 var queryParameters = {};
33707 var headers = {};
33708 var form = {};
33709
33710 if (parameters['enacted'] !== undefined) {
33711 form['enacted'] = parameters['enacted'];
33712 }
33713
33714 if (parameters['policed'] !== undefined) {
33715 form['policed'] = parameters['policed'];
33716 }
33717
33718 if (parameters['backend_register'] !== undefined) {
33719 form['backend_register'] = parameters['backend_register'];
33720 }
33721
33722 if (parameters['backend_status'] !== undefined) {
33723 form['backend_status'] = parameters['backend_status'];
33724 }
33725
33726 if (parameters['backend_status'] === undefined) {
33727 deferred.reject(new Error('Missing required form parameter: backend_status'));
33728 return deferred.promise;
33729 }
33730
33731 if (parameters['deleted'] !== undefined) {
33732 form['deleted'] = parameters['deleted'];
33733 }
33734
33735 if (parameters['write_protect'] !== undefined) {
33736 form['write_protect'] = parameters['write_protect'];
33737 }
33738
33739 if (parameters['lazy_blocked'] !== undefined) {
33740 form['lazy_blocked'] = parameters['lazy_blocked'];
33741 }
33742
33743 if (parameters['no_sync'] !== undefined) {
33744 form['no_sync'] = parameters['no_sync'];
33745 }
33746
33747 if (parameters['site'] !== undefined) {
33748 form['site'] = parameters['site'];
33749 }
33750
33751 if (parameters['site'] === undefined) {
33752 deferred.reject(new Error('Missing required form parameter: site'));
33753 return deferred.promise;
33754 }
33755
33756 if (parameters['deployment'] !== undefined) {
33757 form['deployment'] = parameters['deployment'];
33758 }
33759
33760 if (parameters['deployment'] === undefined) {
33761 deferred.reject(new Error('Missing required form parameter: deployment'));
33762 return deferred.promise;
33763 }
33764
33765 if (parameters['controller'] !== undefined) {
33766 form['controller'] = parameters['controller'];
33767 }
33768
33769 if (parameters['availability_zone'] !== undefined) {
33770 form['availability_zone'] = parameters['availability_zone'];
33771 }
33772
33773 if (parameters.$queryParameters) {
33774 Object.keys(parameters.$queryParameters)
33775 .forEach(function(parameterName) {
33776 var parameter = parameters.$queryParameters[parameterName];
33777 queryParameters[parameterName] = parameter;
33778 });
33779 }
33780
33781 var url = domain + path;
33782 var options = {
33783 timeout: parameters.$timeout,
33784 method: 'POST',
33785 url: url,
33786 params: queryParameters,
33787 data: body,
33788 headers: headers
33789 };
33790 if (Object.keys(form).length > 0) {
33791 options.data = form;
33792 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33793 options.transformRequest = xos.transformRequest;
33794 }
33795 $http(options)
33796 .success(function(data, status, headers, config) {
33797 deferred.resolve(data);
33798 if (parameters.$cache !== undefined) {
33799 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33800 }
33801 })
33802 .error(function(data, status, headers, config) {
33803 deferred.reject({
33804 status: status,
33805 headers: headers,
33806 config: config,
33807 body: data
33808 });
33809 });
33810
33811 return deferred.promise;
33812 };
33813 /**
33814 *
33815 * @method
33816 * @name xos#Site_Deployment_Detail_GET
33817 * @param {string} pk -
33818 *
33819 */
33820 xos.prototype.Site_Deployment_Detail_GET = function(parameters) {
33821 if (parameters === undefined) {
33822 parameters = {};
33823 }
33824 var deferred = $q.defer();
33825
33826 var domain = this.domain;
33827 var path = '/xos/sitedeployments/{pk}/';
33828
33829 var body;
33830 var queryParameters = {};
33831 var headers = {};
33832 var form = {};
33833
33834 path = path.replace('{pk}', parameters['pk']);
33835
33836 if (parameters['pk'] === undefined) {
33837 deferred.reject(new Error('Missing required path parameter: pk'));
33838 return deferred.promise;
33839 }
33840
33841 if (parameters.$queryParameters) {
33842 Object.keys(parameters.$queryParameters)
33843 .forEach(function(parameterName) {
33844 var parameter = parameters.$queryParameters[parameterName];
33845 queryParameters[parameterName] = parameter;
33846 });
33847 }
33848
33849 var url = domain + path;
33850 var cached = parameters.$cache && parameters.$cache.get(url);
33851 if (cached !== undefined && parameters.$refresh !== true) {
33852 deferred.resolve(cached);
33853 return deferred.promise;
33854 }
33855 var options = {
33856 timeout: parameters.$timeout,
33857 method: 'GET',
33858 url: url,
33859 params: queryParameters,
33860 data: body,
33861 headers: headers
33862 };
33863 if (Object.keys(form).length > 0) {
33864 options.data = form;
33865 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
33866 options.transformRequest = xos.transformRequest;
33867 }
33868 $http(options)
33869 .success(function(data, status, headers, config) {
33870 deferred.resolve(data);
33871 if (parameters.$cache !== undefined) {
33872 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
33873 }
33874 })
33875 .error(function(data, status, headers, config) {
33876 deferred.reject({
33877 status: status,
33878 headers: headers,
33879 config: config,
33880 body: data
33881 });
33882 });
33883
33884 return deferred.promise;
33885 };
33886 /**
33887 *
33888 * @method
33889 * @name xos#Site_Deployment_Detail_PUT
33890 * @param {string} pk -
33891 * @param {string} enacted -
33892 * @param {string} policed -
33893 * @param {string} backend_register -
33894 * @param {string} backend_status -
33895 * @param {boolean} deleted -
33896 * @param {boolean} write_protect -
33897 * @param {boolean} lazy_blocked -
33898 * @param {boolean} no_sync -
33899 * @param {string} site -
33900 * @param {string} deployment -
33901 * @param {string} controller -
33902 * @param {string} availability_zone - OpenStack availability zone
33903 *
33904 */
33905 xos.prototype.Site_Deployment_Detail_PUT = function(parameters) {
33906 if (parameters === undefined) {
33907 parameters = {};
33908 }
33909 var deferred = $q.defer();
33910
33911 var domain = this.domain;
33912 var path = '/xos/sitedeployments/{pk}/';
33913
33914 var body;
33915 var queryParameters = {};
33916 var headers = {};
33917 var form = {};
33918
33919 path = path.replace('{pk}', parameters['pk']);
33920
33921 if (parameters['pk'] === undefined) {
33922 deferred.reject(new Error('Missing required path parameter: pk'));
33923 return deferred.promise;
33924 }
33925
33926 if (parameters['enacted'] !== undefined) {
33927 form['enacted'] = parameters['enacted'];
33928 }
33929
33930 if (parameters['policed'] !== undefined) {
33931 form['policed'] = parameters['policed'];
33932 }
33933
33934 if (parameters['backend_register'] !== undefined) {
33935 form['backend_register'] = parameters['backend_register'];
33936 }
33937
33938 if (parameters['backend_status'] !== undefined) {
33939 form['backend_status'] = parameters['backend_status'];
33940 }
33941
33942 if (parameters['backend_status'] === undefined) {
33943 deferred.reject(new Error('Missing required form parameter: backend_status'));
33944 return deferred.promise;
33945 }
33946
33947 if (parameters['deleted'] !== undefined) {
33948 form['deleted'] = parameters['deleted'];
33949 }
33950
33951 if (parameters['write_protect'] !== undefined) {
33952 form['write_protect'] = parameters['write_protect'];
33953 }
33954
33955 if (parameters['lazy_blocked'] !== undefined) {
33956 form['lazy_blocked'] = parameters['lazy_blocked'];
33957 }
33958
33959 if (parameters['no_sync'] !== undefined) {
33960 form['no_sync'] = parameters['no_sync'];
33961 }
33962
33963 if (parameters['site'] !== undefined) {
33964 form['site'] = parameters['site'];
33965 }
33966
33967 if (parameters['site'] === undefined) {
33968 deferred.reject(new Error('Missing required form parameter: site'));
33969 return deferred.promise;
33970 }
33971
33972 if (parameters['deployment'] !== undefined) {
33973 form['deployment'] = parameters['deployment'];
33974 }
33975
33976 if (parameters['deployment'] === undefined) {
33977 deferred.reject(new Error('Missing required form parameter: deployment'));
33978 return deferred.promise;
33979 }
33980
33981 if (parameters['controller'] !== undefined) {
33982 form['controller'] = parameters['controller'];
33983 }
33984
33985 if (parameters['availability_zone'] !== undefined) {
33986 form['availability_zone'] = parameters['availability_zone'];
33987 }
33988
33989 if (parameters.$queryParameters) {
33990 Object.keys(parameters.$queryParameters)
33991 .forEach(function(parameterName) {
33992 var parameter = parameters.$queryParameters[parameterName];
33993 queryParameters[parameterName] = parameter;
33994 });
33995 }
33996
33997 var url = domain + path;
33998 var options = {
33999 timeout: parameters.$timeout,
34000 method: 'PUT',
34001 url: url,
34002 params: queryParameters,
34003 data: body,
34004 headers: headers
34005 };
34006 if (Object.keys(form).length > 0) {
34007 options.data = form;
34008 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34009 options.transformRequest = xos.transformRequest;
34010 }
34011 $http(options)
34012 .success(function(data, status, headers, config) {
34013 deferred.resolve(data);
34014 if (parameters.$cache !== undefined) {
34015 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34016 }
34017 })
34018 .error(function(data, status, headers, config) {
34019 deferred.reject({
34020 status: status,
34021 headers: headers,
34022 config: config,
34023 body: data
34024 });
34025 });
34026
34027 return deferred.promise;
34028 };
34029 /**
34030 *
34031 * @method
34032 * @name xos#Site_Deployment_Detail_PATCH
34033 * @param {string} pk -
34034 * @param {string} enacted -
34035 * @param {string} policed -
34036 * @param {string} backend_register -
34037 * @param {string} backend_status -
34038 * @param {boolean} deleted -
34039 * @param {boolean} write_protect -
34040 * @param {boolean} lazy_blocked -
34041 * @param {boolean} no_sync -
34042 * @param {string} site -
34043 * @param {string} deployment -
34044 * @param {string} controller -
34045 * @param {string} availability_zone - OpenStack availability zone
34046 *
34047 */
34048 xos.prototype.Site_Deployment_Detail_PATCH = function(parameters) {
34049 if (parameters === undefined) {
34050 parameters = {};
34051 }
34052 var deferred = $q.defer();
34053
34054 var domain = this.domain;
34055 var path = '/xos/sitedeployments/{pk}/';
34056
34057 var body;
34058 var queryParameters = {};
34059 var headers = {};
34060 var form = {};
34061
34062 path = path.replace('{pk}', parameters['pk']);
34063
34064 if (parameters['pk'] === undefined) {
34065 deferred.reject(new Error('Missing required path parameter: pk'));
34066 return deferred.promise;
34067 }
34068
34069 if (parameters['enacted'] !== undefined) {
34070 form['enacted'] = parameters['enacted'];
34071 }
34072
34073 if (parameters['policed'] !== undefined) {
34074 form['policed'] = parameters['policed'];
34075 }
34076
34077 if (parameters['backend_register'] !== undefined) {
34078 form['backend_register'] = parameters['backend_register'];
34079 }
34080
34081 if (parameters['backend_status'] !== undefined) {
34082 form['backend_status'] = parameters['backend_status'];
34083 }
34084
34085 if (parameters['deleted'] !== undefined) {
34086 form['deleted'] = parameters['deleted'];
34087 }
34088
34089 if (parameters['write_protect'] !== undefined) {
34090 form['write_protect'] = parameters['write_protect'];
34091 }
34092
34093 if (parameters['lazy_blocked'] !== undefined) {
34094 form['lazy_blocked'] = parameters['lazy_blocked'];
34095 }
34096
34097 if (parameters['no_sync'] !== undefined) {
34098 form['no_sync'] = parameters['no_sync'];
34099 }
34100
34101 if (parameters['site'] !== undefined) {
34102 form['site'] = parameters['site'];
34103 }
34104
34105 if (parameters['deployment'] !== undefined) {
34106 form['deployment'] = parameters['deployment'];
34107 }
34108
34109 if (parameters['controller'] !== undefined) {
34110 form['controller'] = parameters['controller'];
34111 }
34112
34113 if (parameters['availability_zone'] !== undefined) {
34114 form['availability_zone'] = parameters['availability_zone'];
34115 }
34116
34117 if (parameters.$queryParameters) {
34118 Object.keys(parameters.$queryParameters)
34119 .forEach(function(parameterName) {
34120 var parameter = parameters.$queryParameters[parameterName];
34121 queryParameters[parameterName] = parameter;
34122 });
34123 }
34124
34125 var url = domain + path;
34126 var options = {
34127 timeout: parameters.$timeout,
34128 method: 'PATCH',
34129 url: url,
34130 params: queryParameters,
34131 data: body,
34132 headers: headers
34133 };
34134 if (Object.keys(form).length > 0) {
34135 options.data = form;
34136 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34137 options.transformRequest = xos.transformRequest;
34138 }
34139 $http(options)
34140 .success(function(data, status, headers, config) {
34141 deferred.resolve(data);
34142 if (parameters.$cache !== undefined) {
34143 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34144 }
34145 })
34146 .error(function(data, status, headers, config) {
34147 deferred.reject({
34148 status: status,
34149 headers: headers,
34150 config: config,
34151 body: data
34152 });
34153 });
34154
34155 return deferred.promise;
34156 };
34157 /**
34158 *
34159 * @method
34160 * @name xos#Site_Deployment_Detail_DELETE
34161 * @param {string} pk -
34162 *
34163 */
34164 xos.prototype.Site_Deployment_Detail_DELETE = function(parameters) {
34165 if (parameters === undefined) {
34166 parameters = {};
34167 }
34168 var deferred = $q.defer();
34169
34170 var domain = this.domain;
34171 var path = '/xos/sitedeployments/{pk}/';
34172
34173 var body;
34174 var queryParameters = {};
34175 var headers = {};
34176 var form = {};
34177
34178 path = path.replace('{pk}', parameters['pk']);
34179
34180 if (parameters['pk'] === undefined) {
34181 deferred.reject(new Error('Missing required path parameter: pk'));
34182 return deferred.promise;
34183 }
34184
34185 if (parameters.$queryParameters) {
34186 Object.keys(parameters.$queryParameters)
34187 .forEach(function(parameterName) {
34188 var parameter = parameters.$queryParameters[parameterName];
34189 queryParameters[parameterName] = parameter;
34190 });
34191 }
34192
34193 var url = domain + path;
34194 var options = {
34195 timeout: parameters.$timeout,
34196 method: 'DELETE',
34197 url: url,
34198 params: queryParameters,
34199 data: body,
34200 headers: headers
34201 };
34202 if (Object.keys(form).length > 0) {
34203 options.data = form;
34204 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34205 options.transformRequest = xos.transformRequest;
34206 }
34207 $http(options)
34208 .success(function(data, status, headers, config) {
34209 deferred.resolve(data);
34210 if (parameters.$cache !== undefined) {
34211 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34212 }
34213 })
34214 .error(function(data, status, headers, config) {
34215 deferred.reject({
34216 status: status,
34217 headers: headers,
34218 config: config,
34219 body: data
34220 });
34221 });
34222
34223 return deferred.promise;
34224 };
34225 /**
34226 *
34227 * @method
34228 * @name xos#Tenant_With_Container_List_GET
34229 *
34230 */
34231 xos.prototype.Tenant_With_Container_List_GET = function(parameters) {
34232 if (parameters === undefined) {
34233 parameters = {};
34234 }
34235 var deferred = $q.defer();
34236
34237 var domain = this.domain;
34238 var path = '/xos/tenantwithcontainers/';
34239
34240 var body;
34241 var queryParameters = {};
34242 var headers = {};
34243 var form = {};
34244
34245 if (parameters.$queryParameters) {
34246 Object.keys(parameters.$queryParameters)
34247 .forEach(function(parameterName) {
34248 var parameter = parameters.$queryParameters[parameterName];
34249 queryParameters[parameterName] = parameter;
34250 });
34251 }
34252
34253 var url = domain + path;
34254 var cached = parameters.$cache && parameters.$cache.get(url);
34255 if (cached !== undefined && parameters.$refresh !== true) {
34256 deferred.resolve(cached);
34257 return deferred.promise;
34258 }
34259 var options = {
34260 timeout: parameters.$timeout,
34261 method: 'GET',
34262 url: url,
34263 params: queryParameters,
34264 data: body,
34265 headers: headers
34266 };
34267 if (Object.keys(form).length > 0) {
34268 options.data = form;
34269 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34270 options.transformRequest = xos.transformRequest;
34271 }
34272 $http(options)
34273 .success(function(data, status, headers, config) {
34274 deferred.resolve(data);
34275 if (parameters.$cache !== undefined) {
34276 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34277 }
34278 })
34279 .error(function(data, status, headers, config) {
34280 deferred.reject({
34281 status: status,
34282 headers: headers,
34283 config: config,
34284 body: data
34285 });
34286 });
34287
34288 return deferred.promise;
34289 };
34290 /**
34291 *
34292 * @method
34293 * @name xos#Tenant_With_Container_List_POST
34294 * @param {string} enacted -
34295 * @param {string} policed -
34296 * @param {string} backend_register -
34297 * @param {string} backend_status -
34298 * @param {boolean} deleted -
34299 * @param {boolean} write_protect -
34300 * @param {boolean} lazy_blocked -
34301 * @param {boolean} no_sync -
34302 * @param {string} kind -
34303 * @param {string} provider_service -
34304 * @param {string} subscriber_service -
34305 * @param {string} subscriber_tenant -
34306 * @param {string} subscriber_user -
34307 * @param {string} subscriber_root -
34308 * @param {string} service_specific_id -
34309 * @param {string} service_specific_attribute -
34310 * @param {choice} connect_method -
34311 *
34312 */
34313 xos.prototype.Tenant_With_Container_List_POST = function(parameters) {
34314 if (parameters === undefined) {
34315 parameters = {};
34316 }
34317 var deferred = $q.defer();
34318
34319 var domain = this.domain;
34320 var path = '/xos/tenantwithcontainers/';
34321
34322 var body;
34323 var queryParameters = {};
34324 var headers = {};
34325 var form = {};
34326
34327 if (parameters['enacted'] !== undefined) {
34328 form['enacted'] = parameters['enacted'];
34329 }
34330
34331 if (parameters['policed'] !== undefined) {
34332 form['policed'] = parameters['policed'];
34333 }
34334
34335 if (parameters['backend_register'] !== undefined) {
34336 form['backend_register'] = parameters['backend_register'];
34337 }
34338
34339 if (parameters['backend_status'] !== undefined) {
34340 form['backend_status'] = parameters['backend_status'];
34341 }
34342
34343 if (parameters['backend_status'] === undefined) {
34344 deferred.reject(new Error('Missing required form parameter: backend_status'));
34345 return deferred.promise;
34346 }
34347
34348 if (parameters['deleted'] !== undefined) {
34349 form['deleted'] = parameters['deleted'];
34350 }
34351
34352 if (parameters['write_protect'] !== undefined) {
34353 form['write_protect'] = parameters['write_protect'];
34354 }
34355
34356 if (parameters['lazy_blocked'] !== undefined) {
34357 form['lazy_blocked'] = parameters['lazy_blocked'];
34358 }
34359
34360 if (parameters['no_sync'] !== undefined) {
34361 form['no_sync'] = parameters['no_sync'];
34362 }
34363
34364 if (parameters['kind'] !== undefined) {
34365 form['kind'] = parameters['kind'];
34366 }
34367
34368 if (parameters['kind'] === undefined) {
34369 deferred.reject(new Error('Missing required form parameter: kind'));
34370 return deferred.promise;
34371 }
34372
34373 if (parameters['provider_service'] !== undefined) {
34374 form['provider_service'] = parameters['provider_service'];
34375 }
34376
34377 if (parameters['provider_service'] === undefined) {
34378 deferred.reject(new Error('Missing required form parameter: provider_service'));
34379 return deferred.promise;
34380 }
34381
34382 if (parameters['subscriber_service'] !== undefined) {
34383 form['subscriber_service'] = parameters['subscriber_service'];
34384 }
34385
34386 if (parameters['subscriber_tenant'] !== undefined) {
34387 form['subscriber_tenant'] = parameters['subscriber_tenant'];
34388 }
34389
34390 if (parameters['subscriber_user'] !== undefined) {
34391 form['subscriber_user'] = parameters['subscriber_user'];
34392 }
34393
34394 if (parameters['subscriber_root'] !== undefined) {
34395 form['subscriber_root'] = parameters['subscriber_root'];
34396 }
34397
34398 if (parameters['service_specific_id'] !== undefined) {
34399 form['service_specific_id'] = parameters['service_specific_id'];
34400 }
34401
34402 if (parameters['service_specific_attribute'] !== undefined) {
34403 form['service_specific_attribute'] = parameters['service_specific_attribute'];
34404 }
34405
34406 if (parameters['connect_method'] !== undefined) {
34407 form['connect_method'] = parameters['connect_method'];
34408 }
34409
34410 if (parameters['connect_method'] === undefined) {
34411 deferred.reject(new Error('Missing required form parameter: connect_method'));
34412 return deferred.promise;
34413 }
34414
34415 if (parameters.$queryParameters) {
34416 Object.keys(parameters.$queryParameters)
34417 .forEach(function(parameterName) {
34418 var parameter = parameters.$queryParameters[parameterName];
34419 queryParameters[parameterName] = parameter;
34420 });
34421 }
34422
34423 var url = domain + path;
34424 var options = {
34425 timeout: parameters.$timeout,
34426 method: 'POST',
34427 url: url,
34428 params: queryParameters,
34429 data: body,
34430 headers: headers
34431 };
34432 if (Object.keys(form).length > 0) {
34433 options.data = form;
34434 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34435 options.transformRequest = xos.transformRequest;
34436 }
34437 $http(options)
34438 .success(function(data, status, headers, config) {
34439 deferred.resolve(data);
34440 if (parameters.$cache !== undefined) {
34441 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34442 }
34443 })
34444 .error(function(data, status, headers, config) {
34445 deferred.reject({
34446 status: status,
34447 headers: headers,
34448 config: config,
34449 body: data
34450 });
34451 });
34452
34453 return deferred.promise;
34454 };
34455 /**
34456 *
34457 * @method
34458 * @name xos#Tenant_With_Container_Detail_GET
34459 * @param {string} pk -
34460 *
34461 */
34462 xos.prototype.Tenant_With_Container_Detail_GET = function(parameters) {
34463 if (parameters === undefined) {
34464 parameters = {};
34465 }
34466 var deferred = $q.defer();
34467
34468 var domain = this.domain;
34469 var path = '/xos/tenantwithcontainers/{pk}/';
34470
34471 var body;
34472 var queryParameters = {};
34473 var headers = {};
34474 var form = {};
34475
34476 path = path.replace('{pk}', parameters['pk']);
34477
34478 if (parameters['pk'] === undefined) {
34479 deferred.reject(new Error('Missing required path parameter: pk'));
34480 return deferred.promise;
34481 }
34482
34483 if (parameters.$queryParameters) {
34484 Object.keys(parameters.$queryParameters)
34485 .forEach(function(parameterName) {
34486 var parameter = parameters.$queryParameters[parameterName];
34487 queryParameters[parameterName] = parameter;
34488 });
34489 }
34490
34491 var url = domain + path;
34492 var cached = parameters.$cache && parameters.$cache.get(url);
34493 if (cached !== undefined && parameters.$refresh !== true) {
34494 deferred.resolve(cached);
34495 return deferred.promise;
34496 }
34497 var options = {
34498 timeout: parameters.$timeout,
34499 method: 'GET',
34500 url: url,
34501 params: queryParameters,
34502 data: body,
34503 headers: headers
34504 };
34505 if (Object.keys(form).length > 0) {
34506 options.data = form;
34507 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34508 options.transformRequest = xos.transformRequest;
34509 }
34510 $http(options)
34511 .success(function(data, status, headers, config) {
34512 deferred.resolve(data);
34513 if (parameters.$cache !== undefined) {
34514 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34515 }
34516 })
34517 .error(function(data, status, headers, config) {
34518 deferred.reject({
34519 status: status,
34520 headers: headers,
34521 config: config,
34522 body: data
34523 });
34524 });
34525
34526 return deferred.promise;
34527 };
34528 /**
34529 *
34530 * @method
34531 * @name xos#Tenant_With_Container_Detail_PUT
34532 * @param {string} pk -
34533 * @param {string} enacted -
34534 * @param {string} policed -
34535 * @param {string} backend_register -
34536 * @param {string} backend_status -
34537 * @param {boolean} deleted -
34538 * @param {boolean} write_protect -
34539 * @param {boolean} lazy_blocked -
34540 * @param {boolean} no_sync -
34541 * @param {string} kind -
34542 * @param {string} provider_service -
34543 * @param {string} subscriber_service -
34544 * @param {string} subscriber_tenant -
34545 * @param {string} subscriber_user -
34546 * @param {string} subscriber_root -
34547 * @param {string} service_specific_id -
34548 * @param {string} service_specific_attribute -
34549 * @param {choice} connect_method -
34550 *
34551 */
34552 xos.prototype.Tenant_With_Container_Detail_PUT = function(parameters) {
34553 if (parameters === undefined) {
34554 parameters = {};
34555 }
34556 var deferred = $q.defer();
34557
34558 var domain = this.domain;
34559 var path = '/xos/tenantwithcontainers/{pk}/';
34560
34561 var body;
34562 var queryParameters = {};
34563 var headers = {};
34564 var form = {};
34565
34566 path = path.replace('{pk}', parameters['pk']);
34567
34568 if (parameters['pk'] === undefined) {
34569 deferred.reject(new Error('Missing required path parameter: pk'));
34570 return deferred.promise;
34571 }
34572
34573 if (parameters['enacted'] !== undefined) {
34574 form['enacted'] = parameters['enacted'];
34575 }
34576
34577 if (parameters['policed'] !== undefined) {
34578 form['policed'] = parameters['policed'];
34579 }
34580
34581 if (parameters['backend_register'] !== undefined) {
34582 form['backend_register'] = parameters['backend_register'];
34583 }
34584
34585 if (parameters['backend_status'] !== undefined) {
34586 form['backend_status'] = parameters['backend_status'];
34587 }
34588
34589 if (parameters['backend_status'] === undefined) {
34590 deferred.reject(new Error('Missing required form parameter: backend_status'));
34591 return deferred.promise;
34592 }
34593
34594 if (parameters['deleted'] !== undefined) {
34595 form['deleted'] = parameters['deleted'];
34596 }
34597
34598 if (parameters['write_protect'] !== undefined) {
34599 form['write_protect'] = parameters['write_protect'];
34600 }
34601
34602 if (parameters['lazy_blocked'] !== undefined) {
34603 form['lazy_blocked'] = parameters['lazy_blocked'];
34604 }
34605
34606 if (parameters['no_sync'] !== undefined) {
34607 form['no_sync'] = parameters['no_sync'];
34608 }
34609
34610 if (parameters['kind'] !== undefined) {
34611 form['kind'] = parameters['kind'];
34612 }
34613
34614 if (parameters['kind'] === undefined) {
34615 deferred.reject(new Error('Missing required form parameter: kind'));
34616 return deferred.promise;
34617 }
34618
34619 if (parameters['provider_service'] !== undefined) {
34620 form['provider_service'] = parameters['provider_service'];
34621 }
34622
34623 if (parameters['provider_service'] === undefined) {
34624 deferred.reject(new Error('Missing required form parameter: provider_service'));
34625 return deferred.promise;
34626 }
34627
34628 if (parameters['subscriber_service'] !== undefined) {
34629 form['subscriber_service'] = parameters['subscriber_service'];
34630 }
34631
34632 if (parameters['subscriber_tenant'] !== undefined) {
34633 form['subscriber_tenant'] = parameters['subscriber_tenant'];
34634 }
34635
34636 if (parameters['subscriber_user'] !== undefined) {
34637 form['subscriber_user'] = parameters['subscriber_user'];
34638 }
34639
34640 if (parameters['subscriber_root'] !== undefined) {
34641 form['subscriber_root'] = parameters['subscriber_root'];
34642 }
34643
34644 if (parameters['service_specific_id'] !== undefined) {
34645 form['service_specific_id'] = parameters['service_specific_id'];
34646 }
34647
34648 if (parameters['service_specific_attribute'] !== undefined) {
34649 form['service_specific_attribute'] = parameters['service_specific_attribute'];
34650 }
34651
34652 if (parameters['connect_method'] !== undefined) {
34653 form['connect_method'] = parameters['connect_method'];
34654 }
34655
34656 if (parameters['connect_method'] === undefined) {
34657 deferred.reject(new Error('Missing required form parameter: connect_method'));
34658 return deferred.promise;
34659 }
34660
34661 if (parameters.$queryParameters) {
34662 Object.keys(parameters.$queryParameters)
34663 .forEach(function(parameterName) {
34664 var parameter = parameters.$queryParameters[parameterName];
34665 queryParameters[parameterName] = parameter;
34666 });
34667 }
34668
34669 var url = domain + path;
34670 var options = {
34671 timeout: parameters.$timeout,
34672 method: 'PUT',
34673 url: url,
34674 params: queryParameters,
34675 data: body,
34676 headers: headers
34677 };
34678 if (Object.keys(form).length > 0) {
34679 options.data = form;
34680 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34681 options.transformRequest = xos.transformRequest;
34682 }
34683 $http(options)
34684 .success(function(data, status, headers, config) {
34685 deferred.resolve(data);
34686 if (parameters.$cache !== undefined) {
34687 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34688 }
34689 })
34690 .error(function(data, status, headers, config) {
34691 deferred.reject({
34692 status: status,
34693 headers: headers,
34694 config: config,
34695 body: data
34696 });
34697 });
34698
34699 return deferred.promise;
34700 };
34701 /**
34702 *
34703 * @method
34704 * @name xos#Tenant_With_Container_Detail_PATCH
34705 * @param {string} pk -
34706 * @param {string} enacted -
34707 * @param {string} policed -
34708 * @param {string} backend_register -
34709 * @param {string} backend_status -
34710 * @param {boolean} deleted -
34711 * @param {boolean} write_protect -
34712 * @param {boolean} lazy_blocked -
34713 * @param {boolean} no_sync -
34714 * @param {string} kind -
34715 * @param {string} provider_service -
34716 * @param {string} subscriber_service -
34717 * @param {string} subscriber_tenant -
34718 * @param {string} subscriber_user -
34719 * @param {string} subscriber_root -
34720 * @param {string} service_specific_id -
34721 * @param {string} service_specific_attribute -
34722 * @param {choice} connect_method -
34723 *
34724 */
34725 xos.prototype.Tenant_With_Container_Detail_PATCH = function(parameters) {
34726 if (parameters === undefined) {
34727 parameters = {};
34728 }
34729 var deferred = $q.defer();
34730
34731 var domain = this.domain;
34732 var path = '/xos/tenantwithcontainers/{pk}/';
34733
34734 var body;
34735 var queryParameters = {};
34736 var headers = {};
34737 var form = {};
34738
34739 path = path.replace('{pk}', parameters['pk']);
34740
34741 if (parameters['pk'] === undefined) {
34742 deferred.reject(new Error('Missing required path parameter: pk'));
34743 return deferred.promise;
34744 }
34745
34746 if (parameters['enacted'] !== undefined) {
34747 form['enacted'] = parameters['enacted'];
34748 }
34749
34750 if (parameters['policed'] !== undefined) {
34751 form['policed'] = parameters['policed'];
34752 }
34753
34754 if (parameters['backend_register'] !== undefined) {
34755 form['backend_register'] = parameters['backend_register'];
34756 }
34757
34758 if (parameters['backend_status'] !== undefined) {
34759 form['backend_status'] = parameters['backend_status'];
34760 }
34761
34762 if (parameters['deleted'] !== undefined) {
34763 form['deleted'] = parameters['deleted'];
34764 }
34765
34766 if (parameters['write_protect'] !== undefined) {
34767 form['write_protect'] = parameters['write_protect'];
34768 }
34769
34770 if (parameters['lazy_blocked'] !== undefined) {
34771 form['lazy_blocked'] = parameters['lazy_blocked'];
34772 }
34773
34774 if (parameters['no_sync'] !== undefined) {
34775 form['no_sync'] = parameters['no_sync'];
34776 }
34777
34778 if (parameters['kind'] !== undefined) {
34779 form['kind'] = parameters['kind'];
34780 }
34781
34782 if (parameters['provider_service'] !== undefined) {
34783 form['provider_service'] = parameters['provider_service'];
34784 }
34785
34786 if (parameters['subscriber_service'] !== undefined) {
34787 form['subscriber_service'] = parameters['subscriber_service'];
34788 }
34789
34790 if (parameters['subscriber_tenant'] !== undefined) {
34791 form['subscriber_tenant'] = parameters['subscriber_tenant'];
34792 }
34793
34794 if (parameters['subscriber_user'] !== undefined) {
34795 form['subscriber_user'] = parameters['subscriber_user'];
34796 }
34797
34798 if (parameters['subscriber_root'] !== undefined) {
34799 form['subscriber_root'] = parameters['subscriber_root'];
34800 }
34801
34802 if (parameters['service_specific_id'] !== undefined) {
34803 form['service_specific_id'] = parameters['service_specific_id'];
34804 }
34805
34806 if (parameters['service_specific_attribute'] !== undefined) {
34807 form['service_specific_attribute'] = parameters['service_specific_attribute'];
34808 }
34809
34810 if (parameters['connect_method'] !== undefined) {
34811 form['connect_method'] = parameters['connect_method'];
34812 }
34813
34814 if (parameters.$queryParameters) {
34815 Object.keys(parameters.$queryParameters)
34816 .forEach(function(parameterName) {
34817 var parameter = parameters.$queryParameters[parameterName];
34818 queryParameters[parameterName] = parameter;
34819 });
34820 }
34821
34822 var url = domain + path;
34823 var options = {
34824 timeout: parameters.$timeout,
34825 method: 'PATCH',
34826 url: url,
34827 params: queryParameters,
34828 data: body,
34829 headers: headers
34830 };
34831 if (Object.keys(form).length > 0) {
34832 options.data = form;
34833 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34834 options.transformRequest = xos.transformRequest;
34835 }
34836 $http(options)
34837 .success(function(data, status, headers, config) {
34838 deferred.resolve(data);
34839 if (parameters.$cache !== undefined) {
34840 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34841 }
34842 })
34843 .error(function(data, status, headers, config) {
34844 deferred.reject({
34845 status: status,
34846 headers: headers,
34847 config: config,
34848 body: data
34849 });
34850 });
34851
34852 return deferred.promise;
34853 };
34854 /**
34855 *
34856 * @method
34857 * @name xos#Tenant_With_Container_Detail_DELETE
34858 * @param {string} pk -
34859 *
34860 */
34861 xos.prototype.Tenant_With_Container_Detail_DELETE = function(parameters) {
34862 if (parameters === undefined) {
34863 parameters = {};
34864 }
34865 var deferred = $q.defer();
34866
34867 var domain = this.domain;
34868 var path = '/xos/tenantwithcontainers/{pk}/';
34869
34870 var body;
34871 var queryParameters = {};
34872 var headers = {};
34873 var form = {};
34874
34875 path = path.replace('{pk}', parameters['pk']);
34876
34877 if (parameters['pk'] === undefined) {
34878 deferred.reject(new Error('Missing required path parameter: pk'));
34879 return deferred.promise;
34880 }
34881
34882 if (parameters.$queryParameters) {
34883 Object.keys(parameters.$queryParameters)
34884 .forEach(function(parameterName) {
34885 var parameter = parameters.$queryParameters[parameterName];
34886 queryParameters[parameterName] = parameter;
34887 });
34888 }
34889
34890 var url = domain + path;
34891 var options = {
34892 timeout: parameters.$timeout,
34893 method: 'DELETE',
34894 url: url,
34895 params: queryParameters,
34896 data: body,
34897 headers: headers
34898 };
34899 if (Object.keys(form).length > 0) {
34900 options.data = form;
34901 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34902 options.transformRequest = xos.transformRequest;
34903 }
34904 $http(options)
34905 .success(function(data, status, headers, config) {
34906 deferred.resolve(data);
34907 if (parameters.$cache !== undefined) {
34908 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34909 }
34910 })
34911 .error(function(data, status, headers, config) {
34912 deferred.reject({
34913 status: status,
34914 headers: headers,
34915 config: config,
34916 body: data
34917 });
34918 });
34919
34920 return deferred.promise;
34921 };
34922 /**
34923 *
34924 * @method
34925 * @name xos#Deployment_Role_List_GET
34926 *
34927 */
34928 xos.prototype.Deployment_Role_List_GET = function(parameters) {
34929 if (parameters === undefined) {
34930 parameters = {};
34931 }
34932 var deferred = $q.defer();
34933
34934 var domain = this.domain;
34935 var path = '/xos/deploymentroles/';
34936
34937 var body;
34938 var queryParameters = {};
34939 var headers = {};
34940 var form = {};
34941
34942 if (parameters.$queryParameters) {
34943 Object.keys(parameters.$queryParameters)
34944 .forEach(function(parameterName) {
34945 var parameter = parameters.$queryParameters[parameterName];
34946 queryParameters[parameterName] = parameter;
34947 });
34948 }
34949
34950 var url = domain + path;
34951 var cached = parameters.$cache && parameters.$cache.get(url);
34952 if (cached !== undefined && parameters.$refresh !== true) {
34953 deferred.resolve(cached);
34954 return deferred.promise;
34955 }
34956 var options = {
34957 timeout: parameters.$timeout,
34958 method: 'GET',
34959 url: url,
34960 params: queryParameters,
34961 data: body,
34962 headers: headers
34963 };
34964 if (Object.keys(form).length > 0) {
34965 options.data = form;
34966 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
34967 options.transformRequest = xos.transformRequest;
34968 }
34969 $http(options)
34970 .success(function(data, status, headers, config) {
34971 deferred.resolve(data);
34972 if (parameters.$cache !== undefined) {
34973 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
34974 }
34975 })
34976 .error(function(data, status, headers, config) {
34977 deferred.reject({
34978 status: status,
34979 headers: headers,
34980 config: config,
34981 body: data
34982 });
34983 });
34984
34985 return deferred.promise;
34986 };
34987 /**
34988 *
34989 * @method
34990 * @name xos#Deployment_Role_List_POST
34991 * @param {string} enacted -
34992 * @param {string} policed -
34993 * @param {string} backend_register -
34994 * @param {string} backend_status -
34995 * @param {boolean} deleted -
34996 * @param {boolean} write_protect -
34997 * @param {boolean} lazy_blocked -
34998 * @param {boolean} no_sync -
34999
35000 *
35001 */
35002 xos.prototype.Deployment_Role_List_POST = function(parameters) {
35003 if (parameters === undefined) {
35004 parameters = {};
35005 }
35006 var deferred = $q.defer();
35007
35008 var domain = this.domain;
35009 var path = '/xos/deploymentroles/';
35010
35011 var body;
35012 var queryParameters = {};
35013 var headers = {};
35014 var form = {};
35015
35016 if (parameters['enacted'] !== undefined) {
35017 form['enacted'] = parameters['enacted'];
35018 }
35019
35020 if (parameters['policed'] !== undefined) {
35021 form['policed'] = parameters['policed'];
35022 }
35023
35024 if (parameters['backend_register'] !== undefined) {
35025 form['backend_register'] = parameters['backend_register'];
35026 }
35027
35028 if (parameters['backend_status'] !== undefined) {
35029 form['backend_status'] = parameters['backend_status'];
35030 }
35031
35032 if (parameters['backend_status'] === undefined) {
35033 deferred.reject(new Error('Missing required form parameter: backend_status'));
35034 return deferred.promise;
35035 }
35036
35037 if (parameters['deleted'] !== undefined) {
35038 form['deleted'] = parameters['deleted'];
35039 }
35040
35041 if (parameters['write_protect'] !== undefined) {
35042 form['write_protect'] = parameters['write_protect'];
35043 }
35044
35045 if (parameters['lazy_blocked'] !== undefined) {
35046 form['lazy_blocked'] = parameters['lazy_blocked'];
35047 }
35048
35049 if (parameters['no_sync'] !== undefined) {
35050 form['no_sync'] = parameters['no_sync'];
35051 }
35052
35053 form['role'] = 'admin';
35054
35055 if (parameters['role'] === undefined) {
35056 deferred.reject(new Error('Missing required form parameter: role'));
35057 return deferred.promise;
35058 }
35059
35060 if (parameters.$queryParameters) {
35061 Object.keys(parameters.$queryParameters)
35062 .forEach(function(parameterName) {
35063 var parameter = parameters.$queryParameters[parameterName];
35064 queryParameters[parameterName] = parameter;
35065 });
35066 }
35067
35068 var url = domain + path;
35069 var options = {
35070 timeout: parameters.$timeout,
35071 method: 'POST',
35072 url: url,
35073 params: queryParameters,
35074 data: body,
35075 headers: headers
35076 };
35077 if (Object.keys(form).length > 0) {
35078 options.data = form;
35079 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35080 options.transformRequest = xos.transformRequest;
35081 }
35082 $http(options)
35083 .success(function(data, status, headers, config) {
35084 deferred.resolve(data);
35085 if (parameters.$cache !== undefined) {
35086 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35087 }
35088 })
35089 .error(function(data, status, headers, config) {
35090 deferred.reject({
35091 status: status,
35092 headers: headers,
35093 config: config,
35094 body: data
35095 });
35096 });
35097
35098 return deferred.promise;
35099 };
35100 /**
35101 *
35102 * @method
35103 * @name xos#Deployment_Role_Detail_GET
35104 * @param {string} pk -
35105 *
35106 */
35107 xos.prototype.Deployment_Role_Detail_GET = function(parameters) {
35108 if (parameters === undefined) {
35109 parameters = {};
35110 }
35111 var deferred = $q.defer();
35112
35113 var domain = this.domain;
35114 var path = '/xos/deploymentroles/{pk}/';
35115
35116 var body;
35117 var queryParameters = {};
35118 var headers = {};
35119 var form = {};
35120
35121 path = path.replace('{pk}', parameters['pk']);
35122
35123 if (parameters['pk'] === undefined) {
35124 deferred.reject(new Error('Missing required path parameter: pk'));
35125 return deferred.promise;
35126 }
35127
35128 if (parameters.$queryParameters) {
35129 Object.keys(parameters.$queryParameters)
35130 .forEach(function(parameterName) {
35131 var parameter = parameters.$queryParameters[parameterName];
35132 queryParameters[parameterName] = parameter;
35133 });
35134 }
35135
35136 var url = domain + path;
35137 var cached = parameters.$cache && parameters.$cache.get(url);
35138 if (cached !== undefined && parameters.$refresh !== true) {
35139 deferred.resolve(cached);
35140 return deferred.promise;
35141 }
35142 var options = {
35143 timeout: parameters.$timeout,
35144 method: 'GET',
35145 url: url,
35146 params: queryParameters,
35147 data: body,
35148 headers: headers
35149 };
35150 if (Object.keys(form).length > 0) {
35151 options.data = form;
35152 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35153 options.transformRequest = xos.transformRequest;
35154 }
35155 $http(options)
35156 .success(function(data, status, headers, config) {
35157 deferred.resolve(data);
35158 if (parameters.$cache !== undefined) {
35159 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35160 }
35161 })
35162 .error(function(data, status, headers, config) {
35163 deferred.reject({
35164 status: status,
35165 headers: headers,
35166 config: config,
35167 body: data
35168 });
35169 });
35170
35171 return deferred.promise;
35172 };
35173 /**
35174 *
35175 * @method
35176 * @name xos#Deployment_Role_Detail_PUT
35177 * @param {string} pk -
35178 * @param {string} enacted -
35179 * @param {string} policed -
35180 * @param {string} backend_register -
35181 * @param {string} backend_status -
35182 * @param {boolean} deleted -
35183 * @param {boolean} write_protect -
35184 * @param {boolean} lazy_blocked -
35185 * @param {boolean} no_sync -
35186
35187 *
35188 */
35189 xos.prototype.Deployment_Role_Detail_PUT = function(parameters) {
35190 if (parameters === undefined) {
35191 parameters = {};
35192 }
35193 var deferred = $q.defer();
35194
35195 var domain = this.domain;
35196 var path = '/xos/deploymentroles/{pk}/';
35197
35198 var body;
35199 var queryParameters = {};
35200 var headers = {};
35201 var form = {};
35202
35203 path = path.replace('{pk}', parameters['pk']);
35204
35205 if (parameters['pk'] === undefined) {
35206 deferred.reject(new Error('Missing required path parameter: pk'));
35207 return deferred.promise;
35208 }
35209
35210 if (parameters['enacted'] !== undefined) {
35211 form['enacted'] = parameters['enacted'];
35212 }
35213
35214 if (parameters['policed'] !== undefined) {
35215 form['policed'] = parameters['policed'];
35216 }
35217
35218 if (parameters['backend_register'] !== undefined) {
35219 form['backend_register'] = parameters['backend_register'];
35220 }
35221
35222 if (parameters['backend_status'] !== undefined) {
35223 form['backend_status'] = parameters['backend_status'];
35224 }
35225
35226 if (parameters['backend_status'] === undefined) {
35227 deferred.reject(new Error('Missing required form parameter: backend_status'));
35228 return deferred.promise;
35229 }
35230
35231 if (parameters['deleted'] !== undefined) {
35232 form['deleted'] = parameters['deleted'];
35233 }
35234
35235 if (parameters['write_protect'] !== undefined) {
35236 form['write_protect'] = parameters['write_protect'];
35237 }
35238
35239 if (parameters['lazy_blocked'] !== undefined) {
35240 form['lazy_blocked'] = parameters['lazy_blocked'];
35241 }
35242
35243 if (parameters['no_sync'] !== undefined) {
35244 form['no_sync'] = parameters['no_sync'];
35245 }
35246
35247 form['role'] = 'admin';
35248
35249 if (parameters['role'] === undefined) {
35250 deferred.reject(new Error('Missing required form parameter: role'));
35251 return deferred.promise;
35252 }
35253
35254 if (parameters.$queryParameters) {
35255 Object.keys(parameters.$queryParameters)
35256 .forEach(function(parameterName) {
35257 var parameter = parameters.$queryParameters[parameterName];
35258 queryParameters[parameterName] = parameter;
35259 });
35260 }
35261
35262 var url = domain + path;
35263 var options = {
35264 timeout: parameters.$timeout,
35265 method: 'PUT',
35266 url: url,
35267 params: queryParameters,
35268 data: body,
35269 headers: headers
35270 };
35271 if (Object.keys(form).length > 0) {
35272 options.data = form;
35273 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35274 options.transformRequest = xos.transformRequest;
35275 }
35276 $http(options)
35277 .success(function(data, status, headers, config) {
35278 deferred.resolve(data);
35279 if (parameters.$cache !== undefined) {
35280 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35281 }
35282 })
35283 .error(function(data, status, headers, config) {
35284 deferred.reject({
35285 status: status,
35286 headers: headers,
35287 config: config,
35288 body: data
35289 });
35290 });
35291
35292 return deferred.promise;
35293 };
35294 /**
35295 *
35296 * @method
35297 * @name xos#Deployment_Role_Detail_PATCH
35298 * @param {string} pk -
35299 * @param {string} enacted -
35300 * @param {string} policed -
35301 * @param {string} backend_register -
35302 * @param {string} backend_status -
35303 * @param {boolean} deleted -
35304 * @param {boolean} write_protect -
35305 * @param {boolean} lazy_blocked -
35306 * @param {boolean} no_sync -
35307
35308 *
35309 */
35310 xos.prototype.Deployment_Role_Detail_PATCH = function(parameters) {
35311 if (parameters === undefined) {
35312 parameters = {};
35313 }
35314 var deferred = $q.defer();
35315
35316 var domain = this.domain;
35317 var path = '/xos/deploymentroles/{pk}/';
35318
35319 var body;
35320 var queryParameters = {};
35321 var headers = {};
35322 var form = {};
35323
35324 path = path.replace('{pk}', parameters['pk']);
35325
35326 if (parameters['pk'] === undefined) {
35327 deferred.reject(new Error('Missing required path parameter: pk'));
35328 return deferred.promise;
35329 }
35330
35331 if (parameters['enacted'] !== undefined) {
35332 form['enacted'] = parameters['enacted'];
35333 }
35334
35335 if (parameters['policed'] !== undefined) {
35336 form['policed'] = parameters['policed'];
35337 }
35338
35339 if (parameters['backend_register'] !== undefined) {
35340 form['backend_register'] = parameters['backend_register'];
35341 }
35342
35343 if (parameters['backend_status'] !== undefined) {
35344 form['backend_status'] = parameters['backend_status'];
35345 }
35346
35347 if (parameters['deleted'] !== undefined) {
35348 form['deleted'] = parameters['deleted'];
35349 }
35350
35351 if (parameters['write_protect'] !== undefined) {
35352 form['write_protect'] = parameters['write_protect'];
35353 }
35354
35355 if (parameters['lazy_blocked'] !== undefined) {
35356 form['lazy_blocked'] = parameters['lazy_blocked'];
35357 }
35358
35359 if (parameters['no_sync'] !== undefined) {
35360 form['no_sync'] = parameters['no_sync'];
35361 }
35362
35363 form['role'] = 'admin';
35364
35365 if (parameters.$queryParameters) {
35366 Object.keys(parameters.$queryParameters)
35367 .forEach(function(parameterName) {
35368 var parameter = parameters.$queryParameters[parameterName];
35369 queryParameters[parameterName] = parameter;
35370 });
35371 }
35372
35373 var url = domain + path;
35374 var options = {
35375 timeout: parameters.$timeout,
35376 method: 'PATCH',
35377 url: url,
35378 params: queryParameters,
35379 data: body,
35380 headers: headers
35381 };
35382 if (Object.keys(form).length > 0) {
35383 options.data = form;
35384 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35385 options.transformRequest = xos.transformRequest;
35386 }
35387 $http(options)
35388 .success(function(data, status, headers, config) {
35389 deferred.resolve(data);
35390 if (parameters.$cache !== undefined) {
35391 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35392 }
35393 })
35394 .error(function(data, status, headers, config) {
35395 deferred.reject({
35396 status: status,
35397 headers: headers,
35398 config: config,
35399 body: data
35400 });
35401 });
35402
35403 return deferred.promise;
35404 };
35405 /**
35406 *
35407 * @method
35408 * @name xos#Deployment_Role_Detail_DELETE
35409 * @param {string} pk -
35410 *
35411 */
35412 xos.prototype.Deployment_Role_Detail_DELETE = function(parameters) {
35413 if (parameters === undefined) {
35414 parameters = {};
35415 }
35416 var deferred = $q.defer();
35417
35418 var domain = this.domain;
35419 var path = '/xos/deploymentroles/{pk}/';
35420
35421 var body;
35422 var queryParameters = {};
35423 var headers = {};
35424 var form = {};
35425
35426 path = path.replace('{pk}', parameters['pk']);
35427
35428 if (parameters['pk'] === undefined) {
35429 deferred.reject(new Error('Missing required path parameter: pk'));
35430 return deferred.promise;
35431 }
35432
35433 if (parameters.$queryParameters) {
35434 Object.keys(parameters.$queryParameters)
35435 .forEach(function(parameterName) {
35436 var parameter = parameters.$queryParameters[parameterName];
35437 queryParameters[parameterName] = parameter;
35438 });
35439 }
35440
35441 var url = domain + path;
35442 var options = {
35443 timeout: parameters.$timeout,
35444 method: 'DELETE',
35445 url: url,
35446 params: queryParameters,
35447 data: body,
35448 headers: headers
35449 };
35450 if (Object.keys(form).length > 0) {
35451 options.data = form;
35452 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35453 options.transformRequest = xos.transformRequest;
35454 }
35455 $http(options)
35456 .success(function(data, status, headers, config) {
35457 deferred.resolve(data);
35458 if (parameters.$cache !== undefined) {
35459 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35460 }
35461 })
35462 .error(function(data, status, headers, config) {
35463 deferred.reject({
35464 status: status,
35465 headers: headers,
35466 config: config,
35467 body: data
35468 });
35469 });
35470
35471 return deferred.promise;
35472 };
35473 /**
35474 *
35475 * @method
35476 * @name xos#User_Credential_List_GET
35477 *
35478 */
35479 xos.prototype.User_Credential_List_GET = function(parameters) {
35480 if (parameters === undefined) {
35481 parameters = {};
35482 }
35483 var deferred = $q.defer();
35484
35485 var domain = this.domain;
35486 var path = '/xos/usercredentials/';
35487
35488 var body;
35489 var queryParameters = {};
35490 var headers = {};
35491 var form = {};
35492
35493 if (parameters.$queryParameters) {
35494 Object.keys(parameters.$queryParameters)
35495 .forEach(function(parameterName) {
35496 var parameter = parameters.$queryParameters[parameterName];
35497 queryParameters[parameterName] = parameter;
35498 });
35499 }
35500
35501 var url = domain + path;
35502 var cached = parameters.$cache && parameters.$cache.get(url);
35503 if (cached !== undefined && parameters.$refresh !== true) {
35504 deferred.resolve(cached);
35505 return deferred.promise;
35506 }
35507 var options = {
35508 timeout: parameters.$timeout,
35509 method: 'GET',
35510 url: url,
35511 params: queryParameters,
35512 data: body,
35513 headers: headers
35514 };
35515 if (Object.keys(form).length > 0) {
35516 options.data = form;
35517 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35518 options.transformRequest = xos.transformRequest;
35519 }
35520 $http(options)
35521 .success(function(data, status, headers, config) {
35522 deferred.resolve(data);
35523 if (parameters.$cache !== undefined) {
35524 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35525 }
35526 })
35527 .error(function(data, status, headers, config) {
35528 deferred.reject({
35529 status: status,
35530 headers: headers,
35531 config: config,
35532 body: data
35533 });
35534 });
35535
35536 return deferred.promise;
35537 };
35538 /**
35539 *
35540 * @method
35541 * @name xos#User_Credential_List_POST
35542 * @param {string} enacted -
35543 * @param {string} policed -
35544 * @param {string} backend_register -
35545 * @param {string} backend_status -
35546 * @param {boolean} deleted -
35547 * @param {boolean} write_protect -
35548 * @param {boolean} lazy_blocked -
35549 * @param {boolean} no_sync -
35550 * @param {string} user - The User this credential is associated with
35551 * @param {string} name - The credential type, e.g. ec2
35552 * @param {string} key_id - The backend id of this credential
35553 * @param {string} enc_value - The key value of this credential
35554 *
35555 */
35556 xos.prototype.User_Credential_List_POST = function(parameters) {
35557 if (parameters === undefined) {
35558 parameters = {};
35559 }
35560 var deferred = $q.defer();
35561
35562 var domain = this.domain;
35563 var path = '/xos/usercredentials/';
35564
35565 var body;
35566 var queryParameters = {};
35567 var headers = {};
35568 var form = {};
35569
35570 if (parameters['enacted'] !== undefined) {
35571 form['enacted'] = parameters['enacted'];
35572 }
35573
35574 if (parameters['policed'] !== undefined) {
35575 form['policed'] = parameters['policed'];
35576 }
35577
35578 if (parameters['backend_register'] !== undefined) {
35579 form['backend_register'] = parameters['backend_register'];
35580 }
35581
35582 if (parameters['backend_status'] !== undefined) {
35583 form['backend_status'] = parameters['backend_status'];
35584 }
35585
35586 if (parameters['backend_status'] === undefined) {
35587 deferred.reject(new Error('Missing required form parameter: backend_status'));
35588 return deferred.promise;
35589 }
35590
35591 if (parameters['deleted'] !== undefined) {
35592 form['deleted'] = parameters['deleted'];
35593 }
35594
35595 if (parameters['write_protect'] !== undefined) {
35596 form['write_protect'] = parameters['write_protect'];
35597 }
35598
35599 if (parameters['lazy_blocked'] !== undefined) {
35600 form['lazy_blocked'] = parameters['lazy_blocked'];
35601 }
35602
35603 if (parameters['no_sync'] !== undefined) {
35604 form['no_sync'] = parameters['no_sync'];
35605 }
35606
35607 if (parameters['user'] !== undefined) {
35608 form['user'] = parameters['user'];
35609 }
35610
35611 if (parameters['user'] === undefined) {
35612 deferred.reject(new Error('Missing required form parameter: user'));
35613 return deferred.promise;
35614 }
35615
35616 if (parameters['name'] !== undefined) {
35617 form['name'] = parameters['name'];
35618 }
35619
35620 if (parameters['name'] === undefined) {
35621 deferred.reject(new Error('Missing required form parameter: name'));
35622 return deferred.promise;
35623 }
35624
35625 if (parameters['key_id'] !== undefined) {
35626 form['key_id'] = parameters['key_id'];
35627 }
35628
35629 if (parameters['key_id'] === undefined) {
35630 deferred.reject(new Error('Missing required form parameter: key_id'));
35631 return deferred.promise;
35632 }
35633
35634 if (parameters['enc_value'] !== undefined) {
35635 form['enc_value'] = parameters['enc_value'];
35636 }
35637
35638 if (parameters['enc_value'] === undefined) {
35639 deferred.reject(new Error('Missing required form parameter: enc_value'));
35640 return deferred.promise;
35641 }
35642
35643 if (parameters.$queryParameters) {
35644 Object.keys(parameters.$queryParameters)
35645 .forEach(function(parameterName) {
35646 var parameter = parameters.$queryParameters[parameterName];
35647 queryParameters[parameterName] = parameter;
35648 });
35649 }
35650
35651 var url = domain + path;
35652 var options = {
35653 timeout: parameters.$timeout,
35654 method: 'POST',
35655 url: url,
35656 params: queryParameters,
35657 data: body,
35658 headers: headers
35659 };
35660 if (Object.keys(form).length > 0) {
35661 options.data = form;
35662 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35663 options.transformRequest = xos.transformRequest;
35664 }
35665 $http(options)
35666 .success(function(data, status, headers, config) {
35667 deferred.resolve(data);
35668 if (parameters.$cache !== undefined) {
35669 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35670 }
35671 })
35672 .error(function(data, status, headers, config) {
35673 deferred.reject({
35674 status: status,
35675 headers: headers,
35676 config: config,
35677 body: data
35678 });
35679 });
35680
35681 return deferred.promise;
35682 };
35683 /**
35684 *
35685 * @method
35686 * @name xos#User_Credential_Detail_GET
35687 * @param {string} pk -
35688 *
35689 */
35690 xos.prototype.User_Credential_Detail_GET = function(parameters) {
35691 if (parameters === undefined) {
35692 parameters = {};
35693 }
35694 var deferred = $q.defer();
35695
35696 var domain = this.domain;
35697 var path = '/xos/usercredentials/{pk}/';
35698
35699 var body;
35700 var queryParameters = {};
35701 var headers = {};
35702 var form = {};
35703
35704 path = path.replace('{pk}', parameters['pk']);
35705
35706 if (parameters['pk'] === undefined) {
35707 deferred.reject(new Error('Missing required path parameter: pk'));
35708 return deferred.promise;
35709 }
35710
35711 if (parameters.$queryParameters) {
35712 Object.keys(parameters.$queryParameters)
35713 .forEach(function(parameterName) {
35714 var parameter = parameters.$queryParameters[parameterName];
35715 queryParameters[parameterName] = parameter;
35716 });
35717 }
35718
35719 var url = domain + path;
35720 var cached = parameters.$cache && parameters.$cache.get(url);
35721 if (cached !== undefined && parameters.$refresh !== true) {
35722 deferred.resolve(cached);
35723 return deferred.promise;
35724 }
35725 var options = {
35726 timeout: parameters.$timeout,
35727 method: 'GET',
35728 url: url,
35729 params: queryParameters,
35730 data: body,
35731 headers: headers
35732 };
35733 if (Object.keys(form).length > 0) {
35734 options.data = form;
35735 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35736 options.transformRequest = xos.transformRequest;
35737 }
35738 $http(options)
35739 .success(function(data, status, headers, config) {
35740 deferred.resolve(data);
35741 if (parameters.$cache !== undefined) {
35742 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35743 }
35744 })
35745 .error(function(data, status, headers, config) {
35746 deferred.reject({
35747 status: status,
35748 headers: headers,
35749 config: config,
35750 body: data
35751 });
35752 });
35753
35754 return deferred.promise;
35755 };
35756 /**
35757 *
35758 * @method
35759 * @name xos#User_Credential_Detail_PUT
35760 * @param {string} pk -
35761 * @param {string} enacted -
35762 * @param {string} policed -
35763 * @param {string} backend_register -
35764 * @param {string} backend_status -
35765 * @param {boolean} deleted -
35766 * @param {boolean} write_protect -
35767 * @param {boolean} lazy_blocked -
35768 * @param {boolean} no_sync -
35769 * @param {string} user - The User this credential is associated with
35770 * @param {string} name - The credential type, e.g. ec2
35771 * @param {string} key_id - The backend id of this credential
35772 * @param {string} enc_value - The key value of this credential
35773 *
35774 */
35775 xos.prototype.User_Credential_Detail_PUT = function(parameters) {
35776 if (parameters === undefined) {
35777 parameters = {};
35778 }
35779 var deferred = $q.defer();
35780
35781 var domain = this.domain;
35782 var path = '/xos/usercredentials/{pk}/';
35783
35784 var body;
35785 var queryParameters = {};
35786 var headers = {};
35787 var form = {};
35788
35789 path = path.replace('{pk}', parameters['pk']);
35790
35791 if (parameters['pk'] === undefined) {
35792 deferred.reject(new Error('Missing required path parameter: pk'));
35793 return deferred.promise;
35794 }
35795
35796 if (parameters['enacted'] !== undefined) {
35797 form['enacted'] = parameters['enacted'];
35798 }
35799
35800 if (parameters['policed'] !== undefined) {
35801 form['policed'] = parameters['policed'];
35802 }
35803
35804 if (parameters['backend_register'] !== undefined) {
35805 form['backend_register'] = parameters['backend_register'];
35806 }
35807
35808 if (parameters['backend_status'] !== undefined) {
35809 form['backend_status'] = parameters['backend_status'];
35810 }
35811
35812 if (parameters['backend_status'] === undefined) {
35813 deferred.reject(new Error('Missing required form parameter: backend_status'));
35814 return deferred.promise;
35815 }
35816
35817 if (parameters['deleted'] !== undefined) {
35818 form['deleted'] = parameters['deleted'];
35819 }
35820
35821 if (parameters['write_protect'] !== undefined) {
35822 form['write_protect'] = parameters['write_protect'];
35823 }
35824
35825 if (parameters['lazy_blocked'] !== undefined) {
35826 form['lazy_blocked'] = parameters['lazy_blocked'];
35827 }
35828
35829 if (parameters['no_sync'] !== undefined) {
35830 form['no_sync'] = parameters['no_sync'];
35831 }
35832
35833 if (parameters['user'] !== undefined) {
35834 form['user'] = parameters['user'];
35835 }
35836
35837 if (parameters['user'] === undefined) {
35838 deferred.reject(new Error('Missing required form parameter: user'));
35839 return deferred.promise;
35840 }
35841
35842 if (parameters['name'] !== undefined) {
35843 form['name'] = parameters['name'];
35844 }
35845
35846 if (parameters['name'] === undefined) {
35847 deferred.reject(new Error('Missing required form parameter: name'));
35848 return deferred.promise;
35849 }
35850
35851 if (parameters['key_id'] !== undefined) {
35852 form['key_id'] = parameters['key_id'];
35853 }
35854
35855 if (parameters['key_id'] === undefined) {
35856 deferred.reject(new Error('Missing required form parameter: key_id'));
35857 return deferred.promise;
35858 }
35859
35860 if (parameters['enc_value'] !== undefined) {
35861 form['enc_value'] = parameters['enc_value'];
35862 }
35863
35864 if (parameters['enc_value'] === undefined) {
35865 deferred.reject(new Error('Missing required form parameter: enc_value'));
35866 return deferred.promise;
35867 }
35868
35869 if (parameters.$queryParameters) {
35870 Object.keys(parameters.$queryParameters)
35871 .forEach(function(parameterName) {
35872 var parameter = parameters.$queryParameters[parameterName];
35873 queryParameters[parameterName] = parameter;
35874 });
35875 }
35876
35877 var url = domain + path;
35878 var options = {
35879 timeout: parameters.$timeout,
35880 method: 'PUT',
35881 url: url,
35882 params: queryParameters,
35883 data: body,
35884 headers: headers
35885 };
35886 if (Object.keys(form).length > 0) {
35887 options.data = form;
35888 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
35889 options.transformRequest = xos.transformRequest;
35890 }
35891 $http(options)
35892 .success(function(data, status, headers, config) {
35893 deferred.resolve(data);
35894 if (parameters.$cache !== undefined) {
35895 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
35896 }
35897 })
35898 .error(function(data, status, headers, config) {
35899 deferred.reject({
35900 status: status,
35901 headers: headers,
35902 config: config,
35903 body: data
35904 });
35905 });
35906
35907 return deferred.promise;
35908 };
35909 /**
35910 *
35911 * @method
35912 * @name xos#User_Credential_Detail_PATCH
35913 * @param {string} pk -
35914 * @param {string} enacted -
35915 * @param {string} policed -
35916 * @param {string} backend_register -
35917 * @param {string} backend_status -
35918 * @param {boolean} deleted -
35919 * @param {boolean} write_protect -
35920 * @param {boolean} lazy_blocked -
35921 * @param {boolean} no_sync -
35922 * @param {string} user - The User this credential is associated with
35923 * @param {string} name - The credential type, e.g. ec2
35924 * @param {string} key_id - The backend id of this credential
35925 * @param {string} enc_value - The key value of this credential
35926 *
35927 */
35928 xos.prototype.User_Credential_Detail_PATCH = function(parameters) {
35929 if (parameters === undefined) {
35930 parameters = {};
35931 }
35932 var deferred = $q.defer();
35933
35934 var domain = this.domain;
35935 var path = '/xos/usercredentials/{pk}/';
35936
35937 var body;
35938 var queryParameters = {};
35939 var headers = {};
35940 var form = {};
35941
35942 path = path.replace('{pk}', parameters['pk']);
35943
35944 if (parameters['pk'] === undefined) {
35945 deferred.reject(new Error('Missing required path parameter: pk'));
35946 return deferred.promise;
35947 }
35948
35949 if (parameters['enacted'] !== undefined) {
35950 form['enacted'] = parameters['enacted'];
35951 }
35952
35953 if (parameters['policed'] !== undefined) {
35954 form['policed'] = parameters['policed'];
35955 }
35956
35957 if (parameters['backend_register'] !== undefined) {
35958 form['backend_register'] = parameters['backend_register'];
35959 }
35960
35961 if (parameters['backend_status'] !== undefined) {
35962 form['backend_status'] = parameters['backend_status'];
35963 }
35964
35965 if (parameters['deleted'] !== undefined) {
35966 form['deleted'] = parameters['deleted'];
35967 }
35968
35969 if (parameters['write_protect'] !== undefined) {
35970 form['write_protect'] = parameters['write_protect'];
35971 }
35972
35973 if (parameters['lazy_blocked'] !== undefined) {
35974 form['lazy_blocked'] = parameters['lazy_blocked'];
35975 }
35976
35977 if (parameters['no_sync'] !== undefined) {
35978 form['no_sync'] = parameters['no_sync'];
35979 }
35980
35981 if (parameters['user'] !== undefined) {
35982 form['user'] = parameters['user'];
35983 }
35984
35985 if (parameters['name'] !== undefined) {
35986 form['name'] = parameters['name'];
35987 }
35988
35989 if (parameters['key_id'] !== undefined) {
35990 form['key_id'] = parameters['key_id'];
35991 }
35992
35993 if (parameters['enc_value'] !== undefined) {
35994 form['enc_value'] = parameters['enc_value'];
35995 }
35996
35997 if (parameters.$queryParameters) {
35998 Object.keys(parameters.$queryParameters)
35999 .forEach(function(parameterName) {
36000 var parameter = parameters.$queryParameters[parameterName];
36001 queryParameters[parameterName] = parameter;
36002 });
36003 }
36004
36005 var url = domain + path;
36006 var options = {
36007 timeout: parameters.$timeout,
36008 method: 'PATCH',
36009 url: url,
36010 params: queryParameters,
36011 data: body,
36012 headers: headers
36013 };
36014 if (Object.keys(form).length > 0) {
36015 options.data = form;
36016 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36017 options.transformRequest = xos.transformRequest;
36018 }
36019 $http(options)
36020 .success(function(data, status, headers, config) {
36021 deferred.resolve(data);
36022 if (parameters.$cache !== undefined) {
36023 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36024 }
36025 })
36026 .error(function(data, status, headers, config) {
36027 deferred.reject({
36028 status: status,
36029 headers: headers,
36030 config: config,
36031 body: data
36032 });
36033 });
36034
36035 return deferred.promise;
36036 };
36037 /**
36038 *
36039 * @method
36040 * @name xos#User_Credential_Detail_DELETE
36041 * @param {string} pk -
36042 *
36043 */
36044 xos.prototype.User_Credential_Detail_DELETE = function(parameters) {
36045 if (parameters === undefined) {
36046 parameters = {};
36047 }
36048 var deferred = $q.defer();
36049
36050 var domain = this.domain;
36051 var path = '/xos/usercredentials/{pk}/';
36052
36053 var body;
36054 var queryParameters = {};
36055 var headers = {};
36056 var form = {};
36057
36058 path = path.replace('{pk}', parameters['pk']);
36059
36060 if (parameters['pk'] === undefined) {
36061 deferred.reject(new Error('Missing required path parameter: pk'));
36062 return deferred.promise;
36063 }
36064
36065 if (parameters.$queryParameters) {
36066 Object.keys(parameters.$queryParameters)
36067 .forEach(function(parameterName) {
36068 var parameter = parameters.$queryParameters[parameterName];
36069 queryParameters[parameterName] = parameter;
36070 });
36071 }
36072
36073 var url = domain + path;
36074 var options = {
36075 timeout: parameters.$timeout,
36076 method: 'DELETE',
36077 url: url,
36078 params: queryParameters,
36079 data: body,
36080 headers: headers
36081 };
36082 if (Object.keys(form).length > 0) {
36083 options.data = form;
36084 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36085 options.transformRequest = xos.transformRequest;
36086 }
36087 $http(options)
36088 .success(function(data, status, headers, config) {
36089 deferred.resolve(data);
36090 if (parameters.$cache !== undefined) {
36091 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36092 }
36093 })
36094 .error(function(data, status, headers, config) {
36095 deferred.reject({
36096 status: status,
36097 headers: headers,
36098 config: config,
36099 body: data
36100 });
36101 });
36102
36103 return deferred.promise;
36104 };
36105 /**
36106 *
36107 * @method
36108 * @name xos#Tenant_Root_Privilege_List_GET
36109 *
36110 */
36111 xos.prototype.Tenant_Root_Privilege_List_GET = function(parameters) {
36112 if (parameters === undefined) {
36113 parameters = {};
36114 }
36115 var deferred = $q.defer();
36116
36117 var domain = this.domain;
36118 var path = '/xos/tenantrootprivileges/';
36119
36120 var body;
36121 var queryParameters = {};
36122 var headers = {};
36123 var form = {};
36124
36125 if (parameters.$queryParameters) {
36126 Object.keys(parameters.$queryParameters)
36127 .forEach(function(parameterName) {
36128 var parameter = parameters.$queryParameters[parameterName];
36129 queryParameters[parameterName] = parameter;
36130 });
36131 }
36132
36133 var url = domain + path;
36134 var cached = parameters.$cache && parameters.$cache.get(url);
36135 if (cached !== undefined && parameters.$refresh !== true) {
36136 deferred.resolve(cached);
36137 return deferred.promise;
36138 }
36139 var options = {
36140 timeout: parameters.$timeout,
36141 method: 'GET',
36142 url: url,
36143 params: queryParameters,
36144 data: body,
36145 headers: headers
36146 };
36147 if (Object.keys(form).length > 0) {
36148 options.data = form;
36149 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36150 options.transformRequest = xos.transformRequest;
36151 }
36152 $http(options)
36153 .success(function(data, status, headers, config) {
36154 deferred.resolve(data);
36155 if (parameters.$cache !== undefined) {
36156 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36157 }
36158 })
36159 .error(function(data, status, headers, config) {
36160 deferred.reject({
36161 status: status,
36162 headers: headers,
36163 config: config,
36164 body: data
36165 });
36166 });
36167
36168 return deferred.promise;
36169 };
36170 /**
36171 *
36172 * @method
36173 * @name xos#Tenant_Root_Privilege_List_POST
36174 * @param {string} enacted -
36175 * @param {string} policed -
36176 * @param {string} backend_register -
36177 * @param {string} backend_status -
36178 * @param {boolean} deleted -
36179 * @param {boolean} write_protect -
36180 * @param {boolean} lazy_blocked -
36181 * @param {boolean} no_sync -
36182 * @param {string} user -
36183 * @param {string} tenant_root -
36184 * @param {string} role -
36185 *
36186 */
36187 xos.prototype.Tenant_Root_Privilege_List_POST = function(parameters) {
36188 if (parameters === undefined) {
36189 parameters = {};
36190 }
36191 var deferred = $q.defer();
36192
36193 var domain = this.domain;
36194 var path = '/xos/tenantrootprivileges/';
36195
36196 var body;
36197 var queryParameters = {};
36198 var headers = {};
36199 var form = {};
36200
36201 if (parameters['enacted'] !== undefined) {
36202 form['enacted'] = parameters['enacted'];
36203 }
36204
36205 if (parameters['policed'] !== undefined) {
36206 form['policed'] = parameters['policed'];
36207 }
36208
36209 if (parameters['backend_register'] !== undefined) {
36210 form['backend_register'] = parameters['backend_register'];
36211 }
36212
36213 if (parameters['backend_status'] !== undefined) {
36214 form['backend_status'] = parameters['backend_status'];
36215 }
36216
36217 if (parameters['backend_status'] === undefined) {
36218 deferred.reject(new Error('Missing required form parameter: backend_status'));
36219 return deferred.promise;
36220 }
36221
36222 if (parameters['deleted'] !== undefined) {
36223 form['deleted'] = parameters['deleted'];
36224 }
36225
36226 if (parameters['write_protect'] !== undefined) {
36227 form['write_protect'] = parameters['write_protect'];
36228 }
36229
36230 if (parameters['lazy_blocked'] !== undefined) {
36231 form['lazy_blocked'] = parameters['lazy_blocked'];
36232 }
36233
36234 if (parameters['no_sync'] !== undefined) {
36235 form['no_sync'] = parameters['no_sync'];
36236 }
36237
36238 if (parameters['user'] !== undefined) {
36239 form['user'] = parameters['user'];
36240 }
36241
36242 if (parameters['user'] === undefined) {
36243 deferred.reject(new Error('Missing required form parameter: user'));
36244 return deferred.promise;
36245 }
36246
36247 if (parameters['tenant_root'] !== undefined) {
36248 form['tenant_root'] = parameters['tenant_root'];
36249 }
36250
36251 if (parameters['tenant_root'] === undefined) {
36252 deferred.reject(new Error('Missing required form parameter: tenant_root'));
36253 return deferred.promise;
36254 }
36255
36256 if (parameters['role'] !== undefined) {
36257 form['role'] = parameters['role'];
36258 }
36259
36260 if (parameters['role'] === undefined) {
36261 deferred.reject(new Error('Missing required form parameter: role'));
36262 return deferred.promise;
36263 }
36264
36265 if (parameters.$queryParameters) {
36266 Object.keys(parameters.$queryParameters)
36267 .forEach(function(parameterName) {
36268 var parameter = parameters.$queryParameters[parameterName];
36269 queryParameters[parameterName] = parameter;
36270 });
36271 }
36272
36273 var url = domain + path;
36274 var options = {
36275 timeout: parameters.$timeout,
36276 method: 'POST',
36277 url: url,
36278 params: queryParameters,
36279 data: body,
36280 headers: headers
36281 };
36282 if (Object.keys(form).length > 0) {
36283 options.data = form;
36284 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36285 options.transformRequest = xos.transformRequest;
36286 }
36287 $http(options)
36288 .success(function(data, status, headers, config) {
36289 deferred.resolve(data);
36290 if (parameters.$cache !== undefined) {
36291 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36292 }
36293 })
36294 .error(function(data, status, headers, config) {
36295 deferred.reject({
36296 status: status,
36297 headers: headers,
36298 config: config,
36299 body: data
36300 });
36301 });
36302
36303 return deferred.promise;
36304 };
36305 /**
36306 *
36307 * @method
36308 * @name xos#Tenant_Root_Privilege_Detail_GET
36309 * @param {string} pk -
36310 *
36311 */
36312 xos.prototype.Tenant_Root_Privilege_Detail_GET = function(parameters) {
36313 if (parameters === undefined) {
36314 parameters = {};
36315 }
36316 var deferred = $q.defer();
36317
36318 var domain = this.domain;
36319 var path = '/xos/tenantrootprivileges/{pk}/';
36320
36321 var body;
36322 var queryParameters = {};
36323 var headers = {};
36324 var form = {};
36325
36326 path = path.replace('{pk}', parameters['pk']);
36327
36328 if (parameters['pk'] === undefined) {
36329 deferred.reject(new Error('Missing required path parameter: pk'));
36330 return deferred.promise;
36331 }
36332
36333 if (parameters.$queryParameters) {
36334 Object.keys(parameters.$queryParameters)
36335 .forEach(function(parameterName) {
36336 var parameter = parameters.$queryParameters[parameterName];
36337 queryParameters[parameterName] = parameter;
36338 });
36339 }
36340
36341 var url = domain + path;
36342 var cached = parameters.$cache && parameters.$cache.get(url);
36343 if (cached !== undefined && parameters.$refresh !== true) {
36344 deferred.resolve(cached);
36345 return deferred.promise;
36346 }
36347 var options = {
36348 timeout: parameters.$timeout,
36349 method: 'GET',
36350 url: url,
36351 params: queryParameters,
36352 data: body,
36353 headers: headers
36354 };
36355 if (Object.keys(form).length > 0) {
36356 options.data = form;
36357 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36358 options.transformRequest = xos.transformRequest;
36359 }
36360 $http(options)
36361 .success(function(data, status, headers, config) {
36362 deferred.resolve(data);
36363 if (parameters.$cache !== undefined) {
36364 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36365 }
36366 })
36367 .error(function(data, status, headers, config) {
36368 deferred.reject({
36369 status: status,
36370 headers: headers,
36371 config: config,
36372 body: data
36373 });
36374 });
36375
36376 return deferred.promise;
36377 };
36378 /**
36379 *
36380 * @method
36381 * @name xos#Tenant_Root_Privilege_Detail_PUT
36382 * @param {string} pk -
36383 * @param {string} enacted -
36384 * @param {string} policed -
36385 * @param {string} backend_register -
36386 * @param {string} backend_status -
36387 * @param {boolean} deleted -
36388 * @param {boolean} write_protect -
36389 * @param {boolean} lazy_blocked -
36390 * @param {boolean} no_sync -
36391 * @param {string} user -
36392 * @param {string} tenant_root -
36393 * @param {string} role -
36394 *
36395 */
36396 xos.prototype.Tenant_Root_Privilege_Detail_PUT = function(parameters) {
36397 if (parameters === undefined) {
36398 parameters = {};
36399 }
36400 var deferred = $q.defer();
36401
36402 var domain = this.domain;
36403 var path = '/xos/tenantrootprivileges/{pk}/';
36404
36405 var body;
36406 var queryParameters = {};
36407 var headers = {};
36408 var form = {};
36409
36410 path = path.replace('{pk}', parameters['pk']);
36411
36412 if (parameters['pk'] === undefined) {
36413 deferred.reject(new Error('Missing required path parameter: pk'));
36414 return deferred.promise;
36415 }
36416
36417 if (parameters['enacted'] !== undefined) {
36418 form['enacted'] = parameters['enacted'];
36419 }
36420
36421 if (parameters['policed'] !== undefined) {
36422 form['policed'] = parameters['policed'];
36423 }
36424
36425 if (parameters['backend_register'] !== undefined) {
36426 form['backend_register'] = parameters['backend_register'];
36427 }
36428
36429 if (parameters['backend_status'] !== undefined) {
36430 form['backend_status'] = parameters['backend_status'];
36431 }
36432
36433 if (parameters['backend_status'] === undefined) {
36434 deferred.reject(new Error('Missing required form parameter: backend_status'));
36435 return deferred.promise;
36436 }
36437
36438 if (parameters['deleted'] !== undefined) {
36439 form['deleted'] = parameters['deleted'];
36440 }
36441
36442 if (parameters['write_protect'] !== undefined) {
36443 form['write_protect'] = parameters['write_protect'];
36444 }
36445
36446 if (parameters['lazy_blocked'] !== undefined) {
36447 form['lazy_blocked'] = parameters['lazy_blocked'];
36448 }
36449
36450 if (parameters['no_sync'] !== undefined) {
36451 form['no_sync'] = parameters['no_sync'];
36452 }
36453
36454 if (parameters['user'] !== undefined) {
36455 form['user'] = parameters['user'];
36456 }
36457
36458 if (parameters['user'] === undefined) {
36459 deferred.reject(new Error('Missing required form parameter: user'));
36460 return deferred.promise;
36461 }
36462
36463 if (parameters['tenant_root'] !== undefined) {
36464 form['tenant_root'] = parameters['tenant_root'];
36465 }
36466
36467 if (parameters['tenant_root'] === undefined) {
36468 deferred.reject(new Error('Missing required form parameter: tenant_root'));
36469 return deferred.promise;
36470 }
36471
36472 if (parameters['role'] !== undefined) {
36473 form['role'] = parameters['role'];
36474 }
36475
36476 if (parameters['role'] === undefined) {
36477 deferred.reject(new Error('Missing required form parameter: role'));
36478 return deferred.promise;
36479 }
36480
36481 if (parameters.$queryParameters) {
36482 Object.keys(parameters.$queryParameters)
36483 .forEach(function(parameterName) {
36484 var parameter = parameters.$queryParameters[parameterName];
36485 queryParameters[parameterName] = parameter;
36486 });
36487 }
36488
36489 var url = domain + path;
36490 var options = {
36491 timeout: parameters.$timeout,
36492 method: 'PUT',
36493 url: url,
36494 params: queryParameters,
36495 data: body,
36496 headers: headers
36497 };
36498 if (Object.keys(form).length > 0) {
36499 options.data = form;
36500 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36501 options.transformRequest = xos.transformRequest;
36502 }
36503 $http(options)
36504 .success(function(data, status, headers, config) {
36505 deferred.resolve(data);
36506 if (parameters.$cache !== undefined) {
36507 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36508 }
36509 })
36510 .error(function(data, status, headers, config) {
36511 deferred.reject({
36512 status: status,
36513 headers: headers,
36514 config: config,
36515 body: data
36516 });
36517 });
36518
36519 return deferred.promise;
36520 };
36521 /**
36522 *
36523 * @method
36524 * @name xos#Tenant_Root_Privilege_Detail_PATCH
36525 * @param {string} pk -
36526 * @param {string} enacted -
36527 * @param {string} policed -
36528 * @param {string} backend_register -
36529 * @param {string} backend_status -
36530 * @param {boolean} deleted -
36531 * @param {boolean} write_protect -
36532 * @param {boolean} lazy_blocked -
36533 * @param {boolean} no_sync -
36534 * @param {string} user -
36535 * @param {string} tenant_root -
36536 * @param {string} role -
36537 *
36538 */
36539 xos.prototype.Tenant_Root_Privilege_Detail_PATCH = function(parameters) {
36540 if (parameters === undefined) {
36541 parameters = {};
36542 }
36543 var deferred = $q.defer();
36544
36545 var domain = this.domain;
36546 var path = '/xos/tenantrootprivileges/{pk}/';
36547
36548 var body;
36549 var queryParameters = {};
36550 var headers = {};
36551 var form = {};
36552
36553 path = path.replace('{pk}', parameters['pk']);
36554
36555 if (parameters['pk'] === undefined) {
36556 deferred.reject(new Error('Missing required path parameter: pk'));
36557 return deferred.promise;
36558 }
36559
36560 if (parameters['enacted'] !== undefined) {
36561 form['enacted'] = parameters['enacted'];
36562 }
36563
36564 if (parameters['policed'] !== undefined) {
36565 form['policed'] = parameters['policed'];
36566 }
36567
36568 if (parameters['backend_register'] !== undefined) {
36569 form['backend_register'] = parameters['backend_register'];
36570 }
36571
36572 if (parameters['backend_status'] !== undefined) {
36573 form['backend_status'] = parameters['backend_status'];
36574 }
36575
36576 if (parameters['deleted'] !== undefined) {
36577 form['deleted'] = parameters['deleted'];
36578 }
36579
36580 if (parameters['write_protect'] !== undefined) {
36581 form['write_protect'] = parameters['write_protect'];
36582 }
36583
36584 if (parameters['lazy_blocked'] !== undefined) {
36585 form['lazy_blocked'] = parameters['lazy_blocked'];
36586 }
36587
36588 if (parameters['no_sync'] !== undefined) {
36589 form['no_sync'] = parameters['no_sync'];
36590 }
36591
36592 if (parameters['user'] !== undefined) {
36593 form['user'] = parameters['user'];
36594 }
36595
36596 if (parameters['tenant_root'] !== undefined) {
36597 form['tenant_root'] = parameters['tenant_root'];
36598 }
36599
36600 if (parameters['role'] !== undefined) {
36601 form['role'] = parameters['role'];
36602 }
36603
36604 if (parameters.$queryParameters) {
36605 Object.keys(parameters.$queryParameters)
36606 .forEach(function(parameterName) {
36607 var parameter = parameters.$queryParameters[parameterName];
36608 queryParameters[parameterName] = parameter;
36609 });
36610 }
36611
36612 var url = domain + path;
36613 var options = {
36614 timeout: parameters.$timeout,
36615 method: 'PATCH',
36616 url: url,
36617 params: queryParameters,
36618 data: body,
36619 headers: headers
36620 };
36621 if (Object.keys(form).length > 0) {
36622 options.data = form;
36623 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36624 options.transformRequest = xos.transformRequest;
36625 }
36626 $http(options)
36627 .success(function(data, status, headers, config) {
36628 deferred.resolve(data);
36629 if (parameters.$cache !== undefined) {
36630 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36631 }
36632 })
36633 .error(function(data, status, headers, config) {
36634 deferred.reject({
36635 status: status,
36636 headers: headers,
36637 config: config,
36638 body: data
36639 });
36640 });
36641
36642 return deferred.promise;
36643 };
36644 /**
36645 *
36646 * @method
36647 * @name xos#Tenant_Root_Privilege_Detail_DELETE
36648 * @param {string} pk -
36649 *
36650 */
36651 xos.prototype.Tenant_Root_Privilege_Detail_DELETE = function(parameters) {
36652 if (parameters === undefined) {
36653 parameters = {};
36654 }
36655 var deferred = $q.defer();
36656
36657 var domain = this.domain;
36658 var path = '/xos/tenantrootprivileges/{pk}/';
36659
36660 var body;
36661 var queryParameters = {};
36662 var headers = {};
36663 var form = {};
36664
36665 path = path.replace('{pk}', parameters['pk']);
36666
36667 if (parameters['pk'] === undefined) {
36668 deferred.reject(new Error('Missing required path parameter: pk'));
36669 return deferred.promise;
36670 }
36671
36672 if (parameters.$queryParameters) {
36673 Object.keys(parameters.$queryParameters)
36674 .forEach(function(parameterName) {
36675 var parameter = parameters.$queryParameters[parameterName];
36676 queryParameters[parameterName] = parameter;
36677 });
36678 }
36679
36680 var url = domain + path;
36681 var options = {
36682 timeout: parameters.$timeout,
36683 method: 'DELETE',
36684 url: url,
36685 params: queryParameters,
36686 data: body,
36687 headers: headers
36688 };
36689 if (Object.keys(form).length > 0) {
36690 options.data = form;
36691 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36692 options.transformRequest = xos.transformRequest;
36693 }
36694 $http(options)
36695 .success(function(data, status, headers, config) {
36696 deferred.resolve(data);
36697 if (parameters.$cache !== undefined) {
36698 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36699 }
36700 })
36701 .error(function(data, status, headers, config) {
36702 deferred.reject({
36703 status: status,
36704 headers: headers,
36705 config: config,
36706 body: data
36707 });
36708 });
36709
36710 return deferred.promise;
36711 };
36712 /**
36713 *
36714 * @method
36715 * @name xos#Slice_Tag_List_GET
36716 *
36717 */
36718 xos.prototype.Slice_Tag_List_GET = function(parameters) {
36719 if (parameters === undefined) {
36720 parameters = {};
36721 }
36722 var deferred = $q.defer();
36723
36724 var domain = this.domain;
36725 var path = '/xos/slicetags/';
36726
36727 var body;
36728 var queryParameters = {};
36729 var headers = {};
36730 var form = {};
36731
36732 if (parameters.$queryParameters) {
36733 Object.keys(parameters.$queryParameters)
36734 .forEach(function(parameterName) {
36735 var parameter = parameters.$queryParameters[parameterName];
36736 queryParameters[parameterName] = parameter;
36737 });
36738 }
36739
36740 var url = domain + path;
36741 var cached = parameters.$cache && parameters.$cache.get(url);
36742 if (cached !== undefined && parameters.$refresh !== true) {
36743 deferred.resolve(cached);
36744 return deferred.promise;
36745 }
36746 var options = {
36747 timeout: parameters.$timeout,
36748 method: 'GET',
36749 url: url,
36750 params: queryParameters,
36751 data: body,
36752 headers: headers
36753 };
36754 if (Object.keys(form).length > 0) {
36755 options.data = form;
36756 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36757 options.transformRequest = xos.transformRequest;
36758 }
36759 $http(options)
36760 .success(function(data, status, headers, config) {
36761 deferred.resolve(data);
36762 if (parameters.$cache !== undefined) {
36763 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36764 }
36765 })
36766 .error(function(data, status, headers, config) {
36767 deferred.reject({
36768 status: status,
36769 headers: headers,
36770 config: config,
36771 body: data
36772 });
36773 });
36774
36775 return deferred.promise;
36776 };
36777 /**
36778 *
36779 * @method
36780 * @name xos#Slice_Tag_List_POST
36781 * @param {string} enacted -
36782 * @param {string} policed -
36783 * @param {string} backend_register -
36784 * @param {string} backend_status -
36785 * @param {boolean} deleted -
36786 * @param {boolean} write_protect -
36787 * @param {boolean} lazy_blocked -
36788 * @param {boolean} no_sync -
36789 * @param {string} slice -
36790 * @param {choice} name - The name of this tag
36791 * @param {string} value - The value of this tag
36792 *
36793 */
36794 xos.prototype.Slice_Tag_List_POST = function(parameters) {
36795 if (parameters === undefined) {
36796 parameters = {};
36797 }
36798 var deferred = $q.defer();
36799
36800 var domain = this.domain;
36801 var path = '/xos/slicetags/';
36802
36803 var body;
36804 var queryParameters = {};
36805 var headers = {};
36806 var form = {};
36807
36808 if (parameters['enacted'] !== undefined) {
36809 form['enacted'] = parameters['enacted'];
36810 }
36811
36812 if (parameters['policed'] !== undefined) {
36813 form['policed'] = parameters['policed'];
36814 }
36815
36816 if (parameters['backend_register'] !== undefined) {
36817 form['backend_register'] = parameters['backend_register'];
36818 }
36819
36820 if (parameters['backend_status'] !== undefined) {
36821 form['backend_status'] = parameters['backend_status'];
36822 }
36823
36824 if (parameters['backend_status'] === undefined) {
36825 deferred.reject(new Error('Missing required form parameter: backend_status'));
36826 return deferred.promise;
36827 }
36828
36829 if (parameters['deleted'] !== undefined) {
36830 form['deleted'] = parameters['deleted'];
36831 }
36832
36833 if (parameters['write_protect'] !== undefined) {
36834 form['write_protect'] = parameters['write_protect'];
36835 }
36836
36837 if (parameters['lazy_blocked'] !== undefined) {
36838 form['lazy_blocked'] = parameters['lazy_blocked'];
36839 }
36840
36841 if (parameters['no_sync'] !== undefined) {
36842 form['no_sync'] = parameters['no_sync'];
36843 }
36844
36845 if (parameters['slice'] !== undefined) {
36846 form['slice'] = parameters['slice'];
36847 }
36848
36849 if (parameters['slice'] === undefined) {
36850 deferred.reject(new Error('Missing required form parameter: slice'));
36851 return deferred.promise;
36852 }
36853
36854 if (parameters['name'] !== undefined) {
36855 form['name'] = parameters['name'];
36856 }
36857
36858 if (parameters['name'] === undefined) {
36859 deferred.reject(new Error('Missing required form parameter: name'));
36860 return deferred.promise;
36861 }
36862
36863 if (parameters['value'] !== undefined) {
36864 form['value'] = parameters['value'];
36865 }
36866
36867 if (parameters['value'] === undefined) {
36868 deferred.reject(new Error('Missing required form parameter: value'));
36869 return deferred.promise;
36870 }
36871
36872 if (parameters.$queryParameters) {
36873 Object.keys(parameters.$queryParameters)
36874 .forEach(function(parameterName) {
36875 var parameter = parameters.$queryParameters[parameterName];
36876 queryParameters[parameterName] = parameter;
36877 });
36878 }
36879
36880 var url = domain + path;
36881 var options = {
36882 timeout: parameters.$timeout,
36883 method: 'POST',
36884 url: url,
36885 params: queryParameters,
36886 data: body,
36887 headers: headers
36888 };
36889 if (Object.keys(form).length > 0) {
36890 options.data = form;
36891 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36892 options.transformRequest = xos.transformRequest;
36893 }
36894 $http(options)
36895 .success(function(data, status, headers, config) {
36896 deferred.resolve(data);
36897 if (parameters.$cache !== undefined) {
36898 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36899 }
36900 })
36901 .error(function(data, status, headers, config) {
36902 deferred.reject({
36903 status: status,
36904 headers: headers,
36905 config: config,
36906 body: data
36907 });
36908 });
36909
36910 return deferred.promise;
36911 };
36912 /**
36913 *
36914 * @method
36915 * @name xos#Slice_Tag_Detail_GET
36916 * @param {string} pk -
36917 *
36918 */
36919 xos.prototype.Slice_Tag_Detail_GET = function(parameters) {
36920 if (parameters === undefined) {
36921 parameters = {};
36922 }
36923 var deferred = $q.defer();
36924
36925 var domain = this.domain;
36926 var path = '/xos/slicetags/{pk}/';
36927
36928 var body;
36929 var queryParameters = {};
36930 var headers = {};
36931 var form = {};
36932
36933 path = path.replace('{pk}', parameters['pk']);
36934
36935 if (parameters['pk'] === undefined) {
36936 deferred.reject(new Error('Missing required path parameter: pk'));
36937 return deferred.promise;
36938 }
36939
36940 if (parameters.$queryParameters) {
36941 Object.keys(parameters.$queryParameters)
36942 .forEach(function(parameterName) {
36943 var parameter = parameters.$queryParameters[parameterName];
36944 queryParameters[parameterName] = parameter;
36945 });
36946 }
36947
36948 var url = domain + path;
36949 var cached = parameters.$cache && parameters.$cache.get(url);
36950 if (cached !== undefined && parameters.$refresh !== true) {
36951 deferred.resolve(cached);
36952 return deferred.promise;
36953 }
36954 var options = {
36955 timeout: parameters.$timeout,
36956 method: 'GET',
36957 url: url,
36958 params: queryParameters,
36959 data: body,
36960 headers: headers
36961 };
36962 if (Object.keys(form).length > 0) {
36963 options.data = form;
36964 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
36965 options.transformRequest = xos.transformRequest;
36966 }
36967 $http(options)
36968 .success(function(data, status, headers, config) {
36969 deferred.resolve(data);
36970 if (parameters.$cache !== undefined) {
36971 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
36972 }
36973 })
36974 .error(function(data, status, headers, config) {
36975 deferred.reject({
36976 status: status,
36977 headers: headers,
36978 config: config,
36979 body: data
36980 });
36981 });
36982
36983 return deferred.promise;
36984 };
36985 /**
36986 *
36987 * @method
36988 * @name xos#Slice_Tag_Detail_PUT
36989 * @param {string} pk -
36990 * @param {string} enacted -
36991 * @param {string} policed -
36992 * @param {string} backend_register -
36993 * @param {string} backend_status -
36994 * @param {boolean} deleted -
36995 * @param {boolean} write_protect -
36996 * @param {boolean} lazy_blocked -
36997 * @param {boolean} no_sync -
36998 * @param {string} slice -
36999 * @param {choice} name - The name of this tag
37000 * @param {string} value - The value of this tag
37001 *
37002 */
37003 xos.prototype.Slice_Tag_Detail_PUT = function(parameters) {
37004 if (parameters === undefined) {
37005 parameters = {};
37006 }
37007 var deferred = $q.defer();
37008
37009 var domain = this.domain;
37010 var path = '/xos/slicetags/{pk}/';
37011
37012 var body;
37013 var queryParameters = {};
37014 var headers = {};
37015 var form = {};
37016
37017 path = path.replace('{pk}', parameters['pk']);
37018
37019 if (parameters['pk'] === undefined) {
37020 deferred.reject(new Error('Missing required path parameter: pk'));
37021 return deferred.promise;
37022 }
37023
37024 if (parameters['enacted'] !== undefined) {
37025 form['enacted'] = parameters['enacted'];
37026 }
37027
37028 if (parameters['policed'] !== undefined) {
37029 form['policed'] = parameters['policed'];
37030 }
37031
37032 if (parameters['backend_register'] !== undefined) {
37033 form['backend_register'] = parameters['backend_register'];
37034 }
37035
37036 if (parameters['backend_status'] !== undefined) {
37037 form['backend_status'] = parameters['backend_status'];
37038 }
37039
37040 if (parameters['backend_status'] === undefined) {
37041 deferred.reject(new Error('Missing required form parameter: backend_status'));
37042 return deferred.promise;
37043 }
37044
37045 if (parameters['deleted'] !== undefined) {
37046 form['deleted'] = parameters['deleted'];
37047 }
37048
37049 if (parameters['write_protect'] !== undefined) {
37050 form['write_protect'] = parameters['write_protect'];
37051 }
37052
37053 if (parameters['lazy_blocked'] !== undefined) {
37054 form['lazy_blocked'] = parameters['lazy_blocked'];
37055 }
37056
37057 if (parameters['no_sync'] !== undefined) {
37058 form['no_sync'] = parameters['no_sync'];
37059 }
37060
37061 if (parameters['slice'] !== undefined) {
37062 form['slice'] = parameters['slice'];
37063 }
37064
37065 if (parameters['slice'] === undefined) {
37066 deferred.reject(new Error('Missing required form parameter: slice'));
37067 return deferred.promise;
37068 }
37069
37070 if (parameters['name'] !== undefined) {
37071 form['name'] = parameters['name'];
37072 }
37073
37074 if (parameters['name'] === undefined) {
37075 deferred.reject(new Error('Missing required form parameter: name'));
37076 return deferred.promise;
37077 }
37078
37079 if (parameters['value'] !== undefined) {
37080 form['value'] = parameters['value'];
37081 }
37082
37083 if (parameters['value'] === undefined) {
37084 deferred.reject(new Error('Missing required form parameter: value'));
37085 return deferred.promise;
37086 }
37087
37088 if (parameters.$queryParameters) {
37089 Object.keys(parameters.$queryParameters)
37090 .forEach(function(parameterName) {
37091 var parameter = parameters.$queryParameters[parameterName];
37092 queryParameters[parameterName] = parameter;
37093 });
37094 }
37095
37096 var url = domain + path;
37097 var options = {
37098 timeout: parameters.$timeout,
37099 method: 'PUT',
37100 url: url,
37101 params: queryParameters,
37102 data: body,
37103 headers: headers
37104 };
37105 if (Object.keys(form).length > 0) {
37106 options.data = form;
37107 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37108 options.transformRequest = xos.transformRequest;
37109 }
37110 $http(options)
37111 .success(function(data, status, headers, config) {
37112 deferred.resolve(data);
37113 if (parameters.$cache !== undefined) {
37114 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37115 }
37116 })
37117 .error(function(data, status, headers, config) {
37118 deferred.reject({
37119 status: status,
37120 headers: headers,
37121 config: config,
37122 body: data
37123 });
37124 });
37125
37126 return deferred.promise;
37127 };
37128 /**
37129 *
37130 * @method
37131 * @name xos#Slice_Tag_Detail_PATCH
37132 * @param {string} pk -
37133 * @param {string} enacted -
37134 * @param {string} policed -
37135 * @param {string} backend_register -
37136 * @param {string} backend_status -
37137 * @param {boolean} deleted -
37138 * @param {boolean} write_protect -
37139 * @param {boolean} lazy_blocked -
37140 * @param {boolean} no_sync -
37141 * @param {string} slice -
37142 * @param {choice} name - The name of this tag
37143 * @param {string} value - The value of this tag
37144 *
37145 */
37146 xos.prototype.Slice_Tag_Detail_PATCH = function(parameters) {
37147 if (parameters === undefined) {
37148 parameters = {};
37149 }
37150 var deferred = $q.defer();
37151
37152 var domain = this.domain;
37153 var path = '/xos/slicetags/{pk}/';
37154
37155 var body;
37156 var queryParameters = {};
37157 var headers = {};
37158 var form = {};
37159
37160 path = path.replace('{pk}', parameters['pk']);
37161
37162 if (parameters['pk'] === undefined) {
37163 deferred.reject(new Error('Missing required path parameter: pk'));
37164 return deferred.promise;
37165 }
37166
37167 if (parameters['enacted'] !== undefined) {
37168 form['enacted'] = parameters['enacted'];
37169 }
37170
37171 if (parameters['policed'] !== undefined) {
37172 form['policed'] = parameters['policed'];
37173 }
37174
37175 if (parameters['backend_register'] !== undefined) {
37176 form['backend_register'] = parameters['backend_register'];
37177 }
37178
37179 if (parameters['backend_status'] !== undefined) {
37180 form['backend_status'] = parameters['backend_status'];
37181 }
37182
37183 if (parameters['deleted'] !== undefined) {
37184 form['deleted'] = parameters['deleted'];
37185 }
37186
37187 if (parameters['write_protect'] !== undefined) {
37188 form['write_protect'] = parameters['write_protect'];
37189 }
37190
37191 if (parameters['lazy_blocked'] !== undefined) {
37192 form['lazy_blocked'] = parameters['lazy_blocked'];
37193 }
37194
37195 if (parameters['no_sync'] !== undefined) {
37196 form['no_sync'] = parameters['no_sync'];
37197 }
37198
37199 if (parameters['slice'] !== undefined) {
37200 form['slice'] = parameters['slice'];
37201 }
37202
37203 if (parameters['name'] !== undefined) {
37204 form['name'] = parameters['name'];
37205 }
37206
37207 if (parameters['value'] !== undefined) {
37208 form['value'] = parameters['value'];
37209 }
37210
37211 if (parameters.$queryParameters) {
37212 Object.keys(parameters.$queryParameters)
37213 .forEach(function(parameterName) {
37214 var parameter = parameters.$queryParameters[parameterName];
37215 queryParameters[parameterName] = parameter;
37216 });
37217 }
37218
37219 var url = domain + path;
37220 var options = {
37221 timeout: parameters.$timeout,
37222 method: 'PATCH',
37223 url: url,
37224 params: queryParameters,
37225 data: body,
37226 headers: headers
37227 };
37228 if (Object.keys(form).length > 0) {
37229 options.data = form;
37230 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37231 options.transformRequest = xos.transformRequest;
37232 }
37233 $http(options)
37234 .success(function(data, status, headers, config) {
37235 deferred.resolve(data);
37236 if (parameters.$cache !== undefined) {
37237 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37238 }
37239 })
37240 .error(function(data, status, headers, config) {
37241 deferred.reject({
37242 status: status,
37243 headers: headers,
37244 config: config,
37245 body: data
37246 });
37247 });
37248
37249 return deferred.promise;
37250 };
37251 /**
37252 *
37253 * @method
37254 * @name xos#Slice_Tag_Detail_DELETE
37255 * @param {string} pk -
37256 *
37257 */
37258 xos.prototype.Slice_Tag_Detail_DELETE = function(parameters) {
37259 if (parameters === undefined) {
37260 parameters = {};
37261 }
37262 var deferred = $q.defer();
37263
37264 var domain = this.domain;
37265 var path = '/xos/slicetags/{pk}/';
37266
37267 var body;
37268 var queryParameters = {};
37269 var headers = {};
37270 var form = {};
37271
37272 path = path.replace('{pk}', parameters['pk']);
37273
37274 if (parameters['pk'] === undefined) {
37275 deferred.reject(new Error('Missing required path parameter: pk'));
37276 return deferred.promise;
37277 }
37278
37279 if (parameters.$queryParameters) {
37280 Object.keys(parameters.$queryParameters)
37281 .forEach(function(parameterName) {
37282 var parameter = parameters.$queryParameters[parameterName];
37283 queryParameters[parameterName] = parameter;
37284 });
37285 }
37286
37287 var url = domain + path;
37288 var options = {
37289 timeout: parameters.$timeout,
37290 method: 'DELETE',
37291 url: url,
37292 params: queryParameters,
37293 data: body,
37294 headers: headers
37295 };
37296 if (Object.keys(form).length > 0) {
37297 options.data = form;
37298 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37299 options.transformRequest = xos.transformRequest;
37300 }
37301 $http(options)
37302 .success(function(data, status, headers, config) {
37303 deferred.resolve(data);
37304 if (parameters.$cache !== undefined) {
37305 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37306 }
37307 })
37308 .error(function(data, status, headers, config) {
37309 deferred.reject({
37310 status: status,
37311 headers: headers,
37312 config: config,
37313 body: data
37314 });
37315 });
37316
37317 return deferred.promise;
37318 };
37319 /**
37320 *
37321 * @method
37322 * @name xos#Coarse_Tenant_List_GET
37323 *
37324 */
37325 xos.prototype.Coarse_Tenant_List_GET = function(parameters) {
37326 if (parameters === undefined) {
37327 parameters = {};
37328 }
37329 var deferred = $q.defer();
37330
37331 var domain = this.domain;
37332 var path = '/xos/coarsetenants/';
37333
37334 var body;
37335 var queryParameters = {};
37336 var headers = {};
37337 var form = {};
37338
37339 if (parameters.$queryParameters) {
37340 Object.keys(parameters.$queryParameters)
37341 .forEach(function(parameterName) {
37342 var parameter = parameters.$queryParameters[parameterName];
37343 queryParameters[parameterName] = parameter;
37344 });
37345 }
37346
37347 var url = domain + path;
37348 var cached = parameters.$cache && parameters.$cache.get(url);
37349 if (cached !== undefined && parameters.$refresh !== true) {
37350 deferred.resolve(cached);
37351 return deferred.promise;
37352 }
37353 var options = {
37354 timeout: parameters.$timeout,
37355 method: 'GET',
37356 url: url,
37357 params: queryParameters,
37358 data: body,
37359 headers: headers
37360 };
37361 if (Object.keys(form).length > 0) {
37362 options.data = form;
37363 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37364 options.transformRequest = xos.transformRequest;
37365 }
37366 $http(options)
37367 .success(function(data, status, headers, config) {
37368 deferred.resolve(data);
37369 if (parameters.$cache !== undefined) {
37370 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37371 }
37372 })
37373 .error(function(data, status, headers, config) {
37374 deferred.reject({
37375 status: status,
37376 headers: headers,
37377 config: config,
37378 body: data
37379 });
37380 });
37381
37382 return deferred.promise;
37383 };
37384 /**
37385 *
37386 * @method
37387 * @name xos#Coarse_Tenant_List_POST
37388 * @param {string} enacted -
37389 * @param {string} policed -
37390 * @param {string} backend_register -
37391 * @param {string} backend_status -
37392 * @param {boolean} deleted -
37393 * @param {boolean} write_protect -
37394 * @param {boolean} lazy_blocked -
37395 * @param {boolean} no_sync -
37396 * @param {string} kind -
37397 * @param {string} provider_service -
37398 * @param {string} subscriber_service -
37399 * @param {string} subscriber_tenant -
37400 * @param {string} subscriber_user -
37401 * @param {string} subscriber_root -
37402 * @param {string} service_specific_id -
37403 * @param {string} service_specific_attribute -
37404 * @param {choice} connect_method -
37405 *
37406 */
37407 xos.prototype.Coarse_Tenant_List_POST = function(parameters) {
37408 if (parameters === undefined) {
37409 parameters = {};
37410 }
37411 var deferred = $q.defer();
37412
37413 var domain = this.domain;
37414 var path = '/xos/coarsetenants/';
37415
37416 var body;
37417 var queryParameters = {};
37418 var headers = {};
37419 var form = {};
37420
37421 if (parameters['enacted'] !== undefined) {
37422 form['enacted'] = parameters['enacted'];
37423 }
37424
37425 if (parameters['policed'] !== undefined) {
37426 form['policed'] = parameters['policed'];
37427 }
37428
37429 if (parameters['backend_register'] !== undefined) {
37430 form['backend_register'] = parameters['backend_register'];
37431 }
37432
37433 if (parameters['backend_status'] !== undefined) {
37434 form['backend_status'] = parameters['backend_status'];
37435 }
37436
37437 if (parameters['backend_status'] === undefined) {
37438 deferred.reject(new Error('Missing required form parameter: backend_status'));
37439 return deferred.promise;
37440 }
37441
37442 if (parameters['deleted'] !== undefined) {
37443 form['deleted'] = parameters['deleted'];
37444 }
37445
37446 if (parameters['write_protect'] !== undefined) {
37447 form['write_protect'] = parameters['write_protect'];
37448 }
37449
37450 if (parameters['lazy_blocked'] !== undefined) {
37451 form['lazy_blocked'] = parameters['lazy_blocked'];
37452 }
37453
37454 if (parameters['no_sync'] !== undefined) {
37455 form['no_sync'] = parameters['no_sync'];
37456 }
37457
37458 if (parameters['kind'] !== undefined) {
37459 form['kind'] = parameters['kind'];
37460 }
37461
37462 if (parameters['kind'] === undefined) {
37463 deferred.reject(new Error('Missing required form parameter: kind'));
37464 return deferred.promise;
37465 }
37466
37467 if (parameters['provider_service'] !== undefined) {
37468 form['provider_service'] = parameters['provider_service'];
37469 }
37470
37471 if (parameters['provider_service'] === undefined) {
37472 deferred.reject(new Error('Missing required form parameter: provider_service'));
37473 return deferred.promise;
37474 }
37475
37476 if (parameters['subscriber_service'] !== undefined) {
37477 form['subscriber_service'] = parameters['subscriber_service'];
37478 }
37479
37480 if (parameters['subscriber_tenant'] !== undefined) {
37481 form['subscriber_tenant'] = parameters['subscriber_tenant'];
37482 }
37483
37484 if (parameters['subscriber_user'] !== undefined) {
37485 form['subscriber_user'] = parameters['subscriber_user'];
37486 }
37487
37488 if (parameters['subscriber_root'] !== undefined) {
37489 form['subscriber_root'] = parameters['subscriber_root'];
37490 }
37491
37492 if (parameters['service_specific_id'] !== undefined) {
37493 form['service_specific_id'] = parameters['service_specific_id'];
37494 }
37495
37496 if (parameters['service_specific_attribute'] !== undefined) {
37497 form['service_specific_attribute'] = parameters['service_specific_attribute'];
37498 }
37499
37500 if (parameters['connect_method'] !== undefined) {
37501 form['connect_method'] = parameters['connect_method'];
37502 }
37503
37504 if (parameters['connect_method'] === undefined) {
37505 deferred.reject(new Error('Missing required form parameter: connect_method'));
37506 return deferred.promise;
37507 }
37508
37509 if (parameters.$queryParameters) {
37510 Object.keys(parameters.$queryParameters)
37511 .forEach(function(parameterName) {
37512 var parameter = parameters.$queryParameters[parameterName];
37513 queryParameters[parameterName] = parameter;
37514 });
37515 }
37516
37517 var url = domain + path;
37518 var options = {
37519 timeout: parameters.$timeout,
37520 method: 'POST',
37521 url: url,
37522 params: queryParameters,
37523 data: body,
37524 headers: headers
37525 };
37526 if (Object.keys(form).length > 0) {
37527 options.data = form;
37528 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37529 options.transformRequest = xos.transformRequest;
37530 }
37531 $http(options)
37532 .success(function(data, status, headers, config) {
37533 deferred.resolve(data);
37534 if (parameters.$cache !== undefined) {
37535 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37536 }
37537 })
37538 .error(function(data, status, headers, config) {
37539 deferred.reject({
37540 status: status,
37541 headers: headers,
37542 config: config,
37543 body: data
37544 });
37545 });
37546
37547 return deferred.promise;
37548 };
37549 /**
37550 *
37551 * @method
37552 * @name xos#Coarse_Tenant_Detail_GET
37553 * @param {string} pk -
37554 *
37555 */
37556 xos.prototype.Coarse_Tenant_Detail_GET = function(parameters) {
37557 if (parameters === undefined) {
37558 parameters = {};
37559 }
37560 var deferred = $q.defer();
37561
37562 var domain = this.domain;
37563 var path = '/xos/coarsetenants/{pk}/';
37564
37565 var body;
37566 var queryParameters = {};
37567 var headers = {};
37568 var form = {};
37569
37570 path = path.replace('{pk}', parameters['pk']);
37571
37572 if (parameters['pk'] === undefined) {
37573 deferred.reject(new Error('Missing required path parameter: pk'));
37574 return deferred.promise;
37575 }
37576
37577 if (parameters.$queryParameters) {
37578 Object.keys(parameters.$queryParameters)
37579 .forEach(function(parameterName) {
37580 var parameter = parameters.$queryParameters[parameterName];
37581 queryParameters[parameterName] = parameter;
37582 });
37583 }
37584
37585 var url = domain + path;
37586 var cached = parameters.$cache && parameters.$cache.get(url);
37587 if (cached !== undefined && parameters.$refresh !== true) {
37588 deferred.resolve(cached);
37589 return deferred.promise;
37590 }
37591 var options = {
37592 timeout: parameters.$timeout,
37593 method: 'GET',
37594 url: url,
37595 params: queryParameters,
37596 data: body,
37597 headers: headers
37598 };
37599 if (Object.keys(form).length > 0) {
37600 options.data = form;
37601 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37602 options.transformRequest = xos.transformRequest;
37603 }
37604 $http(options)
37605 .success(function(data, status, headers, config) {
37606 deferred.resolve(data);
37607 if (parameters.$cache !== undefined) {
37608 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37609 }
37610 })
37611 .error(function(data, status, headers, config) {
37612 deferred.reject({
37613 status: status,
37614 headers: headers,
37615 config: config,
37616 body: data
37617 });
37618 });
37619
37620 return deferred.promise;
37621 };
37622 /**
37623 *
37624 * @method
37625 * @name xos#Coarse_Tenant_Detail_PUT
37626 * @param {string} pk -
37627 * @param {string} enacted -
37628 * @param {string} policed -
37629 * @param {string} backend_register -
37630 * @param {string} backend_status -
37631 * @param {boolean} deleted -
37632 * @param {boolean} write_protect -
37633 * @param {boolean} lazy_blocked -
37634 * @param {boolean} no_sync -
37635 * @param {string} kind -
37636 * @param {string} provider_service -
37637 * @param {string} subscriber_service -
37638 * @param {string} subscriber_tenant -
37639 * @param {string} subscriber_user -
37640 * @param {string} subscriber_root -
37641 * @param {string} service_specific_id -
37642 * @param {string} service_specific_attribute -
37643 * @param {choice} connect_method -
37644 *
37645 */
37646 xos.prototype.Coarse_Tenant_Detail_PUT = function(parameters) {
37647 if (parameters === undefined) {
37648 parameters = {};
37649 }
37650 var deferred = $q.defer();
37651
37652 var domain = this.domain;
37653 var path = '/xos/coarsetenants/{pk}/';
37654
37655 var body;
37656 var queryParameters = {};
37657 var headers = {};
37658 var form = {};
37659
37660 path = path.replace('{pk}', parameters['pk']);
37661
37662 if (parameters['pk'] === undefined) {
37663 deferred.reject(new Error('Missing required path parameter: pk'));
37664 return deferred.promise;
37665 }
37666
37667 if (parameters['enacted'] !== undefined) {
37668 form['enacted'] = parameters['enacted'];
37669 }
37670
37671 if (parameters['policed'] !== undefined) {
37672 form['policed'] = parameters['policed'];
37673 }
37674
37675 if (parameters['backend_register'] !== undefined) {
37676 form['backend_register'] = parameters['backend_register'];
37677 }
37678
37679 if (parameters['backend_status'] !== undefined) {
37680 form['backend_status'] = parameters['backend_status'];
37681 }
37682
37683 if (parameters['backend_status'] === undefined) {
37684 deferred.reject(new Error('Missing required form parameter: backend_status'));
37685 return deferred.promise;
37686 }
37687
37688 if (parameters['deleted'] !== undefined) {
37689 form['deleted'] = parameters['deleted'];
37690 }
37691
37692 if (parameters['write_protect'] !== undefined) {
37693 form['write_protect'] = parameters['write_protect'];
37694 }
37695
37696 if (parameters['lazy_blocked'] !== undefined) {
37697 form['lazy_blocked'] = parameters['lazy_blocked'];
37698 }
37699
37700 if (parameters['no_sync'] !== undefined) {
37701 form['no_sync'] = parameters['no_sync'];
37702 }
37703
37704 if (parameters['kind'] !== undefined) {
37705 form['kind'] = parameters['kind'];
37706 }
37707
37708 if (parameters['kind'] === undefined) {
37709 deferred.reject(new Error('Missing required form parameter: kind'));
37710 return deferred.promise;
37711 }
37712
37713 if (parameters['provider_service'] !== undefined) {
37714 form['provider_service'] = parameters['provider_service'];
37715 }
37716
37717 if (parameters['provider_service'] === undefined) {
37718 deferred.reject(new Error('Missing required form parameter: provider_service'));
37719 return deferred.promise;
37720 }
37721
37722 if (parameters['subscriber_service'] !== undefined) {
37723 form['subscriber_service'] = parameters['subscriber_service'];
37724 }
37725
37726 if (parameters['subscriber_tenant'] !== undefined) {
37727 form['subscriber_tenant'] = parameters['subscriber_tenant'];
37728 }
37729
37730 if (parameters['subscriber_user'] !== undefined) {
37731 form['subscriber_user'] = parameters['subscriber_user'];
37732 }
37733
37734 if (parameters['subscriber_root'] !== undefined) {
37735 form['subscriber_root'] = parameters['subscriber_root'];
37736 }
37737
37738 if (parameters['service_specific_id'] !== undefined) {
37739 form['service_specific_id'] = parameters['service_specific_id'];
37740 }
37741
37742 if (parameters['service_specific_attribute'] !== undefined) {
37743 form['service_specific_attribute'] = parameters['service_specific_attribute'];
37744 }
37745
37746 if (parameters['connect_method'] !== undefined) {
37747 form['connect_method'] = parameters['connect_method'];
37748 }
37749
37750 if (parameters['connect_method'] === undefined) {
37751 deferred.reject(new Error('Missing required form parameter: connect_method'));
37752 return deferred.promise;
37753 }
37754
37755 if (parameters.$queryParameters) {
37756 Object.keys(parameters.$queryParameters)
37757 .forEach(function(parameterName) {
37758 var parameter = parameters.$queryParameters[parameterName];
37759 queryParameters[parameterName] = parameter;
37760 });
37761 }
37762
37763 var url = domain + path;
37764 var options = {
37765 timeout: parameters.$timeout,
37766 method: 'PUT',
37767 url: url,
37768 params: queryParameters,
37769 data: body,
37770 headers: headers
37771 };
37772 if (Object.keys(form).length > 0) {
37773 options.data = form;
37774 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37775 options.transformRequest = xos.transformRequest;
37776 }
37777 $http(options)
37778 .success(function(data, status, headers, config) {
37779 deferred.resolve(data);
37780 if (parameters.$cache !== undefined) {
37781 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37782 }
37783 })
37784 .error(function(data, status, headers, config) {
37785 deferred.reject({
37786 status: status,
37787 headers: headers,
37788 config: config,
37789 body: data
37790 });
37791 });
37792
37793 return deferred.promise;
37794 };
37795 /**
37796 *
37797 * @method
37798 * @name xos#Coarse_Tenant_Detail_PATCH
37799 * @param {string} pk -
37800 * @param {string} enacted -
37801 * @param {string} policed -
37802 * @param {string} backend_register -
37803 * @param {string} backend_status -
37804 * @param {boolean} deleted -
37805 * @param {boolean} write_protect -
37806 * @param {boolean} lazy_blocked -
37807 * @param {boolean} no_sync -
37808 * @param {string} kind -
37809 * @param {string} provider_service -
37810 * @param {string} subscriber_service -
37811 * @param {string} subscriber_tenant -
37812 * @param {string} subscriber_user -
37813 * @param {string} subscriber_root -
37814 * @param {string} service_specific_id -
37815 * @param {string} service_specific_attribute -
37816 * @param {choice} connect_method -
37817 *
37818 */
37819 xos.prototype.Coarse_Tenant_Detail_PATCH = function(parameters) {
37820 if (parameters === undefined) {
37821 parameters = {};
37822 }
37823 var deferred = $q.defer();
37824
37825 var domain = this.domain;
37826 var path = '/xos/coarsetenants/{pk}/';
37827
37828 var body;
37829 var queryParameters = {};
37830 var headers = {};
37831 var form = {};
37832
37833 path = path.replace('{pk}', parameters['pk']);
37834
37835 if (parameters['pk'] === undefined) {
37836 deferred.reject(new Error('Missing required path parameter: pk'));
37837 return deferred.promise;
37838 }
37839
37840 if (parameters['enacted'] !== undefined) {
37841 form['enacted'] = parameters['enacted'];
37842 }
37843
37844 if (parameters['policed'] !== undefined) {
37845 form['policed'] = parameters['policed'];
37846 }
37847
37848 if (parameters['backend_register'] !== undefined) {
37849 form['backend_register'] = parameters['backend_register'];
37850 }
37851
37852 if (parameters['backend_status'] !== undefined) {
37853 form['backend_status'] = parameters['backend_status'];
37854 }
37855
37856 if (parameters['deleted'] !== undefined) {
37857 form['deleted'] = parameters['deleted'];
37858 }
37859
37860 if (parameters['write_protect'] !== undefined) {
37861 form['write_protect'] = parameters['write_protect'];
37862 }
37863
37864 if (parameters['lazy_blocked'] !== undefined) {
37865 form['lazy_blocked'] = parameters['lazy_blocked'];
37866 }
37867
37868 if (parameters['no_sync'] !== undefined) {
37869 form['no_sync'] = parameters['no_sync'];
37870 }
37871
37872 if (parameters['kind'] !== undefined) {
37873 form['kind'] = parameters['kind'];
37874 }
37875
37876 if (parameters['provider_service'] !== undefined) {
37877 form['provider_service'] = parameters['provider_service'];
37878 }
37879
37880 if (parameters['subscriber_service'] !== undefined) {
37881 form['subscriber_service'] = parameters['subscriber_service'];
37882 }
37883
37884 if (parameters['subscriber_tenant'] !== undefined) {
37885 form['subscriber_tenant'] = parameters['subscriber_tenant'];
37886 }
37887
37888 if (parameters['subscriber_user'] !== undefined) {
37889 form['subscriber_user'] = parameters['subscriber_user'];
37890 }
37891
37892 if (parameters['subscriber_root'] !== undefined) {
37893 form['subscriber_root'] = parameters['subscriber_root'];
37894 }
37895
37896 if (parameters['service_specific_id'] !== undefined) {
37897 form['service_specific_id'] = parameters['service_specific_id'];
37898 }
37899
37900 if (parameters['service_specific_attribute'] !== undefined) {
37901 form['service_specific_attribute'] = parameters['service_specific_attribute'];
37902 }
37903
37904 if (parameters['connect_method'] !== undefined) {
37905 form['connect_method'] = parameters['connect_method'];
37906 }
37907
37908 if (parameters.$queryParameters) {
37909 Object.keys(parameters.$queryParameters)
37910 .forEach(function(parameterName) {
37911 var parameter = parameters.$queryParameters[parameterName];
37912 queryParameters[parameterName] = parameter;
37913 });
37914 }
37915
37916 var url = domain + path;
37917 var options = {
37918 timeout: parameters.$timeout,
37919 method: 'PATCH',
37920 url: url,
37921 params: queryParameters,
37922 data: body,
37923 headers: headers
37924 };
37925 if (Object.keys(form).length > 0) {
37926 options.data = form;
37927 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37928 options.transformRequest = xos.transformRequest;
37929 }
37930 $http(options)
37931 .success(function(data, status, headers, config) {
37932 deferred.resolve(data);
37933 if (parameters.$cache !== undefined) {
37934 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
37935 }
37936 })
37937 .error(function(data, status, headers, config) {
37938 deferred.reject({
37939 status: status,
37940 headers: headers,
37941 config: config,
37942 body: data
37943 });
37944 });
37945
37946 return deferred.promise;
37947 };
37948 /**
37949 *
37950 * @method
37951 * @name xos#Coarse_Tenant_Detail_DELETE
37952 * @param {string} pk -
37953 *
37954 */
37955 xos.prototype.Coarse_Tenant_Detail_DELETE = function(parameters) {
37956 if (parameters === undefined) {
37957 parameters = {};
37958 }
37959 var deferred = $q.defer();
37960
37961 var domain = this.domain;
37962 var path = '/xos/coarsetenants/{pk}/';
37963
37964 var body;
37965 var queryParameters = {};
37966 var headers = {};
37967 var form = {};
37968
37969 path = path.replace('{pk}', parameters['pk']);
37970
37971 if (parameters['pk'] === undefined) {
37972 deferred.reject(new Error('Missing required path parameter: pk'));
37973 return deferred.promise;
37974 }
37975
37976 if (parameters.$queryParameters) {
37977 Object.keys(parameters.$queryParameters)
37978 .forEach(function(parameterName) {
37979 var parameter = parameters.$queryParameters[parameterName];
37980 queryParameters[parameterName] = parameter;
37981 });
37982 }
37983
37984 var url = domain + path;
37985 var options = {
37986 timeout: parameters.$timeout,
37987 method: 'DELETE',
37988 url: url,
37989 params: queryParameters,
37990 data: body,
37991 headers: headers
37992 };
37993 if (Object.keys(form).length > 0) {
37994 options.data = form;
37995 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
37996 options.transformRequest = xos.transformRequest;
37997 }
37998 $http(options)
37999 .success(function(data, status, headers, config) {
38000 deferred.resolve(data);
38001 if (parameters.$cache !== undefined) {
38002 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38003 }
38004 })
38005 .error(function(data, status, headers, config) {
38006 deferred.reject({
38007 status: status,
38008 headers: headers,
38009 config: config,
38010 body: data
38011 });
38012 });
38013
38014 return deferred.promise;
38015 };
38016 /**
38017 *
38018 * @method
38019 * @name xos#Router_List_GET
38020 *
38021 */
38022 xos.prototype.Router_List_GET = function(parameters) {
38023 if (parameters === undefined) {
38024 parameters = {};
38025 }
38026 var deferred = $q.defer();
38027
38028 var domain = this.domain;
38029 var path = '/xos/routers/';
38030
38031 var body;
38032 var queryParameters = {};
38033 var headers = {};
38034 var form = {};
38035
38036 if (parameters.$queryParameters) {
38037 Object.keys(parameters.$queryParameters)
38038 .forEach(function(parameterName) {
38039 var parameter = parameters.$queryParameters[parameterName];
38040 queryParameters[parameterName] = parameter;
38041 });
38042 }
38043
38044 var url = domain + path;
38045 var cached = parameters.$cache && parameters.$cache.get(url);
38046 if (cached !== undefined && parameters.$refresh !== true) {
38047 deferred.resolve(cached);
38048 return deferred.promise;
38049 }
38050 var options = {
38051 timeout: parameters.$timeout,
38052 method: 'GET',
38053 url: url,
38054 params: queryParameters,
38055 data: body,
38056 headers: headers
38057 };
38058 if (Object.keys(form).length > 0) {
38059 options.data = form;
38060 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38061 options.transformRequest = xos.transformRequest;
38062 }
38063 $http(options)
38064 .success(function(data, status, headers, config) {
38065 deferred.resolve(data);
38066 if (parameters.$cache !== undefined) {
38067 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38068 }
38069 })
38070 .error(function(data, status, headers, config) {
38071 deferred.reject({
38072 status: status,
38073 headers: headers,
38074 config: config,
38075 body: data
38076 });
38077 });
38078
38079 return deferred.promise;
38080 };
38081 /**
38082 *
38083 * @method
38084 * @name xos#Router_List_POST
38085 * @param {string} enacted -
38086 * @param {string} policed -
38087 * @param {string} backend_register -
38088 * @param {string} backend_status -
38089 * @param {boolean} deleted -
38090 * @param {boolean} write_protect -
38091 * @param {boolean} lazy_blocked -
38092 * @param {boolean} no_sync -
38093 * @param {string} name -
38094 * @param {string} owner -
38095 *
38096 */
38097 xos.prototype.Router_List_POST = function(parameters) {
38098 if (parameters === undefined) {
38099 parameters = {};
38100 }
38101 var deferred = $q.defer();
38102
38103 var domain = this.domain;
38104 var path = '/xos/routers/';
38105
38106 var body;
38107 var queryParameters = {};
38108 var headers = {};
38109 var form = {};
38110
38111 if (parameters['enacted'] !== undefined) {
38112 form['enacted'] = parameters['enacted'];
38113 }
38114
38115 if (parameters['policed'] !== undefined) {
38116 form['policed'] = parameters['policed'];
38117 }
38118
38119 if (parameters['backend_register'] !== undefined) {
38120 form['backend_register'] = parameters['backend_register'];
38121 }
38122
38123 if (parameters['backend_status'] !== undefined) {
38124 form['backend_status'] = parameters['backend_status'];
38125 }
38126
38127 if (parameters['backend_status'] === undefined) {
38128 deferred.reject(new Error('Missing required form parameter: backend_status'));
38129 return deferred.promise;
38130 }
38131
38132 if (parameters['deleted'] !== undefined) {
38133 form['deleted'] = parameters['deleted'];
38134 }
38135
38136 if (parameters['write_protect'] !== undefined) {
38137 form['write_protect'] = parameters['write_protect'];
38138 }
38139
38140 if (parameters['lazy_blocked'] !== undefined) {
38141 form['lazy_blocked'] = parameters['lazy_blocked'];
38142 }
38143
38144 if (parameters['no_sync'] !== undefined) {
38145 form['no_sync'] = parameters['no_sync'];
38146 }
38147
38148 if (parameters['name'] !== undefined) {
38149 form['name'] = parameters['name'];
38150 }
38151
38152 if (parameters['name'] === undefined) {
38153 deferred.reject(new Error('Missing required form parameter: name'));
38154 return deferred.promise;
38155 }
38156
38157 if (parameters['owner'] !== undefined) {
38158 form['owner'] = parameters['owner'];
38159 }
38160
38161 if (parameters['owner'] === undefined) {
38162 deferred.reject(new Error('Missing required form parameter: owner'));
38163 return deferred.promise;
38164 }
38165
38166 if (parameters.$queryParameters) {
38167 Object.keys(parameters.$queryParameters)
38168 .forEach(function(parameterName) {
38169 var parameter = parameters.$queryParameters[parameterName];
38170 queryParameters[parameterName] = parameter;
38171 });
38172 }
38173
38174 var url = domain + path;
38175 var options = {
38176 timeout: parameters.$timeout,
38177 method: 'POST',
38178 url: url,
38179 params: queryParameters,
38180 data: body,
38181 headers: headers
38182 };
38183 if (Object.keys(form).length > 0) {
38184 options.data = form;
38185 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38186 options.transformRequest = xos.transformRequest;
38187 }
38188 $http(options)
38189 .success(function(data, status, headers, config) {
38190 deferred.resolve(data);
38191 if (parameters.$cache !== undefined) {
38192 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38193 }
38194 })
38195 .error(function(data, status, headers, config) {
38196 deferred.reject({
38197 status: status,
38198 headers: headers,
38199 config: config,
38200 body: data
38201 });
38202 });
38203
38204 return deferred.promise;
38205 };
38206 /**
38207 *
38208 * @method
38209 * @name xos#Router_Detail_GET
38210 * @param {string} pk -
38211 *
38212 */
38213 xos.prototype.Router_Detail_GET = function(parameters) {
38214 if (parameters === undefined) {
38215 parameters = {};
38216 }
38217 var deferred = $q.defer();
38218
38219 var domain = this.domain;
38220 var path = '/xos/routers/{pk}/';
38221
38222 var body;
38223 var queryParameters = {};
38224 var headers = {};
38225 var form = {};
38226
38227 path = path.replace('{pk}', parameters['pk']);
38228
38229 if (parameters['pk'] === undefined) {
38230 deferred.reject(new Error('Missing required path parameter: pk'));
38231 return deferred.promise;
38232 }
38233
38234 if (parameters.$queryParameters) {
38235 Object.keys(parameters.$queryParameters)
38236 .forEach(function(parameterName) {
38237 var parameter = parameters.$queryParameters[parameterName];
38238 queryParameters[parameterName] = parameter;
38239 });
38240 }
38241
38242 var url = domain + path;
38243 var cached = parameters.$cache && parameters.$cache.get(url);
38244 if (cached !== undefined && parameters.$refresh !== true) {
38245 deferred.resolve(cached);
38246 return deferred.promise;
38247 }
38248 var options = {
38249 timeout: parameters.$timeout,
38250 method: 'GET',
38251 url: url,
38252 params: queryParameters,
38253 data: body,
38254 headers: headers
38255 };
38256 if (Object.keys(form).length > 0) {
38257 options.data = form;
38258 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38259 options.transformRequest = xos.transformRequest;
38260 }
38261 $http(options)
38262 .success(function(data, status, headers, config) {
38263 deferred.resolve(data);
38264 if (parameters.$cache !== undefined) {
38265 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38266 }
38267 })
38268 .error(function(data, status, headers, config) {
38269 deferred.reject({
38270 status: status,
38271 headers: headers,
38272 config: config,
38273 body: data
38274 });
38275 });
38276
38277 return deferred.promise;
38278 };
38279 /**
38280 *
38281 * @method
38282 * @name xos#Router_Detail_PUT
38283 * @param {string} pk -
38284 * @param {string} enacted -
38285 * @param {string} policed -
38286 * @param {string} backend_register -
38287 * @param {string} backend_status -
38288 * @param {boolean} deleted -
38289 * @param {boolean} write_protect -
38290 * @param {boolean} lazy_blocked -
38291 * @param {boolean} no_sync -
38292 * @param {string} name -
38293 * @param {string} owner -
38294 *
38295 */
38296 xos.prototype.Router_Detail_PUT = function(parameters) {
38297 if (parameters === undefined) {
38298 parameters = {};
38299 }
38300 var deferred = $q.defer();
38301
38302 var domain = this.domain;
38303 var path = '/xos/routers/{pk}/';
38304
38305 var body;
38306 var queryParameters = {};
38307 var headers = {};
38308 var form = {};
38309
38310 path = path.replace('{pk}', parameters['pk']);
38311
38312 if (parameters['pk'] === undefined) {
38313 deferred.reject(new Error('Missing required path parameter: pk'));
38314 return deferred.promise;
38315 }
38316
38317 if (parameters['enacted'] !== undefined) {
38318 form['enacted'] = parameters['enacted'];
38319 }
38320
38321 if (parameters['policed'] !== undefined) {
38322 form['policed'] = parameters['policed'];
38323 }
38324
38325 if (parameters['backend_register'] !== undefined) {
38326 form['backend_register'] = parameters['backend_register'];
38327 }
38328
38329 if (parameters['backend_status'] !== undefined) {
38330 form['backend_status'] = parameters['backend_status'];
38331 }
38332
38333 if (parameters['backend_status'] === undefined) {
38334 deferred.reject(new Error('Missing required form parameter: backend_status'));
38335 return deferred.promise;
38336 }
38337
38338 if (parameters['deleted'] !== undefined) {
38339 form['deleted'] = parameters['deleted'];
38340 }
38341
38342 if (parameters['write_protect'] !== undefined) {
38343 form['write_protect'] = parameters['write_protect'];
38344 }
38345
38346 if (parameters['lazy_blocked'] !== undefined) {
38347 form['lazy_blocked'] = parameters['lazy_blocked'];
38348 }
38349
38350 if (parameters['no_sync'] !== undefined) {
38351 form['no_sync'] = parameters['no_sync'];
38352 }
38353
38354 if (parameters['name'] !== undefined) {
38355 form['name'] = parameters['name'];
38356 }
38357
38358 if (parameters['name'] === undefined) {
38359 deferred.reject(new Error('Missing required form parameter: name'));
38360 return deferred.promise;
38361 }
38362
38363 if (parameters['owner'] !== undefined) {
38364 form['owner'] = parameters['owner'];
38365 }
38366
38367 if (parameters['owner'] === undefined) {
38368 deferred.reject(new Error('Missing required form parameter: owner'));
38369 return deferred.promise;
38370 }
38371
38372 if (parameters.$queryParameters) {
38373 Object.keys(parameters.$queryParameters)
38374 .forEach(function(parameterName) {
38375 var parameter = parameters.$queryParameters[parameterName];
38376 queryParameters[parameterName] = parameter;
38377 });
38378 }
38379
38380 var url = domain + path;
38381 var options = {
38382 timeout: parameters.$timeout,
38383 method: 'PUT',
38384 url: url,
38385 params: queryParameters,
38386 data: body,
38387 headers: headers
38388 };
38389 if (Object.keys(form).length > 0) {
38390 options.data = form;
38391 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38392 options.transformRequest = xos.transformRequest;
38393 }
38394 $http(options)
38395 .success(function(data, status, headers, config) {
38396 deferred.resolve(data);
38397 if (parameters.$cache !== undefined) {
38398 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38399 }
38400 })
38401 .error(function(data, status, headers, config) {
38402 deferred.reject({
38403 status: status,
38404 headers: headers,
38405 config: config,
38406 body: data
38407 });
38408 });
38409
38410 return deferred.promise;
38411 };
38412 /**
38413 *
38414 * @method
38415 * @name xos#Router_Detail_PATCH
38416 * @param {string} pk -
38417 * @param {string} enacted -
38418 * @param {string} policed -
38419 * @param {string} backend_register -
38420 * @param {string} backend_status -
38421 * @param {boolean} deleted -
38422 * @param {boolean} write_protect -
38423 * @param {boolean} lazy_blocked -
38424 * @param {boolean} no_sync -
38425 * @param {string} name -
38426 * @param {string} owner -
38427 *
38428 */
38429 xos.prototype.Router_Detail_PATCH = function(parameters) {
38430 if (parameters === undefined) {
38431 parameters = {};
38432 }
38433 var deferred = $q.defer();
38434
38435 var domain = this.domain;
38436 var path = '/xos/routers/{pk}/';
38437
38438 var body;
38439 var queryParameters = {};
38440 var headers = {};
38441 var form = {};
38442
38443 path = path.replace('{pk}', parameters['pk']);
38444
38445 if (parameters['pk'] === undefined) {
38446 deferred.reject(new Error('Missing required path parameter: pk'));
38447 return deferred.promise;
38448 }
38449
38450 if (parameters['enacted'] !== undefined) {
38451 form['enacted'] = parameters['enacted'];
38452 }
38453
38454 if (parameters['policed'] !== undefined) {
38455 form['policed'] = parameters['policed'];
38456 }
38457
38458 if (parameters['backend_register'] !== undefined) {
38459 form['backend_register'] = parameters['backend_register'];
38460 }
38461
38462 if (parameters['backend_status'] !== undefined) {
38463 form['backend_status'] = parameters['backend_status'];
38464 }
38465
38466 if (parameters['deleted'] !== undefined) {
38467 form['deleted'] = parameters['deleted'];
38468 }
38469
38470 if (parameters['write_protect'] !== undefined) {
38471 form['write_protect'] = parameters['write_protect'];
38472 }
38473
38474 if (parameters['lazy_blocked'] !== undefined) {
38475 form['lazy_blocked'] = parameters['lazy_blocked'];
38476 }
38477
38478 if (parameters['no_sync'] !== undefined) {
38479 form['no_sync'] = parameters['no_sync'];
38480 }
38481
38482 if (parameters['name'] !== undefined) {
38483 form['name'] = parameters['name'];
38484 }
38485
38486 if (parameters['owner'] !== undefined) {
38487 form['owner'] = parameters['owner'];
38488 }
38489
38490 if (parameters.$queryParameters) {
38491 Object.keys(parameters.$queryParameters)
38492 .forEach(function(parameterName) {
38493 var parameter = parameters.$queryParameters[parameterName];
38494 queryParameters[parameterName] = parameter;
38495 });
38496 }
38497
38498 var url = domain + path;
38499 var options = {
38500 timeout: parameters.$timeout,
38501 method: 'PATCH',
38502 url: url,
38503 params: queryParameters,
38504 data: body,
38505 headers: headers
38506 };
38507 if (Object.keys(form).length > 0) {
38508 options.data = form;
38509 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38510 options.transformRequest = xos.transformRequest;
38511 }
38512 $http(options)
38513 .success(function(data, status, headers, config) {
38514 deferred.resolve(data);
38515 if (parameters.$cache !== undefined) {
38516 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38517 }
38518 })
38519 .error(function(data, status, headers, config) {
38520 deferred.reject({
38521 status: status,
38522 headers: headers,
38523 config: config,
38524 body: data
38525 });
38526 });
38527
38528 return deferred.promise;
38529 };
38530 /**
38531 *
38532 * @method
38533 * @name xos#Router_Detail_DELETE
38534 * @param {string} pk -
38535 *
38536 */
38537 xos.prototype.Router_Detail_DELETE = function(parameters) {
38538 if (parameters === undefined) {
38539 parameters = {};
38540 }
38541 var deferred = $q.defer();
38542
38543 var domain = this.domain;
38544 var path = '/xos/routers/{pk}/';
38545
38546 var body;
38547 var queryParameters = {};
38548 var headers = {};
38549 var form = {};
38550
38551 path = path.replace('{pk}', parameters['pk']);
38552
38553 if (parameters['pk'] === undefined) {
38554 deferred.reject(new Error('Missing required path parameter: pk'));
38555 return deferred.promise;
38556 }
38557
38558 if (parameters.$queryParameters) {
38559 Object.keys(parameters.$queryParameters)
38560 .forEach(function(parameterName) {
38561 var parameter = parameters.$queryParameters[parameterName];
38562 queryParameters[parameterName] = parameter;
38563 });
38564 }
38565
38566 var url = domain + path;
38567 var options = {
38568 timeout: parameters.$timeout,
38569 method: 'DELETE',
38570 url: url,
38571 params: queryParameters,
38572 data: body,
38573 headers: headers
38574 };
38575 if (Object.keys(form).length > 0) {
38576 options.data = form;
38577 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38578 options.transformRequest = xos.transformRequest;
38579 }
38580 $http(options)
38581 .success(function(data, status, headers, config) {
38582 deferred.resolve(data);
38583 if (parameters.$cache !== undefined) {
38584 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38585 }
38586 })
38587 .error(function(data, status, headers, config) {
38588 deferred.reject({
38589 status: status,
38590 headers: headers,
38591 config: config,
38592 body: data
38593 });
38594 });
38595
38596 return deferred.promise;
38597 };
38598 /**
38599 *
38600 * @method
38601 * @name xos#Service_Resource_List_GET
38602 *
38603 */
38604 xos.prototype.Service_Resource_List_GET = function(parameters) {
38605 if (parameters === undefined) {
38606 parameters = {};
38607 }
38608 var deferred = $q.defer();
38609
38610 var domain = this.domain;
38611 var path = '/xos/serviceresources/';
38612
38613 var body;
38614 var queryParameters = {};
38615 var headers = {};
38616 var form = {};
38617
38618 if (parameters.$queryParameters) {
38619 Object.keys(parameters.$queryParameters)
38620 .forEach(function(parameterName) {
38621 var parameter = parameters.$queryParameters[parameterName];
38622 queryParameters[parameterName] = parameter;
38623 });
38624 }
38625
38626 var url = domain + path;
38627 var cached = parameters.$cache && parameters.$cache.get(url);
38628 if (cached !== undefined && parameters.$refresh !== true) {
38629 deferred.resolve(cached);
38630 return deferred.promise;
38631 }
38632 var options = {
38633 timeout: parameters.$timeout,
38634 method: 'GET',
38635 url: url,
38636 params: queryParameters,
38637 data: body,
38638 headers: headers
38639 };
38640 if (Object.keys(form).length > 0) {
38641 options.data = form;
38642 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38643 options.transformRequest = xos.transformRequest;
38644 }
38645 $http(options)
38646 .success(function(data, status, headers, config) {
38647 deferred.resolve(data);
38648 if (parameters.$cache !== undefined) {
38649 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38650 }
38651 })
38652 .error(function(data, status, headers, config) {
38653 deferred.reject({
38654 status: status,
38655 headers: headers,
38656 config: config,
38657 body: data
38658 });
38659 });
38660
38661 return deferred.promise;
38662 };
38663 /**
38664 *
38665 * @method
38666 * @name xos#Service_Resource_List_POST
38667 * @param {string} enacted -
38668 * @param {string} policed -
38669 * @param {string} backend_register -
38670 * @param {string} backend_status -
38671 * @param {boolean} deleted -
38672 * @param {boolean} write_protect -
38673 * @param {boolean} lazy_blocked -
38674 * @param {boolean} no_sync -
38675 * @param {string} serviceClass -
38676 * @param {string} name -
38677 * @param {integer} maxUnitsDeployment -
38678 * @param {integer} maxUnitsNode -
38679 * @param {integer} maxDuration -
38680 * @param {integer} bucketInRate -
38681 * @param {integer} bucketMaxSize -
38682 * @param {integer} cost -
38683 * @param {boolean} calendarReservable -
38684 *
38685 */
38686 xos.prototype.Service_Resource_List_POST = function(parameters) {
38687 if (parameters === undefined) {
38688 parameters = {};
38689 }
38690 var deferred = $q.defer();
38691
38692 var domain = this.domain;
38693 var path = '/xos/serviceresources/';
38694
38695 var body;
38696 var queryParameters = {};
38697 var headers = {};
38698 var form = {};
38699
38700 if (parameters['enacted'] !== undefined) {
38701 form['enacted'] = parameters['enacted'];
38702 }
38703
38704 if (parameters['policed'] !== undefined) {
38705 form['policed'] = parameters['policed'];
38706 }
38707
38708 if (parameters['backend_register'] !== undefined) {
38709 form['backend_register'] = parameters['backend_register'];
38710 }
38711
38712 if (parameters['backend_status'] !== undefined) {
38713 form['backend_status'] = parameters['backend_status'];
38714 }
38715
38716 if (parameters['backend_status'] === undefined) {
38717 deferred.reject(new Error('Missing required form parameter: backend_status'));
38718 return deferred.promise;
38719 }
38720
38721 if (parameters['deleted'] !== undefined) {
38722 form['deleted'] = parameters['deleted'];
38723 }
38724
38725 if (parameters['write_protect'] !== undefined) {
38726 form['write_protect'] = parameters['write_protect'];
38727 }
38728
38729 if (parameters['lazy_blocked'] !== undefined) {
38730 form['lazy_blocked'] = parameters['lazy_blocked'];
38731 }
38732
38733 if (parameters['no_sync'] !== undefined) {
38734 form['no_sync'] = parameters['no_sync'];
38735 }
38736
38737 if (parameters['serviceClass'] !== undefined) {
38738 form['serviceClass'] = parameters['serviceClass'];
38739 }
38740
38741 if (parameters['serviceClass'] === undefined) {
38742 deferred.reject(new Error('Missing required form parameter: serviceClass'));
38743 return deferred.promise;
38744 }
38745
38746 if (parameters['name'] !== undefined) {
38747 form['name'] = parameters['name'];
38748 }
38749
38750 if (parameters['name'] === undefined) {
38751 deferred.reject(new Error('Missing required form parameter: name'));
38752 return deferred.promise;
38753 }
38754
38755 if (parameters['maxUnitsDeployment'] !== undefined) {
38756 form['maxUnitsDeployment'] = parameters['maxUnitsDeployment'];
38757 }
38758
38759 if (parameters['maxUnitsDeployment'] === undefined) {
38760 deferred.reject(new Error('Missing required form parameter: maxUnitsDeployment'));
38761 return deferred.promise;
38762 }
38763
38764 if (parameters['maxUnitsNode'] !== undefined) {
38765 form['maxUnitsNode'] = parameters['maxUnitsNode'];
38766 }
38767
38768 if (parameters['maxUnitsNode'] === undefined) {
38769 deferred.reject(new Error('Missing required form parameter: maxUnitsNode'));
38770 return deferred.promise;
38771 }
38772
38773 if (parameters['maxDuration'] !== undefined) {
38774 form['maxDuration'] = parameters['maxDuration'];
38775 }
38776
38777 if (parameters['maxDuration'] === undefined) {
38778 deferred.reject(new Error('Missing required form parameter: maxDuration'));
38779 return deferred.promise;
38780 }
38781
38782 if (parameters['bucketInRate'] !== undefined) {
38783 form['bucketInRate'] = parameters['bucketInRate'];
38784 }
38785
38786 if (parameters['bucketInRate'] === undefined) {
38787 deferred.reject(new Error('Missing required form parameter: bucketInRate'));
38788 return deferred.promise;
38789 }
38790
38791 if (parameters['bucketMaxSize'] !== undefined) {
38792 form['bucketMaxSize'] = parameters['bucketMaxSize'];
38793 }
38794
38795 if (parameters['bucketMaxSize'] === undefined) {
38796 deferred.reject(new Error('Missing required form parameter: bucketMaxSize'));
38797 return deferred.promise;
38798 }
38799
38800 if (parameters['cost'] !== undefined) {
38801 form['cost'] = parameters['cost'];
38802 }
38803
38804 if (parameters['cost'] === undefined) {
38805 deferred.reject(new Error('Missing required form parameter: cost'));
38806 return deferred.promise;
38807 }
38808
38809 if (parameters['calendarReservable'] !== undefined) {
38810 form['calendarReservable'] = parameters['calendarReservable'];
38811 }
38812
38813 if (parameters.$queryParameters) {
38814 Object.keys(parameters.$queryParameters)
38815 .forEach(function(parameterName) {
38816 var parameter = parameters.$queryParameters[parameterName];
38817 queryParameters[parameterName] = parameter;
38818 });
38819 }
38820
38821 var url = domain + path;
38822 var options = {
38823 timeout: parameters.$timeout,
38824 method: 'POST',
38825 url: url,
38826 params: queryParameters,
38827 data: body,
38828 headers: headers
38829 };
38830 if (Object.keys(form).length > 0) {
38831 options.data = form;
38832 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38833 options.transformRequest = xos.transformRequest;
38834 }
38835 $http(options)
38836 .success(function(data, status, headers, config) {
38837 deferred.resolve(data);
38838 if (parameters.$cache !== undefined) {
38839 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38840 }
38841 })
38842 .error(function(data, status, headers, config) {
38843 deferred.reject({
38844 status: status,
38845 headers: headers,
38846 config: config,
38847 body: data
38848 });
38849 });
38850
38851 return deferred.promise;
38852 };
38853 /**
38854 *
38855 * @method
38856 * @name xos#Service_Resource_Detail_GET
38857 * @param {string} pk -
38858 *
38859 */
38860 xos.prototype.Service_Resource_Detail_GET = function(parameters) {
38861 if (parameters === undefined) {
38862 parameters = {};
38863 }
38864 var deferred = $q.defer();
38865
38866 var domain = this.domain;
38867 var path = '/xos/serviceresources/{pk}/';
38868
38869 var body;
38870 var queryParameters = {};
38871 var headers = {};
38872 var form = {};
38873
38874 path = path.replace('{pk}', parameters['pk']);
38875
38876 if (parameters['pk'] === undefined) {
38877 deferred.reject(new Error('Missing required path parameter: pk'));
38878 return deferred.promise;
38879 }
38880
38881 if (parameters.$queryParameters) {
38882 Object.keys(parameters.$queryParameters)
38883 .forEach(function(parameterName) {
38884 var parameter = parameters.$queryParameters[parameterName];
38885 queryParameters[parameterName] = parameter;
38886 });
38887 }
38888
38889 var url = domain + path;
38890 var cached = parameters.$cache && parameters.$cache.get(url);
38891 if (cached !== undefined && parameters.$refresh !== true) {
38892 deferred.resolve(cached);
38893 return deferred.promise;
38894 }
38895 var options = {
38896 timeout: parameters.$timeout,
38897 method: 'GET',
38898 url: url,
38899 params: queryParameters,
38900 data: body,
38901 headers: headers
38902 };
38903 if (Object.keys(form).length > 0) {
38904 options.data = form;
38905 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
38906 options.transformRequest = xos.transformRequest;
38907 }
38908 $http(options)
38909 .success(function(data, status, headers, config) {
38910 deferred.resolve(data);
38911 if (parameters.$cache !== undefined) {
38912 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
38913 }
38914 })
38915 .error(function(data, status, headers, config) {
38916 deferred.reject({
38917 status: status,
38918 headers: headers,
38919 config: config,
38920 body: data
38921 });
38922 });
38923
38924 return deferred.promise;
38925 };
38926 /**
38927 *
38928 * @method
38929 * @name xos#Service_Resource_Detail_PUT
38930 * @param {string} pk -
38931 * @param {string} enacted -
38932 * @param {string} policed -
38933 * @param {string} backend_register -
38934 * @param {string} backend_status -
38935 * @param {boolean} deleted -
38936 * @param {boolean} write_protect -
38937 * @param {boolean} lazy_blocked -
38938 * @param {boolean} no_sync -
38939 * @param {string} serviceClass -
38940 * @param {string} name -
38941 * @param {integer} maxUnitsDeployment -
38942 * @param {integer} maxUnitsNode -
38943 * @param {integer} maxDuration -
38944 * @param {integer} bucketInRate -
38945 * @param {integer} bucketMaxSize -
38946 * @param {integer} cost -
38947 * @param {boolean} calendarReservable -
38948 *
38949 */
38950 xos.prototype.Service_Resource_Detail_PUT = function(parameters) {
38951 if (parameters === undefined) {
38952 parameters = {};
38953 }
38954 var deferred = $q.defer();
38955
38956 var domain = this.domain;
38957 var path = '/xos/serviceresources/{pk}/';
38958
38959 var body;
38960 var queryParameters = {};
38961 var headers = {};
38962 var form = {};
38963
38964 path = path.replace('{pk}', parameters['pk']);
38965
38966 if (parameters['pk'] === undefined) {
38967 deferred.reject(new Error('Missing required path parameter: pk'));
38968 return deferred.promise;
38969 }
38970
38971 if (parameters['enacted'] !== undefined) {
38972 form['enacted'] = parameters['enacted'];
38973 }
38974
38975 if (parameters['policed'] !== undefined) {
38976 form['policed'] = parameters['policed'];
38977 }
38978
38979 if (parameters['backend_register'] !== undefined) {
38980 form['backend_register'] = parameters['backend_register'];
38981 }
38982
38983 if (parameters['backend_status'] !== undefined) {
38984 form['backend_status'] = parameters['backend_status'];
38985 }
38986
38987 if (parameters['backend_status'] === undefined) {
38988 deferred.reject(new Error('Missing required form parameter: backend_status'));
38989 return deferred.promise;
38990 }
38991
38992 if (parameters['deleted'] !== undefined) {
38993 form['deleted'] = parameters['deleted'];
38994 }
38995
38996 if (parameters['write_protect'] !== undefined) {
38997 form['write_protect'] = parameters['write_protect'];
38998 }
38999
39000 if (parameters['lazy_blocked'] !== undefined) {
39001 form['lazy_blocked'] = parameters['lazy_blocked'];
39002 }
39003
39004 if (parameters['no_sync'] !== undefined) {
39005 form['no_sync'] = parameters['no_sync'];
39006 }
39007
39008 if (parameters['serviceClass'] !== undefined) {
39009 form['serviceClass'] = parameters['serviceClass'];
39010 }
39011
39012 if (parameters['serviceClass'] === undefined) {
39013 deferred.reject(new Error('Missing required form parameter: serviceClass'));
39014 return deferred.promise;
39015 }
39016
39017 if (parameters['name'] !== undefined) {
39018 form['name'] = parameters['name'];
39019 }
39020
39021 if (parameters['name'] === undefined) {
39022 deferred.reject(new Error('Missing required form parameter: name'));
39023 return deferred.promise;
39024 }
39025
39026 if (parameters['maxUnitsDeployment'] !== undefined) {
39027 form['maxUnitsDeployment'] = parameters['maxUnitsDeployment'];
39028 }
39029
39030 if (parameters['maxUnitsDeployment'] === undefined) {
39031 deferred.reject(new Error('Missing required form parameter: maxUnitsDeployment'));
39032 return deferred.promise;
39033 }
39034
39035 if (parameters['maxUnitsNode'] !== undefined) {
39036 form['maxUnitsNode'] = parameters['maxUnitsNode'];
39037 }
39038
39039 if (parameters['maxUnitsNode'] === undefined) {
39040 deferred.reject(new Error('Missing required form parameter: maxUnitsNode'));
39041 return deferred.promise;
39042 }
39043
39044 if (parameters['maxDuration'] !== undefined) {
39045 form['maxDuration'] = parameters['maxDuration'];
39046 }
39047
39048 if (parameters['maxDuration'] === undefined) {
39049 deferred.reject(new Error('Missing required form parameter: maxDuration'));
39050 return deferred.promise;
39051 }
39052
39053 if (parameters['bucketInRate'] !== undefined) {
39054 form['bucketInRate'] = parameters['bucketInRate'];
39055 }
39056
39057 if (parameters['bucketInRate'] === undefined) {
39058 deferred.reject(new Error('Missing required form parameter: bucketInRate'));
39059 return deferred.promise;
39060 }
39061
39062 if (parameters['bucketMaxSize'] !== undefined) {
39063 form['bucketMaxSize'] = parameters['bucketMaxSize'];
39064 }
39065
39066 if (parameters['bucketMaxSize'] === undefined) {
39067 deferred.reject(new Error('Missing required form parameter: bucketMaxSize'));
39068 return deferred.promise;
39069 }
39070
39071 if (parameters['cost'] !== undefined) {
39072 form['cost'] = parameters['cost'];
39073 }
39074
39075 if (parameters['cost'] === undefined) {
39076 deferred.reject(new Error('Missing required form parameter: cost'));
39077 return deferred.promise;
39078 }
39079
39080 if (parameters['calendarReservable'] !== undefined) {
39081 form['calendarReservable'] = parameters['calendarReservable'];
39082 }
39083
39084 if (parameters.$queryParameters) {
39085 Object.keys(parameters.$queryParameters)
39086 .forEach(function(parameterName) {
39087 var parameter = parameters.$queryParameters[parameterName];
39088 queryParameters[parameterName] = parameter;
39089 });
39090 }
39091
39092 var url = domain + path;
39093 var options = {
39094 timeout: parameters.$timeout,
39095 method: 'PUT',
39096 url: url,
39097 params: queryParameters,
39098 data: body,
39099 headers: headers
39100 };
39101 if (Object.keys(form).length > 0) {
39102 options.data = form;
39103 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39104 options.transformRequest = xos.transformRequest;
39105 }
39106 $http(options)
39107 .success(function(data, status, headers, config) {
39108 deferred.resolve(data);
39109 if (parameters.$cache !== undefined) {
39110 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39111 }
39112 })
39113 .error(function(data, status, headers, config) {
39114 deferred.reject({
39115 status: status,
39116 headers: headers,
39117 config: config,
39118 body: data
39119 });
39120 });
39121
39122 return deferred.promise;
39123 };
39124 /**
39125 *
39126 * @method
39127 * @name xos#Service_Resource_Detail_PATCH
39128 * @param {string} pk -
39129 * @param {string} enacted -
39130 * @param {string} policed -
39131 * @param {string} backend_register -
39132 * @param {string} backend_status -
39133 * @param {boolean} deleted -
39134 * @param {boolean} write_protect -
39135 * @param {boolean} lazy_blocked -
39136 * @param {boolean} no_sync -
39137 * @param {string} serviceClass -
39138 * @param {string} name -
39139 * @param {integer} maxUnitsDeployment -
39140 * @param {integer} maxUnitsNode -
39141 * @param {integer} maxDuration -
39142 * @param {integer} bucketInRate -
39143 * @param {integer} bucketMaxSize -
39144 * @param {integer} cost -
39145 * @param {boolean} calendarReservable -
39146 *
39147 */
39148 xos.prototype.Service_Resource_Detail_PATCH = function(parameters) {
39149 if (parameters === undefined) {
39150 parameters = {};
39151 }
39152 var deferred = $q.defer();
39153
39154 var domain = this.domain;
39155 var path = '/xos/serviceresources/{pk}/';
39156
39157 var body;
39158 var queryParameters = {};
39159 var headers = {};
39160 var form = {};
39161
39162 path = path.replace('{pk}', parameters['pk']);
39163
39164 if (parameters['pk'] === undefined) {
39165 deferred.reject(new Error('Missing required path parameter: pk'));
39166 return deferred.promise;
39167 }
39168
39169 if (parameters['enacted'] !== undefined) {
39170 form['enacted'] = parameters['enacted'];
39171 }
39172
39173 if (parameters['policed'] !== undefined) {
39174 form['policed'] = parameters['policed'];
39175 }
39176
39177 if (parameters['backend_register'] !== undefined) {
39178 form['backend_register'] = parameters['backend_register'];
39179 }
39180
39181 if (parameters['backend_status'] !== undefined) {
39182 form['backend_status'] = parameters['backend_status'];
39183 }
39184
39185 if (parameters['deleted'] !== undefined) {
39186 form['deleted'] = parameters['deleted'];
39187 }
39188
39189 if (parameters['write_protect'] !== undefined) {
39190 form['write_protect'] = parameters['write_protect'];
39191 }
39192
39193 if (parameters['lazy_blocked'] !== undefined) {
39194 form['lazy_blocked'] = parameters['lazy_blocked'];
39195 }
39196
39197 if (parameters['no_sync'] !== undefined) {
39198 form['no_sync'] = parameters['no_sync'];
39199 }
39200
39201 if (parameters['serviceClass'] !== undefined) {
39202 form['serviceClass'] = parameters['serviceClass'];
39203 }
39204
39205 if (parameters['name'] !== undefined) {
39206 form['name'] = parameters['name'];
39207 }
39208
39209 if (parameters['maxUnitsDeployment'] !== undefined) {
39210 form['maxUnitsDeployment'] = parameters['maxUnitsDeployment'];
39211 }
39212
39213 if (parameters['maxUnitsNode'] !== undefined) {
39214 form['maxUnitsNode'] = parameters['maxUnitsNode'];
39215 }
39216
39217 if (parameters['maxDuration'] !== undefined) {
39218 form['maxDuration'] = parameters['maxDuration'];
39219 }
39220
39221 if (parameters['bucketInRate'] !== undefined) {
39222 form['bucketInRate'] = parameters['bucketInRate'];
39223 }
39224
39225 if (parameters['bucketMaxSize'] !== undefined) {
39226 form['bucketMaxSize'] = parameters['bucketMaxSize'];
39227 }
39228
39229 if (parameters['cost'] !== undefined) {
39230 form['cost'] = parameters['cost'];
39231 }
39232
39233 if (parameters['calendarReservable'] !== undefined) {
39234 form['calendarReservable'] = parameters['calendarReservable'];
39235 }
39236
39237 if (parameters.$queryParameters) {
39238 Object.keys(parameters.$queryParameters)
39239 .forEach(function(parameterName) {
39240 var parameter = parameters.$queryParameters[parameterName];
39241 queryParameters[parameterName] = parameter;
39242 });
39243 }
39244
39245 var url = domain + path;
39246 var options = {
39247 timeout: parameters.$timeout,
39248 method: 'PATCH',
39249 url: url,
39250 params: queryParameters,
39251 data: body,
39252 headers: headers
39253 };
39254 if (Object.keys(form).length > 0) {
39255 options.data = form;
39256 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39257 options.transformRequest = xos.transformRequest;
39258 }
39259 $http(options)
39260 .success(function(data, status, headers, config) {
39261 deferred.resolve(data);
39262 if (parameters.$cache !== undefined) {
39263 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39264 }
39265 })
39266 .error(function(data, status, headers, config) {
39267 deferred.reject({
39268 status: status,
39269 headers: headers,
39270 config: config,
39271 body: data
39272 });
39273 });
39274
39275 return deferred.promise;
39276 };
39277 /**
39278 *
39279 * @method
39280 * @name xos#Service_Resource_Detail_DELETE
39281 * @param {string} pk -
39282 *
39283 */
39284 xos.prototype.Service_Resource_Detail_DELETE = function(parameters) {
39285 if (parameters === undefined) {
39286 parameters = {};
39287 }
39288 var deferred = $q.defer();
39289
39290 var domain = this.domain;
39291 var path = '/xos/serviceresources/{pk}/';
39292
39293 var body;
39294 var queryParameters = {};
39295 var headers = {};
39296 var form = {};
39297
39298 path = path.replace('{pk}', parameters['pk']);
39299
39300 if (parameters['pk'] === undefined) {
39301 deferred.reject(new Error('Missing required path parameter: pk'));
39302 return deferred.promise;
39303 }
39304
39305 if (parameters.$queryParameters) {
39306 Object.keys(parameters.$queryParameters)
39307 .forEach(function(parameterName) {
39308 var parameter = parameters.$queryParameters[parameterName];
39309 queryParameters[parameterName] = parameter;
39310 });
39311 }
39312
39313 var url = domain + path;
39314 var options = {
39315 timeout: parameters.$timeout,
39316 method: 'DELETE',
39317 url: url,
39318 params: queryParameters,
39319 data: body,
39320 headers: headers
39321 };
39322 if (Object.keys(form).length > 0) {
39323 options.data = form;
39324 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39325 options.transformRequest = xos.transformRequest;
39326 }
39327 $http(options)
39328 .success(function(data, status, headers, config) {
39329 deferred.resolve(data);
39330 if (parameters.$cache !== undefined) {
39331 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39332 }
39333 })
39334 .error(function(data, status, headers, config) {
39335 deferred.reject({
39336 status: status,
39337 headers: headers,
39338 config: config,
39339 body: data
39340 });
39341 });
39342
39343 return deferred.promise;
39344 };
39345 /**
39346 *
39347 * @method
39348 * @name xos#Service_Privilege_List_GET
39349 *
39350 */
39351 xos.prototype.Service_Privilege_List_GET = function(parameters) {
39352 if (parameters === undefined) {
39353 parameters = {};
39354 }
39355 var deferred = $q.defer();
39356
39357 var domain = this.domain;
39358 var path = '/xos/serviceprivileges/';
39359
39360 var body;
39361 var queryParameters = {};
39362 var headers = {};
39363 var form = {};
39364
39365 if (parameters.$queryParameters) {
39366 Object.keys(parameters.$queryParameters)
39367 .forEach(function(parameterName) {
39368 var parameter = parameters.$queryParameters[parameterName];
39369 queryParameters[parameterName] = parameter;
39370 });
39371 }
39372
39373 var url = domain + path;
39374 var cached = parameters.$cache && parameters.$cache.get(url);
39375 if (cached !== undefined && parameters.$refresh !== true) {
39376 deferred.resolve(cached);
39377 return deferred.promise;
39378 }
39379 var options = {
39380 timeout: parameters.$timeout,
39381 method: 'GET',
39382 url: url,
39383 params: queryParameters,
39384 data: body,
39385 headers: headers
39386 };
39387 if (Object.keys(form).length > 0) {
39388 options.data = form;
39389 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39390 options.transformRequest = xos.transformRequest;
39391 }
39392 $http(options)
39393 .success(function(data, status, headers, config) {
39394 deferred.resolve(data);
39395 if (parameters.$cache !== undefined) {
39396 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39397 }
39398 })
39399 .error(function(data, status, headers, config) {
39400 deferred.reject({
39401 status: status,
39402 headers: headers,
39403 config: config,
39404 body: data
39405 });
39406 });
39407
39408 return deferred.promise;
39409 };
39410 /**
39411 *
39412 * @method
39413 * @name xos#Service_Privilege_List_POST
39414 * @param {string} enacted -
39415 * @param {string} policed -
39416 * @param {string} backend_register -
39417 * @param {string} backend_status -
39418 * @param {boolean} deleted -
39419 * @param {boolean} write_protect -
39420 * @param {boolean} lazy_blocked -
39421 * @param {boolean} no_sync -
39422 * @param {string} user -
39423 * @param {string} service -
39424 * @param {string} role -
39425 *
39426 */
39427 xos.prototype.Service_Privilege_List_POST = function(parameters) {
39428 if (parameters === undefined) {
39429 parameters = {};
39430 }
39431 var deferred = $q.defer();
39432
39433 var domain = this.domain;
39434 var path = '/xos/serviceprivileges/';
39435
39436 var body;
39437 var queryParameters = {};
39438 var headers = {};
39439 var form = {};
39440
39441 if (parameters['enacted'] !== undefined) {
39442 form['enacted'] = parameters['enacted'];
39443 }
39444
39445 if (parameters['policed'] !== undefined) {
39446 form['policed'] = parameters['policed'];
39447 }
39448
39449 if (parameters['backend_register'] !== undefined) {
39450 form['backend_register'] = parameters['backend_register'];
39451 }
39452
39453 if (parameters['backend_status'] !== undefined) {
39454 form['backend_status'] = parameters['backend_status'];
39455 }
39456
39457 if (parameters['backend_status'] === undefined) {
39458 deferred.reject(new Error('Missing required form parameter: backend_status'));
39459 return deferred.promise;
39460 }
39461
39462 if (parameters['deleted'] !== undefined) {
39463 form['deleted'] = parameters['deleted'];
39464 }
39465
39466 if (parameters['write_protect'] !== undefined) {
39467 form['write_protect'] = parameters['write_protect'];
39468 }
39469
39470 if (parameters['lazy_blocked'] !== undefined) {
39471 form['lazy_blocked'] = parameters['lazy_blocked'];
39472 }
39473
39474 if (parameters['no_sync'] !== undefined) {
39475 form['no_sync'] = parameters['no_sync'];
39476 }
39477
39478 if (parameters['user'] !== undefined) {
39479 form['user'] = parameters['user'];
39480 }
39481
39482 if (parameters['user'] === undefined) {
39483 deferred.reject(new Error('Missing required form parameter: user'));
39484 return deferred.promise;
39485 }
39486
39487 if (parameters['service'] !== undefined) {
39488 form['service'] = parameters['service'];
39489 }
39490
39491 if (parameters['service'] === undefined) {
39492 deferred.reject(new Error('Missing required form parameter: service'));
39493 return deferred.promise;
39494 }
39495
39496 if (parameters['role'] !== undefined) {
39497 form['role'] = parameters['role'];
39498 }
39499
39500 if (parameters['role'] === undefined) {
39501 deferred.reject(new Error('Missing required form parameter: role'));
39502 return deferred.promise;
39503 }
39504
39505 if (parameters.$queryParameters) {
39506 Object.keys(parameters.$queryParameters)
39507 .forEach(function(parameterName) {
39508 var parameter = parameters.$queryParameters[parameterName];
39509 queryParameters[parameterName] = parameter;
39510 });
39511 }
39512
39513 var url = domain + path;
39514 var options = {
39515 timeout: parameters.$timeout,
39516 method: 'POST',
39517 url: url,
39518 params: queryParameters,
39519 data: body,
39520 headers: headers
39521 };
39522 if (Object.keys(form).length > 0) {
39523 options.data = form;
39524 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39525 options.transformRequest = xos.transformRequest;
39526 }
39527 $http(options)
39528 .success(function(data, status, headers, config) {
39529 deferred.resolve(data);
39530 if (parameters.$cache !== undefined) {
39531 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39532 }
39533 })
39534 .error(function(data, status, headers, config) {
39535 deferred.reject({
39536 status: status,
39537 headers: headers,
39538 config: config,
39539 body: data
39540 });
39541 });
39542
39543 return deferred.promise;
39544 };
39545 /**
39546 *
39547 * @method
39548 * @name xos#Service_Privilege_Detail_GET
39549 * @param {string} pk -
39550 *
39551 */
39552 xos.prototype.Service_Privilege_Detail_GET = function(parameters) {
39553 if (parameters === undefined) {
39554 parameters = {};
39555 }
39556 var deferred = $q.defer();
39557
39558 var domain = this.domain;
39559 var path = '/xos/serviceprivileges/{pk}/';
39560
39561 var body;
39562 var queryParameters = {};
39563 var headers = {};
39564 var form = {};
39565
39566 path = path.replace('{pk}', parameters['pk']);
39567
39568 if (parameters['pk'] === undefined) {
39569 deferred.reject(new Error('Missing required path parameter: pk'));
39570 return deferred.promise;
39571 }
39572
39573 if (parameters.$queryParameters) {
39574 Object.keys(parameters.$queryParameters)
39575 .forEach(function(parameterName) {
39576 var parameter = parameters.$queryParameters[parameterName];
39577 queryParameters[parameterName] = parameter;
39578 });
39579 }
39580
39581 var url = domain + path;
39582 var cached = parameters.$cache && parameters.$cache.get(url);
39583 if (cached !== undefined && parameters.$refresh !== true) {
39584 deferred.resolve(cached);
39585 return deferred.promise;
39586 }
39587 var options = {
39588 timeout: parameters.$timeout,
39589 method: 'GET',
39590 url: url,
39591 params: queryParameters,
39592 data: body,
39593 headers: headers
39594 };
39595 if (Object.keys(form).length > 0) {
39596 options.data = form;
39597 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39598 options.transformRequest = xos.transformRequest;
39599 }
39600 $http(options)
39601 .success(function(data, status, headers, config) {
39602 deferred.resolve(data);
39603 if (parameters.$cache !== undefined) {
39604 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39605 }
39606 })
39607 .error(function(data, status, headers, config) {
39608 deferred.reject({
39609 status: status,
39610 headers: headers,
39611 config: config,
39612 body: data
39613 });
39614 });
39615
39616 return deferred.promise;
39617 };
39618 /**
39619 *
39620 * @method
39621 * @name xos#Service_Privilege_Detail_PUT
39622 * @param {string} pk -
39623 * @param {string} enacted -
39624 * @param {string} policed -
39625 * @param {string} backend_register -
39626 * @param {string} backend_status -
39627 * @param {boolean} deleted -
39628 * @param {boolean} write_protect -
39629 * @param {boolean} lazy_blocked -
39630 * @param {boolean} no_sync -
39631 * @param {string} user -
39632 * @param {string} service -
39633 * @param {string} role -
39634 *
39635 */
39636 xos.prototype.Service_Privilege_Detail_PUT = function(parameters) {
39637 if (parameters === undefined) {
39638 parameters = {};
39639 }
39640 var deferred = $q.defer();
39641
39642 var domain = this.domain;
39643 var path = '/xos/serviceprivileges/{pk}/';
39644
39645 var body;
39646 var queryParameters = {};
39647 var headers = {};
39648 var form = {};
39649
39650 path = path.replace('{pk}', parameters['pk']);
39651
39652 if (parameters['pk'] === undefined) {
39653 deferred.reject(new Error('Missing required path parameter: pk'));
39654 return deferred.promise;
39655 }
39656
39657 if (parameters['enacted'] !== undefined) {
39658 form['enacted'] = parameters['enacted'];
39659 }
39660
39661 if (parameters['policed'] !== undefined) {
39662 form['policed'] = parameters['policed'];
39663 }
39664
39665 if (parameters['backend_register'] !== undefined) {
39666 form['backend_register'] = parameters['backend_register'];
39667 }
39668
39669 if (parameters['backend_status'] !== undefined) {
39670 form['backend_status'] = parameters['backend_status'];
39671 }
39672
39673 if (parameters['backend_status'] === undefined) {
39674 deferred.reject(new Error('Missing required form parameter: backend_status'));
39675 return deferred.promise;
39676 }
39677
39678 if (parameters['deleted'] !== undefined) {
39679 form['deleted'] = parameters['deleted'];
39680 }
39681
39682 if (parameters['write_protect'] !== undefined) {
39683 form['write_protect'] = parameters['write_protect'];
39684 }
39685
39686 if (parameters['lazy_blocked'] !== undefined) {
39687 form['lazy_blocked'] = parameters['lazy_blocked'];
39688 }
39689
39690 if (parameters['no_sync'] !== undefined) {
39691 form['no_sync'] = parameters['no_sync'];
39692 }
39693
39694 if (parameters['user'] !== undefined) {
39695 form['user'] = parameters['user'];
39696 }
39697
39698 if (parameters['user'] === undefined) {
39699 deferred.reject(new Error('Missing required form parameter: user'));
39700 return deferred.promise;
39701 }
39702
39703 if (parameters['service'] !== undefined) {
39704 form['service'] = parameters['service'];
39705 }
39706
39707 if (parameters['service'] === undefined) {
39708 deferred.reject(new Error('Missing required form parameter: service'));
39709 return deferred.promise;
39710 }
39711
39712 if (parameters['role'] !== undefined) {
39713 form['role'] = parameters['role'];
39714 }
39715
39716 if (parameters['role'] === undefined) {
39717 deferred.reject(new Error('Missing required form parameter: role'));
39718 return deferred.promise;
39719 }
39720
39721 if (parameters.$queryParameters) {
39722 Object.keys(parameters.$queryParameters)
39723 .forEach(function(parameterName) {
39724 var parameter = parameters.$queryParameters[parameterName];
39725 queryParameters[parameterName] = parameter;
39726 });
39727 }
39728
39729 var url = domain + path;
39730 var options = {
39731 timeout: parameters.$timeout,
39732 method: 'PUT',
39733 url: url,
39734 params: queryParameters,
39735 data: body,
39736 headers: headers
39737 };
39738 if (Object.keys(form).length > 0) {
39739 options.data = form;
39740 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39741 options.transformRequest = xos.transformRequest;
39742 }
39743 $http(options)
39744 .success(function(data, status, headers, config) {
39745 deferred.resolve(data);
39746 if (parameters.$cache !== undefined) {
39747 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39748 }
39749 })
39750 .error(function(data, status, headers, config) {
39751 deferred.reject({
39752 status: status,
39753 headers: headers,
39754 config: config,
39755 body: data
39756 });
39757 });
39758
39759 return deferred.promise;
39760 };
39761 /**
39762 *
39763 * @method
39764 * @name xos#Service_Privilege_Detail_PATCH
39765 * @param {string} pk -
39766 * @param {string} enacted -
39767 * @param {string} policed -
39768 * @param {string} backend_register -
39769 * @param {string} backend_status -
39770 * @param {boolean} deleted -
39771 * @param {boolean} write_protect -
39772 * @param {boolean} lazy_blocked -
39773 * @param {boolean} no_sync -
39774 * @param {string} user -
39775 * @param {string} service -
39776 * @param {string} role -
39777 *
39778 */
39779 xos.prototype.Service_Privilege_Detail_PATCH = function(parameters) {
39780 if (parameters === undefined) {
39781 parameters = {};
39782 }
39783 var deferred = $q.defer();
39784
39785 var domain = this.domain;
39786 var path = '/xos/serviceprivileges/{pk}/';
39787
39788 var body;
39789 var queryParameters = {};
39790 var headers = {};
39791 var form = {};
39792
39793 path = path.replace('{pk}', parameters['pk']);
39794
39795 if (parameters['pk'] === undefined) {
39796 deferred.reject(new Error('Missing required path parameter: pk'));
39797 return deferred.promise;
39798 }
39799
39800 if (parameters['enacted'] !== undefined) {
39801 form['enacted'] = parameters['enacted'];
39802 }
39803
39804 if (parameters['policed'] !== undefined) {
39805 form['policed'] = parameters['policed'];
39806 }
39807
39808 if (parameters['backend_register'] !== undefined) {
39809 form['backend_register'] = parameters['backend_register'];
39810 }
39811
39812 if (parameters['backend_status'] !== undefined) {
39813 form['backend_status'] = parameters['backend_status'];
39814 }
39815
39816 if (parameters['deleted'] !== undefined) {
39817 form['deleted'] = parameters['deleted'];
39818 }
39819
39820 if (parameters['write_protect'] !== undefined) {
39821 form['write_protect'] = parameters['write_protect'];
39822 }
39823
39824 if (parameters['lazy_blocked'] !== undefined) {
39825 form['lazy_blocked'] = parameters['lazy_blocked'];
39826 }
39827
39828 if (parameters['no_sync'] !== undefined) {
39829 form['no_sync'] = parameters['no_sync'];
39830 }
39831
39832 if (parameters['user'] !== undefined) {
39833 form['user'] = parameters['user'];
39834 }
39835
39836 if (parameters['service'] !== undefined) {
39837 form['service'] = parameters['service'];
39838 }
39839
39840 if (parameters['role'] !== undefined) {
39841 form['role'] = parameters['role'];
39842 }
39843
39844 if (parameters.$queryParameters) {
39845 Object.keys(parameters.$queryParameters)
39846 .forEach(function(parameterName) {
39847 var parameter = parameters.$queryParameters[parameterName];
39848 queryParameters[parameterName] = parameter;
39849 });
39850 }
39851
39852 var url = domain + path;
39853 var options = {
39854 timeout: parameters.$timeout,
39855 method: 'PATCH',
39856 url: url,
39857 params: queryParameters,
39858 data: body,
39859 headers: headers
39860 };
39861 if (Object.keys(form).length > 0) {
39862 options.data = form;
39863 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39864 options.transformRequest = xos.transformRequest;
39865 }
39866 $http(options)
39867 .success(function(data, status, headers, config) {
39868 deferred.resolve(data);
39869 if (parameters.$cache !== undefined) {
39870 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39871 }
39872 })
39873 .error(function(data, status, headers, config) {
39874 deferred.reject({
39875 status: status,
39876 headers: headers,
39877 config: config,
39878 body: data
39879 });
39880 });
39881
39882 return deferred.promise;
39883 };
39884 /**
39885 *
39886 * @method
39887 * @name xos#Service_Privilege_Detail_DELETE
39888 * @param {string} pk -
39889 *
39890 */
39891 xos.prototype.Service_Privilege_Detail_DELETE = function(parameters) {
39892 if (parameters === undefined) {
39893 parameters = {};
39894 }
39895 var deferred = $q.defer();
39896
39897 var domain = this.domain;
39898 var path = '/xos/serviceprivileges/{pk}/';
39899
39900 var body;
39901 var queryParameters = {};
39902 var headers = {};
39903 var form = {};
39904
39905 path = path.replace('{pk}', parameters['pk']);
39906
39907 if (parameters['pk'] === undefined) {
39908 deferred.reject(new Error('Missing required path parameter: pk'));
39909 return deferred.promise;
39910 }
39911
39912 if (parameters.$queryParameters) {
39913 Object.keys(parameters.$queryParameters)
39914 .forEach(function(parameterName) {
39915 var parameter = parameters.$queryParameters[parameterName];
39916 queryParameters[parameterName] = parameter;
39917 });
39918 }
39919
39920 var url = domain + path;
39921 var options = {
39922 timeout: parameters.$timeout,
39923 method: 'DELETE',
39924 url: url,
39925 params: queryParameters,
39926 data: body,
39927 headers: headers
39928 };
39929 if (Object.keys(form).length > 0) {
39930 options.data = form;
39931 options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
39932 options.transformRequest = xos.transformRequest;
39933 }
39934 $http(options)
39935 .success(function(data, status, headers, config) {
39936 deferred.resolve(data);
39937 if (parameters.$cache !== undefined) {
39938 parameters.$cache.put(url, data, parameters.$cacheItemOpts ? parameters.$cacheItemOpts : {});
39939 }
39940 })
39941 .error(function(data, status, headers, config) {
39942 deferred.reject({
39943 status: status,
39944 headers: headers,
39945 config: config,
39946 body: data
39947 });
39948 });
39949
39950 return deferred.promise;
39951 };
39952
39953 return xos;
39954 })();
39955
39956 return xos;
39957 }]);