projects/stargazer/plugins/store/firebird/firebird_store_users.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  19  */
  20
  21 /*
  22  *  User manipulation methods
  23  *
  24  *  $Revision: 1.19 $
  25  *  $Date: 2010/01/19 11:07:25 $
  26  *
  27  */
  28
  29 #include "stg/const.h"
  30 #include "firebird_store.h"
  31 #include "stg/ibpp.h"
  32
  33 //-----------------------------------------------------------------------------
  34 int FIREBIRD_STORE::GetUsersList(std::vector<std::string> * usersList) const
  35 {
  36 STG_LOCKER lock(&mutex);
  37
  38 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amRead, til, tlr);
  39 IBPP::Statement st = IBPP::StatementFactory(db, tr);
  40
  41 std::string name;
  42
  43 try
  44     {
  45     tr->Start();
  46     st->Execute("select name from tb_users");
  47     while (st->Fetch())
  48         {
  49         st->Get(1, name);
  50         usersList->push_back(name);
  51         }
  52     tr->Commit();
  53     }
  54
  55 catch (IBPP::Exception & ex)
  56     {
  57     tr->Rollback();
  58     strError = "IBPP exception";
  59     printfd(__FILE__, ex.what());
  60     return -1;
  61     }
  62
  63 return 0;
  64 }
  65 //-----------------------------------------------------------------------------
  66 int FIREBIRD_STORE::AddUser(const std::string & name) const
  67 {
  68 STG_LOCKER lock(&mutex);
  69
  70 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
  71 IBPP::Statement st = IBPP::StatementFactory(db, tr);
  72
  73 try
  74     {
  75     tr->Start();
  76     st->Prepare("execute procedure sp_add_user(?, ?)");
  77     st->Set(1, name);
  78     st->Set(2, DIR_NUM);
  79     st->Execute();
  80     tr->Commit();
  81     }
  82
  83 catch (IBPP::Exception & ex)
  84     {
  85     tr->Rollback();
  86     strError = "IBPP exception";
  87     printfd(__FILE__, ex.what());
  88     return -1;
  89     }
  90
  91 return 0;
  92 }
  93 //-----------------------------------------------------------------------------
  94 int FIREBIRD_STORE::DelUser(const std::string & login) const
  95 {
  96 STG_LOCKER lock(&mutex);
  97
  98 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
  99 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 100
 101 try
 102     {
 103     tr->Start();
 104     st->Prepare("execute procedure sp_delete_user(?)");
 105     st->Set(1, login);
 106     st->Execute();
 107     tr->Commit();
 108     }
 109
 110 catch (IBPP::Exception & ex)
 111     {
 112     tr->Rollback();
 113     strError = "IBPP exception";
 114     printfd(__FILE__, ex.what());
 115     return -1;
 116     }
 117
 118 return 0;
 119 }
 120 //-----------------------------------------------------------------------------
 121 int FIREBIRD_STORE::SaveUserStat(const USER_STAT & stat,
 122                                  const std::string & login) const
 123 {
 124 STG_LOCKER lock(&mutex);
 125
 126 return SaveStat(stat, login);
 127 }
 128 //-----------------------------------------------------------------------------
 129 int FIREBIRD_STORE::SaveStat(const USER_STAT & stat,
 130                                  const std::string & login,
 131                                  int year,
 132                                  int month) const
 133 {
 134 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 135 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 136
 137 try
 138     {
 139     tr->Start();
 140     st->Prepare("select pk_user from tb_users where name = ?");
 141     st->Set(1, login);
 142     st->Execute();
 143     if (!st->Fetch())
 144     {
 145     strError = "User \"" + login + "\" not found in database";
 146     printfd(__FILE__, "User '%s' not found in database\n", login.c_str());
 147     tr->Rollback();
 148     return -1;
 149     }
 150     st->Get(1, uid);
 151     st->Close();
 152     st->Prepare("select first 1 pk_stat from tb_stats where fk_user = ? order by stats_date desc");
 153     st->Set(1, uid);
 154     st->Execute();
 155     if (!st->Fetch())
 156     {
 157     tr->Rollback();
 158     strError = "No stat info for user \"" + login + "\"";
 159     printfd(__FILE__, "No stat info for user '%s'\n", login.c_str());
 160     return -1;
 161     }
 162     int32_t sid;
 163     st->Get(1, sid);
 164     st->Close();
 165
 166     IBPP::Timestamp actTime;
 167     time_t2ts(stat.lastActivityTime, &actTime);
 168     IBPP::Timestamp addTime;
 169     time_t2ts(stat.lastCashAddTime, &addTime);
 170     IBPP::Date dt;
 171     if (year != 0)
 172         ym2date(year, month, &dt);
 173     else
 174         dt.Today();
 175
 176     st->Prepare("update tb_stats set \
 177                     cash = ?, \
 178                     free_mb = ?, \
 179                     last_activity_time = ?, \
 180                     last_cash_add = ?, \
 181                     last_cash_add_time = ?, \
 182                     passive_time = ?, \
 183                     stats_date = ? \
 184                  where pk_stat = ?");
 185
 186     st->Set(1, stat.cash);
 187     st->Set(2, stat.freeMb);
 188     st->Set(3, actTime);
 189     st->Set(4, stat.lastCashAdd);
 190     st->Set(5, addTime);
 191     st->Set(6, (int32_t)stat.passiveTime);
 192     st->Set(7, dt);
 193     st->Set(8, sid);
 194
 195     st->Execute();
 196     st->Close();
 197
 198     for(int i = 0; i < DIR_NUM; i++)
 199         {
 200         st->Prepare("update tb_stats_traffic set \
 201                         upload = ?, \
 202                         download = ? \
 203                      where fk_stat = ? and dir_num = ?");
 204         st->Set(1, (int64_t)stat.monthUp[i]);
 205         st->Set(2, (int64_t)stat.monthDown[i]);
 206         st->Set(3, sid);
 207         st->Set(4, i);
 208         st->Execute();
 209         st->Close();
 210         }
 211
 212     tr->Commit();
 213     }
 214
 215 catch (IBPP::Exception & ex)
 216     {
 217     tr->Rollback();
 218     strError = "IBPP exception";
 219     printfd(__FILE__, ex.what());
 220     return -1;
 221     }
 222
 223 return 0;
 224 }
 225 //-----------------------------------------------------------------------------
 226 int FIREBIRD_STORE::SaveUserConf(const USER_CONF & conf,
 227                                  const std::string & login) const
 228 {
 229 STG_LOCKER lock(&mutex);
 230
 231 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 232 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 233
 234 try
 235     {
 236     tr->Start();
 237     st->Prepare("select pk_user from tb_users where name = ?");
 238     st->Set(1, login);
 239     st->Execute();
 240     if (!st->Fetch())
 241         {
 242         strError = "User \"" + login + "\" not found in database";
 243         printfd(__FILE__, "User '%s' not found in database\n", login.c_str());
 244         tr->Rollback();
 245         return -1;
 246         }
 247     int32_t uid;
 248     st->Get(1, uid);
 249     st->Close();
 250
 251     IBPP::Timestamp creditExpire;
 252     time_t2ts(conf.creditExpire, &creditExpire);
 253
 254     st->Prepare("update tb_users set \
 255                     address = ?, \
 256                     always_online = ?, \
 257                     credit = ?, \
 258                     credit_expire = ?, \
 259                     disabled = ?, \
 260                     disabled_detail_stat = ?, \
 261                     email = ?, \
 262                     grp = ?, \
 263                     note = ?, \
 264                     passive = ?, \
 265                     passwd = ?, \
 266                     phone = ?, \
 267                     fk_tariff = (select pk_tariff from tb_tariffs \
 268                                  where name = ?), \
 269                     fk_tariff_change = (select pk_tariff from tb_tariffs \
 270                                         where name = ?), \
 271                     fk_corporation = (select pk_corporation from tb_corporations \
 272                                       where name = ?), \
 273                     real_name = ? \
 274                  where pk_user = ?");
 275
 276     st->Set(1, conf.address);
 277     st->Set(2, (bool)conf.alwaysOnline);
 278     st->Set(3, conf.credit);
 279     st->Set(4, creditExpire);
 280     st->Set(5, (bool)conf.disabled);
 281     st->Set(6, (bool)conf.disabledDetailStat);
 282     st->Set(7, conf.email);
 283     st->Set(8, conf.group);
 284     st->Set(9, conf.note);
 285     st->Set(10, (bool)conf.passive);
 286     st->Set(11, conf.password);
 287     st->Set(12, conf.phone);
 288     st->Set(13, conf.tariffName);
 289     st->Set(14, conf.nextTariff);
 290     st->Set(15, conf.corp);
 291     st->Set(16, conf.realName);
 292     st->Set(17, uid);
 293
 294     st->Execute();
 295     st->Close();
 296
 297     st->Prepare("delete from tb_users_services where fk_user = ?");
 298     st->Set(1, uid);
 299     st->Execute();
 300     st->Close();
 301
 302     st->Prepare("insert into tb_users_services (fk_user, fk_service) \
 303                     values (?, (select pk_service from tb_services \
 304                                 where name = ?))");
 305     for(std::vector<std::string>::const_iterator it = conf.service.begin(); it != conf.service.end(); ++it)
 306         {
 307         st->Set(1, uid);
 308         st->Set(2, *it);
 309         st->Execute();
 310         }
 311     st->Close();
 312
 313     st->Prepare("delete from tb_users_data where fk_user = ?");
 314     st->Set(1, uid);
 315     st->Execute();
 316     st->Close();
 317
 318     int i = 0;
 319     st->Prepare("insert into tb_users_data (fk_user, data, num) values (?, ?, ?)");
 320     for (std::vector<std::string>::const_iterator it = conf.userdata.begin(); it != conf.userdata.end(); ++it)
 321         {
 322         st->Set(1, uid);
 323         st->Set(2, *it);
 324         st->Set(3, i++);
 325         st->Execute();
 326         }
 327     st->Close();
 328
 329     st->Prepare("delete from tb_allowed_ip where fk_user = ?");
 330     st->Set(1, uid);
 331     st->Execute();
 332
 333     st->Prepare("insert into tb_allowed_ip (fk_user, ip, mask) values (?, ?, ?)");
 334     for(size_t i = 0; i < conf.ips.Count(); i++)
 335         {
 336         st->Set(1, uid);
 337         st->Set(2, (int32_t)conf.ips[i].ip);
 338         st->Set(3, (int32_t)conf.ips[i].mask);
 339         st->Execute();
 340         }
 341     tr->Commit();
 342     }
 343 catch (IBPP::Exception & ex)
 344     {
 345     tr->Rollback();
 346     strError = "IBPP exception";
 347     printfd(__FILE__, ex.what());
 348     return -1;
 349     }
 350
 351 return 0;
 352 }
 353 //-----------------------------------------------------------------------------
 354 int FIREBIRD_STORE::RestoreUserStat(USER_STAT * stat,
 355                                     const std::string & login) const
 356 {
 357 STG_LOCKER lock(&mutex);
 358
 359 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amRead, til, tlr);
 360 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 361
 362 try
 363     {
 364     tr->Start();
 365     st->Prepare("select pk_user from tb_users where name = ?");
 366     st->Set(1, login);
 367     st->Execute();
 368     if (!st->Fetch())
 369         {
 370         strError = "User \"" + login + "\" not found in database";
 371         printfd(__FILE__, "User '%s' not found in database\n", login.c_str());
 372         return -1;
 373         }
 374     int32_t uid;
 375     st->Get(1, uid);
 376     st->Close();
 377
 378     st->Prepare("select first 1 pk_stat, cash, free_mb, last_activity_time, \
 379                     last_cash_add, last_cash_add_time, passive_time from tb_stats \
 380                  where fk_user = ? order by stats_date desc");
 381     st->Set(1, uid);
 382     st->Execute();
 383     if (!st->Fetch())
 384         {
 385         strError = "No stat info for user \"" + login + "\"";
 386         printfd(__FILE__, "No stat info for user '%s'\n", login.c_str());
 387         tr->Rollback();
 388         return -1;
 389         }
 390
 391     int32_t sid;
 392     st->Get(1, sid);
 393     st->Get(2, stat->cash);
 394     st->Get(3, stat->freeMb);
 395     IBPP::Timestamp actTime;
 396     st->Get(4, actTime);
 397     st->Get(5, stat->lastCashAdd);
 398     IBPP::Timestamp addTime;
 399     st->Get(6, addTime);
 400     int32_t passiveTime;
 401     st->Get(7, passiveTime);
 402
 403     stat->passiveTime = passiveTime;
 404
 405     stat->lastActivityTime = ts2time_t(actTime);
 406
 407     stat->lastCashAddTime = ts2time_t(addTime);
 408
 409     st->Close();
 410     st->Prepare("select * from tb_stats_traffic where fk_stat = ?");
 411     st->Set(1, sid);
 412     st->Execute();
 413     for(int i = 0; i < DIR_NUM; i++)
 414         {
 415         if (st->Fetch())
 416             {
 417             int dir;
 418             st->Get(3, dir);
 419             st->Get(5, (int64_t &)stat->monthUp[dir]);
 420             st->Get(4, (int64_t &)stat->monthDown[dir]);
 421             }
 422         else
 423             {
 424             break;
 425             }
 426         }
 427     tr->Commit();
 428     }
 429
 430 catch (IBPP::Exception & ex)
 431     {
 432     tr->Rollback();
 433     strError = "IBPP exception";
 434     printfd(__FILE__, ex.what());
 435     return -1;
 436     }
 437
 438 return 0;
 439 }
 440 //-----------------------------------------------------------------------------
 441 int FIREBIRD_STORE::RestoreUserConf(USER_CONF * conf,
 442                                     const std::string & login) const
 443 {
 444 STG_LOCKER lock(&mutex);
 445
 446 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amRead, til, tlr);
 447 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 448
 449 try
 450     {
 451     tr->Start();
 452     st->Prepare("select tb_users.pk_user, tb_users.address, tb_users.always_online, \
 453                         tb_users.credit, tb_users.credit_expire, tb_users.disabled, \
 454                         tb_users.disabled_detail_stat, tb_users.email, tb_users.grp, \
 455                         tb_users.note, tb_users.passive, tb_users.passwd, tb_users.phone, \
 456                         tb_users.real_name, tf1.name, tf2.name, tb_corporations.name \
 457                  from tb_users left join tb_tariffs tf1 \
 458                  on tf1.pk_tariff = tb_users.fk_tariff \
 459                  left join tb_tariffs tf2 \
 460                  on tf2.pk_tariff = tb_users.fk_tariff_change \
 461                  left join tb_corporations \
 462                  on tb_corporations.pk_corporation = tb_users.fk_corporation \
 463                  where tb_users.name = ?");
 464     st->Set(1, login);
 465     st->Execute();
 466     if (!st->Fetch())
 467         {
 468         strError = "User \"" + login + "\" not found in database";
 469     printfd(__FILE__, "User '%s' not found in database", login.c_str());
 470         tr->Rollback();
 471         return -1;
 472         }
 473     int32_t uid;
 474     st->Get(1, uid);
 475     // Getting base config
 476     st->Get(2, conf->address);
 477     bool test;
 478     st->Get(3, test);
 479     conf->alwaysOnline = test;
 480     st->Get(4, conf->credit);
 481     IBPP::Timestamp timestamp;
 482     st->Get(5, timestamp);
 483
 484     conf->creditExpire = ts2time_t(timestamp);
 485
 486     st->Get(6, test);
 487     conf->disabled = test;
 488     st->Get(7, test);
 489     conf->disabledDetailStat = test;
 490     st->Get(8, conf->email);
 491     st->Get(9, conf->group);
 492     st->Get(10, conf->note);
 493     st->Get(11, test);
 494     conf->passive = test;
 495     st->Get(12, conf->password);
 496     st->Get(13, conf->phone);
 497     st->Get(14, conf->realName);
 498     st->Get(15, conf->tariffName);
 499     st->Get(16, conf->nextTariff);
 500     st->Get(17, conf->corp);
 501
 502     if (conf->tariffName == "")
 503         conf->tariffName = NO_TARIFF_NAME;
 504     if (conf->corp == "")
 505         conf->corp = NO_CORP_NAME;
 506
 507     // Services
 508     st->Close();
 509     st->Prepare("select name from tb_services \
 510                  where pk_service in \
 511                     (select fk_service from tb_users_services \
 512                      where fk_user = ?)");
 513     st->Set(1, uid);
 514     st->Execute();
 515     while (st->Fetch())
 516         {
 517         std::string name;
 518         st->Get(1, name);
 519         conf->service.push_back(name);
 520         }
 521
 522     // User data
 523     st->Close();
 524     st->Prepare("select data, num from tb_users_data where fk_user = ? order by num");
 525     st->Set(1, uid);
 526     st->Execute();
 527     while (st->Fetch())
 528         {
 529         int i;
 530         st->Get(2, i);
 531         st->Get(1, conf->userdata[i]);
 532         }
 533
 534     // User IPs
 535     st->Close();
 536     st->Prepare("select ip, mask from tb_allowed_ip \
 537                  where fk_user = ?");
 538     st->Set(1, uid);
 539     st->Execute();
 540     conf->ips.Erase();
 541     while (st->Fetch())
 542         {
 543         IP_MASK im;
 544         st->Get(1, (int32_t &)im.ip);
 545         st->Get(2, (int32_t &)im.mask);
 546         conf->ips.Add(im);
 547         }
 548
 549     tr->Commit();
 550     }
 551 catch (IBPP::Exception & ex)
 552     {
 553     tr->Rollback();
 554     strError = "IBPP exception";
 555     printfd(__FILE__, ex.what());
 556     return -1;
 557     }
 558
 559 return 0;
 560 }
 561 //-----------------------------------------------------------------------------
 562 int FIREBIRD_STORE::WriteUserChgLog(const std::string & login,
 563                                     const std::string & admLogin,
 564                                     uint32_t admIP,
 565                                     const std::string & paramName,
 566                                     const std::string & oldValue,
 567                                     const std::string & newValue,
 568                                     const std::string & message = "") const
 569 {
 570 STG_LOCKER lock(&mutex);
 571
 572 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 573 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 574 IBPP::Timestamp now;
 575 now.Now();
 576
 577 std::string temp = ""; // Composed message for log
 578
 579 try
 580     {
 581     tr->Start();
 582     temp += "Admin \"" + admLogin + "\", ";
 583     temp += inet_ntostring(admIP);
 584     temp += ": ";
 585     temp = temp + message;
 586     //----------------------------------------------------------------------------------------
 587     // Checking and inserting parameters in params table
 588     st->Prepare("select pk_parameter from tb_parameters where name = ?");
 589     st->Set(1, paramName);
 590     st->Execute();
 591     if (!st->Fetch())
 592         {
 593         st->Close();
 594         st->Prepare("insert into tb_parameters (name) values (?)");
 595         st->Set(1, paramName);
 596         st->Execute();
 597         }
 598     st->Close();
 599     //----------------------------------------------------------------------------------------
 600     st->Prepare("insert into tb_params_log \
 601                     (fk_user, fk_parameter, event_time, from_val, to_val, comment) \
 602                  values ((select pk_user from tb_users \
 603                           where name = ?), \
 604                          (select pk_parameter from tb_parameters \
 605                           where name = ?), \
 606                          ?, ?, ?, ?)");
 607     st->Set(1, login);
 608     st->Set(2, paramName);
 609     st->Set(3, now);
 610     st->Set(4, oldValue);
 611     st->Set(5, newValue);
 612     st->Set(6, temp);
 613     st->Execute();
 614     tr->Commit();
 615     }
 616
 617 catch (IBPP::Exception & ex)
 618     {
 619     tr->Rollback();
 620     strError = "IBPP exception";
 621     printfd(__FILE__, ex.what());
 622     return -1;
 623     }
 624
 625 return 0;
 626 }
 627 //-----------------------------------------------------------------------------
 628 int FIREBIRD_STORE::WriteUserConnect(const std::string & login, uint32_t ip) const
 629 {
 630 STG_LOCKER lock(&mutex);
 631
 632 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 633 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 634 IBPP::Timestamp now;
 635 now.Now();
 636
 637 try
 638     {
 639     tr->Start();
 640     st->Prepare("execute procedure sp_append_session_log(?, ?, 'c', ?)");
 641     st->Set(1, login);
 642     st->Set(2, now);
 643     st->Set(3, (int32_t)ip);
 644     tr->Commit();
 645     }
 646
 647 catch (IBPP::Exception & ex)
 648     {
 649     tr->Rollback();
 650     strError = "IBPP exception";
 651     printfd(__FILE__, ex.what());
 652     return -1;
 653     }
 654
 655 return 0;
 656 }
 657 //-----------------------------------------------------------------------------
 658 int FIREBIRD_STORE::WriteUserDisconnect(const std::string & login,
 659                     const DIR_TRAFF & up,
 660                     const DIR_TRAFF & down,
 661                     const DIR_TRAFF & sessionUp,
 662                     const DIR_TRAFF & sessionDown,
 663                     double /*cash*/,
 664                     double /*freeMb*/,
 665                     const std::string & /*reason*/) const
 666 {
 667 STG_LOCKER lock(&mutex);
 668
 669 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 670 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 671 IBPP::Timestamp now;
 672 now.Now();
 673
 674 try
 675     {
 676     tr->Start();
 677     st->Prepare("execute procedure sp_append_session_log(?, ?, 'd', 0)");
 678     st->Set(1, login);
 679     st->Set(2, now);
 680     st->Execute();
 681     int32_t id;
 682     st->Get(1, id);
 683     st->Prepare("insert into tb_sessions_data \
 684                     (fk_session_log, dir_num, session_upload, \
 685                      session_download, month_upload, month_download) \
 686                  values (?, ?, ?, ?, ?, ?)");
 687     for(int i = 0; i < DIR_NUM; i++)
 688         {
 689         st->Set(1, id);
 690         st->Set(2, i);
 691         st->Set(3, (int64_t)sessionUp[i]);
 692         st->Set(4, (int64_t)sessionDown[i]);
 693         st->Set(5, (int64_t)up[i]);
 694         st->Set(6, (int64_t)down[i]);
 695         st->Execute();
 696         }
 697     tr->Commit();
 698     }
 699
 700 catch (IBPP::Exception & ex)
 701     {
 702     tr->Rollback();
 703     strError = "IBPP exception";
 704     printfd(__FILE__, ex.what());
 705     return -1;
 706     }
 707
 708 return 0;
 709 }
 710 //-----------------------------------------------------------------------------
 711 int FIREBIRD_STORE::WriteDetailedStat(const std::map<IP_DIR_PAIR, STAT_NODE> & statTree,
 712                                       time_t lastStat,
 713                                       const std::string & login) const
 714 {
 715 STG_LOCKER lock(&mutex);
 716
 717 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 718 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 719
 720 IBPP::Timestamp statTime, now;
 721 now.Now();
 722
 723 time_t2ts(lastStat, &statTime);
 724
 725 try
 726     {
 727     tr->Start();
 728     std::map<IP_DIR_PAIR, STAT_NODE>::const_iterator it;
 729     it = statTree.begin();
 730     st->Prepare("insert into tb_detail_stats \
 731                     (till_time, from_time, fk_user, dir_num, \
 732                      ip, download, upload, cost) \
 733                  values (?, ?, (select pk_user from tb_users \
 734                                 where name = ?), \
 735                      ?, ?, ?, ?, ?)");
 736     while (it != statTree.end())
 737         {
 738         st->Set(1, now);
 739         st->Set(2, statTime);
 740         st->Set(3, login);
 741         st->Set(4, it->first.dir);
 742         st->Set(5, (int32_t)it->first.ip);
 743         st->Set(6, (int64_t)it->second.down);
 744         st->Set(7, (int64_t)it->second.up);
 745         st->Set(8, it->second.cash);
 746         st->Execute();
 747         ++it;
 748         }
 749     tr->Commit();
 750     }
 751
 752 catch (IBPP::Exception & ex)
 753     {
 754     tr->Rollback();
 755     strError = "IBPP exception";
 756     printfd(__FILE__, ex.what());
 757     return -1;
 758     }
 759
 760 return 0;
 761 }
 762 //-----------------------------------------------------------------------------
 763 int FIREBIRD_STORE::SaveMonthStat(const USER_STAT & stat, int month, int year, const std::string & login) const
 764 {
 765 STG_LOCKER lock(&mutex);
 766
 767 IBPP::Transaction tr = IBPP::TransactionFactory(db, IBPP::amWrite, til, tlr);
 768 IBPP::Statement st = IBPP::StatementFactory(db, tr);
 769
 770 IBPP::Timestamp now;
 771 IBPP::Date nowDate;
 772 nowDate.Today();
 773 now.Now();
 774
 775 if (SaveStat(stat, login, year, month))
 776     {
 777     return -1;
 778     }
 779
 780 try
 781     {
 782     tr->Start();
 783
 784     st->Prepare("execute procedure sp_add_stat(?, 0, 0, ?, 0, ?, 0, ?)");
 785     st->Set(1, login);
 786     st->Set(2, now);
 787     st->Set(3, now);
 788     st->Set(4, nowDate);
 789
 790     st->Execute();
 791     int32_t id;
 792     st->Get(1, id);
 793     st->Close();
 794
 795     st->Prepare("insert into tb_stats_traffic \
 796                     (fk_stat, dir_num, upload, download) \
 797                  values (?, ?, 0, 0)");
 798
 799     for(int i = 0; i < DIR_NUM; i++)
 800         {
 801         st->Set(1, id);
 802         st->Set(2, i);
 803         st->Execute();
 804         }
 805
 806     tr->Commit();
 807     }
 808 catch (IBPP::Exception & ex)
 809     {
 810     tr->Rollback();
 811     strError = "IBPP exception";
 812     printfd(__FILE__, ex.what());
 813     return -1;
 814     }
 815
 816 return 0;
 817 }
 818 //-----------------------------------------------------------------------------
 819