src/IntBookmarkPresentationModel.cpp

   1 //
   2
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.1 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 //!Internet
  19 /*@file: IntBookmarkPresentationModel.cpp
  20  *@brief: Used to define BookmarkPresentationModel
  21  */
  22
  23 #include <cstdlib>
  24
  25 #include "IntBookmarkData.h"
  26 #include "IntBookmarkPresentationModel.h"
  27 #include "IntTypes.h"
  28
  29 using namespace Tizen::App;
  30 using namespace Tizen::Base;
  31 using namespace Tizen::Base::Collection;
  32 using namespace Tizen::Base::Utility;
  33 using namespace Tizen::Io;
  34 using namespace Tizen::Locales;
  35 using namespace Tizen::System;
  36
  37 extern const wchar_t* BOOKMARK_URL_TABLE;
  38 //extern const wchar_t* BOOKMARK_FOLDER_TABLE;
  39 extern const wchar_t* DEFAULT_VALUE_PARENTID ;
  40
  41 BookmarkPresentationModel* BookmarkPresentationModel::__pBookmarkPresentationModel = null;
  42
  43 BookmarkPresentationModel::BookmarkPresentationModel(void)
  44 {
  45
  46 }
  47
  48 BookmarkPresentationModel::~BookmarkPresentationModel(void)
  49 {
  50
  51 }
  52
  53 BookmarkPresentationModel::BookmarkPresentationModel(const BookmarkPresentationModel& settingModelObj)
  54 {
  55
  56 }
  57
  58 BookmarkPresentationModel& BookmarkPresentationModel::operator=(const BookmarkPresentationModel& settingModelObj)
  59 {
  60         return *this;
  61 }
  62
  63 result
  64 BookmarkPresentationModel::Construct(void)
  65 {
  66         result r = E_SUCCESS;
  67         DB_FILE_PATH = L"/opt/usr/dbspace/.internet_bookmark.db";
  68
  69         r = PresentationModelBase::Initialize();
  70         TryCatch( !IsFailed(r),,"Failed to intitialize bookmarkPresentation Model %s",GetErrorMessage(r));
  71     CATCH: return r;
  72 }
  73
  74 void
  75 BookmarkPresentationModel::CreateInstance(void)
  76 {
  77         if (__pBookmarkPresentationModel == null)
  78                 __pBookmarkPresentationModel = new(std::nothrow) BookmarkPresentationModel();
  79         result r = __pBookmarkPresentationModel->Construct();
  80         if (IsFailed(r))
  81         {
  82                 delete __pBookmarkPresentationModel;
  83                 __pBookmarkPresentationModel = null;
  84                 return;
  85         }
  86     std::atexit(DestroyInstance);
  87 }
  88
  89
  90 void BookmarkPresentationModel::DestroyInstance(void)
  91 {
  92         if (__pBookmarkPresentationModel)
  93         {
  94                 delete __pBookmarkPresentationModel;
  95                 __pBookmarkPresentationModel = null;
  96         }
  97 }
  98
  99
 100 BookmarkPresentationModel*
 101 BookmarkPresentationModel::GetInstance(void)
 102 {
 103         if(__pBookmarkPresentationModel == null)
 104         {
 105                 CreateInstance();
 106         }
 107         return __pBookmarkPresentationModel;
 108 }
 109
 110 result
 111 BookmarkPresentationModel::SaveFolder(BookmarkData& bookmark)
 112 {
 113         bookmark.SetParentId("0");
 114         return SaveTempBookmark(bookmark);
 115 }
 116
 117 result
 118 BookmarkPresentationModel::SaveBookmark(BookmarkData& bookmark)
 119 {
 120         result r = E_FAILURE;
 121         String bookmarkTable(BOOKMARK_URL_TABLE);
 122         String query;
 123         String columnNames;
 124         String attachment;
 125         int resultCount = -1;
 126         int rowId = -1;
 127         DateTime dt;
 128         String bookmarkId;
 129         String bookmarkTitle = bookmark.GetBookmarkTitle();
 130         bookmarkTitle.Replace(L"'", L"''");
 131         String bookmarkUrl = bookmark.GetUrl();
 132         bookmarkUrl.Replace(L"'", L"''");
 133
 134         AppLog("BookmarkPresentationModel::SaveBookmark");
 135
 136         String pFavArray;
 137         ByteBuffer* pFavBuffer = bookmark.GetFavIconBuffer();
 138         if(pFavBuffer != null)
 139         {
 140                 AppLog("Buffer found");
 141                 pFavBuffer->Flip();
 142
 143                 wchar_t value;
 144
 145                 AppLog("BookmarkPresentationModel::SaveBookmark 0 ");
 146
 147                 while(pFavBuffer->HasRemaining())
 148                 {
 149                         pFavBuffer->GetWchar(value);
 150                         pFavArray.Append(value);
 151                 }
 152         }
 153
 154         AppLog("BookmarkPresentationModel::SaveBookmark 1 pFavArray(%d) is %ls",pFavArray.GetLength(), pFavArray.GetPointer());
 155
 156         PresentationModelBase::GetCurrentDateTime(dt);
 157         if (bookmark.GetBookmarkId() == "")
 158         {
 159                 columnNames.Append(L"TYPE, ");
 160                 columnNames.Append(L"PARENT, ");
 161                 columnNames.Append(L"ADDRESS, ");
 162                 columnNames.Append(L"TITLE, ");
 163                 columnNames.Append(L"CREATIONDATE, ");
 164                 columnNames.Append(L"UPDATEDATE, ");
 165                 columnNames.Append(L"FAVICON, ");
 166                 //      columnNames.Append(L"FAVICON_LENGTH, ");
 167                 columnNames.Append(L"FAVICON_W, ");
 168                 columnNames.Append(L"FAVICON_H");
 169                 //columnNames.Append(L"FAVICON_ID"
 170                 //columnNames.Append(L"FAVICON_ID");
 171
 172                 query.Append(L"INSERT INTO ");
 173                 query.Append(bookmarkTable);
 174                 query.Append("(");
 175                 query.Append(columnNames);
 176                 query.Append(") ");
 177                 query.Append("VALUES(");
 178                 query.Append(bookmark.GetBookmarkType());
 179                 query.Append(", ");
 180                 query.Append(bookmark.GetParentId());
 181                 query.Append(", ");
 182                 query.Append("'");
 183                 query.Append(bookmarkUrl);
 184                 query.Append("', ");
 185                 query.Append("'");
 186                 query.Append(bookmarkTitle);
 187                 query.Append("', ");
 188                 query.Append("'");
 189                 query.Append(dt.ToString());
 190                 query.Append("', ");
 191                 query.Append("'");
 192                 query.Append(dt.ToString());
 193                 query.Append("', ");
 194                 query.Append("'");
 195                 query.Append(pFavArray);
 196                 query.Append("', ");
 197                 query.Append(bookmark.GetFavIconWidth());
 198                 query.Append(", ");
 199                 query.Append(bookmark.GetFavIconHeight());
 200                 /*query.Append("', ");
 201                 query.Append("'");
 202                 query.Append(bookmark.GetIconPath());
 203                 query.Append("'");
 204                 query.Append(", ");
 205                 query.Append("'");
 206                 query.Append(bookmark.GetFaviconId());*/
 207                 query.Append(")");
 208         }
 209         else
 210         {
 211                 query.Append(L"UPDATE ");
 212                 query.Append(bookmarkTable);
 213                 query.Append(" SET PARENT = ");
 214                 query.Append(bookmark.GetParentId());
 215                 query.Append(", ADDRESS = ");
 216                 query.Append("'");
 217                 query.Append(bookmarkUrl);
 218                 query.Append("'");
 219                 query.Append(", TITLE = ");
 220                 query.Append("'");
 221                 query.Append(bookmarkTitle);
 222                 query.Append("'");
 223                 query.Append(", UPDATEDATE = ");
 224                 query.Append("'");
 225                 query.Append(dt.ToString());
 226                 query.Append("'");
 227                 query.Append(" WHERE ID = ");
 228                 query.Append(bookmark.GetBookmarkId());
 229                 /*query.Append(L"UPDATE ");
 230                 query.Append(bookmarkTable);
 231                 query.Append(" SET TITLE = ");
 232                 query.Append("'");
 233                 query.Append(bookmarkTitle);
 234                 query.Append("'");
 235                 query.Append(", URL = ");
 236                 query.Append("'");
 237                 query.Append(bookmarkUrl);
 238                 query.Append("'");
 239                 query.Append(", PARENT_BOOKMARK_ID = ");
 240                 query.Append(bookmark.GetParentId());
 241                 query.Append(", MODIFIED_TIME = ");
 242                 query.Append("'");
 243                 query.Append(dt.ToString());
 244                 query.Append("'");
 245                 query.Append(", ICON_PATH = ");
 246                 query.Append("'");
 247                 query.Append(bookmark.GetIconPath());
 248                 query.Append("'");
 249                 query.Append(", FAVICON_ID = ");
 250                 query.Append("'");
 251                 query.Append(bookmark.GetFaviconId());
 252                 query.Append("'");
 253                 query.Append(" WHERE ID = ");
 254                 query.Append(bookmark.GetBookmarkId());*/
 255         }
 256
 257         r = PresentationModelBase::ExecuteQuery(query, resultCount);
 258         AppLog("BookmarkPresentationModel::SaveBookmark query is %S",query.GetPointer());
 259
 260         if (r == E_SUCCESS)
 261         {
 262                 AppLog("BookmarkPresentationModel::SaveBookmark query is success");
 263         }
 264         else
 265         {
 266                 AppLog("BookmarkPresentationModel::SaveBookmark query is failure");
 267         }
 268
 269         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::SaveBookmark query failed  %s",GetErrorMessage(r));
 270
 271         r = PresentationModelBase::CommitDb();
 272
 273         r = GetLastInsertedId(bookmarkTable, rowId);
 274         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::SaveBookmark GetLastInsertedId failed %s",GetErrorMessage(r));
 275
 276         if (rowId < 0)
 277                 return E_FAILURE;
 278
 279         bookmarkId.Append(rowId);
 280
 281         //Set the generated ID to Bookmark
 282         bookmark.SetBookmarkId(bookmarkId);
 283
 284     CATCH: return r;
 285 }
 286
 287 result
 288 BookmarkPresentationModel::SaveTempBookmark(BookmarkData& bookmark)
 289 {
 290         result r = E_FAILURE;
 291         String bookmarkTable(BOOKMARK_URL_TABLE);
 292         String query;
 293         String columnNames;
 294         String attachment;
 295         int resultCount = -1;
 296         int rowId = -1;
 297         DateTime dt;
 298         String bookmarkId;
 299         String bookmarkTitle = bookmark.GetBookmarkTitle();
 300         bookmarkTitle.Replace(L"'", L"''");
 301         String bookmarkUrl = bookmark.GetUrl();
 302         bookmarkUrl.Replace(L"'", L"''");
 303
 304         PresentationModelBase::GetCurrentDateTime(dt);
 305
 306         if (bookmark.GetBookmarkId() == "")
 307         {
 308                 columnNames.Append(L"TYPE, ");
 309                 columnNames.Append(L"PARENT, ");
 310                 columnNames.Append(L"ADDRESS, ");
 311                 columnNames.Append(L"TITLE, ");
 312                 columnNames.Append(L"CREATIONDATE, ");
 313                 columnNames.Append(L"UPDATEDATE, ");
 314
 315                 columnNames.Append(L"FAVICON, ");
 316                 columnNames.Append(L"FAVICON_W, ");
 317                 columnNames.Append(L"FAVICON_H");
 318
 319                 query.Append(L"INSERT INTO ");
 320                 query.Append(bookmarkTable);
 321                 query.Append("(");
 322                 query.Append(columnNames);
 323                 query.Append(") ");
 324                 query.Append("VALUES");
 325                 query.Append(" (?,?,?,?,?,?,?,?,?)");
 326                 r = PresentationModelBase::ExecuteBookmarkQuery(query, resultCount, bookmark);
 327         }
 328         else
 329         {
 330                 query.Append(L"UPDATE ");
 331                 query.Append(bookmarkTable);
 332                 query.Append(" SET PARENT = ");
 333                 query.Append(bookmark.GetParentId());
 334                 query.Append(", ADDRESS = ");
 335                 query.Append("'");
 336                 query.Append(bookmarkUrl);
 337                 query.Append("'");
 338                 query.Append(", TITLE = ");
 339                 query.Append("'");
 340                 query.Append(bookmarkTitle);
 341                 query.Append("'");
 342                 query.Append(", UPDATEDATE = ");
 343                 query.Append("'");
 344                 query.Append(dt.ToString());
 345                 query.Append("'");
 346                 query.Append(" WHERE ID = ");
 347                 query.Append(bookmark.GetBookmarkId());
 348                 r = PresentationModelBase::ExecuteQuery(query, resultCount);
 349         }
 350
 351
 352         AppLog("BookmarkPresentationModel::SaveBookmark query is %S",query.GetPointer());
 353
 354         if (r == E_SUCCESS)
 355         {
 356                 AppLog("BookmarkPresentationModel::SaveBookmark query is success");
 357         }
 358         else
 359         {
 360                 AppLog("BookmarkPresentationModel::SaveBookmark query is failure");
 361         }
 362
 363         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::SaveBookmark query failed  %s",GetErrorMessage(r));
 364
 365         r = PresentationModelBase::CommitDb();
 366
 367         r = GetLastInsertedId(bookmarkTable, rowId);
 368         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::SaveBookmark GetLastInsertedId failed %s",GetErrorMessage(r));
 369
 370         if (rowId < 0)
 371                 return E_FAILURE;
 372
 373         bookmarkId.Append(rowId);
 374
 375         //Set the generated ID to Bookmark
 376         bookmark.SetBookmarkId(bookmarkId);
 377
 378     CATCH: return r;
 379
 380 }
 381
 382 result
 383 BookmarkPresentationModel::DeleteFolder(int folderId)
 384 {
 385         result r = E_SUCCESS;
 386         String query;
 387         String bookmarkTable(BOOKMARK_URL_TABLE);
 388         int resultCount = -1;
 389
 390         if (folderId < 1)
 391         {
 392                 return E_INVALID_ARG;
 393         }
 394
 395         //strQuery.Format(MAX_DB_QUERY_SIZE, L"DELETE FROM %ls WHERE ID = %d", strBookmarkTable.GetPointer(), bookmarkId);
 396         query.Append(L"DELETE FROM ");
 397         query.Append(bookmarkTable);
 398         query.Append(" WHERE ID = ");
 399         query.Append(folderId);
 400
 401         r = BookmarkPresentationModel::ExecuteQuery(query, resultCount);
 402         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DeleteBookmark query failed  %s",GetErrorMessage(r));
 403         r = BookmarkPresentationModel::CommitDb();
 404         DeleteBookmarkByFolderId(folderId);
 405
 406         CATCH: return r;
 407 }
 408
 409 result
 410 BookmarkPresentationModel::DeleteBookmark(int bookmarkId)
 411 {
 412         result r = E_SUCCESS;
 413         String query;
 414         String bookmarkTable(BOOKMARK_URL_TABLE);
 415         int resultCount = -1;
 416
 417         if (bookmarkId < 1)
 418         {
 419                 return E_INVALID_ARG;
 420         }
 421
 422         //strQuery.Format(MAX_DB_QUERY_SIZE, L"DELETE FROM %ls WHERE ID = %d", strBookmarkTable.GetPointer(), bookmarkId);
 423         query.Append(L"DELETE FROM ");
 424         query.Append(bookmarkTable);
 425         query.Append(" WHERE ID = ");
 426         query.Append(bookmarkId);
 427
 428         r = BookmarkPresentationModel::ExecuteQuery(query, resultCount);
 429         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DeleteBookmark query failed  %s",GetErrorMessage(r));
 430         r = BookmarkPresentationModel::CommitDb();
 431
 432         CATCH: return r;
 433 }
 434
 435 result
 436 BookmarkPresentationModel::DeleteBookmarkByFolderId(int folderId)
 437 {
 438         result r = E_SUCCESS;
 439         String query;
 440         String bookmarkTable(BOOKMARK_URL_TABLE);
 441         int resultCount = -1;
 442
 443         if (folderId < 1)
 444         {
 445                 return E_INVALID_ARG;
 446         }
 447
 448         //strQuery.Format(MAX_DB_QUERY_SIZE, L"DELETE FROM %ls WHERE ID = %d", strBookmarkTable.GetPointer(), bookmarkId);
 449         query.Append(L"DELETE FROM ");
 450         query.Append(bookmarkTable);
 451         query.Append(" WHERE PARENT = ");
 452         query.Append(folderId);
 453
 454         r = BookmarkPresentationModel::ExecuteQuery(query, resultCount);
 455         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DeleteBookmark query failed  %s",GetErrorMessage(r));
 456         r = BookmarkPresentationModel::CommitDb();
 457
 458         CATCH: return r;
 459 }
 460
 461
 462 result
 463 BookmarkPresentationModel::GetFolderBookmarkCount(const String& parentID, int& Count)
 464 {
 465         result r = E_SUCCESS;
 466         int bookmarkCount = 0;
 467         int folderCount = 0;
 468         r = GetBookmarkCount(parentID,bookmarkCount);
 469         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmarkCount query failed  %s",GetErrorMessage(r));
 470
 471         r = GetFolderCount(parentID,folderCount);
 472         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmarkCount query failed  %s",GetErrorMessage(r));
 473         Count = folderCount+ bookmarkCount;
 474         return E_SUCCESS;
 475         CATCH:
 476         return r;
 477 }
 478
 479 result
 480 BookmarkPresentationModel::GetBookmarkCount(const String& parentID, int& bookmarkCount)
 481 {
 482         int count = -1;
 483         int intVal = -1;
 484         String query;
 485         String bookmarkTable(BOOKMARK_URL_TABLE);
 486         result r = E_FAILURE;
 487         bool nextRowPresent = false;
 488
 489         //query.Format(MAX_DB_QUERY_SIZE, L"SELECT COUNT(ID) FROM %ls WHERE PARENT_ID = %ls", strTable.GetPointer(),notebookId.GetPointer());
 490         query.Append(L"SELECT COUNT(ID) FROM ");
 491         query.Append(bookmarkTable);
 492         query.Append(" WHERE PARENT = ");
 493         query.Append(parentID);
 494         query.Append(" AND ADDRESS != ''");
 495
 496
 497         r = PresentationModelBase::ExecuteQuery(query, count);
 498         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmarkCount query failed  %s",GetErrorMessage(r));
 499         r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
 500         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DbIsNextRowPresent query failed  %s",GetErrorMessage(r));
 501         if (nextRowPresent == true)
 502         {
 503                 r = PresentationModelBase::GetColumn(0, intVal);
 504                 if (IsFailed(r))
 505                 {
 506                         AppLogDebug("Error:BookmarkPresentationModel::GetColumn:%s", GetErrorMessage(r));
 507                         return r;
 508                 }
 509         }
 510         bookmarkCount = intVal;
 511         AppLog("Count:%d", bookmarkCount);
 512
 513         CATCH: return r;
 514 }
 515
 516 result
 517 BookmarkPresentationModel::GetFolderCount(const String& parentID, int& folderCount)
 518 {
 519
 520         int count = -1;
 521         int intVal = -1;
 522         String query;
 523         String bookmarkTable(BOOKMARK_URL_TABLE);
 524         result r = E_FAILURE;
 525         bool nextRowPresent = false;
 526
 527         //query.Format(MAX_DB_QUERY_SIZE, L"SELECT COUNT(ID) FROM %ls WHERE PARENT_ID = %ls", strTable.GetPointer(),notebookId.GetPointer());
 528         query.Append(L"SELECT COUNT(ID) FROM ");
 529         query.Append(bookmarkTable);
 530         query.Append(" WHERE PARENT = ");
 531         query.Append(parentID);
 532         query.Append(" AND ADDRESS = ''");
 533
 534         r = PresentationModelBase::ExecuteQuery(query, count);
 535         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmarkCount query failed  %s",GetErrorMessage(r));
 536         r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
 537         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DbIsNextRowPresent query failed  %s",GetErrorMessage(r));
 538         if (nextRowPresent == true)
 539         {
 540                 r = PresentationModelBase::GetColumn(0, intVal);
 541                 if (IsFailed(r))
 542                 {
 543                         AppLogDebug("Error:BookmarkPresentationModel::GetColumn:%s", GetErrorMessage(r));
 544                         return r;
 545                 }
 546         }
 547         folderCount = intVal;
 548         AppLog("Count:%d", folderCount);
 549
 550         CATCH: return r;
 551
 552
 553         /*
 554         int count = -1;
 555         int intVal = -1;
 556         String query;
 557         String bookmarkFolderTable(BOOKMARK_FOLDER_TABLE);
 558         result r = E_FAILURE;
 559         bool nextRowPresent = false;
 560
 561         if (parentID.CompareTo(DEFAULT_VALUE_PARENTID) != 0)
 562         {
 563                 folderCount = 0;
 564                 return E_SUCCESS;
 565         }
 566         query.Append(L"SELECT COUNT(ID) FROM ");
 567         query.Append(bookmarkFolderTable);
 568
 569         r = PresentationModelBase::ExecuteQuery(query, count);
 570         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetFolderCount query failed  %s",GetErrorMessage(r));
 571
 572         r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
 573
 574         if (nextRowPresent == true)
 575         {
 576                 r = PresentationModelBase::GetColumn(0, intVal);
 577         }
 578         folderCount = intVal;
 579
 580         CATCH: return r;
 581 */}
 582
 583 result
 584 BookmarkPresentationModel::GetFoldersBookmarks(const String& parentID, int startIndex, int limit, ArrayList& pBookmarkList)
 585 {
 586         ArrayList arrayList;
 587         arrayList.Construct();
 588         GetFolder(parentID,startIndex,limit,arrayList);
 589         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 590         {
 591                 pBookmarkList.Add(*arrayList.GetAt(index));
 592         }
 593         arrayList.RemoveAll(false);
 594         GetBookmark(parentID,startIndex,limit,arrayList);
 595         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 596         {
 597                 pBookmarkList.Add(*arrayList.GetAt(index));
 598         }
 599         return E_SUCCESS;
 600 }
 601
 602 result
 603 BookmarkPresentationModel::GetBookmark(const String& parentID, int startIndex, int limit, ArrayList& pBookmarkList)
 604 {
 605         int count = -1;
 606         String query;
 607         String bookmarkTable(BOOKMARK_URL_TABLE);
 608         result r = E_FAILURE;
 609
 610         query.Append(L"SELECT * FROM ");
 611         query.Append(bookmarkTable);
 612         query.Append(" WHERE PARENT = ");
 613         query.Append(parentID);
 614         query.Append(" AND ADDRESS != ''");
 615
 616         //Append LIMIT
 617         if (limit > 0)
 618         {
 619                 query.Append(" LIMIT ");
 620                 query.Append(limit);
 621
 622                 //Append OFFESET
 623                 if (startIndex >= 0)
 624                 {
 625                         query.Append(" OFFSET ");
 626                         query.Append(startIndex);
 627                 }
 628         }
 629         r = PresentationModelBase::ExecuteQuery(query, count);
 630         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmark query failed  %s",GetErrorMessage(r));
 631
 632         r = CreateBookmarkList(count, pBookmarkList);
 633         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 634
 635         CATCH: return r;
 636 }
 637
 638 result BookmarkPresentationModel::GetBookmarkForHistory(int startIndex, Tizen::Base::Collection::ArrayList& pBookmarkList)
 639 {
 640         int count = -1;
 641         String query;
 642         String bookmarkTable(BOOKMARK_URL_TABLE);
 643         result r = E_FAILURE;
 644
 645         query.Append(L"SELECT * FROM ");
 646         query.Append(bookmarkTable);
 647         query.Append(" WHERE ADDRESS != ''");
 648
 649         r = PresentationModelBase::ExecuteQuery(query, count);
 650         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetBookmark query failed  %s",GetErrorMessage(r));
 651
 652         r = CreateBookmarkList(count, pBookmarkList);
 653         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 654
 655         CATCH: return r;
 656 }
 657
 658 result
 659 BookmarkPresentationModel::GetFolder(const String& parentID, int startIndex, int limit, ArrayList& folderList)
 660 {
 661         int count = -1;
 662         String query;
 663         String bookmarkTable(BOOKMARK_URL_TABLE);
 664         result r = E_FAILURE;
 665
 666         if (parentID.CompareTo(DEFAULT_VALUE_PARENTID ) != 0)
 667         {
 668                 return E_SUCCESS;
 669         }
 670         query.Append(L"SELECT * FROM ");
 671         query.Append(bookmarkTable);
 672         query.Append(" WHERE ADDRESS = ''");
 673
 674         //Append LIMIT
 675         if (limit > 0)
 676         {
 677                 query.Append(" LIMIT ");
 678                 query.Append(limit);
 679
 680                 //Append OFFESET
 681                 if (startIndex >= 0)
 682                 {
 683                         query.Append(" OFFSET ");
 684                         query.Append(startIndex);
 685                 }
 686         }
 687
 688         r = PresentationModelBase::ExecuteQuery(query, count);
 689         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetFolder query failed  %s",GetErrorMessage(r));
 690
 691         r = CreateFolderList(count, folderList);
 692         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 693
 694         CATCH: return r;
 695 }
 696
 697 result
 698 BookmarkPresentationModel::GetSearchFolderBookmarkCount(int& searchBookmarkCount, String& text)
 699 {
 700         int searchUrlCount = 0;
 701         int searchFolderCount = 0;
 702         GetSearchBookmarkCount(searchUrlCount,text);
 703         GetSearchFolderCount(searchFolderCount,text);
 704         searchBookmarkCount = searchUrlCount + searchFolderCount;
 705         return E_SUCCESS;
 706 }
 707
 708 result
 709 BookmarkPresentationModel::GetSearchBookmarkCount(int& searchBookmarkCount, String& text)
 710 {
 711
 712         int count = -1;
 713         int intVal = -1;
 714         String query;
 715         String bookmarkTable(BOOKMARK_URL_TABLE);
 716         result r = E_FAILURE;
 717         bool nextRowPresent = false;
 718         text.Replace(L"'", L"''");
 719
 720         query.Append(L"SELECT COUNT(ID) FROM ");
 721         query.Append(bookmarkTable);
 722         query.Append(L" WHERE (TITLE LIKE '%");
 723         query.Append(text);
 724         query.Append("%'");
 725         query.Append(" OR ");
 726         query.Append(L"ADDRESS LIKE '%");
 727         query.Append(text);
 728         query.Append("%')");
 729         query.Append(" AND ADDRESS != ''");
 730
 731         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 732         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmarkCount query failed  %s",GetErrorMessage(r));
 733
 734         r = BookmarkPresentationModel::DbIsNextRowPresent(nextRowPresent);
 735
 736         if (nextRowPresent == true)
 737         {
 738                 r = BookmarkPresentationModel::GetColumn(0, intVal);
 739                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetColumn failed  %s",GetErrorMessage(r));
 740         }
 741         searchBookmarkCount = intVal;
 742
 743         CATCH: return r;
 744 }
 745
 746
 747 result
 748 BookmarkPresentationModel::GetSearchFolderCount(int& searchFolderCount, String& text)
 749 {
 750
 751         int count = -1;
 752         int intVal = -1;
 753         String query;
 754         String bookmarkTable(BOOKMARK_URL_TABLE);
 755         result r = E_FAILURE;
 756         bool nextRowPresent = false;
 757         text.Replace(L"'", L"''");
 758
 759         query.Append(L"SELECT COUNT(ID) FROM ");
 760         query.Append(bookmarkTable);
 761         query.Append(L" WHERE TITLE LIKE '%");
 762         query.Append(text);
 763         query.Append("%'");
 764         query.Append(" AND ADDRESS = ''");
 765
 766         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 767         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmarkCount query failed  %s",GetErrorMessage(r));
 768
 769         r = BookmarkPresentationModel::DbIsNextRowPresent(nextRowPresent);
 770
 771         if (nextRowPresent == true)
 772         {
 773                 r = BookmarkPresentationModel::GetColumn(0, intVal);
 774                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetColumn failed  %s",GetErrorMessage(r));
 775         }
 776         searchFolderCount = intVal;
 777
 778         CATCH: return r;
 779 }
 780
 781
 782 result
 783 BookmarkPresentationModel::GetSearchFoldersBookmarks(int startIndex, int limit, ArrayList& pFolderList, String& text)
 784 {
 785         ArrayList arrayList;
 786         arrayList.Construct();
 787         GetSearchFolder(startIndex, limit, arrayList,text);
 788         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 789         {
 790                 pFolderList.Add(*arrayList.GetAt(index));
 791         }
 792         arrayList.RemoveAll(false);
 793         GetSearchBookmark(startIndex, limit, arrayList,text);
 794         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 795         {
 796                 pFolderList.Add(*arrayList.GetAt(index));
 797         }
 798         return E_SUCCESS;
 799 }
 800
 801 result
 802 BookmarkPresentationModel::GetSearchBookmark(int startIndex, int limit, ArrayList& pBookmarkList, String& text)
 803 {
 804         int count = -1;
 805         String query;
 806         String bookmarkTable(BOOKMARK_URL_TABLE);
 807         result r = E_FAILURE;
 808
 809         text.Replace(L"'", L"''");
 810         query.Append(L"SELECT * FROM ");
 811         query.Append(bookmarkTable);
 812         query.Append(L" WHERE ((TITLE LIKE '%");
 813         query.Append(text);
 814         query.Append("%')");
 815         query.Append(" OR ");
 816         query.Append(L"(ADDRESS LIKE '%");
 817         query.Append(text);
 818         query.Append("%'))");
 819         query.Append(" AND (ADDRESS != '')");
 820         //Append LIMIT
 821         if (limit > 0)
 822         {
 823                 query.Append(" LIMIT ");
 824                 query.Append(limit);
 825
 826                 //Append OFFESET
 827                 if (startIndex >= 0)
 828                 {
 829                         query.Append(" OFFSET ");
 830                         query.Append(startIndex);
 831                 }
 832         }
 833         AppLog("Query is %ls", query.GetPointer());
 834         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 835         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmark query failed  %s",GetErrorMessage(r));
 836
 837         r = CreateBookmarkList(count, pBookmarkList);
 838         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 839
 840         CATCH: return r;
 841 }
 842
 843 result
 844 BookmarkPresentationModel::GetSearchFolder(int startIndex, int limit, ArrayList& pFolderList, String& text)
 845 {
 846         int count = -1;
 847         String query;
 848         String bookmarkTable(BOOKMARK_URL_TABLE);
 849         result r = E_FAILURE;
 850         text.Replace(L"'", L"''");
 851
 852         query.Append(L"SELECT * FROM ");
 853         query.Append(bookmarkTable);
 854         query.Append(L" WHERE TITLE LIKE '%");
 855         query.Append(text);
 856         //query.Append("%')");
 857         query.Append("%'");
 858         query.Append(" AND ADDRESS = ''");
 859
 860         //Append LIMIT
 861         if (limit > 0)
 862         {
 863                 query.Append(" LIMIT ");
 864                 query.Append(limit);
 865
 866                 //Append OFFESET
 867                 if (startIndex >= 0)
 868                 {
 869                         query.Append(" OFFSET ");
 870                         query.Append(startIndex);
 871                 }
 872         }
 873
 874         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 875         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmark query failed  %s",GetErrorMessage(r));
 876
 877         r = CreateFolderList(count, pFolderList);
 878         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 879
 880         CATCH: return r;
 881 }
 882
 883 result
 884 BookmarkPresentationModel::CreateFolderList(int bookmarkCount, ArrayList& folderList)
 885 {
 886         BookmarkData* pBookmark = null;
 887         int intVal = -1;
 888         String value;
 889         DateTime dateValue;
 890         result r = E_FAILURE;
 891         String bookmarkId;
 892         String parentId;
 893         String faviconId;
 894         DateTime createdTime;
 895         DateTime modifiedTime;
 896         String iconPath;
 897         bool nextRowPresent = false;
 898
 899         if (bookmarkCount < 1)
 900         {
 901                 return E_SUCCESS;
 902         }
 903         for (int l_bookmarkCount = 0; l_bookmarkCount < bookmarkCount; l_bookmarkCount++)
 904         {
 905                 r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
 906                 if (IsFailed(r))
 907                         return r;
 908                 if (nextRowPresent == true)
 909                 {
 910                         pBookmark = new(std::nothrow) BookmarkData;
 911
 912                         if (pBookmark)
 913                         {
 914                                 for (int columnCount = 0; columnCount < MAX_NOTE_TABLE_COLUMN; columnCount++)
 915                                 {
 916
 917                                         switch (columnCount)
 918                                         {
 919                                         case BOOKMARK_ID:
 920                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
 921                                                 if (!IsFailed(r))
 922                                                 {
 923                                                         if (intVal > 0)
 924                                                         {
 925                                                                 bookmarkId.Clear();
 926                                                                 bookmarkId.Append(intVal);
 927                                                                 if (bookmarkId.GetLength() > 0)
 928                                                                         pBookmark->SetBookmarkId(bookmarkId);
 929                                                         }
 930
 931                                                 }
 932                                                 break;
 933                                         case BOOKMARK_PARENT:
 934                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
 935                                                 if (!IsFailed(r))
 936                                                 {
 937                                                         if (intVal > 0)
 938                                                         {
 939                                                                 parentId.Clear();
 940                                                                 parentId.Append(intVal);
 941                                                                 if (parentId.GetLength() > 0)
 942                                                                         pBookmark->SetParentId(parentId);
 943                                                         }
 944                                                 }
 945                                                 break;
 946                                         case BOOKMARK_ADDRESS:
 947                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 948                                                 if (!IsFailed(r))
 949                                                 {
 950                                                         pBookmark->SetUrl(value);
 951                                                 }
 952                                                 break;
 953                                         case BOOKMARK_TITLE:
 954                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 955                                                 if (!IsFailed(r))
 956                                                 {
 957                                                         pBookmark->SetBookmarkTitle(value);
 958                                                 }
 959                                                 break;
 960                                         case BOOKMARK_CREATIONDATE:
 961                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
 962                                                 if (!IsFailed(r))
 963                                                 {
 964                                                         createdTime = dateValue;
 965                                                         pBookmark->SetCreatedTime(createdTime);
 966                                                 }
 967                                                 break;
 968
 969                                         case BOOKMARK_UPDATEDATA:
 970                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
 971                                                 if (!IsFailed(r))
 972                                                 {
 973                                                         modifiedTime = dateValue;
 974                                                         pBookmark->SetModifiedTime(modifiedTime);
 975                                                 }
 976                                                 break;
 977
 978                                                 /*case 6:
 979                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 980                                                 if (!IsFailed(r))
 981                                                 {
 982                                                         iconPath = value;
 983                                                         pBookmark->SetIconPath(iconPath);
 984                                                 }
 985                                                 break;
 986                                         case 7:
 987
 988                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
 989                                                 if (!IsFailed(r))
 990                                                 {
 991                                                         if (intVal >= 0)
 992                                                         {
 993                                                                 faviconId.Clear();
 994                                                                 faviconId.Append(intVal);
 995                                                                 if (faviconId.GetLength() > 0)
 996                                                                 {
 997                                                                         pBookmark->SetFaviconId(faviconId);
 998                                                                 }
 999                                                         }
1000                                                 }
1001                                                 break;*/
1002
1003                                         default:
1004                                                 break;
1005                                         }
1006
1007                                 }
1008
1009                                 r = folderList.Add(*pBookmark);
1010                                 if (IsFailed(r))
1011                                 {
1012                                         delete pBookmark;
1013                                         return r;
1014                                 }
1015                         }
1016                 }
1017         }
1018         return r;
1019 }
1020
1021 result
1022 BookmarkPresentationModel::CreateBookmarkList(int bookmarkCount, ArrayList& bookmarkList)
1023 {
1024         AppLog("BookmarkPresentationModel::CreateBookmarkList start");
1025         BookmarkData* pBookmark = null;
1026         int intVal = -1;
1027         String value;
1028         DateTime dateValue;
1029         result r = E_FAILURE;
1030         String bookmarkId;
1031         String parentId;
1032         String faviconId;
1033         DateTime createdTime;
1034         DateTime modifiedTime;
1035         ByteBuffer *pFavIconBuffer = null;
1036
1037         String iconPath;
1038         bool nextRowPresent = false;
1039
1040         if (bookmarkCount < 1)
1041         {
1042                 return E_SUCCESS;
1043         }
1044
1045         for (int l_bookmarkCount = 0; l_bookmarkCount < bookmarkCount; l_bookmarkCount++)
1046         {
1047                 r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
1048                 if (IsFailed(r))
1049                         return r;
1050                 if (nextRowPresent == true)
1051                 {
1052                         pBookmark = new(std::nothrow) BookmarkData;
1053                         if (pBookmark)
1054                         {
1055                                 for (int columnCount = 0; columnCount < MAX_NOTE_TABLE_COLUMN; columnCount++)
1056                                 {
1057
1058                                         switch (columnCount)
1059                                         {
1060                                         case BOOKMARK_ID:
1061                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1062                                                 if (!IsFailed(r))
1063                                                 {
1064                                                         if (intVal > 0)
1065                                                         {
1066                                                                 bookmarkId.Clear();
1067                                                                 bookmarkId.Append(intVal);
1068                                                                 if (bookmarkId.GetLength() > 0)
1069                                                                         pBookmark->SetBookmarkId(bookmarkId);
1070                                                         }
1071
1072                                                 }
1073                                                 break;
1074                                         case BOOKMARK_PARENT:
1075                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1076                                                 if (!IsFailed(r))
1077                                                 {
1078                                                         if (intVal > 0)
1079                                                         {
1080                                                                 parentId.Clear();
1081                                                                 parentId.Append(intVal);
1082                                                                 if (parentId.GetLength() > 0)
1083                                                                         pBookmark->SetParentId(parentId);
1084                                                         }
1085                                                 }
1086                                                 break;
1087                                         case BOOKMARK_ADDRESS:
1088                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1089                                                 if (!IsFailed(r))
1090                                                 {
1091                                                         pBookmark->SetUrl(value);
1092                                                 }
1093                                                 break;
1094                                         case BOOKMARK_TITLE:
1095                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1096                                                 if (!IsFailed(r))
1097                                                 {
1098                                                         pBookmark->SetBookmarkTitle(value);
1099                                                 }
1100                                                 break;
1101                                         case BOOKMARK_CREATIONDATE:
1102                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
1103                                                 if (!IsFailed(r))
1104                                                 {
1105                                                         createdTime = dateValue;
1106                                                         pBookmark->SetCreatedTime(createdTime);
1107                                                 }
1108                                                 break;
1109                                         case BOOKMARK_SEQUENCE:
1110                                         {
1111
1112                                         }
1113                                         break;
1114                                         case BOOKMARK_UPDATEDATA:
1115                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
1116                                                 if (!IsFailed(r))
1117                                                 {
1118                                                         modifiedTime = dateValue;
1119                                                         pBookmark->SetModifiedTime(modifiedTime);
1120                                                 }
1121                                                 break;
1122                                         case BOOKMARK_VISITDATE:
1123                                         {
1124
1125                                         }
1126                                         break;
1127                                         case BOOKMARK_EDITABLE:
1128                                         {
1129
1130                                         }
1131                                         break;
1132                                         case BOOKMARK_ACCESSACCOUNT:
1133                                         {
1134
1135                                         }
1136                                         break;
1137                                         case BOOKMARK_FAVICON:
1138                                         {
1139                                                 AppLog("BookmarkPresentationModel::CreateBookmarkList BOOKMARK_FAVICON 0");
1140                                                 pFavIconBuffer = new ByteBuffer();
1141                                                 r = PresentationModelBase::GetColumn(columnCount, *pFavIconBuffer);
1142                                                 AppLog("BookmarkPresentationModel::CreateBookmarkList BOOKMARK_FAVICON 1");
1143                                                 if (pFavIconBuffer->GetCapacity() > 0)
1144                                                 {
1145                                                         AppLog("BookmarkPresentationModel::CreateBookmarkList favIconBuffer not null");
1146                                                 }
1147                                                 else
1148                                                 {
1149                                                         AppLog("BookmarkPresentationModel::CreateBookmarkList favIconBuffer is null");
1150                                                 }
1151
1152                                                 if (!IsFailed(r))
1153                                                 {
1154                                                         iconPath = value;
1155                                                         pBookmark->SetFavIconBuffer(*pFavIconBuffer);
1156                                                 }
1157                                         }
1158                                         break;
1159                                         case BOOKMARK_FAVICON_LENGTH:
1160                                         {
1161
1162                                         }
1163                                         break;
1164                                         case BOOKMARK_FAVICON_W:
1165                                         {
1166                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1167                                                 if (!IsFailed(r))
1168                                                 {
1169                                                         if (intVal > 0)
1170                                                         {
1171                                                                 pBookmark->SetFavIconWidth(intVal);
1172                                                         }
1173                                                 }
1174                                         }
1175                                         break;
1176                                         case BOOKMARK_FAVICON_H:
1177                                         {
1178                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1179                                                 if (!IsFailed(r))
1180                                                 {
1181                                                         if (intVal > 0)
1182                                                         {
1183                                                                 pBookmark->SetFavIconHeight(intVal);
1184                                                         }
1185                                                 }
1186                                         }
1187                                         break;
1188                                                 /*
1189                                                  *case 6:
1190                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1191                                                 if (!IsFailed(r))
1192                                                 {
1193                                                         iconPath = value;
1194                                                         pBookmark->SetIconPath(iconPath);
1195                                                 }
1196                                                 break;
1197                                         case 7:
1198
1199                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1200                                                 if (!IsFailed(r))
1201                                                 {
1202                                                         if (intVal >= 0)
1203                                                         {
1204                                                                 faviconId.Clear();
1205                                                                 faviconId.Append(intVal);
1206                                                                 if (faviconId.GetLength() > 0)
1207                                                                 {
1208                                                                         pBookmark->SetFaviconId(faviconId);
1209                                                                 }
1210                                                         }
1211                                                 }
1212                                                 break;*/
1213
1214                                         default:
1215                                                 break;
1216                                         }
1217
1218                                 }
1219
1220                                 r = bookmarkList.Add(*pBookmark);
1221                                 if (IsFailed(r))
1222                                 {
1223                                         delete pBookmark;
1224                                         return r;
1225                                 }
1226                         }
1227                 }
1228         }
1229         AppLog("BookmarkPresentationModel::CreateBookmarkList end");
1230         return r;
1231 }
1232
1233 result
1234 BookmarkPresentationModel::DoesBookmarkExist(const Tizen::Base::String& Url, bool &exist, const String& parentId, bool checkParentId)
1235 {
1236         int bookmarkCount = -1;
1237         int intVal = -1;
1238         String query;
1239         String bookmarkTable(BOOKMARK_URL_TABLE);
1240         result r = E_FAILURE;
1241         bool nextRowPresent = false;
1242         int count = 0;
1243
1244         query.Append(L"SELECT COUNT(ID) FROM ");
1245         query.Append(bookmarkTable);
1246         query.Append(" WHERE ADDRESS = '");
1247         query.Append(Url);
1248         if(checkParentId == true)
1249         {
1250                 query.Append(L"' AND PARENT = '");
1251                 query.Append(parentId);
1252         }
1253         query.Append("'");
1254
1255         AppLog("BookmarkPresentationModel::DoesBookmarkExist query is %S",query.GetPointer());
1256
1257         r = PresentationModelBase::ExecuteQuery(query, bookmarkCount);
1258         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DoesBookmarkExist query failed  %s",GetErrorMessage(r));
1259
1260         r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
1261
1262         if (nextRowPresent == true)
1263         {
1264                 r = PresentationModelBase::GetColumn(0, intVal);
1265         }
1266         count = intVal;
1267
1268         if (count == 0)
1269         {
1270                 exist = false;
1271         }
1272         else
1273         {
1274                 exist = true ;
1275         }
1276
1277         CATCH: return r;
1278 }
1279
1280 result
1281 BookmarkPresentationModel::DeleteBookmark(const Tizen::Base::String& url)
1282 {
1283         result r = E_SUCCESS;
1284         String query;
1285         String bookmarkTable(BOOKMARK_URL_TABLE);
1286         int resultCount = -1;
1287
1288         query.Append(L"DELETE FROM ");
1289         query.Append(bookmarkTable);
1290         query.Append(" WHERE ADDRESS = '");
1291         query.Append(url);
1292         query.Append(L"'");
1293
1294         r = BookmarkPresentationModel::ExecuteQuery(query, resultCount);
1295         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DeleteBookmark query failed  %s",GetErrorMessage(r));
1296
1297         r = BookmarkPresentationModel::CommitDb();
1298
1299         CATCH: return r;
1300 }