]> git.stg.codes - stg.git/blobdiff - projects/stargazer/user_property.h
Header duplicate removed from user_property.h
[stg.git] / projects / stargazer / user_property.h
index 3ea1be45509eeff7f96e74394ab57dc8112d2d93..feadf54c61321ec6bd45cd50dcaca4f941d7ec02 100644 (file)
@@ -4,7 +4,6 @@ $Date: 2010/09/13 05:54:43 $
 $Author: faust $
 */
 
-
 #ifndef USER_PROPERTY_H
 #define USER_PROPERTY_H
 
@@ -13,31 +12,28 @@ $Author: faust $
 #include <set>
 #include <sstream>
 #include <iostream>
-#include <algorithm>
 
-#include "base_store.h"
-#include "stg_logger.h"
+#include "store.h"
 #include "admin.h"
-#include "settings.h"
 #include "notifer.h"
 #include "stg_logger.h"
 #include "stg_locker.h"
 #include "script_executer.h"
 
-using namespace std;
-
 extern const volatile time_t stgTime;
 
 //-----------------------------------------------------------------------------
 template<typename varT>
-class USER_PROPERTY
-    {
+class USER_PROPERTY {
 public:
     USER_PROPERTY(varT& val);
-    USER_PROPERTY<varT>& operator= (const varT&);
-    USER_PROPERTY<varT>& operator-= (const varT&);
     virtual ~USER_PROPERTY();
 
+    void Set(const varT & rvalue);
+
+    USER_PROPERTY<varT>& operator= (const varT & rvalue);
+    USER_PROPERTY<varT>& operator-= (const varT & rvalue);
+
     const varT * operator&() const throw();
     const varT& ConstData() const throw();
 
@@ -46,8 +42,6 @@ public:
         return value;
     }
 
-    //bool    IsEmpty() const throw();
-
     void    AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
     void    DelBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
 
@@ -57,66 +51,60 @@ public:
     time_t  ModificationTime() const throw();
     void    ModifyTime() throw();
 
-protected:
+private:
     varT  & value;
     time_t  modificationTime;
-    //typedef set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator notifier_iter_t;
-    mutable set<PROPERTY_NOTIFIER_BASE<varT> *> beforeNotifiers;
-    mutable set<PROPERTY_NOTIFIER_BASE<varT> *> afterNotifiers;
+    std::set<PROPERTY_NOTIFIER_BASE<varT> *> beforeNotifiers;
+    std::set<PROPERTY_NOTIFIER_BASE<varT> *> afterNotifiers;
     mutable pthread_mutex_t mutex;
-    };
+};
 //-----------------------------------------------------------------------------
 template<typename varT>
