]> git.stg.codes - stg.git/blob - sgconf/users.cpp
4fcd3559ae232a59a552d2260a21ff458215d36e
[stg.git] / sgconf / users.cpp
1 #include "users.h"
2
3 #include "api_action.h"
4 #include "options.h"
5 #include "config.h"
6 #include "utils.h"
7
8 #include "stg/servconf.h"
9 #include "stg/servconf_types.h"
10 #include "stg/user_conf.h"
11 #include "stg/user_stat.h"
12 #include "stg/user_ips.h"
13 #include "stg/common.h"
14
15 #include <iostream>
16 #include <algorithm>
17 #include <string>
18 #include <map>
19
20 namespace
21 {
22
23 std::string Indent(size_t level, bool dash = false)
24 {
25 if (level == 0)
26     return "";
27 return dash ? std::string(level * 4 - 2, ' ') + "- " : std::string(level * 4, ' ');
28 }
29
30 void PrintUser(const STG::GET_USER::INFO & info, size_t level = 0)
31 {
32 std::cout << Indent(level, true) << "login: " << info.login << "\n"
33           << Indent(level)       << "password: " << info.password << "\n"
34           << Indent(level)       << "cash: " << info.cash << "\n"
35           << Indent(level)       << "credit: " << info.credit << "\n"
36           << Indent(level)       << "credit expire: " << TimeToString(info.creditExpire) << "\n"
37           << Indent(level)       << "last cash add: " << info.lastCashAdd << "\n"
38           << Indent(level)       << "last cash add time: " << TimeToString(info.lastCashAddTime) << "\n"
39           << Indent(level)       << "prepaid traffic: " << info.prepaidTraff << "\n"
40           << Indent(level)       << "disabled: " << (info.disabled ? "t" : "f") << "\n"
41           << Indent(level)       << "passive: " << (info.passive ? "t" : "f") << "\n"
42           << Indent(level)       << "disabled detail stat: " << (info.disableDetailStat ? "t" : "f") << "\n"
43           << Indent(level)       << "connected: " << (info.connected ? "t" : "f") << "\n"
44           << Indent(level)       << "always on-line: " << (info.alwaysOnline ? "t" : "f") << "\n"
45           << Indent(level)       << "IP: " << inet_ntostring(info.ip) << "\n"
46           << Indent(level)       << "IPs: " << info.ips << "\n"
47           << Indent(level)       << "tariff: " << info.tariff << "\n"
48           << Indent(level)       << "group: " << info.group << "\n"
49           << Indent(level)       << "note: " << info.note << "\n"
50           << Indent(level)       << "email: " << info.email << "\n"
51           << Indent(level)       << "name: " << info.name << "\n"
52           << Indent(level)       << "address: " << info.address << "\n"
53           << Indent(level)       << "phone: " << info.phone << "\n"
54           << Indent(level)       << "corporation: " << info.corp << "\n"
55           << Indent(level)       << "last ping time: " << TimeToString(info.pingTime) << "\n"
56           << Indent(level)       << "last activity time: " << TimeToString(info.lastActivityTime) << "\n"
57           << Indent(level)       << "traffic:\n";
58 for (size_t i = 0; i < DIR_NUM; ++i)
59     {
60     std::cout << Indent(level + 1, true) << "dir: " << i << "\n"
61               << Indent(level + 1)       << "session upload: " << info.stat.su[i] << "\n"
62               << Indent(level + 1)       << "session download: " << info.stat.sd[i] << "\n"
63               << Indent(level + 1)       << "month upload: " << info.stat.mu[i] << "\n"
64               << Indent(level + 1)       << "month download: " << info.stat.md[i] << "\n";
65     }
66 std::cout << Indent(level)       << "user data:\n";
67 for (size_t i = 0; i < USERDATA_NUM; ++i)
68     std::cout << Indent(level + 1, true) << "user data " << i << ": " << info.userData[i] << "\n";
69 if (!info.services.empty())
70     {
71     std::cout << Indent(level) << "services:\n";
72     for (size_t i = 0; i < info.services.size(); ++i)
73         std::cout << Indent(level + 1, true) << info.services[i] << "\n";
74     }
75 if (!info.authBy.empty())
76     {
77     std::cout << Indent(level) << "auth by:\n";
78     for (size_t i = 0; i < info.authBy.size(); ++i)
79         std::cout << Indent(level + 1, true) << info.authBy[i] << "\n";
80     }
81 }
82
83 std::vector<SGCONF::API_ACTION::PARAM> GetUserParams()
84 {
85 std::vector<SGCONF::API_ACTION::PARAM> params;
86 params.push_back(SGCONF::API_ACTION::PARAM("password", "<password>", "\tuser's password"));
87 params.push_back(SGCONF::API_ACTION::PARAM("cash-add", "<cash[:message]>", "cash to add (with optional comment)"));
88 params.push_back(SGCONF::API_ACTION::PARAM("cash-set", "<cash[:message]>", "cash to set (with optional comment)"));
89 params.push_back(SGCONF::API_ACTION::PARAM("credit", "<amount>", "\tuser's credit"));
90 params.push_back(SGCONF::API_ACTION::PARAM("credit-expire", "<date>", "\tcredit expiration"));
91 params.push_back(SGCONF::API_ACTION::PARAM("free", "<free mb>", "\tprepaid traffic"));
92 params.push_back(SGCONF::API_ACTION::PARAM("disabled", "<flag>", "\tdisable user (y|n)"));
93 params.push_back(SGCONF::API_ACTION::PARAM("passive", "<flag>", "\tmake user passive (y|n)"));
94 params.push_back(SGCONF::API_ACTION::PARAM("disable-detail-stat", "<flag>", "disable detail stat (y|n)"));
95 params.push_back(SGCONF::API_ACTION::PARAM("always-online", "<flag>", "\tmake user always online (y|n)"));
96 params.push_back(SGCONF::API_ACTION::PARAM("ips", "<ips>", "\t\tcoma-separated list of ips"));
97 params.push_back(SGCONF::API_ACTION::PARAM("tariff", "<tariff name>", "\tcurrent tariff"));
98 params.push_back(SGCONF::API_ACTION::PARAM("next-tariff", "<tariff name>", "tariff starting from the next month"));
99 params.push_back(SGCONF::API_ACTION::PARAM("group", "<group>", "\t\tuser's group"));
100 params.push_back(SGCONF::API_ACTION::PARAM("note", "<note>", "\t\tuser's note"));
101 params.push_back(SGCONF::API_ACTION::PARAM("email", "<email>", "\t\tuser's email"));
102 params.push_back(SGCONF::API_ACTION::PARAM("name", "<real name>", "\tuser's real name"));
103 params.push_back(SGCONF::API_ACTION::PARAM("address", "<address>", "\tuser's postal address"));
104 params.push_back(SGCONF::API_ACTION::PARAM("phone", "<phone>", "\t\tuser's phone number"));
105 params.push_back(SGCONF::API_ACTION::PARAM("corp", "<corp name>", "\tcorporation name"));
106 params.push_back(SGCONF::API_ACTION::PARAM("session-traffic", "<up/dn, ...>", "coma-separated session upload and download"));
107 params.push_back(SGCONF::API_ACTION::PARAM("month-traffic", "<up/dn, ...>", "coma-separated month upload and download"));
108 params.push_back(SGCONF::API_ACTION::PARAM("user-data", "<value, ...>", "coma-separated user data values"));
109 return params;
110 }
111
112 std::vector<SGCONF::API_ACTION::PARAM> GetCheckParams()
113 {
114 std::vector<SGCONF::API_ACTION::PARAM> params;
115 params.push_back(SGCONF::API_ACTION::PARAM("password", "<password>", "\tuser's password"));
116 return params;
117 }
118
119 std::vector<SGCONF::API_ACTION::PARAM> GetMessageParams()
120 {
121 std::vector<SGCONF::API_ACTION::PARAM> params;
122 params.push_back(SGCONF::API_ACTION::PARAM("logins", "<login, ...>", "\tlist of logins to send a message"));
123 params.push_back(SGCONF::API_ACTION::PARAM("text", "<text>", "\t\tmessage text"));
124 return params;
125 }
126
127 void ConvBool(const std::string & value, RESETABLE<int> & res)
128 {
129 res = !value.empty() && value[0] == 'y';
130 }
131
132 void Splice(std::vector<RESETABLE<std::string> > & lhs, const std::vector<RESETABLE<std::string> > & rhs)
133 {
134 for (size_t i = 0; i < lhs.size() && i < rhs.size(); ++i)
135     lhs[i].splice(rhs[i]);
136 }
137
138 RESETABLE<std::string> ConvString(const std::string & value)
139 {
140 return RESETABLE<std::string>(value);
141 }
142
143 void ConvStringList(std::string value, std::vector<RESETABLE<std::string> > & res)
144 {
145 Splice(res, Split<std::vector<RESETABLE<std::string> > >(value, ',', ConvString));
146 }
147
148 void ConvServices(std::string value, RESETABLE<std::vector<std::string> > & res)
149 {
150 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
151 res = Split<std::vector<std::string> >(value, ',');
152 }
153
154 void ConvCreditExpire(const std::string & value, RESETABLE<time_t> & res)
155 {
156 struct tm brokenTime;
157 if (stg_strptime(value.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime) == NULL)
158     throw SGCONF::ACTION::ERROR("Credit expiration should be in format 'YYYY-MM-DD HH:MM:SS'. Got: '" + value + "'");
159 res = stg_timegm(&brokenTime);
160 }
161
162 void ConvIPs(const std::string & value, RESETABLE<USER_IPS> & res)
163 {
164 res = StrToIPS(value);
165 }
166
167 struct TRAFF
168 {
169     uint64_t up;
170     uint64_t down;
171 };
172
173 TRAFF ConvTraff(const std::string & value)
174 {
175 TRAFF res;
176 size_t slashPos = value.find_first_of('/');
177 if (slashPos == std::string::npos)
178     throw SGCONF::ACTION::ERROR("Traffic record should be in format 'upload/download'. Got: '" + value + "'");
179
180 if (str2x(value.substr(0, slashPos), res.up) < 0)
181     throw SGCONF::ACTION::ERROR("Traffic value should be an integer. Got: '" + value.substr(0, slashPos) + "'");
182 if (str2x(value.substr(slashPos + 1, value.length() - slashPos), res.down) < 0)
183     throw SGCONF::ACTION::ERROR("Traffic value should be an integer. Got: '" + value.substr(slashPos + 1, value.length() - slashPos) + "'");
184 return res;
185 }
186
187 void ConvSessionTraff(std::string value, USER_STAT_RES & res)
188 {
189 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
190 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
191 if (traff.size() != DIR_NUM)
192     throw SGCONF::ACTION::ERROR("There should be prcisely " + std::to_string(DIR_NUM) + " records of session traffic.");
193 for (size_t i = 0; i < DIR_NUM; ++i)
194     {
195     res.sessionUp[i] = traff[i].up;
196     res.sessionDown[i] = traff[i].down;
197     }
198 }
199
200 void ConvMonthTraff(std::string value, USER_STAT_RES & res)
201 {
202 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
203 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
204 if (traff.size() != DIR_NUM)
205     throw SGCONF::ACTION::ERROR("There should be prcisely " + std::to_string(DIR_NUM) + " records of month traffic.");
206 for (size_t i = 0; i < DIR_NUM; ++i)
207     {
208     res.monthUp[i] = traff[i].up;
209     res.monthDown[i] = traff[i].down;
210     }
211 }
212
213 void ConvCashInfo(const std::string & value, RESETABLE<CASH_INFO> & res)
214 {
215 CASH_INFO info;
216 size_t pos = value.find_first_of(':');
217 if (pos == std::string::npos)
218     {
219     if (str2x(value, info.first) < 0)
220         throw SGCONF::ACTION::ERROR("Cash should be a double value. Got: '" + value + "'");
221     }
222 else
223     {
224     if (str2x(value.substr(0, pos), info.first) < 0)
225         throw SGCONF::ACTION::ERROR("Cash should be a double value. Got: '" + value + "'");
226     info.second = value.substr(pos + 1);
227     }
228 res = info;
229 }
230
231 void SimpleCallback(bool result,
232                     const std::string & reason,
233                     void * /*data*/)
234 {
235 if (!result)
236     {
237     std::cerr << "Operation failed. Reason: '" << reason << "'." << std::endl;
238     return;
239     }
240 std::cout << "Success.\n";
241 }
242
243 void GetUsersCallback(bool result,
244                       const std::string & reason,
245                       const std::vector<STG::GET_USER::INFO> & info,
246                       void * /*data*/)
247 {
248 if (!result)
249     {
250     std::cerr << "Failed to get user list. Reason: '" << reason << "'." << std::endl;
251     return;
252     }
253 std::cout << "Users:\n";
254 for (size_t i = 0; i < info.size(); ++i)
255     PrintUser(info[i], 1);
256 }
257
258 void GetUserCallback(bool result,
259                      const std::string & reason,
260                      const STG::GET_USER::INFO & info,
261                      void * /*data*/)
262 {
263 if (!result)
264     {
265     std::cerr << "Failed to get user. Reason: '" << reason << "'." << std::endl;
266     return;
267     }
268 PrintUser(info);
269 }
270
271 void AuthByCallback(bool result,
272                     const std::string & reason,
273                     const std::vector<std::string> & info,
274                     void * /*data*/)
275 {
276 if (!result)
277     {
278     std::cerr << "Failed to get authorizer list. Reason: '" << reason << "'." << std::endl;
279     return;
280     }
281 std::cout << "Authorized by:\n";
282 for (size_t i = 0; i < info.size(); ++i)
283     std::cout << Indent(1, true) << info[i] << "\n";
284 }
285
286 bool GetUsersFunction(const SGCONF::CONFIG & config,
287                       const std::string & /*arg*/,
288                       const std::map<std::string, std::string> & /*options*/)
289 {
290 STG::SERVCONF proto(config.server.data(),
291                     config.port.data(),
292                     config.localAddress.data(),
293                     config.localPort.data(),
294                     config.userName.data(),
295                     config.userPass.data());
296 return proto.GetUsers(GetUsersCallback, NULL) == STG::st_ok;
297 }
298
299 bool GetUserFunction(const SGCONF::CONFIG & config,
300                      const std::string & arg,
301                      const std::map<std::string, std::string> & /*options*/)
302 {
303 STG::SERVCONF proto(config.server.data(),
304                     config.port.data(),
305                     config.localAddress.data(),
306                     config.localPort.data(),
307                     config.userName.data(),
308                     config.userPass.data());
309 return proto.GetUser(arg, GetUserCallback, NULL) == STG::st_ok;
310 }
311
312 bool DelUserFunction(const SGCONF::CONFIG & config,
313                      const std::string & arg,
314                      const std::map<std::string, std::string> & /*options*/)
315 {
316 STG::SERVCONF proto(config.server.data(),
317                     config.port.data(),
318                     config.localAddress.data(),
319                     config.localPort.data(),
320                     config.userName.data(),
321                     config.userPass.data());
322 return proto.DelUser(arg, SimpleCallback, NULL) == STG::st_ok;
323 }
324
325 bool AddUserFunction(const SGCONF::CONFIG & config,
326                      const std::string & arg,
327                      const std::map<std::string, std::string> & options)
328 {
329 USER_CONF_RES conf;
330 SGCONF::MaybeSet(options, "password", conf.password);
331 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
332 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);
333 SGCONF::MaybeSet(options, "disable-detail-stat", conf.disabledDetailStat, ConvBool);
334 SGCONF::MaybeSet(options, "always-online", conf.alwaysOnline, ConvBool);
335 SGCONF::MaybeSet(options, "tariff", conf.tariffName);
336 SGCONF::MaybeSet(options, "address", conf.address);
337 SGCONF::MaybeSet(options, "phone", conf.phone);
338 SGCONF::MaybeSet(options, "email", conf.email);
339 SGCONF::MaybeSet(options, "note", conf.note);
340 SGCONF::MaybeSet(options, "name", conf.realName);
341 SGCONF::MaybeSet(options, "corp", conf.corp);
342 SGCONF::MaybeSet(options, "services", conf.services, ConvServices);
343 SGCONF::MaybeSet(options, "group", conf.group);
344 SGCONF::MaybeSet(options, "credit", conf.credit);
345 SGCONF::MaybeSet(options, "next-tariff", conf.nextTariff);
346 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
347 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
348 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);
349 USER_STAT_RES stat;
350 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
351 SGCONF::MaybeSet(options, "free", stat.freeMb);
352 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
353 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);
354 STG::SERVCONF proto(config.server.data(),
355                     config.port.data(),
356                     config.localAddress.data(),
357                     config.localPort.data(),
358                     config.userName.data(),
359                     config.userPass.data());
360 return proto.AddUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;
361 }
362
363 bool ChgUserFunction(const SGCONF::CONFIG & config,
364                      const std::string & arg,
365                      const std::map<std::string, std::string> & options)
366 {
367 USER_CONF_RES conf;
368 SGCONF::MaybeSet(options, "password", conf.password);
369 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
370 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);
371 SGCONF::MaybeSet(options, "disable-detail-stat", conf.disabledDetailStat, ConvBool);
372 SGCONF::MaybeSet(options, "always-online", conf.alwaysOnline, ConvBool);
373 SGCONF::MaybeSet(options, "tariff", conf.tariffName);
374 SGCONF::MaybeSet(options, "address", conf.address);
375 SGCONF::MaybeSet(options, "phone", conf.phone);
376 SGCONF::MaybeSet(options, "email", conf.email);
377 SGCONF::MaybeSet(options, "note", conf.note);
378 SGCONF::MaybeSet(options, "name", conf.realName);
379 SGCONF::MaybeSet(options, "corp", conf.corp);
380 SGCONF::MaybeSet(options, "services", conf.services, ConvServices);
381 SGCONF::MaybeSet(options, "group", conf.group);
382 SGCONF::MaybeSet(options, "credit", conf.credit);
383 SGCONF::MaybeSet(options, "next-tariff", conf.nextTariff);
384 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
385 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
386 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);
387 USER_STAT_RES stat;
388 SGCONF::MaybeSet(options, "cash-add", stat.cashAdd, ConvCashInfo);
389 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
390 SGCONF::MaybeSet(options, "free", stat.freeMb);
391 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
392 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);
393 STG::SERVCONF proto(config.server.data(),
394                     config.port.data(),
395                     config.localAddress.data(),
396                     config.localPort.data(),
397                     config.userName.data(),
398                     config.userPass.data());
399 return proto.ChgUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;
400 }
401
402 bool CheckUserFunction(const SGCONF::CONFIG & config,
403                        const std::string & arg,
404                        const std::map<std::string, std::string> & options)
405 {
406 std::map<std::string, std::string>::const_iterator it(options.find("password"));
407 if (it == options.end())
408     throw SGCONF::ACTION::ERROR("Password is not specified.");
409 STG::SERVCONF proto(config.server.data(),
410                     config.port.data(),
411                     config.localAddress.data(),
412                     config.localPort.data(),
413                     config.userName.data(),
414                     config.userPass.data());
415 return proto.CheckUser(arg, it->second, SimpleCallback, NULL) == STG::st_ok;
416 }
417
418 bool SendMessageFunction(const SGCONF::CONFIG & config,
419                          const std::string & /*arg*/,
420                          const std::map<std::string, std::string> & options)
421 {
422 std::map<std::string, std::string>::const_iterator it(options.find("logins"));
423 if (it == options.end())
424     throw SGCONF::ACTION::ERROR("Logins are not specified.");
425 std::string logins = it->second;
426 for (size_t i = 0; i < logins.length(); ++i)
427     if (logins[i] == ',')
428         logins[i] = ':';
429 it = options.find("text");
430 if (it == options.end())
431     throw SGCONF::ACTION::ERROR("Message text is not specified.");
432 std::string text = it->second;
433 STG::SERVCONF proto(config.server.data(),
434                     config.port.data(),
435                     config.localAddress.data(),
436                     config.localPort.data(),
437                     config.userName.data(),
438                     config.userPass.data());
439 return proto.SendMessage(logins, text, SimpleCallback, NULL) == STG::st_ok;
440 }
441
442 bool AuthByFunction(const SGCONF::CONFIG & config,
443                     const std::string & arg,
444                     const std::map<std::string, std::string> & /*options*/)
445 {
446 STG::SERVCONF proto(config.server.data(),
447                     config.port.data(),
448                     config.localAddress.data(),
449                     config.localPort.data(),
450                     config.userName.data(),
451                     config.userPass.data());
452 return proto.AuthBy(arg, AuthByCallback, NULL) == STG::st_ok;
453 }
454
455 } // namespace anonymous
456
457 void SGCONF::AppendUsersOptionBlock(COMMANDS & commands, OPTION_BLOCKS & blocks)
458 {
459 std::vector<API_ACTION::PARAM> params(GetUserParams());
460 blocks.Add("User management options")
461       .Add("get-users", SGCONF::MakeAPIAction(commands, GetUsersFunction), "\tget user list")
462       .Add("get-user", SGCONF::MakeAPIAction(commands, "<login>", GetUserFunction), "get user")
463       .Add("add-user", SGCONF::MakeAPIAction(commands, "<login>", params, AddUserFunction), "add user")
464       .Add("del-user", SGCONF::MakeAPIAction(commands, "<login>", DelUserFunction), "delete user")
465       .Add("chg-user", SGCONF::MakeAPIAction(commands, "<login>", params, ChgUserFunction), "change user")
466       .Add("check-user", SGCONF::MakeAPIAction(commands, "<login>", GetCheckParams(), CheckUserFunction), "check user existance and credentials")
467       .Add("send-message", SGCONF::MakeAPIAction(commands, GetMessageParams(), SendMessageFunction), "send message")
468       .Add("auth-by", SGCONF::MakeAPIAction(commands, "<login>", AuthByFunction), "a list of authorizers user authorized by");
469 }