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

scripts/libs/classes/class_mapOthers.ctl
1 270 строк42 KB
Sergey
refactor
12 май 2025, 16:11
12 май 2025, 16:118c27993
#uses "scadMsg_Messages"
#uses "SQL/sqlQueries.ctl"
#uses "classes/TabViewScad.ctl"
#uses "classes/TableViewScad.ctl"
#uses "classes/DataBase.ctl"
#uses "classes/Structures.ctl"
#uses "classes/class_printTable.ctl"
#uses "classes/class_printTable.ctl"
#uses "stdlib"

class EntityMapOthers
{
  string CCCCCC;
  string WARNING;
  string PATH;

  defaultParametrsForsetPointMap paramSetPointMap;

  dyn_dyn_anytype listTab;
  mapping buf_write_to_para_;
  shape mode_btn_, archive_btn_, plc_btn_;
  dyn_int selected_rows_;
  dyn_int selected_columns_;

  public  shared_ptr<BaseTab>       TabView = nullptr;
  private shared_ptr<OperatingMode> Mode_   = nullptr;
  private shared_ptr<DataBase>      db      = nullptr;
  private shared_ptr<DataBase>      db_re   = nullptr;

  dyn_anytype Tab_;
  bool editingIsAllowed;

  //конструктор
  public EntityMapOthers()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    CCCCCC  = paramSetPointMap.backColor;
    WARNING = paramSetPointMap.warningColor;
    PATH    = paramSetPointMap.pathToSave;

    editingIsAllowed = getUserPermission(6);

    db    = new DataBase();    // подключаемся к базе данных
    db_re = new DataBase(true);
    Mode_ = new OperatingMode;

    Mode_.setMode(true, false);

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public bool getPermission() {return editingIsAllowed;}

  public mapping getBufferToWriteToPara()
  {
    return buf_write_to_para_; //возвращаем массив уставок, которые нужно записать
  }
  public mapping getMode()
  {
    return Mode_.getMode(); //возвращаем текущий режим карты уставок ПЛК или Архив
  }

  public string setVersion()
  {
    return paramSetPointMap.__VERSION__;
  }

  //переключение режимов карты уставок
  public setMode(bool PLC, bool Arch)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    Mode_.setMode(PLC, Arch); //меняем режим карты уставок

    int idActiveTab;
    getValue("TAB1", "activeRegister", idActiveTab); //меняем режим карты уставок

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;

