Remove std::list from tariffs.

[stg.git] / include / stg / user_property.h

diff --git a/include/stg/user_property.h b/include/stg/user_property.h
index f0a6d18e85644c8f9d1a8f81919cef898b64f00d..4a26b21144dc5e2c908c70ba0eacbfaea3384be4 100644 (file)
--- a/include/stg/user_property.h
+++ b/include/stg/user_property.h
@@ -12,24 +12,34 @@ $Author: faust $
 #include <ctime>
 #include <string>
 #include <set>
 #include <ctime>
 #include <string>
 #include <set>

+#include <map>

 #include <sstream>
 #include <iostream>
 
 #include <sstream>
 #include <iostream>
 

+#include "stg/logger.h"
+#include "stg/locker.h"
+#include "stg/settings.h"
+#include "stg/scriptexecuter.h"
+#include "stg/common.h"
+

 #include "store.h"
 #include "admin.h"
 #include "notifer.h"
 #include "store.h"
 #include "admin.h"
 #include "notifer.h"

-#include "logger.h"
-#include "locker.h"
-#include "scriptexecuter.h"

 #include "noncopyable.h"
 
 #include "noncopyable.h"
 

-extern const volatile time_t stgTime;
-
+extern volatile time_t stgTime;
+//-----------------------------------------------------------------------------
+class USER_PROPERTY_BASE {
+public:
+    virtual std::string ToString() const = 0;
+};
+//-----------------------------------------------------------------------------
+typedef std::map<std::string, USER_PROPERTY_BASE *> REGISTRY;

 //-----------------------------------------------------------------------------
 template<typename varT>
 //-----------------------------------------------------------------------------
 template<typename varT>

-class USER_PROPERTY {
+class USER_PROPERTY : public USER_PROPERTY_BASE {

 public:
 public:

-    USER_PROPERTY(varT & val);
+    explicit USER_PROPERTY(varT & val);

     virtual ~USER_PROPERTY();
 
     void Set(const varT & rvalue);
     virtual ~USER_PROPERTY();
 
     void Set(const varT & rvalue);


@@ -42,14 +52,15 @@ public:
     operator const varT&() const throw() { return value; }
 
     void    AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
     operator const varT&() const throw() { return value; }
 
     void    AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);

-    void    DelBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
+    void    DelBeforeNotifier(const PROPERTY_NOTIFIER_BASE<varT> * n);

 
     void    AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
 
     void    AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);

-    void    DelAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n);
+    void    DelAfterNotifier(const PROPERTY_NOTIFIER_BASE<varT> * n);

 
     time_t  ModificationTime() const throw() { return modificationTime; }
     void    ModifyTime() throw();
 
 
     time_t  ModificationTime() const throw() { return modificationTime; }
     void    ModifyTime() throw();
 

+    std::string ToString() const;

 private:
     varT & value;
     time_t modificationTime;
 private:
     varT & value;
     time_t modificationTime;


@@ -66,10 +77,12 @@ public:
                          bool isPassword,
                          bool isStat,
                          STG_LOGGER & logger,
                          bool isPassword,
                          bool isStat,
                          STG_LOGGER & logger,

-                         const std::string & sd);
+                         const SETTINGS & s,
+                         REGISTRY & properties);

     virtual ~USER_PROPERTY_LOGGED() {}
 
     USER_PROPERTY_LOGGED<varT> * GetPointer() throw() { return this; }
     virtual ~USER_PROPERTY_LOGGED() {}
 
     USER_PROPERTY_LOGGED<varT> * GetPointer() throw() { return this; }

