eis/eqpalg/.do_not_use/otheralg/table_static.cpp

#include <dlib/serialize.h>
#include <dlib/statistics.h>
#include <eqpalg/algs/table_static.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 <mix_cc/sql/database/db2_t.h>
// #include <filesystem>
// #include <fstream>
TableStatic::TableStatic(const string name, const mix_cc::json& rule_json,
                         const string ruleId)
    : AlgBase(name, rule_json, ruleId) {
  logger_.reset(new LOG("TableStatic:" + rule_name_, AUTO_CATCH_PID));
}
TableStatic::~TableStatic() {}

void TableStatic::init_config() {
  is_usable_ = false;
  this->reload_config_tag();
  int d_min = rule_json_.at("interval").at("time").at(1).get<int64_t>();
  if (d_min < 5) {
    d_min = 5;
  }
  this->delay_time_proc_ = minutes(d_min);
  this->delay_time_ = milliseconds(1000);

  last_run_start_time_ = system_clock::now() - this->delay_time_;
  last_run_start_time_proc_ = system_clock::now() - this->delay_time_proc_;
  /// table_name获取
  this->table_name_ =
      rule_json_.at("table_name").at("name").at(1).get<string>();
  this->table_key_ = rule_json_.at("table_key").at("name").at(1).get<string>();
}

int TableStatic::init() {
  try {
    this->init_config();
    ///标记 group 后缀
    this->running_flag_ =
        rule_json_.at("running_static").at("time").at(1).get<int>();
    this->logger_->Debug() << "this->running_flag_:" << this->running_flag_
                           << endl;
    if (this->running_flag_ > 0) {
      //运行时间 或 剪切次数
      this->mp_table_data_[0] = TableData();
      if (this->running_flag_ == 1) {
        this->mp_table_data_[0].group_name_ = this->table_name_ + "-运行时间";
      } else {
        this->mp_table_data_[0].group_name_ = this->table_name_ + "-次数";
      }
    }
    this->fault_flag_ =
        rule_json_.at("fault_static").at("times").at(1).get<int>();
    if (this->fault_flag_ > 0) {
      //重故障 或仅故障
      if (this->running_flag_ == 0) {
        this->main_flag_ = 1;
      }
      this->mp_table_data_[1] = TableData();
    }
    this->alrm_flag_ =
        rule_json_.at("alarm_static").at("times").at(1).get<int>();
    if (this->alrm_flag_ > 0) {
      //报警 轻故障
      this->mp_table_data_[2] = TableData();
    }
    if (this->fault_flag_ && this->alrm_flag_) {
      this->mp_table_data_[1].group_name_ = this->table_name_ + "-重故障";
      this->mp_table_data_[2].group_name_ = this->table_name_ + "-轻故障";
    }
    if (this->fault_flag_ && !this->alrm_flag_) {
      this->mp_table_data_[1].group_name_ = this->table_name_ + "-故障";
      this->logger_->Debug() << "this->mp_table_data_[1].group_name_:"
                             << this->mp_table_data_[1].group_name_ << endl;
    }
    get_ruleid();  ///<查cfg
    this->Jkey_ += this->table_key_;
  } catch (const std::exception& e) {
    std::throw_with_nested(
        mix_cc::Exception(-1, "init error", BOOST_CURRENT_LOCATION));
  }
  return 0;
}

/**
 * @brief
 */
AlarmInfo TableStatic::exec_mon() {
  AlarmInfo out_alarm{};
  // this->logger_->Debug() << " TableStatic::exec_mon: start!" << endl;
  if (this->get_cycled_proc()) {
    auto reSult = this->mon_proc();
    this->logger_->Debug() << " update json" << endl;
  } else if (this->get_clear_flag()) {
    mix_cc::json js1 = this->table_data_.invert2json();
    this->Jvalue_ = js1.dump();
    // this->logger_->Debug() << "Jkey:" << this->Jkey_
    //                        << " this->Jvalue_ :" << this->Jvalue_ << endl;
    auto reSult = insert_memcache(this->Jkey_, this->Jvalue_);
  }

  return out_alarm;
}
std::vector<AlarmInfo> TableStatic::exec_task(mix_cc::time_range_t time_range) {
  return {};
}
void TableStatic::set_usable(bool usable) { this->is_usable_ = usable; }
/**
 * @brief 获取ruleid 从 cfg
 * @return int
 */