-class USER_PROPERTY_LOGGED: public USER_PROPERTY<varT>
-    {
+class USER_PROPERTY_LOGGED: public USER_PROPERTY<varT> {
 public:
-    USER_PROPERTY_LOGGED(varT& val,
-                         const string n,
+    USER_PROPERTY_LOGGED(varT & val,
+                         const std::string n,
                          bool isPassword,
                          bool isStat,
                          STG_LOGGER & logger,
-                         const SETTINGS * s);
+                         const std::string & sd);
     virtual ~USER_PROPERTY_LOGGED();
 
-    //operator const varT&() const throw();;
     USER_PROPERTY_LOGGED<varT> * GetPointer() throw();
     const varT & Get() const;
-    const string & GetName() const;
+    const std::string & GetName() const;
     bool Set(const varT & val,
-             const ADMIN & admin,
-             const string & login,
-             const BASE_STORE * store,
-             const string & msg = "");
-protected:
-    void WriteAccessDenied(const string & login,
-                           const ADMIN  & admin,
-                           const string & parameter);
-
-    void WriteSuccessChange(const string     & login,
-                            const ADMIN      & admin,
-                            const string     & parameter,
-                            const string     & oldValue,
-                            const string     & newValue,
-                            const string     & msg,
-                            const BASE_STORE * store);
-
-    void OnChange(const string & login,
-                  const string & paramName,
-                  const string & oldValue,
-                  const string & newValue,
-                  const ADMIN  & admin);
-
-    string          name;       // parameter name. needed for logging
-    bool            isPassword; // is parameter password. when true, it will be logged as *******
-    bool            isStat;     // is parameter a stat data or conf data?
-    mutable pthread_mutex_t mutex;
-    STG_LOGGER &    stgLogger;  // server's logger
-    const SETTINGS * settings;
-    };
+             const ADMIN * admin,
+             const std::string & login,
+             const STORE * store,
+             const std::string & msg = "");
+private:
+    void WriteAccessDenied(const std::string & login,
+                           const ADMIN * admin,
+                           const std::string & parameter);
+
+    void WriteSuccessChange(const std::string & login,
+                            const ADMIN * admin,
+                            const std::string & parameter,
+                            const std::string & oldValue,
+                            const std::string & newValue,
+                            const std::string & msg,
+                            const STORE * store);
+
+    void OnChange(const std::string & login,
+                  const std::string & paramName,
+                  const std::string & oldValue,
+                  const std::string & newValue,
+                  const ADMIN  * admin);
+
+    STG_LOGGER &      stgLogger;
+    bool              isPassword;
+    bool              isStat;
+    std::string       name;
+    const std::string scriptsDir;
+};
 //-----------------------------------------------------------------------------
