src/platform/Tizen/Account/AccountWrapper.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 /**
  19  * @file        AccountWrapper.cpp
  20  * @author      Jihwa Park (jh7979.park@samsung.com)
  21  * @author      Sangtai Kim
  22  * @version     0.1
  23  */
  24
  25 #include <string.h>
  26 #include <algorithm>
  27 #include <pcrecpp.h>
  28 #include <dpl/log/log.h>
  29 #include <Commons/Exception.h>
  30 #include "AccountWrapper.h"
  31 #include "AccountService.h"
  32 #include "account.h"
  33
  34 #include "db-util.h"
  35
  36 using namespace TizenApis::Api::Account;
  37 using namespace WrtDeviceApis::Commons;
  38 //using namespace WrtDeviceApis::CommonsJavaScript;
  39
  40  // For Test
  41
  42 #define _QUERY_DB_NAME "/opt/dbspace/.test-accounts.db"
  43 #define _QUERY_SQL_STRING_LEN           4096    //short sql string length
  44 #define _USER_ACCOUNT_TABLE_NAME "user_account"
  45 #define _SERVICES_TABLE_NAME "service"
  46 #define _SERVICETYPE_TABLE_NAME "service_type"
  47 #define _PROVIDER_LIST_TABLE_NAME "provider_list"
  48 #define _TAGS_MIME_TABLE_NAME "tags_mime"
  49 #define _RELATION_TABLE_NAME "relation"
  50 #define _REL_PROVIDER_TABLE_NAME "provider_to_svctype"
  51
  52 static sqlite3 *test_hDBCt;
  53 typedef sqlite3_stmt* stmt;
  54
  55 #define __USER_ACCOUNT_SCHEMA  "create table %s \n"\
  56 "(\n"\
  57         "user_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
  58         "displayname TEXT, "\
  59         "icon TEXT, "\
  60         "account_id TEXT, "\
  61         "enable INTEGER, "\
  62         "credential_id REAL, "\
  63         "settings TEXT, "\
  64         "provider_id TEXT, "\
  65         "login_id TEXT, "\
  66         "_list_id INTEGER "\
  67 ");"
  68
  69 #define __SERVICE_SCHEMA  "create table %s \n"\
  70 "(\n"\
  71         "_svc_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
  72         "service_id TEXT, "\
  73         "service_name TEXT, "\
  74         "application_id TEXT, "\
  75         "display_name TEXT, "\
  76         "icon TEXT, "\
  77         "serviceType_id TEXT,  "\
  78         "provider_id TEXT,  "\
  79         "setting TEXT, "\
  80         "enable INTEGER DEFAULT 0"\
  81 ");"
  82
  83 #define __SERVICETYPE_SCHEMA  "create table %s \n"\
  84 "(\n"\
  85         "type_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
  86         "serviceType_id TEXT, "\
  87         "display_name TEXT, "\
  88         "icon TEXT "\
  89 ");"
  90
  91 #define __TAGS_MIMETYPE_SCHEMA  "create table %s \n"\
  92 "(\n"\
  93         "tags_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
  94         "tag_name TEXT "\
  95 ");"
  96
  97 #define __RELATION_SCHEMA  "create table %s \n"\
  98 "(\n"\
  99         "relation_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
 100         "tags_id INTEGER, "\
 101         "_svc_id INTEGER, "\
 102         "type_id INTEGER, "\
 103         "tag_name TEXT "\
 104 ");"
 105
 106 #define __REL_PROVIDER_SCHEMA  "create table %s \n"\
 107 "(\n"\
 108         "_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
 109         "_list_id INTEGER, "\
 110         "type_id INTEGER "\
 111 ");"
 112
 113 #define __PROVIDER_LIST_SCHEMA  "create table %s \n"\
 114 "(\n"\
 115         "_list_id INTEGER PRIMARY KEY AUTOINCREMENT, "\
 116         "provider_id TEXT, "\
 117         "display_name TEXT, "\
 118         "icon TEXT "\
 119 ");"
 120
 121 stmt __query_prepare(char *query)
 122 {
 123         int rc = -1;
 124         stmt pStmt = NULL;
 125
 126         printf("!! query : %s \n", query);
 127
 128         rc = sqlite3_prepare_v2(test_hDBCt, query, strlen(query), &pStmt, NULL);
 129
 130         if(SQLITE_OK != rc)
 131         {
 132                 return NULL;
 133         }
 134
 135         return pStmt;
 136 }
 137
 138 int _query_exec(char *query)
 139 {
 140    int rc = -1;
 141    char* pszErrorMsg = NULL;
 142
 143     rc = sqlite3_exec(test_hDBCt, query, NULL, NULL, &pszErrorMsg);
 144    if(SQLITE_OK != rc)
 145    {
 146        sqlite3_free(pszErrorMsg);
 147    }
 148
 149    return rc;
 150 }
 151
 152 int
 153 _create_all_tables(void)
 154 {
 155         int rc = -1;
 156         int error_code = 0;
 157         char    query[_QUERY_SQL_STRING_LEN + 1] = {0, };
 158
 159         //Create test table
 160         {
 161                 memset(query, 0, sizeof(query));
 162                 snprintf(query, sizeof(query) - 1,  __USER_ACCOUNT_SCHEMA, _USER_ACCOUNT_TABLE_NAME);
 163                 rc = _query_exec(query);
 164
 165                 memset(query, 0, sizeof(query));
 166                 snprintf(query, sizeof(query) - 1,  __SERVICE_SCHEMA, _SERVICES_TABLE_NAME);
 167                 rc = _query_exec(query);
 168
 169                 memset(query, 0, sizeof(query));
 170                 snprintf(query, sizeof(query) - 1,  __SERVICETYPE_SCHEMA, _SERVICETYPE_TABLE_NAME);
 171                 rc = _query_exec(query);
 172
 173                 memset(query, 0, sizeof(query));
 174                 snprintf(query, sizeof(query) - 1,  __TAGS_MIMETYPE_SCHEMA, _TAGS_MIME_TABLE_NAME);
 175                 rc = _query_exec(query);
 176
 177                 memset(query, 0, sizeof(query));
 178                 snprintf(query, sizeof(query) - 1,  __RELATION_SCHEMA, _RELATION_TABLE_NAME);
 179                 rc = _query_exec(query);
 180
 181                 memset(query, 0, sizeof(query));
 182                 snprintf(query, sizeof(query) - 1,  __REL_PROVIDER_SCHEMA, _REL_PROVIDER_TABLE_NAME);
 183                 rc = _query_exec(query);
 184
 185                 memset(query, 0, sizeof(query));
 186                 snprintf(query, sizeof(query) - 1,  __PROVIDER_LIST_SCHEMA, _PROVIDER_LIST_TABLE_NAME);
 187                 rc = _query_exec(query);
 188
 189         }
 190
 191         return error_code;
 192 }
 193
 194 int _query_bind_text(stmt pStmt, int pos, char* str)
 195 {
 196         int len = 0;
 197         if(str != NULL)
 198         {
 199                 len = strlen(str);
 200                 return sqlite3_bind_text(pStmt, pos, (const char*)str, len, SQLITE_STATIC);
 201         }
 202         return -1;
 203 }
 204
 205 int _query_step(stmt pStmt)
 206 {
 207         return sqlite3_step(pStmt);
 208 }
 209
 210 void _query_finalize(stmt pStmt)
 211 {
 212         int rc = -1;
 213
 214         if(!pStmt)
 215           return;
 216
 217         rc = sqlite3_finalize(pStmt);
 218         if(rc != SQLITE_OK)
 219         {
 220
 221         }
 222 }
 223
 224 int _query_bind_int(stmt pStmt, int pos, int num)
 225 {
 226    return sqlite3_bind_int(pStmt, pos, num);
 227 }
 228 #if 0
 229 void insert_dummy_data()
 230 {
 231         int             rc = 0;
 232         char    query[_QUERY_SQL_STRING_LEN + 1] = {0, };
 233         stmt    hstmt = NULL;
 234         int i = 0;
 235
 236         _create_all_tables();
 237
 238 // insert to tag_name to tag_mime table
 239         memset(query, 0x00, sizeof(query));
 240         sprintf(query, "insert into %s(tag_name) values (?) ", _TAGS_MIME_TABLE_NAME);
 241
 242         char* tag_name[] =
 243         {
 244                 "tizen.messaging",
 245                 "tizen.email",
 246                 "tizen.sms",
 247                 "tizen.mms",
 248                 "tizen.chat",
 249                 "tizen.call",
 250                 "tizen.sharing"
 251         };
 252
 253         for(i = 0; i < 7; i++)
 254         {
 255                 hstmt = __query_prepare(query);
 256
 257                 _query_bind_text(hstmt, 1, (char*)tag_name[i]);
 258                 rc = _query_step(hstmt);
 259                 if(rc != SQLITE_DONE)
 260                 {
 261                         printf("\n !! rc : %d \n", rc);
 262                 }
 263
 264                 _query_finalize(hstmt);
 265                 hstmt = NULL;
 266         }
 267
 268 //    rc = sqlite3_exec(test_hDBCt, "BEGIN IMMEDIATE TRANSACTION", NULL, NULL, &pszErrorMsg);
 269
 270 // insert to _USER_ACCOUNT_TABLE_NAME
 271         memset(query, 0x00, sizeof(query));
 272         sprintf(query, "insert into %s(displayname, icon, account_id, provider_id, login_id) values "
 273                 "(?, ?, ?, ?, ?) ", _USER_ACCOUNT_TABLE_NAME);
 274
 275         char* displayname[] =
 276         {
 277                 "Jamie's google account",
 278                 "William's facebook account",
 279                 "Craig's twitter account",
 280                 "Lucille's account"
 281         };
 282
 283         char* icon[] =
 284         {
 285                 "/opt/icon/image1.jpg",
 286                 "",
 287                 "/opt/icon/image1.jpg",
 288                 "/opt/icon/image2.jpg"
 289         };
 290
 291         char* account_id[] =
 292         {
 293                 "com.google:Jamie@gmail.com",
 294                 "com.facebook:William@facebook.com",
 295                 "com.twitter:Craig@twitter.com",
 296                 "com.custom:Lucille@gmail.com"
 297         };
 298
 299         char* provider_id[] =
 300         {
 301                 "com.google",
 302                 "com.facebook",
 303                 "com.twitter",
 304                 "com.custom"
 305         };
 306
 307         char* login_id[] =
 308         {
 309                 "Jamie@gmail.com",
 310                 "William@facebook.com",
 311                 "Craig@twitter.com",
 312                 "Lucille@gmail.com"
 313         };
 314
 315         for(i = 0; i < 4; i++)
 316         {
 317                 hstmt = __query_prepare(query);
 318
 319                 _query_bind_text(hstmt, 1, (char*)displayname[i]);
 320                 _query_bind_text(hstmt, 2, (char*)icon[i]);
 321                 _query_bind_text(hstmt, 3, (char*)account_id[i]);
 322                 _query_bind_text(hstmt, 4, (char*)provider_id[i]);
 323                 _query_bind_text(hstmt, 5, (char*)login_id[i]);
 324
 325                 rc = _query_step(hstmt);
 326                 if(rc != SQLITE_DONE)
 327                 {
 328                         printf("\n !! rc : %d \n", rc);
 329                 }
 330
 331                 _query_finalize(hstmt);
 332                 hstmt = NULL;
 333         }
 334
 335 // insert to _SERVICETYPE_TABLE_NAME
 336         memset(query, 0x00, sizeof(query));
 337         sprintf(query, "insert into %s(serviceType_id) values (?) ", _SERVICETYPE_TABLE_NAME);
 338
 339         char* service_type_id[] =
 340         {
 341                 "tizen.sms",
 342                 "tizen.mms",
 343                 "tizen.tel"
 344         };
 345
 346         for(i = 0; i < 3; i++)
 347         {
 348                 hstmt = __query_prepare(query);
 349                 _query_bind_text(hstmt, 1, (char*)service_type_id[i]);
 350
 351                 rc = _query_step(hstmt);
 352                 if(rc != SQLITE_DONE)
 353                 {
 354                         printf("\n !! rc : %d \n", rc);
 355                 }
 356
 357                 _query_finalize(hstmt);
 358                 hstmt = NULL;
 359         }
 360
 361 // insert to _SERVICE_TABLE_NAME
 362         memset(query, 0x00, sizeof(query));
 363         sprintf(query, "insert into %s(service_id, provider_id, serviceType_id) values "
 364                 "(?, ?, ?) ", _SERVICES_TABLE_NAME);
 365
 366         char* service_id[] =
 367         {
 368                 "com.google.gmail",
 369                 "com.google.gtalk",
 370                 "com.google.picasa",
 371                 "com.facebook.facebook",
 372                 "com.twitter.twitter",
 373                 "com.custom.custom",
 374         };
 375
 376         for(i = 0; i < 6; i++)
 377         {
 378                 hstmt = __query_prepare(query);
 379
 380                 _query_bind_text(hstmt, 1, (char*)service_id[i]);
 381
 382                 if(i < 3)
 383                 {
 384                         _query_bind_text(hstmt, 2, (char*)provider_id[0]);
 385                         _query_bind_text(hstmt, 3, (char*)service_type_id[i]);
 386                 }else
 387                 {
 388                         _query_bind_text(hstmt, 2, (char*)provider_id[i-2]);
 389                         _query_bind_text(hstmt, 3, (char*)service_type_id[2]);
 390                 }
 391
 392                 rc = _query_step(hstmt);
 393                 if(rc != SQLITE_DONE)
 394                 {
 395                         printf("\n !! rc : %d \n", rc);
 396                 }
 397
 398                 _query_finalize(hstmt);
 399                 hstmt = NULL;
 400         }
 401
 402 // insert to _PROVIDER_LIST_TABLE_NAME
 403         memset(query, 0x00, sizeof(query));
 404         sprintf(query, "insert into %s(provider_id, display_name) values (?, ?) ", _PROVIDER_LIST_TABLE_NAME);
 405
 406         char* provider_display_name[] =
 407         {
 408                 "provider:com.google",
 409                 "provider:com.facebook",
 410                 "provider:com.twitter",
 411                 "provider:com.custom",
 412         };
 413
 414         for(i = 0; i < 4; i++)
 415         {
 416                 hstmt = __query_prepare(query);
 417
 418                 _query_bind_text(hstmt, 1, (char*)provider_id[i]);
 419                 _query_bind_text(hstmt, 2, (char*)provider_display_name[i]);
 420
 421                 rc = _query_step(hstmt);
 422                 if(rc != SQLITE_DONE)
 423                 {
 424                         printf("\n !! rc : %d \n", rc);
 425                 }
 426
 427                 _query_finalize(hstmt);
 428                 hstmt = NULL;
 429         }
 430
 431 // insert to _RELATION_TABLE_NAME
 432         memset(query, 0x00, sizeof(query));
 433         sprintf(query, "insert into %s(tags_id, _svc_id, type_id, tag_name) values (?, ?, ?, ?) ", _RELATION_TABLE_NAME);
 434
 435         hstmt = __query_prepare(query);
 436
 437         _query_bind_int(hstmt, 1, 2);
 438         _query_bind_int(hstmt, 2, 1);
 439         _query_bind_int(hstmt, 3, 0);
 440         _query_bind_text(hstmt, 4, (char*)tag_name[1]);
 441
 442         rc = _query_step(hstmt);
 443         if(rc != SQLITE_DONE)
 444                 printf("\n !! rc : %d \n", rc);
 445         _query_finalize(hstmt);
 446         hstmt = NULL;
 447
 448         hstmt = __query_prepare(query);
 449         _query_bind_int(hstmt, 1, 5);
 450         _query_bind_int(hstmt, 2, 2);
 451         _query_bind_int(hstmt, 3, 0);
 452         _query_bind_text(hstmt, 4, (char*)tag_name[4]);
 453
 454         rc = _query_step(hstmt);
 455         if(rc != SQLITE_DONE)
 456                 printf("\n !! rc : %d \n", rc);
 457         _query_finalize(hstmt);
 458         hstmt = NULL;
 459
 460         hstmt = __query_prepare(query);
 461         _query_bind_int(hstmt, 1, 7);
 462         _query_bind_int(hstmt, 2, 3);
 463         _query_bind_int(hstmt, 3, 0);
 464         _query_bind_text(hstmt, 4, (char*)tag_name[6]);
 465
 466         rc = _query_step(hstmt);
 467         if(rc != SQLITE_DONE)
 468                 printf("\n !! rc : %d \n", rc);
 469         _query_finalize(hstmt);
 470         hstmt = NULL;
 471
 472         hstmt = __query_prepare(query);
 473
 474         _query_bind_int(hstmt, 1, 7);
 475         _query_bind_int(hstmt, 2, 4);
 476         _query_bind_int(hstmt, 3, 0);
 477         _query_bind_text(hstmt, 4, (char*)tag_name[6]);
 478
 479         rc = _query_step(hstmt);
 480         if(rc != SQLITE_DONE)
 481                 printf("\n !! rc : %d \n", rc);
 482         _query_finalize(hstmt);
 483         hstmt = NULL;
 484
 485         hstmt = __query_prepare(query);
 486
 487         _query_bind_int(hstmt, 1, 7);
 488         _query_bind_int(hstmt, 2, 5);
 489         _query_bind_int(hstmt, 3, 0);
 490         _query_bind_text(hstmt, 4, (char*)tag_name[6]);
 491
 492         rc = _query_step(hstmt);
 493         if(rc != SQLITE_DONE)
 494                 printf("\n !! rc : %d \n", rc);
 495         _query_finalize(hstmt);
 496         hstmt = NULL;
 497
 498         hstmt = __query_prepare(query);
 499
 500         _query_bind_int(hstmt, 1, 7);
 501         _query_bind_int(hstmt, 2, 6);
 502         _query_bind_int(hstmt, 3, 0);
 503         _query_bind_text(hstmt, 4, (char*)tag_name[6]);
 504
 505         rc = _query_step(hstmt);
 506         if(rc != SQLITE_DONE)
 507                 printf("\n !! rc : %d \n", rc);
 508         _query_finalize(hstmt);
 509         hstmt = NULL;
 510
 511         hstmt = __query_prepare(query);
 512
 513         _query_bind_int(hstmt, 1, 1);
 514         _query_bind_int(hstmt, 2, 0);
 515         _query_bind_int(hstmt, 3, 1);
 516         _query_bind_text(hstmt, 4, (char*)tag_name[0]);
 517
 518         rc = _query_step(hstmt);
 519         if(rc != SQLITE_DONE)
 520                 printf("\n !! rc : %d \n", rc);
 521         _query_finalize(hstmt);
 522         hstmt = NULL;
 523
 524         hstmt = __query_prepare(query);
 525
 526         _query_bind_int(hstmt, 1, 3);
 527         _query_bind_int(hstmt, 2, 0);
 528         _query_bind_int(hstmt, 3, 1);
 529         _query_bind_text(hstmt, 4, (char*)tag_name[2]);
 530
 531         rc = _query_step(hstmt);
 532         if(rc != SQLITE_DONE)
 533                 printf("\n !! rc : %d \n", rc);
 534         _query_finalize(hstmt);
 535         hstmt = NULL;
 536
 537         hstmt = __query_prepare(query);
 538
 539         _query_bind_int(hstmt, 1, 4);
 540         _query_bind_int(hstmt, 2, 0);
 541         _query_bind_int(hstmt, 3, 1);
 542         _query_bind_text(hstmt, 4, (char*)tag_name[3]);
 543
 544         rc = _query_step(hstmt);
 545         if(rc != SQLITE_DONE)
 546                 printf("\n !! rc : %d \n", rc);
 547         _query_finalize(hstmt);
 548         hstmt = NULL;
 549
 550         hstmt = __query_prepare(query);
 551
 552         _query_bind_int(hstmt, 1, 1);
 553         _query_bind_int(hstmt, 2, 0);
 554         _query_bind_int(hstmt, 3, 2);
 555         _query_bind_text(hstmt, 4, (char*)tag_name[0]);
 556
 557         rc = _query_step(hstmt);
 558         if(rc != SQLITE_DONE)
 559                 printf("\n !! rc : %d \n", rc);
 560         _query_finalize(hstmt);
 561         hstmt = NULL;
 562
 563         hstmt = __query_prepare(query);
 564
 565         _query_bind_int(hstmt, 1, 4);
 566         _query_bind_int(hstmt, 2, 0);
 567         _query_bind_int(hstmt, 3, 2);
 568         _query_bind_text(hstmt, 4, (char*)tag_name[3]);
 569
 570         rc = _query_step(hstmt);
 571         if(rc != SQLITE_DONE)
 572                 printf("\n !! rc : %d \n", rc);
 573         _query_finalize(hstmt);
 574         hstmt = NULL;
 575
 576         hstmt = __query_prepare(query);
 577
 578         _query_bind_int(hstmt, 1, 5);
 579         _query_bind_int(hstmt, 2, 0);
 580         _query_bind_int(hstmt, 3, 3);
 581         _query_bind_text(hstmt, 4, (char*)tag_name[4]);
 582
 583         rc = _query_step(hstmt);
 584         if(rc != SQLITE_DONE)
 585                 printf("\n !! rc : %d \n", rc);
 586         _query_finalize(hstmt);
 587         hstmt = NULL;
 588
 589         hstmt = __query_prepare(query);
 590
 591         _query_bind_int(hstmt, 1, 6);
 592         _query_bind_int(hstmt, 2, 0);
 593         _query_bind_int(hstmt, 3, 3);
 594         _query_bind_text(hstmt, 4, (char*)tag_name[5]);
 595
 596         rc = _query_step(hstmt);
 597         if(rc != SQLITE_DONE)
 598                 printf("\n !! rc : %d \n", rc);
 599         _query_finalize(hstmt);
 600         hstmt = NULL;
 601
 602 // insert to _REL_PROVIDER_TABLE_NAME
 603         memset(query, 0x00, sizeof(query));
 604         sprintf(query, "insert into %s(_list_id, type_id) values (?, ?) ", _REL_PROVIDER_TABLE_NAME);
 605
 606         for(i = 0; i < 6; i++)
 607         {
 608                 hstmt = __query_prepare(query);
 609
 610                 if(i<3)
 611                 {
 612                         _query_bind_int(hstmt, 1, 1);
 613                         _query_bind_int(hstmt, 2, i+1);
 614                 }else
 615                 {
 616                         _query_bind_int(hstmt, 1, i-1);
 617                         _query_bind_int(hstmt, 2, 3);
 618                 }
 619
 620                 rc = _query_step(hstmt);
 621                 if(rc != SQLITE_DONE)
 622                 {
 623                         printf("\n !! rc : %d \n", rc);
 624                 }
 625
 626                 _query_finalize(hstmt);
 627                 hstmt = NULL;
 628         }
 629 //    rc = sqlite3_exec(test_hDBCt, "COMMIT TRANSACTION", NULL, NULL, &pszErrorMsg);
 630
 631 }
 632 #endif
 633
 634 typedef enum
 635 {
 636         SERVICE_TYPE_ID,
 637         TAGS,
 638         PROVIDER_ID,
 639         FILTER_ATTRIBUTE_MAX
 640 }filter_e;
 641
 642 typedef enum
 643 {
 644         ENABLE,
 645         DISABLE,
 646         ALL
 647 }status_e;
 648
 649 typedef enum
 650 {
 651         TIZEN_MESSAGING = 0x00000001,
 652         TIZEN_SMS = 0x00000002,
 653         TIZEN_MMS = 0x00000004,
 654         TIZEN_EMAIL = 0x00000008,
 655         TIZEN_CHAT = 0x00000010,
 656         TIZEN_CALL = 0x00000020,
 657         TIZEN_TEL = 0x00000040,
 658         TIZEN_VIDEOCALL = 0x00000080,
 659         TIZEN_VOIP = 0x00000100,
 660         TIZEN_SKYPE = 0x00000200,
 661         TIZEN_SHARING = 0x00000400,
 662         TIZEN_CUSTOM = 0x01000000
 663 }tags_e;
 664
 665 typedef struct
 666 {
 667         char* tag_info;
 668         bool enabled;
 669 }tags_info_t;
 670
 671 typedef struct
 672 {
 673         char* AccountServiceTypeId;
 674         char* displayName;
 675         char* icon;
 676         GList* tags_info; // tags_info_t
 677 }AccountServiceType_t;
 678
 679 typedef struct
 680 {
 681         char* AccountServiceId;
 682         char* serviceName;
 683         char* applicationId;
 684         char* displayName;
 685         char* icon;
 686         char* AccountId;
 687         char* AccountServiceTypeId;
 688         char* AccountServiceProviderId;
 689         char* setting;
 690         GList* tags_info; // tags_info_t
 691         bool enabled;
 692 }AccountService_t;
 693
 694 typedef struct
 695 {
 696         char* AccountServiceProviderId;
 697         char* displayName;
 698         char* icon;
 699 }provider_t;
 700
 701 typedef struct
 702 {
 703         char* AccountId;
 704         char* displayName;
 705         char* icon;
 706         bool enabled;
 707         char* AccountServiceProviderId;
 708         unsigned long credentialId;
 709         GList* services; // AccountService_t
 710         char* settings;
 711         provider_t* provider;
 712 }UserAccount_t;
 713
 714 typedef struct
 715 {
 716         char* displayName;
 717         char* icon;
 718 }UserProperties_t;
 719
 720 UserAccount_t user_account = {0, };
 721 UserProperties_t property = {0, };
 722 AccountServiceType_t serviceType = {0, };
 723 provider_t provider = {0, };
 724
 725 int addAccount(const char* providerId, UserProperties_t* properties, UserAccount_t* account)
 726 {
 727         return 0;
 728 }
 729
 730 typedef struct
 731 {
 732         GList* filter_list;
 733         status_e status;
 734         int tags_count;
 735 }search_list_t;
 736
 737 typedef struct
 738 {
 739         filter_e filter_type;
 740         char* value;
 741 }filter_value_t;
 742
 743 int set_account_filter(search_list_t* search_list, filter_e filter_type, char* value)
 744 {
 745         filter_value_t* object = NULL;
 746         object = g_new0(filter_value_t, 1);
 747
 748         object->filter_type = filter_type;
 749         object->value = g_strdup(value);
 750         if(filter_type == TAGS)
 751                 search_list->tags_count++;
 752         search_list->filter_list = g_list_append(search_list->filter_list, object);
 753
 754         return 0;
 755 }
 756
 757 static char* filter_attribute[FILTER_ATTRIBUTE_MAX] =
 758 {
 759         "serviceType_id",
 760         "tag_name",
 761         "provider_id"
 762 };
 763
 764 typedef enum
 765 {
 766         USE_FILTER_NONE = 0x00000000,
 767         USE_SERVICE_TYPE_ID = 0x00000001,
 768         USE_TAGS = 0x00000002,
 769         USE_PROVIDER_ID = 0x00000004
 770 }used_filter_attr;
 771
 772 typedef enum
 773 {
 774         TAG_SERVICE,
 775         TAG_SERVICE_TYPE
 776 }tags_owner;
 777
 778 typedef enum
 779 {
 780         FIND_ACCOUNT,
 781         FIND_SERVICE
 782 }query_type_e;
 783
 784 int _query_column_int(stmt pStmt, int pos)
 785 {
 786    return sqlite3_column_int(pStmt, pos);
 787 }
 788
 789 char* _query_column_text(stmt pStmt, int pos)
 790 {
 791    return (char *)sqlite3_column_text(pStmt, pos);
 792 }
 793
 794 double _query_column_double(stmt pStmt, int pos)
 795 {
 796    return sqlite3_column_double(pStmt, pos);
 797 }
 798
 799 #define QUERY_MAX_LEN 4096
 800 #define SUB_QUERY_LEN 2048
 801 #define TABLE_LEN 512
 802
 803 void _get_tags(tags_owner owner, int id, GList** tags_list)
 804 {
 805         int rc = 0;
 806         char query[QUERY_MAX_LEN + 1] = {0, };
 807
 808         switch(owner)
 809         {
 810                 case TAG_SERVICE :
 811                         snprintf(query, sizeof(query) - 1, "select tag_name from relation where _svc_id = %d", id);
 812                         break;
 813                 case TAG_SERVICE_TYPE :
 814                         snprintf(query, sizeof(query) - 1, "select tag_name from relation where type_id = %d", id);
 815                 default :
 816                         break;
 817         }
 818
 819         stmt hstmt = __query_prepare(query);
 820
 821         rc = _query_step(hstmt);
 822         while(rc == SQLITE_ROW)
 823         {
 824                 tags_info_t* tag_info = NULL;
 825                 tag_info = g_new0(tags_info_t, 1);
 826                 tag_info->tag_info = g_strdup(_query_column_text(hstmt, 0));
 827
 828                 *tags_list = g_list_append(*tags_list, tag_info);
 829                 rc = _query_step(hstmt);
 830         }
 831         _query_finalize(hstmt);
 832 }
 833
 834 char* _make_condition_part(search_list_t* search_list, query_type_e type)
 835 {
 836         char* query = NULL;
 837         char tmp_query[SUB_QUERY_LEN + 1] = {0, };
 838         char pre_query[TABLE_LEN + 1] = {0, };
 839         char table[TABLE_LEN + 1] = {0, };
 840         used_filter_attr use_filter = USE_FILTER_NONE;
 841         int filter_count = 0;
 842         int tags_count = 0;
 843
 844         query = g_new0(char, QUERY_MAX_LEN);
 845
 846         if(type == FIND_ACCOUNT)
 847                 snprintf(pre_query, sizeof(pre_query) - 1, "where user_account.provider_id in (select a.provider_id from service a ");
 848         else
 849                 snprintf(pre_query, sizeof(pre_query) - 1, "where service._svc_id in (select a._svc_id from service a ");
 850
 851         GList* tmp_filter_list = search_list->filter_list;
 852         while(tmp_filter_list)
 853         {
 854                 filter_value_t* object = (filter_value_t*)tmp_filter_list->data;
 855
 856                 if(object->value != NULL)
 857                 {
 858                         if(object->filter_type == SERVICE_TYPE_ID)
 859                         {
 860                                 use_filter = (used_filter_attr)(use_filter | USE_SERVICE_TYPE_ID);
 861
 862                                 if(tmp_query[0] == '\0')
 863                                         sprintf(tmp_query, "a.%s = ? ", filter_attribute[object->filter_type]);
 864                                 else
 865                                         sprintf(tmp_query, "and %s a.%s = ? ", tmp_query, filter_attribute[object->filter_type]);
 866
 867                         }else if(object->filter_type == TAGS)
 868                         {
 869                                 use_filter = (used_filter_attr)(use_filter | USE_TAGS);
 870                                 tags_count++;
 871
 872                                 if(tags_count == 1)
 873                                 {
 874                                         if(table[0] == '\0')
 875                                                 sprintf(table, ", relation b ");
 876                                         else
 877                                                 sprintf(table, "%s, relation b ", table);
 878
 879                                         if(tmp_query[0] == '\0')
 880                                         {
 881                                                 if(search_list->tags_count > 1)
 882                                                         sprintf(tmp_query, "(a._svc_id = b._svc_id) and (b.%s = ? ", filter_attribute[object->filter_type]);
 883                                                 else
 884                                                         sprintf(tmp_query, "(a._svc_id = b._svc_id) and b.%s = ? ", filter_attribute[object->filter_type]);
 885                                         }else
 886                                         {
 887                                                 if(search_list->tags_count > 1)
 888                                                         sprintf(tmp_query, "%s and (a._svc_id = b._svc_id) and (b.%s = ? ", tmp_query, filter_attribute[object->filter_type]);
 889                                                 else
 890                                                         sprintf(tmp_query, "%s and (a._svc_id = b._svc_id) and b.%s = ? ", tmp_query, filter_attribute[object->filter_type]);
 891                                         }
 892                                 }else
 893                                 {
 894                                         sprintf(tmp_query, "%s or b.%s = ? ", tmp_query, filter_attribute[object->filter_type]);
 895                                         if(search_list->tags_count > 1 && search_list->tags_count == tags_count)
 896                                                 sprintf(tmp_query, "%s) ", tmp_query);
 897                                 }
 898                         }else if(object->filter_type == PROVIDER_ID)
 899                         {
 900                                 use_filter = (used_filter_attr)(use_filter | USE_PROVIDER_ID);
 901
 902                                 if(tmp_query[0] == '\0')
 903                                         sprintf(tmp_query, "a.%s = ? ", filter_attribute[object->filter_type]);
 904                                 else
 905                                         sprintf(tmp_query, "%s and a.%s = ? ", tmp_query, filter_attribute[object->filter_type]);
 906                         }
 907                         filter_count++;
 908                 }
 909                 tmp_filter_list = g_list_next(tmp_filter_list);
 910         }
 911
 912         if(table[0] != '\0')
 913                 snprintf(query, QUERY_MAX_LEN, "%s %s where %s)", pre_query, table, tmp_query);
 914         else
 915                 snprintf(query, QUERY_MAX_LEN, "%s where %s)", pre_query, tmp_query);
 916
 917         if(type == FIND_ACCOUNT)
 918         {
 919                 if((use_filter | USE_PROVIDER_ID) == USE_PROVIDER_ID && filter_count == 1)
 920                 {
 921                         memset(query, 0x00, QUERY_MAX_LEN);
 922                         snprintf(query, QUERY_MAX_LEN, "where user_account.provider_id = ? ");
 923                 }else if((use_filter | USE_SERVICE_TYPE_ID) == USE_SERVICE_TYPE_ID && filter_count == 1)
 924                 {
 925                         memset(query, 0x00, QUERY_MAX_LEN);
 926                         snprintf(query, QUERY_MAX_LEN, ",service where (user_account.provider_id = service.provider_id) and service.serviceType_id = ? ");
 927                 }
 928         }else
 929         {
 930                 if((use_filter | USE_PROVIDER_ID) == USE_PROVIDER_ID && filter_count == 1)
 931                 {
 932                         memset(query, 0x00, QUERY_MAX_LEN);
 933                         snprintf(query, QUERY_MAX_LEN, ",service where (user_account.provider_id = service.provider_id) and user_account.provider_id = ? ");
 934                 }else if((use_filter | USE_SERVICE_TYPE_ID) == USE_SERVICE_TYPE_ID && filter_count == 1)
 935                 {
 936                         memset(query, 0x00, QUERY_MAX_LEN);
 937                         snprintf(query, QUERY_MAX_LEN, " where service.serviceType_id = ? ");
 938                 }
 939         }
 940
 941         if(filter_count == 0)
 942                 return NULL;
 943         else
 944                 return query;
 945 }
 946
 947 void _get_service_list_by_account(char* provider_id, GList** service_list)
 948 {
 949         int rc = 0;
 950         int id = 0;
 951         char query[QUERY_MAX_LEN + 1] = {0, };
 952
 953         snprintf(query, sizeof(query) - 1, "select service_id, service_name, application_id, display_name, icon, serviceType_id, provider_id, setting, enable, _svc_id "
 954                 "from %s where provider_id = %s", _SERVICES_TABLE_NAME, provider_id);
 955
 956         stmt hstmt = __query_prepare(query);
 957
 958         rc = _query_step(hstmt);
 959         while(rc == SQLITE_ROW)
 960         {
 961                 AccountService_t* service_info = NULL;
 962                 service_info = g_new0(AccountService_t, 1);
 963
 964                 service_info->AccountServiceId = g_strdup(_query_column_text(hstmt, 0));
 965                 service_info->serviceName = g_strdup(_query_column_text(hstmt, 1));
 966                 service_info->applicationId = g_strdup(_query_column_text(hstmt, 2));
 967                 service_info->displayName = g_strdup(_query_column_text(hstmt, 3));
 968                 service_info->icon = g_strdup(_query_column_text(hstmt, 4));
 969                 service_info->AccountServiceTypeId = g_strdup(_query_column_text(hstmt, 5));
 970                 service_info->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 6));
 971                 service_info->setting = g_strdup(_query_column_text(hstmt, 7));
 972                 service_info->enabled = _query_column_int(hstmt, 8);
 973                 id =  _query_column_int(hstmt, 9);
 974
 975                 _get_tags(TAG_SERVICE, id, &(service_info->tags_info));
 976
 977                 *service_list = g_list_append(*service_list, service_info);
 978                 rc = _query_step(hstmt);
 979         }
 980         _query_finalize(hstmt);
 981 }
 982
 983 void _make_account_info(int user_id, UserAccount_t* account_info)
 984 {
 985         char query[QUERY_MAX_LEN + 1] = {0, };
 986         int rc = 0;
 987
 988 // Get user_account
 989         snprintf(query, sizeof(query) - 1, "select displayname, icon, account_id, enable, credential_id, settings, provider_id "
 990                 "from %s where user_id = %d", _USER_ACCOUNT_TABLE_NAME, user_id);
 991
 992         stmt hstmt = __query_prepare(query);
 993
 994         rc = _query_step(hstmt);
 995         account_info->displayName = g_strdup(_query_column_text(hstmt, 0));
 996         account_info->icon = g_strdup(_query_column_text(hstmt, 1));
 997         account_info->AccountId = g_strdup(_query_column_text(hstmt, 2));
 998         account_info->enabled = _query_column_int(hstmt, 3);
 999         account_info->credentialId = _query_column_double(hstmt, 4);
1000         account_info->settings = g_strdup(_query_column_text(hstmt, 5));
1001         account_info->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 6));
1002
1003         _query_finalize(hstmt);
1004         hstmt = NULL;
1005
1006 // Get provider
1007         snprintf(query, sizeof(query) - 1, "select provider_id, display_name, icon "
1008                 "from %s where provider_id = '%s'", _PROVIDER_LIST_TABLE_NAME, account_info->AccountServiceProviderId);
1009
1010         hstmt = __query_prepare(query);
1011
1012         rc = _query_step(hstmt);
1013
1014         account_info->provider = g_new0(provider_t, 1);
1015         account_info->provider->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 0));
1016         account_info->provider->displayName = g_strdup(_query_column_text(hstmt, 1));
1017         account_info->provider->icon = g_strdup(_query_column_text(hstmt, 2));
1018
1019         _query_finalize(hstmt);
1020         hstmt = NULL;
1021
1022 // Get services
1023         _get_service_list_by_account(account_info->AccountServiceProviderId, &(account_info->services));
1024 }
1025
1026 void _make_service_info(int id, AccountService_t* service_info)
1027 {
1028         char query[QUERY_MAX_LEN + 1] = {0, };
1029         int rc = 0;
1030         stmt hstmt = NULL;
1031
1032 // Get user_account
1033         snprintf(query, sizeof(query) - 1, "select service_id, service_name, application_id, display_name, icon, serviceType_id, provider_id, setting, enable "
1034                 "from %s where _svc_id = %d", _SERVICES_TABLE_NAME, id);
1035
1036         hstmt = __query_prepare(query);
1037
1038         rc = _query_step(hstmt);
1039         service_info->AccountServiceId = g_strdup(_query_column_text(hstmt, 0));
1040         service_info->serviceName = g_strdup(_query_column_text(hstmt, 1));
1041         service_info->applicationId = g_strdup(_query_column_text(hstmt, 2));
1042         service_info->displayName = g_strdup(_query_column_text(hstmt, 3));
1043         service_info->icon = g_strdup(_query_column_text(hstmt, 4));
1044         service_info->AccountServiceTypeId = g_strdup(_query_column_text(hstmt, 5));
1045         service_info->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 6));
1046         service_info->setting = g_strdup(_query_column_text(hstmt, 7));
1047         service_info->enabled = _query_column_int(hstmt, 8);
1048
1049         _query_finalize(hstmt);
1050         hstmt = NULL;
1051
1052 // Get account_id
1053         snprintf(query, sizeof(query) - 1, "select account_id from %s where provider_id = %s", _USER_ACCOUNT_TABLE_NAME, service_info->AccountServiceProviderId);
1054
1055         hstmt = __query_prepare(query);
1056
1057         rc = _query_step(hstmt);
1058         service_info->AccountId = g_strdup(_query_column_text(hstmt, 0));
1059
1060         _query_finalize(hstmt);
1061         hstmt = NULL;
1062
1063 // Get tags
1064         _get_tags(TAG_SERVICE, id, &(service_info->tags_info));
1065
1066 }
1067
1068 int find_accounts(search_list_t* search_list, status_e status, GList** account_list)
1069 {
1070         int error_code = 0;
1071         char query[QUERY_MAX_LEN + 1] = {0, };
1072         int i = 1;
1073         int index_list[SUB_QUERY_LEN + 1] = {0, };
1074         int index_count = 0;
1075         int rc = 0;
1076         stmt    hstmt = NULL;
1077
1078         char* filter = _make_condition_part(search_list, FIND_ACCOUNT);
1079
1080         switch(status)
1081         {
1082                 case ENABLE :
1083                 {
1084                         if(filter)
1085                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account %s and user_account.enable = 1", filter);
1086                         else
1087                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account where user_account.enable = 1");
1088                 }
1089                         break;
1090                 case DISABLE :
1091                 {
1092                         if(filter)
1093                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account %s and user_account.enable = 0", filter);
1094                         else
1095                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account where user_account.enable = 0");
1096                 }
1097                         break;
1098                 case ALL :
1099                 default :
1100                 {
1101                         if(filter)
1102                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account %s", filter);
1103                         else
1104                                 snprintf(query, sizeof(query) - 1, "select user_account.user_id from user_account");
1105                 }
1106                         break;
1107         }
1108
1109         hstmt = __query_prepare(query);
1110
1111         GList* filter_list_val = search_list->filter_list;
1112         while(filter_list_val)
1113         {
1114                 filter_value_t* object = (filter_value_t*)filter_list_val->data;
1115
1116                 if(object->value != NULL)
1117                         _query_bind_text(hstmt, i++, object->value);
1118
1119                 printf("input value : %s \n", object->value);
1120
1121                 filter_list_val = g_list_next(filter_list_val);
1122         }
1123
1124         rc = _query_step(hstmt);
1125         printf("rc : %d \n", rc);
1126
1127         int ret = 0;
1128         while(rc == SQLITE_ROW)
1129         {
1130                 ret = _query_column_int(hstmt, 0);
1131                 index_list[index_count++] = ret;
1132                 rc = _query_step(hstmt);
1133         }
1134
1135         _query_finalize(hstmt);
1136
1137 // make account object by index_list
1138         for(i = 0; i< index_count; i++)
1139         {
1140 // Get account info
1141                 UserAccount_t* account_info = NULL;
1142                 account_info = g_new0(UserAccount_t, 1);
1143                 _make_account_info(index_list[i], account_info);
1144
1145 // Generate account list
1146                 *account_list = g_list_append(*account_list, account_info);
1147         }
1148
1149         if(filter)
1150                 free(filter);
1151
1152         return error_code;
1153 }
1154
1155 int find_services(search_list_t* search_list, status_e status, GList** service_list)
1156 {
1157         int error_code = 0;
1158         char query[QUERY_MAX_LEN + 1] = {0, };
1159         int i = 1;
1160         int index_list[SUB_QUERY_LEN + 1] = {0, };
1161         int index_count = 0;
1162         int rc = 0;
1163
1164         char* filter = _make_condition_part(search_list, FIND_SERVICE);
1165
1166         switch(status)
1167         {
1168                 case ENABLE :
1169                 {
1170                         if(filter)
1171                                 snprintf(query, sizeof(query) - 1, "select service._id from service %s and service.enable = 1", filter);
1172                         else
1173                                 snprintf(query, sizeof(query) - 1, "select service._id from service where service.enable = 1");
1174                 }
1175                         break;
1176                 case DISABLE :
1177                 {
1178                         if(filter)
1179                                 snprintf(query, sizeof(query) - 1, "select service._id from service %s and service.enable = 0", filter);
1180                         else
1181                                 snprintf(query, sizeof(query) - 1, "select service._id from service where service.enable = 0");
1182                 }
1183                         break;
1184                 case ALL :
1185                 default :
1186                 {
1187                         if(filter)
1188                                 snprintf(query, sizeof(query) - 1, "select service._id from service %s", filter);
1189                         else
1190                                 snprintf(query, sizeof(query) - 1, "select service._id from service");
1191                 }
1192                         break;
1193         }
1194
1195         stmt hstmt = __query_prepare(query);
1196
1197         GList* filter_list_val = search_list->filter_list;
1198         while(filter_list_val)
1199         {
1200                 filter_value_t* object = (filter_value_t*)filter_list_val->data;
1201
1202                 if(object->value != NULL)
1203                         _query_bind_text(hstmt, i++, object->value);
1204
1205                 filter_list_val = g_list_next(filter_list_val);
1206         }
1207
1208         rc = _query_step(hstmt);
1209         while(rc == SQLITE_ROW)
1210         {
1211                 index_list[index_count++] = _query_column_int(hstmt, 0);
1212                 rc = _query_step(hstmt);
1213         }
1214
1215         _query_finalize(hstmt);
1216
1217         for(i = 0; i< index_count; i++)
1218         {
1219 // Get service info
1220                 AccountService_t* service_info = NULL;
1221                 service_info = g_new0(AccountService_t, 1);
1222                 _make_service_info(index_list[i], service_info);
1223
1224 // Generate service list
1225                 *service_list = g_list_append(*service_list, service_info);
1226         }
1227
1228         if(filter)
1229                 free(filter);
1230
1231         return error_code;
1232 }
1233
1234 int find_providers(const char* serviceTypeId, GList** provider_list)
1235 {
1236         int error_code = 0;
1237         int rc = 0;
1238         char query[QUERY_MAX_LEN + 1] = {0, };
1239         char sub_query[SUB_QUERY_LEN + 1] = {0, };
1240
1241         if(serviceTypeId == NULL)
1242         {
1243                 snprintf(query, sizeof(query) - 1, "select provider_id, display_name, icon from provider_list");
1244         }else
1245         {
1246                 snprintf(sub_query, sizeof(sub_query) - 1, "select type_id from service_type where serviceType_id = ?");
1247                 snprintf(query, sizeof(query) - 1, "select a.provider_id, a.display_name, a.icon from provider_list a, provider_to_svctype b "
1248                         "where (a._list_id = b._list_id) and b.type_id in (%s) ", sub_query);
1249         }
1250
1251         stmt hstmt = __query_prepare(query);
1252
1253         rc = _query_step(hstmt);
1254         while(rc == SQLITE_ROW)
1255         {
1256                 provider_t* provider = NULL;
1257                 provider = g_new0(provider_t, 1);
1258                 provider->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 0));
1259                 provider->displayName = g_strdup(_query_column_text(hstmt, 1));
1260                 provider->icon = g_strdup(_query_column_text(hstmt, 2));
1261
1262                 *provider_list = g_list_append(*provider_list, provider);
1263                 rc = _query_step(hstmt);
1264         }
1265
1266         _query_finalize(hstmt);
1267
1268         return error_code;
1269 }
1270
1271 int find_service_types(char* prefix, GList** servicetype_list)
1272 {
1273         int error_code = 0;
1274         int rc = 0;
1275         int type_id = 0;
1276         char query[QUERY_MAX_LEN + 1] = {0, };
1277
1278         if(prefix == NULL)
1279                 snprintf(query, sizeof(query) - 1, "select type_id, serviceType_id, display_name, icon from service_type");
1280         else
1281                 snprintf(query, sizeof(query) - 1, "select type_id, serviceType_id, display_name, icon from service_type where serviceType_id like (? || '%%')");
1282
1283         stmt hstmt = __query_prepare(query);
1284
1285         if(prefix != NULL)
1286                 _query_bind_text(hstmt, 1, prefix);
1287
1288         rc = _query_step(hstmt);
1289         while(rc == SQLITE_ROW)
1290         {
1291                 type_id = _query_column_int(hstmt, 0);
1292
1293                 AccountServiceType_t* servicetype = NULL;
1294                 servicetype = g_new0(AccountServiceType_t, 1);
1295                 servicetype->AccountServiceTypeId = g_strdup(_query_column_text(hstmt, 1));
1296                 servicetype->displayName = g_strdup(_query_column_text(hstmt, 2));
1297                 servicetype->icon = g_strdup(_query_column_text(hstmt, 3));
1298
1299                 _get_tags(TAG_SERVICE_TYPE, type_id, &(servicetype->tags_info));
1300
1301                 *servicetype_list = g_list_append(*servicetype_list, servicetype);
1302                 rc = _query_step(hstmt);
1303         }
1304         _query_finalize(hstmt);
1305
1306         return error_code;
1307 }
1308
1309 // use mandatory input parameter
1310 int getAccountById(char* accountId, UserAccount_t* account)
1311 {
1312         int error_code = 0;
1313         int rc = 0;
1314         int user_id = 0;
1315         char query[QUERY_MAX_LEN + 1] = {0, };
1316
1317         snprintf(query, sizeof(query) - 1, "select user_id from user_account where account_id = ?");
1318
1319         stmt hstmt = __query_prepare(query);
1320         _query_bind_text(hstmt, 1, accountId);
1321
1322         rc = _query_step(hstmt);
1323
1324         user_id = _query_column_int(hstmt, 0);
1325         _query_finalize(hstmt);
1326
1327         _make_account_info(user_id, account);
1328
1329         return error_code;
1330 }
1331
1332 int getServiceTypeById(char* serviceTypeId, AccountServiceType_t* serviceType)
1333 {
1334         int error_code = 0;
1335         int rc = 0;
1336         int type_id = 0;
1337         char query[QUERY_MAX_LEN + 1] = {0, };
1338
1339         snprintf(query, sizeof(query) - 1, "select type_id, serviceType_id, display_name, icon from service_type where serviceType_id = ?");
1340
1341         stmt hstmt = __query_prepare(query);
1342         _query_bind_text(hstmt, 1, serviceTypeId);
1343
1344         rc = _query_step(hstmt);
1345
1346         type_id = _query_column_int(hstmt, 0);
1347
1348         serviceType->AccountServiceTypeId = g_strdup(_query_column_text(hstmt, 1));
1349         serviceType->displayName = g_strdup(_query_column_text(hstmt, 2));
1350         serviceType->icon = g_strdup(_query_column_text(hstmt, 3));
1351
1352         _get_tags(TAG_SERVICE_TYPE, type_id, &(serviceType->tags_info));
1353
1354         _query_finalize(hstmt);
1355
1356         return error_code;
1357 }
1358
1359 int getProviderById(char* serviceProviderId, provider_t* provider)
1360 {
1361         int error_code = 0;
1362         int rc = 0;
1363         char query[QUERY_MAX_LEN + 1] = {0, };
1364
1365         snprintf(query, sizeof(query) - 1, "select provider_id, display_name, icon from provider_list where provider_id = ?");
1366
1367         stmt hstmt = __query_prepare(query);
1368         _query_bind_text(hstmt, 1, serviceProviderId);
1369
1370         rc = _query_step(hstmt);
1371
1372         provider->AccountServiceProviderId = g_strdup(_query_column_text(hstmt, 0));
1373         provider->displayName = g_strdup(_query_column_text(hstmt, 1));
1374         provider->icon = g_strdup(_query_column_text(hstmt, 2));
1375
1376         _query_finalize(hstmt);
1377
1378         return error_code;
1379 }
1380
1381 namespace TizenApis {
1382 namespace Platform {
1383 namespace Account{
1384 AccountWrapper::AccountWrapper() : m_platformAccount(NULL), m_abstractAccount(NULL)
1385 {
1386     LogDebug("entered");
1387     m_abstractAccount = EventAccountPtr(new EventAccount());
1388     if (!m_abstractAccount) {
1389         ThrowMsg(UnknownException, "abstract object is not created");
1390     }
1391 }
1392
1393 AccountWrapper::AccountWrapper(const EventAccountPtr &event) : m_platformAccount(NULL), m_abstractAccount(event)
1394 {
1395     LogDebug("entered");
1396 }
1397
1398 AccountWrapper::~AccountWrapper()
1399 {
1400     LogDebug("entered");
1401     //TODO: After inserting ,It seems like F/W frees handle. I need to review this later.
1402     // After inserting and call freePlatformAccount, Segment fault occurs.
1403     //freePlatformAccount();
1404 }
1405
1406 int AccountWrapper::getIDFromPlatformAccount() const
1407 {
1408     LogDebug("Entered");
1409     int error_code = -1;
1410         int accountid = 0;
1411     if (m_platformAccount == NULL) {
1412         ThrowMsg(NullPointerException, "m_platformAccount is not set");
1413     }
1414
1415         error_code = account_get_account_id(m_platformAccount, &accountid);
1416
1417         if(ACCOUNT_ERROR_NONE != error_code)
1418         {
1419                 ThrowMsg(PlatformException, "Can't get a account id");
1420         }
1421     return accountid;
1422 }
1423
1424 //TODO: check if it works to dicriminate update/insert with account id.
1425 void AccountWrapper::saveAccount()
1426 {
1427     LogDebug("entered");
1428
1429     int accountID = 0;
1430     //Check if platform struct is set.
1431     //It could be set here, but forcing user to do it manually can help to avoid problems.
1432     if (m_platformAccount == NULL) {
1433         ThrowMsg(NullPointerException, "m_platformAccount is not set");
1434     }
1435
1436     accountID = m_abstractAccount->getID();
1437
1438     displayPlatformAccount();
1439
1440     int returnID;
1441
1442     //insert new record or update existing one
1443     if (accountID < 0) { // insert new account
1444             int err = addAccount(m_abstractAccount->getProviderName().c_str(), &property, &user_account);
1445                 user_account.AccountId = g_strdup("com.google:myaccount1@gmail.com");
1446
1447 //        int err = account_insert_to_db(m_platformAccount, &returnID);
1448         if (ACCOUNT_ERROR_NONE != err) {
1449             LogError("Can't insert new account, error code: " << returnID);
1450             ThrowMsg(PlatformException, "Can't insert new account.");
1451         }
1452         m_abstractAccount->setID(returnID);
1453                 m_abstractAccount->setAccountId(user_account.AccountId);
1454
1455         LogInfo("New event inserted");
1456     } else { //update
1457
1458            //accountID = getIDFromPlatformAccount();
1459           LogDebug("accountID: " << accountID);
1460         if (ACCOUNT_ERROR_NONE != account_update_to_db_by_id(m_platformAccount, accountID)) {
1461             ThrowMsg(PlatformException, "Can't update new account.");
1462         }
1463         LogDebug("Account updated");
1464     }
1465
1466 }
1467
1468 void AccountWrapper::loadAccount(int id)
1469 {
1470         LogDebug("Entered. ID of account to load: " << id);
1471
1472         freePlatformAccount();
1473
1474         if (ACCOUNT_ERROR_NONE != account_create(&m_platformAccount)) {
1475                 ThrowMsg(PlatformException, "Can't create handle");
1476         }
1477
1478         int errorCode = account_query_account_by_account_id(id, &m_platformAccount);
1479
1480         if (ACCOUNT_ERROR_NONE != errorCode) {
1481                 LogError("Can't get account with ID = " << id << ", error code: " << errorCode);
1482                 ThrowMsg(PlatformException, "Can't get account with ID = " << id << ", error code: " << errorCode);
1483         }
1484         convertPlatformAccountToAbstractAccount();
1485         displayAbstractAccount();
1486 }
1487
1488 void AccountWrapper::deleteAccount()
1489 {
1490     if (m_platformAccount == NULL) {
1491         ThrowMsg(NullPointerException, "Failed to delete event (m_platformAccount==NULL)");
1492     }
1493     int accountID = m_abstractAccount->getID();
1494     LogDebug("accountID : " << accountID);
1495     if (accountID < 0) {
1496         ThrowMsg(InvalidArgumentException, "Failed to delete account from account DB (account is not saved in account DB)");
1497     }
1498
1499     int err = -1;
1500     err = account_delete_from_db_by_id(accountID);
1501     if (ACCOUNT_ERROR_NONE != err) {
1502         ThrowMsg(PlatformException, "Can't delete account. Error code " << err);
1503     }
1504     //TODO: Is it necessary?
1505     //m_abstractAccount->resetId();
1506     //setIDToPlatformAccount();
1507 }
1508
1509 void AccountWrapper::getAccountbyId()
1510 {
1511     std::string accountID = m_abstractAccount->getAccountId();
1512     LogDebug("accountID : " << accountID);
1513         unsigned long value = 123;
1514         bool b_value = true;
1515
1516 //      int errorCode = getAccountById(m_abstractAccount->getAccountId().c_str(), &user_account);
1517
1518         m_abstractAccount->setAccountId("com.google:getaccountbyid@gmail.com");
1519         m_abstractAccount->setDisplayName("samsung");
1520         m_abstractAccount->setIconPath("/path/icon/icon.png");
1521         m_abstractAccount->setProviderName("com.google");
1522         m_abstractAccount->setEnabled(b_value);
1523         m_abstractAccount->setCredentailId(value);
1524         m_abstractAccount->setSettings("port:8080, server:http://test.com");
1525 /*
1526         m_abstractAccount->setAccountId(user_account.AccountId);
1527         m_abstractAccount->setDisplayName(user_account.displayName);
1528         m_abstractAccount->setIconPath(user_account.icon);
1529         m_abstractAccount->setProviderName(user_account.AccountServiceProviderId);
1530         m_abstractAccount->setEnabled(user_account.enabled);
1531         m_abstractAccount->setCredentailId(user_account.credentialId);
1532         m_abstractAccount->setSettings(user_account.settings);
1533 */
1534 /*
1535         if (ACCOUNT_ERROR_NONE != errorCode) {
1536                 LogError("Can't get account with ID = " << id << ", error code: " << errorCode);
1537                 ThrowMsg(PlatformException, "Can't get account with ID = " << id << ", error code: " << errorCode);
1538         }
1539 */
1540 //      convertPlatformAccountToAbstractAccount();
1541 }
1542
1543 void AccountWrapper::getServiceTypebyId()
1544 {
1545     std::string serviceTypeId = m_abstractAccount->getServiceTypeId();
1546     LogDebug("serviceTypeId : " << serviceTypeId);
1547
1548 //      getServiceTypeById(m_abstractAccount->getServiceTypeId().c_str(), &serviceType);
1549         m_abstractAccount->setAccountId("com.google:getaccountbyid@gmail.com");
1550
1551 }
1552
1553 void AccountWrapper::getProviderbyId()
1554 {
1555     std::string providerId = m_abstractAccount->getProviderId();
1556     LogDebug("providerId : " << providerId);
1557
1558 //      getProviderById(m_abstractAccount->getProviderId().c_str(), &provider);
1559         m_abstractAccount->setAccountId("com.google:getaccountbyid@gmail.com");
1560
1561 }
1562
1563 void AccountWrapper::findProviders()
1564 {
1565     std::string serviceTypeId = m_abstractAccount->getServiceTypeId();
1566     LogDebug("serviceTypeId : " << serviceTypeId);
1567
1568         db_util_open(_QUERY_DB_NAME, &test_hDBCt, 0);
1569 //      insert_dummy_data();
1570
1571 #if 0
1572         GList* provider_list = NULL;
1573         int i = 0;
1574
1575         GList* account_list = NULL;
1576         UserAccount_t* account = NULL;
1577
1578         search_list_t search_list = {0, };
1579         set_account_filter(&search_list, SERVICE_TYPE_ID, "tizen.sms");
1580         find_accounts(&search_list, DISABLE, &account_list);
1581         while(account_list)
1582         {
1583                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1584             printf("account_info->AccountId : %s \n", account_info->AccountId);
1585             printf("account_info->AccountServiceProviderId : %s \n\n\n", account_info->AccountServiceProviderId);
1586                 account_list = g_list_next(account_list);
1587         }
1588
1589         search_list_t search_list1 = {0, };
1590         set_account_filter(&search_list1, TAGS, "tizen.sharing");
1591         find_accounts(&search_list1, DISABLE, &account_list);
1592         while(account_list)
1593         {
1594                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1595             printf("account_info->AccountId : %s \n", account_info->AccountId);
1596             printf("account_info->AccountServiceProviderId : %s \n\n\n", account_info->AccountServiceProviderId);
1597                 account_list = g_list_next(account_list);
1598         }
1599
1600         search_list_t search_list2 = {0, };
1601         set_account_filter(&search_list2, PROVIDER_ID, "com.google");
1602         find_accounts(&search_list2, DISABLE, &account_list);
1603         while(account_list)
1604         {
1605                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1606             printf("account_info->AccountId : %s \n", account_info->AccountId);
1607             printf("account_info->AccountServiceProviderId : %s \n\n\n", account_info->AccountServiceProviderId);
1608                 account_list = g_list_next(account_list);
1609         }
1610
1611         search_list_t search_list3 = {0, };
1612         set_account_filter(&search_list3, SERVICE_TYPE_ID, "tizen.sms");
1613         set_account_filter(&search_list3, TAGS, "tizen.sharing");
1614         set_account_filter(&search_list3, TAGS, "tizen.email");
1615         set_account_filter(&search_list3, PROVIDER_ID, "com.google");
1616         find_accounts(&search_list3, DISABLE, &account_list);
1617         while(account_list)
1618         {
1619                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1620             printf("account_info->AccountId : %s \n", account_info->AccountId);
1621             printf("account_info->AccountServiceProviderId : %s \n\n\n", account_info->AccountServiceProviderId);
1622                 account_list = g_list_next(account_list);
1623         }
1624
1625         search_list_t search_list4 = {0, };
1626         find_accounts(&search_list4, DISABLE, &account_list);
1627         while(account_list)
1628         {
1629                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1630             printf("account_info->AccountId : %s \n", account_info->AccountId);
1631             printf("account_info->AccountServiceProviderId : %s \n\n\n", account_info->AccountServiceProviderId);
1632                 account_list = g_list_next(account_list);
1633         }
1634
1635         search_list_t search_list5 = {0, };
1636         set_account_filter(&search_list5, TAGS, "tizen.sms");
1637         set_account_filter(&search_list5, TAGS, "tizen.mms");
1638         find_accounts(&search_list5, DISABLE, &account_list);
1639
1640         while(account_list)
1641         {
1642                 UserAccount_t* account_info = (UserAccount_t*)account_list->data;
1643             printf("account_info->AccountId : %s \n", account_info->AccountId);
1644             printf("account_info->AccountServiceProviderId : %s \n", account_info->AccountServiceProviderId);
1645
1646 // Add service info to Javascript obj
1647                 account_list = g_list_next(account_list);
1648         }
1649
1650 #endif
1651         GList* servicetype_list = NULL;
1652
1653         find_service_types("tizen", &servicetype_list);
1654         while(servicetype_list)
1655         {
1656                 AccountServiceType_t* service_type_info = (AccountServiceType_t*)servicetype_list->data;
1657             printf("service_type_info->AccountServiceTypeId : %s \n", service_type_info->AccountServiceTypeId);
1658             printf("service_type_info->displayName : %s \n", service_type_info->displayName);
1659             printf("service_type_info->icon : %s \n", service_type_info->icon);
1660
1661                 GList* tmp_tag_list = service_type_info->tags_info;
1662
1663                 while(tmp_tag_list)
1664                 {
1665                         tags_info_t* tag = (tags_info_t*)tmp_tag_list->data;
1666                     printf("tag->tag_info : %s \n", tag->tag_info);
1667
1668                         tmp_tag_list = g_list_next(tmp_tag_list);
1669                 }
1670
1671                 servicetype_list = g_list_next(servicetype_list);
1672         }
1673
1674         m_abstractAccount->setAccountId("com.google:findProviders@gmail.com");
1675
1676 }
1677
1678 void AccountWrapper::findServiceTypes()
1679 {
1680         std::string prefix = m_abstractAccount->getprefix();
1681     LogDebug("prefix : " << prefix);
1682 //      GList* servicetype_list = NULL;
1683
1684 //      find_service_types(m_abstractAccount->getprefix().c_str(), &servicetype_list);
1685
1686 //      m_abstractAccount->setAccountId("com.google:findServiceTypes@gmail.com");
1687
1688 }
1689
1690 char *AccountWrapper::getPlatformAccount() const
1691 {
1692     LogDebug("entered");
1693     return (char*)m_platformAccount;
1694 }
1695
1696 EventAccountPtr AccountWrapper::getAbstractAccount() const
1697 {
1698     LogDebug("entered");
1699     return m_abstractAccount;
1700 }
1701
1702 void AccountWrapper::freePlatformAccount()
1703 {
1704     LogDebug("entered");
1705     if (m_platformAccount != NULL) {
1706         if (ACCOUNT_ERROR_NONE != account_destroy(m_platformAccount)) {
1707             LogError("Can't free account handle.");
1708         }
1709         m_platformAccount = NULL;
1710     }
1711 }
1712
1713 char *AccountWrapper::convertAbstractAccountToPlatformAccount()
1714 {
1715         LogDebug("entered");
1716         freePlatformAccount();
1717
1718         if (ACCOUNT_ERROR_NONE != account_create(&m_platformAccount)) {
1719                 ThrowMsg(PlatformException, "Can't create handle");
1720         }
1721
1722         property.displayName = g_strdup(m_abstractAccount->getDisplayName().c_str());
1723         property.icon = g_strdup(m_abstractAccount->getIconPath().c_str());
1724
1725         setDisplayNameToPlatformAccount();
1726         setIconPathToPlatformAccount();
1727         setProviderNameToPlatformAccount();
1728 /*
1729         setUserNameToPlatformAccount();
1730         setPackageNameToPlatformAccount();
1731
1732         //TODO: check if we need to have  user be able to set  the ID.
1733         //setIDToPlatformAccount();
1734         setEmailAddressToPlatformAccount();
1735         setDomainNameToPlatformAccount();
1736
1737         setAccountServices();
1738 */
1739         return getPlatformAccount();
1740 }
1741
1742 void AccountWrapper::setIDToPlatformAccount()
1743 {
1744     LogDebug("entered");
1745
1746 //TODO: check if we need to have  user be able to set  the ID.
1747
1748 #if 0
1749     if (!m_platformAccount) {
1750         ThrowMsg(UnknownException, "Null platform pointer.");
1751     }
1752     if (m_abstractAccount->getIdIsSet()) {
1753         if (CAL_SUCCESS != calendar_svc_struct_set_int(m_platformEvent,
1754                                                        CAL_VALUE_INT_INDEX,
1755                                                        m_abstractEvent->getId()))
1756         {
1757             ThrowMsg(PlatformException, "Can't set event ID.");
1758         }
1759     } else {
1760         if (CAL_SUCCESS != calendar_svc_struct_set_int(m_platformEvent,
1761                                                        CAL_VALUE_INT_INDEX,
1762                                                        NEW_EVENT_ID)) {
1763             ThrowMsg(PlatformException, "Can't set event ID.");
1764         }
1765     }
1766         #endif
1767 }
1768
1769 void AccountWrapper::setDisplayNameToPlatformAccount()
1770 {
1771     LogDebug("entered");
1772         if (!m_platformAccount) {
1773                 ThrowMsg(UnknownException, "Null platform pointer.");
1774         }
1775
1776         if (ACCOUNT_ERROR_NONE != account_set_display_name(m_platformAccount, m_abstractAccount->getDisplayName().c_str()))
1777         {
1778                 ThrowMsg(PlatformException, "Can't set displayname.");
1779         }
1780
1781 }
1782
1783 void AccountWrapper::setIconPathToPlatformAccount()
1784 {
1785     LogDebug("entered");
1786         if (!m_platformAccount) {
1787                 ThrowMsg(UnknownException, "Null platform pointer.");
1788         }
1789
1790         if (ACCOUNT_ERROR_NONE != account_set_icon_path(m_platformAccount, m_abstractAccount->getIconPath().c_str()))
1791         {
1792                 ThrowMsg(PlatformException, "Can't set iconPath.");
1793         }
1794
1795 }
1796
1797 void AccountWrapper::setProviderNameToPlatformAccount()
1798 {
1799     LogDebug("entered");
1800         if (!m_platformAccount) {
1801                 ThrowMsg(UnknownException, "Null platform pointer.");
1802         }
1803
1804         if (ACCOUNT_ERROR_NONE != account_set_source(m_platformAccount, m_abstractAccount->getProviderName().c_str()))
1805         {
1806                 ThrowMsg(PlatformException, "Can't set providername.");
1807         }
1808 }
1809
1810 void AccountWrapper::setEmailAddressToPlatformAccount()
1811 {
1812         LogDebug("entered");
1813         if (!m_platformAccount) {
1814                 ThrowMsg(UnknownException, "Null platform pointer.");
1815         }
1816
1817         if (ACCOUNT_ERROR_NONE != account_set_email_address(m_platformAccount, m_abstractAccount->getEmailAddress().c_str()))
1818         {
1819                 ThrowMsg(PlatformException, "Can't set packagename.");
1820         }
1821 }
1822
1823 void AccountWrapper::setDomainNameToPlatformAccount()
1824 {
1825         LogDebug("entered");
1826         if (!m_platformAccount) {
1827                 ThrowMsg(UnknownException, "Null platform pointer.");
1828         }
1829
1830         if (ACCOUNT_ERROR_NONE != account_set_domain_name(m_platformAccount, m_abstractAccount->getDomainName().c_str()))
1831         {
1832                 ThrowMsg(PlatformException, "Can't set packagename.");
1833         }
1834 }
1835
1836 /*
1837 void AccountWrapper::setHasContactFeatureToPlatformAccount()
1838 {
1839     LogDebug("entered");
1840     if (!m_platformAccount) {
1841         ThrowMsg(UnknownException, "Null platform pointer.");
1842     }
1843         account_set_capability(m_platformAccount, ACCOUNT_CAPABILITY_CONTACT, ACCOUNT_CAPABILITY_ENABLED);
1844 }
1845 */
1846
1847 void AccountWrapper::setAccountServices()
1848 {
1849     LogDebug("entered");
1850     if (!m_platformAccount) {
1851         ThrowMsg(UnknownException, "Null platform pointer.");
1852     }
1853
1854         AccountServicesArrayPtr services = m_abstractAccount->getService();
1855         if ((services == NULL) || (services->size() == 0))
1856                 return;
1857
1858         //add new items
1859         for (size_t i = 0; i < services->size(); ++i)
1860         {
1861             LogDebug("getServiceName : " << services->at(i)->getName().c_str());
1862 //          LogDebug("getServiceType : " << services->at(i)->getServiceType().c_str());
1863         }
1864
1865 }
1866
1867 void AccountWrapper::getAccountServices()
1868 {
1869     LogDebug("entered");
1870     if (!m_platformAccount) {
1871         ThrowMsg(UnknownException, "Null platform pointer.");
1872     }
1873
1874         AccountServicesArrayPtr services(new AccountServicesArray());
1875         for(int i = 0; i < 2; i++)
1876         {
1877                 AccountServicesPtr service(new AccountServices());
1878
1879                 service->setName("gmail");
1880 //              service->setServiceType("google_service");
1881
1882                 services->push_back(service);
1883         }
1884         m_abstractAccount->setService(services);
1885
1886 }
1887
1888 AccountServiceTypePropertyPtr AccountWrapper::getDummyAccountServiceType(){
1889
1890         std::string serviceTypeId = m_abstractAccount->getServiceTypeId();
1891
1892         AccountServiceTypePropertyPtr accountServiceTypePropertyPtr(new AccountServiceTypeProperty);
1893         accountServiceTypePropertyPtr->setId(serviceTypeId);
1894         accountServiceTypePropertyPtr->setDisplayName("dummyDisplayName");
1895         accountServiceTypePropertyPtr->setIconPath("dummyIconPath");
1896         std::vector<std::string> dummyVector;
1897         dummyVector.push_back("dummyTag1");
1898         dummyVector.push_back("dummyTag2");
1899         accountServiceTypePropertyPtr->setTags(dummyVector);
1900
1901         return accountServiceTypePropertyPtr;
1902 }
1903
1904 AccountServiceProviderPropertyPtr AccountWrapper::getDummyAccountServiceProviderProperty(){
1905         std::string accountServiceProviderId = m_abstractAccount->getProviderId();
1906
1907         AccountServiceProviderPropertyPtr accountServiceProviderPropertyPtr(new AccountServiceProviderProperty);
1908         accountServiceProviderPropertyPtr->setId(accountServiceProviderId);
1909         accountServiceProviderPropertyPtr->setDisplayName("dummyDisplayName");
1910         accountServiceProviderPropertyPtr->setIconPath("dummyIconPath");
1911
1912         return accountServiceProviderPropertyPtr;
1913 }
1914
1915 void AccountWrapper::setDummyServices(){
1916         LogDebug("<<<");
1917
1918         AccountServicesArrayPtr services(new AccountServicesArray());
1919         for (int i = 0; i < 2; i++) {
1920                 AccountServicesPtr service(new AccountServices());
1921
1922                 service->setId("dummy_id");
1923                 service->setName("dummy_name");
1924                 service->setApplicationId("dummy_applicationId");
1925                 service->setDisplayName("dummy_displayName");
1926                 service->setIcon("dummy_Icon");
1927                 service->setAccountId("dummy_accountId");
1928                 service->setServiceTypeId("dummy_serviceTypeId");
1929                 service->setProviderId("dummy_ProviderId");
1930 //              service->setTags("dummy_");
1931                 service->setSettings("dummy_settings");
1932
1933                 services->push_back(service);
1934         }
1935
1936         m_abstractAccount->setService(services);
1937
1938         LogDebug(">>>");
1939 }
1940
1941
1942 EventAccountPtr AccountWrapper::convertPlatformAccountToAbstractAccount()
1943 {
1944     LogDebug("entered");
1945     setDisplayNameFromPlatformAccount();
1946         setIconPathFromPlatformAccount();
1947     setProviderNameFromPlatformAccount();
1948
1949 /*
1950     setUserNameFromPlatformAccount();
1951     setPackageNameFromPlatformAccount();
1952     setIDFromPlatformAccount();
1953     setEmailAddressFromPlatformAccount();
1954     setDomainNameFromPlatformAccount();
1955
1956         getAccountServices();
1957 */
1958     displayPlatformAccount();
1959     return getAbstractAccount();
1960 }
1961
1962 EventAccountPtr AccountWrapper::convertPlatformAccountToAbstractAccount(account_h account_info)
1963 {
1964     LogDebug("entered");
1965         m_platformAccount = account_info;
1966     setDisplayNameFromPlatformAccount();
1967         setIconPathFromPlatformAccount();
1968     setProviderNameFromPlatformAccount();
1969 /*
1970     setUserNameFromPlatformAccount();
1971     setPackageNameFromPlatformAccount();
1972     setIDFromPlatformAccount();
1973     setEmailAddressFromPlatformAccount();
1974     setDomainNameFromPlatformAccount();
1975
1976         getAccountServices();
1977 */
1978     displayPlatformAccount();
1979     return getAbstractAccount();
1980 }
1981
1982 void AccountWrapper::setIDFromPlatformAccount()
1983 {
1984     LogDebug("entered");
1985     if (!m_platformAccount) {
1986         ThrowMsg(UnknownException, "Null platform pointer.");
1987     }
1988     m_abstractAccount->setID(getIDFromPlatformAccount());
1989 }
1990
1991 void AccountWrapper::setDisplayNameFromPlatformAccount()
1992 {
1993     LogDebug("entered");
1994     if (!m_platformAccount) {
1995         ThrowMsg(UnknownException, "Null platform pointer.");
1996     }
1997
1998     char *displayname = NULL;
1999         account_get_display_name(m_platformAccount, &displayname);
2000     if (displayname) {
2001         m_abstractAccount->setDisplayName(displayname);
2002     }
2003 }
2004
2005 void AccountWrapper::setIconPathFromPlatformAccount()
2006 {
2007     LogDebug("entered");
2008     if (!m_platformAccount) {
2009         ThrowMsg(UnknownException, "Null platform pointer.");
2010     }
2011
2012     char *iconPath = NULL;
2013         account_get_icon_path(m_platformAccount, &iconPath);
2014     if (iconPath) {
2015         m_abstractAccount->setIconPath(iconPath);
2016     }
2017 }
2018
2019 void AccountWrapper::setProviderNameFromPlatformAccount()
2020 {
2021     LogDebug("entered");
2022     if (!m_platformAccount) {
2023         ThrowMsg(UnknownException, "Null platform pointer.");
2024     }
2025
2026     char *providername = NULL;
2027         account_get_source(m_platformAccount, &providername);
2028     if (providername) {
2029         m_abstractAccount->setProviderName(providername);
2030     }
2031 }
2032
2033 void AccountWrapper::setEmailAddressFromPlatformAccount()
2034 {
2035     LogDebug("entered");
2036     if (!m_platformAccount) {
2037         ThrowMsg(UnknownException, "Null platform pointer.");
2038     }
2039
2040     char *emailaddress = NULL;
2041         account_get_email_address(m_platformAccount, &emailaddress);
2042     if (emailaddress) {
2043         m_abstractAccount->setEmailAddress(emailaddress);
2044     }
2045 }
2046
2047 void AccountWrapper::setDomainNameFromPlatformAccount()
2048 {
2049     LogDebug("entered");
2050     if (!m_platformAccount) {
2051         ThrowMsg(UnknownException, "Null platform pointer.");
2052     }
2053
2054     char *domainname = NULL;
2055         account_get_domain_name(m_platformAccount, &domainname);
2056     if (domainname) {
2057         m_abstractAccount->setDomainName(domainname);
2058     }
2059 }
2060
2061 void AccountWrapper::displayAbstractAccount()
2062 {
2063         LogDebug("account id : " << m_abstractAccount->getID());
2064         LogDebug("Display name  : " << m_abstractAccount->getDisplayName());
2065 }
2066
2067 void AccountWrapper::displayPlatformAccount()
2068 {
2069
2070 }
2071
2072 }
2073 }
2074 }