src/FNet_NetAccountDatabase.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0
  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 * @file                 FNet_NetAccountDatabase.cpp
  19 * @brief                This is the implementation file for the %_NetAccountDatabase class.
  20 *
  21 * This file contains the implementation of the %_NetAccountDatabase class.
  22 */
  23
  24 #include <unique_ptr.h>
  25 #include <FBaseString.h>
  26 #include <FBaseColIList.h>
  27 #include <FBaseColIListT.h>
  28 #include <FIoDatabase.h>
  29 #include <FIoDbStatement.h>
  30 #include <FIoDbEnumerator.h>
  31 #include <FIoDirectory.h>
  32 #include <FAppApp.h>
  33 #include <FBaseSysLog.h>
  34 #include <FApp_AppInfo.h>
  35 #include "FNet_NetTypes.h"
  36 #include "FNet_NetUtility.h"
  37 #include "FNet_NetAccountDatabase.h"
  38
  39 using namespace std;
  40 using namespace Tizen::App;
  41 using namespace Tizen::Base;
  42 using namespace Tizen::Base::Collection;
  43 using namespace Tizen::Io;
  44
  45 namespace Tizen { namespace Net {
  46
  47 result
  48 _NetAccountDatabase::InitializeRepository(void)
  49 {
  50         static const wchar_t _NET_ACCOUNT_DATABASE_CREATE_TABLE_STATEMENT[] =
  51                         L"CREATE TABLE IF NOT EXISTS NetAccountTable (accountId INTEGER UNIQUE, accountName TEXT(256) UNIQUE, profileName TEXT(256) UNIQUE, isReadOnly INTEGER)";
  52
  53         result r = E_SUCCESS;
  54         Database accountDb;
  55
  56         if (!Database::Exists(_NetAccountDatabase::GetDbPath()))
  57         {
  58                 SysLog(NID_NET, "NetAccount database is NOT found, so create it now.");
  59         }
  60
  61         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), true);
  62         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
  63
  64         r = accountDb.ExecuteSql(String(_NET_ACCOUNT_DATABASE_CREATE_TABLE_STATEMENT), true);
  65         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
  66
  67         return r;
  68 }
  69
  70 result
  71 _NetAccountDatabase::AddAccount(const String& accountName, const String& profileName, _NetAccountOwner owner, NetAccountId& accountId)
  72 {
  73         static const wchar_t _NET_ACCOUNT_DATABASE_GET_MAX_ACCOUNT_ID_STATEMENT[] =
  74                         L"SELECT MAX(accountId) FROM NetAccountTable";
  75         static const wchar_t _NET_ACCOUNT_DATABASE_ADD_ACCOUNT_STATEMENT[] =
  76                         L"INSERT INTO NetAccountTable (accountId, accountName, profileName, isReadOnly) VALUES(?, ?, ?, ?)";
  77
  78         result r = E_SUCCESS;
  79         Database accountDb;
  80         unique_ptr<DbStatement> pStmt;
  81         unique_ptr<DbEnumerator> pEnum;
  82         bool isReadOnly = true;
  83         NetAccountId netAccountId = INVALID_HANDLE;
  84
  85         SysSecureLog(NID_NET, "AddAccount() has been called with accountName:%ls, profileName:%ls, owner:%d",
  86                         accountName.GetPointer(), profileName.GetPointer(), owner);
  87
  88         accountId = INVALID_HANDLE;
  89
  90         SysTryReturnResult(NID_NET, !accountName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. accountName is an empty string.");
  91         SysTryReturnResult(NID_NET, !profileName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. profileName is an empty string.");
  92
  93         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
  94         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
  95
  96         if (owner == _NET_ACCOUNT_OWNER_THIS)
  97         {
  98                 isReadOnly = false;
  99         }
 100         else
 101         {
 102                 isReadOnly = true;
 103         }
 104
 105         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_MAX_ACCOUNT_ID_STATEMENT)));
 106         r = GetLastResult();
 107         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 108
 109         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 110         if (pEnum != null)
 111         {
 112                 while (pEnum->MoveNext() == E_SUCCESS)
 113                 {
 114                         pEnum->GetIntAt(0, netAccountId);
 115                         break;
 116                 }
 117         }
 118
 119         if (netAccountId >= _PS_ACCOUNT_ID_START)
 120         {
 121                 netAccountId++;
 122         }
 123         else
 124         {
 125                 netAccountId = _PS_ACCOUNT_ID_START;
 126         }
 127
 128         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_ADD_ACCOUNT_STATEMENT)));
 129         r = GetLastResult();
 130         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 131
 132         r = pStmt->BindInt(0, netAccountId);
 133         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 134
 135         r = pStmt->BindString(1, accountName);
 136         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 137
 138         r = pStmt->BindString(2, profileName);
 139         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 140
 141         r = pStmt->BindInt(3, (int)isReadOnly);
 142         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 143
 144         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 145         r = GetLastResult();
 146         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 147
 148         accountId = netAccountId;
 149
 150         return r;
 151 }
 152
 153 result
 154 _NetAccountDatabase::RemoveAccountByAccountId(NetAccountId accountId)
 155 {
 156         static const wchar_t _NET_ACCOUNT_DATABASE_REMOVE_ACCOUNT_BY_ACCOUNT_ID_STATEMENT[] =
 157                         L"DELETE FROM NetAccountTable WHERE accountId=?";
 158
 159         SysSecureLog(NID_NET, "RemoveAccountByAccountId() has been called with accountId:%d", accountId);
 160
 161         result r = E_SUCCESS;
 162         Database accountDb;
 163         unique_ptr<DbStatement> pStmt;
 164         unique_ptr<DbEnumerator> pEnum;
 165
 166         SysTryReturnResult(NID_NET, accountId > 0, E_INVALID_ARG, "Invalid argument is used. accountId=%d", accountId);
 167
 168         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 169         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 170
 171         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_REMOVE_ACCOUNT_BY_ACCOUNT_ID_STATEMENT)));
 172         r = GetLastResult();
 173         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 174
 175         r = pStmt->BindInt(0, accountId);
 176         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 177
 178         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 179         r = GetLastResult();
 180
 181         return r;
 182 }
 183
 184 result
 185 _NetAccountDatabase::RemoveAccountByProfileName(const String& profileName)
 186 {
 187         static const wchar_t _NET_ACCOUNT_DATABASE_REMOVE_ACCOUNT_BY_PROFILE_NAME_STATEMENT[] =
 188                         L"DELETE FROM NetAccountTable WHERE profileName=?";
 189
 190         SysLog(NID_NET, "RemoveAccountByProfileName() has been called with profileName:%ls", profileName.GetPointer());
 191
 192         result r = E_SUCCESS;
 193         Database accountDb;
 194         unique_ptr<DbStatement> pStmt;
 195         unique_ptr<DbEnumerator> pEnum;
 196
 197         SysTryReturnResult(NID_NET, !profileName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. profileName is an empty string.");
 198
 199         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 200         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 201
 202         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_REMOVE_ACCOUNT_BY_PROFILE_NAME_STATEMENT)));
 203         r = GetLastResult();
 204         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 205
 206         r = pStmt->BindString(0, profileName);
 207         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 208
 209         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 210         r = GetLastResult();
 211
 212         return r;
 213 }
 214
 215 result
 216 _NetAccountDatabase::UpdateAccountName(NetAccountId accountId, const String& accountName)
 217 {
 218         static const wchar_t _NET_ACCOUNT_DATABASE_UPDATE_ACCOUNT_NAME_STATEMENT[] =
 219                         L"UPDATE NetAccountTable SET accountName=? WHERE accountId=?";
 220
 221         SysSecureLog(NID_NET, "UpdateAccountName() has been called with accountId:%d, accountName:%ls", accountId, accountName.GetPointer());
 222
 223         result r = E_SUCCESS;
 224         Database accountDb;
 225         unique_ptr<DbStatement> pStmt;
 226         unique_ptr<DbEnumerator> pEnum;
 227
 228         SysTryReturnResult(NID_NET, accountId > 0, E_INVALID_ARG, "AccountId[%d] is invalid.", accountId);
 229         SysTryReturnResult(NID_NET, !accountName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. accountName is an empty string.");
 230
 231         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 232         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 233
 234         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_UPDATE_ACCOUNT_NAME_STATEMENT)));
 235         r = GetLastResult();
 236         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 237
 238         r = pStmt->BindString(0, accountName);
 239         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 240
 241         r = pStmt->BindInt(1, accountId);
 242         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 243
 244         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 245         r = GetLastResult();
 246
 247         return r;
 248 }
 249
 250 IListT<NetAccountId>*
 251 _NetAccountDatabase::GetAccountIdsN(void)
 252 {
 253         static const wchar_t _NET_ACCOUNT_DATABASE_GET_ACCOUNT_IDS_STATEMENT[] =
 254                         L"SELECT accountId FROM NetAccountTable";
 255
 256         result r = E_SUCCESS;
 257         Database accountDb;
 258         unique_ptr<DbStatement> pStmt;
 259         unique_ptr<DbEnumerator> pEnum;
 260         unique_ptr< ArrayListT<NetAccountId> > pList;
 261
 262         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 263         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 264
 265         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_ACCOUNT_IDS_STATEMENT)));
 266         r = GetLastResult();
 267         SysTryReturn(NID_NET, pStmt != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 268
 269         pList.reset(new (std::nothrow) ArrayListT<NetAccountId>());
 270         r = GetLastResult();
 271         SysTryReturn(NID_NET, pList != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 272
 273         r = pList->Construct();
 274         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 275
 276         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 277         r = GetLastResult();
 278         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 279
 280         if (pEnum != null)
 281         {
 282                 while (pEnum->MoveNext() == E_SUCCESS)
 283                 {
 284                         NetAccountId accountId = INVALID_HANDLE;
 285
 286                         r = pEnum->GetIntAt(0, accountId);
 287                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 288
 289                         r = pList->Add(accountId);
 290                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 291                 }
 292         }
 293
 294         ClearLastResult(); // To suppress E_OUT_OF_RANGE
 295
 296         return pList.release();
 297 }
 298
 299 IList*
 300 _NetAccountDatabase::GetAccountNamesN(void)
 301 {
 302         static const wchar_t _NET_ACCOUNT_DATABASE_GET_ACCOUNT_NAMES_STATEMENT[] =
 303                         L"SELECT accountName FROM NetAccountTable";
 304
 305         result r = E_SUCCESS;
 306         Database accountDb;
 307         unique_ptr<DbStatement> pStmt;
 308         unique_ptr<DbEnumerator> pEnum;
 309         unique_ptr<ArrayList, _CollectionDeleter> pList;
 310
 311         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 312         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 313
 314         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_ACCOUNT_NAMES_STATEMENT)));
 315         r = GetLastResult();
 316         SysTryReturn(NID_NET, pStmt != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 317
 318         pList.reset(new (std::nothrow) ArrayList());
 319         r = GetLastResult();
 320         SysTryReturn(NID_NET, pList != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 321
 322         r = pList->Construct();
 323         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 324
 325         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 326         r = GetLastResult();
 327         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 328
 329         if (pEnum != null)
 330         {
 331                 while (pEnum->MoveNext() == E_SUCCESS)
 332                 {
 333                         unique_ptr<String> pAccountName(new (std::nothrow) String());
 334                         SysTryReturn(NID_NET, pAccountName != null, null, E_OUT_OF_MEMORY,
 335                                         "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 336
 337                         r = pEnum->GetStringAt(0, *pAccountName);
 338                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 339
 340                         r = pList->Add(*pAccountName);
 341                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 342
 343                         pAccountName.release();
 344                 }
 345         }
 346
 347         ClearLastResult(); // To suppress E_OUT_OF_RANGE
 348
 349         return pList.release();
 350 }
 351
 352 IList*
 353 _NetAccountDatabase::GetProfileNamesN(void)
 354 {
 355         static const wchar_t _NET_ACCOUNT_DATABASE_GET_PROFILE_NAMES_STATEMENT[] =
 356                         L"SELECT profileName FROM NetAccountTable";
 357
 358         result r = E_SUCCESS;
 359         Database accountDb;
 360         unique_ptr<DbStatement> pStmt;
 361         unique_ptr<DbEnumerator> pEnum;
 362         unique_ptr<ArrayList, _CollectionDeleter> pList;
 363
 364         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 365         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 366
 367         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_PROFILE_NAMES_STATEMENT)));
 368         r = GetLastResult();
 369         SysTryReturn(NID_NET, pStmt != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 370
 371         pList.reset(new (std::nothrow) ArrayList());
 372         r = GetLastResult();
 373         SysTryReturn(NID_NET, pList != null, null, r, "[%s] Propagating.", GetErrorMessage(r));
 374
 375         r = pList->Construct();
 376         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 377
 378         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 379         r = GetLastResult();
 380         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 381
 382         if (pEnum != null)
 383         {
 384                 while (pEnum->MoveNext() == E_SUCCESS)
 385                 {
 386                         unique_ptr<String> pProfileName(new (std::nothrow) String());
 387                         SysTryReturn(NID_NET, pProfileName != null, null, E_OUT_OF_MEMORY,
 388                                         "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
 389
 390                         r = pEnum->GetStringAt(0, *pProfileName);
 391                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 392
 393                         r = pList->Add(*pProfileName);
 394                         SysTryReturn(NID_NET, r == E_SUCCESS, null, r, "[%s] Propagating.", GetErrorMessage(r));
 395
 396                         pProfileName.release();
 397                 }
 398         }
 399
 400         ClearLastResult(); // To suppress E_OUT_OF_RANGE
 401
 402         return pList.release();
 403 }
 404
 405 result
 406 _NetAccountDatabase::GetAccountName(NetAccountId accountId, String& accountName)
 407 {
 408         static const wchar_t _NET_ACCOUNT_DATABASE_GET_ACCOUNT_NAME_STATEMENT[] =
 409                         L"SELECT accountName FROM NetAccountTable WHERE accountId=?";
 410
 411         SysSecureLog(NID_NET, "GetAccountName() has been called with accountId:%d", accountId);
 412
 413         result r = E_SUCCESS;
 414         Database accountDb;
 415         unique_ptr<DbStatement> pStmt;
 416         unique_ptr<DbEnumerator> pEnum;
 417
 418         SysTryReturnResult(NID_NET, accountId > 0, E_INVALID_ARG, "Invalid argument is used. accountId=%d", accountId);
 419
 420         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 421         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 422
 423         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_ACCOUNT_NAME_STATEMENT)));
 424         r = GetLastResult();
 425         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 426
 427         r = pStmt->BindInt(0, accountId);
 428         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 429
 430         r = E_OBJ_NOT_FOUND;
 431
 432         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 433         if (pEnum != null)
 434         {
 435                 while (pEnum->MoveNext() == E_SUCCESS)
 436                 {
 437                         pEnum->GetStringAt(0, accountName);
 438                         r = E_SUCCESS;
 439                         break;
 440                 }
 441         }
 442
 443         return r;
 444 }
 445
 446 result
 447 _NetAccountDatabase::GetProfileName(NetAccountId accountId, String& profileName)
 448 {
 449         static const wchar_t _NET_ACCOUNT_DATABASE_GET_PROFILE_NAME_STATEMENT[] =
 450                         L"SELECT profileName FROM NetAccountTable WHERE accountId=?";
 451
 452         SysSecureLog(NID_NET, "GetProfileName() has been called with accountId:%d", accountId);
 453
 454         result r = E_SUCCESS;
 455         Database accountDb;
 456         unique_ptr<DbStatement> pStmt;
 457         unique_ptr<DbEnumerator> pEnum;
 458
 459         SysTryReturnResult(NID_NET, accountId > 0, E_INVALID_ARG, "Invalid argument is used. accountId=%d", accountId);
 460
 461         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 462         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 463
 464         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_PROFILE_NAME_STATEMENT)));
 465         r = GetLastResult();
 466         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 467
 468         r = pStmt->BindInt(0, accountId);
 469         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 470
 471         r = E_OBJ_NOT_FOUND;
 472
 473         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 474         if (pEnum != null)
 475         {
 476                 while (pEnum->MoveNext() == E_SUCCESS)
 477                 {
 478                         pEnum->GetStringAt(0, profileName);
 479                         r = E_SUCCESS;
 480                         break;
 481                 }
 482         }
 483
 484         return r;
 485 }
 486
 487 result
 488 _NetAccountDatabase::GetAccountIdByAccountName(const String& accountName, NetAccountId& accountId)
 489 {
 490         static const wchar_t _NET_ACCOUNT_DATABASE_GET_ACCOUNT_ID_BY_ACCOUNT_NAME_STATEMENT[] =
 491                         L"SELECT accountId FROM NetAccountTable WHERE accountName=?";
 492
 493         SysSecureLog(NID_NET, "GetAccountIdByAccountName() has been called with accountName:%ls", accountName.GetPointer());
 494
 495         result r = E_SUCCESS;
 496         Database accountDb;
 497         unique_ptr<DbStatement> pStmt;
 498         unique_ptr<DbEnumerator> pEnum;
 499
 500         SysTryReturnResult(NID_NET, !accountName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. accountName is an empty string.");
 501
 502         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 503         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 504
 505         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_ACCOUNT_ID_BY_ACCOUNT_NAME_STATEMENT)));
 506         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 507
 508         r = pStmt->BindString(0, accountName);
 509         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 510
 511         r = E_OBJ_NOT_FOUND;
 512
 513         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 514         if (pEnum != null)
 515         {
 516                 while (pEnum->MoveNext() == E_SUCCESS)
 517                 {
 518                         pEnum->GetIntAt(0, accountId);
 519                         r = E_SUCCESS;
 520                         break;
 521                 }
 522         }
 523
 524         return r;
 525 }
 526
 527 result
 528 _NetAccountDatabase::GetAccountIdByProfileName(const String& profileName, NetAccountId& accountId)
 529 {
 530         static const wchar_t _NET_ACCOUNT_DATABASE_GET_ACCOUNT_ID_BY_PROFILE_NAME_STATEMENT[] =
 531                         L"SELECT accountId FROM NetAccountTable WHERE profileName=?";
 532
 533         SysLog(NID_NET, "GetAccountIdByProfileName() has been called with profileName:%ls", profileName.GetPointer());
 534
 535         result r = E_SUCCESS;
 536         Database accountDb;
 537         unique_ptr<DbStatement> pStmt;
 538         unique_ptr<DbEnumerator> pEnum;
 539
 540         SysTryReturnResult(NID_NET, !profileName.IsEmpty(), E_INVALID_ARG, "Invalid argument is used. profileName is an empty string.");
 541
 542         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 543         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 544
 545         pStmt.reset(accountDb.CreateStatementN(String(_NET_ACCOUNT_DATABASE_GET_ACCOUNT_ID_BY_PROFILE_NAME_STATEMENT)));
 546         r = GetLastResult();
 547         SysTryReturnResult(NID_NET, pStmt != null, r, "Propagating.");
 548
 549         r = pStmt->BindString(0, profileName);
 550         SysTryReturnResult(NID_NET, r == E_SUCCESS, r, "Propagating.");
 551
 552         r = E_OBJ_NOT_FOUND;
 553
 554         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 555         if (pEnum != null)
 556         {
 557                 while (pEnum->MoveNext() == E_SUCCESS)
 558                 {
 559                         pEnum->GetIntAt(0, accountId);
 560                         r = E_SUCCESS;
 561                         break;
 562                 }
 563         }
 564
 565         return r;
 566 }
 567
 568 bool
 569 _NetAccountDatabase::IsReadOnly(NetAccountId accountId)
 570 {
 571         static const wchar_t NET_ACCOUNT_DATABASE_GET_IS_READ_ONLY_STATEMENT[] =
 572                         L"SELECT isReadOnly FROM NetAccountTable WHERE accountId=?";
 573
 574         SysSecureLog(NID_NET, "IsReadOnly() has been called with accountId:%d", accountId);
 575
 576         result r = E_SUCCESS;
 577         Database accountDb;
 578         unique_ptr<DbStatement> pStmt;
 579         unique_ptr<DbEnumerator> pEnum;
 580         int isReadOnly = 1;
 581
 582         SysTryReturn(NID_NET, accountId > 0, true, E_INVALID_ARG,
 583                         "[%s] Invalid argument is used. accountId=%d", GetErrorMessage(E_INVALID_ARG), accountId);
 584
 585         r = accountDb.Construct(_NetAccountDatabase::GetDbPath(), false);
 586         SysTryReturn(NID_NET, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 587
 588         pStmt.reset(accountDb.CreateStatementN(String(NET_ACCOUNT_DATABASE_GET_IS_READ_ONLY_STATEMENT)));
 589         r = GetLastResult();
 590         SysTryReturn(NID_NET, pStmt != null, true, r, "[%s] Propagating.", GetErrorMessage(r));
 591
 592         r = pStmt->BindInt(0, accountId);
 593         SysTryReturn(NID_NET, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 594
 595         r = E_OBJ_NOT_FOUND;
 596         pEnum.reset(accountDb.ExecuteStatementN(*pStmt));
 597         if (pEnum != null)
 598         {
 599                 while (pEnum->MoveNext() == E_SUCCESS)
 600                 {
 601                         pEnum->GetIntAt(0, isReadOnly);
 602                         r = E_SUCCESS;
 603                         break;
 604                 }
 605         }
 606         SysTryReturn(NID_NET, r == E_SUCCESS, true, r, "[%s] Propagating.", GetErrorMessage(r));
 607
 608         ClearLastResult();
 609
 610         return (bool)isReadOnly;
 611 }
 612
 613 String
 614 _NetAccountDatabase::GetDbPath(void)
 615 {
 616         static const wchar_t _OLD_DATA_PATH[] = L"/Home/";
 617         static const wchar_t _NET_ACCOUNT_DATABASE_FILE_NAME[] = L".tizen_netaccount.db";
 618
 619         String dbPath;
 620         _ApiVersion apiVersion = _AppInfo::GetApiVersion();
 621
 622         if (apiVersion == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
 623         {
 624                 dbPath = String(_OLD_DATA_PATH);
 625         }
 626         else
 627         {
 628                 dbPath = Tizen::App::App::GetInstance()->GetAppDataPath();
 629         }
 630
 631         dbPath += String(_NET_ACCOUNT_DATABASE_FILE_NAME);
 632
 633         SysLog(NID_NET, "GetDbPath() has been succeeded with the path:%ls", dbPath.GetPointer());
 634
 635         return dbPath;
 636 }
 637
 638 }} // Tizen::Net