projects/stargazer/plugins/configuration/sgconfig/parser.h

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  */
  20
  21 #ifndef PARSER_H
  22 #define PARSER_H
  23
  24 #include "stg/message.h"
  25 #include "stg/tariff_conf.h"
  26 #include "stg/resetable.h"
  27 #include "stg/const.h"
  28
  29 #include <string>
  30 #include <vector>
  31
  32 class TARIFFS;
  33 class SETTINGS;
  34 class STORE;
  35 class ADMINS;
  36 class ADMIN;
  37 class USERS;
  38 class USER;
  39 class USER_STAT_RES;
  40 class USER_CONF_RES;
  41
  42 //-----------------------------------------------------------------------------
  43 class BASE_PARSER {
  44 public:
  45     BASE_PARSER()
  46         : strError(),
  47           admins(NULL),
  48           users(NULL),
  49           tariffs(NULL),
  50           store(NULL),
  51           settings(NULL),
  52           currAdmin(NULL),
  53           depth(0)
  54     {}
  55     virtual ~BASE_PARSER() {}
  56     virtual int ParseStart(void *data, const char *el, const char **attr) = 0;
  57     virtual int ParseEnd(void *data, const char *el) = 0;
  58     virtual void Reset() { answer.clear(); depth = 0; }
  59
  60     virtual void SetUsers(USERS * u) { users = u; }
  61     virtual void SetAdmins(ADMINS * a) { admins = a; }
  62     virtual void SetTariffs(TARIFFS * t) { tariffs = t; }
  63     virtual void SetStore(STORE * s) { store = s; }
  64     virtual void SetStgSettings(const SETTINGS * s) { settings = s; }
  65
  66     void SetCurrAdmin(ADMIN & cua) { currAdmin = &cua; }
  67     const std::string & GetStrError() const { return strError; }
  68     const std::string & GetAnswer() const { return answer; }
  69
  70 protected:
  71     BASE_PARSER(const BASE_PARSER & rvalue);
  72     BASE_PARSER & operator=(const BASE_PARSER & rvalue);
  73
  74     std::string      strError;
  75     ADMINS *         admins;
  76     USERS *          users;
  77     TARIFFS *        tariffs;
  78     STORE *          store;
  79     const SETTINGS * settings;
  80     ADMIN          * currAdmin;
  81     int              depth;
  82     std::string      answer;
  83 };
  84 //-----------------------------------------------------------------------------
  85 class PARSER_GET_ADMINS: public BASE_PARSER {
  86 public:
  87     int ParseStart(void *data, const char *el, const char **attr);
  88     int ParseEnd(void *data, const char *el);
  89     void CreateAnswer();
  90 };
  91 //-----------------------------------------------------------------------------
  92 class PARSER_ADD_ADMIN: public BASE_PARSER {
  93 public:
  94         PARSER_ADD_ADMIN() : BASE_PARSER(), adminToAdd() {}
  95     int ParseStart(void *data, const char *el, const char **attr);
  96     int ParseEnd(void *data, const char *el);
  97     void CreateAnswer();
  98 private:
  99     std::string adminToAdd;
 100 };
 101 //-----------------------------------------------------------------------------
 102 class PARSER_DEL_ADMIN: public BASE_PARSER {
 103 public:
 104         PARSER_DEL_ADMIN() : BASE_PARSER(), adminToDel() {}
 105     int ParseStart(void *data, const char *el, const char **attr);
 106     int ParseEnd(void *data, const char *el);
 107     void CreateAnswer();
 108 private:
 109     int CheckAttr(const char **attr);
 110     std::string adminToDel;
 111 };
 112 //-----------------------------------------------------------------------------
 113 class PARSER_CHG_ADMIN: public BASE_PARSER {
 114 public:
 115         PARSER_CHG_ADMIN() : BASE_PARSER(), login(), password(), privAsString() {}
 116     int ParseStart(void *data, const char *el, const char **attr);
 117     int ParseEnd(void *data, const char *el);
 118     void CreateAnswer();
 119 private:
 120     RESETABLE<std::string> login;
 121     RESETABLE<std::string> password;
 122     RESETABLE<std::string> privAsString;
 123 };
 124 //-----------------------------------------------------------------------------
 125 class PARSER_GET_SERVER_INFO: public BASE_PARSER {
 126 public:
 127     int ParseStart(void *data, const char *el, const char **attr);
 128     int ParseEnd(void *data, const char *el);
 129     void CreateAnswer();
 130 };
 131 //-----------------------------------------------------------------------------
 132 class PARSER_GET_USER: public BASE_PARSER {
 133 public:
 134         PARSER_GET_USER() : BASE_PARSER(), login() {}
 135         ~PARSER_GET_USER() {}
 136     int ParseStart(void *data, const char *el, const char **attr);
 137     int ParseEnd(void *data, const char *el);
 138     void CreateAnswer();
 139 private:
 140     std::string login;
 141 };
 142 //-----------------------------------------------------------------------------
 143 class PARSER_GET_USERS: public BASE_PARSER {
 144 public:
 145         PARSER_GET_USERS() : BASE_PARSER(), lastUserUpdateTime(0), lastUpdateFound(false) {}
 146     int ParseStart(void *data, const char *el, const char **attr);
 147     int ParseEnd(void *data, const char *el);
 148     void CreateAnswer();
 149 private:
 150     time_t lastUserUpdateTime;
 151     bool lastUpdateFound;
 152 };
 153 //-----------------------------------------------------------------------------
 154 class PARSER_GET_TARIFFS: public BASE_PARSER {
 155 public:
 156     int ParseStart(void *data, const char *el, const char **attr);
 157     int ParseEnd(void *data, const char *el);
 158     void CreateAnswer();
 159 };
 160 //-----------------------------------------------------------------------------
 161 class PARSER_ADD_TARIFF: public BASE_PARSER {
 162 public:
 163         PARSER_ADD_TARIFF() : BASE_PARSER(), tariffToAdd() {}
 164     int ParseStart(void *data, const char *el, const char **attr);
 165     int ParseEnd(void *data, const char *el);
 166     void CreateAnswer();
 167 private:
 168     std::string tariffToAdd;
 169 };
 170 //-----------------------------------------------------------------------------
 171 class PARSER_DEL_TARIFF: public BASE_PARSER {
 172 public:
 173         PARSER_DEL_TARIFF() : BASE_PARSER(), tariffToDel() {}
 174     int ParseStart(void *data, const char *el, const char **attr);
 175     int ParseEnd(void *data, const char *el);
 176     void CreateAnswer();
 177 private:
 178     std::string tariffToDel;
 179 };
 180 //-----------------------------------------------------------------------------
 181 class PARSER_CHG_TARIFF: public BASE_PARSER {
 182 public:
 183         PARSER_CHG_TARIFF() : BASE_PARSER(), td() {}
 184     int ParseStart(void *data, const char *el, const char **attr);
 185     int ParseEnd(void *data, const char *el);
 186     void CreateAnswer();
 187 private:
 188     int ParseSlashedIntParams(int paramsNum, const std::string & s, int * params);
 189     int ParseSlashedDoubleParams(int paramsNum, const std::string & s, double * params);
 190     int CheckTariffData();
 191     int AplayChanges();
 192
 193     TARIFF_DATA_RES td;
 194 };
 195 //-----------------------------------------------------------------------------/
 196 class PARSER_ADD_USER: public BASE_PARSER {
 197 public:
 198         PARSER_ADD_USER() : BASE_PARSER(), login() {}
 199         ~PARSER_ADD_USER() {}
 200     int ParseStart(void *data, const char *el, const char **attr);
 201     int ParseEnd(void *data, const char *el);
 202     void CreateAnswer();
 203     void Reset();
 204 private:
 205     int CheckUserData();
 206     std::string login;
 207 };
 208 //-----------------------------------------------------------------------------
 209 class PARSER_CHG_USER: public BASE_PARSER {
 210 public:
 211         PARSER_CHG_USER();
 212         ~PARSER_CHG_USER();
 213     int ParseStart(void *data, const char *el, const char **attr);
 214     int ParseEnd(void *data, const char *el);
 215     void CreateAnswer();
 216     void Reset();
 217 private:
 218     PARSER_CHG_USER(const PARSER_CHG_USER & rvalue);
 219     PARSER_CHG_USER & operator=(const PARSER_CHG_USER & rvalue);
 220
 221     std::string EncChar2String(const char *);
 222     int AplayChanges();
 223
 224     USER_STAT_RES * usr;
 225     USER_CONF_RES * ucr;
 226     RESETABLE<uint64_t> * upr;
 227     RESETABLE<uint64_t> * downr;
 228     std::string cashMsg;
 229     std::string login;
 230     bool cashMustBeAdded;
 231     int res;
 232 };
 233 //-----------------------------------------------------------------------------
 234 class PARSER_DEL_USER: public BASE_PARSER {
 235 public:
 236         PARSER_DEL_USER() : BASE_PARSER(), res(0), u(NULL) {}
 237     int ParseStart(void *data, const char *el, const char **attr);
 238     int ParseEnd(void *data, const char *el);
 239     void CreateAnswer();
 240
 241 private:
 242     PARSER_DEL_USER(const PARSER_DEL_USER & rvalue);
 243     PARSER_DEL_USER & operator=(const PARSER_DEL_USER & rvalue);
 244
 245     int res;
 246     USER * u;
 247 };
 248 //-----------------------------------------------------------------------------
 249 class PARSER_CHECK_USER: public BASE_PARSER {
 250 public:
 251         PARSER_CHECK_USER() : BASE_PARSER(), result(false) {}
 252     int ParseStart(void *data, const char *el, const char **attr);
 253     int ParseEnd(void *data, const char *el);
 254     void CreateAnswer();
 255 private:
 256     bool result;
 257 };
 258 //-----------------------------------------------------------------------------
 259 class PARSER_SEND_MESSAGE: public BASE_PARSER {
 260 public:
 261         PARSER_SEND_MESSAGE() : BASE_PARSER(), logins(), result(0), msg(), u(NULL) {}
 262     int ParseStart(void *data, const char *el, const char **attr);
 263     int ParseEnd(void *data, const char *el);
 264     void CreateAnswer();
 265 private:
 266     PARSER_SEND_MESSAGE(const PARSER_SEND_MESSAGE & rvalue);
 267     PARSER_SEND_MESSAGE & operator=(const PARSER_SEND_MESSAGE & rvalue);
 268
 269     int ParseLogins(const char * logins);
 270
 271     enum {res_ok, res_params_error, res_unknown};
 272     std::vector<std::string> logins;
 273     int result;
 274     STG_MSG msg;
 275     USER * u;
 276 };
 277 //-----------------------------------------------------------------------------
 278 #endif //PARSER_H