]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/store/postgresql/postgresql_store_tariffs.cpp
Ticket 37. WriteTime() changed to WriteString() and formatTime() added
[stg.git] / projects / stargazer / plugins / store / postgresql / postgresql_store_tariffs.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  *  Tariffs manipulation methods
23  *
24  *  $Revision: 1.2 $
25  *  $Date: 2009/06/09 12:32:40 $
26  *
27  */
28
29 #include <string>
30 #include <vector>
31 #include <sstream>
32 #include <cmath>
33
34 #include <libpq-fe.h>
35
36 #include "stg/common.h"
37 #include "postgresql_store.h"
38 #include "stg/locker.h"
39
40 namespace
41 {
42
43 const int pt_mega = 1024 * 1024;
44
45 }
46
47 //-----------------------------------------------------------------------------
48 int POSTGRESQL_STORE::GetTariffsList(std::vector<std::string> * tariffsList) const
49 {
50 STG_LOCKER lock(&mutex);
51
52 if (PQstatus(connection) != CONNECTION_OK)
53     {
54     printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
55     if (Reset())
56         {
57         strError = "Connection lost";
58         printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): '%s'\n", strError.c_str());
59         return -1;
60         }
61     }
62
63 PGresult * result;
64
65 if (StartTransaction())
66     {
67     printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): 'Failed to start transaction'\n");
68     return -1;
69     }
70
71 result = PQexec(connection, "SELECT name FROM tb_tariffs");
72
73 if (PQresultStatus(result) != PGRES_TUPLES_OK)
74     {
75     strError = PQresultErrorMessage(result);
76     PQclear(result);
77     printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): '%s'\n", strError.c_str());
78     if (RollbackTransaction())
79         {
80         printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): 'Failed to rollback transaction'\n");
81         }
82     return -1;
83     }
84
85 int tuples = PQntuples(result);
86
87 for (int i = 0; i < tuples; ++i)
88     {
89     tariffsList->push_back(PQgetvalue(result, i, 0));
90     }
91
92 PQclear(result);
93
94 if (CommitTransaction())
95     {
96     printfd(__FILE__, "POSTGRESQL_STORE::GetTariffsList(): 'Failed to commit transaction'\n");
97     return -1;
98     }
99
100 return 0;
101 }
102
103 //-----------------------------------------------------------------------------
104 int POSTGRESQL_STORE::AddTariff(const std::string & name) const
105 {
106 STG_LOCKER lock(&mutex);
107
108 if (PQstatus(connection) != CONNECTION_OK)
109     {
110     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
111     if (Reset())
112         {
113         strError = "Connection lost";
114         printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): '%s'\n", strError.c_str());
115         return -1;
116         }
117     }
118
119 PGresult * result;
120
121 if (StartTransaction())
122     {
123     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to start transaction'\n");
124     return -1;
125     }
126
127 std::string ename = name;
128
129 if (EscapeString(ename))
130     {
131     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to escape name'\n");
132     if (RollbackTransaction())
133         {
134         printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to rollback transaction'\n");
135         }
136     return -1;
137     }
138
139 std::ostringstream query;
140 query << "SELECT sp_add_tariff('" << ename << "', " << DIR_NUM << ")";
141
142 result = PQexec(connection, query.str().c_str());
143
144 if (PQresultStatus(result) != PGRES_TUPLES_OK)
145     {
146     strError = PQresultErrorMessage(result);
147     PQclear(result);
148     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): '%s'\n", strError.c_str());
149     if (RollbackTransaction())
150         {
151         printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to rollback transaction'\n");
152         }
153     return -1;
154     }
155
156 PQclear(result);
157
158 if (CommitTransaction())
159     {
160     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to commit transaction'\n");
161     return -1;
162     }
163
164 return 0;
165 }
166 //-----------------------------------------------------------------------------
167 int POSTGRESQL_STORE::DelTariff(const std::string & name) const
168 {
169 STG_LOCKER lock(&mutex);
170
171 if (PQstatus(connection) != CONNECTION_OK)
172     {
173     printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
174     if (Reset())
175         {
176         strError = "Connection lost";
177         printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): '%s'\n", strError.c_str());
178         return -1;
179         }
180     }
181
182 PGresult * result;
183
184 if (StartTransaction())
185     {
186     printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): 'Failed to start transaction'\n");
187     return -1;
188     }
189
190 std::string ename = name;
191
192 if (EscapeString(ename))
193     {
194     printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to escape name'\n");
195     if (RollbackTransaction())
196         {
197         printfd(__FILE__, "POSTGRESQL_STORE::AddTariff(): 'Failed to rollback transaction'\n");
198         }
199     return -1;
200     }
201
202 std::ostringstream query;
203 query << "DELETE FROM tb_tariffs WHERE name = '" << ename << "'";
204
205 result = PQexec(connection, query.str().c_str());
206
207 if (PQresultStatus(result) != PGRES_COMMAND_OK)
208     {
209     strError = PQresultErrorMessage(result);
210     PQclear(result);
211     printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): '%s'\n", strError.c_str());
212     if (RollbackTransaction())
213         {
214         printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): 'Failed to rollback transaction'\n");
215         }
216     return -1;
217     }
218
219 PQclear(result);
220
221 if (CommitTransaction())
222     {
223     printfd(__FILE__, "POSTGRESQL_STORE::DelTariff(): 'Failed to commit transaction'\n");
224     return -1;
225     }
226
227 return 0;
228 }
229 //-----------------------------------------------------------------------------
230 int POSTGRESQL_STORE::SaveTariff(const TARIFF_DATA & td,
231                                  const std::string & tariffName) const
232 {
233 STG_LOCKER lock(&mutex);
234
235 if (PQstatus(connection) != CONNECTION_OK)
236     {
237     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
238     if (Reset())
239         {
240         strError = "Connection lost";
241         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): '%s'\n", strError.c_str());
242         return -1;
243         }
244     }
245
246 PGresult * result;
247
248 if (StartTransaction())
249     {
250     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to start transaction'\n");
251     return -1;
252     }
253
254 std::string ename = tariffName;
255
256 if (EscapeString(ename))
257     {
258     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to escape name'\n");
259     if (RollbackTransaction())
260         {
261         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to rollback transaction'\n");
262         }
263     return -1;
264     }
265
266     {
267     std::ostringstream query;
268     query << "SELECT pk_tariff FROM tb_tariffs WHERE name = '" << ename << "'";
269
270     result = PQexec(connection, query.str().c_str());
271     }
272
273 if (PQresultStatus(result) != PGRES_TUPLES_OK)
274     {
275     strError = PQresultErrorMessage(result);
276     PQclear(result);
277     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): '%s'\n", strError.c_str());
278     if (RollbackTransaction())
279         {
280         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to rollback transaction'\n");
281         }
282     return -1;
283     }
284
285 int tuples = PQntuples(result);
286
287 if (tuples != 1)
288     {
289     strError = "Failed to fetch tariff ID";
290     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
291     PQclear(result);
292     if (RollbackTransaction())
293         {
294         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to rollback transaction'\n");
295         }
296     return -1;
297     }
298
299 int32_t id;
300
301     {
302     std::stringstream tuple;
303     tuple << PQgetvalue(result, 0, 0);
304
305     PQclear(result);
306
307     tuple >> id;
308     }
309
310     {
311     std::ostringstream query;
312     query << "UPDATE tb_tariffs SET \
313                   fee = " << td.tariffConf.fee << ", \
314                   free = " << td.tariffConf.free << ", \
315                   passive_cost = " << td.tariffConf.passiveCost << ", \
316                   traff_type = " << td.tariffConf.traffType;
317
318     if (version > 6)
319         query << ", period = '" << TARIFF::PeriodToString(td.tariffConf.period) << "'";
320
321     if (version > 7)
322         query << ", change_policy = '" << TARIFF::ChangePolicyToString(td.tariffConf.changePolicy) << "', \
323                   change_policy_timeout = CAST('" << formatTime(td.tariffConf.changePolicyTimeout) << "' AS TIMESTAMP)";
324
325     query << " WHERE pk_tariff = " << id;
326
327     result = PQexec(connection, query.str().c_str());
328     }
329
330 if (PQresultStatus(result) != PGRES_COMMAND_OK)
331     {
332     strError = PQresultErrorMessage(result);
333     PQclear(result);
334     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): '%s'\n", strError.c_str());
335     if (RollbackTransaction())
336         {
337         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to rollback transaction'\n");
338         }
339     return -1;
340     }
341
342 PQclear(result);
343
344 for(int i = 0; i < DIR_NUM; i++)
345     {
346     double pda = td.dirPrice[i].priceDayA * 1024 * 1024;
347     double pdb = td.dirPrice[i].priceDayB * 1024 * 1024;
348     double pna = 0;
349     double pnb = 0;
350
351     if (td.dirPrice[i].singlePrice)
352         {
353         pna = pda;
354         pnb = pdb;
355         }
356     else
357         {
358         pna = td.dirPrice[i].priceNightA * 1024 * 1024;
359         pnb = td.dirPrice[i].priceNightB * 1024 * 1024;
360         }
361
362     int threshold = 0;
363     if (td.dirPrice[i].noDiscount)
364         {
365         threshold = 0xffFFffFF;
366         }
367     else
368         {
369         threshold = td.dirPrice[i].threshold;
370         }
371
372         {
373         std::ostringstream query;
374         query << "UPDATE tb_tariffs_params SET \
375                       price_day_a = " << pda << ", \
376                       price_day_b = " << pdb << ", \
377                       price_night_a = " << pna << ", \
378                       price_night_b = " << pnb << ", \
379                       threshold = " << threshold << ", \
380                       time_day_begins = CAST('" << td.dirPrice[i].hDay
381                                                 << ":"
382                                                 << td.dirPrice[i].mDay << "' AS TIME), \
383                       time_day_ends = CAST('" << td.dirPrice[i].hNight
384                                               << ":"
385                                               << td.dirPrice[i].mNight << "' AS TIME) \
386                  WHERE fk_tariff = " << id << " AND dir_num = " << i;
387
388         result = PQexec(connection, query.str().c_str());
389         }
390
391     if (PQresultStatus(result) != PGRES_COMMAND_OK)
392         {
393         strError = PQresultErrorMessage(result);
394         PQclear(result);
395         printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): '%s'\n", strError.c_str());
396         if (RollbackTransaction())
397             {
398             printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to rollback transaction'\n");
399             }
400         return -1;
401         }
402
403     PQclear(result);
404     }
405
406 if (CommitTransaction())
407     {
408     printfd(__FILE__, "POSTGRESQL_STORE::SaveTariff(): 'Failed to commit transaction'\n");
409     return -1;
410     }
411
412 return 0;
413 }
414 //-----------------------------------------------------------------------------
415 int POSTGRESQL_STORE::RestoreTariff(TARIFF_DATA * td,
416                                   const std::string & tariffName) const
417 {
418 STG_LOCKER lock(&mutex);
419
420 if (PQstatus(connection) != CONNECTION_OK)
421     {
422     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Connection lost. Trying to reconnect...'\n", strError.c_str());
423     if (Reset())
424         {
425         strError = "Connection lost";
426         printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): '%s'\n", strError.c_str());
427         return -1;
428         }
429     }
430
431 PGresult * result;
432
433 if (StartTransaction())
434     {
435     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to start transaction'\n");
436     return -1;
437     }
438
439 std::string ename = tariffName;
440
441 if (EscapeString(ename))
442     {
443     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to escape name'\n");
444     if (RollbackTransaction())
445         {
446         printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to rollback transaction'\n");
447         }
448     return -1;
449     }
450
451 td->tariffConf.name = tariffName;
452
453 std::ostringstream query;
454 query << "SELECT pk_tariff, \
455                  fee, \
456                  free, \
457                  passive_cost, \
458                  traff_type";
459
460 if (version > 6)
461     query << ", period";
462
463 if (version > 7)
464     query << ", change_policy \
465               , change_policy_timeout";
466
467 query << " FROM tb_tariffs WHERE name = '" << ename << "'";
468
469 result = PQexec(connection, query.str().c_str());
470
471 if (PQresultStatus(result) != PGRES_TUPLES_OK)
472     {
473     strError = PQresultErrorMessage(result);
474     PQclear(result);
475     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): '%s'\n", strError.c_str());
476     if (RollbackTransaction())
477         {
478         printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to rollback transaction'\n");
479         }
480     return -1;
481     }
482
483 int tuples = PQntuples(result);
484
485 if (tuples != 1)
486     {
487     strError = "Failed to fetch tariff data";
488     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Invalid number of tuples. Wanted 1, actulally %d'\n", tuples);
489     PQclear(result);
490     if (RollbackTransaction())
491         {
492         printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to rollback transaction'\n");
493         }
494     return -1;
495     }
496
497 int id;
498
499     {
500     std::stringstream tuple;
501     tuple << PQgetvalue(result, 0, 0) << " ";
502     tuple << PQgetvalue(result, 0, 1) << " ";
503     tuple << PQgetvalue(result, 0, 2) << " ";
504     tuple << PQgetvalue(result, 0, 3) << " ";
505     tuple << PQgetvalue(result, 0, 4) << " ";
506
507     tuple >> id;
508     tuple >> td->tariffConf.fee;
509     tuple >> td->tariffConf.free;
510     tuple >> td->tariffConf.passiveCost;
511     tuple >> td->tariffConf.traffType;
512     }
513
514 if (version > 6)
515     td->tariffConf.period = TARIFF::StringToPeriod(PQgetvalue(result, 0, 5));
516
517 if (version > 7)
518     {
519     td->tariffConf.changePolicy = TARIFF::StringToChangePolicy(PQgetvalue(result, 0, 6));
520     td->tariffConf.changePolicyTimeout = readTime(PQgetvalue(result, 0, 7));
521     }
522
523 PQclear(result);
524
525 query.str("");
526 query << "SELECT dir_num, \
527                  price_day_a, \
528                  price_day_b, \
529                  price_night_a, \
530                  price_night_b, \
531                  threshold, \
532                  EXTRACT(hour FROM time_day_begins), \
533                  EXTRACT(minute FROM time_day_begins), \
534                  EXTRACT(hour FROM time_day_ends), \
535                  EXTRACT(minute FROM time_day_ends) \
536           FROM tb_tariffs_params \
537           WHERE fk_tariff = " << id;
538
539 result = PQexec(connection, query.str().c_str());
540
541 if (PQresultStatus(result) != PGRES_TUPLES_OK)
542     {
543     strError = PQresultErrorMessage(result);
544     PQclear(result);
545     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): '%s'\n", strError.c_str());
546     if (RollbackTransaction())
547         {
548         printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to rollback transaction'\n");
549         }
550     return -1;
551     }
552
553 tuples = PQntuples(result);
554
555 if (tuples != DIR_NUM)
556     {
557     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Tariff params count and DIR_NUM does not feet (wanted %d, actually %d)'\n", DIR_NUM, tuples);
558     }
559
560 for (int i = 0; i < std::min(tuples, DIR_NUM); ++i)
561     {
562     int dir;
563
564         {
565         std::stringstream tuple;
566         tuple << PQgetvalue(result, i, 0) << " ";
567         tuple << PQgetvalue(result, i, 1) << " ";
568         tuple << PQgetvalue(result, i, 2) << " ";
569         tuple << PQgetvalue(result, i, 3) << " ";
570         tuple << PQgetvalue(result, i, 4) << " ";
571         tuple << PQgetvalue(result, i, 5) << " ";
572         tuple << PQgetvalue(result, i, 6) << " ";
573         tuple << PQgetvalue(result, i, 7) << " ";
574         tuple << PQgetvalue(result, i, 8) << " ";
575         tuple << PQgetvalue(result, i, 9) << " ";
576
577         tuple >> dir;
578         tuple >> td->dirPrice[dir].priceDayA;
579         td->dirPrice[dir].priceDayA /= 1024 * 1024;
580         tuple >> td->dirPrice[dir].priceDayB;
581         td->dirPrice[dir].priceDayB /= 1024 * 1024;
582         tuple >> td->dirPrice[dir].priceNightA;
583         td->dirPrice[dir].priceNightA /= 1024 * 1024;
584         tuple >> td->dirPrice[dir].priceNightB;
585         td->dirPrice[dir].priceNightB /= 1024 * 1024;
586         tuple >> td->dirPrice[dir].threshold;
587         tuple >> td->dirPrice[dir].hDay;
588         tuple >> td->dirPrice[dir].mDay;
589         tuple >> td->dirPrice[dir].hNight;
590         tuple >> td->dirPrice[dir].mNight;
591         }
592
593     if (std::fabs(td->dirPrice[dir].priceDayA - td->dirPrice[dir].priceNightA) < 1.0e-3 / pt_mega &&
594         std::fabs(td->dirPrice[dir].priceDayB - td->dirPrice[dir].priceNightB) < 1.0e-3 / pt_mega)
595         {
596         td->dirPrice[dir].singlePrice = true;
597         }
598     else
599         {
600         td->dirPrice[dir].singlePrice = false;
601         }
602     if (td->dirPrice[dir].threshold == (int)0xffFFffFF)
603         {
604         td->dirPrice[dir].noDiscount = true;
605         }
606     else
607         {
608
609         td->dirPrice[dir].noDiscount = false;
610         }
611
612     }
613
614 PQclear(result);
615
616 if (CommitTransaction())
617     {
618     printfd(__FILE__, "POSTGRESQL_STORE::RestoreTariff(): 'Failed to commit transaction'\n");
619     return -1;
620     }
621
622 return 0;
623 }
624 //-----------------------------------------------------------------------------
625