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