]> git.stg.codes - stg.git/blob - stargazer/plugins/configuration/rpcconfig/users_methods.h
f03e98890944e96a5b0357c1b9865b028dc40bf7
[stg.git] / 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 };