]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/store/postgresql/postgresql_store_users.cpp
0722cc4c8d76671982b60fcf2dd948a7ba8d7746
[stg.git] / projects / stargazer / plugins / store / postgresql / postgresql_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.14 $
25  *  $Date: 2010/05/07 07:26:36 $
26  *
27  */
28
29 #include <string>
30 #include <vector>
31 #include <sstream>
32 #include <ctime>
33
34 #include <libpq-fe.h>
35
36 #include "stg/const.h"
37 #include "stg/locker.h"
38 #include "../../../stg_timer.h"
39 #include "postgresql_store.h"
40
41 //-----------------------------------------------------------------------------
42 int POSTGRESQL_STORE::GetUsersList(std::vector<std::string> * usersList) const
43 {
44 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
45
46 if (PQstatus(connection) != CONNECTION_OK)
47     {
48     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
49     if (Reset())
50         {
51         strError = "Connection lost";
52         printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): '%s'\n", strError.c_str());
53         return -1;
54         }
55     }
56
57 PGresult * result;
58
59 if (StartTransaction())
60     {
61     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to start transaction'\n");
62     return -1;
63     }
64
65 result = PQexec(connection, "SELECT name FROM tb_users");
66
67 if (PQresultStatus(result) != PGRES_TUPLES_OK)
68     {
69     strError = PQresultErrorMessage(result);
70     PQclear(result);
71     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): '%s'\n", strError.c_str());
72     if (RollbackTransaction())
73         {
74         printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to rollback transaction'\n");
75         }
76     return -1;
77     }
78
79 int tuples = PQntuples(result);
80
81 for (int i = 0; i < tuples; ++i)
82     {
83     usersList->push_back(PQgetvalue(result, i, 0));
84     }
85
86 PQclear(result);
87
88 if (CommitTransaction())
89     {
90     printfd(__FILE__, "POSTGRESQL_STORE::GetUsersList(): 'Failed to commit transaction'\n");
91     return -1;
92     }
93
94 return 0;
95 }
96
97 //-----------------------------------------------------------------------------
98 int POSTGRESQL_STORE::AddUser(const std::string & name) const
99 {
100 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
101
102 if (PQstatus(connection) != CONNECTION_OK)
103     {
104     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
105     if (Reset())
106         {
107         strError = "Connection lost";
108         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): '%s'\n", strError.c_str());
109         return -1;
110         }
111     }
112
113 PGresult * result;
114
115 if (StartTransaction())
116     {
117     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to start transaction'\n");
118     return -1;
119     }
120
121 std::string elogin = name;
122
123 if (EscapeString(elogin))
124     {
125     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to escape login'\n");
126     if (RollbackTransaction())
127         {
128         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to rollback transaction'\n");
129         }
130     return -1;
131     }
132
133 std::ostringstream query;
134 query << "SELECT sp_add_user('" << elogin << "')";
135
136 result = PQexec(connection, query.str().c_str());
137
138 if (PQresultStatus(result) != PGRES_TUPLES_OK)
139     {
140     strError = PQresultErrorMessage(result);
141     PQclear(result);
142     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): '%s'\n", strError.c_str());
143     if (RollbackTransaction())
144         {
145         printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to rollback transaction'\n");
146         }
147     return -1;
148     }
149
150 PQclear(result);
151
152 if (CommitTransaction())
153     {
154     printfd(__FILE__, "POSTGRESQL_STORE::AddUser(): 'Failed to commit transaction'\n");
155     return -1;
156     }
157
158 return 0;
159 }
160
161 //-----------------------------------------------------------------------------
162 int POSTGRESQL_STORE::DelUser(const std::string & login) const
163 {
164 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
165
166 if (PQstatus(connection) != CONNECTION_OK)
167     {
168     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
169     if (Reset())
170         {
171         strError = "Connection lost";
172         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): '%s'\n", strError.c_str());
173         return -1;
174         }
175     }
176
177 PGresult * result;
178
179 if (StartTransaction())
180     {
181     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to start transaction'\n");
182     return -1;
183     }
184
185 std::string elogin = login;
186
187 if (EscapeString(elogin))
188     {
189     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to escape login'\n");
190     if (RollbackTransaction())
191         {
192         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to rollback transaction'\n");
193         }
194     return -1;
195     }
196
197 std::ostringstream query;
198 query << "DELETE FROM tb_users WHERE name = '" << elogin << "'";
199
200 result = PQexec(connection, query.str().c_str());
201
202 if (PQresultStatus(result) != PGRES_COMMAND_OK)
203     {
204     strError = PQresultErrorMessage(result);
205     PQclear(result);
206     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): '%s'\n", strError.c_str());
207     if (RollbackTransaction())
208         {
209         printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to rollback transaction'\n");
210         }
211     return -1;
212     }
213
214 PQclear(result);
215
216 if (CommitTransaction())
217     {
218     printfd(__FILE__, "POSTGRESQL_STORE::DelUser(): 'Failed to commit transaction'\n");
219     return -1;
220     }
221
222 return 0;
223 }
224 //-----------------------------------------------------------------------------
225 int POSTGRESQL_STORE::SaveUserStat(const USER_STAT & stat,
226                                    const std::string & login) const
227 {
228 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
229
230 return SaveStat(stat, login);
231 }
232 //-----------------------------------------------------------------------------
233 int POSTGRESQL_STORE::SaveStat(const USER_STAT & stat,
234                                const std::string & login,
235                                int year,
236                                int month) const
237 {
238 if (PQstatus(connection) != CONNECTION_OK)
239     {
240     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
241     if (Reset())
242         {
243         strError = "Connection lost";
244         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
245         return -1;
246         }
247     }
248
249 PGresult * result;
250
251 if (StartTransaction())
252     {
253     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to start transaction'\n");
254     return -1;
255     }
256
257 std::string elogin = login;
258
259 if (EscapeString(elogin))
260     {
261     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to escape login'\n");
262     if (RollbackTransaction())
263         {
264         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
265         }
266     return -1;
267     }
268
269 std::ostringstream query;
270 query << "UPDATE tb_users SET "
271             "cash = " << stat.cash << ", "
272             "free_mb = " << stat.freeMb << ", "
273             "last_activity_time = CAST('" << Int2TS(stat.lastActivityTime) << "' AS TIMESTAMP), "
274             "last_cash_add = " << stat.lastCashAdd << ", "
275             "last_cash_add_time = CAST('" << Int2TS(stat.lastCashAddTime) << "' AS TIMESTAMP), "
276             "passive_time = " << stat.passiveTime << " "
277          "WHERE name = '" << elogin << "'";
278
279 result = PQexec(connection, query.str().c_str());
280
281 if (PQresultStatus(result) != PGRES_COMMAND_OK)
282     {
283     strError = PQresultErrorMessage(result);
284     PQclear(result);
285     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
286     if (RollbackTransaction())
287         {
288         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
289         }
290     return -1;
291     }
292
293 PQclear(result);
294
295 std::string date;
296
297 MakeDate(date, year, month);
298
299 for (int dir = 0; dir < DIR_NUM; ++dir)
300     {
301     query.str("");
302     query << "SELECT sp_add_stats_traffic ("
303                 "'" << elogin << "', "
304                 "CAST('" << date << "' AS DATE), "
305                 "CAST(" << dir << " AS SMALLINT), "
306                 "CAST(" << stat.up[dir] << " AS BIGINT), "
307                 "CAST(" << stat.down[dir] << " AS BIGINT))";
308
309     result = PQexec(connection, query.str().c_str());
310
311     if (PQresultStatus(result) != PGRES_TUPLES_OK)
312         {
313         strError = PQresultErrorMessage(result);
314         PQclear(result);
315         printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): '%s'\n", strError.c_str());
316         if (RollbackTransaction())
317             {
318             printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to rollback transaction'\n");
319             }
320         return -1;
321         }
322
323     PQclear(result);
324     }
325
326 if (CommitTransaction())
327     {
328     printfd(__FILE__, "POSTGRESQL_STORE::SaveStat(): 'Failed to commit transaction'\n");
329     return -1;
330     }
331
332 return 0;
333 }
334
335 //-----------------------------------------------------------------------------
336 int POSTGRESQL_STORE::SaveUserConf(const USER_CONF & conf,
337                                  const std::string & login) const
338 {
339 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
340
341 if (PQstatus(connection) != CONNECTION_OK)
342     {
343     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
344     if (Reset())
345         {
346         strError = "Connection lost";
347         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
348         return -1;
349         }
350     }
351
352 PGresult * result;
353
354 if (StartTransaction())
355     {
356     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to start transaction'\n");
357     return -1;
358     }
359
360 std::string elogin = login;
361
362 if (EscapeString(elogin))
363     {
364     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape login'\n");
365     if (RollbackTransaction())
366         {
367         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
368         }
369     return -1;
370     }
371
372 std::ostringstream query;
373 query << "SELECT pk_user FROM tb_users WHERE name = '" << elogin << "'";
374
375 result = PQexec(connection, query.str().c_str());
376
377 if (PQresultStatus(result) != PGRES_TUPLES_OK)
378     {
379     strError = PQresultErrorMessage(result);
380     PQclear(result);
381     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
382     if (RollbackTransaction())
383         {
384         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
385         }
386     return -1;
387     }
388
389 int tuples = PQntuples(result);
390
391 if (tuples != 1)
392     {
393     strError = "Failed to fetch user's ID";
394     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
395     PQclear(result);
396     if (RollbackTransaction())
397         {
398         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
399         }
400     return -1;
401     }
402
403 uint32_t uid;
404
405     {
406     std::stringstream tuple;
407     tuple << PQgetvalue(result, 0, 0);
408
409     PQclear(result);
410
411     tuple >> uid;
412     }
413
414 std::string eaddress = conf.address;
415 std::string eemail = conf.email;
416 std::string egroup = conf.group;
417 std::string enote = conf.note;
418 std::string epassword = conf.password;
419 std::string ephone = conf.phone;
420 std::string erealname = conf.realName;
421 std::string etariffname = conf.tariffName;
422 std::string enexttariff = conf.nextTariff;
423 std::string ecorporation = conf.corp;
424
425 if (EscapeString(eaddress))
426     {
427     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape address'\n");
428     if (RollbackTransaction())
429         {
430         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
431         }
432     return -1;
433     }
434
435 if (EscapeString(eemail))
436     {
437     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape email'\n");
438     if (RollbackTransaction())
439         {
440         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
441         }
442     return -1;
443     }
444
445 if (EscapeString(egroup))
446     {
447     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape group'\n");
448     if (RollbackTransaction())
449         {
450         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
451         }
452     return -1;
453     }
454
455 if (EscapeString(enote))
456     {
457     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape note'\n");
458     if (RollbackTransaction())
459         {
460         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
461         }
462     return -1;
463     }
464
465 if (EscapeString(epassword))
466     {
467     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape password'\n");
468     if (RollbackTransaction())
469         {
470         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
471         }
472     return -1;
473     }
474
475 if (EscapeString(ephone))
476     {
477     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape phone'\n");
478     if (RollbackTransaction())
479         {
480         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
481         }
482     return -1;
483     }
484
485 if (EscapeString(erealname))
486     {
487     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape real name'\n");
488     if (RollbackTransaction())
489         {
490         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
491         }
492     return -1;
493     }
494
495 if (EscapeString(etariffname))
496     {
497     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape tariff name'\n");
498     if (RollbackTransaction())
499         {
500         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
501         }
502     return -1;
503     }
504
505 if (EscapeString(enexttariff))
506     {
507     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape next tariff name'\n");
508     if (RollbackTransaction())
509         {
510         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
511         }
512     return -1;
513     }
514
515 if (EscapeString(ecorporation))
516     {
517     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to escape corporation name'\n");
518     if (RollbackTransaction())
519         {
520         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
521         }
522     return -1;
523     }
524
525 query.str("");
526 query << "UPDATE tb_users SET "
527              "address = '" << eaddress << "', "
528              "always_online = " << (conf.alwaysOnline ? "'t'" : "'f'") << ", "
529              "credit = " << conf.credit << ", "
530              "credit_expire = CAST('" << Int2TS(conf.creditExpire) << "' AS TIMESTAMP), "
531              "disabled = " << (conf.disabled ? "'t'" : "'f'") << ", "
532              "disabled_detail_stat = " << (conf.disabledDetailStat ? "'t'" : "'f'") << ", "
533              "email = '" << eemail << "', "
534              "grp = '" << egroup << "', "
535              "note = '" << enote << "', "
536              "passive = " << (conf.passive ? "'t'" : "'f'") << ", "
537              "passwd = '" << epassword << "', "
538              "phone = '" << ephone << "', "
539              "real_name = '" << erealname << "', "
540              "fk_tariff = (SELECT pk_tariff "
541                    "FROM tb_tariffs "
542                    "WHERE name = '" << etariffname << "'), "
543              "fk_tariff_change = (SELECT pk_tariff "
544                    "FROM tb_tariffs "
545                    "WHERE name = '" << enexttariff << "'), "
546              "fk_corporation = (SELECT pk_corporation "
547                    "FROM tb_corporations "
548                    "WHERE name = '" << ecorporation << "') "
549          "WHERE pk_user = " << uid;
550
551 result = PQexec(connection, query.str().c_str());
552
553 if (PQresultStatus(result) != PGRES_COMMAND_OK)
554     {
555     strError = PQresultErrorMessage(result);
556     PQclear(result);
557     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): '%s'\n", strError.c_str());
558     if (RollbackTransaction())
559         {
560         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
561         }
562     return -1;
563     }
564
565 PQclear(result);
566
567 if (SaveUserServices(uid, conf.service))
568     {
569     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's services'\n");
570     if (RollbackTransaction())
571         {
572         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
573         }
574     return -1;
575     }
576
577 if (SaveUserData(uid, conf.userdata))
578     {
579     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's data'\n");
580     if (RollbackTransaction())
581         {
582         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
583         }
584     return -1;
585     }
586
587 if (SaveUserIPs(uid, conf.ips))
588     {
589     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to save user's IPs'\n");
590     if (RollbackTransaction())
591         {
592         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to rollback transaction'\n");
593         }
594     return -1;
595     }
596
597 if (CommitTransaction())
598     {
599     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserConf(): 'Failed to commit transaction'\n");
600     return -1;
601     }
602
603 return 0;
604 }
605
606 //-----------------------------------------------------------------------------
607 int POSTGRESQL_STORE::RestoreUserStat(USER_STAT * stat,
608                                     const std::string & login) const
609 {
610 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
611
612 if (PQstatus(connection) != CONNECTION_OK)
613     {
614     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
615     if (Reset())
616         {
617         strError = "Connection lost";
618         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
619         return -1;
620         }
621     }
622
623 PGresult * result;
624
625 if (StartTransaction())
626     {
627     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to start transaction'\n");
628     return -1;
629     }
630
631 std::string elogin = login;
632
633 if (EscapeString(elogin))
634     {
635     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to escape login'\n");
636     if (RollbackTransaction())
637         {
638         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
639         }
640     return -1;
641     }
642
643     {
644     std::ostringstream query;
645     query << "SELECT cash, free_mb, "
646                 "last_activity_time, last_cash_add, "
647                 "last_cash_add_time, passive_time "
648              "FROM tb_users "
649              "WHERE name = '" << elogin << "'";
650
651     result = PQexec(connection, query.str().c_str());
652     }
653
654 if (PQresultStatus(result) != PGRES_TUPLES_OK)
655     {
656     strError = PQresultErrorMessage(result);
657     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
658     PQclear(result);
659     if (RollbackTransaction())
660         {
661         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
662         }
663     return -1;
664     }
665
666 int tuples = PQntuples(result);
667
668 if (tuples != 1)
669     {
670     strError = "Failed to fetch user's stat";
671     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
672     PQclear(result);
673     if (RollbackTransaction())
674         {
675         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
676         }
677     return -1;
678     }
679
680     {
681     std::stringstream tuple;
682     tuple << PQgetvalue(result, 0, 0) << " ";
683     tuple << PQgetvalue(result, 0, 1) << " ";
684     stat->lastActivityTime = TS2Int(PQgetvalue(result, 0, 2));
685     tuple << PQgetvalue(result, 0, 3) << " ";
686     stat->lastCashAddTime = TS2Int(PQgetvalue(result, 0, 4));
687     tuple << PQgetvalue(result, 0, 5) << " ";
688
689     PQclear(result);
690
691     tuple >> stat->cash
692           >> stat->freeMb
693           >> stat->lastCashAdd
694           >> stat->passiveTime;
695     }
696
697     {
698     std::ostringstream query;
699     query << "SELECT dir_num, upload, download "
700              "FROM tb_stats_traffic "
701              "WHERE fk_user IN (SELECT pk_user FROM tb_users WHERE name = '" << elogin << "') AND "
702                    "DATE_TRUNC('month', stats_date) = DATE_TRUNC('month', CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP))";
703
704     result = PQexec(connection, query.str().c_str());
705     }
706
707 if (PQresultStatus(result) != PGRES_TUPLES_OK)
708     {
709     strError = PQresultErrorMessage(result);
710     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): '%s'\n", strError.c_str());
711     PQclear(result);
712     if (RollbackTransaction())
713         {
714         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
715         }
716     return -1;
717     }
718
719 tuples = PQntuples(result);
720
721 for (int i = 0; i < tuples; ++i)
722     {
723     std::stringstream tuple;
724     tuple << PQgetvalue(result, i, 0) << " ";
725     tuple << PQgetvalue(result, i, 1) << " ";
726     tuple << PQgetvalue(result, i, 2) << " ";
727
728     int dir;
729
730     tuple >> dir;
731     tuple >> stat->up[dir];
732     tuple >> stat->down[dir];
733     }
734
735 PQclear(result);
736
737 if (CommitTransaction())
738     {
739     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to commit transaction'\n");
740     return -1;
741     }
742
743 return 0;
744 }
745
746 //-----------------------------------------------------------------------------
747 int POSTGRESQL_STORE::RestoreUserConf(USER_CONF * conf,
748                                     const std::string & login) const
749 {
750 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
751
752 if (PQstatus(connection) != CONNECTION_OK)
753     {
754     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
755     if (Reset())
756         {
757         strError = "Connection lost";
758         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
759         return -1;
760         }
761     }
762
763 PGresult * result;
764
765 if (StartTransaction())
766     {
767     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to start transaction'\n");
768     return -1;
769     }
770
771 std::string elogin = login;
772
773 if (EscapeString(elogin))
774     {
775     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to escape login'\n");
776     if (RollbackTransaction())
777         {
778         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserStat(): 'Failed to rollback transaction'\n");
779         }
780     return -1;
781     }
782
783     {
784     std::ostringstream query;
785     query << "SELECT tb_users.pk_user, tb_users.address, tb_users.always_online, "
786                     "tb_users.credit, tb_users.credit_expire, tb_users.disabled, "
787                     "tb_users.disabled_detail_stat, tb_users.email, tb_users.grp, "
788                     "tb_users.note, tb_users.passive, tb_users.passwd, tb_users.phone, "
789                     "tb_users.real_name, tf1.name, tf2.name, tb_corporations.name "
790              "FROM tb_users LEFT JOIN tb_tariffs AS tf1 "
791                                 "ON tf1.pk_tariff = tb_users.fk_tariff "
792                            "LEFT JOIN tb_tariffs AS tf2 "
793                                 "ON tf2.pk_tariff = tb_users.fk_tariff_change "
794                            "LEFT JOIN tb_corporations "
795                                 "ON tb_corporations.pk_corporation = tb_users.fk_corporation "
796              "WHERE tb_users.name = '" << elogin << "'";
797
798     result = PQexec(connection, query.str().c_str());
799     }
800
801 if (PQresultStatus(result) != PGRES_TUPLES_OK)
802     {
803     strError = PQresultErrorMessage(result);
804     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
805     PQclear(result);
806     if (RollbackTransaction())
807         {
808         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
809         }
810     return -1;
811     }
812
813 int tuples = PQntuples(result);
814
815 if (tuples != 1)
816     {
817     strError = "Failed to fetch user's stat";
818     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
819     PQclear(result);
820     if (RollbackTransaction())
821         {
822         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
823         }
824     return -1;
825     }
826
827 uint32_t uid;
828
829     {
830     std::stringstream tuple;
831     tuple << PQgetvalue(result, 0, 0) << " ";               // uid
832     conf->address = PQgetvalue(result, 0, 1);               // address
833     conf->alwaysOnline = !strncmp(PQgetvalue(result, 0, 2), "t", 1);
834     tuple << PQgetvalue(result, 0, 3) << " ";               // credit
835     conf->creditExpire = TS2Int(PQgetvalue(result, 0, 4));  // creditExpire
836     conf->disabled = !strncmp(PQgetvalue(result, 0, 5), "t", 1);
837     conf->disabledDetailStat = !strncmp(PQgetvalue(result, 0, 6), "t", 1);
838     conf->email = PQgetvalue(result, 0, 7);                 // email
839     conf->group = PQgetvalue(result, 0, 8);                 // group
840     conf->note = PQgetvalue(result, 0, 9);                  // note
841     conf->passive = !strncmp(PQgetvalue(result, 0, 10), "t", 1);
842     conf->password = PQgetvalue(result, 0, 11);             // password
843     conf->phone = PQgetvalue(result, 0, 12);                // phone
844     conf->realName = PQgetvalue(result, 0, 13);             // realName
845     conf->tariffName = PQgetvalue(result, 0, 14);           // tariffName
846     conf->nextTariff = PQgetvalue(result, 0, 15);           // nextTariff
847     conf->corp = PQgetvalue(result, 0, 16);                 // corp
848
849     PQclear(result);
850
851     if (conf->tariffName == "")
852         conf->tariffName = NO_TARIFF_NAME;
853     if (conf->corp == "")
854         conf->corp = NO_CORP_NAME;
855
856     tuple >> uid
857           >> conf->credit;
858     }
859
860     {
861     std::ostringstream query;
862     query << "SELECT name FROM tb_services "
863              "WHERE pk_service IN (SELECT fk_service "
864                                   "FROM tb_users_services "
865                                   "WHERE fk_user = " << uid << ")";
866
867     result = PQexec(connection, query.str().c_str());
868     }
869
870 if (PQresultStatus(result) != PGRES_TUPLES_OK)
871     {
872     strError = PQresultErrorMessage(result);
873     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
874     PQclear(result);
875     if (RollbackTransaction())
876         {
877         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
878         }
879     return -1;
880     }
881
882 tuples = PQntuples(result);
883
884 for (int i = 0; i < tuples; ++i)
885     {
886     conf->service.push_back(PQgetvalue(result, i, 0));
887     }
888
889 PQclear(result);
890
891     {
892     std::ostringstream query;
893     query << "SELECT num, data "
894              "FROM tb_users_data "
895              "WHERE fk_user = " << uid;
896
897     result = PQexec(connection, query.str().c_str());
898     }
899
900 if (PQresultStatus(result) != PGRES_TUPLES_OK)
901     {
902     strError = PQresultErrorMessage(result);
903     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
904     PQclear(result);
905     if (RollbackTransaction())
906         {
907         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
908         }
909     return -1;
910     }
911
912 tuples = PQntuples(result);
913
914 for (int i = 0; i < tuples; ++i)
915     {
916     int num;
917     if (str2x(PQgetvalue(result, i, 0), num))
918         {
919         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to convert string to int'\n");
920         }
921     else
922         {
923         if (num < USERDATA_NUM &&
924             num >= 0)
925             {
926             conf->userdata[num] = PQgetvalue(result, i, 1);
927             }
928         }
929     }
930
931 PQclear(result);
932
933     {
934     std::ostringstream query;
935     query << "SELECT host(ip), masklen(ip) "
936              "FROM tb_allowed_ip "
937              "WHERE fk_user = " << uid;
938
939     result = PQexec(connection, query.str().c_str());
940     }
941
942 if (PQresultStatus(result) != PGRES_TUPLES_OK)
943     {
944     strError = PQresultErrorMessage(result);
945     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): '%s'\n", strError.c_str());
946     PQclear(result);
947     if (RollbackTransaction())
948         {
949         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to rollback transaction'\n");
950         }
951     return -1;
952     }
953
954 tuples = PQntuples(result);
955
956 conf->ips.Erase();
957 for (int i = 0; i < tuples; ++i)
958     {
959     IP_MASK ipm;
960
961     int ip, mask;
962
963     ip = inet_strington(PQgetvalue(result, i, 0));
964
965     if (str2x(PQgetvalue(result, i, 1), mask))
966         {
967         printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to fetch mask'\n");
968         continue;
969         }
970
971     ipm.ip = ip;
972     ipm.mask = mask;
973
974     conf->ips.Add(ipm);
975     }
976
977 PQclear(result);
978
979 if (CommitTransaction())
980     {
981     printfd(__FILE__, "POSTGRESQL_STORE::RestoreUserConf(): 'Failed to commit transaction'\n");
982     return -1;
983     }
984
985 return 0;
986 }
987
988 //-----------------------------------------------------------------------------
989 int POSTGRESQL_STORE::WriteUserChgLog(const std::string & login,
990                                     const std::string & admLogin,
991                                     uint32_t admIP,
992                                     const std::string & paramName,
993                                     const std::string & oldValue,
994                                     const std::string & newValue,
995                                     const std::string & message = "") const
996 {
997 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
998
999 if (PQstatus(connection) != CONNECTION_OK)
1000     {
1001     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1002     if (Reset())
1003         {
1004         strError = "Connection lost";
1005         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): '%s'\n", strError.c_str());
1006         return -1;
1007         }
1008     }
1009
1010 PGresult * result;
1011
1012 if (StartTransaction())
1013     {
1014     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to start transaction'\n");
1015     return -1;
1016     }
1017
1018 std::string elogin(login);
1019 std::string eadminLogin(admLogin);
1020 std::string eparam(paramName);
1021 std::string eold(oldValue);
1022 std::string enew(newValue);
1023 std::string emessage(message);
1024
1025 if (EscapeString(elogin))
1026     {
1027     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape login'\n");
1028     if (RollbackTransaction())
1029         {
1030         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1031         }
1032     return -1;
1033     }
1034
1035 if (EscapeString(eadminLogin))
1036     {
1037     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape admin's login'\n");
1038     if (RollbackTransaction())
1039         {
1040         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1041         }
1042     return -1;
1043     }
1044
1045 if (EscapeString(eparam))
1046     {
1047     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape param's name'\n");
1048     if (RollbackTransaction())
1049         {
1050         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1051         }
1052     return -1;
1053     }
1054
1055 if (EscapeString(eold))
1056     {
1057     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape old value'\n");
1058     if (RollbackTransaction())
1059         {
1060         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1061         }
1062     return -1;
1063     }
1064
1065 if (EscapeString(enew))
1066     {
1067     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to escape new value'\n");
1068     if (RollbackTransaction())
1069         {
1070         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1071         }
1072     return -1;
1073     }
1074
1075 std::ostringstream query;
1076 query << "SELECT sp_add_param_log_entry("
1077             "'" << elogin << "', "
1078             "'" << eadminLogin << "', CAST('"
1079             << inet_ntostring(admIP) << "/32' AS INET), "
1080             "'" << eparam << "', "
1081             "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1082             "'" << eold << "', "
1083             "'" << enew << "', "
1084             "'" << emessage << "')";
1085
1086 result = PQexec(connection, query.str().c_str());
1087
1088 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1089     {
1090     strError = PQresultErrorMessage(result);
1091     PQclear(result);
1092     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): '%s'\n", strError.c_str());
1093     if (RollbackTransaction())
1094         {
1095         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to rollback transaction'\n");
1096         }
1097     return -1;
1098     }
1099
1100 PQclear(result);
1101
1102 if (CommitTransaction())
1103     {
1104     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserChgLog(): 'Failed to commit transaction'\n");
1105     return -1;
1106     }
1107
1108 return 0;
1109 }
1110
1111 //-----------------------------------------------------------------------------
1112 int POSTGRESQL_STORE::WriteUserConnect(const std::string & login, uint32_t ip) const
1113 {
1114 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1115
1116 if (PQstatus(connection) != CONNECTION_OK)
1117     {
1118     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1119     if (Reset())
1120         {
1121         strError = "Connection lost";
1122         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): '%s'\n", strError.c_str());
1123         return -1;
1124         }
1125     }
1126
1127 PGresult * result;
1128
1129 if (StartTransaction())
1130     {
1131     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to start transaction'\n");
1132     return -1;
1133     }
1134
1135 std::string elogin(login);
1136
1137 if (EscapeString(elogin))
1138     {
1139     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to escape login'\n");
1140     if (RollbackTransaction())
1141         {
1142         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to rollback transaction'\n");
1143         }
1144     return -1;
1145     }
1146
1147 std::ostringstream query;
1148 if (version < 6)
1149     {
1150     query << "SELECT sp_add_session_log_entry("
1151                  "'" << elogin << "', "
1152                  "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1153                  "'c', CAST('"
1154                  << inet_ntostring(ip) << "/32' AS INET), 0)";
1155     }
1156 else
1157     {
1158     query << "SELECT sp_add_session_log_entry("
1159                  "'" << elogin << "', "
1160                  "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1161                  "'c', CAST('"
1162                  << inet_ntostring(ip) << "/32' AS INET), 0, 0, '')";
1163     }
1164
1165 result = PQexec(connection, query.str().c_str());
1166
1167 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1168     {
1169     strError = PQresultErrorMessage(result);
1170     PQclear(result);
1171     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): '%s'\n", strError.c_str());
1172     if (RollbackTransaction())
1173         {
1174         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to rollback transaction'\n");
1175         }
1176     return -1;
1177     }
1178
1179 PQclear(result);
1180
1181 if (CommitTransaction())
1182     {
1183     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserConnect(): 'Failed to commit transaction'\n");
1184     return -1;
1185     }
1186
1187 return 0;
1188 }
1189
1190 //-----------------------------------------------------------------------------
1191 int POSTGRESQL_STORE::WriteUserDisconnect(const std::string & login,
1192                     const DIR_TRAFF & up,
1193                     const DIR_TRAFF & down,
1194                     const DIR_TRAFF & sessionUp,
1195                     const DIR_TRAFF & sessionDown,
1196                     double cash,
1197                     double freeMb,
1198                     const std::string & reason) const
1199 {
1200 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1201
1202 if (PQstatus(connection) != CONNECTION_OK)
1203     {
1204     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1205     if (Reset())
1206         {
1207         strError = "Connection lost";
1208         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1209         return -1;
1210         }
1211     }
1212
1213 PGresult * result;
1214
1215 if (StartTransaction())
1216     {
1217     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to start transaction'\n");
1218     return -1;
1219     }
1220
1221 std::string elogin(login);
1222
1223 if (EscapeString(elogin))
1224     {
1225     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to escape login'\n");
1226     if (RollbackTransaction())
1227         {
1228         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1229         }
1230     return -1;
1231     }
1232
1233 std::string ereason(reason);
1234
1235 if (EscapeString(ereason))
1236     {
1237     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to escape reason'\n");
1238     if (RollbackTransaction())
1239         {
1240         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1241         }
1242     return -1;
1243     }
1244
1245     {
1246     std::ostringstream query;
1247     if (version < 6)
1248         {
1249         // Old database version - no freeMb logging support
1250         query << "SELECT sp_add_session_log_entry("
1251                     "'" << elogin << "', "
1252                     "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1253                     "'d', CAST('0.0.0.0/0' AS INET), "
1254                     << cash << ")";
1255         }
1256     else
1257         {
1258         query << "SELECT sp_add_session_log_entry("
1259                     "'" << elogin << "', "
1260                     "CAST('" << Int2TS(stgTime) << "' AS TIMESTAMP), "
1261                     "'d', CAST('0.0.0.0/0' AS INET), "
1262                     << cash << ", " << freeMb << ", '" << ereason << "')";
1263         }
1264
1265     result = PQexec(connection, query.str().c_str());
1266     }
1267
1268 if (PQresultStatus(result) != PGRES_TUPLES_OK)
1269     {
1270     strError = PQresultErrorMessage(result);
1271     PQclear(result);
1272     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1273     if (RollbackTransaction())
1274         {
1275         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1276         }
1277     return -1;
1278     }
1279
1280 int tuples = PQntuples(result);
1281
1282 if (tuples != 1)
1283     {
1284     strError = "Failed to fetch session's log ID";
1285     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
1286     PQclear(result);
1287     if (RollbackTransaction())
1288         {
1289         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1290         }
1291     return -1;
1292     }
1293
1294 uint32_t lid;
1295
1296 if (str2x(PQgetvalue(result, 0, 0), lid))
1297     {
1298     strError = "Failed to convert string to int";
1299     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1300     PQclear(result);
1301     if (RollbackTransaction())
1302         {
1303         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1304         }
1305     return -1;
1306     }
1307
1308 PQclear(result);
1309
1310 for (int i = 0; i < DIR_NUM; ++i)
1311     {
1312     std::ostringstream query;
1313     query << "INSERT INTO tb_sessions_data "
1314                 "(fk_session_log, "
1315                  "dir_num, "
1316                  "session_upload, "
1317                  "session_download, "
1318                  "month_upload, "
1319                  "month_download)"
1320              "VALUES ("
1321                 << lid << ", "
1322                 << i << ", "
1323                 << sessionUp[i] << ", "
1324                 << sessionDown[i] << ", "
1325                 << up[i] << ", "
1326                 << down[i] << ")";
1327
1328     result = PQexec(connection, query.str().c_str());
1329
1330     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1331         {
1332         strError = PQresultErrorMessage(result);
1333         PQclear(result);
1334         printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): '%s'\n", strError.c_str());
1335         if (RollbackTransaction())
1336             {
1337             printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to rollback transaction'\n");
1338             }
1339         return -1;
1340         }
1341
1342     PQclear(result);
1343     }
1344
1345 if (CommitTransaction())
1346     {
1347     printfd(__FILE__, "POSTGRESQL_STORE::WriteUserDisconnect(): 'Failed to commit transaction'\n");
1348     return -1;
1349     }
1350
1351 return 0;
1352 }
1353
1354 //-----------------------------------------------------------------------------
1355 int POSTGRESQL_STORE::WriteDetailedStat(const std::map<IP_DIR_PAIR, STAT_NODE> & statTree,
1356                                       time_t lastStat,
1357                                       const std::string & login) const
1358 {
1359 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1360
1361 if (PQstatus(connection) != CONNECTION_OK)
1362     {
1363     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
1364     if (Reset())
1365         {
1366         strError = "Connection lost";
1367         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): '%s'\n", strError.c_str());
1368         return -1;
1369         }
1370     }
1371
1372 PGresult * result;
1373
1374 if (StartTransaction())
1375     {
1376     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to start transaction'\n");
1377     return -1;
1378     }
1379
1380 std::string elogin(login);
1381
1382 if (EscapeString(elogin))
1383     {
1384     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to escape login'\n");
1385     if (RollbackTransaction())
1386         {
1387         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to rollback transaction'\n");
1388         }
1389     return -1;
1390     }
1391
1392 std::map<IP_DIR_PAIR, STAT_NODE>::const_iterator it;
1393 time_t currTime = time(NULL);
1394
1395 for (it = statTree.begin(); it != statTree.end(); ++it)
1396     {
1397     std::ostringstream query;
1398     query << "INSERT INTO tb_detail_stats "
1399                 "(till_time, from_time, fk_user, "
1400                  "dir_num, ip, download, upload, cost) "
1401              "VALUES ("
1402                 "CAST('" << Int2TS(currTime) << "' AS TIMESTAMP), "
1403                 "CAST('" << Int2TS(lastStat) << "' AS TIMESTAMP), "
1404                 "(SELECT pk_user FROM tb_users WHERE name = '" << elogin << "'), "
1405                 << it->first.dir << ", "
1406                 << "CAST('" << inet_ntostring(it->first.ip) << "' AS INET), "
1407                 << it->second.down << ", "
1408                 << it->second.up << ", "
1409                 << it->second.cash << ")";
1410
1411     result = PQexec(connection, query.str().c_str());
1412
1413     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1414         {
1415         strError = PQresultErrorMessage(result);
1416         PQclear(result);
1417         printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): '%s'\n", strError.c_str());
1418         if (RollbackTransaction())
1419             {
1420             printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to rollback transaction'\n");
1421             }
1422         return -1;
1423         }
1424
1425     PQclear(result);
1426     }
1427
1428 if (CommitTransaction())
1429     {
1430     printfd(__FILE__, "POSTGRESQL_STORE::WriteDetailedStat(): 'Failed to commit transaction'\n");
1431     return -1;
1432     }
1433
1434 return 0;
1435 }
1436
1437 //-----------------------------------------------------------------------------
1438 int POSTGRESQL_STORE::SaveMonthStat(const USER_STAT & stat, int month, int year, const std::string & login) const
1439 {
1440 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
1441
1442 return SaveStat(stat, login, year, month);
1443 }
1444
1445 //-----------------------------------------------------------------------------
1446 int POSTGRESQL_STORE::SaveUserServices(uint32_t uid,
1447                                        const std::vector<std::string> & services) const
1448 {
1449 PGresult * result;
1450
1451     {
1452     std::ostringstream query;
1453     query << "DELETE FROM tb_users_services WHERE fk_user = " << uid;
1454
1455     result = PQexec(connection, query.str().c_str());
1456
1457     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1458         {
1459         strError = PQresultErrorMessage(result);
1460         PQclear(result);
1461         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): '%s'\n", strError.c_str());
1462         return -1;
1463         }
1464
1465     PQclear(result);
1466     }
1467
1468 std::vector<std::string>::const_iterator it;
1469
1470 for (it = services.begin(); it != services.end(); ++it)
1471     {
1472     std::string ename = *it;
1473
1474     if (EscapeString(ename))
1475         {
1476         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): 'Failed to escape service name'\n");
1477         return -1;
1478         }
1479
1480     std::ostringstream query;
1481     query << "INSERT INTO tb_users_services "
1482                 "(fk_user, fk_service) "
1483              "VALUES "
1484                 "(" << uid << ", "
1485                   "(SELECT pk_service "
1486                    "FROM tb_services "
1487                    "WHERE name = '" << ename << "'))";
1488
1489     result = PQexec(connection, query.str().c_str());
1490
1491     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1492         {
1493         strError = PQresultErrorMessage(result);
1494         PQclear(result);
1495         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserServices(): '%s'\n", strError.c_str());
1496         return -1;
1497         }
1498
1499     PQclear(result);
1500     }
1501
1502 return 0;
1503 }
1504
1505 //-----------------------------------------------------------------------------
1506 int POSTGRESQL_STORE::SaveUserIPs(uint32_t uid,
1507                                   const USER_IPS & ips) const
1508 {
1509 PGresult * result;
1510
1511     {
1512     std::ostringstream query;
1513     query << "DELETE FROM tb_allowed_ip WHERE fk_user = " << uid;
1514
1515     result = PQexec(connection, query.str().c_str());
1516     }
1517
1518 if (PQresultStatus(result) != PGRES_COMMAND_OK)
1519     {
1520     strError = PQresultErrorMessage(result);
1521     PQclear(result);
1522     printfd(__FILE__, "POSTGRESQL_STORE::SaveUserIPs(): '%s'\n", strError.c_str());
1523     return -1;
1524     }
1525
1526 PQclear(result);
1527
1528 for (size_t i = 0; i < ips.Count(); ++i)
1529     {
1530     std::ostringstream query;
1531     query << "INSERT INTO tb_allowed_ip "
1532                 "(fk_user, ip) "
1533              "VALUES "
1534                 "(" << uid << ", CAST('"
1535                     << inet_ntostring(ips[i].ip) << "/"
1536                     << static_cast<int>(ips[i].mask) << "' AS INET))";
1537
1538     result = PQexec(connection, query.str().c_str());
1539
1540     if (PQresultStatus(result) != PGRES_COMMAND_OK)
1541         {
1542         strError = PQresultErrorMessage(result);
1543         PQclear(result);
1544         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserIPs(): '%s'\n", strError.c_str());
1545         return -1;
1546         }
1547
1548     PQclear(result);
1549     }
1550
1551 return 0;
1552 }
1553
1554 //-----------------------------------------------------------------------------
1555 int POSTGRESQL_STORE::SaveUserData(uint32_t uid,
1556                                    const std::vector<std::string> & data) const
1557 {
1558 for (unsigned i = 0; i < data.size(); ++i)
1559     {
1560     std::string edata = data[i];
1561
1562     if (EscapeString(edata))
1563         {
1564         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserData(): 'Failed to escape userdata field'\n");
1565         return -1;
1566         }
1567
1568     PGresult * result;
1569
1570     std::ostringstream query;
1571     query << "SELECT sp_set_user_data("
1572                 << uid << ", "
1573                 << "CAST(" << i << " AS SMALLINT), "
1574                 << "'" << edata << "')";
1575
1576     result = PQexec(connection, query.str().c_str());
1577
1578     if (PQresultStatus(result) != PGRES_TUPLES_OK)
1579         {
1580         strError = PQresultErrorMessage(result);
1581         PQclear(result);
1582         printfd(__FILE__, "POSTGRESQL_STORE::SaveUserData(): '%s'\n", strError.c_str());
1583         return -1;
1584         }
1585
1586     PQclear(result);
1587     }
1588
1589 return 0;
1590 }
1591