src/bookmark/bookmark_api.js

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16
  17 var validator_ = xwalk.utils.validator;
  18 var types_ = validator_.Types;
  19 var native_ = new xwalk.utils.NativeManager(extension);
  20
  21 function EditManager() {
  22   this.canEdit = false;
  23 }
  24
  25 EditManager.prototype.allow = function() {
  26   this.canEdit = true;
  27 };
  28
  29 EditManager.prototype.disallow = function() {
  30   this.canEdit = false;
  31 };
  32
  33 var _edit = new EditManager();
  34
  35 function BookmarkManager() {}
  36
  37 BookmarkManager.prototype.get = function() {
  38   var args = validator_.validateArgs(arguments, [
  39     {
  40       name: 'parentFolder',
  41       type: types_.PLATFORM_OBJECT,
  42       values: [tizen.BookmarkFolder, tizen.BookmarkItem],
  43       optional: true,
  44       nullable: true
  45     },
  46     {
  47       name: 'recursive',
  48       type: types_.BOOLEAN,
  49       optional: true,
  50       nullable: true
  51     }
  52   ]);
  53   var result;
  54
  55   if (arguments.length === 0 || args.parentFolder === null) {
  56     result = provider.getFolderItems(provider.getRootId(), args.recursive);
  57     if (!result)
  58       throw new WebAPIException(WebAPIException.NOT_FOUND_ERR);
  59     return result;
  60   }
  61   if (args.parentFolder.id === null || args.parentFolder.id === 0)
  62     throw new WebAPIException(WebAPIException.NOT_FOUND_ERR);
  63
  64   result = provider.getFolderItems(args.parentFolder.id, args.recursive);
  65   if (!result)
  66     throw new WebAPIException(WebAPIException.NOT_FOUND_ERR);
  67   return result;
  68 };
  69
  70 BookmarkManager.prototype.add = function() {
  71   var args = validator_.validateArgs(arguments, [
  72     {
  73       name: 'bookmark',
  74       type: types_.PLATFORM_OBJECT,
  75       values: [tizen.BookmarkFolder, tizen.BookmarkItem],
  76       optional: false,
  77       nullable: false
  78     },
  79     {
  80       name: 'parentFolder',
  81       type: types_.PLATFORM_OBJECT,
  82       values: tizen.BookmarkFolder,
  83       optional: true,
  84       nullable: true
  85     }
  86   ]);
  87   if (arguments.length == 1 || args.parentFolder === null) {
  88     if (args.bookmark.id) {
  89       throw new WebAPIException(WebAPIException.INVALID_VALUES_ERR);
  90     }
  91
  92     provider.addToFolder(args.bookmark, provider.getRootId());
  93     return;
  94   }
  95   if (!args.parentFolder.id) {
  96     throw new WebAPIException(WebAPIException.NOT_FOUND_ERR);
  97   }
  98
  99   provider.addToFolder(args.bookmark, args.parentFolder.id);
 100 };
 101
 102 BookmarkManager.prototype.remove = function() {
 103   var args = validator_.validateArgs(arguments, [
 104     {
 105       name: 'bookmark',
 106       type: types_.PLATFORM_OBJECT,
 107       values: [tizen.BookmarkFolder, tizen.BookmarkItem],
 108       optional: true,
 109       nullable: true
 110     }
 111   ]);
 112
 113   if (!arguments.length || args.bookmark === null) {
 114     var result = native_.callSync('Bookmark_removeAll');
 115     if (native_.isFailure(result)) {
 116       throw native_.getErrorObject(result);
 117     }
 118
 119     return;
 120   }
 121
 122   if (!args.bookmark.id) {
 123     throw new WebAPIException(WebAPIException.UNKNOWN_ERR);
 124   }
 125
 126   var result = native_.isFailure(native_.callSync('Bookmark_remove', {id: args.bookmark.id}));
 127   if (native_.isFailure(result)) {
 128     throw native_.getErrorObject(result);
 129   }
 130
 131   _edit.allow();
 132   args.bookmark.id = null;
 133   args.bookmark.parent = undefined;
 134   _edit.disallow();
 135 };
 136
 137 function BookmarkProvider() {}
 138
 139 BookmarkProvider.prototype.addToFolder = function() {
 140   var args = validator_.validateArgs(arguments, [
 141     {
 142       name: 'bookmark',
 143       type: types_.PLATFORM_OBJECT,
 144       values: [tizen.BookmarkFolder, tizen.BookmarkItem],
 145       optional: true,
 146       nullable: true
 147     },
 148     {
 149       name: 'parentId',
 150       type: types_.DOUBLE,
 151       optional: false,
 152       nullable: false}
 153   ]);
 154   var ret = native_.callSync('Bookmark_add',
 155     {
 156       title: args.bookmark.title,
 157       url: String(args.bookmark.url),
 158       parentId: args.parentId,
 159       type: args.bookmark instanceof tizen.BookmarkFolder ? 1 : 0
 160     }
 161   );
 162
 163   if (native_.isFailure(ret)) {
 164     throw native_.getErrorObject(ret);
 165   }
 166
 167   var ret_id = native_.getResultObject(ret);
 168   _edit.allow();
 169   args.bookmark.id = ret_id;
 170   args.bookmark.parent = this.getFolder(args.parentId);
 171   _edit.disallow();
 172 };
 173
 174 BookmarkProvider.prototype.getFolder = function() {
 175   var args = validator_.validateArgs(arguments, [
 176     {
 177       name: 'id',
 178       type: types_.DOUBLE,
 179       optional: false,
 180       nullable: false
 181     }
 182   ]);
 183   if (arguments.length === 0 || args.id <= 0)
 184     return null;
 185   if (args.id == this.getRootId())
 186     return null;
 187
 188   var ret = native_.callSync('Bookmark_get', {
 189     id: args.id,
 190     shouldGetItems: 0
 191   });
 192
 193   if (native_.isFailure(ret)) {
 194     throw native_.getErrorObject(ret);
 195   }
 196
 197   var folder = native_.getResultObject(ret);
 198   if (folder === undefined || folder === null) {
 199     throw new WebAPIException(WebAPIException.UNKNOWN_ERR);
 200   }
 201
 202   var obj = new tizen.BookmarkFolder(folder[0].title);
 203   obj.id = folder[0].id;
 204   obj.parent = this.getFolder(folder[0].parentId);
 205   return obj;
 206 };
 207
 208 BookmarkProvider.prototype.getFolderItems = function() {
 209   var args = validator_.validateArgs(arguments, [
 210     {
 211       name: 'id',
 212       type: types_.DOUBLE,
 213       optional: false,
 214       nullable: false
 215     },
 216     {
 217       name: 'recursive',
 218       type: types_.BOOLEAN,
 219       optional: true,
 220       nullable: true
 221     }
 222   ]);
 223
 224   var ret = native_.callSync('Bookmark_get', {
 225     id: Number(args.id),
 226     shouldGetItems: 1
 227   });
 228
 229   if (native_.isFailure(ret)) {
 230     throw native_.getErrorObject(ret);
 231   }
 232
 233   var folder = native_.getResultObject(ret);
 234   if (folder === undefined) {
 235     throw new WebAPIException(WebAPIException.UNKNOWN_ERR);
 236   }
 237
 238   var item;
 239   var obj;
 240   var result = [];
 241   var len = folder.length;
 242
 243   for (var i = 0; item = folder[i], i < len; i++) {
 244     if (Number(item.type) === 0)
 245       obj = new tizen.BookmarkItem(item.title, item.url);
 246     else
 247       obj = new tizen.BookmarkFolder(item.title);
 248
 249     _edit.allow();
 250     obj.id = item.id;
 251     obj.parent = this.getFolder(item.parentId);
 252     _edit.disallow();
 253     result.push(obj);
 254
 255     if (args.recursive && Number(item.type) !== 0)
 256       result = result.concat(this.getFolderItems(item.id, true));
 257   }
 258   return result;
 259 };
 260
 261 BookmarkProvider.prototype.getRootId = function() {
 262   var ret = native_.callSync('Bookmark_getRootId');
 263   if (native_.isFailure(ret)) {
 264     throw native_.getErrorObject(ret);
 265   }
 266   var rootId = native_.getResultObject(ret);
 267   return Number(rootId);
 268 };
 269
 270 var provider = new BookmarkProvider();
 271
 272 tizen.BookmarkItem = function() {
 273   validator_.isConstructorCall(this, tizen.BookmarkItem);
 274   var args = validator_.validateArgs(arguments, [
 275     {
 276       name: 'title',
 277       type: types_.STRING,
 278       optional: false
 279     },
 280     {
 281       name: 'url',
 282       type: types_.STRING,
 283       optional: false
 284     }
 285   ]);
 286   var parent_;
 287   var id_ = null;
 288
 289   Object.defineProperties(this, {
 290     parent: {
 291       get: function() {
 292         return parent_;
 293       },
 294       set: function(new_parent) {
 295         if (_edit.canEdit)
 296           parent_ = new_parent;
 297       },
 298       enumerable: true,
 299       nullable: true
 300     },
 301     title: {
 302       get: function() {
 303         return args.title;
 304       },
 305       enumerable: true,
 306       nullable: false
 307     },
 308     url: {
 309       get: function() {
 310         if (args.url === "undefined")
 311           args.url = undefined;
 312         return args.url;
 313       },
 314       enumerable: true,
 315       nullable: false
 316     },
 317     id: {
 318       get: function() {
 319         return id_;
 320       },
 321       set: function(new_id) {
 322         if (_edit.canEdit)
 323           id_ = new_id;
 324       },
 325       enumerable: false,
 326       nullable: true
 327     }
 328   });
 329 };
 330
 331 tizen.BookmarkFolder = function() {
 332   validator_.isConstructorCall(this, tizen.BookmarkFolder);
 333   var args = validator_.validateArgs(arguments, [
 334     {
 335       name: 'title',
 336       type: types_.STRING,
 337       optional: false,
 338       nullable: false
 339     }
 340   ]);
 341
 342   var parent_;
 343   var id_ = null;
 344
 345   Object.defineProperties(this, {
 346     parent: {
 347       get: function() {
 348         return parent_;
 349       },
 350       set: function(new_parent) {
 351         if (_edit.canEdit)
 352           parent_ = new_parent;
 353       },
 354       enumerable: true,
 355       nullable: true
 356     },
 357     title: {
 358       get: function() {
 359         return args.title;
 360       },
 361       enumerable: true,
 362       nullable: false
 363     },
 364     id: {
 365       get: function() {
 366         return id_;
 367       },
 368       set: function(new_id) {
 369         if (_edit.canEdit)
 370           id_ = new_id;
 371       },
 372       enumerable: false,
 373       nullable: true
 374     }
 375   });
 376 };
 377 exports = new BookmarkManager();