Install Boost in GitHub Actions.

[stg.git] / projects / sgconf / users.cpp

diff --git a/projects/sgconf/users.cpp b/projects/sgconf/users.cpp
index 018556df5d18895b2d985c514cbf6e393436964c..d1dd1a7343c594b0b139f9b06964701f0f0b5847 100644 (file)
--- a/projects/sgconf/users.cpp
+++ b/projects/sgconf/users.cpp
@@ -2,6 +2,7 @@
 
 #include "api_action.h"
 #include "options.h"
 
 #include "api_action.h"
 #include "options.h"

+#include "makeproto.h"

 #include "config.h"
 #include "utils.h"
 
 #include "config.h"
 #include "utils.h"
 


@@ -11,11 +12,13 @@
 #include "stg/user_stat.h"
 #include "stg/user_ips.h"
 #include "stg/common.h"
 #include "stg/user_stat.h"
 #include "stg/user_ips.h"
 #include "stg/common.h"

+#include "stg/splice.h"

 
 #include <iostream>
 #include <algorithm>
 #include <string>
 #include <map>
 
 #include <iostream>
 #include <algorithm>
 #include <string>
 #include <map>

+#include <optional>

 
 namespace
 {
 
 namespace
 {


@@ -27,7 +30,7 @@ if (level == 0)
 return dash ? std::string(level * 4 - 2, ' ') + "- " : std::string(level * 4, ' ');
 }
 
 return dash ? std::string(level * 4 - 2, ' ') + "- " : std::string(level * 4, ' ');
 }
 

-void PrintUser(const STG::GET_USER::INFO & info, size_t level = 0)
+void PrintUser(const STG::GetUser::Info & info, size_t level = 0)

 {
 std::cout << Indent(level, true) << "login: " << info.login << "\n"
           << Indent(level)       << "password: " << info.password << "\n"
 {
 std::cout << Indent(level, true) << "login: " << info.login << "\n"
           << Indent(level)       << "password: " << info.password << "\n"


@@ -124,34 +127,34 @@ params.push_back(SGCONF::API_ACTION::PARAM("text", "<text>", "\t\tmessage text")
 return params;
 }
 
 return params;
 }
 

-void ConvBool(const std::string & value, RESETABLE<int> & res)
+void ConvBool(const std::string & value, std::optional<int> & res)

 {
 res = !value.empty() && value[0] == 'y';
 }
 
 {
 res = !value.empty() && value[0] == 'y';
 }
 

-void Splice(std::vector<RESETABLE<std::string> > & lhs, const std::vector<RESETABLE<std::string> > & rhs)
+void Splice(std::vector<std::optional<std::string> > & lhs, const std::vector<std::optional<std::string> > & rhs)

 {
 for (size_t i = 0; i < lhs.size() && i < rhs.size(); ++i)
 {
 for (size_t i = 0; i < lhs.size() && i < rhs.size(); ++i)

-    lhs[i].splice(rhs[i]);
+    STG::splice(lhs[i], rhs[i]);

 }
 
 }
 

-RESETABLE<std::string> ConvString(const std::string & value)
+std::optional<std::string> ConvString(const std::string & value)

 {
 {

-return RESETABLE<std::string>(value);
+return std::optional<std::string>(value);

 }
 
 }
 

-void ConvStringList(std::string value, std::vector<RESETABLE<std::string> > & res)
+void ConvStringList(std::string value, std::vector<std::optional<std::string> > & res)

 {
 {

-Splice(res, Split<std::vector<RESETABLE<std::string> > >(value, ',', ConvString));
+Splice(res, Split<std::vector<std::optional<std::string> > >(value, ',', ConvString));

 }
 
 }
 

-void ConvServices(std::string value, RESETABLE<std::vector<std::string> > & res)
+void ConvServices(std::string value, std::optional<std::vector<std::string> > & res)

 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 res = Split<std::vector<std::string> >(value, ',');
 }
 
 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 res = Split<std::vector<std::string> >(value, ',');
 }
 

-void ConvCreditExpire(const std::string & value, RESETABLE<time_t> & res)
+void ConvCreditExpire(const std::string & value, std::optional<time_t> & res)

 {
 struct tm brokenTime;
 if (stg_strptime(value.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime) == NULL)
 {
 struct tm brokenTime;
 if (stg_strptime(value.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime) == NULL)


@@ -159,9 +162,9 @@ if (stg_strptime(value.c_str(), "%Y-%m-%d %H:%M:%S", &brokenTime) == NULL)
 res = stg_timegm(&brokenTime);
 }
 
 res = stg_timegm(&brokenTime);
 }
 

-void ConvIPs(const std::string & value, RESETABLE<USER_IPS> & res)
+void ConvIPs(const std::string & value, std::optional<STG::UserIPs> & res)

 {
 {

-res = StrToIPS(value);
+res = STG::UserIPs::parse(value);

 }
 
 struct TRAFF
 }
 
 struct TRAFF


