eis/eqpalg/utility/eqp_stat.cc

#include <eqpalg/table_struct/fv_result_latest.h>
#include <eqpalg/table_struct/t_rule_cfg.h>
#include <eqpalg/table_struct/t_rule_result.h>
#include <eqpalg/table_struct/t_rule_sample_1d.h>
#include <eqpalg/utility/eqp_stat.h>
#include <mix_cc/sql.h>
#include <mix_cc/sql/database/db2_t.h>
#include <mutex>
/*mapRuleStat 单例*/
namespace {
std::mutex up_mutex{};
RuleStatShm::MapRuleStat mapRuleStat;
RuleStatShm::RuleStat rule_stat;
};

EqpStat::EqpStat() {
  logger_ = std::make_unique<LOG>("EqpStat");
  logger_->Debug() << "EqpStat::EqpStat()" << endl;
}
EqpStat::~EqpStat() { logger_->Info() << "EqpStat::~EqpStat()" << std::endl; }

void EqpStat::get_cfg_rules() {
  T_RULE_CFG t_rule_cfg;
  auto sql_statement = select(t_rule_cfg.ruleId()).from(t_rule_cfg);
  auto rule_list_maybe = mix_cc::sql::exec<db2_t, T_RULE_CFG>(sql_statement);
  if (rule_list_maybe.is_just()) {
    auto rule_list = rule_list_maybe.unsafe_get_just();
    logger_->Debug() << "cfg_rules_ size:" << cfg_rules_.size() << endl;
    cfg_rules_.clear();
    if (!rule_list.empty()) {
      int num = rule_list.size();
      logger_->Debug() << "rules num:" << num << endl;
      for (int i = 0; i < num; i++) {
        cfg_rules_.push_back(rule_list[i].ruleId);
      }
    } else {
      logger_->Info() << "no rule in database cfg!" << std::endl;
    }
  } else {
    logger_->Error() << "EqpStat::get_cfg_rules()"
                     << ", select查询异常！" << std::endl;
  }
  auto res = this->stat_find_no_ruleid();
  if (!res.empty()) {
    for (auto item : res) {
      this->delete_stat(item);
    }
  }
}

bool EqpStat::update_dynamic(std::string ruleid,
                             const RuleStatShm::RuleStat &rule_stat) {
  try {
    return mapRuleStat.update_dynamic(ruleid, rule_stat, true);
  } catch (const std::exception &e) {
    logger_->Error() << "ruleid:" << ruleid << "EqpStat::update_dynamic ERROR!"
                     << e.what() << std::endl;
    return false;
  }
}

bool EqpStat::update_static(std::string ruleid, bool is_times) {
  try {
    std::lock_guard<std::mutex> guard(up_mutex);
    rule_stat.alarm_times = select_alarm_by_ruleid(ruleid);
    rule_stat.dev_coder = select_dev_coder_by_ruleid(ruleid);
    rule_stat.running_time = is_times ? select_running_by_ruleid(ruleid) : 0;
    rule_stat.shear_times = is_times ? select_times_by_ruleid(ruleid) : 0;
    rule_stat.last_alarm_time = select_latest_alarm_by_ruleid(ruleid);
    mapRuleStat.update_dynamic(ruleid, rule_stat, false);
    return true;
  } catch (const std::exception &e) {
    logger_->Error() << "EqpStat::update_static() ERROR!" << e.what()
                     << std::endl;
    return false;
  }
}

bool EqpStat::update_static() {
  try {
    bool res = true;
    for (auto ruleid : cfg_rules_) {
      res = res & this->update_static(ruleid, true);
    }
    return res;
  } catch (const std::exception &e) {
    logger_->Error() << "EqpStat::update_static() ERROR!" << e.what()
                     << std::endl;
    return false;
  }
}

bool EqpStat::update_stat(std::string ruleid,
                          const RuleStatShm::RuleStat &rule_stat) {
  try {
    return mapRuleStat.update(ruleid, rule_stat);
  } catch (const std::exception &e) {
    logger_->Error() << "ruleid:" << ruleid << "EqpStat::update_stat ERROR!"
                     << e.what() << std::endl;
    return false;
  }
}

bool EqpStat::add_stat_values(std::string ruleid, const double &rule_stat) {
  try {
    return mapRuleStat.add_stat_value(ruleid, rule_stat);
  } catch (const std::exception &e) {
    logger_->Error() << "ruleid:" << ruleid << "EqpStat::add_stat_values ERROR!"
                     << e.what() << std::endl;
    return false;
  }
}
bool EqpStat::get_stat_values(std::string ruleid,
                              RuleStatShm::RuleStat &rule_stat) {
  try {
    return mapRuleStat.get_stat_value(ruleid, rule_stat);
  } catch (const std::exception &e) {
    logger_->Error() << "ruleid:" << ruleid << "EqpStat::get_stat_values ERROR!"
                     << e.what() << std::endl;
    return false;
  }
}

