stargazer/plugins/configuration/rpcconfig/users_methods.h

   1 #ifndef __USERS_METHODS_H__
   2 #define __USERS_METHODS_H__
   3
   4 #include <xmlrpc-c/base.hpp>
   5 #include <xmlrpc-c/registry.hpp>
   6
   7 class RPC_CONFIG;
   8 class ADMINS;
   9 class TARIFFS;
  10 class USERS;
  11 class STORE;
  12 struct IP_MASK;
  13
  14 class METHOD_USER_GET : public xmlrpc_c::method {
  15 public:
  16     METHOD_USER_GET(RPC_CONFIG * c,
  17                     USERS * u)
  18         : config(c),
  19           users(u)
  20     {
  21     }
  22
  23     void execute(xmlrpc_c::paramList const & paramList,
  24                  xmlrpc_c::value *   const   retvalP);
  25
  26 private:
  27     METHOD_USER_GET(const METHOD_USER_GET & rvalue);
  28     METHOD_USER_GET & operator=(const METHOD_USER_GET & rvalue);
  29
  30     RPC_CONFIG * config;
  31     USERS * users;
  32 };
  33
  34 class METHOD_USER_ADD : public xmlrpc_c::method {
  35 public:
  36     METHOD_USER_ADD(RPC_CONFIG * c,
  37                     ADMINS * a,
  38                     USERS * u)
  39         : config(c),
  40           admins(a),
  41           users(u)
  42     {
  43     }
  44
  45     void execute(xmlrpc_c::paramList const & paramList,
  46                  xmlrpc_c::value *   const   retvalP);
  47
  48 private:
  49     METHOD_USER_ADD(const METHOD_USER_ADD & rvalue);
  50     METHOD_USER_ADD & operator=(const METHOD_USER_ADD & rvalue);
  51
  52     RPC_CONFIG * config;
  53     ADMINS * admins;
  54     USERS * users;
  55 };
  56
  57 class METHOD_USER_DEL : public xmlrpc_c::method {
  58 public:
  59     METHOD_USER_DEL(RPC_CONFIG * c,
  60                     ADMINS * a,
  61                     USERS * u)
  62         : config(c),
  63           admins(a),
  64           users(u)
  65     {
  66     }
  67
  68     void execute(xmlrpc_c::paramList const & paramList,
  69                  xmlrpc_c::value *   const   retvalP);
  70
  71 private:
  72     METHOD_USER_DEL(const METHOD_USER_DEL & rvalue);
  73     METHOD_USER_DEL & operator=(const METHOD_USER_DEL & rvalue);
  74
  75     RPC_CONFIG * config;
  76     ADMINS * admins;
  77     USERS * users;
  78 };
  79
  80 class METHOD_USERS_GET : public xmlrpc_c::method {
  81 public:
  82     METHOD_USERS_GET(RPC_CONFIG * c,
  83                      USERS * u)
  84         : config(c),
  85           users(u)
  86     {
  87     }
  88
  89     void execute(xmlrpc_c::paramList const & paramList,
  90                  xmlrpc_c::value *   const   retvalP);
  91
  92 private:
  93     METHOD_USERS_GET(const METHOD_USERS_GET & rvalue);
  94     METHOD_USERS_GET & operator=(const METHOD_USERS_GET & rvalue);
  95
  96     RPC_CONFIG * config;
  97     USERS * users;
  98 };
  99
 100 class METHOD_USER_CHG : public xmlrpc_c::method {
 101 public:
 102     METHOD_USER_CHG(RPC_CONFIG * c,
 103                     ADMINS * a,
 104                     TARIFFS * t,
 105                     STORE * s,
 106                     USERS * u)
 107         : config(c),
 108           admins(a),
 109           tariffs(t),
 110           store(s),
 111           users(u)
 112     {
 113     }
 114
 115     void execute(xmlrpc_c::paramList const & paramList,
 116                  xmlrpc_c::value *   const   retvalP);
 117
 118 private:
 119     METHOD_USER_CHG(const METHOD_USER_CHG & rvalue);
 120     METHOD_USER_CHG & operator=(const METHOD_USER_CHG & rvalue);
 121
 122     RPC_CONFIG * config;
 123     ADMINS * admins;
 124     TARIFFS * tariffs;
 125     STORE * store;
 126     USERS * users;
 127 };
 128
 129 class METHOD_USER_CASH_ADD : public xmlrpc_c::method {
 130 public:
 131     METHOD_USER_CASH_ADD(RPC_CONFIG * c,
 132                          ADMINS * a,
 133                          STORE * s,
 134                          USERS * u)
 135         : config(c),
 136           admins(a),
 137           store(s),
 138           users(u)
 139     {
 140     }
 141
 142     void execute(xmlrpc_c::paramList const & paramList,
 143                  xmlrpc_c::value *   const   retvalP);
 144
 145 private:
 146     METHOD_USER_CASH_ADD(const METHOD_USER_CASH_ADD & rvalue);
 147     METHOD_USER_CASH_ADD & operator=(const METHOD_USER_CASH_ADD & rvalue);
 148
 149     RPC_CONFIG * config;
 150     ADMINS * admins;
 151     STORE * store;
 152     USERS * users;
 153 };
 154
 155 class METHOD_USER_CASH_SET : public xmlrpc_c::method {
 156 public:
 157     METHOD_USER_CASH_SET(RPC_CONFIG * c,
 158                          ADMINS * a,
 159                          STORE * s,
 160                          USERS * u)
 161         : config(c),
 162           admins(a),
 163           store(s),
 164           users(u)
 165     {
 166     }
 167
 168     void execute(xmlrpc_c::paramList const & paramList,
 169                  xmlrpc_c::value *   const   retvalP);
 170
 171 private:
 172     METHOD_USER_CASH_SET(const METHOD_USER_CASH_SET & rvalue);
 173     METHOD_USER_CASH_SET & operator=(const METHOD_USER_CASH_SET & rvalue);
 174
 175     RPC_CONFIG * config;
 176     ADMINS * admins;
 177     STORE * store;
 178     USERS * users;
 179 };
 180
 181 class METHOD_USER_TARIFF_CHANGE : public xmlrpc_c::method {
 182 public:
 183     METHOD_USER_TARIFF_CHANGE(RPC_CONFIG * c,
 184                               ADMINS * a,
 185                               TARIFFS * t,
 186                               STORE * s,
 187                               USERS * u)
 188         : config(c),
 189           admins(a),
 190           tariffs(t),
 191           store(s),
 192           users(u)
 193     {
 194     }
 195
 196     void execute(xmlrpc_c::paramList const & paramList,
 197                  xmlrpc_c::value *   const   retvalP);
 198
 199 private:
 200     METHOD_USER_TARIFF_CHANGE(const METHOD_USER_TARIFF_CHANGE & rvalue);
 201     METHOD_USER_TARIFF_CHANGE & operator=(const METHOD_USER_TARIFF_CHANGE & rvalue);
 202
 203     RPC_CONFIG * config;
 204     ADMINS * admins;
 205     TARIFFS * tariffs;
 206     STORE * store;
 207     USERS * users;
 208 };
 209
 210 class METHOD_GET_ONLINE_IPS : public xmlrpc_c::method {
 211 public:
 212     METHOD_GET_ONLINE_IPS(RPC_CONFIG * c,
 213                           USERS * u)
 214         : config(c),
 215           users(u)
 216     {
 217     }
 218
 219     void execute(xmlrpc_c::paramList const & paramList,
 220                  xmlrpc_c::value *   const   retvalP);
 221
 222 private:
 223     METHOD_GET_ONLINE_IPS(const METHOD_GET_ONLINE_IPS & rvalue);
 224     METHOD_GET_ONLINE_IPS & operator=(const METHOD_GET_ONLINE_IPS & rvalue);
 225
 226     RPC_CONFIG * config;
 227     USERS * users;
 228
 229     bool ParseNet(const std::string & net, IP_MASK & ipm) const;
 230 };
 231
 232 class METHOD_GET_USER_AUTH_BY : public xmlrpc_c::method {
 233 public:
 234     METHOD_GET_USER_AUTH_BY(RPC_CONFIG * c,
 235                             USERS * u)
 236         : config(c),
 237           users(u)
 238     {
 239     }
 240
 241     void execute(xmlrpc_c::paramList const & paramList,
 242                  xmlrpc_c::value *   const   retvalP);
 243
 244 private:
 245     METHOD_GET_USER_AUTH_BY(const METHOD_GET_ONLINE_IPS & rvalue);
 246     METHOD_GET_USER_AUTH_BY & operator=(const METHOD_GET_ONLINE_IPS & rvalue);
 247
 248     RPC_CONFIG * config;
 249     USERS * users;
 250 };
 251
 252 #endif