@@ -184,12 +187,12 @@ if (str2x(value.substr(slashPos + 1, value.length() - slashPos), res.down) < 0)
 return res;
 }
 
 return res;
 }
 

-void ConvSessionTraff(std::string value, USER_STAT_RES & res)
+void ConvSessionTraff(std::string value, STG::UserStatOpt & res)

 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
 if (traff.size() != DIR_NUM)
 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
 if (traff.size() != DIR_NUM)

-    throw SGCONF::ACTION::ERROR("There should be prcisely " + x2str(DIR_NUM) + " records of session traffic.");
+    throw SGCONF::ACTION::ERROR("There should be prcisely " + std::to_string(DIR_NUM) + " records of session traffic.");

 for (size_t i = 0; i < DIR_NUM; ++i)
     {
     res.sessionUp[i] = traff[i].up;
 for (size_t i = 0; i < DIR_NUM; ++i)
     {
     res.sessionUp[i] = traff[i].up;


@@ -197,12 +200,12 @@ for (size_t i = 0; i < DIR_NUM; ++i)
     }
 }
 
     }
 }
 

-void ConvMonthTraff(std::string value, USER_STAT_RES & res)
+void ConvMonthTraff(std::string value, STG::UserStatOpt & res)

 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
 if (traff.size() != DIR_NUM)
 {
 value.erase(std::remove(value.begin(), value.end(), ' '), value.end());
 std::vector<TRAFF> traff(Split<std::vector<TRAFF> >(value, ',', ConvTraff));
 if (traff.size() != DIR_NUM)

-    throw SGCONF::ACTION::ERROR("There should be prcisely " + x2str(DIR_NUM) + " records of month traffic.");
+    throw SGCONF::ACTION::ERROR("There should be prcisely " + std::to_string(DIR_NUM) + " records of month traffic.");

 for (size_t i = 0; i < DIR_NUM; ++i)
     {
     res.monthUp[i] = traff[i].up;
 for (size_t i = 0; i < DIR_NUM; ++i)
     {
     res.monthUp[i] = traff[i].up;


@@ -210,9 +213,9 @@ for (size_t i = 0; i < DIR_NUM; ++i)
     }
 }
 
     }
 }
 

-void ConvCashInfo(const std::string & value, RESETABLE<CASH_INFO> & res)
+void ConvCashInfo(const std::string & value, std::optional<STG::CashInfo> & res)

 {
 {

-CASH_INFO info;
+STG::CashInfo info;

 size_t pos = value.find_first_of(':');
 if (pos == std::string::npos)
     {
 size_t pos = value.find_first_of(':');
 if (pos == std::string::npos)
     {


@@ -242,7 +245,7 @@ std::cout << "Success.\n";
 
 void GetUsersCallback(bool result,
                       const std::string & reason,
 
 void GetUsersCallback(bool result,
                       const std::string & reason,

-                      const std::vector<STG::GET_USER::INFO> & info,
+                      const std::vector<STG::GetUser::Info> & info,

                       void * /*data*/)
 {
 if (!result)
                       void * /*data*/)
 {
 if (!result)


@@ -257,7 +260,7 @@ for (size_t i = 0; i < info.size(); ++i)
 
 void GetUserCallback(bool result,
                      const std::string & reason,
 
 void GetUserCallback(bool result,
                      const std::string & reason,

-                     const STG::GET_USER::INFO & info,
+                     const STG::GetUser::Info & info,

                      void * /*data*/)
 {
 if (!result)
                      void * /*data*/)
 {
 if (!result)


@@ -287,46 +290,28 @@ bool GetUsersFunction(const SGCONF::CONFIG & config,
                       const std::string & /*arg*/,
                       const std::map<std::string, std::string> & /*options*/)
 {
                       const std::string & /*arg*/,
                       const std::map<std::string, std::string> & /*options*/)
 {

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.GetUsers(GetUsersCallback, NULL) == STG::st_ok;
+return makeProto(config).GetUsers(GetUsersCallback, NULL) == STG::st_ok;

 }
 
 bool GetUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & /*options*/)
 {
 }
 
 bool GetUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & /*options*/)
 {

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.GetUser(arg, GetUserCallback, NULL) == STG::st_ok;
+return makeProto(config).GetUser(arg, GetUserCallback, NULL) == STG::st_ok;

 }
 
 bool DelUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & /*options*/)
 {
 }
 
 bool DelUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & /*options*/)
 {

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.DelUser(arg, SimpleCallback, NULL) == STG::st_ok;
+return makeProto(config).DelUser(arg, SimpleCallback, NULL) == STG::st_ok;

 }
 
 bool AddUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & options)
 {
 }
 
 bool AddUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & options)
 {

-USER_CONF_RES conf;
+STG::UserConfOpt conf;

 SGCONF::MaybeSet(options, "password", conf.password);
 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);
 SGCONF::MaybeSet(options, "password", conf.password);
 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);


@@ -346,25 +331,19 @@ SGCONF::MaybeSet(options, "next-tariff", conf.nextTariff);
 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);
 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);

