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

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