stargazer/plugins/configuration/rpcconfig/users_methods.h

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