-USER_STAT_RES stat;
+STG::UserStatOpt stat;

 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
 SGCONF::MaybeSet(options, "free", stat.freeMb);
 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);
 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
 SGCONF::MaybeSet(options, "free", stat.freeMb);
 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.AddUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;
+return makeProto(config).AddUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;

 }
 
 bool ChgUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & options)
 {
 }
 
 bool ChgUserFunction(const SGCONF::CONFIG & config,
                      const std::string & arg,
                      const std::map<std::string, std::string> & options)
 {

-USER_CONF_RES conf;
+STG::UserConfOpt conf;

 SGCONF::MaybeSet(options, "password", conf.password);
 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);
 SGCONF::MaybeSet(options, "password", conf.password);
 SGCONF::MaybeSet(options, "passive", conf.passive, ConvBool);
 SGCONF::MaybeSet(options, "disabled", conf.disabled, ConvBool);


@@ -384,19 +363,13 @@ SGCONF::MaybeSet(options, "next-tariff", conf.nextTariff);
 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);
 SGCONF::MaybeSet(options, "user-data", conf.userdata, ConvStringList);
 SGCONF::MaybeSet(options, "credit-expire", conf.creditExpire, ConvCreditExpire);
 SGCONF::MaybeSet(options, "ips", conf.ips, ConvIPs);

-USER_STAT_RES stat;
+STG::UserStatOpt stat;

 SGCONF::MaybeSet(options, "cash-add", stat.cashAdd, ConvCashInfo);
 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
 SGCONF::MaybeSet(options, "free", stat.freeMb);
 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);
 SGCONF::MaybeSet(options, "cash-add", stat.cashAdd, ConvCashInfo);
 SGCONF::MaybeSet(options, "cash-set", stat.cashSet, ConvCashInfo);
 SGCONF::MaybeSet(options, "free", stat.freeMb);
 SGCONF::MaybeSet(options, "session-traffic", stat, ConvSessionTraff);
 SGCONF::MaybeSet(options, "month-traffic", stat, ConvMonthTraff);

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.ChgUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;
+return makeProto(config).ChgUser(arg, conf, stat, SimpleCallback, NULL) == STG::st_ok;

 }
 
 bool CheckUserFunction(const SGCONF::CONFIG & config,
 }
 
 bool CheckUserFunction(const SGCONF::CONFIG & config,


@@ -406,13 +379,7 @@ bool CheckUserFunction(const SGCONF::CONFIG & config,
 std::map<std::string, std::string>::const_iterator it(options.find("password"));
 if (it == options.end())
     throw SGCONF::ACTION::ERROR("Password is not specified.");
 std::map<std::string, std::string>::const_iterator it(options.find("password"));
 if (it == options.end())
     throw SGCONF::ACTION::ERROR("Password is not specified.");

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.CheckUser(arg, it->second, SimpleCallback, NULL) == STG::st_ok;
+return makeProto(config).CheckUser(arg, it->second, SimpleCallback, NULL) == STG::st_ok;

 }
 
 bool SendMessageFunction(const SGCONF::CONFIG & config,
 }
 
 bool SendMessageFunction(const SGCONF::CONFIG & config,


@@ -430,26 +397,14 @@ it = options.find("text");
 if (it == options.end())
     throw SGCONF::ACTION::ERROR("Message text is not specified.");
 std::string text = it->second;
 if (it == options.end())
     throw SGCONF::ACTION::ERROR("Message text is not specified.");
 std::string text = it->second;

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.SendMessage(logins, text, SimpleCallback, NULL) == STG::st_ok;
+return makeProto(config).SendMessage(logins, text, SimpleCallback, NULL) == STG::st_ok;

 }
 
 bool AuthByFunction(const SGCONF::CONFIG & config,
                     const std::string & arg,
                     const std::map<std::string, std::string> & /*options*/)
 {
 }
 
 bool AuthByFunction(const SGCONF::CONFIG & config,
                     const std::string & arg,
                     const std::map<std::string, std::string> & /*options*/)
 {

-STG::SERVCONF proto(config.server.data(),
-                    config.port.data(),
-                    config.localAddress.data(),
-                    config.localPort.data(),
-                    config.userName.data(),
-                    config.userPass.data());
-return proto.AuthBy(arg, AuthByCallback, NULL) == STG::st_ok;
+return makeProto(config).AuthBy(arg, AuthByCallback, NULL) == STG::st_ok;

 }
 
 } // namespace anonymous
 }
 
 } // namespace anonymous