-class USER_PROPERTIES
-    {
-    friend class USER;
+class USER_PROPERTIES {
 /*
  В этом месте важен порядок следования приватной и открытой частей.
  Это связано с тем, что часть которая находится в публичной секции
@@ -130,8 +118,10 @@ private:
     USER_CONF conf;
 
 public:
-    USER_PROPERTIES(const SETTINGS * settings);
+    USER_PROPERTIES(const std::string & sd);
 
+    USER_STAT & Stat() { return stat; }
+    USER_CONF & Conf() { return conf; }
     const USER_STAT & GetStat() const { return stat; }
     const USER_CONF & GetConf() const { return conf; }
     void SetStat(const USER_STAT & s) { stat = s; }
@@ -148,34 +138,33 @@ public:
     USER_PROPERTY_LOGGED<double>            freeMb;
     USER_PROPERTY_LOGGED<time_t>            lastActivityTime;
 
-    USER_PROPERTY_LOGGED<string>            password;
+    USER_PROPERTY_LOGGED<std::string>       password;
     USER_PROPERTY_LOGGED<int>               passive;
     USER_PROPERTY_LOGGED<int>               disabled;
     USER_PROPERTY_LOGGED<int>               disabledDetailStat;
     USER_PROPERTY_LOGGED<int>               alwaysOnline;
-    USER_PROPERTY_LOGGED<string>            tariffName;
-    USER_PROPERTY_LOGGED<string>            nextTariff;
-    USER_PROPERTY_LOGGED<string>            address;
-    USER_PROPERTY_LOGGED<string>            note;
-    USER_PROPERTY_LOGGED<string>            group;
-    USER_PROPERTY_LOGGED<string>            email;
-    USER_PROPERTY_LOGGED<string>            phone;
-    USER_PROPERTY_LOGGED<string>            realName;
+    USER_PROPERTY_LOGGED<std::string>       tariffName;
+    USER_PROPERTY_LOGGED<std::string>       nextTariff;
+    USER_PROPERTY_LOGGED<std::string>       address;
+    USER_PROPERTY_LOGGED<std::string>       note;
+    USER_PROPERTY_LOGGED<std::string>       group;
+    USER_PROPERTY_LOGGED<std::string>       email;
+    USER_PROPERTY_LOGGED<std::string>       phone;
+    USER_PROPERTY_LOGGED<std::string>       realName;
     USER_PROPERTY_LOGGED<double>            credit;
     USER_PROPERTY_LOGGED<time_t>            creditExpire;
     USER_PROPERTY_LOGGED<USER_IPS>          ips;
-    USER_PROPERTY_LOGGED<string>            userdata0;
-    USER_PROPERTY_LOGGED<string>            userdata1;
-    USER_PROPERTY_LOGGED<string>            userdata2;
-    USER_PROPERTY_LOGGED<string>            userdata3;
-    USER_PROPERTY_LOGGED<string>            userdata4;
-    USER_PROPERTY_LOGGED<string>            userdata5;
-    USER_PROPERTY_LOGGED<string>            userdata6;
-    USER_PROPERTY_LOGGED<string>            userdata7;
-    USER_PROPERTY_LOGGED<string>            userdata8;
-    USER_PROPERTY_LOGGED<string>            userdata9;
-    };
-
+    USER_PROPERTY_LOGGED<std::string>       userdata0;
+    USER_PROPERTY_LOGGED<std::string>       userdata1;
+    USER_PROPERTY_LOGGED<std::string>       userdata2;
+    USER_PROPERTY_LOGGED<std::string>       userdata3;
+    USER_PROPERTY_LOGGED<std::string>       userdata4;
+    USER_PROPERTY_LOGGED<std::string>       userdata5;
+    USER_PROPERTY_LOGGED<std::string>       userdata6;
+    USER_PROPERTY_LOGGED<std::string>       userdata7;
+    USER_PROPERTY_LOGGED<std::string>       userdata8;
+    USER_PROPERTY_LOGGED<std::string>       userdata9;
+};
 //=============================================================================
 
 //-----------------------------------------------------------------------------
@@ -183,8 +172,7 @@ public:
 //-----------------------------------------------------------------------------
 template <typename varT>
 USER_PROPERTY<varT>::USER_PROPERTY(varT& val)
-:
-value(val)
+    : value(val)
 {
 pthread_mutex_init(&mutex, NULL);
 modificationTime = stgTime;
@@ -198,81 +186,57 @@ USER_PROPERTY<varT>::~USER_PROPERTY()
 template <typename varT>
 void USER_PROPERTY<varT>::ModifyTime() throw()
 {
-    modificationTime = stgTime;
+modificationTime = stgTime;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
-USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator= (const varT& newValue)
+void USER_PROPERTY<varT>::Set(const varT & rvalue)
 {
 STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 
-/*
-TODO
-if (value == newValue)
-    return *this;*/
-
-typename set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
+typename std::set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
 
 varT oldVal = value;
 
 ni = beforeNotifiers.begin();
 while (ni != beforeNotifiers.end())
-    (*ni++)->Notify(oldVal, newValue);
+    (*ni++)->Notify(oldVal, rvalue);
 
-value = newValue;
+value = rvalue;
 modificationTime = stgTime;
 
 ni = afterNotifiers.begin();
 while (ni != afterNotifiers.end())
-    (*ni++)->Notify(oldVal, newValue);
-
+    (*ni++)->Notify(oldVal, rvalue);
+}
+//-----------------------------------------------------------------------------
+template <typename varT>
+USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator= (const varT & newValue)
+{
+Set(newValue);
 return *this;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
-USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator-= (const varT& delta)
+USER_PROPERTY<varT>& USER_PROPERTY<varT>::operator-= (const varT & delta)
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-
-typename set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
-
-varT oldVal = value;
-
-ni = beforeNotifiers.begin();
-while (ni != beforeNotifiers.end())
-    (*ni++)->Notify(oldVal, oldVal - delta);
-
-value -= delta;
-modificationTime = stgTime;
-
-ni = afterNotifiers.begin();
-while (ni != afterNotifiers.end())
-    (*ni++)->Notify(oldVal, value);
-
+varT newValue = ConstData() - delta;
+Set(newValue);
 return *this;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 const varT * USER_PROPERTY<varT>::operator&() const throw()
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 return &value;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 const varT& USER_PROPERTY<varT>::ConstData() const throw()
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 return value;
 }
 //-----------------------------------------------------------------------------
-/*template <typename varT>
-bool USER_PROPERTY<varT>::IsEmpty() const throw()
-{
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-return !is_set;
-}*/
-//-----------------------------------------------------------------------------
 template <typename varT>
 void USER_PROPERTY<varT>::AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
 {
@@ -304,76 +268,61 @@ afterNotifiers.erase(n);
 template <typename varT>
 time_t USER_PROPERTY<varT>::ModificationTime() const throw()
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 return modificationTime;
 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 template <typename varT>
-USER_PROPERTY_LOGGED<varT>::USER_PROPERTY_LOGGED(
-                                                varT& val,
-                                                string n,
-                                                bool isPass,
-                                                bool isSt,
-                                                STG_LOGGER & logger,
-                                                const SETTINGS * s)
-
-:USER_PROPERTY<varT>(val),
-stgLogger(logger)
+USER_PROPERTY_LOGGED<varT>::USER_PROPERTY_LOGGED(varT& val,
+                                                 std::string n,
+                                                 bool isPass,
+                                                 bool isSt,
+                                                 STG_LOGGER & logger,
+                                                 const std::string & sd)
+
+    : USER_PROPERTY<varT>(val),
+      stgLogger(logger),
+      isPassword(isPass),
+      isStat(isSt),
+      name(n),
+      scriptsDir(sd)
 {
-pthread_mutex_init(&mutex, NULL);
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-USER_PROPERTY<varT>::value = val;
-isPassword = isPass;
-isStat = isSt;
-name = n;
-settings = s;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 USER_PROPERTY_LOGGED<varT>::~USER_PROPERTY_LOGGED()
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 USER_PROPERTY_LOGGED<varT> * USER_PROPERTY_LOGGED<varT>::GetPointer() throw()
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 return this;
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 const varT & USER_PROPERTY_LOGGED<varT>::Get() const
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-return USER_PROPERTY<varT>::value;
+return USER_PROPERTY<varT>::ConstData();
 };
 //-------------------------------------------------------------------------
 template <typename varT>
-const string & USER_PROPERTY_LOGGED<varT>::GetName() const
+const std::string & USER_PROPERTY_LOGGED<varT>::GetName() const
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
 return name;
 };
 //-------------------------------------------------------------------------
 template <typename varT>
 bool USER_PROPERTY_LOGGED<varT>::Set(const varT & val,
-                                     const ADMIN & admin,
-                                     const string & login,
-                                     const BASE_STORE * store,
-                                     const string & msg)
+                                     const ADMIN * admin,
+                                     const std::string & login,
+                                     const STORE * store,
+                                     const std::string & msg)
 {
-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-
-//cout << "USER_PROPERTY_LOGGED " << val << endl;
-//value = val;
-//modificationTime = stgTime;
-
-const PRIV * priv = admin.GetPriv();
-string adm_login = admin.GetLogin();
-string adm_ip = admin.GetAdminIPStr();
+const PRIV * priv = admin->GetPriv();
+std::string adm_login = admin->GetLogin();
+std::string adm_ip = admin->GetIPStr();
 
 if ((priv->userConf && !isStat) || (priv->userStat && isStat) || (priv->userPasswd && isPassword) || (priv->userCash && name == "cash"))
     {
@@ -383,7 +332,7 @@ if ((priv->userConf && !isStat) || (priv->userStat && isStat) || (priv->userPass
     oldVal.flags(oldVal.flags() | ios::fixed);
     newVal.flags(newVal.flags() | ios::fixed);
 
-    oldVal << USER_PROPERTY<varT>::value;
+    oldVal << USER_PROPERTY<varT>::ConstData();
     newVal << val;
 
     OnChange(login, name, oldVal.str(), newVal.str(), admin);
@@ -396,7 +345,7 @@ if ((priv->userConf && !isStat) || (priv->userStat && isStat) || (priv->userPass
         {
         WriteSuccessChange(login, admin, name, oldVal.str(), newVal.str(), msg, store);
         }
-    USER_PROPERTY<varT>::operator =(val);
+    USER_PROPERTY<varT>::Set(val);
     return true;
     }
 else
@@ -408,48 +357,48 @@ return true;
 }
 //-------------------------------------------------------------------------
 template <typename varT>
-void USER_PROPERTY_LOGGED<varT>::WriteAccessDenied(const string & login,
-                                                   const ADMIN  & admin,
-                                                   const string & parameter)
+void USER_PROPERTY_LOGGED<varT>::WriteAccessDenied(const std::string & login,
+                                                   const ADMIN  * admin,
+                                                   const std::string & parameter)
 {
 stgLogger("%s Change user \'%s.\' Parameter \'%s\'. Access denied.",
-          admin.GetLogStr().c_str(), login.c_str(), parameter.c_str());
+          admin->GetLogStr().c_str(), login.c_str(), parameter.c_str());
 }
 //-------------------------------------------------------------------------
 template <typename varT>
-void USER_PROPERTY_LOGGED<varT>::WriteSuccessChange(const string & login,
-                                                    const ADMIN      & admin,
-                                                    const string     & parameter,
-                                                    const string     & oldValue,
-                                                    const string     & newValue,
-                                                    const string     & msg,
-                                                    const BASE_STORE * store)
+void USER_PROPERTY_LOGGED<varT>::WriteSuccessChange(const std::string & login,
+                                                    const ADMIN * admin,
+                                                    const std::string & parameter,
+                                                    const std::string & oldValue,
+                                                    const std::string & newValue,
+                                                    const std::string & msg,
+                                                    const STORE * store)
 {
 stgLogger("%s User \'%s\': \'%s\' parameter changed from \'%s\' to \'%s\'. %s",
-          admin.GetLogStr().c_str(),
+          admin->GetLogStr().c_str(),
           login.c_str(),
           parameter.c_str(),
           oldValue.c_str(),
           newValue.c_str(),
           msg.c_str());
 
-store->WriteUserChgLog(login, admin.GetLogin(), admin.GetAdminIP(), parameter, oldValue, newValue, msg);
+store->WriteUserChgLog(login, admin->GetLogin(), admin->GetIP(), parameter, oldValue, newValue, msg);
 }
 //-------------------------------------------------------------------------
 template <typename varT>
-void USER_PROPERTY_LOGGED<varT>::OnChange(const string & login,
-                                          const string & paramName,
-                                          const string & oldValue,
-                                          const string & newValue,
-                                          const ADMIN  & admin)
+void USER_PROPERTY_LOGGED<varT>::OnChange(const std::string & login,
+                                          const std::string & paramName,
+                                          const std::string & oldValue,
+                                          const std::string & newValue,
+                                          const ADMIN * admin)
 {
-string str1;
+std::string str1;
 
-str1 = settings->GetConfDir() + "/OnChange";
+str1 = scriptsDir + "/OnChange";
 
 if (access(str1.c_str(), X_OK) == 0)
     {
-    string str2("\"" + str1 + "\" \"" + login + "\" \"" + paramName + "\" \"" + oldValue + "\" \"" + newValue + "\" \"" + admin.GetLogin() + "\" \"" + admin.GetAdminIPStr() + "\"");
+    std::string str2("\"" + str1 + "\" \"" + login + "\" \"" + paramName + "\" \"" + oldValue + "\" \"" + newValue + "\" \"" + admin->GetLogin() + "\" \"" + admin->GetIPStr() + "\"");
     ScriptExec(str2);
     }
 else
@@ -461,19 +410,10 @@ else
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------
 template<typename varT>
-stringstream & operator<< (stringstream & s, const USER_PROPERTY<varT> & v)
+ostream & operator<< (ostream & stream, const USER_PROPERTY<varT> & value)
 {
-s << v.ConstData();
-return s;
+return stream << value.ConstData();
 }
 //-----------------------------------------------------------------------------
-template<typename varT>
-ostream & operator<< (ostream & o, const USER_PROPERTY<varT> & v)
-{
-return o << v.ConstData();
-}
-//-----------------------------------------------------------------------------
-
 
 #endif // USER_PROPERTY_H
-