移动设备RPA脚本
view | history | commit | commitdiff
panchengyong
10 days ago b2d3f7caf927e5b83ec52efb74f1f818dbb15236
commit | author | age
bc5e1e 1 function ECloudWrapper() {
X 2
3 }
4
5
6 var ecloud = new ECloudWrapper();
7
8
9 ECloudWrapper.prototype.log = function (msg) {
10     var s = [];
11     for (var i = 1; i < arguments.length; i++) {
12         s.push(arguments[i]);
13     }
14     ecImporter.cloudLog(msg, s);
15 }
16 /**
17  * 普通的打印的日志(logd,logi,logw,loge)是否同步到云控，默认是同步的，可以不使用ecloud.log的时候,云控也可以看到日志
18  * @param logSyncToCloud true 代表同步 false 代表不同步
19  */
20 ECloudWrapper.prototype.commonLogToCloud = function (logSyncToCloud) {
21     ecImporter.commonLogToCloud(logSyncToCloud);
22 }
23
24 /**
25  * 取得当前任务的信息
b2d3f7 26  * @return {null|JSON} 对象
bc5e1e 27  */
X 28 ECloudWrapper.prototype.getTaskInfo = function () {
29     if (ecloudWrapper == null) {
30         return;
31     }
32     var d = ecloudWrapper.getTaskInfo();
33     if (d == null || d == "") {
34         return null;
35     }
b2d3f7 36     try {
P 37         return JSON.parse(d);
38     } catch (e) {
39     }
40     return null;
bc5e1e 41
X 42 };
43
44
45 /**
46  * 获取机器编号
47  * @return {string} 机器编码或者null
48  */
49 ECloudWrapper.prototype.getDeviceNo = function () {
50     if (ecloudWrapper == null) {
51         return;
52     }
53     return javaString2string(ecloudWrapper.getDeviceNo());
54 };
55
56 /**
57  * 通过资源组取得一组资源
58  * 注意: EC 6.4.0+ 已废弃，云控 2.0.0+ 无法使用，该项只做保留
59  * @param map 可扩展参数表
60  *   例如 {"groupName":"资源组1"}
61  *   key定义：
62  *   groupName = 资源组名称
63  *   pageNum= 页码 例如 1代表第一页
64  *   pageSize= 每页个数 例如 10 代表一页有10个
65  *
b2d3f7 66  * @return {null|JSON} 资源JSON对象
bc5e1e 67  */
X 68 ECloudWrapper.prototype.getResources = function (map) {
69     if (ecloudWrapper == null) {
70         return;
71     }
72     var d = ecloudWrapper.getResources(JSON.stringify(map));
73     if (d == null || d == "") {
74         return null;
75     }
b2d3f7 76     try {
P 77         return JSON.parse(d);
78     } catch (e) {
79     }
80     return null;
bc5e1e 81 };
X 82
83
84 /**
85  * 上传要存储的数据
86  * 注意: EC 6.4.0+ 已废弃，云控 2.0.0+ 无法使用，该项只做保留
87  * @param map 可扩展参数表
88  *   例如
89  * {
90  *   "groupName":"123",
91  *    "dataKey": "11111",
92  *  "content":"123"
93  * }
94  *   key定义：
95  *   groupName = 数据的组名，如果云端没有这个组，会自动创建
96  *   dataKey = 存储数据的唯一标示
97  *   content = 数据字符串
b2d3f7 98  * @return {boolean} true代表成功 false 代表失败
bc5e1e 99  */
X 100 ECloudWrapper.prototype.uploadStorageData = function (map) {
101     if (ecloudWrapper == null) {
102         return;
103     }
104     return ecloudWrapper.uploadStorageData(JSON.stringify(map));
105 };
106
107 /**
108  * 通过数据组名取得一组数据
109  * 注意: EC 6.4.0+ 已废弃，云控 2.0.0+ 无法使用，该项只做保留
110  * @param map 可扩展参数表
111  *   例如 {"groupName":"数据组1"}
112  *   {"dataKey":"key"}
113  *   key定义： groupName = 数据组名称
114  *   dataKey = 数据唯一标示
115  *   pageNum= 页码 例如 1代表第一页
116  *   pageSize= 每页个数 例如 10 代表一页有10个
b2d3f7 117  * @return {null|JSON} JSON对象
bc5e1e 118  */
X 119 ECloudWrapper.prototype.getStorageDatas = function (map) {
120     if (ecloudWrapper == null) {
121         return;
122     }
123     var d = ecloudWrapper.getStorageDatas(JSON.stringify(map));
124     if (d == null || d == "") {
125         return null;
126     }
b2d3f7 127     try {
P 128         return JSON.parse(d);
129     } catch (e) {
130     }
131     return null;
bc5e1e 132 };
X 133
134 /**
135  * 子任务失败
136  * 注意: EC 6.4.0+ 已废弃，云控 2.0.0+ 无法使用，该项只做保留
137  *  @param map 可扩展参数表
138  *   例如
139  * {
140  *   "subTaskId":123,
141  *     "msg": "因为找不到XXX失败"
142  * }
b2d3f7 143  * @return {boolean} true代表成功 false 代表失败
bc5e1e 144  */
X 145 ECloudWrapper.prototype.subTaskFail = function (map) {
146     if (ecloudWrapper == null) {
147         return;
148     }
149     return ecloudWrapper.subTaskFail(JSON.stringify(map));
150 };
151
152 /**
153  * 子任务成功
154  * 注意: EC 6.4.0+ 已废弃，云控 2.0.0+ 无法使用，该项只做保留
155  *  @param map 可扩展参数表
156  *   例如
157  * {
158  *   "subTaskId":123,
159  *    "msg": "任务成功"
160  * }
b2d3f7 161  * @return {boolean} true代表成功 false 代表失败
bc5e1e 162  */
X 163 ECloudWrapper.prototype.subTaskOk = function (map) {
164     if (ecloudWrapper == null) {
165         return;
166     }
167     return ecloudWrapper.subTaskOk(JSON.stringify(map));
168 };
169
170 /**
171  * 通过数据组名或者数据名称取得数据, 前提是要中云控中存在这个数据
172  * @param map 可扩展参数表
173  * 例如 {"groupName":"数据组1","dataName":"key"}
174  * key定义： groupName = 数据组名称
175  * dataName = 数据名称
b2d3f7 176  * @return {null|JSON}
bc5e1e 177  */
X 178 ECloudWrapper.prototype.getData = function (map) {
179     if (ecloudWrapper == null) {
180         return;
181     }
182     let d = ecloudWrapper.getData(JSON.stringify(map));
183     if (d == null || d == "") {
184         return null;
185     }
b2d3f7 186     try {
P 187         return JSON.parse(d);
188     } catch (e) {
189     }
190     return null;
191
bc5e1e 192 };
X 193
194
195 /**
196  * 通过数据组名或者数据名称取得数据,获取后云控自动删除, 前提是要中云控中存在这个数据
197  * @param map 可扩展参数表
198  * 例如 {"groupName":"数据组1","dataName":"key","getType":1,"size":1}
199  * key定义： groupName = 数据组名称
200  * dataName = 数据名称
201  * getType = 获取数据方式，1 头部获取，2 尾部获取，3 随机获取
202  * size = 需要获取的数据条数
b2d3f7 203  * @return {null|JSON} 空或者JSON数组
bc5e1e 204  */
X 205 ECloudWrapper.prototype.getDataPop = function (map) {
206     if (ecloudWrapper == null) {
207         return;
208     }
209     let d = ecloudWrapper.getDataPop(JSON.stringify(map));
210     if (d == null || d == "") {
211         return null;
212     }
b2d3f7 213     try {
P 214         return JSON.parse(d);
215     } catch (e) {
216
217     }
218     return null;
bc5e1e 219 };
X 220
221
222 /**
223  * 新增一组数据，如果组名存在了，会自动最近数据
224  * @param map 可扩展参数表
225  * 例如 {"groupName":"数据组1","dataName":"key","content":"数据"}
226  * key定义：
227  * groupName = 数据组名称
228  * dataName = 数据名称
229  * content=内容
b2d3f7 230  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 231  */
X 232 ECloudWrapper.prototype.addData = function (map) {
233     if (ecloudWrapper == null) {
234         return;
235     }
236     return ecloudWrapper.addData(JSON.stringify(map));
237 };
238
239 /**
240  * 修改某个组下面的数据，组名和数据名必填
241  * @param map 可扩展参数表
242  * 例如
243  * {"groupName":"数据组1","dataName":"key","content":"数据"}
244  * key定义：
245  * groupName = 数据组名称
246  * dataName = 数据名称
247  * content=内容
b2d3f7 248  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 249  */
X 250 ECloudWrapper.prototype.updateData = function (map) {
251     if (ecloudWrapper == null) {
252         return;
253     }
254     return ecloudWrapper.updateData(JSON.stringify(map));
255 };
256 /**
257  * 删除某个组下面的数据，如果只填写组名，该组下面全部被删除，如果组名和数据名都有，就删除该组下数据名相同的数据
258  * @param map 可扩展参数表
259  * 例如 {"groupName":"数据组1","dataName":"key"}
260  * key定义：
261  * groupName = 数据组名称
262  * dataName = 数据名称
b2d3f7 263  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 264  */
X 265 ECloudWrapper.prototype.removeData = function (map) {
266     if (ecloudWrapper == null) {
267         return;
268     }
269     return ecloudWrapper.removeData(JSON.stringify(map));
270 };
271
272 /**
273  * 查询该组下面的数据名的内容，并向内容尾追加一条数据
274  * @param map 可扩展参数表
275  * 例如 {"groupName":"数据组1","dataName":"key","content":"数据"}
276  * key定义：
277  * groupName = 数据组名称
278  * dataName = 数据名称
279  * content=内容
b2d3f7 280  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 281  */
X 282 ECloudWrapper.prototype.appendOneLineData = function (map) {
283     if (ecloudWrapper == null) {
284         return;
285     }
286     return ecloudWrapper.appendOneLineData(JSON.stringify(map));
287 };
288
289 /**
290  * 查询该组下面的数据名的内容，并删除其中一条与content相等的数据
291  * @param map 可扩展参数表
292  * 例如 {"groupName":"数据组1","dataName":"key","content":"数据"}
293  * key定义：
294  * groupName = 数据组名称
295  * dataName = 数据名称
296  * content=内容
b2d3f7 297  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 298  */
X 299 ECloudWrapper.prototype.removeOneLineData = function (map) {
300     if (ecloudWrapper == null) {
301         return;
302     }
303     return ecloudWrapper.removeOneLineData(JSON.stringify(map));
304 };
305
306
307 /**
308  * 获取云控的URL地址
309  * @return {string} 云控的URL地址或者null
310  */
311 ECloudWrapper.prototype.getCloudUrl = function () {
312     if (ecloudWrapper == null) {
313         return;
314     }
315     return javaString2string(ecloudWrapper.getCloudUrl());
316 };
317
318
319 /**
320  * 删除脚本文件保证安全
b2d3f7 321  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 322  */
X 323 ECloudWrapper.prototype.removeScriptFile = function () {
324     if (ecloudWrapper == null) {
325         return;
326     }
327     return ecloudWrapper.removeScriptFile();
328 };
329
330 /**
331  * 创建或者更新动态数据表结构<br/>
332  * 如果columns有增加新的，就自动创建字段，如果少了某个字段，就自动从表中移出字段<br/>
333  * 请谨慎操作表，以免数据丢失！！！<br/>
334  * 适合版本EC 6.16.0+
335  * @param param 参数<Br/>
336  * {
337  *     "tableName": "我是牛逼的表",
338  *     "tableNameEn": "niubi_table",
339  *     "columns": [{
340  *             "columnInfo": "姓名",
341  *             "columnName": "name",
342  *             "columnSize": 500
343  *         },
344  *         {
345  *             "columnInfo": "年龄",
346  *             "columnName": "age",
347  *             "columnSize": 500
348  *         },
349  *         {
350  *             "columnInfo": "性别",
351  *             "columnName": "sex",
352  *             "columnSize": 500
353  *         }
354  *     ]
355  * }<br/>
356  * 解释: <br/>
357  * tableName: 中文表名，相当于名称，但是不是实际表名<br/>
358  * tableNameEn: 英文表名，真实的表名<br/>
359  * columns: 表的字段数据，字段类型统一是字符串<br/>
360  *      columnInfo: 字段的注释信息<br/>
361  *      columnName: 字段名称，要用英文，不要有空格和特殊字符<br/>
362  *      columnSize: 字段长度<br/>
363  * @return {string} JSON字符串，自行转换为JSON对象
364  * <br/>成功返回示例：{"result":{"data":1}}，data代表操作的成功行数
365  * <br/>失败返回示例：{"result":{"msg":"我是错误信息"}}
366  */
367 ECloudWrapper.prototype.dynamicCreateTable = function (param) {
368     if (ecloudWrapper == null || param == null) {
369         return null;
370     }
371     return ecloudWrapper.dynamicCreateTable(JSON.stringify(param));
372 };
373
374 /**
375  * 动态查询数据<Br/>
376  * 适合版本EC 6.16.0+
377  * @param param 参数<Br/>
378  * {
379  *     "pageNumber": 1,
380  *     "pageSize": 4,
381  *     "fields": "id,name",
382  *     "query": "and name like '%我是%'",
383  *     "tableNameEn": "niubi_table",
384  *     "search": {
385  *         "id": "1",
386  *         "name": "我是name"
387  *     }
388  * }
389  * <br/>
390  * 解释: <br/>
391  * pageNumber: 页码 从1开始<br/>
392  * pageSize: 每页条数<br/>
393  * fields: 要查下的字段，可以不写，如果填写就是用英文逗号链接，请看例子<br/>
394  * query: 自定义的查询条件，遵循sql的写法<br/>
395  * tableNameEn: 英文的表名<br/>
396  * search：查询条件，和query查询条件二选一，这个查询是等于模式<br/>
397  * search 例子： "id":"1" 代表查询字段id=1的记录
398  * @return {string} JSON字符串，自行转换为JSON对象
399  * <br/>成功返回示例：{"result":{"data":[{"name":"3","id":2}]}}，data代表返回的数据数组
400  * <br/>失败返回示例：{"result":{"msg":"我是错误信息"}}
401  */
402 ECloudWrapper.prototype.dynamicQuery = function (param) {
403     if (ecloudWrapper == null || param == null) {
404         return null;
405     }
406     return ecloudWrapper.dynamicQuery(JSON.stringify(param));
407 };
408
409
410 /**
411  * 动态增加数据<Br/>
412  * 适合版本EC 6.16.0+<Br/>
413  * {
414  *     "tableNameEn": "niubi_table",<Br/>
415  *     "columns": {<Br/>
416  *         "name": "我是牛逼",<Br/>
417  *         "age": "niubi_table2",<Br/>
418  *         "sex": "niubi_table2"<Br/>
419  *     }<Br/>
420  * }<Br/>
421  * @param param 参数<Br/>
422  * 解释: <br/>
423  * tableNameEn: 英文的表名<br/>
424  * columns: 字段和字段值列表<br/>
425  * 例如 "name": "我是牛逼的表"，代表插入一个数据name=我是牛逼的表
426  * @return {string} JSON字符串，自行转换为JSON对象
427  * <br/>成功返回示例：{"result":{"data":1}}，data代表操作的成功行数
428  * <br/>失败返回示例：{"result":{"msg":"我是错误信息"}}
429  */
430 ECloudWrapper.prototype.dynamicAdd = function (param) {
431     if (ecloudWrapper == null || param == null) {
432         return null;
433     }
434     return ecloudWrapper.dynamicAdd(JSON.stringify(param));
435 };
436
437
438 /**
439  * 动态更新数据<Br/>
440  * 适合版本EC 6.16.0+
441  * @param param 参数<Br/>
442  * {
443  *     "tableNameEn": "niubi_table",
444  *     "columns": {
445  *         "name": "我x是牛逼xxxx的表",
446  *         "age": "niubi_table2",
447  *         "sex": "niubi_table2"
448  *     },
449  *     "query": "and id=1",
450  *     "search": {
451  *         "id": "7"
452  *     }
453  * }
454  * query: 自定义的查询条件，遵循sql的写法<br/>
455  * tableNameEn: 英文的表名<br/>
456  * search：查询条件，和query查询条件二选一，这个查询是等于模式<br/>
457  * search 例子： "id":"1" 代表查询字段id=1的记录
458  * columns: 要更新的字段和字段值列表<br/>
459  * 例如 "name": "我是牛逼的表"，代表把name的指更新为 我是牛逼的表
460  * @return {string} JSON字符串，自行转换为JSON对象
461  * <br/>成功返回示例：{"result":{"data":1}}，data代表操作的成功行数
462  * <br/>失败返回示例：{"result":{"msg":"我是错误信息"}}
463  */
464 ECloudWrapper.prototype.dynamicUpdate = function (param) {
465     if (ecloudWrapper == null || param == null) {
466         return null;
467     }
468     return ecloudWrapper.dynamicUpdate(JSON.stringify(param));
469 };
470
471
472 /**
473  * 动态删除数据<Br/>
474  * 适合版本EC 6.16.0+<Br/>
475  * {
476  *     "tableNameEn": "niubi_table",<Br/>
477  *     "query":"and name like '%我%'",<Br/>
478  *     "search": {<Br/>
479  *         "id": "1"
480  *     }<Br/>
481  * }<Br/>
482  * @param param 参数<Br/>
483  * 解释: <br/>
484  * query: 自定义的查询条件，遵循sql的写法<br/>
485  * tableNameEn: 英文的表名<br/>
486  * search：查询条件，和query查询条件二选一，这个查询是等于模式<br/>
487  * search 例子： "id":"1" 代表查询字段id=1的记录
488  * @return {string} JSON字符串，自行转换为JSON对象
489  * <br/>成功返回示例：{"result":{"data":1}}，data代表操作的成功行数
490  * <br/>失败返回示例：{"result":{"msg":"我是错误信息"}}
491  */
492 ECloudWrapper.prototype.dynamicRemove = function (param) {
493     if (ecloudWrapper == null || param == null) {
494         return null;
495     }
496     return ecloudWrapper.dynamicRemove(JSON.stringify(param));
497 };
498
499
500 /**
501  * 新增一个存放在redis的缓存
502  * 适合版本 EC 7.5.0+
503  * @param map 可扩展参数表
504  * 例如 {"cacheKey":"缓存key","expireTime":300,"dataType":1,"content":"数据"}
505  * key定义：
506  * cacheKey = 缓存key
507  * expireTime = 过期时间 单位是秒，为空或者小于等于0代表不过期
508  * dataType=数据类型，1 字符串，2 set集合用换行符\n分割的
509  * content=数据，如果dataType=2这个数据将会用换行符\n分割转换为集合存储到redis中
b2d3f7 510  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 511  */
X 512 ECloudWrapper.prototype.addCache = function (map) {
513     if (ecloudWrapper == null) {
514         return;
515     }
516     return ecloudWrapper.addCache(JSON.stringify(map));
517 };
518
519
520 /**
521  * 更新一个redis的缓存
522  * 适合版本 EC 7.5.0+
523  * @param map 可扩展参数表
524  * 例如 {"cacheKey":"缓存key","expireTime":300,"dataType":1,"content":"数据"}
525  * key定义：
526  * cacheKey = 缓存key
527  * expireTime = 过期时间 单位是秒，为空或者小于等于0代表不过期
528  * dataType=数据类型，1 字符串，2 set集合用换行符\n分割的
529  * content=数据，如果dataType=2这个数据将会用换行符\n分割转换为集合存储到redis中
b2d3f7 530  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 531  */
X 532 ECloudWrapper.prototype.updateCache = function (map) {
533     if (ecloudWrapper == null) {
534         return;
535     }
536     return ecloudWrapper.updateCache(JSON.stringify(map));
537 };
538
539 /**
540  * 更新一个redis的缓存过期时间
541  * 适合版本 EC 7.5.0+
542  * @param map 可扩展参数表
543  * 例如 {"cacheKey":"缓存key","expireTime":300}
544  * key定义：
545  * cacheKey = 缓存key
546  * expireTime = 过期时间 单位是秒，为空或者小于等于0代表不过期
b2d3f7 547  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 548  */
X 549 ECloudWrapper.prototype.updateCacheExpire = function (map) {
550     if (ecloudWrapper == null) {
551         return;
552     }
553     return ecloudWrapper.updateCacheExpire(JSON.stringify(map));
554 };
555
556 /**
557  * 删除一个redis的缓存
558  * 适合版本 EC 7.5.0+
559  * @param map 可扩展参数表
560  * 例如 {"cacheKey":"缓存key"}
561  * key定义：
562  * cacheKey = 缓存key
b2d3f7 563  * @return {boolean} true代表成功 false ，代表失败
bc5e1e 564  */
X 565 ECloudWrapper.prototype.removeCache = function (map) {
566     if (ecloudWrapper == null) {
567         return;
568     }
569     return ecloudWrapper.removeCache(JSON.stringify(map));
570 };
571
572
573 /**
574  * 获取一个缓存，如果缓存失效了 无数据返回
575  * 适合版本 EC 7.5.0+
576  * @param map 可扩展参数表
577  * 例如 {"cacheKey":"缓存key"}
578  * key定义：
579  * cacheKey = 缓存key
580  * @return {string} 服务端返回的JSON字符串，解析result节点即可
581  */
582 ECloudWrapper.prototype.getCache = function (map) {
583     if (ecloudWrapper == null) {
584         return;
585     }
586     let d = ecloudWrapper.getCache(JSON.stringify(map));
587     if (d == null || d == "") {
588         return null;
589     }
590     return JSON.parse(d);
591 };
592
593
594 /**
595  * 追加一个redis set的缓存
596  * 适合版本 EC 7.5.0+
597  * @param map 可扩展参数表
598  * 例如 {"cacheKey":"缓存key","content":"数据"}
599  * key定义：
600  * cacheKey = 缓存key
601  * content=数据，作为一整行，追加到redis的set集合中
602  * @return {string} 服务端返回的JSON字符串，解析result节点即可
603  */
604 ECloudWrapper.prototype.appendOneLineCache = function (map) {
605     if (ecloudWrapper == null) {
606         return;
607     }
608     let d = ecloudWrapper.appendOneLineCache(JSON.stringify(map));
609
610     if (d == null || d == "") {
611         return null;
612     }
613     return JSON.parse(d);
614 };
615
616
617 /**
618  * 删除一个redis set的缓存元素
619  * 适合版本 EC 7.5.0+
620  * @param map 可扩展参数表
621  * 例如 {"cacheKey":"缓存key","content":"数据"}
622  * key定义：
623  * cacheKey = 缓存key
624  * content=数据，作为一整行，从redis的set集合中移出
625  * @return {string} 服务端返回的JSON字符串，解析result节点即可
626  */
627 ECloudWrapper.prototype.removeOneLineCache = function (map) {
628     if (ecloudWrapper == null) {
629         return;
630     }
631     let d = ecloudWrapper.removeOneLineCache(JSON.stringify(map));
632     if (d == null || d == "") {
633         return null;
634     }
b2d3f7 635     try {
P 636         return JSON.parse(d);
637     } catch (e) {
638     }
639     return null;
bc5e1e 640 };
X 641
642 /**
643  * redis的自增长计数功能，每次调用这个key的值都会+1
644  * 适合版本 EC 7.5.0+
645  * @param map 可扩展参数表
646  * 例如 {"cacheKey":"缓存key"}
647  * key定义：
648  * cacheKey = 缓存key
b2d3f7 649  * @return {number} 返回redis自增后的值
bc5e1e 650  */
X 651 ECloudWrapper.prototype.incrementCache = function (map) {
652     if (ecloudWrapper == null) {
653         return;
654     }
655     return ecloudWrapper.incrementCache(JSON.stringify(map));
656 };
657 /**
658  * redis push或者pop命令
659  * 适合版本 EC 7.8.0+
660  * @param map 可扩展参数表
661  * 例如 {"cacheKey":"缓存key"}
662  * key定义：
663  * cmd = 支持 spop，rpush，lpush，lpop，rpop
664  * cacheKey = 缓存key
665  * content = push或者pop的内容
666  * @return {string} 服务端返回的JSON字符串，解析result节点即可
667  */
668 ECloudWrapper.prototype.popPushCache = function (map) {
669     if (ecloudWrapper == null) {
670         return;
671     }
672     return ecloudWrapper.popPushCache(JSON.stringify(map));
673 };
674
675
676 /**
677  * redis的自减计数功能，每次调用这个key的值都会-1
678  * 适合版本 EC 7.5.0+
679  * @param map 可扩展参数表
680  * 例如 {"cacheKey":"缓存key"}
681  * key定义：
682  * cacheKey = 缓存key
b2d3f7 683  * @return {number} 返回redis自减的值
bc5e1e 684  */
X 685 ECloudWrapper.prototype.decrementCache = function (map) {
686     if (ecloudWrapper == null) {
687         return;
688     }
689     return ecloudWrapper.decrementCache(JSON.stringify(map));
690 };
691
692 /**
693  * 获取一个redis的key剩余的过期时间
694  * 适合版本 EC 7.5.0+
695  * @param map 可扩展参数表
696  * 例如 {"cacheKey":"缓存key"}
697  * key定义：
698  * cacheKey = 缓存key
b2d3f7 699  * @return {number} 返回redis剩余的过期时间，负数代表永不过期
bc5e1e 700  */
X 701 ECloudWrapper.prototype.getCacheExpire = function (map) {
702     if (ecloudWrapper == null) {
703         return;
704     }
705     return ecloudWrapper.getCacheExpire(JSON.stringify(map));
706 };
707
708
709