+    const USER_PROPERTY_LOGGED<varT> * GetPointer() const throw() { return this; }

     const varT & Get() const { return USER_PROPERTY<varT>::ConstData(); }
     const std::string & GetName() const { return name; }
     bool Set(const varT & val,
     const varT & Get() const { return USER_PROPERTY<varT>::ConstData(); }
     const std::string & GetName() const { return name; }
     bool Set(const varT & val,


@@ -100,7 +113,7 @@ private:
     bool              isPassword;
     bool              isStat;
     std::string       name;
     bool              isPassword;
     bool              isStat;
     std::string       name;

-    const std::string scriptsDir;
+    const SETTINGS&   settings;

 };
 //-----------------------------------------------------------------------------
 class USER_PROPERTIES : private NONCOPYABLE {
 };
 //-----------------------------------------------------------------------------
 class USER_PROPERTIES : private NONCOPYABLE {


@@ -116,8 +129,9 @@ private:
     USER_STAT stat;
     USER_CONF conf;
 
     USER_STAT stat;
     USER_CONF conf;
 

+    REGISTRY properties;

 public:
 public:

-    USER_PROPERTIES(const std::string & sd);
+    explicit USER_PROPERTIES(const SETTINGS& s);

 
     USER_STAT & Stat() { return stat; }
     USER_CONF & Conf() { return conf; }
 
     USER_STAT & Stat() { return stat; }
     USER_CONF & Conf() { return conf; }


@@ -128,6 +142,9 @@ public:
 
     void SetProperties(const USER_PROPERTIES & p) { stat = p.stat; conf = p.conf; }
 
 
     void SetProperties(const USER_PROPERTIES & p) { stat = p.stat; conf = p.conf; }
 

+    std::string GetPropertyValue(const std::string & name) const;
+    bool Exists(const std::string & name) const;
+

     USER_PROPERTY_LOGGED<double>            cash;
     USER_PROPERTY_LOGGED<DIR_TRAFF>         up;
     USER_PROPERTY_LOGGED<DIR_TRAFF>         down;
     USER_PROPERTY_LOGGED<double>            cash;
     USER_PROPERTY_LOGGED<DIR_TRAFF>         up;
     USER_PROPERTY_LOGGED<DIR_TRAFF>         down;


@@ -173,7 +190,10 @@ template <typename varT>
 inline
 USER_PROPERTY<varT>::USER_PROPERTY(varT & val)
     : value(val),
 inline
 USER_PROPERTY<varT>::USER_PROPERTY(varT & val)
     : value(val),

-      modificationTime(stgTime)
+      modificationTime(stgTime),
+      beforeNotifiers(),
+      afterNotifiers(),
+      mutex()

 {
 pthread_mutex_init(&mutex, NULL);
 }
 {
 pthread_mutex_init(&mutex, NULL);
 }


@@ -196,7 +216,7 @@ template <typename varT>
 inline
 void USER_PROPERTY<varT>::Set(const varT & rvalue)
 {
 inline
 void USER_PROPERTY<varT>::Set(const varT & rvalue)
 {

-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
+STG_LOCKER locker(&mutex);

 
 typename std::set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
 
 
 typename std::set<PROPERTY_NOTIFIER_BASE<varT> *>::iterator ni;
 


@@ -226,32 +246,32 @@ template <typename varT>
 inline
 void USER_PROPERTY<varT>::AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
 {
 inline
 void USER_PROPERTY<varT>::AddBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
 {

-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
+STG_LOCKER locker(&mutex);

 beforeNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline
 beforeNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline

-void USER_PROPERTY<varT>::DelBeforeNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
+void USER_PROPERTY<varT>::DelBeforeNotifier(const PROPERTY_NOTIFIER_BASE<varT> * n)

 {
 {

-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-beforeNotifiers.erase(n);
+STG_LOCKER locker(&mutex);
+beforeNotifiers.erase(const_cast<PROPERTY_NOTIFIER_BASE<varT> *>(n));

 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline
 void USER_PROPERTY<varT>::AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
 {
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline
 void USER_PROPERTY<varT>::AddAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
 {

-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
+STG_LOCKER locker(&mutex);

 afterNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline
 afterNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 template <typename varT>
 inline

-void USER_PROPERTY<varT>::DelAfterNotifier(PROPERTY_NOTIFIER_BASE<varT> * n)
+void USER_PROPERTY<varT>::DelAfterNotifier(const PROPERTY_NOTIFIER_BASE<varT> * n)

 {
 {

-STG_LOCKER locker(&mutex, __FILE__, __LINE__);
-afterNotifiers.erase(n);
+STG_LOCKER locker(&mutex);
+afterNotifiers.erase(const_cast<PROPERTY_NOTIFIER_BASE<varT> *>(n));

 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 }
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------


@@ -263,15 +283,17 @@ USER_PROPERTY_LOGGED<varT>::USER_PROPERTY_LOGGED(varT & val,
                                                  bool isPass,
                                                  bool isSt,
                                                  STG_LOGGER & logger,
                                                  bool isPass,
                                                  bool isSt,
                                                  STG_LOGGER & logger,

-                                                 const std::string & sd)
+                                                 const SETTINGS& s,
+                                                 REGISTRY & properties)

 
     : USER_PROPERTY<varT>(val),
       stgLogger(logger),
       isPassword(isPass),
       isStat(isSt),
       name(n),
 
     : USER_PROPERTY<varT>(val),
       stgLogger(logger),
       isPassword(isPass),
       isStat(isSt),
       name(n),

-      scriptsDir(sd)
+      settings(s)

 {
 {

+properties.insert(std::make_pair(ToLower(name), this));

 }
 //-------------------------------------------------------------------------
 template <typename varT>
 }
 //-------------------------------------------------------------------------
 template <typename varT>


@@ -282,8 +304,6 @@ bool USER_PROPERTY_LOGGED<varT>::Set(const varT & val,
                                      const std::string & msg)
 {
 const PRIV * priv = admin->GetPriv();
                                      const std::string & msg)
 {
 const PRIV * priv = admin->GetPriv();

-std::string adm_login = admin->GetLogin();
-std::string adm_ip = admin->GetIPStr();

 
 if ((priv->userConf && !isStat) ||
     (priv->userStat && isStat) ||
 
 if ((priv->userConf && !isStat) ||
     (priv->userStat && isStat) ||


@@ -293,8 +313,8 @@ if ((priv->userConf && !isStat) ||
     std::stringstream oldVal;
     std::stringstream newVal;
 
     std::stringstream oldVal;
     std::stringstream newVal;
 

-    oldVal.flags(oldVal.flags() | ios::fixed);
-    newVal.flags(newVal.flags() | ios::fixed);
+    oldVal.flags(oldVal.flags() | std::ios::fixed);
+    newVal.flags(newVal.flags() | std::ios::fixed);

 
     oldVal << USER_PROPERTY<varT>::ConstData();
     newVal << val;
 
     oldVal << USER_PROPERTY<varT>::ConstData();
     newVal << val;


@@ -348,7 +368,12 @@ stgLogger("%s User \'%s\': \'%s\' parameter changed from \'%s\' to \'%s\'. %s",
           newValue.c_str(),
           msg.c_str());
 
           newValue.c_str(),
           msg.c_str());
 

-store->WriteUserChgLog(login, admin->GetLogin(), admin->GetIP(), parameter, oldValue, newValue, msg);
+for (size_t i = 0; i < settings.GetFilterParamsLog().size(); ++i)
+    if (settings.GetFilterParamsLog()[i] == "*" || strcasecmp(settings.GetFilterParamsLog()[i].c_str(), parameter.c_str()) == 0)
+        {
+        store->WriteUserChgLog(login, admin->GetLogin(), admin->GetIP(), parameter, oldValue, newValue, msg);
+        return;
+        }

 }
 //-------------------------------------------------------------------------
 template <typename varT>
 }
 //-------------------------------------------------------------------------
 template <typename varT>


@@ -358,12 +383,12 @@ void USER_PROPERTY_LOGGED<varT>::OnChange(const std::string & login,
                                           const std::string & newValue,
                                           const ADMIN * admin)
 {
                                           const std::string & newValue,
                                           const ADMIN * admin)
 {

-std::string filePath = scriptsDir + "/OnChange";
+static std::string filePath = settings.GetScriptsDir() + "/OnChange";

 
 if (access(filePath.c_str(), X_OK) == 0)
     {
     std::string execString("\"" + filePath + "\" \"" + login + "\" \"" + paramName + "\" \"" + oldValue + "\" \"" + newValue + "\" \"" + admin->GetLogin() + "\" \"" + admin->GetIPStr() + "\"");
 
 if (access(filePath.c_str(), X_OK) == 0)
     {
     std::string execString("\"" + filePath + "\" \"" + login + "\" \"" + paramName + "\" \"" + oldValue + "\" \"" + newValue + "\" \"" + admin->GetLogin() + "\" \"" + admin->GetIPStr() + "\"");

-    ScriptExec(execString);
+    ScriptExec(execString.c_str());

     }
 else
     {
     }
 else
     {


@@ -373,12 +398,36 @@ else
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------
 //-------------------------------------------------------------------------

+inline
+std::string USER_PROPERTIES::GetPropertyValue(const std::string & name) const
+{
+REGISTRY::const_iterator it = properties.find(ToLower(name));
+if (it == properties.end())
+    return "";
+return it->second->ToString();
+}
+//-----------------------------------------------------------------------------
+inline
+bool USER_PROPERTIES::Exists(const std::string & name) const
+{
+return properties.find(ToLower(name)) != properties.end();
+}
+//-------------------------------------------------------------------------
+//-------------------------------------------------------------------------
+//-------------------------------------------------------------------------

 template<typename varT>
 inline
 template<typename varT>
 inline

-ostream & operator<< (ostream & stream, const USER_PROPERTY<varT> & value)
+std::ostream & operator<< (std::ostream & stream, const USER_PROPERTY<varT> & value)

 {
 return stream << value.ConstData();
 }
 //-----------------------------------------------------------------------------
 {
 return stream << value.ConstData();
 }
 //-----------------------------------------------------------------------------

-
+template<typename varT>
+inline
+std::string USER_PROPERTY<varT>::ToString() const
+{
+std::ostringstream stream;
+stream << value;
+return stream.str();
+}

 #endif // USER_PROPERTY_H
 #endif // USER_PROPERTY_H