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