1 |
|
2 |
|
3 | import { __awaiter, __extends, __generator } from "tslib";
|
4 | import { isStreamOperation } from "../operationSpec";
|
5 | import { RestError } from "../restError";
|
6 | import { MapperType } from "../serializer";
|
7 | import * as utils from "../util/utils";
|
8 | import { parseXML } from "../util/xml";
|
9 | import { BaseRequestPolicy, } from "./requestPolicy";
|
10 |
|
11 |
|
12 |
|
13 |
|
14 | export function deserializationPolicy(deserializationContentTypes) {
|
15 | return {
|
16 | create: function (nextPolicy, options) {
|
17 | return new DeserializationPolicy(nextPolicy, deserializationContentTypes, options);
|
18 | },
|
19 | };
|
20 | }
|
21 | export var defaultJsonContentTypes = ["application/json", "text/json"];
|
22 | export var defaultXmlContentTypes = ["application/xml", "application/atom+xml"];
|
23 |
|
24 |
|
25 |
|
26 |
|
27 | var DeserializationPolicy = (function (_super) {
|
28 | __extends(DeserializationPolicy, _super);
|
29 | function DeserializationPolicy(nextPolicy, deserializationContentTypes, options) {
|
30 | var _this = _super.call(this, nextPolicy, options) || this;
|
31 | _this.jsonContentTypes =
|
32 | (deserializationContentTypes && deserializationContentTypes.json) || defaultJsonContentTypes;
|
33 | _this.xmlContentTypes =
|
34 | (deserializationContentTypes && deserializationContentTypes.xml) || defaultXmlContentTypes;
|
35 | return _this;
|
36 | }
|
37 | DeserializationPolicy.prototype.sendRequest = function (request) {
|
38 | return __awaiter(this, void 0, void 0, function () {
|
39 | var _this = this;
|
40 | return __generator(this, function (_a) {
|
41 | return [2 , this._nextPolicy
|
42 | .sendRequest(request)
|
43 | .then(function (response) {
|
44 | return deserializeResponseBody(_this.jsonContentTypes, _this.xmlContentTypes, response);
|
45 | })];
|
46 | });
|
47 | });
|
48 | };
|
49 | return DeserializationPolicy;
|
50 | }(BaseRequestPolicy));
|
51 | export { DeserializationPolicy };
|
52 | function getOperationResponse(parsedResponse) {
|
53 | var result;
|
54 | var request = parsedResponse.request;
|
55 | var operationSpec = request.operationSpec;
|
56 | if (operationSpec) {
|
57 | var operationResponseGetter = request.operationResponseGetter;
|
58 | if (!operationResponseGetter) {
|
59 | result = operationSpec.responses[parsedResponse.status];
|
60 | }
|
61 | else {
|
62 | result = operationResponseGetter(operationSpec, parsedResponse);
|
63 | }
|
64 | }
|
65 | return result;
|
66 | }
|
67 | function shouldDeserializeResponse(parsedResponse) {
|
68 | var shouldDeserialize = parsedResponse.request.shouldDeserialize;
|
69 | var result;
|
70 | if (shouldDeserialize === undefined) {
|
71 | result = true;
|
72 | }
|
73 | else if (typeof shouldDeserialize === "boolean") {
|
74 | result = shouldDeserialize;
|
75 | }
|
76 | else {
|
77 | result = shouldDeserialize(parsedResponse);
|
78 | }
|
79 | return result;
|
80 | }
|
81 | export function deserializeResponseBody(jsonContentTypes, xmlContentTypes, response) {
|
82 | return parse(jsonContentTypes, xmlContentTypes, response).then(function (parsedResponse) {
|
83 | var shouldDeserialize = shouldDeserializeResponse(parsedResponse);
|
84 | if (shouldDeserialize) {
|
85 | var operationSpec = parsedResponse.request.operationSpec;
|
86 | if (operationSpec && operationSpec.responses) {
|
87 | var statusCode = parsedResponse.status;
|
88 | var expectedStatusCodes = Object.keys(operationSpec.responses);
|
89 | var hasNoExpectedStatusCodes = expectedStatusCodes.length === 0 ||
|
90 | (expectedStatusCodes.length === 1 && expectedStatusCodes[0] === "default");
|
91 | var responseSpec = getOperationResponse(parsedResponse);
|
92 | var isExpectedStatusCode = hasNoExpectedStatusCodes
|
93 | ? 200 <= statusCode && statusCode < 300
|
94 | : !!responseSpec;
|
95 | if (!isExpectedStatusCode) {
|
96 | var defaultResponseSpec = operationSpec.responses.default;
|
97 | if (defaultResponseSpec) {
|
98 | var initialErrorMessage = isStreamOperation(operationSpec)
|
99 | ? "Unexpected status code: " + statusCode
|
100 | : parsedResponse.bodyAsText;
|
101 | var error = new RestError(initialErrorMessage);
|
102 | error.statusCode = statusCode;
|
103 | error.request = utils.stripRequest(parsedResponse.request);
|
104 | error.response = utils.stripResponse(parsedResponse);
|
105 | var parsedErrorResponse = parsedResponse.parsedBody;
|
106 | try {
|
107 | if (parsedErrorResponse) {
|
108 | var defaultResponseBodyMapper = defaultResponseSpec.bodyMapper;
|
109 | if (defaultResponseBodyMapper &&
|
110 | defaultResponseBodyMapper.serializedName === "CloudError") {
|
111 | if (parsedErrorResponse.error) {
|
112 | parsedErrorResponse = parsedErrorResponse.error;
|
113 | }
|
114 | if (parsedErrorResponse.code) {
|
115 | error.code = parsedErrorResponse.code;
|
116 | }
|
117 | if (parsedErrorResponse.message) {
|
118 | error.message = parsedErrorResponse.message;
|
119 | }
|
120 | }
|
121 | else {
|
122 | var internalError = parsedErrorResponse;
|
123 | if (parsedErrorResponse.error) {
|
124 | internalError = parsedErrorResponse.error;
|
125 | }
|
126 | error.code = internalError.code;
|
127 | if (internalError.message) {
|
128 | error.message = internalError.message;
|
129 | }
|
130 | }
|
131 | if (defaultResponseBodyMapper) {
|
132 | var valueToDeserialize = parsedErrorResponse;
|
133 | if (operationSpec.isXML &&
|
134 | defaultResponseBodyMapper.type.name === MapperType.Sequence) {
|
135 | valueToDeserialize =
|
136 | typeof parsedErrorResponse === "object"
|
137 | ? parsedErrorResponse[defaultResponseBodyMapper.xmlElementName]
|
138 | : [];
|
139 | }
|
140 | error.body = operationSpec.serializer.deserialize(defaultResponseBodyMapper, valueToDeserialize, "error.body");
|
141 | }
|
142 | }
|
143 | }
|
144 | catch (defaultError) {
|
145 | error.message = "Error \"" + defaultError.message + "\" occurred in deserializing the responseBody - \"" + parsedResponse.bodyAsText + "\" for the default response.";
|
146 | }
|
147 | return Promise.reject(error);
|
148 | }
|
149 | }
|
150 | else if (responseSpec) {
|
151 | if (responseSpec.bodyMapper) {
|
152 | var valueToDeserialize = parsedResponse.parsedBody;
|
153 | if (operationSpec.isXML && responseSpec.bodyMapper.type.name === MapperType.Sequence) {
|
154 | valueToDeserialize =
|
155 | typeof valueToDeserialize === "object"
|
156 | ? valueToDeserialize[responseSpec.bodyMapper.xmlElementName]
|
157 | : [];
|
158 | }
|
159 | try {
|
160 | parsedResponse.parsedBody = operationSpec.serializer.deserialize(responseSpec.bodyMapper, valueToDeserialize, "operationRes.parsedBody");
|
161 | }
|
162 | catch (error) {
|
163 | var restError = new RestError("Error " + error + " occurred in deserializing the responseBody - " + parsedResponse.bodyAsText);
|
164 | restError.request = utils.stripRequest(parsedResponse.request);
|
165 | restError.response = utils.stripResponse(parsedResponse);
|
166 | return Promise.reject(restError);
|
167 | }
|
168 | }
|
169 | else if (operationSpec.httpMethod === "HEAD") {
|
170 |
|
171 | parsedResponse.parsedBody = response.status >= 200 && response.status < 300;
|
172 | }
|
173 | if (responseSpec.headersMapper) {
|
174 | parsedResponse.parsedHeaders = operationSpec.serializer.deserialize(responseSpec.headersMapper, parsedResponse.headers.rawHeaders(), "operationRes.parsedHeaders");
|
175 | }
|
176 | }
|
177 | }
|
178 | }
|
179 | return Promise.resolve(parsedResponse);
|
180 | });
|
181 | }
|
182 | function parse(jsonContentTypes, xmlContentTypes, operationResponse) {
|
183 | var errorHandler = function (err) {
|
184 | var msg = "Error \"" + err + "\" occurred while parsing the response body - " + operationResponse.bodyAsText + ".";
|
185 | var errCode = err.code || RestError.PARSE_ERROR;
|
186 | var e = new RestError(msg, errCode, operationResponse.status, operationResponse.request, operationResponse, operationResponse.bodyAsText);
|
187 | return Promise.reject(e);
|
188 | };
|
189 | if (!operationResponse.request.streamResponseBody && operationResponse.bodyAsText) {
|
190 | var text_1 = operationResponse.bodyAsText;
|
191 | var contentType = operationResponse.headers.get("Content-Type") || "";
|
192 | var contentComponents = !contentType
|
193 | ? []
|
194 | : contentType.split(";").map(function (component) { return component.toLowerCase(); });
|
195 | if (contentComponents.length === 0 ||
|
196 | contentComponents.some(function (component) { return jsonContentTypes.indexOf(component) !== -1; })) {
|
197 | return new Promise(function (resolve) {
|
198 | operationResponse.parsedBody = JSON.parse(text_1);
|
199 | resolve(operationResponse);
|
200 | }).catch(errorHandler);
|
201 | }
|
202 | else if (contentComponents.some(function (component) { return xmlContentTypes.indexOf(component) !== -1; })) {
|
203 | return parseXML(text_1)
|
204 | .then(function (body) {
|
205 | operationResponse.parsedBody = body;
|
206 | return operationResponse;
|
207 | })
|
208 | .catch(errorHandler);
|
209 | }
|
210 | }
|
211 | return Promise.resolve(operationResponse);
|
212 | }
|
213 |
|
\ | No newline at end of file |