scripts/libs/classes/Structures.ctl - master - Puzzman/setPointMap

scripts/libs/classes/Structures.ctl
391 строка13 KB
Sergey
refactor
13 май 2025, 16:44
13 май 2025, 16:44e49876e
const string ustEnable   = getSystemName() + "OIP_$1.OIPUst.UstEnable";
const string msgEnable   = getSystemName() + "OIP_$1.OIPUst.UstMsg";
const string soundEnable = getSystemName() + "OIP_$1.OIPUst.UstSound";

mapping maskUst = makeMapping("UstMin5", 32, "UstMin4", 16, "UstMin3", 8, "UstMin2", 4, "UstMin1", 2, "UstMin0", 1,
                              "UstMax0", 256, "UstMax1", 512, "UstMax2", 1024, "UstMax3", 2048, "UstMax4", 4096, "UstMax5", 8192);

struct defaultParametrsForsetPointMap
{
  //Повышаем первую цифру, когда гордимся тем, что сделали
  //Повышаем вторую цифру для обычных релизов
  //Повышаем третью цифру, когда стыдимся багов, которые пришлось починить

  const string __VERSION__  = "1.2.1";

  // ======================================================================

  const string backColor    = "{192,192,192}";
  const string warningColor = "{255,153,0}";
  const string pathToSave   = "/opt/scadcc_export/scadUstMap/";
  const bool PermissionOK   = true;
};

// буфер для режимов PLC и Archive
struct OperatingMode
{
  private mapping Mode_;

  public OperatingMode()
  {
    Mode_["PLC"] = true;
    Mode_["Archive"] = false;
  }

  public mapping getMode()
  {
    return Mode_;
  }

  public setMode(bool PLC, bool Arch)
  {
    Mode_["PLC"] = PLC;
    Mode_["Archive"] = Arch;
  }
};

struct StateTab
{
  int id;                   // индетификатор вкладки
  string title;             // имя вкладки для отображения
  bool needToFlip;          // необходимость перевернуть таблицу
  bool haveBeenChanges;     // флаг наличия изменений на вкладке
  string nameSQLTable;      // имя таблицы данных в Postgresql
  bool enable;              // включить\отключить вкладку
  string tagTab;            // внутреннее имя вкладки
  string tagTable;          // внутреннее имя таблицы;
  dyn_string needWriteToDB;
  anytype classTable;
  shared_ptr<void> tableData = nullptr;

  public StateTab(dyn_string tab, int id_, anytype Struct)
  {
    id            = id_;
    title         = tab[2];
    needToFlip    = tab[3];
    nameSQLTable  = tab[4];
    enable        = tab[5];
    tagTab   = "tab_" + (id);
    tagTable = "table_" + (id);
    tableData = Struct;

    if (nameSQLTable.contains("vibr"))
    {
      tableData.isVibration = true;
    }
  }

  public bool isCurrentTable(const string &name)
  {
    return this.tagTable == name;
  }

  public bool isCurrentTab(const string &name)
  {
    return this.tagTab == name;
  }

  int getCountLine()
  {
    return (this.needToFlip) ? dynlen(this.tableData.nameUst[1]) : dynlen(this.tableData.nameObjects);
  }

  dyn_string getTags()
  {
    return (this.needToFlip) ? this.tableData.tagObjects : this.tableData.tagUst[1];
  }

  dyn_string getColums()
  {
    dyn_string columns;

    if (this.needToFlip)
    {
      columns = this.tableData.nameObjects;
    }
    else
    {
      for (int j = 1; j <= dynlen(this.tableData.nameUst[1]); ++j)
      {
        //добавляем единицы измерения в названия колонок
        if (!(this.tableData.tagUst[1][j].contains("Ust") || this.tableData.tagUst[1][j].contains("ValRange")))
        {
          dynAppend(columns, this.tableData.nameUst[1][j] + "," + this.tableData.units[1][j]);
        }
        else
        {
          dynAppend(columns, this.tableData.nameUst[1][j]);
        }
      }
    }

    return columns;
  }

  public fillingTableRows()
  {
    for (int j = 1; j <= this.getCountLine(); ++j)
    {
      fillingTableRowsPLC(j);
      fillingTableRowsArch(j);
    }
  }

