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(" ESCAPE '/')");
 730         query.Append(" AND ADDRESS != ''");
 731
 732         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 733         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmarkCount query failed  %s",GetErrorMessage(r));
 734
 735         r = BookmarkPresentationModel::DbIsNextRowPresent(nextRowPresent);
 736
 737         if (nextRowPresent == true)
 738         {
 739                 r = BookmarkPresentationModel::GetColumn(0, intVal);
 740                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetColumn failed  %s",GetErrorMessage(r));
 741         }
 742         searchBookmarkCount = intVal;
 743
 744         CATCH:
 745 //      text.Replace(L"''", L"'");
 746         return r;
 747
 748 }
 749
 750
 751 result
 752 BookmarkPresentationModel::GetSearchFolderCount(int& searchFolderCount, String& text)
 753 {
 754
 755         int count = -1;
 756         int intVal = -1;
 757         String query;
 758         String bookmarkTable(BOOKMARK_URL_TABLE);
 759         result r = E_FAILURE;
 760         bool nextRowPresent = false;
 761         text.Replace(L"'", L"\'");
 762
 763         query.Append(L"SELECT COUNT(ID) FROM ");
 764         query.Append(bookmarkTable);
 765         query.Append(L" WHERE TITLE LIKE '%");
 766         query.Append(text);
 767         query.Append("%'");
 768         query.Append(" ESCAPE '/'");
 769         query.Append(" AND ADDRESS = ''");
 770
 771         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 772         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmarkCount query failed  %s",GetErrorMessage(r));
 773
 774         r = BookmarkPresentationModel::DbIsNextRowPresent(nextRowPresent);
 775
 776         if (nextRowPresent == true)
 777         {
 778                 r = BookmarkPresentationModel::GetColumn(0, intVal);
 779                 TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetColumn failed  %s",GetErrorMessage(r));
 780         }
 781         searchFolderCount = intVal;
 782
 783         CATCH:
 784 //      text.Replace(L"''", L"'");
 785         return r;
 786 }
 787
 788
 789 result
 790 BookmarkPresentationModel::GetSearchFoldersBookmarks(int startIndex, int limit, ArrayList& pFolderList, String& text)
 791 {
 792         ArrayList arrayList;
 793         arrayList.Construct();
 794         GetSearchFolder(startIndex, limit, arrayList,text);
 795         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 796         {
 797                 pFolderList.Add(*arrayList.GetAt(index));
 798         }
 799         arrayList.RemoveAll(false);
 800         GetSearchBookmark(startIndex, limit, arrayList,text);
 801         for(int index = arrayList.GetCount()-1; index >= 0; index--)
 802         {
 803                 pFolderList.Add(*arrayList.GetAt(index));
 804         }
 805         return E_SUCCESS;
 806 }
 807
 808 result
 809 BookmarkPresentationModel::GetSearchBookmark(int startIndex, int limit, ArrayList& pBookmarkList, String& text)
 810 {
 811         int count = -1;
 812         String query;
 813         String bookmarkTable(BOOKMARK_URL_TABLE);
 814         result r = E_FAILURE;
 815
 816         text.Replace(L"'", L"\'");
 817         query.Append(L"SELECT * FROM ");
 818         query.Append(bookmarkTable);
 819         query.Append(L" WHERE ((TITLE LIKE '%");
 820         query.Append(text);
 821         query.Append("%' ESCAPE '/')");
 822         query.Append(" OR ");
 823         query.Append(L"(ADDRESS LIKE '%");
 824         query.Append(text);
 825         query.Append("%' ESCAPE '/') )");
 826         query.Append(" AND (ADDRESS != '')");
 827         //Append LIMIT
 828         if (limit > 0)
 829         {
 830                 query.Append(" LIMIT ");
 831                 query.Append(limit);
 832
 833                 //Append OFFESET
 834                 if (startIndex >= 0)
 835                 {
 836                         query.Append(" OFFSET ");
 837                         query.Append(startIndex);
 838                 }
 839         }
 840         AppLog("Query is %ls", query.GetPointer());
 841         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 842         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmark query failed  %s",GetErrorMessage(r));
 843
 844         r = CreateBookmarkList(count, pBookmarkList);
 845         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 846
 847         CATCH:
 848 //      text.Replace(L"''", L"'");
 849         return r;
 850 }
 851
 852 result
 853 BookmarkPresentationModel::GetSearchFolder(int startIndex, int limit, ArrayList& pFolderList, String& text)
 854 {
 855         int count = -1;
 856         String query;
 857         String bookmarkTable(BOOKMARK_URL_TABLE);
 858         result r = E_FAILURE;
 859         text.Replace(L"'", L"\'");
 860
 861         query.Append(L"SELECT * FROM ");
 862         query.Append(bookmarkTable);
 863         query.Append(L" WHERE TITLE LIKE '%");
 864         query.Append(text);
 865         //query.Append("%')");
 866         query.Append("%'");
 867         query.Append(" ESCAPE '/'");
 868         query.Append(" AND ADDRESS = ''");
 869
 870         //Append LIMIT
 871         if (limit > 0)
 872         {
 873                 query.Append(" LIMIT ");
 874                 query.Append(limit);
 875
 876                 //Append OFFESET
 877                 if (startIndex >= 0)
 878                 {
 879                         query.Append(" OFFSET ");
 880                         query.Append(startIndex);
 881                 }
 882         }
 883
 884         r = BookmarkPresentationModel::ExecuteQuery(query, count);
 885         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::GetSearchBookmark query failed  %s",GetErrorMessage(r));
 886
 887         r = CreateFolderList(count, pFolderList);
 888         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::CreateBookmarkList failed  %s",GetErrorMessage(r));
 889
 890         CATCH:
 891 //      text.Replace(L"''", L"'");
 892         return r;
 893 }
 894
 895 result
 896 BookmarkPresentationModel::CreateFolderList(int bookmarkCount, ArrayList& folderList)
 897 {
 898         BookmarkData* pBookmark = null;
 899         int intVal = -1;
 900         String value;
 901         DateTime dateValue;
 902         result r = E_FAILURE;
 903         String bookmarkId;
 904         String parentId;
 905         String faviconId;
 906         DateTime createdTime;
 907         DateTime modifiedTime;
 908         String iconPath;
 909         bool nextRowPresent = false;
 910
 911         if (bookmarkCount < 1)
 912         {
 913                 return E_SUCCESS;
 914         }
 915         for (int l_bookmarkCount = 0; l_bookmarkCount < bookmarkCount; l_bookmarkCount++)
 916         {
 917                 r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
 918                 if (IsFailed(r))
 919                         return r;
 920                 if (nextRowPresent == true)
 921                 {
 922                         pBookmark = new(std::nothrow) BookmarkData;
 923
 924                         if (pBookmark)
 925                         {
 926                                 for (int columnCount = 0; columnCount < MAX_NOTE_TABLE_COLUMN; columnCount++)
 927                                 {
 928
 929                                         switch (columnCount)
 930                                         {
 931                                         case BOOKMARK_ID:
 932                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
 933                                                 if (!IsFailed(r))
 934                                                 {
 935                                                         if (intVal > 0)
 936                                                         {
 937                                                                 bookmarkId.Clear();
 938                                                                 bookmarkId.Append(intVal);
 939                                                                 if (bookmarkId.GetLength() > 0)
 940                                                                         pBookmark->SetBookmarkId(bookmarkId);
 941                                                         }
 942
 943                                                 }
 944                                                 break;
 945                                         case BOOKMARK_PARENT:
 946                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
 947                                                 if (!IsFailed(r))
 948                                                 {
 949                                                         if (intVal > 0)
 950                                                         {
 951                                                                 parentId.Clear();
 952                                                                 parentId.Append(intVal);
 953                                                                 if (parentId.GetLength() > 0)
 954                                                                         pBookmark->SetParentId(parentId);
 955                                                         }
 956                                                 }
 957                                                 break;
 958                                         case BOOKMARK_ADDRESS:
 959                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 960                                                 if (!IsFailed(r))
 961                                                 {
 962                                                         pBookmark->SetUrl(value);
 963                                                 }
 964                                                 break;
 965                                         case BOOKMARK_TITLE:
 966                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 967                                                 if (!IsFailed(r))
 968                                                 {
 969                                                         pBookmark->SetBookmarkTitle(value);
 970                                                 }
 971                                                 break;
 972                                         case BOOKMARK_CREATIONDATE:
 973                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
 974                                                 if (!IsFailed(r))
 975                                                 {
 976                                                         createdTime = dateValue;
 977                                                         pBookmark->SetCreatedTime(createdTime);
 978                                                 }
 979                                                 break;
 980
 981                                         case BOOKMARK_UPDATEDATA:
 982                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
 983                                                 if (!IsFailed(r))
 984                                                 {
 985                                                         modifiedTime = dateValue;
 986                                                         pBookmark->SetModifiedTime(modifiedTime);
 987                                                 }
 988                                                 break;
 989
 990                                                 /*case 6:
 991                                                 r = PresentationModelBase::GetColumn(columnCount, value);
 992                                                 if (!IsFailed(r))
 993                                                 {
 994                                                         iconPath = value;
 995                                                         pBookmark->SetIconPath(iconPath);
 996                                                 }
 997                                                 break;
 998                                         case 7:
 999
1000                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1001                                                 if (!IsFailed(r))
1002                                                 {
1003                                                         if (intVal >= 0)
1004                                                         {
1005                                                                 faviconId.Clear();
1006                                                                 faviconId.Append(intVal);
1007                                                                 if (faviconId.GetLength() > 0)
1008                                                                 {
1009                                                                         pBookmark->SetFaviconId(faviconId);
1010                                                                 }
1011                                                         }
1012                                                 }
1013                                                 break;*/
1014
1015                                         default:
1016                                                 break;
1017                                         }
1018
1019                                 }
1020
1021                                 r = folderList.Add(*pBookmark);
1022                                 if (IsFailed(r))
1023                                 {
1024                                         delete pBookmark;
1025                                         return r;
1026                                 }
1027                         }
1028                 }
1029         }
1030         return r;
1031 }
1032
1033 result
1034 BookmarkPresentationModel::CreateBookmarkList(int bookmarkCount, ArrayList& bookmarkList)
1035 {
1036         AppLog("BookmarkPresentationModel::CreateBookmarkList start");
1037         BookmarkData* pBookmark = null;
1038         int intVal = -1;
1039         String value;
1040         DateTime dateValue;
1041         result r = E_FAILURE;
1042         String bookmarkId;
1043         String parentId;
1044         String faviconId;
1045         DateTime createdTime;
1046         DateTime modifiedTime;
1047         ByteBuffer *pFavIconBuffer = null;
1048
1049         String iconPath;
1050         bool nextRowPresent = false;
1051
1052         if (bookmarkCount < 1)
1053         {
1054                 return E_SUCCESS;
1055         }
1056
1057         for (int l_bookmarkCount = 0; l_bookmarkCount < bookmarkCount; l_bookmarkCount++)
1058         {
1059                 r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
1060                 if (IsFailed(r))
1061                         return r;
1062                 if (nextRowPresent == true)
1063                 {
1064                         pBookmark = new(std::nothrow) BookmarkData;
1065                         if (pBookmark)
1066                         {
1067                                 for (int columnCount = 0; columnCount < MAX_NOTE_TABLE_COLUMN; columnCount++)
1068                                 {
1069
1070                                         switch (columnCount)
1071                                         {
1072                                         case BOOKMARK_ID:
1073                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1074                                                 if (!IsFailed(r))
1075                                                 {
1076                                                         if (intVal > 0)
1077                                                         {
1078                                                                 bookmarkId.Clear();
1079                                                                 bookmarkId.Append(intVal);
1080                                                                 if (bookmarkId.GetLength() > 0)
1081                                                                         pBookmark->SetBookmarkId(bookmarkId);
1082                                                         }
1083
1084                                                 }
1085                                                 break;
1086                                         case BOOKMARK_PARENT:
1087                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1088                                                 if (!IsFailed(r))
1089                                                 {
1090                                                         if (intVal > 0)
1091                                                         {
1092                                                                 parentId.Clear();
1093                                                                 parentId.Append(intVal);
1094                                                                 if (parentId.GetLength() > 0)
1095                                                                         pBookmark->SetParentId(parentId);
1096                                                         }
1097                                                 }
1098                                                 break;
1099                                         case BOOKMARK_ADDRESS:
1100                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1101                                                 if (!IsFailed(r))
1102                                                 {
1103                                                         pBookmark->SetUrl(value);
1104                                                 }
1105                                                 break;
1106                                         case BOOKMARK_TITLE:
1107                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1108                                                 if (!IsFailed(r))
1109                                                 {
1110                                                         pBookmark->SetBookmarkTitle(value);
1111                                                 }
1112                                                 break;
1113                                         case BOOKMARK_CREATIONDATE:
1114                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
1115                                                 if (!IsFailed(r))
1116                                                 {
1117                                                         createdTime = dateValue;
1118                                                         pBookmark->SetCreatedTime(createdTime);
1119                                                 }
1120                                                 break;
1121                                         case BOOKMARK_SEQUENCE:
1122                                         {
1123
1124                                         }
1125                                         break;
1126                                         case BOOKMARK_UPDATEDATA:
1127                                                 r = PresentationModelBase::GetColumn(columnCount, dateValue);
1128                                                 if (!IsFailed(r))
1129                                                 {
1130                                                         modifiedTime = dateValue;
1131                                                         pBookmark->SetModifiedTime(modifiedTime);
1132                                                 }
1133                                                 break;
1134                                         case BOOKMARK_VISITDATE:
1135                                         {
1136
1137                                         }
1138                                         break;
1139                                         case BOOKMARK_EDITABLE:
1140                                         {
1141
1142                                         }
1143                                         break;
1144                                         case BOOKMARK_ACCESSACCOUNT:
1145                                         {
1146
1147                                         }
1148                                         break;
1149                                         case BOOKMARK_FAVICON:
1150                                         {
1151                                                 AppLog("BookmarkPresentationModel::CreateBookmarkList BOOKMARK_FAVICON 0");
1152                                                 pFavIconBuffer = new ByteBuffer();
1153                                                 r = PresentationModelBase::GetColumn(columnCount, *pFavIconBuffer);
1154                                                 AppLog("BookmarkPresentationModel::CreateBookmarkList BOOKMARK_FAVICON 1");
1155                                                 if (pFavIconBuffer->GetCapacity() > 0)
1156                                                 {
1157                                                         AppLog("BookmarkPresentationModel::CreateBookmarkList favIconBuffer not null");
1158                                                 }
1159                                                 else
1160                                                 {
1161                                                         AppLog("BookmarkPresentationModel::CreateBookmarkList favIconBuffer is null");
1162                                                 }
1163
1164                                                 if (!IsFailed(r))
1165                                                 {
1166                                                         iconPath = value;
1167                                                         pBookmark->SetFavIconBuffer(*pFavIconBuffer);
1168                                                 }
1169                                         }
1170                                         break;
1171                                         case BOOKMARK_FAVICON_LENGTH:
1172                                         {
1173
1174                                         }
1175                                         break;
1176                                         case BOOKMARK_FAVICON_W:
1177                                         {
1178                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1179                                                 if (!IsFailed(r))
1180                                                 {
1181                                                         if (intVal > 0)
1182                                                         {
1183                                                                 pBookmark->SetFavIconWidth(intVal);
1184                                                         }
1185                                                 }
1186                                         }
1187                                         break;
1188                                         case BOOKMARK_FAVICON_H:
1189                                         {
1190                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1191                                                 if (!IsFailed(r))
1192                                                 {
1193                                                         if (intVal > 0)
1194                                                         {
1195                                                                 pBookmark->SetFavIconHeight(intVal);
1196                                                         }
1197                                                 }
1198                                         }
1199                                         break;
1200                                                 /*
1201                                                  *case 6:
1202                                                 r = PresentationModelBase::GetColumn(columnCount, value);
1203                                                 if (!IsFailed(r))
1204                                                 {
1205                                                         iconPath = value;
1206                                                         pBookmark->SetIconPath(iconPath);
1207                                                 }
1208                                                 break;
1209                                         case 7:
1210
1211                                                 r = PresentationModelBase::GetColumn(columnCount, intVal);
1212                                                 if (!IsFailed(r))
1213                                                 {
1214                                                         if (intVal >= 0)
1215                                                         {
1216                                                                 faviconId.Clear();
1217                                                                 faviconId.Append(intVal);
1218                                                                 if (faviconId.GetLength() > 0)
1219                                                                 {
1220                                                                         pBookmark->SetFaviconId(faviconId);
1221                                                                 }
1222                                                         }
1223                                                 }
1224                                                 break;*/
1225
1226                                         default:
1227                                                 break;
1228                                         }
1229
1230                                 }
1231
1232                                 r = bookmarkList.Add(*pBookmark);
1233                                 if (IsFailed(r))
1234                                 {
1235                                         delete pBookmark;
1236                                         return r;
1237                                 }
1238                         }
1239                 }
1240         }
1241         AppLog("BookmarkPresentationModel::CreateBookmarkList end");
1242         return r;
1243 }
1244
1245 result
1246 BookmarkPresentationModel::DoesBookmarkExist(const Tizen::Base::String& Url, bool &exist, const String& parentId, bool checkParentId)
1247 {
1248         int bookmarkCount = -1;
1249         int intVal = -1;
1250         String query;
1251         String bookmarkTable(BOOKMARK_URL_TABLE);
1252         result r = E_FAILURE;
1253         bool nextRowPresent = false;
1254         int count = 0;
1255
1256         query.Append(L"SELECT COUNT(ID) FROM ");
1257         query.Append(bookmarkTable);
1258         query.Append(" WHERE ADDRESS = '");
1259         query.Append(Url);
1260         if(Url.EndsWith(L"/"))
1261         {
1262                 query.Append("' OR ADDRESS = '");
1263                 String newUrl = L"";
1264                 Url.SubString(0,Url.GetLength()-1 ,newUrl);
1265                 query.Append(newUrl);
1266         }
1267         else
1268         {
1269                 query.Append("' OR ADDRESS = '");
1270                 String newUrl = Url;
1271 //              Url.SubString(0,Url.GetLength()-1 ,newUrl);
1272                 newUrl.Append(L"/");
1273                 query.Append(newUrl);
1274         }
1275
1276         if(checkParentId == true)
1277         {
1278                 query.Append(L"' AND PARENT = '");
1279                 query.Append(parentId);
1280         }
1281         query.Append("'");
1282
1283         AppLog("BookmarkPresentationModel::DoesBookmarkExist query is %S",query.GetPointer());
1284
1285         r = PresentationModelBase::ExecuteQuery(query, bookmarkCount);
1286         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DoesBookmarkExist query failed  %s",GetErrorMessage(r));
1287
1288         r = PresentationModelBase::DbIsNextRowPresent(nextRowPresent);
1289
1290         if (nextRowPresent == true)
1291         {
1292                 r = PresentationModelBase::GetColumn(0, intVal);
1293         }
1294         count = intVal;
1295
1296         if (count == 0)
1297         {
1298                 exist = false;
1299         }
1300         else
1301         {
1302                 exist = true ;
1303         }
1304
1305         CATCH: return r;
1306 }
1307
1308 result
1309 BookmarkPresentationModel::DeleteBookmark(const Tizen::Base::String& url)
1310 {
1311         result r = E_SUCCESS;
1312         String query;
1313         String bookmarkTable(BOOKMARK_URL_TABLE);
1314         int resultCount = -1;
1315
1316         query.Append(L"DELETE FROM ");
1317         query.Append(bookmarkTable);
1318         query.Append(" WHERE ADDRESS = '");
1319         query.Append(url);
1320
1321         if(url.EndsWith(L"/"))
1322         {
1323                 query.Append("' OR ADDRESS = '");
1324                 String newUrl = L"";
1325                 url.SubString(0,url.GetLength()-1 ,newUrl);
1326                 query.Append(newUrl);
1327         }
1328         else
1329         {
1330                 query.Append("' OR ADDRESS = '");
1331                 String newUrl = url;
1332 //              Url.SubString(0,Url.GetLength()-1 ,newUrl);
1333                 newUrl.Append(L"/");
1334                 query.Append(newUrl);
1335
1336         }
1337
1338         query.Append(L"'");
1339
1340         r = BookmarkPresentationModel::ExecuteQuery(query, resultCount);
1341         TryCatch( r == E_SUCCESS,,"BookmarkPresentationModel::DeleteBookmark query failed  %s",GetErrorMessage(r));
1342
1343         r = BookmarkPresentationModel::CommitDb();
1344
1345         CATCH: return r;
1346 }