void TableStatic::get_ruleid() {
  for (int i = 0; i < 3; i++) {
    auto reSult = get_ruleid_by_int(i);
  }
  this->logger_->Debug()
      << "this->main_flag_:" << this->main_flag_ << " main_table_ nums is "
      << this->mp_table_data_[this->main_flag_].rule_ids_.size() << endl;
  this->table_data_.init_id(this->mp_table_data_[this->main_flag_].rule_ids_,
                            this->mp_table_data_[this->main_flag_].rule_names_);
  this->is_rules_empty_ = !this->table_data_.rule_nums_;
}
int TableStatic::get_ruleid_by_int(int num) {
  T_RULE_CFG trc;
  if (this->mp_table_data_.find(num) == this->mp_table_data_.end()) {
    this->logger_->Debug() << "no " << num
                           << " [0-running_time;1-重故障;2-轻故障]" << endl;
    return -3;
  }

  string grop_name = this->mp_table_data_[num].group_name_;
  auto query_list_maybe =
      exec<db2_t, T_RULE_CFG>(select(trc.ruleId(), trc.ruleName())
                                  .from(trc)
                                  .where(trc.ruleGroup() == grop_name));
  if (query_list_maybe.is_just()) {
    auto& query_list = query_list_maybe.unsafe_get_just();
    if (!query_list.empty()) {
      this->mp_table_data_[num].rule_nums_ = query_list.size();
      logger_->Info() << query_list.size() << " rules in DB where group is:"
                      << this->mp_table_data_[num].group_name_ << endl;
      // this->mp_table_data_[num].rule_ids_ =
      //     vector<string>(this->table_data_.rule_nums_, "a");
      // this->mp_table_data_[num].rule_names_ =
      //     vector<string>(this->table_data_.rule_nums_, "a");
      for (int i = 0; i < this->mp_table_data_[num].rule_nums_; i++) {
        this->mp_table_data_[num].rule_ids_.push_back(query_list[i].ruleId);
        this->mp_table_data_[num].rule_names_.push_back(query_list[i].ruleName);
      }
      this->mp_table_data_[num].init_id(this->mp_table_data_[num].rule_ids_,
                                        this->mp_table_data_[num].rule_names_);
    } else {
      this->gb_logger_->log_error("no rule in DB where group is:" +
                                  this->mp_table_data_[num].group_name_);
      return -2;
    }
  } else {
    this->gb_logger_->log_error("db2查询失败" + this->rule_name_);
    return -1;
  }
  return 0;
}

int TableStatic::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 {
    return 0;
  }
}
double TableStatic::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()) {
      this->logger_->Debug() << "query_list.empty() ruleid:" << ruleid << endl;
      return 0;
    }
    // if (ruleid == "f600feef-b91e-45a5-9f78-4d87aeb53c1f") {
    //   this->logger_->Debug() << "query_list[0].X1:" << query_list[0].X1 <<
    //   endl;
    // }
    return query_list[0].X1;
  } else {
    this->logger_->Debug() << "!query_list_maybe.is_just() ruleid:" << ruleid
                           << endl;
    return 0;
  }
}
unsigned long TableStatic::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;
  }
}