  private fillingTableRowsArch(int j)
  {
    int row, col;
    anytype objects;

    if (this.needToFlip)
    {
      dynAppend(this.tableData.rowsWithDataArch[j], j);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.nameUst[1][j]);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.tagUst[1][j]);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.units[1][j]);
      objects = this.tableData.valuesArch;
    }
    else
    {
      dynAppend(this.tableData.rowsWithDataArch[j], j);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.nameObjects[j]);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.tagObjects[j]);
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.units[j][1]);
      objects = this.tableData.nameUst[j];
    }

    for (int k = 1; k <= dynlen(objects); ++k)
    {
      row  = (this.needToFlip) ? k : j;
      col  = (this.needToFlip) ? j : k;
      dynAppend(this.tableData.rowsWithDataArch[j], this.tableData.valuesArch[row][col]);
    }
  }

  private fillingTableRowsPLC(int j)
  {
    anytype objects;
    string path;
    anytype value;
    int row, col;

    if (this.needToFlip)
    {
      dynAppend(this.tableData.rowsWithDataPLC[j], j);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.nameUst[1][j]);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.tagUst[1][j]);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.units[1][j]);
      objects = this.tableData.pathUst;
    }
    else
    {
      dynAppend(this.tableData.rowsWithDataPLC[j], j);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.nameObjects[j]);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.tagObjects[j]);
      dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.units[j][1]);
      dynInsertAt(this.tableData.format[j], makeDynString("", "", "", ""), 1);
      objects = this.tableData.nameUst[j];
    }

    for (int k = 1; k <= dynlen(objects); ++k)
    {

      row  = (this.needToFlip) ? k : j;
      col  = (this.needToFlip) ? j : k;
      path = this.tableData.pathUst[row][col];

      if (dpExists(path))
      {
        int err = dpGet(this.tableData.pathUst[row][col], value);

        if (err == 0)
        {
          string f = (this.needToFlip) ? this.tableData.format[row][col] : this.tableData.format[row][col + 4];
          sprintf(this.tableData.valuesPLC[row][col], f, value);
          strreplace(this.tableData.valuesPLC[row][col], " ", "");
          dynAppend(this.tableData.rowsWithDataPLC[j], this.tableData.valuesPLC[row][col]);
        }
        else
        {
          DebugN("В модуле 'PARA' данный путь '" + path + "' не найден!!!");
          continue;
        }
      }
      else
      {
        DebugN("В модуле 'PARA' данный путь '" + path + "' не найден!!!");
        continue;
      }
    }
  }

  public fillingObjectsWithDataAnalog(dyn_dyn_string result)
  {
    for (int j = 1; j <= dynlen(result); ++j)
    {
      dynAppend(this.tableData.nameObjects, result[j][1]);
      dynAppend(this.tableData.tagObjects,  result[j][2]);
      dynAppend(this.tableData.nameUst,     stringToArray(result[j][4]));
      dynAppend(this.tableData.tagUst,      stringToArray(result[j][5]));

      dyn_string tmp = stringToArray(result[j][7]);

      for (int i = 1; i <= dynlen(tmp); ++i) tmp[i] = getSystemName() + tmp[i];

      dynAppend(this.tableData.pathUst, tmp);

      string tmp_str;
      dyn_string arr_tmp = stringToArray(result[j][9]);
      tmp_str = ustEnable;
      strreplace(tmp_str, "$1", result[j][2]);
      string val;
      dpGet(tmp_str, val);
      dynAppend(this.tableData.UstEnable[j], makeDynString(tmp_str, arr_tmp[1], val));

      tmp_str = msgEnable;
      strreplace(tmp_str, "$1", result[j][2]);
      dpGet(tmp_str, val);
      dynAppend(this.tableData.UstMsg[j], makeDynString(tmp_str, arr_tmp[2], val));
      //заполняем UstSound
      tmp_str = soundEnable;
      strreplace(tmp_str, "$1", result[j][2]);
      dpGet(tmp_str, val);
      dynAppend(this.tableData.UstSound[j], makeDynString(tmp_str, arr_tmp[3], val));
      //заполняем units
      dynAppend(this.tableData.units,      stringToArray(result[j][6]));

      for (int k = 1; k <= dynlen(this.tableData.units[j]); ++k)
      {
        if (this.tableData.units[j][k] == "")
        {
          this.tableData.units[j][k] = result[j][3];
        }
      }

      //заполняем valueArch
      dynAppend(this.tableData.valuesArch,    stringToArray(result[j][8]));

      //заполняем format
      dynAppend(this.tableData.format,      stringToArray(result[j][11]));

      for (int k = 1; k <= dynlen(this.tableData.format[j]); ++k)
      {
        if (this.tableData.format[j][k] == "")
        {
          this.tableData.format[j][k] = result[j][10];
        }

        float tmp = (float)this.tableData.valuesArch[j][k];
        sprintf(this.tableData.valuesArch[j][k], this.tableData.format[j][k], (float)this.tableData.valuesArch[j][k]);
        strreplace(this.tableData.valuesArch[j][k], " ", "");
      }
    }
  }

  public fillingObjectsWithData(dyn_dyn_string result)
  {
    for (int j = 1; j <= dynlen(result); ++j)
    {
      //заполняем nameObjects
      dynAppend(this.tableData.nameObjects, result[j][1]);
      //заполняем tagObjects
      dynAppend(this.tableData.tagObjects, result[j][2]);
      //заполняем nameUst
      dynAppend(this.tableData.nameUst,    stringToArray(result[j][3]));
      //заполняем tagUst
      dynAppend(this.tableData.tagUst,     stringToArray(result[j][4]));
      //заполняем pathUst
      dyn_string tmp = stringToArray(result[j][6]);

      for (int i = 1; i <= dynlen(tmp); ++i) tmp[i] = getSystemName() + tmp[i];

      dynAppend(this.tableData.pathUst, tmp);
      //заполняем units
      dynAppend(this.tableData.units,      stringToArray(result[j][5]));
      //заполняем valueArch
      dynAppend(this.tableData.valuesArch,    stringToArray(result[j][7]));
      //заполняем format
      dynAppend(this.tableData.format,      stringToArray(result[j][8]));

      for (int k = 1; k <= dynlen(this.tableData.format[j]); ++k)
      {
        float tmp = (float)this.tableData.valuesArch[j][k];
        sprintf(this.tableData.valuesArch[j][k], this.tableData.format[j][k], (float)this.tableData.valuesArch[j][k]);
        strreplace(this.tableData.valuesArch[j][k], " ", "");
      }
    }
  }

  private dyn_string stringToArray(string str)
  {
    return strsplit(str, ";");
  }
};

