src/IntBookmarkPresentationModel.cpp

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