      if (Arch)
      {
        fillTables(Tab_[i], false, Arch);
      }
      else
      {
        if (Tab_[i].id != idActiveTab) continue;

        updateValueFromPlc(Tab_[i]);  //обновляем данные из PLC только для активной вкладки
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " ------> END");
  }

  //функция записи данных в PARA
  public writeBufferToPara()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_string tmp_tab;
    dyn_string keys = mappingKeys(buf_write_to_para_); //получаем пути до dpPoint для записи уставок

    for (int i = 1; i <= dynlen(keys); i++)
    {
      createMessage(buf_write_to_para_[keys[i]], keys[i]);

      int err = dpSetWait(keys[i], buf_write_to_para_[keys[i]]["Current Value"]);

      if (err == 0)
      {
        string tagTab           = buf_write_to_para_[keys[i]]["Title Tab"];
        string tagTable         = buf_write_to_para_[keys[i]]["Title Table"];
        string currentRow       = buf_write_to_para_[keys[i]]["Selected Rows"];
        string tagCurrentColumn = buf_write_to_para_[keys[i]]["Title Column"];
        //убираем цвет измененной уставки
        setValue(tagTable, "cellBackColRC", currentRow, tagCurrentColumn, "_Transparent");

        //создаем массив вкладок по которым нужно обновить таблицы
        if (dynContains(tmp_tab, tagTab) == 0)
        {
          dynAppend(tmp_tab, tagTab);
        }
      }
    }

    //обновляем таблицы
    for (int i = 1; i <= dynlen(tmp_tab); i++)
    {
      shared_ptr<StateTab> tab = getCurrentTab(tmp_tab[i]);
      updateBuffPLC();
      fillTables(tab, false);
      setValue("TAB1", "registerIcon", tab.id, ""); //убираем иконку наличия изменных уставок
      tab.haveBeenChanges = false;
    }

    mappingClear(buf_write_to_para_);
  }

  private void choosingUpdateLocation(const string &key, const anytype &tmp_value, const int &err)
  {
    shared_ptr<StateTab> tab = getCurrentTab(buf_write_to_para_[key]["Title Tab"]);
    int col     = buf_write_to_para_[key]["Selected Columns"];
    int row     = buf_write_to_para_[key]["Selected Rows"] + 1;
    int r       = (tab.needToFlip) ? col - 3 : row;
    int tmp_col = (tab.needToFlip) ? row : col + 1;

    string value;
    sprintf(value, tab.tableData.format[r][tmp_col], tmp_value);
    strreplace(value, " ", "");

    if (patternMatch("*UstEnable", key))
    {
      if (err == 0) tab.tableData.UstEnable[r][3] = value;
    }
    else if (patternMatch("*UstMsg", key))
    {
      if (err == 0) tab.tableData.UstMsg[r][3] = value;
    }
    else if (patternMatch("*UstSound", key))
    {
      if (err == 0) tab.tableData.UstSound[r][3] = value;
    }
    else
    {
      if (err == 0)
      {
        if (tab.needToFlip)
        {
          tab.tableData.valuesPLC[col - 3][row] = value;
        }
        else
        {
          tab.tableData.valuesPLC[row][col - 3] = value;
        }

        tab.tableData.rowsWithDataPLC[row][col + 1] = value;
      }
    }
  }

  private updateBuffPLC()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_string keys = mappingKeys(buf_write_to_para_);

    for (int i = 1; i <= dynlen(keys); i++)
    {
      anytype tmp_value;
      int err = dpGet(keys[i], tmp_value);

      choosingUpdateLocation(keys[i], tmp_value, err);
    }
  }

  private shared_ptr<StateTab> getCurrentTable(const string &table_name)
  {
    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      if (Tab_[i].isCurrentTable(table_name))
      {
        return Tab_[i];
      }
    }
  }

  //получим текущий объект Tab по имени владки
  private shared_ptr<StateTab> getCurrentTab(const string &tab_name)
  {
    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      if (Tab_[i].isCurrentTab(tab_name))
      {
        return Tab_[i];
      }
    }
  }

  //Заполнение вкладками
  public initTab()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    dyn_string titleTab;
    int idCount = 0;                         //счетчик нужен, если вкладки идут не подряд

    listTab = db.getData(getNameTabs); //запрашиваем имена вкладок

    for (int i = 1;  i <= dynlen(listTab); ++i)
    {
      if ((bool)listTab[i][5])
      {
        shared_ptr<StateTab> tab_ = new StateTab(listTab[i], idCount, new dataTable);   // создаем структуру вкладок
        dynAppend(Tab_, tab_);
        idCount += 1;
      }
    }

    if (dynlen(Tab_) > 0)
    {
      TabView = new BaseTab(Tab_);    //создаем класс TAB
      TabView.setTabEnable(false);    //временное решение
      initTables();
    }
    else
    {
      DebugFTN("dbgmap", __LINE__, __FUNCTION__, "Не получено ни одной вкладки");
    }
  }

  //функция снятия редактирования со всех ячеек кроме выбранной
  public functionOfRemovingEditingCellsExeptForSelectedOne(int row, int column, string tableName)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    int rowCount, columnCount, shift;
    string nameColumn, nameTab, aliasTab, color;

    getValue(tableName, "lineCount",   rowCount);
    getValue(tableName, "columnCount", columnCount);
    getValue("TAB1", "namedActiveRegister", nameTab);
    getValue("TAB1", "namedColumnHeader", nameTab, aliasTab);
    int idx;

    shared_ptr<StateTab> tab = getCurrentTab(nameTab);

    shift = (tab.needToFlip) ? 4 : 3;


    for (int i = 0; i < rowCount; i++)
    {
      for (int j = shift; j < columnCount; j++)
      {

        getValue(tableName, "columnToName", j, nameColumn);
        getValue(tableName, "cellBackColRC", i, nameColumn, color);

        if (row == i && column == j && color != CCCCCC)
        {
          setValue(tableName, "cellEditableRC", row, nameColumn, true);
        }
        else
        {
          setValue(tableName, "cellEditableRC", i, nameColumn, false);
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --->  END");
  }

  // получелние выбранных строк и столбцов
  public selectionProcessing(dyn_int rows, dyn_int columns, string table_name, int cur_row, int cur_col, string value, string name_column)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START", cur_row, name_column, value);

    shared_ptr<StateTab> tab_ = getCurrentTable(table_name);

    if (cur_col == 0 && dynlen(rows) == 1)
    {
      setValue(table_name, "selectLineN", cur_row); //выделение всей строки при выборе первой колонки
    }

    if (name_column != "id" && name_column != "name" && name_column != "tag" && name_column != "unit")
    {
      dyn_int aTmp;
      aTmp = (tab_.needToFlip) ? columns : rows;
      changedValue(table_name, cur_row, aTmp, value, name_column);
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public writeToFile()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    string nameTable, title;
    ExportToXML(Tab_, "Карта временных утсавок");
//     string dir = PATH + formatTime("%Y-%m-%d_%H-%M-%S", getCurrentTime())+ "_Timer" + "/";
//
//     bool result = mkdir(dir,"777");  //создаем директорию
    //если все удачно
//     if (result)
//     {
//       for (int i = 1; i <= dynlen(Tab_); i++)
//       {
//         nameTable = Tab_[i].tagTable;
//         title = Tab_[i].title;
//         string command = "iconv -f UTF-8 -t CP1251//TRANSLIT $1 -o $2";                                    //команда на смену кодировки файла
        //string path = dir + title + "_" + formatTime("%Y-%m-%d_%H-%M-%S", getCurrentTime()) + ".csv";
//         string path = dir + nameTable + ".csv";                                                            //создаем файл без кириллицы
//         string tmp = dir + "out_a"+ i +".csv";                                                             //создаем временный файл
//         setValue(nameTable, "writeToFile", tmp, TABLE_WRITE_ALL_COLUMNS | TABLE_WRITE_COLUMN_HEADER, ";"); //выгружаем таблицы по одной
//         strreplace(command, "$1", tmp);                                                                    //реплейсим по шаблону
//         strreplace(command, "$2", path);                                                                   //тут тоже))
//         system(command);                                                                                   //вызываем консольную команду на смену кодировки
//         delay(0, 100);                                                                                     //отдыхаем
//         remove(tmp);                                                                                       //удаляем временный файл
//         string path1 = dir + "_" + title + ".csv";                                                         //создаем имя для файла в читабельном виде
//         moveFile(path, path1);                                                                             //команда move позволяет переименовать файл
//       }

//     }

//     else
//     {
//       DebugN("Директория " + dir + " не была создана");
//     }
//     string msg = "Карта уставок временных параметров успешно экспортирована в директорию " + dir;
//     openInformationPanel(makeDynString("$sInformation:" + msg + "", "$iTimer:0", "$bCritical:false"), "-1", "-1");
//     CreateMultiInstanceMessage("Произведен экспорт карты уставок пользователем " + getUserName() + " в директорию " + dir , "", "armMessages_10", "armMessages_10", getHostname());
  }

  public writeToParaFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      dyn_dyn_string paths = Tab_[i].tableData.pathUst;

      for (int j = 1; j <= dynlen(paths); ++j)
      {
//           DebugN(paths[j], Tab_[i].tableData.valuesArch[j]);
        int err = dpSetWait(paths[j], Tab_[i].tableData.valuesArch[j]);

        if (err != 0)
        {
          for (int k = 1; k <= dynlen(paths[j]); ++k)
          {
            DebugN("Не удалось записать уставку " + Tab_[i].tableData.nameObjects[j] + "(" + Tab_[i].tableData.nameUst[j][k] + ") со значением " + Tab_[i].tableData.valuesArch[j][k] + " в ПЛК");
          }

        }
      }

      Tab_[i].tableData.rowsWithDataPLC = Tab_[i].tableData.rowsWithDataArch;
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
      fillTables(Tab_[i], false);
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public readFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    updateValueFromArchive();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public switchingTab(string name_tab, bool init = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    mapping mode = Mode_.getMode();

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      shape t = Tab_[i].classTable.get_table();
      setValue(t.name, "visible", (Tab_[i].tagTab == name_tab) ? true : false);

      if (t.visible() && mode["PLC"] && !Tab_[i].haveBeenChanges)
      {
        if (!init)
        {
          updateValueFromPlc(Tab_[i]);
          setValue("TAB1", "registerIcon", Tab_[i].id, "");
          Tab_[i].haveBeenChanges = false;
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public readFromPLC()
  {
    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      shape t = Tab_[i].classTable.get_table();

      if (t.visible() && mode["PLC"])
      {
        updateValueFromPlc(Tab_[i]);
        setValue("TAB1", "registerIcon", Tab_[i].id, "");
        Tab_[i].haveBeenChanges = false;
      }
    }
  }

  public updateValueFromPlc(anytype &tab)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    dyn_dyn_string paths = tab.tableData.pathUst;
    dyn_anytype tmp_rez;
    int shift;

    for (int j = 1; j <= dynlen(paths); ++j)
    {
      int err = dpGet(paths[j], tmp_rez);

      if (err == 0)
      {
        tab.tableData.valuesPLC[j] = tmp_rez;
        shift = 4;

        //обновление массива таблицы
        for (int k = 1; k <= dynlen(tmp_rez); ++k)
        {
          if (!tab.needToFlip)
          {
            sprintf(tab.tableData.rowsWithDataPLC[j][shift + k], tab.tableData.format[j][shift + k], (float)tmp_rez[k]);
            strreplace(tab.tableData.rowsWithDataPLC[j][shift + k], " ", "");
          }
          else
          {
            sprintf(tab.tableData.rowsWithDataPLC[k][shift + j], tab.tableData.format[j][k], (float)tmp_rez[k]);
            strreplace(tab.tableData.rowsWithDataPLC[k][shift + j], " ", "");

          }
        }

      }
      else
      {
        DebugN(paths[j], "----> error reading " + paths[j]);
      }
    }

    fillTables(tab, false);

  }

  private updateRowsTable()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");


    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      for (int j = 1; j <= dynlen(Tab_[i].tableData.rowsWithDataArch); ++j)
      {
        getValue(Tab_[i].tagTable, "getLineN", j - 1, Tab_[i].tableData.rowsWithDataArch[j]);
      }

      if (Tab_[i].needToFlip)
      {
        int count_column;
        getValue(Tab_[i].tagTable, "columnCount", count_column);

        for (int j = 4; j < count_column - 1; ++j)
        {
          dyn_string tmp;
          getValue(Tab_[i].tagTable, "getColumnN", j, tmp);

          for (int k = 1; k <= dynlen(tmp); ++k)
          {
            if (tmp[k].isEmpty())
            {
              Tab_[i].tableData.valuesArch[j - 3][k] = 0;
            }
            else
            {
              Tab_[i].tableData.valuesArch[j - 3][k] = tmp[k];
            }
          }
        }
      }
      else
      {
        for (int j = 1; j <= dynlen(Tab_[i].tableData.rowsWithDataArch); ++j)
        {
          for (int k = 5; k <= dynlen(Tab_[i].tableData.rowsWithDataArch[j]) - 1; ++k)
          {
            if (Tab_[i].tableData.rowsWithDataArch[j][k] == "")
            {
              Tab_[i].tableData.valuesArch[j][k - 4] = 0;
            }
            else
            {
              Tab_[i].tableData.valuesArch[j][k - 4] = Tab_[i].tableData.rowsWithDataArch[j][k];
            }
          }
        }
      }

      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
    }

    mappingClear(buf_write_to_para_);
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public updateValueFromArchive()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    queryToDataBase();

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  //сравнение архива и плк по уставкам (нужно доделать)
  public comparingArrays()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    int ust_changed, msg_changed, sound_changed;

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      int shift = 5;

      for (int row = 1; row <= dynlen(Tab_[i].tableData.rowsWithDataPLC); ++row)
      {
        for (int col = shift; col <= dynlen(Tab_[i].tableData.rowsWithDataPLC[row]); ++col)
        {
          int r = (Tab_[i].needToFlip) ? col - 4 : row;
          //проверка колонок на измененные уставки
          langString header_row;
          getValue(Tab_[i].tagTable, "rowHeader", row - 1, header_row);
          string name_column;
          getValue(Tab_[i].tagTable, "columnToName", col - 1, name_column);
          string name = (Tab_[i].needToFlip) ? header_row : name_column;

          if (Tab_[i].tableData.rowsWithDataPLC[row][col] != Tab_[i].tableData.rowsWithDataArch[row][col])
          {
            string color, name_column;
            getValue(Tab_[i].tagTable, "columnToName", col - 1, name_column);
            getValue(Tab_[i].tagTable, "cellBackColRC", row - 1, name_column, color);

            if (color != CCCCCC)
            {
              if (dynCount(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]) == 0) dynAppend(Tab_[i].needWriteToDB, Tab_[i].tableData.tagObjects[r]);

              setValue(Tab_[i].tagTable, "cellBackColRC", row - 1, name_column, WARNING);
              setValue("TAB1", "registerIcon", Tab_[i].id, "2.png");
              Tab_[i].haveBeenChanges = true;
            }
          }
        }
      }
    }

    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  public void changedValue(const string &tableName, int curRow, dyn_int rowsColumns_, string curValue, string colName)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    string key, color;
    string form;
    anytype value;
    dyn_anytype tmp;
    int curColumn;

    shared_ptr<StateTab> tab = getCurrentTable(tableName);

    getValue(tableName, "nameToColumn", colName, curColumn);
    getValue(tableName, "cellBackColRC", curRow, colName, color);

    int r = (tab.needToFlip) ? curColumn - 3 : curRow + 1;
    int c = (tab.needToFlip) ? curRow + 1 : curColumn + 1;

    string path = (tab.needToFlip) ? tab.tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
    //string format = (tab.needToFlip) ? tab.tableData.format[r][c] : tab.tableData.format[r][c];
    string format = tab.tableData.format[r][c];

    if (Mode_.getMode()["PLC"] == true)
    {
      anytype var;
      dpGet(path, var);
      sprintf(value, format, var);
      strreplace(value, " ", "");
    }
    else
    {
      value = tab.tableData.rowsWithDataArch[curRow + 1][curColumn + 1];
    }

    if (color == WARNING && mappinglen(buf_write_to_para_) > 0)
    {

      if (value == curValue)
      {
        if (dynlen(rowsColumns_) > 1)
        {
          for (int i = 1; i <= dynlen(rowsColumns_); i++)
          {

            if (!tab.needToFlip)
            {
              curRow = rowsColumns_[i];
              getValue(tableName, "cellBackColRC", rowsColumns_[i], colName, color);
            }
            else
            {
              curColumn = rowsColumns_[i];
              getValue(tableName, "columnToName", curColumn, colName);
              getValue(tableName, "cellBackColRC", curRow, colName, color);
            }

            if (color != CCCCCC)
            {
              tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
              tmp[2] = "_Transparent";
              tmp[3] = "";
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, "_Transparent");
              string key = (tab.needToFlip) ? tab.tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
              mappingRemove(buf_write_to_para_, key);
            }
          }
        }
        else
        {
          if (color != CCCCCC)
          {
            tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
            tmp[2] = "_Transparent";
            tmp[3] = "";
            setValue(tableName, "cellValueRC", curRow, colName, curValue);
            string key = (tab.needToFlip) ? tab.tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
            mappingRemove(buf_write_to_para_, key);
          }
        }
      }

      if (mappinglen(buf_write_to_para_) == 0)
      {
        setValue("TAB1", "registerIcon", tab.id, "");
        tab.haveBeenChanges = false;
      }
    }

    if (value != curValue && color != CCCCCC)
    {
      if (dynlen(rowsColumns_) > 1)
      {
        for (int i = 1; i <= dynlen(rowsColumns_); i++)
        {
          if (!tab.needToFlip)
          {
            getValue(tableName, "cellBackColRC", rowsColumns_[i], colName, color);
          }
          else
          {
            getValue(tableName, "columnToName", rowsColumns_[i], colName);
            getValue(tableName, "cellBackColRC", curRow, colName, color);
          }

          if (color != CCCCCC)
          {
            tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
            tmp[2] = WARNING;
            tmp[3] = "";

            if (!tab.needToFlip)
            {
              curRow = rowsColumns_[i];
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, WARNING);
            }
            else
            {
              curColumn = rowsColumns_[i];
              setValue(tableName, "cellValueRC", curRow, colName, curValue);
              setValue(tableName, "cellBackColRC", curRow, colName, WARNING);
            }

            setValue("TAB1", "registerIcon", tab.id, "2.png");
            tab.haveBeenChanges = true;

            string key;

            if (curValue != "")
            {
              if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[i]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[i]);

              //временный костыль
              int r = (tab.needToFlip) ? curColumn - 3 : curRow + 1;
              int c = (tab.needToFlip) ? curRow + 1 : curColumn - 3;
              //вычитываем каждое значение отдельно, для корректности сообщений
              value = (Mode_.getMode()["PLC"] == true) ? tab.tableData.valuesPLC[r][c] : tab.tableData.valuesArch[r][c];
              //заполняем буфер на запись в PLC
              key = tab.tableData.pathUst[r][c];
              buf_write_to_para_[key] = makeMapping();
              buf_write_to_para_[key]["Current Value"]    = curValue;
              buf_write_to_para_[key]["Old Value"]        = value;
              buf_write_to_para_[key]["Title Table"]      = tableName;
              buf_write_to_para_[key]["Selected Rows"]    = curRow;
              buf_write_to_para_[key]["Selected Columns"] = curColumn;
              buf_write_to_para_[key]["Title Column"]     = colName;
              buf_write_to_para_[key]["Title Tab"]        = tab.tagTab;
            }
          }
        }
      }
      else
      {
        tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
        tmp[2] = WARNING;
        tmp[3] = "";
        setValue(tableName, "cellValueRC", curRow, colName, tmp);
        setValue(tableName, "cellBackColRC", curRow, colName, WARNING);

        setValue("TAB1", "registerIcon", tab.id, "2.png");
        tab.haveBeenChanges = true;

        //тут будет вызываться функция для проверки корректности ввода уставок
        string key;

        if (curValue != "")
        {
          if (dynCount(tab.needWriteToDB, tab.tableData.tagObjects[r]) == 0) dynAppend(tab.needWriteToDB, tab.tableData.tagObjects[r]);

          key = (tab.needToFlip) ? tab.tableData.pathUst[r][c] : tab.tableData.pathUst[r][c - 4];
          buf_write_to_para_[key] = makeMapping();
          buf_write_to_para_[key]["Current Value"]    = curValue;
          buf_write_to_para_[key]["Old Value"]        = value;
          buf_write_to_para_[key]["Title Table"]      = tableName;
          buf_write_to_para_[key]["Selected Rows"]    = curRow;
          buf_write_to_para_[key]["Selected Columns"] = curColumn;
          buf_write_to_para_[key]["Title Column"]     = colName;
          buf_write_to_para_[key]["Title Tab"]        = tab.tagTab;
        }
      }
    }
    else
    {
      if (color != CCCCCC)
      {
        tmp[1] = (curValue == "TRUE") ? true : (curValue == "FALSE") ? false : curValue;
        tmp[2] = "_Transparent";
        tmp[3] = "";
        setValue(tableName, "cellValueRC", curRow, colName, tmp);
      }
    }
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> END");
  }

  private changingSizeTable(anytype tab)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    int size_total_cell, addNumber = 37;
    shape table = tab.classTable.get_table();
    int column_count;
    getValue(table, "columnCount", column_count);
    bool lineBreak;
    string columnHeader;

    for (int i = 0; i < column_count; ++i)
    {
      getValue(table, "columnHeader", i, columnHeader);

      if (columnHeader.contains("\n"))
      {
        addNumber = 53;
        break;
      }
    }


    for (int i = 1; i <= column_count; i++)
    {
      int size;
      getValue(table, "columnWidth", i - 1, size);
      size_total_cell += size;
    }

    int r, c;
    getValue(table, "minimumSize", r, c);

    size_total_cell += 17;

    if (size_total_cell < r)
    {
      table.size(size_total_cell, c);
      table.minimumSize(size_total_cell, c);
      table.maximumSize(size_total_cell, c);
    }
    else
    {
      size_total_cell = r;
    }

    if ((table.rowHeight() * table.lineCount()) < SIZE_Y)
    {
      table.size(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
      table.minimumSize(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
      table.maximumSize(size_total_cell, (table.rowHeight() * table.lineCount()) + addNumber);
    }
  }

  private fillTables(anytype &tab, bool FocusOnFirstRow = true, bool isArch = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    mapping mode = Mode_.getMode();
    dyn_mixed tmp;
    shape table = tab.classTable.get_table();
    string format = "";
    int cCount = table.columnCount();
    int rCount = table.lineCount();
    table.columnVisibility(cCount - 1, FALSE);
    dyn_string col_name_;
    dyn_langString row_name_;
    bool isUst;
    uint mask, ust_enab;

    anytype rows = (isArch || mode["Archive"]) ? tab.tableData.rowsWithDataArch : tab.tableData.rowsWithDataPLC;

    for (int i = 1; i <= cCount; i++)
    {
      col_name_[i] = table.columnName(i - 1);
    }

    for (int i = 1; i <= dynlen(rows); i++)
    {
      setValue(tab.tagTable, "rowHeader", i - 1, rows[i][3]);
    }

    for (int i = 1; i <= rCount; i++)
    {
      getValue(tab.tagTable, "rowHeader", i - 1, row_name_[i]);
    }

    int count = -1;

    for (int i = 1; i <= (dynlen(rows)); i++)
    {
      if (dynlen(rows) < 1 || dynlen(rows[i]) < 4)
      {
        continue;
      }

      count++;
//           table.rowHeader(count,rows[i][3]);

      for (int j = 1; j <= dynlen(col_name_) - 1; j++)
      {
        tmp[1] = (rows[i][j] == "TRUE") ? true : (rows[i][j] == "FALSE") ? false : rows[i][j];
        tmp[2] = "";
        tmp[3] = "";

        int r = (tab.needToFlip) ? j - 4 : i;
        int c = (tab.needToFlip) ? i : j - 4;

        if (tab.needToFlip)
        {
          if (j > 4 && j < dynlen(col_name_) - 1) format = tab.tableData.format[r][c];
        }
        else
        {
          format = tab.tableData.format[i][j];
        }


//               Задание формата ячейкам (todo нужно будет вынести в отдельный приватный метод)
        if (col_name_[j] == "name")
        {
          table.cellFormatRC(count, col_name_[j], "[0s,,,ALIGNMENT_LEFT]");
        }
        else
        {
          if (col_name_[j] == "id" || col_name_[j] == "tag" || col_name_[j] == "unit")
          {
            table.cellFormatRC(count, col_name_[j], "[0s,,,ALIGNMENT_CENTER]");
          }
          else
          {
            table.cellFormatRC(count, col_name_[j], "[" + strltrim(format, "%") + ",False,False,AlignHCenter|AlignVCenter,False]");
          }
        }

        table.cellValueRC(count, col_name_[j], tmp);
        table.cellEditableRC(count, col_name_[j], FALSE);

        //перемещаем фокус на первую строку, если это необходимо
        if (FocusOnFirstRow)
        {
          table.lineVisible(0);
        }

      }
    }

    this.TabView.init = false;
    changingSizeTable(tab);
  }
  // *************************************************************************************************
  // **************************************ИНИЦИАЛИЗАЦИЯ ТАБЛИЦ **************************************
  // *************************************************************************************************
  private initTables()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    //формируем имена таблиц
    string table_shape_name = "";
    int idx;

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      //создаем таблицу для каждой вкладки
      shape TABLE_                    = addShape(myModuleName(), myPanelName(), 1, "TABLE", Tab_[i].tagTable);
      shared_ptr<TableViewScad> Table = new TableViewScad(TABLE_, Tab_[i].needToFlip, editingIsAllowed);
      Tab_[i].classTable              = Table;
    }

    queryToDataBase(true);
  }


  private queryToDataBase(bool init = false)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");
    IndicatorLoad.start();

    for (int i = 1; i <= dynlen(Tab_); i++)
    {
      mapping r;

      mixed result;
      int countLine = 0;
      dyn_string columns, tags;

      bool needToFlip = Tab_[i].needToFlip;
      string nameSqlTable = Tab_[i].nameSQLTable;
      // формируем запрос в БД
      string request = getDataFromSQL;
      strreplace(request, "$2", nameSqlTable);
      // запрос в БД
      result = db.getData(request);

      if (dynlen(result) == 0) continue;

      //заполнение полей класса
      Tab_[i].tableData.clear();
      Tab_[i].fillingObjectsWithData(result);

      countLine  = (needToFlip) ? dynlen(Tab_[i].tableData.nameUst[1]) : dynlen(Tab_[i].tableData.nameObjects);
      tags       = (needToFlip) ? Tab_[i].tableData.tagObjects : Tab_[i].tableData.tagUst[1];

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

        // если необходими перевернуть таблицу, то добавляем колонку
        //if (needToFlip) dynInsertAt(columns, "Ед.\nизм.", 1);

        //if (needToFlip) dynInsertAt(tags,    "unit",      1);

        // добавляем в конец таблицы колонку, чтобы была граница
        dynInsertAt(columns, "",    dynlen(columns) + 1);
        dynInsertAt(tags,    "end", dynlen(tags) + 1);

        // формирование колонок таблиц
        Tab_[i].classTable.insert_columns(columns, tags);
        Tab_[i].classTable.append_lines(countLine);
      }

      processingRequest(Tab_[i], countLine);
    }

    TabView.setTabEnable(true);
    IndicatorLoad.stop();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --->  END");
  }

  public printTables()
  {
    string nameTab;
    getValue("TAB1", "namedActiveRegister", nameTab);
    shared_ptr<StateTab> tab = getCurrentTab(nameTab);
    shared_ptr<ClassPrintTable> PT = new ClassPrintTable(tab);
    string msg = "Крата уставок \"" + tab.title + "\" отправлена на печать";
    openInformationPanel(makeDynString("$sInformation:" + msg + "", "$iTimer:0", "$bCritical:false"), "-1", "-1");
    CreateMultiInstanceMessage("Произведена печать карты уставок \"" + tab.title + "\" пользователем " + getUserName(), "", "armMessages_10", "armMessages_10", getHostname());
    PT.createTable();
  }

  // Обработка результата запроса в БД
  private processingRequest(anytype &tab, int countLine)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