//структура данных для параметров кроме аналога
struct dataTable
{
  dyn_string nameObjects;          // имена объектов
  dyn_string tagObjects;           // tags объектов
  dyn_dyn_string nameUst;          // имя уставок
  dyn_dyn_string tagUst;           // имя tags уставок
  dyn_dyn_string pathUst;          // пути уставок в para
  dyn_dyn_string valuesArch;       // значения архивные
  dyn_dyn_string valuesPLC;        // значения в ПЛК
  dyn_dyn_string rowsWithDataPLC;  // значения в widget'Table'
  dyn_dyn_string rowsWithDataArch; // значения в widget'Table'
  dyn_dyn_string units;            // ед. измерения
  dyn_dyn_string format;                 // format

  public clear()
  {
    dynClear(this.nameObjects);
    dynClear(this.tagObjects);
    dynClear(this.nameUst);
    dynClear(this.tagUst);
    dynClear(this.pathUst);
    dynClear(this.valuesArch);
    dynClear(this.valuesPLC);
    dynClear(this.rowsWithDataPLC);
    dynClear(this.rowsWithDataArch);
    dynClear(this.units);
    dynClear(this.format);
  }
};

//структура данных для параметров кроме аналога
struct dataTableAnalog
{
  bool isVibration = false;
  dyn_string nameObjects;              // имена объектов
  dyn_string tagObjects;               // tags объектов
  dyn_dyn_string UstEnable;            // пути включения уставок в para
  dyn_dyn_string UstMsg;               // пути включения сообщений в para
  dyn_dyn_string UstSound;               // пути включения сообщений в para
  dyn_dyn_string nameUst;              // имя уставок
  dyn_dyn_string tagUst;               // имя tags уставок
  dyn_dyn_string pathUst;              // пути уставок в para
  dyn_dyn_string valuesArch;        // значения архивные
  dyn_dyn_string valuesPLC;         // значения в ПЛК
  dyn_dyn_string rowsWithDataPLC;  // значения в widget'Table'
  dyn_dyn_string rowsWithDataArch; // значения в widget'Table'
  dyn_dyn_string units;                 // ед. измерения
  dyn_dyn_string format;                 // format

  public clear()
  {
    dynClear(this.nameObjects);
    dynClear(this.tagObjects);
    dynClear(this.UstEnable);
    dynClear(this.UstMsg);
    dynClear(this.UstSound);
    dynClear(this.nameUst);
    dynClear(this.tagUst);
    dynClear(this.pathUst);
    dynClear(this.valuesArch);
    dynClear(this.valuesPLC);
    dynClear(this.rowsWithDataPLC);
    dynClear(this.rowsWithDataArch);
    dynClear(this.units);
    dynClear(this.format);
  }
};