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