]> git.stg.codes - stg.git/blob - projects/stargazer/user_property.h
Исправлена тупая и уже успевшая запарить ошибка (опечатка) выражающаяся в создании...
[stg.git] / projects / stargazer / user_property.h
1 /*
2 $Revision: 1.44 $
3 $Date: 2010/09/13 05:54:43 $
4 $Author: faust $
5 */
6
7
8 #ifndef USER_PROPERTY_H
9 #define USER_PROPERTY_H
10
11 #include <ctime>
12 #include <string>
13 #include <set>
14 #include <sstream>
15 #include <iostream>
16 #include <algorithm>
17
18 #include "base_store.h"
19 #include "stg_logger.h"
20 #include "admin.h"
21 #include "settings.h"
22 #include "notifer.h"
23 #include "stg_logger.h"
24 #include "stg_locker.h"
25 #include "script_executer.h"
26
27 using namespace std;
28
29 extern const volatile time_t stgTime;
30
31 //-----------------------------------------------------------------------------
32 template<typename varT>
33 class USER_PROPERTY
34     {
35 public:
36     USER_PROPERTY(varT& val);
37     USER_PROPERTY<varT>& operator= (const varT&);
38     USER_PROPERTY<varT>& operator-= (const varT&);
39     virtual ~USER_PROPERTY();
40
41     const varT * operator&() const throw();
42     const varT& ConstData() const throw();
43
44     operator const varT&() const throw()
45     {
46         return value;
47     }
48
49     //bool    IsEmpty() const throw();
50
51     void    AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
52     void    DelBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
53
54     void    AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
55     void    DelAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
56
57     time_t  ModificationTime() const throw();
58     void    ModifyTime() throw();
59
60 protected:
61     varT  & value;
62     time_t  modificationTime;
63     //typedef set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator notifier_iter_t;
64     mutable set<PROPERTY_NOTIFIER_BASE<varT> *> beforeNotifiers;
65     mutable set<PROPERTY_NOTIFIER_BASE<varT> *> afterNotifiers;
66     mutable pthread_mutex_t mutex;
67     };
68 //-----------------------------------------------------------------------------
69 template<typename varT>
70 class USER_PROPERTY_LOGGED: public USER_PROPERTY<varT>
71     {
72 public:
73     USER_PROPERTY_LOGGED(varT& val,
74                          const string n,
75                          bool isPassword,
76                          bool isStat,
77                          STG_LOGGER & logger,
78                          const SETTINGS * s);
79     virtual ~USER_PROPERTY_LOGGED();
80
81     //operator const varT&() const throw();;
82     USER_PROPERTY_LOGGED<varT> * GetPointer() throw();
83     const varT & Get() const;
84     const string & GetName() const;
85     bool Set(const varT & val,
86              const ADMIN & admin,
87              const string & login,
88              const BASE_STORE * store,
89              const string & msg = "");
90 protected:
91     void WriteAccessDenied(const string & login,
92                            const ADMIN  & admin,
93                            const string & parameter);
94
95     void WriteSuccessChange(const string     & login,
96                             const ADMIN      & admin,
97                             const string     & parameter,
98                             const string     & oldValue,
99                             const string     & newValue,
100                             const string     & msg,
101                             const BASE_STORE * store);
102
103     void OnChange(const string & login,
104                   const string & paramName,
105                   const string & oldValue,
106                   const string & newValue,
107                   const ADMIN  & admin);
108
109     string          name;       // parameter name. needed for logging
110     bool            isPassword; // is parameter password. when true, it will be logged as *******
111     bool            isStat;     // is parameter a stat data or conf data?
112     mutable pthread_mutex_t mutex;
113     STG_LOGGER &    stgLogger;  // server's logger
114     const SETTINGS * settings;
115     };
116 //-----------------------------------------------------------------------------
117 class USER_PROPERTIES
118     {
119     friend class USER;
120 /*
121  В этом месте важен порядок следования приватной и открытой частей.
122  Это связано с тем, что часть которая находится в публичной секции
123  по сути является завуалированной ссылкой на закрытую часть. Т.о. нам нужно
124  чтобы конструкторы из закрытой части вызвались раньше открытой. Поэтомому в
125  начале идет закрытая секция
126  * */
127
128 private:
129     USER_STAT stat;
130     USER_CONF conf;
131
132 public:
133     USER_PROPERTIES(const SETTINGS * settings);
134
135     const USER_STAT & GetStat() const { return stat; }
136     const USER_CONF & GetConf() const { return conf; }
137     void SetStat(const USER_STAT & s) { stat = s; }
138     void SetConf(const USER_CONF & c) { conf = c; }
139
140     void SetProperties(const USER_PROPERTIES & p) { stat = p.stat; conf = p.conf; }
141
142     USER_PROPERTY_LOGGED<double>            cash;
143     USER_PROPERTY_LOGGED<DIR_TRAFF>         up;
144     USER_PROPERTY_LOGGED<DIR_TRAFF>         down;
145     USER_PROPERTY_LOGGED<double>            lastCashAdd;
146     USER_PROPERTY_LOGGED<time_t>            passiveTime;
147     USER_PROPERTY_LOGGED<time_t>            lastCashAddTime;
148     USER_PROPERTY_LOGGED<double>            freeMb;
149     USER_PROPERTY_LOGGED<time_t>            lastActivityTime;
150
151     USER_PROPERTY_LOGGED<string>            password;
152     USER_PROPERTY_LOGGED<int>               passive;
153     USER_PROPERTY_LOGGED<int>               disabled;
154     USER_PROPERTY_LOGGED<int>               disabledDetailStat;
155     USER_PROPERTY_LOGGED<int>               alwaysOnline;
156     USER_PROPERTY_LOGGED<string>            tariffName;
157     USER_PROPERTY_LOGGED<string>            nextTariff;
158     USER_PROPERTY_LOGGED<string>            address;
159     USER_PROPERTY_LOGGED<string>            note;
160     USER_PROPERTY_LOGGED<string>            group;
161     USER_PROPERTY_LOGGED<string>            email;
162     USER_PROPERTY_LOGGED<string>            phone;
163     USER_PROPERTY_LOGGED<string>            realName;
164     USER_PROPERTY_LOGGED<double>            credit;
165     USER_PROPERTY_LOGGED<time_t>            creditExpire;
166     USER_PROPERTY_LOGGED<USER_IPS>          ips;
167     USER_PROPERTY_LOGGED<string>            userdata0;
168     USER_PROPERTY_LOGGED<string>            userdata1;
169     USER_PROPERTY_LOGGED<string>            userdata2;
170     USER_PROPERTY_LOGGED<string>            userdata3;
171     USER_PROPERTY_LOGGED<string>            userdata4;
172     USER_PROPERTY_LOGGED<string>            userdata5;
173     USER_PROPERTY_LOGGED<string>            userdata6;
174     USER_PROPERTY_LOGGED<string>            userdata7;
175     USER_PROPERTY_LOGGED<string>            userdata8;
176     USER_PROPERTY_LOGGED<string>            userdata9;
177     };
178
179 //=============================================================================
180
181 //-----------------------------------------------------------------------------
182 //-----------------------------------------------------------------------------
183 //-----------------------------------------------------------------------------
184 template <typename varT>
185 USER_PROPERTY<varT>::USER_PROPERTY(varT& val)
186 :
187 value(val)
188 {
189 pthread_mutex_init(&mutex, NULL);
190 modificationTime = stgTime;
191 }
192 //-----------------------------------------------------------------------------
193 template <typename varT>
194 USER_PROPERTY<varT>::~USER_PROPERTY()
195 {
196 }
197 //-----------------------------------------------------------------------------
198 template <typename varT>
199 void USER_PROPERTY<varT>::ModifyTime() throw()
200 {
201     modificationTime = stgTime;
202 }
203 //-----------------------------------------------------------------------------
204 template <typename varT>
205 USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator= (const varT& newValue)
206 {
207 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
208
209 /*
210 TODO
211 if (value == newValue)
212     return *this;*/
213
214 typename set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
215
216 //printf("USER_PROPERTY<varT>::operator= (const varT& rhs)\n");
217
218 varT oldVal = value;
219
220 ni = beforeNotifiers.begin();
221 while (ni != beforeNotifiers.end())
222     (*ni++)->Notify(oldVal, newValue);
223
224 value = newValue;
225 modificationTime = stgTime;
226
227 ni = afterNotifiers.begin();
228 while (ni != afterNotifiers.end())
229     (*ni++)->Notify(oldVal, newValue);
230
231 return *this;
232 }
233 //-----------------------------------------------------------------------------
234 template <typename varT>
235 USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator-= (const varT& delta)
236 {
237 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
238
239 typename set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
240
241 varT oldVal = value;
242
243 ni = beforeNotifiers.begin();
244 while (ni != beforeNotifiers.end())
245     (*ni++)->Notify(oldVal, oldVal - delta);
246
247 value -= delta;
248 modificationTime = stgTime;
249
250 ni = afterNotifiers.begin();
251 while (ni != afterNotifiers.end())
252     (*ni++)->Notify(oldVal, value);
253
254 return *this;
255 }
256 //-----------------------------------------------------------------------------
257 template <typename varT>
258 const varT * USER_PROPERTY<varT>::operator&() const throw()
259 {
260 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
261 return &value;
262 }
263 //-----------------------------------------------------------------------------
264 template <typename varT>
265 const varT& USER_PROPERTY<varT>::ConstData() const throw()
266 {
267 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
268 return value;
269 }
270 //-----------------------------------------------------------------------------
271 /*template <typename varT>
272 bool USER_PROPERTY<varT>::IsEmpty() const throw()
273 {
274 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
275 return !is_set;
276 }*/
277 //-----------------------------------------------------------------------------
278 template <typename varT>
279 void USER_PROPERTY<varT>::AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
280 {
281 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
282 beforeNotifiers.insert(n);
283 }
284 //-----------------------------------------------------------------------------
285 template <typename varT>
286 void USER_PROPERTY<varT>::DelBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
287 {
288 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
289 beforeNotifiers.erase(n);
290 }
291 //-----------------------------------------------------------------------------
292 template <typename varT>
293 void USER_PROPERTY<varT>::AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
294 {
295 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
296 afterNotifiers.insert(n);
297 }
298 //-----------------------------------------------------------------------------
299 template <typename varT>
300 void USER_PROPERTY<varT>::DelAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
301 {
302 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
303 afterNotifiers.erase(n);
304 }
305 //-----------------------------------------------------------------------------
306 template <typename varT>
307 time_t USER_PROPERTY<varT>::ModificationTime() const throw()
308 {
309 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
310 return modificationTime;
311 }
312 //-----------------------------------------------------------------------------
313 //-----------------------------------------------------------------------------
314 //-----------------------------------------------------------------------------
315 template <typename varT>
316 USER_PROPERTY_LOGGED<varT>::USER_PROPERTY_LOGGED(
317                                                 varT& val,
318                                                 string n,
319                                                 bool isPass,
320                                                 bool isSt,
321                                                 STG_LOGGER & logger,
322                                                 const SETTINGS * s)
323
324 :USER_PROPERTY<varT>(val),
325 stgLogger(logger)
326 {
327 pthread_mutex_init(&mutex, NULL);
328 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
329 USER_PROPERTY<varT>::value = val;
330 isPassword = isPass;
331 isStat = isSt;
332 name = n;
333 settings = s;
334 }
335 //-----------------------------------------------------------------------------
336 template <typename varT>
337 USER_PROPERTY_LOGGED<varT>::~USER_PROPERTY_LOGGED()
338 {
339 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
340 }
341 //-----------------------------------------------------------------------------
342 template <typename varT>
343 USER_PROPERTY_LOGGED<varT> * USER_PROPERTY_LOGGED<varT>::GetPointer() throw()
344 {
345 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
346 return this;
347 }
348 //-----------------------------------------------------------------------------
349 template <typename varT>
350 const varT & USER_PROPERTY_LOGGED<varT>::Get() const
351 {
352 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
353 return USER_PROPERTY<varT>::value;
354 };
355 //-------------------------------------------------------------------------
356 template <typename varT>
357 const string & USER_PROPERTY_LOGGED<varT>::GetName() const
358 {
359 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
360 return name;
361 };
362 //-------------------------------------------------------------------------
363 template <typename varT>
364 bool USER_PROPERTY_LOGGED<varT>::Set(const varT & val,
365                                      const ADMIN & admin,
366                                      const string & login,
367                                      const BASE_STORE * store,
368                                      const string & msg)
369 {
370 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
371
372 //cout << "USER_PROPERTY_LOGGED " << val << endl;
373 //value = val;
374 //modificationTime = stgTime;
375
376 const PRIV * priv = admin.GetPriv();
377 string adm_login = admin.GetLogin();
378 string adm_ip = admin.GetAdminIPStr();
379
380 if ((priv->userConf && !isStat) || (priv->userStat && isStat) || (priv->userPasswd && isPassword) || (priv->userCash && name == "cash"))
381     {
382     stringstream oldVal;
383     stringstream newVal;
384
385     oldVal.flags(oldVal.flags() | ios::fixed);
386     newVal.flags(newVal.flags() | ios::fixed);
387
388     oldVal << USER_PROPERTY<varT>::value;
389     newVal << val;
390
391     OnChange(login, name, oldVal.str(), newVal.str(), admin);
392
393     if (isPassword)
394         {
395         WriteSuccessChange(login, admin, name, "******", "******", msg, store);
396         }
397     else
398         {
399         WriteSuccessChange(login, admin, name, oldVal.str(), newVal.str(), msg, store);
400         }
401     USER_PROPERTY<varT>::operator =(val);
402     return true;
403     }
404 else
405     {
406     WriteAccessDenied(login, admin, name);
407     return false;
408     }
409 return true;
410 }
411 //-------------------------------------------------------------------------
412 template <typename varT>
413 void USER_PROPERTY_LOGGED<varT>::WriteAccessDenied(const string & login,
414                                                    const ADMIN  & admin,
415                                                    const string & parameter)
416 {
417 stgLogger("%s Change user \'%s.\' Parameter \'%s\'. Access denied.",
418           admin.GetLogStr().c_str(), login.c_str(), parameter.c_str());
419 }
420 //-------------------------------------------------------------------------
421 template <typename varT>
422 void USER_PROPERTY_LOGGED<varT>::WriteSuccessChange(const string & login,
423                                                     const ADMIN      & admin,
424                                                     const string     & parameter,
425                                                     const string     & oldValue,
426                                                     const string     & newValue,
427                                                     const string     & msg,
428                                                     const BASE_STORE * store)
429 {
430 stgLogger("%s User \'%s\': \'%s\' parameter changed from \'%s\' to \'%s\'. %s",
431           admin.GetLogStr().c_str(),
432           login.c_str(),
433           parameter.c_str(),
434           oldValue.c_str(),
435           newValue.c_str(),
436           msg.c_str());
437
438
439 /*char userLogMsg[2048];
440 sprintf(userLogMsg, "\'%s\' parameter changed from \'%s\' to \'%s\'. %s",
441          parameter.c_str(), oldValue.c_str(),
442          newValue.c_str(),  msg.c_str());*/
443 store->WriteUserChgLog(login, admin.GetLogin(), admin.GetAdminIP(), parameter, oldValue, newValue, msg);
444 //store->WriteLogString(userLogMsg, login);
445 }
446 //-------------------------------------------------------------------------
447 template <typename varT>
448 void USER_PROPERTY_LOGGED<varT>::OnChange(const string & login,
449                                           const string & paramName,
450                                           const string & oldValue,
451                                           const string & newValue,
452                                           const ADMIN  &)
453 {
454 string str1;
455
456 str1 = settings->GetConfDir() + "/OnChange";
457
458 if (access(str1.c_str(), X_OK) == 0)
459     {
460     string str2("\"" + str1 + "\" \"" + login + "\" \"" + paramName + "\" \"" + oldValue + "\" \"" + newValue + "\"");
461     ScriptExec(str2);
462     }
463 else
464     {
465     stgLogger("Script OnChange cannot be executed. File %s not found.", str1.c_str());
466     }
467 }
468 //-------------------------------------------------------------------------
469 //-------------------------------------------------------------------------
470 //-------------------------------------------------------------------------
471 template<typename varT>
472 stringstream & operator<< (stringstream & s, const USER_PROPERTY<varT> & v)
473 {
474 s << v.ConstData();
475 return s;
476 }
477 //-----------------------------------------------------------------------------
478 template<typename varT>
479 ostream & operator<< (ostream & o, const USER_PROPERTY<varT> & v)
480 {
481 return o << v.ConstData();
482 }
483 //-----------------------------------------------------------------------------
484
485
486 #endif // USER_PROPERTY_H
487