swagger-ui_rails_audionerd 2.3.1 → 2.3.2

Sign up to get free protection for your applications and to get access to all the features.
@@ -1,3294 +0,0 @@
1
- /**
2
- * swagger-client - swagger.js is a javascript client for use with swaggering APIs.
3
- * @version v2.1.9-M1
4
- * @link http://swagger.io
5
- * @license apache 2.0
6
- */
7
- (function(){
8
- var ArrayModel = function(definition) {
9
- this.name = "arrayModel";
10
- this.definition = definition || {};
11
- this.properties = [];
12
-
13
- var requiredFields = definition.enum || [];
14
- var innerType = definition.items;
15
- if(innerType) {
16
- if(innerType.type) {
17
- this.type = typeFromJsonSchema(innerType.type, innerType.format);
18
- }
19
- else {
20
- this.ref = innerType.$ref;
21
- }
22
- }
23
- return this;
24
- };
25
-
26
- ArrayModel.prototype.createJSONSample = function(modelsToIgnore) {
27
- var result;
28
- modelsToIgnore = (modelsToIgnore||{});
29
- if(this.type) {
30
- result = this.type;
31
- }
32
- else if (this.ref) {
33
- var name = simpleRef(this.ref);
34
- if(typeof modelsToIgnore[name] === 'undefined') {
35
- modelsToIgnore[name] = this;
36
- result = models[name].createJSONSample(modelsToIgnore);
37
- }
38
- else {
39
- return name;
40
- }
41
- }
42
- return [ result ];
43
- };
44
-
45
- ArrayModel.prototype.getSampleValue = function(modelsToIgnore) {
46
- var result;
47
- modelsToIgnore = (modelsToIgnore || {});
48
- if(this.type) {
49
- result = type;
50
- }
51
- else if (this.ref) {
52
- var name = simpleRef(this.ref);
53
- result = models[name].getSampleValue(modelsToIgnore);
54
- }
55
- return [ result ];
56
- };
57
-
58
- ArrayModel.prototype.getMockSignature = function(modelsToIgnore) {
59
- var propertiesStr = [];
60
- var i, prop;
61
- for (i = 0; i < this.properties.length; i++) {
62
- prop = this.properties[i];
63
- propertiesStr.push(prop.toString());
64
- }
65
-
66
- var strong = '<span class="strong">';
67
- var stronger = '<span class="stronger">';
68
- var strongClose = '</span>';
69
- var classOpen = strong + 'array' + ' {' + strongClose;
70
- var classClose = strong + '}' + strongClose;
71
- var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
72
-
73
- if (!modelsToIgnore)
74
- modelsToIgnore = {};
75
- modelsToIgnore[this.name] = this;
76
- for (i = 0; i < this.properties.length; i++) {
77
- prop = this.properties[i];
78
- var ref = prop.$ref;
79
- var model = models[ref];
80
- if (model && typeof modelsToIgnore[ref] === 'undefined') {
81
- returnVal = returnVal + ('<br>' + model.getMockSignature(modelsToIgnore));
82
- }
83
- }
84
- return returnVal;
85
- };
86
-
87
-
88
- /**
89
- * SwaggerAuthorizations applys the correct authorization to an operation being executed
90
- */
91
- var SwaggerAuthorizations = function() {
92
- this.authz = {};
93
- };
94
-
95
- SwaggerAuthorizations.prototype.add = function(name, auth) {
96
- this.authz[name] = auth;
97
- return auth;
98
- };
99
-
100
- SwaggerAuthorizations.prototype.remove = function(name) {
101
- return delete this.authz[name];
102
- };
103
-
104
- SwaggerAuthorizations.prototype.apply = function (obj, authorizations) {
105
- var status = null;
106
- var key, name, value, result;
107
-
108
- // if the "authorizations" key is undefined, or has an empty array, add all keys
109
- if (typeof authorizations === 'undefined' || Object.keys(authorizations).length === 0) {
110
- for (key in this.authz) {
111
- value = this.authz[key];
112
- result = value.apply(obj, authorizations);
113
- if (result === true)
114
- status = true;
115
- }
116
- }
117
- else {
118
- // 2.0 support
119
- if (Array.isArray(authorizations)) {
120
-
121
- for (var i = 0; i < authorizations.length; i++) {
122
- var auth = authorizations[i];
123
- for (name in auth) {
124
- for (key in this.authz) {
125
- if (key == name) {
126
- value = this.authz[key];
127
- result = value.apply(obj, authorizations);
128
- if (result === true)
129
- status = true;
130
- }
131
- }
132
- }
133
- }
134
- }
135
- else {
136
- // 1.2 support
137
- for (name in authorizations) {
138
- for (key in this.authz) {
139
- if (key == name) {
140
- value = this.authz[key];
141
- result = value.apply(obj, authorizations);
142
- if (result === true)
143
- status = true;
144
- }
145
- }
146
- }
147
- }
148
- }
149
-
150
- return status;
151
- };
152
-
153
- /**
154
- * ApiKeyAuthorization allows a query param or header to be injected
155
- */
156
- var ApiKeyAuthorization = function(name, value, type) {
157
- this.name = name;
158
- this.value = value;
159
- this.type = type;
160
- };
161
-
162
- ApiKeyAuthorization.prototype.apply = function(obj, authorizations) {
163
- if (this.type === "query") {
164
- if (obj.url.indexOf('?') > 0)
165
- obj.url = obj.url + "&" + this.name + "=" + this.value;
166
- else
167
- obj.url = obj.url + "?" + this.name + "=" + this.value;
168
- return true;
169
- } else if (this.type === "header") {
170
- obj.headers[this.name] = this.value;
171
- return true;
172
- }
173
- };
174
-
175
- var CookieAuthorization = function(cookie) {
176
- this.cookie = cookie;
177
- };
178
-
179
- CookieAuthorization.prototype.apply = function(obj, authorizations) {
180
- obj.cookieJar = obj.cookieJar || CookieJar();
181
- obj.cookieJar.setCookie(this.cookie);
182
- return true;
183
- };
184
-
185
- /**
186
- * Password Authorization is a basic auth implementation
187
- */
188
- var PasswordAuthorization = function(name, username, password) {
189
- this.name = name;
190
- this.username = username;
191
- this.password = password;
192
- this._btoa = null;
193
- if (typeof window !== 'undefined')
194
- this._btoa = btoa;
195
- else
196
- this._btoa = require("btoa");
197
- };
198
-
199
- PasswordAuthorization.prototype.apply = function(obj, authorizations) {
200
- var base64encoder = this._btoa;
201
- obj.headers.Authorization = "Basic " + base64encoder(this.username + ":" + this.password);
202
- return true;
203
- };
204
- var __bind = function(fn, me){
205
- return function(){
206
- return fn.apply(me, arguments);
207
- };
208
- };
209
-
210
- fail = function(message) {
211
- log(message);
212
- };
213
-
214
- log = function(){
215
- log.history = log.history || [];
216
- log.history.push(arguments);
217
- if(this.console){
218
- console.log( Array.prototype.slice.call(arguments)[0] );
219
- }
220
- };
221
-
222
- if (!Array.prototype.indexOf) {
223
- Array.prototype.indexOf = function(obj, start) {
224
- for (var i = (start || 0), j = this.length; i < j; i++) {
225
- if (this[i] === obj) { return i; }
226
- }
227
- return -1;
228
- };
229
- }
230
-
231
- /**
232
- * allows override of the default value based on the parameter being
233
- * supplied
234
- **/
235
- var applyParameterMacro = function (operation, parameter) {
236
- var e = (typeof window !== 'undefined' ? window : exports);
237
- if(e.parameterMacro)
238
- return e.parameterMacro(operation, parameter);
239
- else
240
- return parameter.defaultValue;
241
- };
242
-
243
- /**
244
- * allows overriding the default value of an model property
245
- **/
246
- var applyModelPropertyMacro = function (model, property) {
247
- var e = (typeof window !== 'undefined' ? window : exports);
248
- if(e.modelPropertyMacro)
249
- return e.modelPropertyMacro(model, property);
250
- else
251
- return property.defaultValue;
252
- };
253
-
254
- /**
255
- * PrimitiveModel
256
- **/
257
- var PrimitiveModel = function(definition) {
258
- this.name = "name";
259
- this.definition = definition || {};
260
- this.properties = [];
261
-
262
- var requiredFields = definition.enum || [];
263
- this.type = typeFromJsonSchema(definition.type, definition.format);
264
- };
265
-
266
- PrimitiveModel.prototype.createJSONSample = function(modelsToIgnore) {
267
- var result = this.type;
268
- return result;
269
- };
270
-
271
- PrimitiveModel.prototype.getSampleValue = function() {
272
- var result = this.type;
273
- return null;
274
- };
275
-
276
- PrimitiveModel.prototype.getMockSignature = function(modelsToIgnore) {
277
- var propertiesStr = [];
278
- var i, prop;
279
- for (i = 0; i < this.properties.length; i++) {
280
- prop = this.properties[i];
281
- propertiesStr.push(prop.toString());
282
- }
283
-
284
- var strong = '<span class="strong">';
285
- var stronger = '<span class="stronger">';
286
- var strongClose = '</span>';
287
- var classOpen = strong + this.name + ' {' + strongClose;
288
- var classClose = strong + '}' + strongClose;
289
- var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
290
-
291
- if (!modelsToIgnore)
292
- modelsToIgnore = {};
293
- modelsToIgnore[this.name] = this;
294
- for (i = 0; i < this.properties.length; i++) {
295
- prop = this.properties[i];
296
- var ref = prop.$ref;
297
- var model = models[ref];
298
- if (model && typeof modelsToIgnore[ref] === 'undefined') {
299
- returnVal = returnVal + ('<br>' + model.getMockSignature(modelsToIgnore));
300
- }
301
- }
302
- return returnVal;
303
- };
304
- /**
305
- * Resolves a spec's remote references
306
- */
307
- var Resolver = function (){};
308
-
309
- Resolver.prototype.resolve = function(spec, callback, scope) {
310
- this.scope = (scope || this);
311
- var host, name, path, property, propertyName, type;
312
- var processedCalls = 0, resolvedRefs = {}, unresolvedRefs = {};
313
-
314
- // store objects for dereferencing
315
- var resolutionTable = {};
316
-
317
- // models
318
- for(name in spec.definitions) {
319
- var model = spec.definitions[name];
320
- for(propertyName in model.properties) {
321
- property = model.properties[propertyName];
322
- this.resolveTo(property, resolutionTable);
323
- }
324
- }
325
- // operations
326
- for(name in spec.paths) {
327
- var method, operation, responseCode;
328
- path = spec.paths[name];
329
- for(method in path) {
330
- operation = path[method];
331
- var i, parameters = operation.parameters;
332
- for(i in parameters) {
333
- var parameter = parameters[i];
334
- if(parameter.in === 'body' && parameter.schema) {
335
- this.resolveTo(parameter.schema, resolutionTable);
336
- }
337
- if(parameter.$ref) {
338
- this.resolveInline(spec, parameter, resolutionTable, unresolvedRefs);
339
- }
340
- }
341
- for(responseCode in operation.responses) {
342
- var response = operation.responses[responseCode];
343
- if(response.schema) {
344
- this.resolveTo(response.schema, resolutionTable);
345
- }
346
- }
347
- }
348
- }
349
- // get hosts
350
- var opts = {}, expectedCalls = 0;
351
- for(name in resolutionTable) {
352
- var parts = name.split('#');
353
- if(parts.length == 2) {
354
- host = parts[0]; path = parts[1];
355
- if(!Array.isArray(opts[host])) {
356
- opts[host] = [];
357
- expectedCalls += 1;
358
- }
359
- opts[host].push(path);
360
- }
361
- }
362
-
363
- for(name in opts) {
364
- var self = this, opt = opts[name];
365
- host = name;
366
-
367
- var obj = {
368
- useJQuery: false, // TODO
369
- url: host,
370
- method: "get",
371
- headers: {
372
- accept: this.scope.swaggerRequestHeaders || 'application/json'
373
- },
374
- on: {
375
- error: function(response) {
376
- processedCalls += 1;
377
- var i;
378
- for(i = 0; i < opt.length; i++) {
379
- // fail all of these
380
- var resolved = host + '#' + opt[i];
381
- unresolvedRefs[resolved] = null;
382
- }
383
- if(processedCalls === expectedCalls)
384
- self.finish(spec, resolutionTable, resolvedRefs, unresolvedRefs, callback);
385
- },
386
- response: function(response) {
387
- var i, j, swagger = response.obj;
388
- processedCalls += 1;
389
- for(i = 0; i < opt.length; i++) {
390
- var location = swagger, path = opt[i], parts = path.split('/');
391
- for(j = 0; j < parts.length; j++) {
392
- var segment = parts[j];
393
- if(typeof location === 'undefined')
394
- break;
395
- if(segment.length > 0)
396
- location = location[segment];
397
- }
398
- var resolved = host + '#' + path, resolvedName = parts[j-1];
399
- if(typeof location !== 'undefined') {
400
- resolvedRefs[resolved] = {
401
- name: resolvedName,
402
- obj: location
403
- };
404
- }
405
- else unresolvedRefs[resolved] = null;
406
- }
407
- if(processedCalls === expectedCalls)
408
- self.finish(spec, resolutionTable, resolvedRefs, unresolvedRefs, callback);
409
- }
410
- }
411
- };
412
- authorizations.apply(obj);
413
- new SwaggerHttp().execute(obj);
414
- }
415
- if(Object.keys(opts).length === 0)
416
- callback.call(this.scope, spec, unresolvedRefs);
417
- };
418
-
419
- Resolver.prototype.finish = function(spec, resolutionTable, resolvedRefs, unresolvedRefs, callback) {
420
- // walk resolution table and replace with resolved refs
421
- var ref;
422
- for(ref in resolutionTable) {
423
- var i, locations = resolutionTable[ref];
424
- for(i = 0; i < locations.length; i++) {
425
- var resolvedTo = resolvedRefs[locations[i].obj.$ref];
426
- if(resolvedTo) {
427
- if(!spec.definitions)
428
- spec.definitions = {};
429
- if(locations[i].resolveAs === '$ref') {
430
- spec.definitions[resolvedTo.name] = resolvedTo.obj;
431
- locations[i].obj.$ref = '#/definitions/' + resolvedTo.name;
432
- }
433
- else if (locations[i].resolveAs === 'inline') {
434
- var key;
435
- var targetObj = locations[i].obj;
436
- delete targetObj.$ref;
437
- for(key in resolvedTo.obj) {
438
- targetObj[key] = resolvedTo.obj[key];
439
- }
440
- }
441
- }
442
- }
443
- }
444
- callback.call(this.scope, spec, unresolvedRefs);
445
- };
446
-
447
- /**
448
- * immediately in-lines local refs, queues remote refs
449
- * for inline resolution
450
- */
451
- Resolver.prototype.resolveInline = function (spec, property, objs, unresolvedRefs) {
452
- var ref = property.$ref;
453
- if(ref) {
454
- if(ref.indexOf('http') === 0) {
455
- if(Array.isArray(objs[ref])) {
456
- objs[ref].push({obj: property, resolveAs: 'inline'});
457
- }
458
- else {
459
- objs[ref] = [{obj: property, resolveAs: 'inline'}];
460
- }
461
- }
462
- else if (ref.indexOf('#') === 0) {
463
- // local resolve
464
- var shortenedRef = ref.substring(1);
465
- var i, parts = shortenedRef.split('/'), location = spec;
466
- for(i = 0; i < parts.length; i++) {
467
- var part = parts[i];
468
- if(part.length > 0) {
469
- location = location[part];
470
- }
471
- }
472
- if(location) {
473
- delete property.$ref;
474
- var key;
475
- for(key in location) {
476
- property[key] = location[key];
477
- }
478
- }
479
- else unresolvedRefs[ref] = null;
480
- }
481
- }
482
- else if(property.type === 'array') {
483
- this.resolveTo(property.items, objs);
484
- }
485
- };
486
-
487
- Resolver.prototype.resolveTo = function (property, objs) {
488
- var ref = property.$ref;
489
- if(ref) {
490
- if(ref.indexOf('http') === 0) {
491
- if(Array.isArray(objs[ref])) {
492
- objs[ref].push({obj: property, resolveAs: '$ref'});
493
- }
494
- else {
495
- objs[ref] = [{obj: property, resolveAs: '$ref'}];
496
- }
497
- }
498
- }
499
- else if(property.type === 'array') {
500
- var items = property.items;
501
- this.resolveTo(items, objs);
502
- }
503
- };
504
- var addModel = function(name, model) {
505
- models[name] = model;
506
- };
507
-
508
- var SwaggerClient = function(url, options) {
509
- this.isBuilt = false;
510
- this.url = null;
511
- this.debug = false;
512
- this.basePath = null;
513
- this.modelsArray = [];
514
- this.authorizations = null;
515
- this.authorizationScheme = null;
516
- this.isValid = false;
517
- this.info = null;
518
- this.useJQuery = false;
519
- this.resourceCount = 0;
520
-
521
- if(typeof url !== 'undefined')
522
- return this.initialize(url, options);
523
- };
524
-
525
- SwaggerClient.prototype.initialize = function (url, options) {
526
- this.models = models = {};
527
-
528
- options = (options||{});
529
-
530
- if(typeof url === 'string')
531
- this.url = url;
532
- else if(typeof url === 'object') {
533
- options = url;
534
- this.url = options.url;
535
- }
536
- this.swaggerRequstHeaders = options.swaggerRequstHeaders || 'application/json;charset=utf-8,*/*';
537
- this.defaultSuccessCallback = options.defaultSuccessCallback || null;
538
- this.defaultErrorCallback = options.defaultErrorCallback || null;
539
-
540
- if (typeof options.success === 'function')
541
- this.success = options.success;
542
-
543
- if (options.useJQuery)
544
- this.useJQuery = options.useJQuery;
545
-
546
- if (options.authorizations) {
547
- this.clientAuthorizations = options.authorizations;
548
- } else {
549
- this.clientAuthorizations = authorizations;
550
- }
551
-
552
- this.supportedSubmitMethods = options.supportedSubmitMethods || [];
553
- this.failure = options.failure || function() {};
554
- this.progress = options.progress || function() {};
555
- this.spec = options.spec;
556
- this.options = options;
557
-
558
- if (typeof options.success === 'function') {
559
- this.ready = true;
560
- this.build();
561
- }
562
- };
563
-
564
- SwaggerClient.prototype.build = function(mock) {
565
- if (this.isBuilt) return this;
566
- var self = this;
567
- this.progress('fetching resource list: ' + this.url);
568
- var obj = {
569
- useJQuery: this.useJQuery,
570
- url: this.url,
571
- method: "get",
572
- headers: {
573
- accept: this.swaggerRequstHeaders
574
- },
575
- on: {
576
- error: function(response) {
577
- if (self.url.substring(0, 4) !== 'http')
578
- return self.fail('Please specify the protocol for ' + self.url);
579
- else if (response.status === 0)
580
- return self.fail('Can\'t read from server. It may not have the appropriate access-control-origin settings.');
581
- else if (response.status === 404)
582
- return self.fail('Can\'t read swagger JSON from ' + self.url);
583
- else
584
- return self.fail(response.status + ' : ' + response.statusText + ' ' + self.url);
585
- },
586
- response: function(resp) {
587
- var responseObj = resp.obj || JSON.parse(resp.data);
588
- self.swaggerVersion = responseObj.swaggerVersion;
589
-
590
- if(responseObj.swagger && parseInt(responseObj.swagger) === 2) {
591
- self.swaggerVersion = responseObj.swagger;
592
- new Resolver().resolve(responseObj, self.buildFromSpec, self);
593
- self.isValid = true;
594
- }
595
- else {
596
- if (self.swaggerVersion === '1.2') {
597
- return self.buildFrom1_2Spec(responseObj);
598
- } else {
599
- return self.buildFrom1_1Spec(responseObj);
600
- }
601
- }
602
- }
603
- }
604
- };
605
- if(this.spec) {
606
- setTimeout(function() {
607
- new Resolver().resolve(self.spec, self.buildFromSpec, self);
608
- }, 10);
609
- }
610
- else {
611
- authorizations.apply(obj);
612
- if(mock)
613
- return obj;
614
- new SwaggerHttp().execute(obj);
615
- }
616
- return this;
617
- };
618
-
619
- SwaggerClient.prototype.buildFromSpec = function(response) {
620
- if(this.isBuilt) return this;
621
-
622
- this.info = response.info || {};
623
- this.title = response.title || '';
624
- this.host = response.host || '';
625
- this.schemes = response.schemes || [];
626
- this.basePath = response.basePath || '';
627
- this.apis = {};
628
- this.apisArray = [];
629
- this.consumes = response.consumes;
630
- this.produces = response.produces;
631
- this.securityDefinitions = response.securityDefinitions;
632
-
633
- // legacy support
634
- this.authSchemes = response.securityDefinitions;
635
-
636
- var definedTags = {};
637
- if(Array.isArray(response.tags)) {
638
- definedTags = {};
639
- for(k = 0; k < response.tags.length; k++) {
640
- var t = response.tags[k];
641
- definedTags[t.name] = t;
642
- }
643
- }
644
-
645
- var location;
646
- if(typeof this.url === 'string') {
647
- location = this.parseUri(this.url);
648
- }
649
-
650
- if(typeof this.schemes === 'undefined' || this.schemes.length === 0) {
651
- this.scheme = location.scheme || 'http';
652
- }
653
- else {
654
- this.scheme = this.schemes[0];
655
- }
656
-
657
- if(typeof this.host === 'undefined' || this.host === '') {
658
- this.host = location.host;
659
- if (location.port) {
660
- this.host = this.host + ':' + location.port;
661
- }
662
- }
663
-
664
- this.definitions = response.definitions;
665
- var key;
666
- for(key in this.definitions) {
667
- var model = new Model(key, this.definitions[key]);
668
- if(model) {
669
- models[key] = model;
670
- }
671
- }
672
-
673
- // get paths, create functions for each operationId
674
- var path;
675
- var operations = [];
676
- for(path in response.paths) {
677
- if(typeof response.paths[path] === 'object') {
678
- var httpMethod;
679
- for(httpMethod in response.paths[path]) {
680
- if(['delete', 'get', 'head', 'options', 'patch', 'post', 'put'].indexOf(httpMethod) === -1) {
681
- continue;
682
- }
683
- var operation = response.paths[path][httpMethod];
684
- var tags = operation.tags;
685
- if(typeof tags === 'undefined') {
686
- operation.tags = [ 'default' ];
687
- tags = operation.tags;
688
- }
689
- var operationId = this.idFromOp(path, httpMethod, operation);
690
- var operationObject = new Operation (
691
- this,
692
- operation.scheme,
693
- operationId,
694
- httpMethod,
695
- path,
696
- operation,
697
- this.definitions
698
- );
699
- // bind this operation's execute command to the api
700
- if(tags.length > 0) {
701
- var i;
702
- for(i = 0; i < tags.length; i++) {
703
- var tag = this.tagFromLabel(tags[i]);
704
- var operationGroup = this[tag];
705
- if(typeof this.apis[tag] === 'undefined')
706
- this.apis[tag] = {};
707
- if(typeof operationGroup === 'undefined') {
708
- this[tag] = [];
709
- operationGroup = this[tag];
710
- operationGroup.operations = {};
711
- operationGroup.label = tag;
712
- operationGroup.apis = [];
713
- var tagObject = definedTags[tag];
714
- if(typeof tagObject === 'object') {
715
- operationGroup.description = tagObject.description;
716
- operationGroup.externalDocs = tagObject.externalDocs;
717
- }
718
- this[tag].help = this.help.bind(operationGroup);
719
- this.apisArray.push(new OperationGroup(tag, operationGroup.description, operationGroup.externalDocs, operationObject));
720
- }
721
- if(typeof this.apis[tag].help !== 'function')
722
- this.apis[tag].help = this.help.bind(operationGroup);
723
- // bind to the apis object
724
- this.apis[tag][operationId] = operationObject.execute.bind(operationObject);
725
- this.apis[tag][operationId].help = operationObject.help.bind(operationObject);
726
- this.apis[tag][operationId].asCurl = operationObject.asCurl.bind(operationObject);
727
- operationGroup[operationId] = operationObject.execute.bind(operationObject);
728
- operationGroup[operationId].help = operationObject.help.bind(operationObject);
729
- operationGroup[operationId].asCurl = operationObject.asCurl.bind(operationObject);
730
-
731
- operationGroup.apis.push(operationObject);
732
- operationGroup.operations[operationId] = operationObject;
733
-
734
- // legacy UI feature
735
- var j;
736
- var api;
737
- for(j = 0; j < this.apisArray.length; j++) {
738
- if(this.apisArray[j].tag === tag) {
739
- api = this.apisArray[j];
740
- }
741
- }
742
- if(api) {
743
- api.operationsArray.push(operationObject);
744
- }
745
- }
746
- }
747
- else {
748
- log('no group to bind to');
749
- }
750
- }
751
- }
752
- }
753
- this.isBuilt = true;
754
- if (this.success) {
755
- this.isValid = true;
756
- this.isBuilt = true;
757
- this.success();
758
- }
759
- return this;
760
- };
761
-
762
- SwaggerClient.prototype.parseUri = function(uri) {
763
- var urlParseRE = /^(((([^:\/#\?]+:)?(?:(\/\/)((?:(([^:@\/#\?]+)(?:\:([^:@\/#\?]+))?)@)?(([^:\/#\?\]\[]+|\[[^\/\]@#?]+\])(?:\:([0-9]+))?))?)?)?((\/?(?:[^\/\?#]+\/+)*)([^\?#]*)))?(\?[^#]+)?)(#.*)?/;
764
- var parts = urlParseRE.exec(uri);
765
- return {
766
- scheme: parts[4].replace(':',''),
767
- host: parts[11],
768
- port: parts[12],
769
- path: parts[15]
770
- };
771
- };
772
-
773
- SwaggerClient.prototype.help = function(dontPrint) {
774
- var i;
775
- var output = 'operations for the "' + this.label + '" tag';
776
- for(i = 0; i < this.apis.length; i++) {
777
- var api = this.apis[i];
778
- output += '\n * ' + api.nickname + ': ' + api.operation.summary;
779
- }
780
- if(dontPrint)
781
- return output;
782
- else {
783
- log(output);
784
- return output;
785
- }
786
- };
787
-
788
- SwaggerClient.prototype.tagFromLabel = function(label) {
789
- return label;
790
- };
791
-
792
- SwaggerClient.prototype.idFromOp = function(path, httpMethod, op) {
793
- var opId = op.operationId || (path.substring(1) + '_' + httpMethod);
794
- return opId.replace(/[\.,-\/#!$%\^&\*;:{}=\-_`~()\+\s]/g,'_');
795
- };
796
-
797
- SwaggerClient.prototype.fail = function(message) {
798
- this.failure(message);
799
- throw message;
800
- };
801
-
802
- var OperationGroup = function(tag, description, externalDocs, operation) {
803
- this.tag = tag;
804
- this.path = tag;
805
- this.description = description;
806
- this.externalDocs = externalDocs;
807
- this.name = tag;
808
- this.operation = operation;
809
- this.operationsArray = [];
810
- };
811
-
812
- var Operation = function(parent, scheme, operationId, httpMethod, path, args, definitions) {
813
- var errors = [];
814
- parent = parent||{};
815
- args = args||{};
816
-
817
- this.operations = {};
818
- this.operation = args;
819
- this.deprecated = args.deprecated;
820
- this.consumes = args.consumes;
821
- this.produces = args.produces;
822
- this.parent = parent;
823
- this.host = parent.host || 'localhost';
824
- this.schemes = parent.schemes;
825
- this.scheme = scheme || parent.scheme || 'http';
826
- this.basePath = parent.basePath || '/';
827
- this.nickname = (operationId||errors.push('Operations must have a nickname.'));
828
- this.method = (httpMethod||errors.push('Operation ' + operationId + ' is missing method.'));
829
- this.path = (path||errors.push('Operation ' + this.nickname + ' is missing path.'));
830
- this.parameters = args !== null ? (args.parameters||[]) : {};
831
- this.summary = args.summary || '';
832
- this.responses = (args.responses||{});
833
- this.type = null;
834
- this.security = args.security;
835
- this.authorizations = args.security;
836
- this.description = args.description;
837
- this.useJQuery = parent.useJQuery;
838
-
839
- if(typeof this.deprecated === 'string') {
840
- switch(this.deprecated.toLowerCase()) {
841
- case 'true': case 'yes': case '1': {
842
- this.deprecated = true;
843
- break;
844
- }
845
- case 'false': case 'no': case '0': case null: {
846
- this.deprecated = false;
847
- break;
848
- }
849
- default: this.deprecated = Boolean(this.deprecated);
850
- }
851
- }
852
-
853
- var i, model;
854
-
855
- if(definitions) {
856
- // add to global models
857
- var key;
858
- for(key in this.definitions) {
859
- model = new Model(key, definitions[key]);
860
- if(model) {
861
- models[key] = model;
862
- }
863
- }
864
- }
865
- for(i = 0; i < this.parameters.length; i++) {
866
- var param = this.parameters[i];
867
- if(param.type === 'array') {
868
- param.isList = true;
869
- param.allowMultiple = true;
870
- }
871
- var innerType = this.getType(param);
872
- if(innerType && innerType.toString().toLowerCase() === 'boolean') {
873
- param.allowableValues = {};
874
- param.isList = true;
875
- param['enum'] = ["true", "false"];
876
- }
877
- if(typeof param['enum'] !== 'undefined') {
878
- var id;
879
- param.allowableValues = {};
880
- param.allowableValues.values = [];
881
- param.allowableValues.descriptiveValues = [];
882
- for(id = 0; id < param['enum'].length; id++) {
883
- var value = param['enum'][id];
884
- var isDefault = (value === param.default) ? true : false;
885
- param.allowableValues.values.push(value);
886
- param.allowableValues.descriptiveValues.push({value : value, isDefault: isDefault});
887
- }
888
- }
889
- if(param.type === 'array') {
890
- innerType = [innerType];
891
- if(typeof param.allowableValues === 'undefined') {
892
- // can't show as a list if no values to select from
893
- delete param.isList;
894
- delete param.allowMultiple;
895
- }
896
- }
897
- param.signature = this.getModelSignature(innerType, models).toString();
898
- param.sampleJSON = this.getModelSampleJSON(innerType, models);
899
- param.responseClassSignature = param.signature;
900
- }
901
-
902
- var defaultResponseCode, response, responses = this.responses;
903
-
904
- if(responses['200']) {
905
- response = responses['200'];
906
- defaultResponseCode = '200';
907
- }
908
- else if(responses['201']) {
909
- response = responses['201'];
910
- defaultResponseCode = '201';
911
- }
912
- else if(responses['202']) {
913
- response = responses['202'];
914
- defaultResponseCode = '202';
915
- }
916
- else if(responses['203']) {
917
- response = responses['203'];
918
- defaultResponseCode = '203';
919
- }
920
- else if(responses['204']) {
921
- response = responses['204'];
922
- defaultResponseCode = '204';
923
- }
924
- else if(responses['205']) {
925
- response = responses['205'];
926
- defaultResponseCode = '205';
927
- }
928
- else if(responses['206']) {
929
- response = responses['206'];
930
- defaultResponseCode = '206';
931
- }
932
- else if(responses['default']) {
933
- response = responses['default'];
934
- defaultResponseCode = 'default';
935
- }
936
-
937
- if(response && response.schema) {
938
- var resolvedModel = this.resolveModel(response.schema, definitions);
939
- delete responses[defaultResponseCode];
940
- if(resolvedModel) {
941
- this.successResponse = {};
942
- this.successResponse[defaultResponseCode] = resolvedModel;
943
- }
944
- else {
945
- this.successResponse = {};
946
- this.successResponse[defaultResponseCode] = response.schema.type;
947
- }
948
- this.type = response;
949
- }
950
-
951
- if (errors.length > 0) {
952
- if(this.resource && this.resource.api && this.resource.api.fail)
953
- this.resource.api.fail(errors);
954
- }
955
-
956
- return this;
957
- };
958
-
959
- OperationGroup.prototype.sort = function(sorter) {
960
-
961
- };
962
-
963
- Operation.prototype.getType = function (param) {
964
- var type = param.type;
965
- var format = param.format;
966
- var isArray = false;
967
- var str;
968
- if(type === 'integer' && format === 'int32')
969
- str = 'integer';
970
- else if(type === 'integer' && format === 'int64')
971
- str = 'long';
972
- else if(type === 'integer')
973
- str = 'integer';
974
- else if(type === 'string') {
975
- if(format === 'date-time')
976
- str = 'date-time';
977
- else if(format === 'date')
978
- str = 'date';
979
- else
980
- str = 'string';
981
- }
982
- else if(type === 'number' && format === 'float')
983
- str = 'float';
984
- else if(type === 'number' && format === 'double')
985
- str = 'double';
986
- else if(type === 'number')
987
- str = 'double';
988
- else if(type === 'boolean')
989
- str = 'boolean';
990
- else if(type === 'array') {
991
- isArray = true;
992
- if(param.items)
993
- str = this.getType(param.items);
994
- }
995
- if(param.$ref)
996
- str = param.$ref;
997
-
998
- var schema = param.schema;
999
- if(schema) {
1000
- var ref = schema.$ref;
1001
- if(ref) {
1002
- ref = simpleRef(ref);
1003
- if(isArray)
1004
- return [ ref ];
1005
- else
1006
- return ref;
1007
- }
1008
- else
1009
- return this.getType(schema);
1010
- }
1011
- if(isArray)
1012
- return [ str ];
1013
- else
1014
- return str;
1015
- };
1016
-
1017
- Operation.prototype.resolveModel = function (schema, definitions) {
1018
- if(typeof schema.$ref !== 'undefined') {
1019
- var ref = schema.$ref;
1020
- if(ref.indexOf('#/definitions/') === 0)
1021
- ref = ref.substring('#/definitions/'.length);
1022
- if(definitions[ref]) {
1023
- return new Model(ref, definitions[ref]);
1024
- }
1025
- }
1026
- if(schema.type === 'array')
1027
- return new ArrayModel(schema);
1028
- else
1029
- return null;
1030
- };
1031
-
1032
- Operation.prototype.help = function(dontPrint) {
1033
- var out = this.nickname + ': ' + this.summary + '\n';
1034
- for(var i = 0; i < this.parameters.length; i++) {
1035
- var param = this.parameters[i];
1036
- var typeInfo = param.signature;
1037
- out += '\n * ' + param.name + ' (' + typeInfo + '): ' + param.description;
1038
- }
1039
- if(typeof dontPrint === 'undefined')
1040
- log(out);
1041
- return out;
1042
- };
1043
-
1044
- Operation.prototype.getModelSignature = function(type, definitions) {
1045
- var isPrimitive, listType;
1046
-
1047
- if(type instanceof Array) {
1048
- listType = true;
1049
- type = type[0];
1050
- }
1051
- else if(typeof type === 'undefined')
1052
- type = 'undefined';
1053
-
1054
- if(type === 'string')
1055
- isPrimitive = true;
1056
- else
1057
- isPrimitive = (listType && definitions[listType]) || (definitions[type]) ? false : true;
1058
- if (isPrimitive) {
1059
- if(listType)
1060
- return 'Array[' + type + ']';
1061
- else
1062
- return type.toString();
1063
- } else {
1064
- if (listType)
1065
- return 'Array[' + definitions[type].getMockSignature() + ']';
1066
- else
1067
- return definitions[type].getMockSignature();
1068
- }
1069
- };
1070
-
1071
- Operation.prototype.supportHeaderParams = function () {
1072
- return true;
1073
- };
1074
-
1075
- Operation.prototype.supportedSubmitMethods = function () {
1076
- return this.parent.supportedSubmitMethods;
1077
- };
1078
-
1079
- Operation.prototype.getHeaderParams = function (args) {
1080
- var headers = this.setContentTypes(args, {});
1081
- for(var i = 0; i < this.parameters.length; i++) {
1082
- var param = this.parameters[i];
1083
- if(typeof args[param.name] !== 'undefined') {
1084
- if (param.in === 'header') {
1085
- var value = args[param.name];
1086
- if(Array.isArray(value))
1087
- value = value.toString();
1088
- headers[param.name] = value;
1089
- }
1090
- }
1091
- }
1092
- return headers;
1093
- };
1094
-
1095
- Operation.prototype.urlify = function (args) {
1096
- var formParams = {};
1097
- var requestUrl = this.path;
1098
-
1099
- // grab params from the args, build the querystring along the way
1100
- var querystring = '';
1101
- for(var i = 0; i < this.parameters.length; i++) {
1102
- var param = this.parameters[i];
1103
- if(typeof args[param.name] !== 'undefined') {
1104
- if(param.in === 'path') {
1105
- var reg = new RegExp('\{' + param.name + '\}', 'gi');
1106
- var value = args[param.name];
1107
- if(Array.isArray(value))
1108
- value = this.encodePathCollection(param.collectionFormat, param.name, value);
1109
- else
1110
- value = this.encodePathParam(value);
1111
- requestUrl = requestUrl.replace(reg, value);
1112
- }
1113
- else if (param.in === 'query' && typeof args[param.name] !== 'undefined') {
1114
- if(querystring === '')
1115
- querystring += '?';
1116
- else
1117
- querystring += '&';
1118
- if(typeof param.collectionFormat !== 'undefined') {
1119
- var qp = args[param.name];
1120
- if(Array.isArray(qp))
1121
- querystring += this.encodeQueryCollection(param.collectionFormat, param.name, qp);
1122
- else
1123
- querystring += this.encodeQueryParam(param.name) + '=' + this.encodeQueryParam(args[param.name]);
1124
- }
1125
- else
1126
- querystring += this.encodeQueryParam(param.name) + '=' + this.encodeQueryParam(args[param.name]);
1127
- }
1128
- else if (param.in === 'formData')
1129
- formParams[param.name] = args[param.name];
1130
- }
1131
- }
1132
- var url = this.scheme + '://' + this.host;
1133
-
1134
- if(this.basePath !== '/')
1135
- url += this.basePath;
1136
-
1137
- return url + requestUrl + querystring;
1138
- };
1139
-
1140
- Operation.prototype.getMissingParams = function(args) {
1141
- var missingParams = [];
1142
- // check required params, track the ones that are missing
1143
- var i;
1144
- for(i = 0; i < this.parameters.length; i++) {
1145
- var param = this.parameters[i];
1146
- if(param.required === true) {
1147
- if(typeof args[param.name] === 'undefined')
1148
- missingParams = param.name;
1149
- }
1150
- }
1151
- return missingParams;
1152
- };
1153
-
1154
- Operation.prototype.getBody = function(headers, args, opts) {
1155
- var formParams = {}, body, key;
1156
-
1157
- for(var i = 0; i < this.parameters.length; i++) {
1158
- var param = this.parameters[i];
1159
- if(typeof args[param.name] !== 'undefined') {
1160
- if (param.in === 'body') {
1161
- body = args[param.name];
1162
- } else if(param.in === 'formData') {
1163
- formParams[param.name] = args[param.name];
1164
- }
1165
- }
1166
- }
1167
-
1168
- // handle form params
1169
- if(headers['Content-Type'] === 'application/x-www-form-urlencoded') {
1170
- var encoded = "";
1171
- for(key in formParams) {
1172
- value = formParams[key];
1173
- if(typeof value !== 'undefined'){
1174
- if(encoded !== "")
1175
- encoded += "&";
1176
- encoded += encodeURIComponent(key) + '=' + encodeURIComponent(value);
1177
- }
1178
- }
1179
- body = encoded;
1180
- }
1181
- else if (headers['Content-Type'] && headers['Content-Type'].indexOf('multipart/form-data') >= 0) {
1182
- if(opts.useJQuery) {
1183
- var bodyParam = new FormData();
1184
- bodyParam.type = 'formData';
1185
- for (key in formParams) {
1186
- value = args[key];
1187
- if (typeof value !== 'undefined') {
1188
- // required for jquery file upload
1189
- if(value.type === 'file' && value.value) {
1190
- delete headers['Content-Type'];
1191
- bodyParam.append(key, value.value);
1192
- }
1193
- else
1194
- bodyParam.append(key, value);
1195
- }
1196
- }
1197
- body = bodyParam;
1198
- }
1199
- }
1200
-
1201
- return body;
1202
- };
1203
-
1204
- /**
1205
- * gets sample response for a single operation
1206
- **/
1207
- Operation.prototype.getModelSampleJSON = function(type, models) {
1208
- var isPrimitive, listType, sampleJson;
1209
-
1210
- listType = (type instanceof Array);
1211
- isPrimitive = models[type] ? false : true;
1212
- sampleJson = isPrimitive ? void 0 : models[type].createJSONSample();
1213
- if (sampleJson) {
1214
- sampleJson = listType ? [sampleJson] : sampleJson;
1215
- if(typeof sampleJson == 'string')
1216
- return sampleJson;
1217
- else if(typeof sampleJson === 'object') {
1218
- var t = sampleJson;
1219
- if(sampleJson instanceof Array && sampleJson.length > 0) {
1220
- t = sampleJson[0];
1221
- }
1222
- if(t.nodeName) {
1223
- var xmlString = new XMLSerializer().serializeToString(t);
1224
- return this.formatXml(xmlString);
1225
- }
1226
- else
1227
- return JSON.stringify(sampleJson, null, 2);
1228
- }
1229
- else
1230
- return sampleJson;
1231
- }
1232
- };
1233
-
1234
- /**
1235
- * legacy binding
1236
- **/
1237
- Operation.prototype["do"] = function(args, opts, callback, error, parent) {
1238
- return this.execute(args, opts, callback, error, parent);
1239
- };
1240
-
1241
-
1242
- /**
1243
- * executes an operation
1244
- **/
1245
- Operation.prototype.execute = function(arg1, arg2, arg3, arg4, parent) {
1246
- var args = arg1 || {};
1247
- var opts = {}, success, error;
1248
- if(typeof arg2 === 'object') {
1249
- opts = arg2;
1250
- success = arg3;
1251
- error = arg4;
1252
- }
1253
-
1254
- if(typeof arg2 === 'function') {
1255
- success = arg2;
1256
- error = arg3;
1257
- }
1258
-
1259
- success = (success||log);
1260
- error = (error||log);
1261
-
1262
- if(opts.useJQuery)
1263
- this.useJQuery = opts.useJQuery;
1264
-
1265
- var missingParams = this.getMissingParams(args);
1266
- if(missingParams.length > 0) {
1267
- var message = 'missing required params: ' + missingParams;
1268
- fail(message);
1269
- return;
1270
- }
1271
- var allHeaders = this.getHeaderParams(args);
1272
- var contentTypeHeaders = this.setContentTypes(args, opts);
1273
-
1274
- var headers = {}, attrname;
1275
- for (attrname in allHeaders) { headers[attrname] = allHeaders[attrname]; }
1276
- for (attrname in contentTypeHeaders) { headers[attrname] = contentTypeHeaders[attrname]; }
1277
-
1278
- var body = this.getBody(headers, args, opts);
1279
- var url = this.urlify(args);
1280
-
1281
- var obj = {
1282
- url: url,
1283
- method: this.method.toUpperCase(),
1284
- body: body,
1285
- useJQuery: this.useJQuery,
1286
- headers: headers,
1287
- on: {
1288
- response: function(response) {
1289
- return success(response, parent);
1290
- },
1291
- error: function(response) {
1292
- return error(response, parent);
1293
- }
1294
- }
1295
- };
1296
- var status = authorizations.apply(obj, this.operation.security);
1297
- if(opts.mock === true)
1298
- return obj;
1299
- else
1300
- new SwaggerHttp().execute(obj, opts);
1301
- };
1302
-
1303
- Operation.prototype.setContentTypes = function(args, opts) {
1304
- // default type
1305
- var accepts = 'application/json';
1306
- var consumes = args.parameterContentType || 'application/json';
1307
- var allDefinedParams = this.parameters;
1308
- var definedFormParams = [];
1309
- var definedFileParams = [];
1310
- var body;
1311
- var headers = {};
1312
-
1313
- // get params from the operation and set them in definedFileParams, definedFormParams, headers
1314
- var i;
1315
- for(i = 0; i < allDefinedParams.length; i++) {
1316
- var param = allDefinedParams[i];
1317
- if(param.in === 'formData') {
1318
- if(param.type === 'file')
1319
- definedFileParams.push(param);
1320
- else
1321
- definedFormParams.push(param);
1322
- }
1323
- else if(param.in === 'header' && opts) {
1324
- var key = param.name;
1325
- var headerValue = opts[param.name];
1326
- if(typeof opts[param.name] !== 'undefined')
1327
- headers[key] = headerValue;
1328
- }
1329
- else if(param.in === 'body' && typeof args[param.name] !== 'undefined') {
1330
- body = args[param.name];
1331
- }
1332
- }
1333
-
1334
- // if there's a body, need to set the consumes header via requestContentType
1335
- if (body && (this.method === 'post' || this.method === 'put' || this.method === 'patch' || this.method === 'delete')) {
1336
- if (opts.requestContentType)
1337
- consumes = opts.requestContentType;
1338
- } else {
1339
- // if any form params, content type must be set
1340
- if(definedFormParams.length > 0) {
1341
- if(opts.requestContentType) // override if set
1342
- consumes = opts.requestContentType;
1343
- else if(definedFileParams.length > 0) // if a file, must be multipart/form-data
1344
- consumes = 'multipart/form-data';
1345
- else // default to x-www-from-urlencoded
1346
- consumes = 'application/x-www-form-urlencoded';
1347
- }
1348
- else if (this.type == 'DELETE')
1349
- body = '{}';
1350
- else if (this.type != 'DELETE')
1351
- consumes = null;
1352
- }
1353
-
1354
- if (consumes && this.consumes) {
1355
- if (this.consumes.indexOf(consumes) === -1) {
1356
- log('server doesn\'t consume ' + consumes + ', try ' + JSON.stringify(this.consumes));
1357
- }
1358
- }
1359
-
1360
- if (opts.responseContentType) {
1361
- accepts = opts.responseContentType;
1362
- } else {
1363
- accepts = 'application/json';
1364
- }
1365
- if (accepts && this.produces) {
1366
- if (this.produces.indexOf(accepts) === -1) {
1367
- log('server can\'t produce ' + accepts);
1368
- }
1369
- }
1370
-
1371
- if ((consumes && body !== '') || (consumes === 'application/x-www-form-urlencoded'))
1372
- headers['Content-Type'] = consumes;
1373
- if (accepts)
1374
- headers.Accept = accepts;
1375
- return headers;
1376
- };
1377
-
1378
- Operation.prototype.asCurl = function (args) {
1379
- var obj = this.execute(args, {mock: true});
1380
- authorizations.apply(obj);
1381
- var results = [];
1382
- results.push('-X ' + this.method.toUpperCase());
1383
- if (obj.headers) {
1384
- var key;
1385
- for (key in obj.headers)
1386
- results.push('--header "' + key + ': ' + obj.headers[key] + '"');
1387
- }
1388
- if(obj.body) {
1389
- var body;
1390
- if(typeof obj.body === 'object')
1391
- body = JSON.stringify(obj.body);
1392
- else
1393
- body = obj.body;
1394
- results.push('-d "' + body.replace(/"/g, '\\"') + '"');
1395
- }
1396
- return 'curl ' + (results.join(' ')) + ' "' + obj.url + '"';
1397
- };
1398
-
1399
- Operation.prototype.encodePathCollection = function(type, name, value) {
1400
- var encoded = '';
1401
- var i;
1402
- var separator = '';
1403
- if(type === 'ssv')
1404
- separator = '%20';
1405
- else if(type === 'tsv')
1406
- separator = '\\t';
1407
- else if(type === 'pipes')
1408
- separator = '|';
1409
- else
1410
- separator = ',';
1411
-
1412
- for(i = 0; i < value.length; i++) {
1413
- if(i === 0)
1414
- encoded = this.encodeQueryParam(value[i]);
1415
- else
1416
- encoded += separator + this.encodeQueryParam(value[i]);
1417
- }
1418
- return encoded;
1419
- };
1420
-
1421
- Operation.prototype.encodeQueryCollection = function(type, name, value) {
1422
- var encoded = '';
1423
- var i;
1424
- if(type === 'default' || type === 'multi') {
1425
- for(i = 0; i < value.length; i++) {
1426
- if(i > 0) encoded += '&';
1427
- encoded += this.encodeQueryParam(name) + '=' + this.encodeQueryParam(value[i]);
1428
- }
1429
- }
1430
- else {
1431
- var separator = '';
1432
- if(type === 'csv')
1433
- separator = ',';
1434
- else if(type === 'ssv')
1435
- separator = '%20';
1436
- else if(type === 'tsv')
1437
- separator = '\\t';
1438
- else if(type === 'pipes')
1439
- separator = '|';
1440
- else if(type === 'brackets') {
1441
- for(i = 0; i < value.length; i++) {
1442
- if(i !== 0)
1443
- encoded += '&';
1444
- encoded += this.encodeQueryParam(name) + '[]=' + this.encodeQueryParam(value[i]);
1445
- }
1446
- }
1447
- if(separator !== '') {
1448
- for(i = 0; i < value.length; i++) {
1449
- if(i === 0)
1450
- encoded = this.encodeQueryParam(name) + '=' + this.encodeQueryParam(value[i]);
1451
- else
1452
- encoded += separator + this.encodeQueryParam(value[i]);
1453
- }
1454
- }
1455
- }
1456
- return encoded;
1457
- };
1458
-
1459
- Operation.prototype.encodeQueryParam = function(arg) {
1460
- return encodeURIComponent(arg);
1461
- };
1462
-
1463
- /**
1464
- * TODO revisit, might not want to leave '/'
1465
- **/
1466
- Operation.prototype.encodePathParam = function(pathParam) {
1467
- var encParts, part, parts, i, len;
1468
- pathParam = pathParam.toString();
1469
- if (pathParam.indexOf('/') === -1) {
1470
- return encodeURIComponent(pathParam);
1471
- } else {
1472
- parts = pathParam.split('/');
1473
- encParts = [];
1474
- for (i = 0, len = parts.length; i < len; i++) {
1475
- encParts.push(encodeURIComponent(parts[i]));
1476
- }
1477
- return encParts.join('/');
1478
- }
1479
- };
1480
-
1481
- var Model = function(name, definition) {
1482
- this.name = name;
1483
- this.definition = definition || {};
1484
- this.properties = [];
1485
- var requiredFields = definition.required || [];
1486
- if(definition.type === 'array') {
1487
- var out = new ArrayModel(definition);
1488
- return out;
1489
- }
1490
- var key;
1491
- var props = definition.properties;
1492
- if(props) {
1493
- for(key in props) {
1494
- var required = false;
1495
- var property = props[key];
1496
- if(requiredFields.indexOf(key) >= 0)
1497
- required = true;
1498
- this.properties.push(new Property(key, property, required));
1499
- }
1500
- }
1501
- };
1502
-
1503
- Model.prototype.createJSONSample = function(modelsToIgnore) {
1504
- var i, result = {}, representations = {};
1505
- modelsToIgnore = (modelsToIgnore||{});
1506
- modelsToIgnore[this.name] = this;
1507
- for (i = 0; i < this.properties.length; i++) {
1508
- prop = this.properties[i];
1509
- var sample = prop.getSampleValue(modelsToIgnore, representations);
1510
- result[prop.name] = sample;
1511
- }
1512
- delete modelsToIgnore[this.name];
1513
- return result;
1514
- };
1515
-
1516
- Model.prototype.getSampleValue = function(modelsToIgnore) {
1517
- var i, obj = {}, representations = {};
1518
- for(i = 0; i < this.properties.length; i++ ) {
1519
- var property = this.properties[i];
1520
- obj[property.name] = property.sampleValue(false, modelsToIgnore, representations);
1521
- }
1522
- return obj;
1523
- };
1524
-
1525
- Model.prototype.getMockSignature = function(modelsToIgnore) {
1526
- var i, prop, propertiesStr = [];
1527
- for (i = 0; i < this.properties.length; i++) {
1528
- prop = this.properties[i];
1529
- propertiesStr.push(prop.toString());
1530
- }
1531
- var strong = '<span class="strong">';
1532
- var stronger = '<span class="stronger">';
1533
- var strongClose = '</span>';
1534
- var classOpen = strong + this.name + ' {' + strongClose;
1535
- var classClose = strong + '}' + strongClose;
1536
- var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
1537
- if (!modelsToIgnore)
1538
- modelsToIgnore = {};
1539
-
1540
- modelsToIgnore[this.name] = this;
1541
- for (i = 0; i < this.properties.length; i++) {
1542
- prop = this.properties[i];
1543
- var ref = prop.$ref;
1544
- var model = models[ref];
1545
- if (model && typeof modelsToIgnore[model.name] === 'undefined') {
1546
- returnVal = returnVal + ('<br>' + model.getMockSignature(modelsToIgnore));
1547
- }
1548
- }
1549
- return returnVal;
1550
- };
1551
-
1552
- var Property = function(name, obj, required) {
1553
- this.schema = obj;
1554
- this.required = required;
1555
- if(obj.$ref)
1556
- this.$ref = simpleRef(obj.$ref);
1557
- else if (obj.type === 'array' && obj.items) {
1558
- if(obj.items.$ref)
1559
- this.$ref = simpleRef(obj.items.$ref);
1560
- else
1561
- obj = obj.items;
1562
- }
1563
- this.name = name;
1564
- this.description = obj.description;
1565
- this.obj = obj;
1566
- this.optional = true;
1567
- this.optional = !required;
1568
- this.default = obj.default || null;
1569
- this.example = obj.example !== undefined ? obj.example : null;
1570
- this.collectionFormat = obj.collectionFormat || null;
1571
- this.maximum = obj.maximum || null;
1572
- this.exclusiveMaximum = obj.exclusiveMaximum || null;
1573
- this.minimum = obj.minimum || null;
1574
- this.exclusiveMinimum = obj.exclusiveMinimum || null;
1575
- this.maxLength = obj.maxLength || null;
1576
- this.minLength = obj.minLength || null;
1577
- this.pattern = obj.pattern || null;
1578
- this.maxItems = obj.maxItems || null;
1579
- this.minItems = obj.minItems || null;
1580
- this.uniqueItems = obj.uniqueItems || null;
1581
- this['enum'] = obj['enum'] || null;
1582
- this.multipleOf = obj.multipleOf || null;
1583
- };
1584
-
1585
- Property.prototype.getSampleValue = function (modelsToIgnore, representations) {
1586
- return this.sampleValue(false, modelsToIgnore, representations);
1587
- };
1588
-
1589
- Property.prototype.isArray = function () {
1590
- var schema = this.schema;
1591
- if(schema.type === 'array')
1592
- return true;
1593
- else
1594
- return false;
1595
- };
1596
-
1597
- Property.prototype.sampleValue = function(isArray, ignoredModels, representations) {
1598
- isArray = (isArray || this.isArray());
1599
- ignoredModels = (ignoredModels || {});
1600
- // representations = (representations || {});
1601
-
1602
- var type = getStringSignature(this.obj, true);
1603
- var output;
1604
-
1605
- if(this.$ref) {
1606
- var refModelName = simpleRef(this.$ref);
1607
- var refModel = models[refModelName];
1608
- if(typeof representations[type] !== 'undefined') {
1609
- return representations[type];
1610
- }
1611
- else
1612
-
1613
- if(refModel && typeof ignoredModels[type] === 'undefined') {
1614
- ignoredModels[type] = this;
1615
- output = refModel.getSampleValue(ignoredModels, representations);
1616
- representations[type] = output;
1617
- }
1618
- else {
1619
- output = (representations[type] || refModelName);
1620
- }
1621
- }
1622
- else if(this.example)
1623
- output = this.example;
1624
- else if(this.default)
1625
- output = this.default;
1626
- else if(type === 'date-time')
1627
- output = new Date().toISOString();
1628
- else if(type === 'date')
1629
- output = new Date().toISOString().split("T")[0];
1630
- else if(type === 'string')
1631
- output = 'string';
1632
- else if(type === 'integer')
1633
- output = 0;
1634
- else if(type === 'long')
1635
- output = 0;
1636
- else if(type === 'float')
1637
- output = 0.0;
1638
- else if(type === 'double')
1639
- output = 0.0;
1640
- else if(type === 'boolean')
1641
- output = true;
1642
- else
1643
- output = {};
1644
- ignoredModels[type] = output;
1645
- if(isArray)
1646
- return [output];
1647
- else
1648
- return output;
1649
- };
1650
-
1651
- getStringSignature = function(obj, baseComponent) {
1652
- var str = '';
1653
- if(typeof obj.$ref !== 'undefined')
1654
- str += simpleRef(obj.$ref);
1655
- else if(typeof obj.type === 'undefined')
1656
- str += 'object';
1657
- else if(obj.type === 'array') {
1658
- if(baseComponent)
1659
- str += getStringSignature((obj.items || obj.$ref || {}));
1660
- else {
1661
- str += 'Array[';
1662
- str += getStringSignature((obj.items || obj.$ref || {}));
1663
- str += ']';
1664
- }
1665
- }
1666
- else if(obj.type === 'integer' && obj.format === 'int32')
1667
- str += 'integer';
1668
- else if(obj.type === 'integer' && obj.format === 'int64')
1669
- str += 'long';
1670
- else if(obj.type === 'integer' && typeof obj.format === 'undefined')
1671
- str += 'long';
1672
- else if(obj.type === 'string' && obj.format === 'date-time')
1673
- str += 'date-time';
1674
- else if(obj.type === 'string' && obj.format === 'date')
1675
- str += 'date';
1676
- else if(obj.type === 'string' && typeof obj.format === 'undefined')
1677
- str += 'string';
1678
- else if(obj.type === 'number' && obj.format === 'float')
1679
- str += 'float';
1680
- else if(obj.type === 'number' && obj.format === 'double')
1681
- str += 'double';
1682
- else if(obj.type === 'number' && typeof obj.format === 'undefined')
1683
- str += 'double';
1684
- else if(obj.type === 'boolean')
1685
- str += 'boolean';
1686
- else if(obj.$ref)
1687
- str += simpleRef(obj.$ref);
1688
- else
1689
- str += obj.type;
1690
- return str;
1691
- };
1692
-
1693
- simpleRef = function(name) {
1694
- if(typeof name === 'undefined')
1695
- return null;
1696
- if(name.indexOf("#/definitions/") === 0)
1697
- return name.substring('#/definitions/'.length);
1698
- else
1699
- return name;
1700
- };
1701
-
1702
- Property.prototype.toString = function() {
1703
- var str = getStringSignature(this.obj);
1704
- if(str !== '') {
1705
- str = '<span class="propName ' + this.required + '">' + this.name + '</span> (<span class="propType">' + str + '</span>';
1706
- if(!this.required)
1707
- str += ', <span class="propOptKey">optional</span>';
1708
- str += ')';
1709
- }
1710
- else
1711
- str = this.name + ' (' + JSON.stringify(this.obj) + ')';
1712
-
1713
- if(typeof this.description !== 'undefined')
1714
- str += ': ' + this.description;
1715
-
1716
- if (this['enum']) {
1717
- str += ' = <span class="propVals">[\'' + this['enum'].join('\' or \'') + '\']</span>';
1718
- }
1719
- if (this.descr) {
1720
- str += ': <span class="propDesc">' + this.descr + '</span>';
1721
- }
1722
-
1723
-
1724
- var options = '';
1725
- var isArray = this.schema.type === 'array';
1726
- var type;
1727
-
1728
- if(isArray) {
1729
- if(this.schema.items)
1730
- type = this.schema.items.type;
1731
- else
1732
- type = '';
1733
- }
1734
- else {
1735
- type = this.schema.type;
1736
- }
1737
-
1738
- if (this.default)
1739
- options += optionHtml('Default', this.default);
1740
-
1741
- switch (type) {
1742
- case 'string':
1743
- if (this.minLength)
1744
- options += optionHtml('Min. Length', this.minLength);
1745
- if (this.maxLength)
1746
- options += optionHtml('Max. Length', this.maxLength);
1747
- if (this.pattern)
1748
- options += optionHtml('Reg. Exp.', this.pattern);
1749
- break;
1750
- case 'integer':
1751
- case 'number':
1752
- if (this.minimum)
1753
- options += optionHtml('Min. Value', this.minimum);
1754
- if (this.exclusiveMinimum)
1755
- options += optionHtml('Exclusive Min.', "true");
1756
- if (this.maximum)
1757
- options += optionHtml('Max. Value', this.maximum);
1758
- if (this.exclusiveMaximum)
1759
- options += optionHtml('Exclusive Max.', "true");
1760
- if (this.multipleOf)
1761
- options += optionHtml('Multiple Of', this.multipleOf);
1762
- break;
1763
- }
1764
-
1765
- if (isArray) {
1766
- if (this.minItems)
1767
- options += optionHtml('Min. Items', this.minItems);
1768
- if (this.maxItems)
1769
- options += optionHtml('Max. Items', this.maxItems);
1770
- if (this.uniqueItems)
1771
- options += optionHtml('Unique Items', "true");
1772
- if (this.collectionFormat)
1773
- options += optionHtml('Coll. Format', this.collectionFormat);
1774
- }
1775
-
1776
- if (this['enum']) {
1777
- var enumString;
1778
-
1779
- if (type === 'number' || type === 'integer')
1780
- enumString = this['enum'].join(', ');
1781
- else {
1782
- enumString = '"' + this['enum'].join('", "') + '"';
1783
- }
1784
-
1785
- options += optionHtml('Enum', enumString);
1786
- }
1787
-
1788
- if (options.length > 0)
1789
- str = '<span class="propWrap">' + str + '<table class="optionsWrapper"><tr><th colspan="2">' + this.name + '</th></tr>' + options + '</table></span>';
1790
-
1791
- return str;
1792
- };
1793
-
1794
- optionHtml = function(label, value) {
1795
- return '<tr><td class="optionName">' + label + ':</td><td>' + value + '</td></tr>';
1796
- };
1797
-
1798
- typeFromJsonSchema = function(type, format) {
1799
- var str;
1800
- if(type === 'integer' && format === 'int32')
1801
- str = 'integer';
1802
- else if(type === 'integer' && format === 'int64')
1803
- str = 'long';
1804
- else if(type === 'integer' && typeof format === 'undefined')
1805
- str = 'long';
1806
- else if(type === 'string' && format === 'date-time')
1807
- str = 'date-time';
1808
- else if(type === 'string' && format === 'date')
1809
- str = 'date';
1810
- else if(type === 'number' && format === 'float')
1811
- str = 'float';
1812
- else if(type === 'number' && format === 'double')
1813
- str = 'double';
1814
- else if(type === 'number' && typeof format === 'undefined')
1815
- str = 'double';
1816
- else if(type === 'boolean')
1817
- str = 'boolean';
1818
- else if(type === 'string')
1819
- str = 'string';
1820
-
1821
- return str;
1822
- };
1823
-
1824
- var sampleModels = {};
1825
- var cookies = {};
1826
- var models = {};
1827
-
1828
- SwaggerClient.prototype.buildFrom1_2Spec = function (response) {
1829
- if (response.apiVersion !== null) {
1830
- this.apiVersion = response.apiVersion;
1831
- }
1832
- this.apis = {};
1833
- this.apisArray = [];
1834
- this.consumes = response.consumes;
1835
- this.produces = response.produces;
1836
- this.authSchemes = response.authorizations;
1837
- this.info = this.convertInfo(response.info);
1838
-
1839
- var isApi = false, i, res;
1840
- for (i = 0; i < response.apis.length; i++) {
1841
- var api = response.apis[i];
1842
- if (api.operations) {
1843
- var j;
1844
- for (j = 0; j < api.operations.length; j++) {
1845
- operation = api.operations[j];
1846
- isApi = true;
1847
- }
1848
- }
1849
- }
1850
- if (response.basePath)
1851
- this.basePath = response.basePath;
1852
- else if (this.url.indexOf('?') > 0)
1853
- this.basePath = this.url.substring(0, this.url.lastIndexOf('?'));
1854
- else
1855
- this.basePath = this.url;
1856
-
1857
- if (isApi) {
1858
- var newName = response.resourcePath.replace(/\//g, '');
1859
- this.resourcePath = response.resourcePath;
1860
- res = new SwaggerResource(response, this);
1861
- this.apis[newName] = res;
1862
- this.apisArray.push(res);
1863
- this.finish();
1864
- } else {
1865
- var k;
1866
- this.expectedResourceCount = response.apis.length;
1867
- for (k = 0; k < response.apis.length; k++) {
1868
- var resource = response.apis[k];
1869
- res = new SwaggerResource(resource, this);
1870
- this.apis[res.name] = res;
1871
- this.apisArray.push(res);
1872
- }
1873
- }
1874
- this.isValid = true;
1875
- return this;
1876
- };
1877
-
1878
- SwaggerClient.prototype.finish = function() {
1879
- if (typeof this.success === 'function') {
1880
- this.isValid = true;
1881
- this.ready = true;
1882
- this.isBuilt = true;
1883
- this.selfReflect();
1884
- this.success();
1885
- }
1886
- };
1887
-
1888
- SwaggerClient.prototype.buildFrom1_1Spec = function (response) {
1889
- log('This API is using a deprecated version of Swagger! Please see http://github.com/wordnik/swagger-core/wiki for more info');
1890
- if (response.apiVersion !== null)
1891
- this.apiVersion = response.apiVersion;
1892
- this.apis = {};
1893
- this.apisArray = [];
1894
- this.produces = response.produces;
1895
- this.info = this.convertInfo(response.info);
1896
- var isApi = false, res;
1897
- for (var i = 0; i < response.apis.length; i++) {
1898
- var api = response.apis[i];
1899
- if (api.operations) {
1900
- for (var j = 0; j < api.operations.length; j++) {
1901
- operation = api.operations[j];
1902
- isApi = true;
1903
- }
1904
- }
1905
- }
1906
- if (response.basePath) {
1907
- this.basePath = response.basePath;
1908
- } else if (this.url.indexOf('?') > 0) {
1909
- this.basePath = this.url.substring(0, this.url.lastIndexOf('?'));
1910
- } else {
1911
- this.basePath = this.url;
1912
- }
1913
- if (isApi) {
1914
- var newName = response.resourcePath.replace(/\//g, '');
1915
- this.resourcePath = response.resourcePath;
1916
- res = new SwaggerResource(response, this);
1917
- this.apis[newName] = res;
1918
- this.apisArray.push(res);
1919
- this.finish();
1920
- } else {
1921
- this.expectedResourceCount = response.apis.length;
1922
- for (k = 0; k < response.apis.length; k++) {
1923
- resource = response.apis[k];
1924
- res = new SwaggerResource(resource, this);
1925
- this.apis[res.name] = res;
1926
- this.apisArray.push(res);
1927
- }
1928
- }
1929
- this.isValid = true;
1930
- return this;
1931
- };
1932
-
1933
- SwaggerClient.prototype.convertInfo = function (resp) {
1934
- if(typeof resp == 'object') {
1935
- var info = {};
1936
-
1937
- info.title = resp.title;
1938
- info.description = resp.description;
1939
- info.termsOfService = resp.termsOfServiceUrl;
1940
- info.contact = {};
1941
- info.contact.name = resp.contact;
1942
- info.license = {};
1943
- info.license.name = resp.license;
1944
- info.license.url = resp.licenseUrl;
1945
-
1946
- return info;
1947
- }
1948
- };
1949
-
1950
- SwaggerClient.prototype.selfReflect = function () {
1951
- var resource, tag, ref;
1952
- if (this.apis === null) {
1953
- return false;
1954
- }
1955
- ref = this.apis;
1956
- for (tag in ref) {
1957
- api = ref[tag];
1958
- if (api.ready === null) {
1959
- return false;
1960
- }
1961
- this[tag] = api;
1962
- this[tag].help = __bind(api.help, api);
1963
- }
1964
- this.setConsolidatedModels();
1965
- this.ready = true;
1966
- };
1967
-
1968
- SwaggerClient.prototype.setConsolidatedModels = function () {
1969
- var model, modelName, resource, resource_name, i, apis, models, results;
1970
- this.models = {};
1971
- apis = this.apis;
1972
- for (resource_name in apis) {
1973
- resource = apis[resource_name];
1974
- for (modelName in resource.models) {
1975
- if (typeof this.models[modelName] === 'undefined') {
1976
- this.models[modelName] = resource.models[modelName];
1977
- this.modelsArray.push(resource.models[modelName]);
1978
- }
1979
- }
1980
- }
1981
- models = this.modelsArray;
1982
- results = [];
1983
- for (i = 0; i < models.length; i++) {
1984
- model = models[i];
1985
- results.push(model.setReferencedModels(this.models));
1986
- }
1987
- return results;
1988
- };
1989
-
1990
- var SwaggerResource = function (resourceObj, api) {
1991
- var _this = this;
1992
- this.api = api;
1993
- this.swaggerRequstHeaders = api.swaggerRequstHeaders;
1994
- this.path = (typeof this.api.resourcePath === 'string') ? this.api.resourcePath : resourceObj.path;
1995
- this.description = resourceObj.description;
1996
- this.authorizations = (resourceObj.authorizations || {});
1997
-
1998
- var parts = this.path.split('/');
1999
- this.name = parts[parts.length - 1].replace('.{format}', '');
2000
- this.basePath = this.api.basePath;
2001
- this.operations = {};
2002
- this.operationsArray = [];
2003
- this.modelsArray = [];
2004
- this.models = api.models || {};
2005
- this.rawModels = {};
2006
- this.useJQuery = (typeof api.useJQuery !== 'undefined') ? api.useJQuery : null;
2007
-
2008
- if ((resourceObj.apis) && this.api.resourcePath) {
2009
- this.addApiDeclaration(resourceObj);
2010
- } else {
2011
- if (typeof this.path === 'undefined') {
2012
- this.api.fail('SwaggerResources must have a path.');
2013
- }
2014
- if (this.path.substring(0, 4) === 'http') {
2015
- this.url = this.path.replace('{format}', 'json');
2016
- } else {
2017
- this.url = this.api.basePath + this.path.replace('{format}', 'json');
2018
- }
2019
- this.api.progress('fetching resource ' + this.name + ': ' + this.url);
2020
- var obj = {
2021
- url: this.url,
2022
- method: 'GET',
2023
- useJQuery: this.useJQuery,
2024
- headers: {
2025
- accept: this.swaggerRequstHeaders
2026
- },
2027
- on: {
2028
- response: function (resp) {
2029
- var responseObj = resp.obj || JSON.parse(resp.data);
2030
- _this.api.resourceCount += 1;
2031
- return _this.addApiDeclaration(responseObj);
2032
- },
2033
- error: function (response) {
2034
- _this.api.resourceCount += 1;
2035
- return _this.api.fail('Unable to read api \'' +
2036
- _this.name + '\' from path ' + _this.url + ' (server returned ' + response.statusText + ')');
2037
- }
2038
- }
2039
- };
2040
- var e = typeof window !== 'undefined' ? window : exports;
2041
- e.authorizations.apply(obj);
2042
- new SwaggerHttp().execute(obj);
2043
- }
2044
- };
2045
-
2046
- SwaggerResource.prototype.help = function (dontPrint) {
2047
- var i;
2048
- var output = 'operations for the "' + this.name + '" tag';
2049
- for(i = 0; i < this.operationsArray.length; i++) {
2050
- var api = this.operationsArray[i];
2051
- output += '\n * ' + api.nickname + ': ' + api.description;
2052
- }
2053
- if(dontPrint)
2054
- return output;
2055
- else {
2056
- log(output);
2057
- return output;
2058
- }
2059
- };
2060
-
2061
- SwaggerResource.prototype.getAbsoluteBasePath = function (relativeBasePath) {
2062
- var pos, url;
2063
- url = this.api.basePath;
2064
- pos = url.lastIndexOf(relativeBasePath);
2065
- var parts = url.split('/');
2066
- var rootUrl = parts[0] + '//' + parts[2];
2067
-
2068
- if (relativeBasePath.indexOf('http') === 0)
2069
- return relativeBasePath;
2070
- if (relativeBasePath === '/')
2071
- return rootUrl;
2072
- if (relativeBasePath.substring(0, 1) == '/') {
2073
- // use root + relative
2074
- return rootUrl + relativeBasePath;
2075
- }
2076
- else {
2077
- pos = this.basePath.lastIndexOf('/');
2078
- var base = this.basePath.substring(0, pos);
2079
- if (base.substring(base.length - 1) == '/')
2080
- return base + relativeBasePath;
2081
- else
2082
- return base + '/' + relativeBasePath;
2083
- }
2084
- };
2085
-
2086
- SwaggerResource.prototype.addApiDeclaration = function (response) {
2087
- if (typeof response.produces === 'string')
2088
- this.produces = response.produces;
2089
- if (typeof response.consumes === 'string')
2090
- this.consumes = response.consumes;
2091
- if ((typeof response.basePath === 'string') && response.basePath.replace(/\s/g, '').length > 0)
2092
- this.basePath = response.basePath.indexOf('http') === -1 ? this.getAbsoluteBasePath(response.basePath) : response.basePath;
2093
- this.resourcePath = response.resourcePath;
2094
- this.addModels(response.models);
2095
- if (response.apis) {
2096
- for (var i = 0 ; i < response.apis.length; i++) {
2097
- var endpoint = response.apis[i];
2098
- this.addOperations(endpoint.path, endpoint.operations, response.consumes, response.produces);
2099
- }
2100
- }
2101
- this.api[this.name] = this;
2102
- this.ready = true;
2103
- if(this.api.resourceCount === this.api.expectedResourceCount)
2104
- this.api.finish();
2105
- return this;
2106
- };
2107
-
2108
- SwaggerResource.prototype.addModels = function (models) {
2109
- if (typeof models === 'object') {
2110
- var modelName;
2111
- for (modelName in models) {
2112
- if (typeof this.models[modelName] === 'undefined') {
2113
- var swaggerModel = new SwaggerModel(modelName, models[modelName]);
2114
- this.modelsArray.push(swaggerModel);
2115
- this.models[modelName] = swaggerModel;
2116
- this.rawModels[modelName] = models[modelName];
2117
- }
2118
- }
2119
- var output = [];
2120
- for (var i = 0; i < this.modelsArray.length; i++) {
2121
- var model = this.modelsArray[i];
2122
- output.push(model.setReferencedModels(this.models));
2123
- }
2124
- return output;
2125
- }
2126
- };
2127
-
2128
- SwaggerResource.prototype.addOperations = function (resource_path, ops, consumes, produces) {
2129
- if (ops) {
2130
- var output = [];
2131
- for (var i = 0; i < ops.length; i++) {
2132
- var o = ops[i];
2133
- consumes = this.consumes;
2134
- produces = this.produces;
2135
- if (typeof o.consumes !== 'undefined')
2136
- consumes = o.consumes;
2137
- else
2138
- consumes = this.consumes;
2139
-
2140
- if (typeof o.produces !== 'undefined')
2141
- produces = o.produces;
2142
- else
2143
- produces = this.produces;
2144
- var type = (o.type || o.responseClass);
2145
-
2146
- if (type === 'array') {
2147
- ref = null;
2148
- if (o.items)
2149
- ref = o.items.type || o.items.$ref;
2150
- type = 'array[' + ref + ']';
2151
- }
2152
- var responseMessages = o.responseMessages;
2153
- var method = o.method;
2154
- if (o.httpMethod) {
2155
- method = o.httpMethod;
2156
- }
2157
- if (o.supportedContentTypes) {
2158
- consumes = o.supportedContentTypes;
2159
- }
2160
- if (o.errorResponses) {
2161
- responseMessages = o.errorResponses;
2162
- for (var j = 0; j < responseMessages.length; j++) {
2163
- r = responseMessages[j];
2164
- r.message = r.reason;
2165
- r.reason = null;
2166
- }
2167
- }
2168
- o.nickname = this.sanitize(o.nickname);
2169
- var op = new SwaggerOperation(o.nickname,
2170
- resource_path,
2171
- method,
2172
- o.parameters,
2173
- o.summary,
2174
- o.notes,
2175
- type,
2176
- responseMessages,
2177
- this,
2178
- consumes,
2179
- produces,
2180
- o.authorizations,
2181
- o.deprecated);
2182
-
2183
- this.operations[op.nickname] = op;
2184
- output.push(this.operationsArray.push(op));
2185
- }
2186
- return output;
2187
- }
2188
- };
2189
-
2190
- SwaggerResource.prototype.sanitize = function (nickname) {
2191
- var op;
2192
- op = nickname.replace(/[\s!@#$%^&*()_+=\[{\]};:<>|.\/?,\\'""-]/g, '_');
2193
- op = op.replace(/((_){2,})/g, '_');
2194
- op = op.replace(/^(_)*/g, '');
2195
- op = op.replace(/([_])*$/g, '');
2196
- return op;
2197
- };
2198
-
2199
- var SwaggerModel = function (modelName, obj) {
2200
- this.name = typeof obj.id !== 'undefined' ? obj.id : modelName;
2201
- this.properties = [];
2202
- var propertyName;
2203
- for (propertyName in obj.properties) {
2204
- if (obj.required) {
2205
- var value;
2206
- for (value in obj.required) {
2207
- if (propertyName === obj.required[value]) {
2208
- obj.properties[propertyName].required = true;
2209
- }
2210
- }
2211
- }
2212
- var prop = new SwaggerModelProperty(propertyName, obj.properties[propertyName], this);
2213
- this.properties.push(prop);
2214
- }
2215
- };
2216
-
2217
- SwaggerModel.prototype.setReferencedModels = function (allModels) {
2218
- var results = [];
2219
- for (var i = 0; i < this.properties.length; i++) {
2220
- var property = this.properties[i];
2221
- var type = property.type || property.dataType;
2222
- if (allModels[type])
2223
- results.push(property.refModel = allModels[type]);
2224
- else if ((property.refDataType) && (allModels[property.refDataType]))
2225
- results.push(property.refModel = allModels[property.refDataType]);
2226
- else
2227
- results.push(void 0);
2228
- }
2229
- return results;
2230
- };
2231
-
2232
- SwaggerModel.prototype.getMockSignature = function (modelsToIgnore) {
2233
- var i, prop, propertiesStr = [];
2234
- for (i = 0; i < this.properties.length; i++) {
2235
- prop = this.properties[i];
2236
- propertiesStr.push(prop.toString());
2237
- }
2238
-
2239
- var strong = '<span class="strong">';
2240
- var strongClose = '</span>';
2241
- var classOpen = strong + this.name + ' {' + strongClose;
2242
- var classClose = strong + '}' + strongClose;
2243
- var returnVal = classOpen + '<div>' + propertiesStr.join(',</div><div>') + '</div>' + classClose;
2244
- if (!modelsToIgnore)
2245
- modelsToIgnore = [];
2246
- modelsToIgnore.push(this.name);
2247
-
2248
- for (i = 0; i < this.properties.length; i++) {
2249
- prop = this.properties[i];
2250
- if ((prop.refModel) && modelsToIgnore.indexOf(prop.refModel.name) === -1) {
2251
- returnVal = returnVal + ('<br>' + prop.refModel.getMockSignature(modelsToIgnore));
2252
- }
2253
- }
2254
- return returnVal;
2255
- };
2256
-
2257
- SwaggerModel.prototype.createJSONSample = function (modelsToIgnore) {
2258
- if (sampleModels[this.name]) {
2259
- return sampleModels[this.name];
2260
- }
2261
- else {
2262
- var result = {};
2263
- modelsToIgnore = (modelsToIgnore || []);
2264
- modelsToIgnore.push(this.name);
2265
- for (var i = 0; i < this.properties.length; i++) {
2266
- var prop = this.properties[i];
2267
- result[prop.name] = prop.getSampleValue(modelsToIgnore);
2268
- }
2269
- modelsToIgnore.pop(this.name);
2270
- return result;
2271
- }
2272
- };
2273
-
2274
- var SwaggerModelProperty = function (name, obj, model) {
2275
- this.name = name;
2276
- this.dataType = obj.type || obj.dataType || obj.$ref;
2277
- this.isCollection = this.dataType && (this.dataType.toLowerCase() === 'array' || this.dataType.toLowerCase() === 'list' || this.dataType.toLowerCase() === 'set');
2278
- this.descr = obj.description;
2279
- this.required = obj.required;
2280
- this.defaultValue = applyModelPropertyMacro(obj, model);
2281
- if (obj.items) {
2282
- if (obj.items.type) {
2283
- this.refDataType = obj.items.type;
2284
- }
2285
- if (obj.items.$ref) {
2286
- this.refDataType = obj.items.$ref;
2287
- }
2288
- }
2289
- this.dataTypeWithRef = this.refDataType ? (this.dataType + '[' + this.refDataType + ']') : this.dataType;
2290
- if (obj.allowableValues) {
2291
- this.valueType = obj.allowableValues.valueType;
2292
- this.values = obj.allowableValues.values;
2293
- if (this.values) {
2294
- this.valuesString = '\'' + this.values.join('\' or \'') + '\'';
2295
- }
2296
- }
2297
- if (obj['enum']) {
2298
- this.valueType = 'string';
2299
- this.values = obj['enum'];
2300
- if (this.values) {
2301
- this.valueString = '\'' + this.values.join('\' or \'') + '\'';
2302
- }
2303
- }
2304
- };
2305
-
2306
- SwaggerModelProperty.prototype.getSampleValue = function (modelsToIgnore) {
2307
- var result;
2308
- if ((this.refModel) && (modelsToIgnore.indexOf(this.refModel.name) === -1)) {
2309
- result = this.refModel.createJSONSample(modelsToIgnore);
2310
- } else {
2311
- if (this.isCollection) {
2312
- result = this.toSampleValue(this.refDataType);
2313
- } else {
2314
- result = this.toSampleValue(this.dataType);
2315
- }
2316
- }
2317
- if (this.isCollection) {
2318
- return [result];
2319
- } else {
2320
- return result;
2321
- }
2322
- };
2323
-
2324
- SwaggerModelProperty.prototype.toSampleValue = function (value) {
2325
- var result;
2326
- if ((typeof this.defaultValue !== 'undefined') && this.defaultValue) {
2327
- result = this.defaultValue;
2328
- } else if (value === 'integer') {
2329
- result = 0;
2330
- } else if (value === 'boolean') {
2331
- result = false;
2332
- } else if (value === 'double' || value === 'number') {
2333
- result = 0.0;
2334
- } else if (value === 'string') {
2335
- result = '';
2336
- } else {
2337
- result = value;
2338
- }
2339
- return result;
2340
- };
2341
-
2342
- SwaggerModelProperty.prototype.toString = function () {
2343
- var req = this.required ? 'propReq' : 'propOpt';
2344
- var str = '<span class="propName ' + req + '">' + this.name + '</span> (<span class="propType">' + this.dataTypeWithRef + '</span>';
2345
- if (!this.required) {
2346
- str += ', <span class="propOptKey">optional</span>';
2347
- }
2348
- str += ')';
2349
- if (this.values) {
2350
- str += ' = <span class="propVals">[\'' + this.values.join('\' or \'') + '\']</span>';
2351
- }
2352
- if (this.descr) {
2353
- str += ': <span class="propDesc">' + this.descr + '</span>';
2354
- }
2355
- return str;
2356
- };
2357
-
2358
- var SwaggerOperation = function (nickname, path, method, parameters, summary, notes, type, responseMessages, resource, consumes, produces, authorizations, deprecated) {
2359
- var _this = this;
2360
-
2361
- var errors = [];
2362
- this.nickname = (nickname || errors.push('SwaggerOperations must have a nickname.'));
2363
- this.path = (path || errors.push('SwaggerOperation ' + nickname + ' is missing path.'));
2364
- this.method = (method || errors.push('SwaggerOperation ' + nickname + ' is missing method.'));
2365
- this.parameters = parameters ? parameters : [];
2366
- this.summary = summary;
2367
- this.notes = notes;
2368
- this.type = type;
2369
- this.responseMessages = (responseMessages || []);
2370
- this.resource = (resource || errors.push('Resource is required'));
2371
- this.consumes = consumes;
2372
- this.produces = produces;
2373
- this.authorizations = typeof authorizations !== 'undefined' ? authorizations : resource.authorizations;
2374
- this.deprecated = deprecated;
2375
- this['do'] = __bind(this['do'], this);
2376
-
2377
-
2378
- if(typeof this.deprecated === 'string') {
2379
- switch(this.deprecated.toLowerCase()) {
2380
- case 'true': case 'yes': case '1': {
2381
- this.deprecated = true;
2382
- break;
2383
- }
2384
- case 'false': case 'no': case '0': case null: {
2385
- this.deprecated = false;
2386
- break;
2387
- }
2388
- default: this.deprecated = Boolean(this.deprecated);
2389
- }
2390
- }
2391
-
2392
- if (errors.length > 0) {
2393
- console.error('SwaggerOperation errors', errors, arguments);
2394
- this.resource.api.fail(errors);
2395
- }
2396
-
2397
- this.path = this.path.replace('{format}', 'json');
2398
- this.method = this.method.toLowerCase();
2399
- this.isGetMethod = this.method === 'get';
2400
-
2401
- var i, j, v;
2402
- this.resourceName = this.resource.name;
2403
- if (typeof this.type !== 'undefined' && this.type === 'void')
2404
- this.type = null;
2405
- else {
2406
- this.responseClassSignature = this.getSignature(this.type, this.resource.models);
2407
- this.responseSampleJSON = this.getSampleJSON(this.type, this.resource.models);
2408
- }
2409
-
2410
- for (i = 0; i < this.parameters.length; i++) {
2411
- var param = this.parameters[i];
2412
- // might take this away
2413
- param.name = param.name || param.type || param.dataType;
2414
- // for 1.1 compatibility
2415
- type = param.type || param.dataType;
2416
- if (type === 'array') {
2417
- type = 'array[' + (param.items.$ref ? param.items.$ref : param.items.type) + ']';
2418
- }
2419
- param.type = type;
2420
-
2421
- if (type && type.toLowerCase() === 'boolean') {
2422
- param.allowableValues = {};
2423
- param.allowableValues.values = ['true', 'false'];
2424
- }
2425
- param.signature = this.getSignature(type, this.resource.models);
2426
- param.sampleJSON = this.getSampleJSON(type, this.resource.models);
2427
-
2428
- var enumValue = param['enum'];
2429
- if (typeof enumValue !== 'undefined') {
2430
- param.isList = true;
2431
- param.allowableValues = {};
2432
- param.allowableValues.descriptiveValues = [];
2433
-
2434
- for (j = 0; j < enumValue.length; j++) {
2435
- v = enumValue[j];
2436
- if (param.defaultValue) {
2437
- param.allowableValues.descriptiveValues.push({
2438
- value: String(v),
2439
- isDefault: (v === param.defaultValue)
2440
- });
2441
- }
2442
- else {
2443
- param.allowableValues.descriptiveValues.push({
2444
- value: String(v),
2445
- isDefault: false
2446
- });
2447
- }
2448
- }
2449
- }
2450
- else if (param.allowableValues) {
2451
- if (param.allowableValues.valueType === 'RANGE')
2452
- param.isRange = true;
2453
- else
2454
- param.isList = true;
2455
- if (param.allowableValues) {
2456
- param.allowableValues.descriptiveValues = [];
2457
- if (param.allowableValues.values) {
2458
- for (j = 0; j < param.allowableValues.values.length; j++) {
2459
- v = param.allowableValues.values[j];
2460
- if (param.defaultValue !== null) {
2461
- param.allowableValues.descriptiveValues.push({
2462
- value: String(v),
2463
- isDefault: (v === param.defaultValue)
2464
- });
2465
- }
2466
- else {
2467
- param.allowableValues.descriptiveValues.push({
2468
- value: String(v),
2469
- isDefault: false
2470
- });
2471
- }
2472
- }
2473
- }
2474
- }
2475
- }
2476
- param.defaultValue = applyParameterMacro(this, param);
2477
- }
2478
- var defaultSuccessCallback = this.resource.api.defaultSuccessCallback || null;
2479
- var defaultErrorCallback = this.resource.api.defaultErrorCallback || null;
2480
-
2481
- this.resource[this.nickname] = function (args, opts, callback, error) {
2482
- var arg1, arg2, arg3, arg4;
2483
- if(typeof args === 'function') { // right shift 3
2484
- arg1 = {}; arg2 = {}; arg3 = args; arg4 = opts;
2485
- }
2486
- else if(typeof args === 'object' && typeof opts === 'function') { // right shift 2
2487
- arg1 = args; arg2 = {}; arg3 = opts; arg4 = callback;
2488
- }
2489
- else {
2490
- arg1 = args; arg2 = opts; arg3 = callback; arg4 = error;
2491
- }
2492
- return _this['do'](arg1 || {}, arg2 || {}, arg3 || defaultSuccessCallback, arg4 || defaultErrorCallback);
2493
- };
2494
-
2495
- this.resource[this.nickname].help = function (dontPrint) {
2496
- return _this.help(dontPrint);
2497
- };
2498
- this.resource[this.nickname].asCurl = function (args) {
2499
- return _this.asCurl(args);
2500
- };
2501
- };
2502
-
2503
- SwaggerOperation.prototype.isListType = function (type) {
2504
- if (type && type.indexOf('[') >= 0) {
2505
- return type.substring(type.indexOf('[') + 1, type.indexOf(']'));
2506
- } else {
2507
- return void 0;
2508
- }
2509
- };
2510
-
2511
- SwaggerOperation.prototype.getSignature = function (type, models) {
2512
- var isPrimitive, listType;
2513
- listType = this.isListType(type);
2514
- isPrimitive = ((typeof listType !== 'undefined') && models[listType]) || (typeof models[type] !== 'undefined') ? false : true;
2515
- if (isPrimitive) {
2516
- return type;
2517
- } else {
2518
- if (typeof listType !== 'undefined') {
2519
- return models[listType].getMockSignature();
2520
- } else {
2521
- return models[type].getMockSignature();
2522
- }
2523
- }
2524
- };
2525
-
2526
- SwaggerOperation.prototype.getSampleJSON = function (type, models) {
2527
- var isPrimitive, listType, val;
2528
- listType = this.isListType(type);
2529
- isPrimitive = ((typeof listType !== 'undefined') && models[listType]) || (typeof models[type] !== 'undefined') ? false : true;
2530
- val = isPrimitive ? void 0 : (listType ? models[listType].createJSONSample() : models[type].createJSONSample());
2531
- if (val) {
2532
- val = listType ? [val] : val;
2533
- if (typeof val == 'string')
2534
- return val;
2535
- else if (typeof val === 'object') {
2536
- var t = val;
2537
- if (val instanceof Array && val.length > 0) {
2538
- t = val[0];
2539
- }
2540
- if (t.nodeName) {
2541
- var xmlString = new XMLSerializer().serializeToString(t);
2542
- return this.formatXml(xmlString);
2543
- }
2544
- else
2545
- return JSON.stringify(val, null, 2);
2546
- }
2547
- else
2548
- return val;
2549
- }
2550
- };
2551
-
2552
- SwaggerOperation.prototype['do'] = function (args, opts, callback, error) {
2553
- var key, param, params, possibleParams = [], req, value;
2554
-
2555
- if (typeof error !== 'function') {
2556
- error = function (xhr, textStatus, error) {
2557
- return log(xhr, textStatus, error);
2558
- };
2559
- }
2560
-
2561
- if (typeof callback !== 'function') {
2562
- callback = function (response) {
2563
- var content;
2564
- content = null;
2565
- if (response !== null) {
2566
- content = response.data;
2567
- } else {
2568
- content = 'no data';
2569
- }
2570
- return log('default callback: ' + content);
2571
- };
2572
- }
2573
-
2574
- params = {};
2575
- params.headers = [];
2576
- if (args.headers) {
2577
- params.headers = args.headers;
2578
- delete args.headers;
2579
- }
2580
- // allow override from the opts
2581
- if(opts && opts.responseContentType) {
2582
- params.headers['Content-Type'] = opts.responseContentType;
2583
- }
2584
- if(opts && opts.requestContentType) {
2585
- params.headers.Accept = opts.requestContentType;
2586
- }
2587
-
2588
- for (var i = 0; i < this.parameters.length; i++) {
2589
- param = this.parameters[i];
2590
- if (param.paramType === 'header') {
2591
- if (typeof args[param.name] !== 'undefined')
2592
- params.headers[param.name] = args[param.name];
2593
- }
2594
- else if (param.paramType === 'form' || param.paramType.toLowerCase() === 'file')
2595
- possibleParams.push(param);
2596
- else if (param.paramType === 'body' && param.name !== 'body' && typeof args[param.name] !== 'undefined') {
2597
- if (args.body) {
2598
- throw new Error('Saw two body params in an API listing; expecting a max of one.');
2599
- }
2600
- args.body = args[param.name];
2601
- }
2602
- }
2603
-
2604
- if (typeof args.body !== 'undefined') {
2605
- params.body = args.body;
2606
- delete args.body;
2607
- }
2608
-
2609
- if (possibleParams) {
2610
- for (key in possibleParams) {
2611
- value = possibleParams[key];
2612
- if (args[value.name]) {
2613
- params[value.name] = args[value.name];
2614
- }
2615
- }
2616
- }
2617
-
2618
- req = new SwaggerRequest(this.method, this.urlify(args), params, opts, callback, error, this);
2619
- if (opts.mock) {
2620
- return req;
2621
- } else {
2622
- return true;
2623
- }
2624
- };
2625
-
2626
- SwaggerOperation.prototype.pathJson = function () {
2627
- return this.path.replace('{format}', 'json');
2628
- };
2629
-
2630
- SwaggerOperation.prototype.pathXml = function () {
2631
- return this.path.replace('{format}', 'xml');
2632
- };
2633
-
2634
- SwaggerOperation.prototype.encodePathParam = function (pathParam) {
2635
- var encParts, part, parts, _i, _len;
2636
- pathParam = pathParam.toString();
2637
- if (pathParam.indexOf('/') === -1) {
2638
- return encodeURIComponent(pathParam);
2639
- } else {
2640
- parts = pathParam.split('/');
2641
- encParts = [];
2642
- for (_i = 0, _len = parts.length; _i < _len; _i++) {
2643
- part = parts[_i];
2644
- encParts.push(encodeURIComponent(part));
2645
- }
2646
- return encParts.join('/');
2647
- }
2648
- };
2649
-
2650
- SwaggerOperation.prototype.urlify = function (args) {
2651
- var i, j, param, url;
2652
- // ensure no double slashing...
2653
- if(this.resource.basePath.length > 1 && this.resource.basePath.slice(-1) === '/' && this.pathJson().charAt(0) === '/')
2654
- url = this.resource.basePath + this.pathJson().substring(1);
2655
- else
2656
- url = this.resource.basePath + this.pathJson();
2657
- var params = this.parameters;
2658
- for (i = 0; i < params.length; i++) {
2659
- param = params[i];
2660
- if (param.paramType === 'path') {
2661
- if (typeof args[param.name] !== 'undefined') {
2662
- // apply path params and remove from args
2663
- var reg = new RegExp('\\{\\s*?' + param.name + '[^\\{\\}\\/]*(?:\\{.*?\\}[^\\{\\}\\/]*)*\\}(?=(\\/?|$))', 'gi');
2664
- url = url.replace(reg, this.encodePathParam(args[param.name]));
2665
- delete args[param.name];
2666
- }
2667
- else
2668
- throw '' + param.name + ' is a required path param.';
2669
- }
2670
- }
2671
-
2672
- var queryParams = '';
2673
- for (i = 0; i < params.length; i++) {
2674
- param = params[i];
2675
- if(param.paramType === 'query') {
2676
- if (queryParams !== '')
2677
- queryParams += '&';
2678
- if (Array.isArray(param)) {
2679
- var output = '';
2680
- for(j = 0; j < param.length; j++) {
2681
- if(j > 0)
2682
- output += ',';
2683
- output += encodeURIComponent(param[j]);
2684
- }
2685
- queryParams += encodeURIComponent(param.name) + '=' + output;
2686
- }
2687
- else {
2688
- if (typeof args[param.name] !== 'undefined') {
2689
- queryParams += encodeURIComponent(param.name) + '=' + encodeURIComponent(args[param.name]);
2690
- } else {
2691
- if (param.required)
2692
- throw '' + param.name + ' is a required query param.';
2693
- }
2694
- }
2695
- }
2696
- }
2697
- if ((queryParams) && queryParams.length > 0)
2698
- url += '?' + queryParams;
2699
- return url;
2700
- };
2701
-
2702
- SwaggerOperation.prototype.supportHeaderParams = function () {
2703
- return this.resource.api.supportHeaderParams;
2704
- };
2705
-
2706
- SwaggerOperation.prototype.supportedSubmitMethods = function () {
2707
- return this.resource.api.supportedSubmitMethods;
2708
- };
2709
-
2710
- SwaggerOperation.prototype.getQueryParams = function (args) {
2711
- return this.getMatchingParams(['query'], args);
2712
- };
2713
-
2714
- SwaggerOperation.prototype.getHeaderParams = function (args) {
2715
- return this.getMatchingParams(['header'], args);
2716
- };
2717
-
2718
- SwaggerOperation.prototype.getMatchingParams = function (paramTypes, args) {
2719
- var matchingParams = {};
2720
- var params = this.parameters;
2721
- for (var i = 0; i < params.length; i++) {
2722
- param = params[i];
2723
- if (args && args[param.name])
2724
- matchingParams[param.name] = args[param.name];
2725
- }
2726
- var headers = this.resource.api.headers;
2727
- var name;
2728
- for (name in headers) {
2729
- var value = headers[name];
2730
- matchingParams[name] = value;
2731
- }
2732
- return matchingParams;
2733
- };
2734
-
2735
- SwaggerOperation.prototype.help = function (dontPrint) {
2736
- var msg = this.nickname + ': ' + this.summary;
2737
- var params = this.parameters;
2738
- for (var i = 0; i < params.length; i++) {
2739
- var param = params[i];
2740
- msg += '\n* ' + param.name + (param.required ? ' (required)' : '') + " - " + param.description;
2741
- }
2742
- if(dontPrint)
2743
- return msg;
2744
- else {
2745
- console.log(msg);
2746
- return msg;
2747
- }
2748
- };
2749
-
2750
- SwaggerOperation.prototype.asCurl = function (args) {
2751
- var results = [];
2752
- var i;
2753
-
2754
- var headers = SwaggerRequest.prototype.setHeaders(args, {}, this);
2755
- for(i = 0; i < this.parameters.length; i++) {
2756
- var param = this.parameters[i];
2757
- if(param.paramType && param.paramType === 'header' && args[param.name]) {
2758
- headers[param.name] = args[param.name];
2759
- }
2760
- }
2761
-
2762
- var key;
2763
- for (key in headers) {
2764
- results.push('--header "' + key + ': ' + headers[key] + '"');
2765
- }
2766
- return 'curl ' + (results.join(' ')) + ' ' + this.urlify(args);
2767
- };
2768
-
2769
- SwaggerOperation.prototype.formatXml = function (xml) {
2770
- var contexp, formatted, indent, lastType, lines, ln, pad, reg, transitions, wsexp, _fn, _i, _len;
2771
- reg = /(>)(<)(\/*)/g;
2772
- wsexp = /[ ]*(.*)[ ]+\n/g;
2773
- contexp = /(<.+>)(.+\n)/g;
2774
- xml = xml.replace(reg, '$1\n$2$3').replace(wsexp, '$1\n').replace(contexp, '$1\n$2');
2775
- pad = 0;
2776
- formatted = '';
2777
- lines = xml.split('\n');
2778
- indent = 0;
2779
- lastType = 'other';
2780
- transitions = {
2781
- 'single->single': 0,
2782
- 'single->closing': -1,
2783
- 'single->opening': 0,
2784
- 'single->other': 0,
2785
- 'closing->single': 0,
2786
- 'closing->closing': -1,
2787
- 'closing->opening': 0,
2788
- 'closing->other': 0,
2789
- 'opening->single': 1,
2790
- 'opening->closing': 0,
2791
- 'opening->opening': 1,
2792
- 'opening->other': 1,
2793
- 'other->single': 0,
2794
- 'other->closing': -1,
2795
- 'other->opening': 0,
2796
- 'other->other': 0
2797
- };
2798
- _fn = function (ln) {
2799
- var fromTo, j, key, padding, type, types, value;
2800
- types = {
2801
- single: Boolean(ln.match(/<.+\/>/)),
2802
- closing: Boolean(ln.match(/<\/.+>/)),
2803
- opening: Boolean(ln.match(/<[^!?].*>/))
2804
- };
2805
- type = ((function () {
2806
- var _results;
2807
- _results = [];
2808
- for (key in types) {
2809
- value = types[key];
2810
- if (value) {
2811
- _results.push(key);
2812
- }
2813
- }
2814
- return _results;
2815
- })())[0];
2816
- type = type === void 0 ? 'other' : type;
2817
- fromTo = lastType + '->' + type;
2818
- lastType = type;
2819
- padding = '';
2820
- indent += transitions[fromTo];
2821
- padding = ((function () {
2822
- var _j, _ref5, _results;
2823
- _results = [];
2824
- for (j = _j = 0, _ref5 = indent; 0 <= _ref5 ? _j < _ref5 : _j > _ref5; j = 0 <= _ref5 ? ++_j : --_j) {
2825
- _results.push(' ');
2826
- }
2827
- return _results;
2828
- })()).join('');
2829
- if (fromTo === 'opening->closing') {
2830
- formatted = formatted.substr(0, formatted.length - 1) + ln + '\n';
2831
- } else {
2832
- formatted += padding + ln + '\n';
2833
- }
2834
- };
2835
- for (_i = 0, _len = lines.length; _i < _len; _i++) {
2836
- ln = lines[_i];
2837
- _fn(ln);
2838
- }
2839
- return formatted;
2840
- };
2841
-
2842
- var SwaggerRequest = function (type, url, params, opts, successCallback, errorCallback, operation, execution) {
2843
- var _this = this;
2844
- var errors = [];
2845
-
2846
- this.useJQuery = (typeof operation.resource.useJQuery !== 'undefined' ? operation.resource.useJQuery : null);
2847
- this.type = (type || errors.push('SwaggerRequest type is required (get/post/put/delete/patch/options).'));
2848
- this.url = (url || errors.push('SwaggerRequest url is required.'));
2849
- this.params = params;
2850
- this.opts = opts;
2851
- this.successCallback = (successCallback || errors.push('SwaggerRequest successCallback is required.'));
2852
- this.errorCallback = (errorCallback || errors.push('SwaggerRequest error callback is required.'));
2853
- this.operation = (operation || errors.push('SwaggerRequest operation is required.'));
2854
- this.execution = execution;
2855
- this.headers = (params.headers || {});
2856
-
2857
- if (errors.length > 0) {
2858
- throw errors;
2859
- }
2860
-
2861
- this.type = this.type.toUpperCase();
2862
-
2863
- // set request, response content type headers
2864
- var headers = this.setHeaders(params, opts, this.operation);
2865
- var body = params.body;
2866
-
2867
- // encode the body for form submits
2868
- if (headers['Content-Type']) {
2869
- var key, value, values = {}, i;
2870
- var operationParams = this.operation.parameters;
2871
- for (i = 0; i < operationParams.length; i++) {
2872
- var param = operationParams[i];
2873
- if (param.paramType === 'form')
2874
- values[param.name] = param;
2875
- }
2876
-
2877
- if (headers['Content-Type'].indexOf('application/x-www-form-urlencoded') === 0) {
2878
- var encoded = '';
2879
- for (key in values) {
2880
- value = this.params[key];
2881
- if (typeof value !== 'undefined') {
2882
- if (encoded !== '')
2883
- encoded += '&';
2884
- encoded += encodeURIComponent(key) + '=' + encodeURIComponent(value);
2885
- }
2886
- }
2887
- body = encoded;
2888
- }
2889
- else if (headers['Content-Type'].indexOf('multipart/form-data') === 0) {
2890
- // encode the body for form submits
2891
- var data = '';
2892
- var boundary = '----SwaggerFormBoundary' + Date.now();
2893
- for (key in values) {
2894
- value = this.params[key];
2895
- if (typeof value !== 'undefined') {
2896
- data += '--' + boundary + '\n';
2897
- data += 'Content-Disposition: form-data; name="' + key + '"';
2898
- data += '\n\n';
2899
- data += value + '\n';
2900
- }
2901
- }
2902
- data += '--' + boundary + '--\n';
2903
- headers['Content-Type'] = 'multipart/form-data; boundary=' + boundary;
2904
- body = data;
2905
- }
2906
- }
2907
-
2908
- var obj;
2909
- if (!((this.headers) && (this.headers.mock))) {
2910
- obj = {
2911
- url: this.url,
2912
- method: this.type,
2913
- headers: headers,
2914
- body: body,
2915
- useJQuery: this.useJQuery,
2916
- on: {
2917
- error: function (response) {
2918
- return _this.errorCallback(response, _this.opts.parent);
2919
- },
2920
- redirect: function (response) {
2921
- return _this.successCallback(response, _this.opts.parent);
2922
- },
2923
- 307: function (response) {
2924
- return _this.successCallback(response, _this.opts.parent);
2925
- },
2926
- response: function (response) {
2927
- return _this.successCallback(response, _this.opts.parent);
2928
- }
2929
- }
2930
- };
2931
-
2932
- var status = false;
2933
- if (this.operation.resource && this.operation.resource.api && this.operation.resource.api.clientAuthorizations) {
2934
- // Get the client authorizations from the resource declaration
2935
- status = this.operation.resource.api.clientAuthorizations.apply(obj, this.operation.authorizations);
2936
- } else {
2937
- // Get the client authorization from the default authorization declaration
2938
- var e;
2939
- if (typeof window !== 'undefined') {
2940
- e = window;
2941
- } else {
2942
- e = exports;
2943
- }
2944
- status = e.authorizations.apply(obj, this.operation.authorizations);
2945
- }
2946
-
2947
- if (!opts.mock) {
2948
- if (status !== false) {
2949
- new SwaggerHttp().execute(obj);
2950
- } else {
2951
- obj.canceled = true;
2952
- }
2953
- } else {
2954
- return obj;
2955
- }
2956
- }
2957
- return obj;
2958
- };
2959
-
2960
- SwaggerRequest.prototype.setHeaders = function (params, opts, operation) {
2961
- // default type
2962
- var accepts = opts.responseContentType || 'application/json';
2963
- var consumes = opts.requestContentType || 'application/json';
2964
-
2965
- var allDefinedParams = operation.parameters;
2966
- var definedFormParams = [];
2967
- var definedFileParams = [];
2968
- var body = params.body;
2969
- var headers = {};
2970
-
2971
- // get params from the operation and set them in definedFileParams, definedFormParams, headers
2972
- var i;
2973
- for (i = 0; i < allDefinedParams.length; i++) {
2974
- var param = allDefinedParams[i];
2975
- if (param.paramType === 'form')
2976
- definedFormParams.push(param);
2977
- else if (param.paramType === 'file')
2978
- definedFileParams.push(param);
2979
- else if (param.paramType === 'header' && this.params.headers) {
2980
- var key = param.name;
2981
- var headerValue = this.params.headers[param.name];
2982
- if (typeof this.params.headers[param.name] !== 'undefined')
2983
- headers[key] = headerValue;
2984
- }
2985
- }
2986
-
2987
- // if there's a body, need to set the accepts header via requestContentType
2988
- if (body && (this.type === 'POST' || this.type === 'PUT' || this.type === 'PATCH' || this.type === 'DELETE')) {
2989
- if (this.opts.requestContentType)
2990
- consumes = this.opts.requestContentType;
2991
- } else {
2992
- // if any form params, content type must be set
2993
- if (definedFormParams.length > 0) {
2994
- if (definedFileParams.length > 0)
2995
- consumes = 'multipart/form-data';
2996
- else
2997
- consumes = 'application/x-www-form-urlencoded';
2998
- }
2999
- else if (this.type === 'DELETE')
3000
- body = '{}';
3001
- else if (this.type != 'DELETE')
3002
- consumes = null;
3003
- }
3004
-
3005
- if (consumes && this.operation.consumes) {
3006
- if (this.operation.consumes.indexOf(consumes) === -1) {
3007
- log('server doesn\'t consume ' + consumes + ', try ' + JSON.stringify(this.operation.consumes));
3008
- }
3009
- }
3010
-
3011
- if (this.opts && this.opts.responseContentType) {
3012
- accepts = this.opts.responseContentType;
3013
- } else {
3014
- accepts = 'application/json';
3015
- }
3016
- if (accepts && operation.produces) {
3017
- if (operation.produces.indexOf(accepts) === -1) {
3018
- log('server can\'t produce ' + accepts);
3019
- }
3020
- }
3021
-
3022
- if ((consumes && body !== '') || (consumes === 'application/x-www-form-urlencoded'))
3023
- headers['Content-Type'] = consumes;
3024
- if (accepts)
3025
- headers.Accept = accepts;
3026
- return headers;
3027
- };
3028
-
3029
- /**
3030
- * SwaggerHttp is a wrapper for executing requests
3031
- */
3032
- var SwaggerHttp = function() {};
3033
-
3034
- SwaggerHttp.prototype.execute = function(obj, opts) {
3035
- if(obj && (typeof obj.useJQuery === 'boolean'))
3036
- this.useJQuery = obj.useJQuery;
3037
- else
3038
- this.useJQuery = this.isIE8();
3039
-
3040
- if(obj && typeof obj.body === 'object') {
3041
- if(obj.body.type && obj.body.type !== 'formData')
3042
- obj.body = JSON.stringify(obj.body);
3043
- else {
3044
- obj.contentType = false;
3045
- obj.processData = false;
3046
- // delete obj.cache;
3047
- delete obj.headers['Content-Type'];
3048
- }
3049
- }
3050
-
3051
- if(this.useJQuery)
3052
- return new JQueryHttpClient(opts).execute(obj);
3053
- else
3054
- return new ShredHttpClient(opts).execute(obj);
3055
- };
3056
-
3057
- SwaggerHttp.prototype.isIE8 = function() {
3058
- var detectedIE = false;
3059
- if (typeof navigator !== 'undefined' && navigator.userAgent) {
3060
- nav = navigator.userAgent.toLowerCase();
3061
- if (nav.indexOf('msie') !== -1) {
3062
- var version = parseInt(nav.split('msie')[1]);
3063
- if (version <= 8) {
3064
- detectedIE = true;
3065
- }
3066
- }
3067
- }
3068
- return detectedIE;
3069
- };
3070
-
3071
- /*
3072
- * JQueryHttpClient lets a browser take advantage of JQuery's cross-browser magic.
3073
- * NOTE: when jQuery is available it will export both '$' and 'jQuery' to the global space.
3074
- * Since we are using closures here we need to alias it for internal use.
3075
- */
3076
- var JQueryHttpClient = function(options) {
3077
- "use strict";
3078
- if(!jQuery){
3079
- var jQuery = window.jQuery;
3080
- }
3081
- };
3082
-
3083
- JQueryHttpClient.prototype.execute = function(obj) {
3084
- var cb = obj.on;
3085
- var request = obj;
3086
-
3087
- obj.type = obj.method;
3088
- obj.cache = false;
3089
- delete obj.useJQuery;
3090
-
3091
- /*
3092
- obj.beforeSend = function(xhr) {
3093
- var key, results;
3094
- if (obj.headers) {
3095
- results = [];
3096
- for (key in obj.headers) {
3097
- if (key.toLowerCase() === "content-type") {
3098
- results.push(obj.contentType = obj.headers[key]);
3099
- } else if (key.toLowerCase() === "accept") {
3100
- results.push(obj.accepts = obj.headers[key]);
3101
- } else {
3102
- results.push(xhr.setRequestHeader(key, obj.headers[key]));
3103
- }
3104
- }
3105
- return results;
3106
- }
3107
- };*/
3108
-
3109
- obj.data = obj.body;
3110
- delete obj.body;
3111
- obj.complete = function(response, textStatus, opts) {
3112
- var headers = {},
3113
- headerArray = response.getAllResponseHeaders().split("\n");
3114
-
3115
- for(var i = 0; i < headerArray.length; i++) {
3116
- var toSplit = headerArray[i].trim();
3117
- if(toSplit.length === 0)
3118
- continue;
3119
- var separator = toSplit.indexOf(":");
3120
- if(separator === -1) {
3121
- // Name but no value in the header
3122
- headers[toSplit] = null;
3123
- continue;
3124
- }
3125
- var name = toSplit.substring(0, separator).trim(),
3126
- value = toSplit.substring(separator + 1).trim();
3127
- headers[name] = value;
3128
- }
3129
-
3130
- var out = {
3131
- url: request.url,
3132
- method: request.method,
3133
- status: response.status,
3134
- statusText: response.statusText,
3135
- data: response.responseText,
3136
- headers: headers
3137
- };
3138
-
3139
- var contentType = (headers["content-type"]||headers["Content-Type"]||null);
3140
- if(contentType) {
3141
- if(contentType.indexOf("application/json") === 0 || contentType.indexOf("+json") > 0) {
3142
- try {
3143
- out.obj = response.responseJSON || JSON.parse(out.data) || {};
3144
- } catch (ex) {
3145
- // do not set out.obj
3146
- log("unable to parse JSON content");
3147
- }
3148
- }
3149
- }
3150
-
3151
- if(response.status >= 200 && response.status < 300)
3152
- cb.response(out);
3153
- else if(response.status === 0 || (response.status >= 400 && response.status < 599))
3154
- cb.error(out);
3155
- else
3156
- return cb.response(out);
3157
- };
3158
-
3159
- jQuery.support.cors = true;
3160
- return jQuery.ajax(obj);
3161
- };
3162
-
3163
- /*
3164
- * ShredHttpClient is a light-weight, node or browser HTTP client
3165
- */
3166
- var ShredHttpClient = function(opts) {
3167
- this.opts = (opts||{});
3168
- this.isInitialized = false;
3169
-
3170
- var identity, toString;
3171
-
3172
- if (typeof window !== 'undefined') {
3173
- this.Shred = require("./shred");
3174
- this.content = require("./shred/content");
3175
- }
3176
- else
3177
- this.Shred = require("shred");
3178
- this.shred = new this.Shred(opts);
3179
- };
3180
-
3181
- ShredHttpClient.prototype.initShred = function () {
3182
- this.isInitialized = true;
3183
- this.registerProcessors(this.shred);
3184
- };
3185
-
3186
- ShredHttpClient.prototype.registerProcessors = function(shred) {
3187
- var identity = function(x) {
3188
- return x;
3189
- };
3190
- var toString = function(x) {
3191
- return x.toString();
3192
- };
3193
-
3194
- if (typeof window !== 'undefined') {
3195
- this.content.registerProcessor(["application/json; charset=utf-8", "application/json", "json"], {
3196
- parser: identity,
3197
- stringify: toString
3198
- });
3199
- } else {
3200
- this.Shred.registerProcessor(["application/json; charset=utf-8", "application/json", "json"], {
3201
- parser: identity,
3202
- stringify: toString
3203
- });
3204
- }
3205
- };
3206
-
3207
- ShredHttpClient.prototype.execute = function(obj) {
3208
- if(!this.isInitialized)
3209
- this.initShred();
3210
-
3211
- var cb = obj.on, res;
3212
- var transform = function(response) {
3213
- var out = {
3214
- headers: response._headers,
3215
- url: response.request.url,
3216
- method: response.request.method,
3217
- status: response.status,
3218
- data: response.content.data
3219
- };
3220
-
3221
- var headers = response._headers.normalized || response._headers;
3222
- var contentType = (headers["content-type"]||headers["Content-Type"]||null);
3223
-
3224
- if(contentType) {
3225
- if(contentType.indexOf("application/json") === 0 || contentType.indexOf("+json") > 0) {
3226
- if(response.content.data && response.content.data !== "")
3227
- try{
3228
- out.obj = JSON.parse(response.content.data);
3229
- }
3230
- catch (e) {
3231
- // unable to parse
3232
- }
3233
- else
3234
- out.obj = {};
3235
- }
3236
- }
3237
- return out;
3238
- };
3239
-
3240
- // Transform an error into a usable response-like object
3241
- var transformError = function (error) {
3242
- var out = {
3243
- // Default to a status of 0 - The client will treat this as a generic permissions sort of error
3244
- status: 0,
3245
- data: error.message || error
3246
- };
3247
-
3248
- if (error.code) {
3249
- out.obj = error;
3250
-
3251
- if (error.code === 'ENOTFOUND' || error.code === 'ECONNREFUSED') {
3252
- // We can tell the client that this should be treated as a missing resource and not as a permissions thing
3253
- out.status = 404;
3254
- }
3255
- }
3256
- return out;
3257
- };
3258
-
3259
- res = {
3260
- error: function (response) {
3261
- if (obj)
3262
- return cb.error(transform(response));
3263
- },
3264
- // Catch the Shred error raised when the request errors as it is made (i.e. No Response is coming)
3265
- request_error: function (err) {
3266
- if (obj)
3267
- return cb.error(transformError(err));
3268
- },
3269
- response: function (response) {
3270
- if (obj) {
3271
- return cb.response(transform(response));
3272
- }
3273
- }
3274
- };
3275
- if (obj) {
3276
- obj.on = res;
3277
- }
3278
- return this.shred.request(obj);
3279
- };
3280
-
3281
-
3282
- var e = (typeof window !== 'undefined' ? window : exports);
3283
-
3284
- e.authorizations = authorizations = new SwaggerAuthorizations();
3285
- e.ApiKeyAuthorization = ApiKeyAuthorization;
3286
- e.PasswordAuthorization = PasswordAuthorization;
3287
- e.CookieAuthorization = CookieAuthorization;
3288
- e.SwaggerClient = SwaggerClient;
3289
- e.SwaggerApi = SwaggerClient;
3290
- e.Operation = Operation;
3291
- e.Model = Model;
3292
- e.addModel = addModel;
3293
- e.Resolver = Resolver;
3294
- })();