const connection = require("../utils/connectDB");
const { execProc } = require("../utils/concatSQL");
const Device = function () {};

Device.getAllExcludeError = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_device_getAllError`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addExcludeError = async (message, model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_device_addError`, [message, model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteExcludeError = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_device_deleteError`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllStation = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_getAllStation`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addLineForStation = async (number, port, clear, ip, station) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_addLineForStation`, [
        number,
        port,
        clear,
        ip,
        station,
      ]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllLineOfStation = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_getAllLineOfStation`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.editLine = async (id, number, port, clear, ip) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_editLine`, [id, number, port, clear, ip]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addGroup = async (group_name, created_by, created_at, action) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_addGroup`, [
        group_name,
        created_by,
        created_at,
        action,
      ]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pData: res[0][0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addModel = async (id_model, id_group, type, created_at) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_addModel`, [
        id_model,
        id_group,
        type,
        created_at,
      ]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addCmdForGroup = async (group_id, cmd_message) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_addCmdForGroup`, [group_id, cmd_message]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addCmdForModel = async (model_id, cmd_message) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_addCmdForModel`, [model_id, cmd_message]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addModelForGroup = async (group_id, idModel) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_addModelForGroup`, [group_id, idModel]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllGroup = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllGroup`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllModel = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllModel`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllGroupOfModel = async (id_model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllGroupOfModel`, [id_model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllModelOfGroup = async (id_group) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllModelOfGroup`, [id_group]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllCmdOfGroup = async (id_group) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllCmdOfGroup`, [id_group]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllCmdOfModel = async (id_model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_getAllCmdOfModel`, [id_model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteCmdOfGroup = async (mess, id_group) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_deleteCmdOfGroup`, [mess, id_group]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteCmdOfModel = async (mess, id_model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_deleteCmdOfModel`, [mess, id_model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteModelOfGroup = async (id_model, id_group) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_deleteModelOfGroup`, [id_model, id_group]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.clearGroupOfModel = async (id_model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_clearGroupOfModel`, [id_model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.clearCmdOfModel = async (id_model) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_clearCmdOfModel`, [id_model]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.editGroup = async (id, name) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_editGroup`, [id, name]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.editModel = async (id, type) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_editModel`, [id, type]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteGroup = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_deleteGroup`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteModel = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_group_deleteModel`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.editStation = async (
  id,
  ip,
  tftp,
  network,
  netmask,
  gateway,
  gateway_line,
  netmask_line,
  APC1,
  APC2,
  portTelnet,
  APC1_port,
  APC2_port
) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_editStation`, [
        id,
        ip,
        tftp,
        network,
        netmask,
        gateway,
        gateway_line,
        netmask_line,
        APC1,
        APC2,
        portTelnet,
        APC1_port,
        APC2_port
      ]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.enableLine = async (id, status) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_station_enableLine`, [id, status]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addLog = async (
  log_line,
  log_content,
  log_status,
  created_at,
  created_by,
  PID,
  SN
) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_log_addLog`, [
        log_line,
        log_content,
        log_status,
        created_at,
        created_by,
        PID,
        SN,
      ]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllLogOfLine = async (log_line) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_log_getAllLogOfLine`, [log_line]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.changeCommand = async (id, command) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_log_changeCommand`, [id, command]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        console.log(result);
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllValue = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_value_getAllValue`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addValue = async (key, value) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_value_addValue`, [key, value]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.deleteValue = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_value_deleteValue`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.addItem = async (item_SN, item_PID, item_desrc, SN_parent_item, created_at) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_item_addItem`, [item_SN, item_PID, item_desrc, SN_parent_item, created_at]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pCode: res[0][0].pCode,
          pMess: res[1][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllItem = async () => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_item_getAllItem`, []);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getAllItemBySNParent = async (id) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_item_getAllItemBySNParent`, [id]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};

Device.getLogByCreatedAt = async (created_at) => {
  return new Promise((resolve, reject) => {
    try {
      let sql = execProc(`pro_log_getLogByCreatedAt`, [created_at]);
      let result;
      connection.query(sql, (err, res) => {
        if (err) {
          console.log(err.sqlMessage);
          result = {
            pCode: 0,
            pMess: err.sqlMessage,
            pData: null,
          };
          reject(result);
        }
        result = {
          pData: res[0],
          pCode: res[1][0].pCode,
          pMess: res[2][0].pMess,
        };
        resolve(result);
      });
    } catch (error) {
      let result = {
        pCode: 0,
        pMess: error.message,
      };
      reject(result);
    }
  });
};
module.exports = Device;