1 |
|
2 |
|
3 | const config = require("./config");
|
4 | const https = /^http:/.test(config().upload_prefix) ? require('http') : require('https');
|
5 | const querystring = require("querystring");
|
6 | const Q = require('q');
|
7 | const url = require('url');
|
8 | const utils = require("./utils");
|
9 | const ensureOption = require('./utils/ensureOption').defaults(config());
|
10 |
|
11 | const { extend, includes, only, ensurePresenceOf } = utils;
|
12 |
|
13 | const TRANSFORMATIONS_URI = "transformations";
|
14 |
|
15 | function call_api(method, uri, params, callback, options) {
|
16 | let handle_response, query_params;
|
17 | ensurePresenceOf({ method, uri });
|
18 | const deferred = Q.defer();
|
19 | const cloudinary = ensureOption(options, "upload_prefix", "https://api.cloudinary.com");
|
20 | const cloud_name = ensureOption(options, "cloud_name");
|
21 | const api_key = ensureOption(options, "api_key");
|
22 | const api_secret = ensureOption(options, "api_secret");
|
23 |
|
24 | method = method.toUpperCase();
|
25 | let api_url = [cloudinary, "v1_1", cloud_name].concat(uri).join("/");
|
26 | let content_type = 'application/x-www-form-urlencoded';
|
27 | if (options.content_type === 'json') {
|
28 | query_params = JSON.stringify(params);
|
29 | content_type = 'application/json';
|
30 | } else {
|
31 | query_params = querystring.stringify(params);
|
32 | }
|
33 | if (method === "GET") {
|
34 | api_url += "?" + query_params;
|
35 | }
|
36 | let request_options = url.parse(api_url);
|
37 | request_options = extend(request_options, {
|
38 | method: method,
|
39 | headers: {
|
40 | 'Content-Type': content_type,
|
41 | 'User-Agent': utils.getUserAgent(),
|
42 | },
|
43 | auth: api_key + ":" + api_secret,
|
44 | });
|
45 | if (options.agent != null) {
|
46 | request_options.agent = options.agent;
|
47 | }
|
48 | if (method !== "GET") {
|
49 | request_options.headers['Content-Length'] = Buffer.byteLength(query_params);
|
50 | }
|
51 | handle_response = function (res) {
|
52 | if (includes([200, 400, 401, 403, 404, 409, 420, 500], res.statusCode)) {
|
53 | let buffer = "";
|
54 | let error = false;
|
55 | res.on("data", function (d) {
|
56 | buffer += d;
|
57 | return buffer;
|
58 | });
|
59 | res.on("end", function () {
|
60 | let result;
|
61 | if (error) {
|
62 | return;
|
63 | }
|
64 | try {
|
65 | result = JSON.parse(buffer);
|
66 | } catch (e) {
|
67 | result = {
|
68 | error: {
|
69 | message: "Server return invalid JSON response. Status Code " + res.statusCode,
|
70 | },
|
71 | };
|
72 | }
|
73 | if (result.error) {
|
74 | result.error.http_code = res.statusCode;
|
75 | } else {
|
76 | result.rate_limit_allowed = parseInt(res.headers["x-featureratelimit-limit"]);
|
77 | result.rate_limit_reset_at = new Date(res.headers["x-featureratelimit-reset"]);
|
78 | result.rate_limit_remaining = parseInt(res.headers["x-featureratelimit-remaining"]);
|
79 | }
|
80 | if (result.error) {
|
81 | deferred.reject(result);
|
82 | } else {
|
83 | deferred.resolve(result);
|
84 | }
|
85 | if (typeof callback === "function") {
|
86 | callback(result);
|
87 | }
|
88 | });
|
89 | res.on("error", function (e) {
|
90 | error = true;
|
91 | let err_obj = {
|
92 | error: {
|
93 | message: e,
|
94 | http_code: res.statusCode,
|
95 | },
|
96 | };
|
97 | deferred.reject(err_obj.error);
|
98 | if (typeof callback === "function") {
|
99 | callback(err_obj);
|
100 | }
|
101 | });
|
102 | } else {
|
103 | let err_obj = {
|
104 | error: {
|
105 | message: "Server returned unexpected status code - " + res.statusCode,
|
106 | http_code: res.statusCode,
|
107 | },
|
108 | };
|
109 | deferred.reject(err_obj.error);
|
110 | if (typeof callback === "function") {
|
111 | callback(err_obj);
|
112 | }
|
113 | }
|
114 | };
|
115 | const request = https.request(request_options, handle_response);
|
116 | request.on("error", function (e) {
|
117 | deferred.reject(e);
|
118 | return typeof callback === "function" ? callback({ error: e }) : void 0;
|
119 | });
|
120 | request.setTimeout(ensureOption(options, "timeout", 60000));
|
121 | if (method !== "GET") {
|
122 | request.write(query_params);
|
123 | }
|
124 | request.end();
|
125 | return deferred.promise;
|
126 | }
|
127 |
|
128 | function deleteResourcesParams(options, params = {}) {
|
129 | return extend(params, only(options, "keep_original", "invalidate", "next_cursor", "transformations"));
|
130 | }
|
131 |
|
132 | exports.ping = function ping(callback, options = {}) {
|
133 | return call_api("get", ["ping"], {}, callback, options);
|
134 | };
|
135 |
|
136 | exports.usage = function usage(callback, options = {}) {
|
137 | return call_api("get", ["usage"], {}, callback, options);
|
138 | };
|
139 |
|
140 | exports.resource_types = function resource_types(callback, options = {}) {
|
141 | return call_api("get", ["resources"], {}, callback, options);
|
142 | };
|
143 |
|
144 | exports.resources = function resources(callback, options = {}) {
|
145 | let resource_type, type, uri;
|
146 | resource_type = options.resource_type || "image";
|
147 | type = options.type;
|
148 | uri = ["resources", resource_type];
|
149 | if (type != null) {
|
150 | uri.push(type);
|
151 | }
|
152 | if ((options.start_at != null) && Object.prototype.toString.call(options.start_at) === '[object Date]') {
|
153 | options.start_at = options.start_at.toUTCString();
|
154 | }
|
155 | return call_api("get", uri, only(options, "next_cursor", "max_results", "prefix", "tags", "context", "direction", "moderations", "start_at"), callback, options);
|
156 | };
|
157 |
|
158 | exports.resources_by_tag = function resources_by_tag(tag, callback, options = {}) {
|
159 | let resource_type, uri;
|
160 | resource_type = options.resource_type || "image";
|
161 | uri = ["resources", resource_type, "tags", tag];
|
162 | return call_api("get", uri, only(options, "next_cursor", "max_results", "tags", "context", "direction", "moderations"), callback, options);
|
163 | };
|
164 |
|
165 | exports.resources_by_context = function resources_by_context(key, value, callback, options = {}) {
|
166 | let params, resource_type, uri;
|
167 | resource_type = options.resource_type || "image";
|
168 | uri = ["resources", resource_type, "context"];
|
169 | params = only(options, "next_cursor", "max_results", "tags", "context", "direction", "moderations");
|
170 | params.key = key;
|
171 | if (value != null) {
|
172 | params.value = value;
|
173 | }
|
174 | return call_api("get", uri, params, callback, options);
|
175 | };
|
176 |
|
177 | exports.resources_by_moderation = function resources_by_moderation(kind, status, callback, options = {}) {
|
178 | let resource_type, uri;
|
179 | resource_type = options.resource_type || "image";
|
180 | uri = ["resources", resource_type, "moderations", kind, status];
|
181 | return call_api("get", uri, only(options, "next_cursor", "max_results", "tags", "context", "direction", "moderations"), callback, options);
|
182 | };
|
183 |
|
184 | exports.resources_by_ids = function resources_by_ids(public_ids, callback, options = {}) {
|
185 | let params, resource_type, type, uri;
|
186 | resource_type = options.resource_type || "image";
|
187 | type = options.type || "upload";
|
188 | uri = ["resources", resource_type, type];
|
189 | params = only(options, "tags", "context", "moderations");
|
190 | params["public_ids[]"] = public_ids;
|
191 | return call_api("get", uri, params, callback, options);
|
192 | };
|
193 |
|
194 | exports.resource = function resource(public_id, callback, options = {}) {
|
195 | let resource_type, type, uri;
|
196 | resource_type = options.resource_type || "image";
|
197 | type = options.type || "upload";
|
198 | uri = ["resources", resource_type, type, public_id];
|
199 | return call_api("get", uri, only(options, "exif", "colors", "derived_next_cursor", "faces", "image_metadata", "pages", "phash", "coordinates", "max_results"), callback, options);
|
200 | };
|
201 |
|
202 | exports.restore = function restore(public_ids, callback, options = {}) {
|
203 | let resource_type, type, uri;
|
204 | resource_type = options.resource_type || "image";
|
205 | type = options.type || "upload";
|
206 | uri = ["resources", resource_type, type, "restore"];
|
207 | return call_api("post", uri, {
|
208 | public_ids: public_ids,
|
209 | }, callback, options);
|
210 | };
|
211 |
|
212 | exports.update = function update(public_id, callback, options = {}) {
|
213 | let params, resource_type, type, uri;
|
214 | resource_type = options.resource_type || "image";
|
215 | type = options.type || "upload";
|
216 | uri = ["resources", resource_type, type, public_id];
|
217 | params = utils.updateable_resource_params(options);
|
218 | if (options.moderation_status != null) {
|
219 | params.moderation_status = options.moderation_status;
|
220 | }
|
221 | return call_api("post", uri, params, callback, options);
|
222 | };
|
223 |
|
224 | exports.delete_resources = function delete_resources(public_ids, callback, options = {}) {
|
225 | let resource_type, type, uri;
|
226 | resource_type = options.resource_type || "image";
|
227 | type = options.type || "upload";
|
228 | uri = ["resources", resource_type, type];
|
229 | return call_api("delete", uri, deleteResourcesParams(options, {
|
230 | "public_ids[]": public_ids,
|
231 | }), callback, options);
|
232 | };
|
233 |
|
234 | exports.delete_resources_by_prefix = function delete_resources_by_prefix(prefix, callback, options = {}) {
|
235 | let resource_type, type, uri;
|
236 | resource_type = options.resource_type || "image";
|
237 | type = options.type || "upload";
|
238 | uri = ["resources", resource_type, type];
|
239 | return call_api("delete", uri, deleteResourcesParams(options, {
|
240 | prefix: prefix,
|
241 | }), callback, options);
|
242 | };
|
243 |
|
244 | exports.delete_resources_by_tag = function delete_resources_by_tag(tag, callback, options = {}) {
|
245 | let resource_type, uri;
|
246 | resource_type = options.resource_type || "image";
|
247 | uri = ["resources", resource_type, "tags", tag];
|
248 | return call_api("delete", uri, deleteResourcesParams(options), callback, options);
|
249 | };
|
250 |
|
251 | exports.delete_all_resources = function delete_all_resources(callback, options = {}) {
|
252 | let resource_type, type, uri;
|
253 |
|
254 | resource_type = options.resource_type || "image";
|
255 | type = options.type || "upload";
|
256 | uri = ["resources", resource_type, type];
|
257 | return call_api("delete", uri, deleteResourcesParams(options, {
|
258 | all: true,
|
259 | }), callback, options);
|
260 | };
|
261 |
|
262 | exports.delete_derived_resources = function delete_derived_resources(derived_resource_ids, callback, options = {}) {
|
263 | let uri;
|
264 | uri = ["derived_resources"];
|
265 | return call_api("delete", uri, {
|
266 | "derived_resource_ids[]": derived_resource_ids,
|
267 | }, callback, options);
|
268 | };
|
269 |
|
270 | exports.delete_derived_by_transformation = function delete_derived_by_transformation(
|
271 | public_ids,
|
272 | transformations,
|
273 | callback,
|
274 | options = {},
|
275 | ) {
|
276 | let params, resource_type, type, uri;
|
277 | resource_type = options.resource_type || "image";
|
278 | type = options.type || "upload";
|
279 | uri = "resources/" + resource_type + "/" + type;
|
280 | params = extend({
|
281 | "public_ids[]": public_ids,
|
282 | }, only(options, "invalidate"));
|
283 | params.keep_original = true;
|
284 | params.transformations = utils.build_eager(transformations);
|
285 | return call_api("delete", uri, params, callback, options);
|
286 | };
|
287 |
|
288 | exports.tags = function tags(callback, options = {}) {
|
289 | let resource_type, uri;
|
290 | resource_type = options.resource_type || "image";
|
291 | uri = ["tags", resource_type];
|
292 | return call_api("get", uri, only(options, "next_cursor", "max_results", "prefix"), callback, options);
|
293 | };
|
294 |
|
295 | exports.transformations = function transformations(callback, options = {}) {
|
296 | const params = only(options, "next_cursor", "max_results", "named");
|
297 | return call_api("get", TRANSFORMATIONS_URI, params, callback, options);
|
298 | };
|
299 |
|
300 | exports.transformation = function transformation(transformationName, callback, options = {}) {
|
301 | const params = only(options, "next_cursor", "max_results");
|
302 | params.transformation = utils.build_eager(transformationName);
|
303 | return call_api("get", TRANSFORMATIONS_URI, params, callback, options);
|
304 | };
|
305 |
|
306 | exports.delete_transformation = function delete_transformation(transformationName, callback, options = {}) {
|
307 | const params = {};
|
308 | params.transformation = utils.build_eager(transformationName);
|
309 | return call_api("delete", TRANSFORMATIONS_URI, params, callback, options);
|
310 | };
|
311 |
|
312 | exports.update_transformation = function update_transformation(transformationName, updates, callback, options = {}) {
|
313 | const params = only(updates, "allowed_for_strict");
|
314 | params.transformation = utils.build_eager(transformationName);
|
315 | if (updates.unsafe_update != null) {
|
316 | params.unsafe_update = utils.build_eager(updates.unsafe_update);
|
317 | }
|
318 | return call_api("put", TRANSFORMATIONS_URI, params, callback, options);
|
319 | };
|
320 |
|
321 | exports.create_transformation = function create_transformation(name, definition, callback, options = {}) {
|
322 | const params = { name };
|
323 | params.transformation = utils.build_eager(definition);
|
324 | return call_api("post", TRANSFORMATIONS_URI, params, callback, options);
|
325 | };
|
326 |
|
327 | exports.upload_presets = function upload_presets(callback, options = {}) {
|
328 | return call_api("get", ["upload_presets"], only(options, "next_cursor", "max_results"), callback, options);
|
329 | };
|
330 |
|
331 | exports.upload_preset = function upload_preset(name, callback, options = {}) {
|
332 | let uri;
|
333 | uri = ["upload_presets", name];
|
334 | return call_api("get", uri, {}, callback, options);
|
335 | };
|
336 |
|
337 | exports.delete_upload_preset = function delete_upload_preset(name, callback, options = {}) {
|
338 | let uri;
|
339 | uri = ["upload_presets", name];
|
340 | return call_api("delete", uri, {}, callback, options);
|
341 | };
|
342 |
|
343 | exports.update_upload_preset = function update_upload_preset(name, callback, options = {}) {
|
344 | let params, uri;
|
345 | uri = ["upload_presets", name];
|
346 | params = utils.merge(utils.clear_blank(utils.build_upload_params(options)), only(options, "unsigned", "disallow_public_id"));
|
347 | return call_api("put", uri, params, callback, options);
|
348 | };
|
349 |
|
350 | exports.create_upload_preset = function create_upload_preset(callback, options = {}) {
|
351 | let params, uri;
|
352 | uri = ["upload_presets"];
|
353 | params = utils.merge(utils.clear_blank(utils.build_upload_params(options)), only(options, "name", "unsigned", "disallow_public_id"));
|
354 | return call_api("post", uri, params, callback, options);
|
355 | };
|
356 |
|
357 | exports.root_folders = function root_folders(callback, options = {}) {
|
358 | let uri;
|
359 | uri = ["folders"];
|
360 | return call_api("get", uri, {}, callback, options);
|
361 | };
|
362 |
|
363 | exports.sub_folders = function sub_folders(path, callback, options = {}) {
|
364 | let uri;
|
365 | uri = ["folders", path];
|
366 | return call_api("get", uri, {}, callback, options);
|
367 | };
|
368 |
|
369 | exports.delete_folder = function delete_folder(path, callback, options = {}) {
|
370 | let uri;
|
371 | uri = ["folders", path];
|
372 | return call_api("delete", uri, {}, callback, options);
|
373 | };
|
374 |
|
375 | exports.upload_mappings = function upload_mappings(callback, options = {}) {
|
376 | let params;
|
377 | params = only(options, "next_cursor", "max_results");
|
378 | return call_api("get", "upload_mappings", params, callback, options);
|
379 | };
|
380 |
|
381 | exports.upload_mapping = function upload_mapping(name, callback, options = {}) {
|
382 | if (name == null) {
|
383 | name = null;
|
384 | }
|
385 | return call_api("get", 'upload_mappings', {
|
386 | folder: name,
|
387 | }, callback, options);
|
388 | };
|
389 |
|
390 | exports.delete_upload_mapping = function delete_upload_mapping(name, callback, options = {}) {
|
391 | return call_api("delete", 'upload_mappings', {
|
392 | folder: name,
|
393 | }, callback, options);
|
394 | };
|
395 |
|
396 | exports.update_upload_mapping = function update_upload_mapping(name, callback, options = {}) {
|
397 | let params;
|
398 | params = only(options, "template");
|
399 | params.folder = name;
|
400 | return call_api("put", 'upload_mappings', params, callback, options);
|
401 | };
|
402 |
|
403 | exports.create_upload_mapping = function create_upload_mapping(name, callback, options = {}) {
|
404 | let params;
|
405 | params = only(options, "template");
|
406 | params.folder = name;
|
407 | return call_api("post", 'upload_mappings', params, callback, options);
|
408 | };
|
409 |
|
410 | function publishResource(byKey, value, callback, options = {}) {
|
411 | let params, resource_type, uri;
|
412 | params = only(options, "type", "invalidate", "overwrite");
|
413 | params[byKey] = value;
|
414 | resource_type = options.resource_type || "image";
|
415 | uri = ["resources", resource_type, "publish_resources"];
|
416 | options = extend({
|
417 | resource_type: resource_type,
|
418 | }, options);
|
419 | return call_api("post", uri, params, callback, options);
|
420 | }
|
421 |
|
422 | exports.publish_by_prefix = function publish_by_prefix(prefix, callback, options = {}) {
|
423 | return publishResource("prefix", prefix, callback, options);
|
424 | };
|
425 |
|
426 | exports.publish_by_tag = function publish_by_tag(tag, callback, options = {}) {
|
427 | return publishResource("tag", tag, callback, options);
|
428 | };
|
429 |
|
430 | exports.publish_by_ids = function publish_by_ids(public_ids, callback, options = {}) {
|
431 | return publishResource("public_ids", public_ids, callback, options);
|
432 | };
|
433 |
|
434 | exports.list_streaming_profiles = function list_streaming_profiles(callback, options = {}) {
|
435 | return call_api("get", "streaming_profiles", {}, callback, options);
|
436 | };
|
437 |
|
438 | exports.get_streaming_profile = function get_streaming_profile(name, callback, options = {}) {
|
439 | return call_api("get", "streaming_profiles/" + name, {}, callback, options);
|
440 | };
|
441 |
|
442 | exports.delete_streaming_profile = function delete_streaming_profile(name, callback, options = {}) {
|
443 | return call_api("delete", "streaming_profiles/" + name, {}, callback, options);
|
444 | };
|
445 |
|
446 | exports.update_streaming_profile = function update_streaming_profile(name, callback, options = {}) {
|
447 | let params;
|
448 | params = utils.build_streaming_profiles_param(options);
|
449 | return call_api("put", "streaming_profiles/" + name, params, callback, options);
|
450 | };
|
451 |
|
452 | exports.create_streaming_profile = function create_streaming_profile(name, callback, options = {}) {
|
453 | let params;
|
454 | params = utils.build_streaming_profiles_param(options);
|
455 | params.name = name;
|
456 | return call_api("post", 'streaming_profiles', params, callback, options);
|
457 | };
|
458 |
|
459 | function updateResourcesAccessMode(access_mode, by_key, value, callback, options = {}) {
|
460 | let params, resource_type, type;
|
461 | resource_type = options.resource_type || "image";
|
462 | type = options.type || "upload";
|
463 | params = {
|
464 | access_mode: access_mode,
|
465 | };
|
466 | params[by_key] = value;
|
467 | return call_api("post", "resources/" + resource_type + "/" + type + "/update_access_mode", params, callback, options);
|
468 | }
|
469 |
|
470 | exports.search = function search(params, callback, options = {}) {
|
471 | options.content_type = 'json';
|
472 | return call_api("post", "resources/search", params, callback, options);
|
473 | };
|
474 |
|
475 | exports.update_resources_access_mode_by_prefix = function update_resources_access_mode_by_prefix(
|
476 | access_mode,
|
477 | prefix,
|
478 | callback,
|
479 | options = {},
|
480 | ) {
|
481 | return updateResourcesAccessMode(access_mode, "prefix", prefix, callback, options);
|
482 | };
|
483 |
|
484 | exports.update_resources_access_mode_by_tag = function update_resources_access_mode_by_tag(
|
485 | access_mode,
|
486 | tag,
|
487 | callback,
|
488 | options = {},
|
489 | ) {
|
490 | return updateResourcesAccessMode(access_mode, "tag", tag, callback, options);
|
491 | };
|
492 |
|
493 | exports.update_resources_access_mode_by_ids = function update_resources_access_mode_by_ids(
|
494 | access_mode,
|
495 | ids,
|
496 | callback,
|
497 | options = {},
|
498 | ) {
|
499 | return updateResourcesAccessMode(access_mode, "public_ids[]", ids, callback, options);
|
500 | };
|