bool EqpStat::delete_stat(std::string ruleid) {
  try {
    return mapRuleStat.delete_data(ruleid);
  } catch (const std::exception &e) {
    logger_->Error() << "ruleid:" << ruleid << "EqpStat::delete_stat ERROR!"
                     << e.what() << std::endl;
    return false;
  }
}

std::string EqpStat::get_stat_json() { return mapRuleStat.GetDataJson(); }

std::vector<std::string> EqpStat::stat_find_no_ruleid() {
  std::vector<std::string> res{};
  res = mapRuleStat.find_no_rule_id(cfg_rules_);
  return res;
}

int EqpStat::get_stat_size() { return mapRuleStat.size(); }

double EqpStat::select_running_by_ruleid(string ruleid) {
  T_RULE_SAMPLE_1D trs1a;
  auto query_list_maybe = exec<db2_t, T_RULE_SAMPLE_1D>(
      select(trs1a.X1()).from(trs1a).where(trs1a.RuleId() == ruleid));
  if (query_list_maybe.is_just()) {
    auto &query_list = query_list_maybe.unsafe_get_just();
    if (query_list.empty()) {
      return 0;
    }
    return query_list[0].X1;
  } else {
    this->logger_->Debug() << "!query_list_maybe.is_just() ruleid:" << ruleid
                           << endl;
    return 0;
  }
}
unsigned long EqpStat::select_times_by_ruleid(string ruleid) {
  T_RULE_SAMPLE_1D trs1a;
  auto query_list_maybe = exec<db2_t, T_RULE_SAMPLE_1D>(
      select(trs1a.Count()).from(trs1a).where(trs1a.RuleId() == ruleid));
  if (query_list_maybe.is_just()) {
    auto &query_list = query_list_maybe.unsafe_get_just();
    if (query_list.empty()) {
      return 0;
    }
    return query_list[0].Count;
  } else {
    return 0;
  }
}

string EqpStat::get_ruleid_json() {
  mix_cc::json js1;
  js1["ruleid"] = this->cfg_rules_;
  return js1.dump();
}

int EqpStat::select_alarm_by_ruleid(string ruleid) {
  T_RULE_RESULT trr;
  auto query_list_maybe = exec<db2_t, T_RULE_CFG>(
      select(trr.ruleId())
          .from(trr)
          .where(trr.ruleId() == ruleid, trr.dealResult() == 0));
  if (query_list_maybe.is_just()) {
    auto &query_list = query_list_maybe.unsafe_get_just();
    return query_list.size();
  } else {
    logger_->Error() << "ruleid:" << ruleid << "select_alarm_by_ruleid ERROR!"
                     << ",location:" << BOOST_CURRENT_LOCATION << endl;
    return 0;
  }
}

std::string EqpStat::select_dev_coder_by_ruleid(string ruleid) {
  T_RULE_CFG t_rule_cfg;
  auto sql_statement = select(t_rule_cfg.eqpid())
                           .from(t_rule_cfg)
                           .where(t_rule_cfg.ruleId() == ruleid);
  auto query_list_maybe = mix_cc::sql::exec<db2_t, T_RULE_CFG>(sql_statement);
  if (query_list_maybe.is_just()) {
    auto &query_list = query_list_maybe.unsafe_get_just();
    return query_list[0].eqpid;
  } else {
    logger_->Error() << "规则：" << ruleid << ",九位码查询异常！" << std::endl;
    return "";
  }
}

string EqpStat::select_latest_alarm_by_ruleid(string ruleid) {
  try {
    FV_RESULT_LATEST fvrl;

    auto query_list_maybe = exec<db2_t, FV_RESULT_LATEST>(
        select(fvrl.alarmtime())
            .from(fvrl)
            .where(fvrl.ruleId() == ruleid, fvrl.rank() == 1));
    if (query_list_maybe.is_just()) {
      auto &query_list = query_list_maybe.unsafe_get_just();
      if (query_list.size() == 0) {
        return "无报警";
      }
      string quered_time =
          mix_cc::mix_time_t(query_list[0].alarmtime).to_formatted_time();
      return quered_time;

    } else {
      return "无报警";
    }
  } catch (std::exception &e) {
    this->logger_->Error() << "查询最新报警时间，规则：" << ruleid << e.what()
                           << std::endl;
  }
  return "无报警";
}

void EqpStat::init() {
  if (!this->cfg_flag) {
    get_cfg_rules();
    logger_->Debug() << "EqpStat::init()---get_cfg_rules()---" << endl;
    update_static();
    logger_->Debug() << "EqpStat::init()---update_static()---" << endl;
    this->cfg_flag = true;
    last_update_static_time_ = chrono::system_clock::now();
  }
  if (chrono::system_clock::now() - last_update_static_time_ >
      chrono::minutes(5)) {
    this->cfg_flag = false;
  }
}