projects/stargazer/plugins/other/smux/sensors.h

   1 #ifndef __SENSORS_H__
   2 #define __SENSORS_H__
   3
   4 #include <map>
   5
   6 #include "stg/users.h"
   7 #include "stg/user.h"
   8 #include "stg/tariffs.h"
   9 #include "stg/admins.h"
  10 #include "stg/services.h"
  11 #include "stg/corporations.h"
  12 #include "stg/traffcounter.h"
  13 #include "stg/user_property.h"
  14
  15 #include "stg/ObjectSyntax.h"
  16
  17 #include "value2os.h"
  18 #include "types.h"
  19
  20 class Sensor {
  21     public:
  22         virtual ~Sensor() = default;
  23         virtual bool GetValue(ObjectSyntax_t * objectSyntax) const = 0;
  24 #ifdef DEBUG
  25         virtual std::string ToString() const = 0;
  26 #endif
  27 };
  28
  29 typedef std::map<OID, Sensor *> Sensors;
  30
  31 class TotalUsersSensor : public Sensor {
  32     public:
  33         explicit TotalUsersSensor(const STG::Users & u) : users(u) {}
  34
  35         bool GetValue(ObjectSyntax_t * objectSyntax) const override
  36         {
  37         ValueToOS(users.Count(), objectSyntax);
  38         return true;
  39         }
  40
  41 #ifdef DEBUG
  42         std::string ToString() const override
  43         { std::string res; std::to_string(users.Count(), res); return res; }
  44 #endif
  45
  46     private:
  47         const STG::Users & users;
  48 };
  49
  50 class UsersSensor : public Sensor {
  51     public:
  52         explicit UsersSensor(STG::Users & u) : users(u) {}
  53
  54         bool GetValue(ObjectSyntax_t * objectSyntax) const override;
  55 #ifdef DEBUG
  56         std::string ToString() const override;
  57 #endif
  58
  59     private:
  60         STG::Users & users;
  61
  62         virtual bool UserPredicate(STG::User* userPtr) const = 0;
  63 };
  64
  65 class ConnectedUsersSensor : public UsersSensor {
  66     public:
  67         explicit ConnectedUsersSensor(STG::Users & u) : UsersSensor(u) {}
  68
  69     private:
  70         bool UserPredicate(STG::User* userPtr) const override
  71         { return userPtr->GetConnected(); }
  72 };
  73
  74 class AuthorizedUsersSensor : public UsersSensor {
  75     public:
  76         explicit AuthorizedUsersSensor(STG::Users & u) : UsersSensor(u) {}
  77
  78     private:
  79         bool UserPredicate(STG::User* userPtr) const override
  80         { return userPtr->GetAuthorized(); }
  81 };
  82
  83 class AlwaysOnlineUsersSensor : public UsersSensor {
  84     public:
  85         explicit AlwaysOnlineUsersSensor(STG::Users & u) : UsersSensor(u) {}
  86
  87     private:
  88         bool UserPredicate(STG::User* userPtr) const override
  89         { return userPtr->GetProperties().alwaysOnline; }
  90 };
  91
  92 class NoCashUsersSensor : public UsersSensor {
  93     public:
  94         explicit NoCashUsersSensor(STG::Users & u) : UsersSensor(u) {}
  95
  96     private:
  97         bool UserPredicate(STG::User* userPtr) const override
  98         { return userPtr->GetProperties().cash < 0; }
  99 };
 100
 101 class DisabledDetailStatsUsersSensor : public UsersSensor {
 102     public:
 103         explicit DisabledDetailStatsUsersSensor(STG::Users & u) : UsersSensor(u) {}
 104
 105     private:
 106         bool UserPredicate(STG::User* userPtr) const override
 107         { return userPtr->GetProperties().disabledDetailStat; }
 108 };
 109
 110 class DisabledUsersSensor : public UsersSensor {
 111     public:
 112         explicit DisabledUsersSensor(STG::Users & u) : UsersSensor(u) {}
 113
 114     private:
 115         bool UserPredicate(STG::User* userPtr) const override
 116         { return userPtr->GetProperties().disabled; }
 117 };
 118
 119 class PassiveUsersSensor : public UsersSensor {
 120     public:
 121         explicit PassiveUsersSensor(STG::Users & u) : UsersSensor(u) {}
 122
 123     private:
 124         bool UserPredicate(STG::User* userPtr) const override
 125         { return userPtr->GetProperties().passive; }
 126 };
 127
 128 class CreditUsersSensor : public UsersSensor {
 129     public:
 130         explicit CreditUsersSensor(STG::Users & u) : UsersSensor(u) {}
 131
 132     private:
 133         bool UserPredicate(STG::User* userPtr) const override
 134         { return userPtr->GetProperties().credit > 0; }
 135 };
 136
 137 class FreeMbUsersSensor : public UsersSensor {
 138     public:
 139         explicit FreeMbUsersSensor(STG::Users & u) : UsersSensor(u) {}
 140
 141     private:
 142         bool UserPredicate(STG::User* userPtr) const override
 143         { return userPtr->GetProperties().freeMb > 0; }
 144 };
 145
 146 class TariffChangeUsersSensor : public UsersSensor {
 147     public:
 148         explicit TariffChangeUsersSensor(STG::Users & u) : UsersSensor(u) {}
 149
 150     private:
 151         bool UserPredicate(STG::User* userPtr) const override
 152         { return !userPtr->GetProperties().nextTariff.ConstData().empty(); }
 153 };
 154
 155 class ActiveUsersSensor : public UsersSensor {
 156     public:
 157         explicit ActiveUsersSensor(STG::Users & u) : UsersSensor(u) {}
 158
 159     private:
 160         bool UserPredicate(STG::User* userPtr) const override;
 161 };
 162
 163 class TotalTariffsSensor : public Sensor {
 164     public:
 165         explicit TotalTariffsSensor(const STG::Tariffs & t) : tariffs(t) {}
 166
 167         bool GetValue(ObjectSyntax_t * objectSyntax) const override
 168         {
 169         ValueToOS(tariffs.Count(), objectSyntax);
 170         return true;
 171         }
 172
 173 #ifdef DEBUG
 174         std::string ToString() const override
 175         { std::string res; std::to_string(tariffs.Count(), res); return res; }
 176 #endif
 177
 178     private:
 179         const STG::Tariffs & tariffs;
 180 };
 181
 182 class TotalAdminsSensor : public Sensor {
 183     public:
 184         explicit TotalAdminsSensor(const STG::Admins & a) : admins(a) {}
 185
 186         bool GetValue(ObjectSyntax_t * objectSyntax) const override
 187         {
 188         ValueToOS(admins.count(), objectSyntax);
 189         return true;
 190         }
 191
 192 #ifdef DEBUG
 193         std::string ToString() const override
 194         { std::string res; std::to_string(admins.Count(), res); return res; }
 195 #endif
 196
 197     private:
 198         const STG::Admins & admins;
 199 };
 200
 201 class TotalServicesSensor : public Sensor {
 202     public:
 203         explicit TotalServicesSensor(const STG::Services & s) : services(s) {}
 204
 205         bool GetValue(ObjectSyntax_t * objectSyntax) const override
 206         {
 207         ValueToOS(services.Count(), objectSyntax);
 208         return true;
 209         }
 210
 211 #ifdef DEBUG
 212         std::string ToString() const override
 213         { std::string res; std::to_string(services.Count(), res); return res; }
 214 #endif
 215
 216     private:
 217         const STG::Services & services;
 218 };
 219
 220 class TotalCorporationsSensor : public Sensor {
 221     public:
 222         explicit TotalCorporationsSensor(const STG::Corporations & c) : corporations(c) {}
 223
 224         bool GetValue(ObjectSyntax_t * objectSyntax) const override
 225         {
 226         ValueToOS(corporations.Count(), objectSyntax);
 227         return true;
 228         }
 229
 230 #ifdef DEBUG
 231         std::string ToString() const override
 232         { std::string res; std::to_string(corporations.Count(), res); return res; }
 233 #endif
 234
 235     private:
 236         const STG::Corporations & corporations;
 237 };
 238
 239 class TotalRulesSensor : public Sensor {
 240     public:
 241         explicit TotalRulesSensor(const STG::TraffCounter & t) : traffcounter(t) {}
 242
 243         bool GetValue(ObjectSyntax_t * objectSyntax) const override
 244         {
 245         ValueToOS(traffcounter.rulesCount(), objectSyntax);
 246         return true;
 247         }
 248
 249 #ifdef DEBUG
 250         std::string ToString() const override
 251         { std::string res; std::to_string(traffcounter.rulesCount(), res); return res; }
 252 #endif
 253
 254     private:
 255         const STG::TraffCounter & traffcounter;
 256 };
 257
 258 template <typename T>
 259 class ConstSensor : public Sensor {
 260     public:
 261         explicit ConstSensor(const T & v) : value(v) {}
 262
 263         bool GetValue(ObjectSyntax * objectSyntax) const override
 264         { return ValueToOS(value, objectSyntax); }
 265
 266 #ifdef DEBUG
 267         std::string ToString() const override
 268         { std::string res; std::to_string(value, res); return res; }
 269 #endif
 270
 271     private:
 272         T value;
 273 };
 274
 275 #ifdef DEBUG
 276 template <>
 277 inline
 278 std::string ConstSensor<std::string>::ToString() const
 279 {
 280 return value;
 281 }
 282 #endif
 283
 284 #endif