//      DebugTN(__FUNCTION__ , ustName);

    //заполняем словарь для архивных данных
    dynClear(tab.tableData.rowsWithDataPLC);
    dynClear(tab.tableData.rowsWithDataArch);

    for (int j = 1; j <= countLine; ++j)
    {
      if (tab.needToFlip)
      {
        //PLC
        dynAppend(tab.tableData.rowsWithDataPLC[j], j);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.nameUst[1][j]);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.tagUst[1][j]);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.units[1][j]);

        for (int k = 1; k <= dynlen(tab.tableData.nameUst); ++k)
        {
          anytype value;
          int err = dpGet(tab.tableData.pathUst[k][j], value);

          if (err == 0)
          {
            sprintf(tab.tableData.valuesPLC[k][j], tab.tableData.format[k][j], value);
            strreplace(tab.tableData.valuesPLC[k][j], " ", "");
            dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.valuesPLC[k][j]);
          }
          else
          {
            DebugN("В модуле 'PARA' данный путь '" + tab.tableData.pathUst[k][j] + "' не найден!!!");
            continue;
          }
        }

        //Arch
        dynAppend(tab.tableData.rowsWithDataArch[j], j);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.nameUst[1][j]);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.tagUst[1][j]);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.units[1][j]);

        for (int k = 1; k <= dynlen(tab.tableData.valuesArch); ++k)
        {
          dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.valuesArch[k][j]);
        }
      }
      else
      {
        //PLC
        dynAppend(tab.tableData.rowsWithDataPLC[j], j);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.nameObjects[j]);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.tagObjects[j]);
        dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.units[j][1]);
        dynInsertAt(tab.tableData.format[j], makeDynString("", "", "", ""), 1);

        for (int k = 1; k <= dynlen(tab.tableData.nameUst[j]); ++k)
        {
          anytype value;

          if (dpExists(tab.tableData.pathUst[j][k]))
          {
            int err = dpGet(tab.tableData.pathUst[j][k], value);

            if (err == 0)
            {
              sprintf(tab.tableData.valuesPLC[j][k], tab.tableData.format[j][k + 4], value);
              strreplace(tab.tableData.valuesPLC[j][k], " ", "");
              dynAppend(tab.tableData.rowsWithDataPLC[j], tab.tableData.valuesPLC[j][k]);
            }
            else
            {
              DebugN("В модуле 'PARA' данный путь '" + tab.tableData.pathUst[j][k] + "' не найден!!!");
              continue;
            }
          }
          else
          {
            DebugN("В модуле 'PARA' данный путь '" + tab.tableData.pathUst[j][k] + "' не найден!!!");
            continue;
          }
        }

        //Arch
        dynAppend(tab.tableData.rowsWithDataArch[j], j);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.nameObjects[j]);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.tagObjects[j]);
        dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.units[j][1]);

        for (int k = 1; k <= dynlen(tab.tableData.nameUst[j]); ++k)
        {
          dynAppend(tab.tableData.rowsWithDataArch[j], tab.tableData.valuesArch[j][k]);
        }
      }
    }

    //заполняем виджет "таблица" данными
    fillTables(tab);
  }

  public writeToSQL()
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    IndicatorLoad.start();
    mapping mode = Mode_.getMode();

    if (!(bool)mode["PLC"]) updateRowsTable();
    else comparingArrays();

    for (int i = 1; i <= dynlen(Tab_); ++i)
    {
      int id = startThread("createQuery", i);
      waitThread(id);
      fillTables(Tab_[i], false, true);
      setValue("TAB1", "registerIcon", Tab_[i].id, "");
      Tab_[i].haveBeenChanges = false;
    }

    IndicatorLoad.stop();
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + "----> END");
  }

  private createMessage(anytype buff, string key)
  {
    string cur_value_   = buff["Current Value"];
    string old_value_   = buff["Old Value"];
    string table_name_  = buff["Title Table"];
    int row_            = buff["Selected Rows"];
    int col_            = buff["Selected Columns"];
    string name_column_ = buff["Title Column"];
    string tab_name_    = buff["Title Tab"];
    string nameUst;
    string msg, msg1;
    bool isUstOnOff = false;
    int col;
    getValue(table_name_, "nameToColumn", name_column_, col);
    string rowHeader;
    getValue(table_name_, "rowHeader", row_, rowHeader);

    string tagUst;
    string unit;

    shared_ptr<StateTab> tab = getCurrentTab(tab_name_);

    int r = (tab.needToFlip) ? col - 3 : row_ + 1;
    int c = (tab.needToFlip) ? row_ + 1 : col - 3;

    if (tab.nameSQLTable == "other")
    {
      nameUst = tab.tableData.nameUst[r][c];
      tagUst = tab.tableData.nameObjects[r];
    }
    else
    {
      nameUst = tab.tableData.nameObjects[r];
      tagUst = tab.tableData.nameUst[r][c];
    }
    unit = tab.tableData.units[r][c];

    strreplace(nameUst, "\n", "");
    strreplace(tagUst, "\n", "");

    msg = "Пользователь " + getUserName() + " отправил(а) команду сохранить устаку \"$1\"($5) в ПЛК";
    strreplace(msg, "$1", nameUst);
    strreplace(msg, "$5", tagUst);


    msg1 = "Пользователь " + getUserName() + " изменил(а) уставку \"$1\"($5) c $2  $3 на $4 $3";
    strreplace(msg1, "$1", nameUst);
    strreplace(msg1, "$2", old_value_);
    strreplace(msg1, "$3", unit);
    strreplace(msg1, "$4", cur_value_);
    strreplace(msg1, "$5", tagUst);


    if (!msg.isEmpty()) CreateMultiInstanceMessage(msg, "", "armMessages_10", "armMessages_10", getHostname());

    if (!msg.isEmpty()) CreateMultiInstanceMessage(msg1, "", "armMessages_10", "armMessages_10", getHostname());
  }


  private createQuery(int i)
  {
    DebugFTN("dbgmap", __LINE__, __FUNCTION__ + " --> START");

    string ust_tag;
    string obj_tag;
    string obj = Tab_[i].nameSQLTable;                   //получаем имя таблицы в SQL;
    bool ternTable = Tab_[i].needToFlip;                             //проверяем повернута таблица или нет;
    mapping mode = Mode_.getMode();
    dyn_string rows = Tab_[i].tableData.tagObjects;
    int shift = 0;

    for (int row = 1; row <= dynlen(rows); ++row)
    {

      if (Tab_[i].tableData.valuesArch[row] == Tab_[i].tableData.valuesPLC[row]) continue;

      string updateSQL = writeToDb;
      dyn_string val = ((bool)mode["PLC"]) ? Tab_[i].tableData.valuesPLC[row] : Tab_[i].tableData.valuesArch[row];

      strreplace(updateSQL, "$1", obj);
      strreplace(updateSQL, "$3", rows[row]);
      strreplace(updateSQL, "$2", strjoin(val, ","));

      DebugN(updateSQL);

      db.setData(updateSQL);
    }

    if ((bool)mode["PLC"]) Tab_[i].tableData.valuesArch = Tab_[i].tableData.valuesPLC;

    if ((bool)mode["PLC"]) Tab_[i].tableData.rowsWithDataArch = Tab_[i].tableData.rowsWithDataPLC;
  }

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

  ~EntityMapOthers() {DebugN("setPointMap is closed");}
};