int TableStatic::insert_memcache(string Jkey, string Jvalue) {
  auto reSult =
      m_memclient.Insert(Jkey.c_str(),
                         Jvalue.c_str());  ///< memcache time_t expiration = 0
  if (1 != reSult) {
    this->logger_->Debug()
        << "m_memclient.Insert异常[0,set data fail;-1,key=null or value=null]："
        << reSult << endl;
  }
  return 0;
}
int TableStatic::mon_proc() {
  if (!is_rules_empty_) {
    if (this->fault_flag_ && this->alrm_flag_) {
      // 1 查 t_rule_result 后缀 _轻故障 2
      for (int i = 0; i < this->table_data_.rule_nums_; i++) {
        this->table_data_.alrm_times_[i] =
            this->select_alarm_by_ruleid(this->mp_table_data_[2].rule_ids_[i]);
        // 2查 t_rule_result 后缀 _重故障 1
        this->table_data_.fault_times_[i] =
            this->select_alarm_by_ruleid(this->mp_table_data_[1].rule_ids_[i]);
      }
    } else if (this->fault_flag_) {
      // 2查 t_rule_result 后缀 _故障 1
      for (int i = 0; i < this->table_data_.rule_nums_; i++) {
        this->table_data_.fault_times_[i] =
            this->select_alarm_by_ruleid(this->mp_table_data_[1].rule_ids_[i]);
      }
      //去掉轻故障
      this->table_data_.clear_alrm_times();
    } else {
      this->table_data_.clear_fault_times();
      this->table_data_.clear_alrm_times();
    }

    if (this->running_flag_ == 1) {
      // 查 T_RULE_SAMPLE_1D x1字段 0 0
      for (int i = 0; i < this->table_data_.rule_nums_; i++) {
        this->table_data_.running_time_[i] = this->select_running_by_ruleid(
            this->mp_table_data_[0].rule_ids_[i]);
      }
      this->table_data_.clear_used_times();
    } else if (this->running_flag_ == 2) {
      // 查 T_RULE_SAMPLE_1D count字段 2 3
      for (int i = 0; i < this->table_data_.rule_nums_; i++) {
        this->table_data_.used_times_[i] =
            this->select_times_by_ruleid(this->mp_table_data_[0].rule_ids_[i]);
      }
      this->table_data_.clear_running_time();
    } else {
      this->table_data_.clear_running_time();
      this->table_data_.clear_used_times();
    }

    mix_cc::json js1 = this->table_data_.invert2json();
    this->Jvalue_ = js1.dump();
    // this->logger_->Debug() << "Jkey:" << this->Jkey_
    //                        << " this->Jvalue_ :" << this->Jvalue_ << endl;
    auto reSult = insert_memcache(this->Jkey_, this->Jvalue_);
  } else {
    this->logger_->Debug() << this->table_data_.group_name_ << " 没有配置规则！"
                           << endl;
    return -1;
  }
  return 0;
}
bool TableStatic::get_cycled_proc() {
  auto now = system_clock::now();
  if ((now - last_run_start_time_proc_) > this->delay_time_proc_) {
    last_run_start_time_proc_ = now;
  } else {
    return false;
  }
  return true;
}
bool TableStatic::get_clear_flag() {
  string Jkey = string(CMemVar::Const()->UnitNo) + "_" + "clear_flag";
  string Jkey2 = string(CMemVar::Const()->UnitNo) + "_" + "clear_flag_id";
  auto reSult = m_memclient.Get(Jkey.c_str());
  auto reSult2 = m_memclient.Get(Jkey2.c_str());
  // this->logger_->Debug() << "Jkey:" << Jkey << " Jvalue:" << reSult << endl;
  // this->logger_->Debug() << "Jkey2:" << Jkey2 << " Jvalue2:" << reSult2 <<
  // endl;
  string Jvalue = "0";
  if (reSult == "no key" || reSult == "no value" || reSult == "1") {
    auto find_r = std::find(this->table_data_.rule_ids_.begin(),
                            this->table_data_.rule_ids_.end(), reSult2);
    if (find_r != this->table_data_.rule_ids_.end()) {
      int sub_index = find_r - this->table_data_.rule_ids_.begin();
      //运行时间
      if (this->running_flag_ == 1) {
        this->table_data_.running_time_[sub_index] =
            this->select_running_by_ruleid(
                this->mp_table_data_[0].rule_ids_[sub_index]);
      }
      //使用次数
      else if (this->running_flag_ == 2) {
        this->table_data_.used_times_[sub_index] = this->select_times_by_ruleid(
            this->mp_table_data_[0].rule_ids_[sub_index]);
      }
      //重故障
      if (this->fault_flag_) {
        this->table_data_.fault_times_[sub_index] =
            this->select_alarm_by_ruleid(
                this->mp_table_data_[1].rule_ids_[sub_index]);
      }
      //轻故障
      if (this->alrm_flag_) {
        this->table_data_.alrm_times_[sub_index] = this->select_alarm_by_ruleid(
            this->mp_table_data_[2].rule_ids_[sub_index]);
      }
      this->insert_memcache(Jkey, Jvalue);
      return true;
    } else {
      // this->insert_memcache(Jkey, Jvalue);
      this->logger_->Debug() << "ruleid: " << reSult2 << " 不存在！" << endl;
    }
  }
  return false;
}