#include "EquipmentDao.h"

EquipmentDao::EquipmentDao()
{

}

QStringList EquipmentDao::getEquipmentModelByIds(QStringList deviceIds)
{
    QStringList result;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT DISTINCT eei.model_id FROM eqpt_equipment_info eei WHERE 1 = 1 AND (";
    for (int i = 0; i < deviceIds.size() - 1; i++) {
        sql += "eei.id = ? OR ";
    }
    sql += "eei.id = ?);";
    query.prepare(sql);

    for (int i = 0; i < deviceIds.size(); i++) {
        query.bindValue(i, deviceIds.at(i));
    }

    bool isSuccess = query.exec();
    if (isSuccess) {
        while (query.next()) {
            result << query.value("model_id").toString();
        }
    } else {
        qDebug() << "Query execution failed: " << query.lastError().text();
    }

    return result;
}

BizEquipmentInfoDto EquipmentDao::getBizEqptInfoById(QString bizEqptId)
{
    BizEquipmentInfoDto result;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT bei.*, besi.standard_name FROM biz_equipment_info bei "
                  "JOIN biz_equipment_standard_equipment_relation besr ON bei.id = besr.equipment_id "
                  "LEFT JOIN biz_equipment_standard_info besi ON besi.id = besr.standard_id "
                  "WHERE bei.id = :id;";

    query.prepare(sql);
    query.bindValue(":id", bizEqptId);

    bool isSuccess = query.exec();
    if (isSuccess) {
        if (query.first()) {
            result.id = query.value("id").toString();
            result.equipmentNo = query.value("equipment_no").toString();
            result.labCode = query.value("lab_code").toString();
            result.groupCode = query.value("group_code").toString();
            result.equipmentName = query.value("equipment_name").toString();
            result.model = query.value("model").toString();
            result.manufactureNo = query.value("manufacture_no").toString();
            result.measureValidDate = query.value("measure_valid_date").toDate();
            result.productCountry = query.value("product_country").toString();
            result.manufacturer = query.value("manufacturer").toString();
            result.produceDate = query.value("produce_date").toString();
            result.purchaseDate = query.value("purchase_date").toString();
            result.unitPrice = query.value("unit_price").toString();
            result.usageStatus = query.value("usage_status").toString();
            result.qualityStatus = query.value("quality_status").toString();
            result.deptName = query.value("dept_name").toString();
            result.directorName = query.value("director_name").toString();
            result.supplierName = query.value("supplier_name").toString();
            result.location = query.value("location").toString();
            result.type = query.value("type").toString();
            result.standardType = query.value("standard_type").toString();
            result.category = query.value("category").toString();
            result.level = query.value("level").toString();
            result.measureCycle = query.value("measure_cycle").toString();
            result.unpackRecordName = query.value("unpack_record_name").toString();
            result.remark = query.value("remark").toString();
            result.standardName = query.value("standard_name").toString();
        }
    } else {
        qDebug() << "Query execution failed: " << query.lastError().text();
    }

    return result;
}

quint32 EquipmentDao::getBizEqptInfoCount(BizEquipmentRequest request)
{
    quint32 result = 0;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    // 构造查询语句
    QString sql = "SELECT COUNT(id) AS RECCT FROM biz_equipment_info";
    sql = QString("%1 %2;").arg(sql).arg(generateBizEqptInfoListPageWhereClause(request));
//    qDebug() << sql;

    // 绑定查询条件
    query.prepare(sql);
    bindValueBizEqptInfoListPage(query, request);

    if (query.exec() && query.next()) {
        result = query.value("RECCT").toInt();
    } else {
        LogUtil::PrintLog("ERROR", QString("查找标准设备数失败！[%1]").arg(query.lastError().text()));
    }
    return result;
}
QList<BizEquipmentInfoDto> EquipmentDao::getBizEqptInfoListPage(BizEquipmentRequest request, PageUtil & page)
{
    QList<BizEquipmentInfoDto> resultList;

    // 查询总数
    quint32 totalCount = getBizEqptInfoCount(request);

    page.totalCount = totalCount;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT bei.* FROM biz_equipment_info bei";

    sql = QString("%1 %2").arg(sql).arg(generateBizEqptInfoListPageWhereClause(request));

    // 添加分页查询
    sql = QString("%1 ORDER BY bei.create_time DESC").arg(sql);
    sql = QString("%1 %2").arg(sql).arg("LIMIT :offset, :limit;");
//    qDebug() << sql;

    query.prepare(sql);
    bindValueBizEqptInfoListPage(query, request);
    query.bindValue(":offset", page.currentPage * page.tableRowCount);
    query.bindValue(":limit", page.tableRowCount);

    bool isSuccess = query.exec();
    if (isSuccess) {
        while (query.next()) {
            BizEquipmentInfoDto bizEquipment;

            bizEquipment.id = query.value("id").toString();
            bizEquipment.equipmentNo = query.value("equipment_no").toString();
            bizEquipment.labCode = query.value("lab_code").toString();
            bizEquipment.groupCode = query.value("group_code").toString();
            bizEquipment.equipmentName = query.value("equipment_name").toString();
            bizEquipment.model = query.value("model").toString();
            bizEquipment.manufactureNo = query.value("manufacture_no").toString();
            bizEquipment.measureValidDate = query.value("measure_valid_date").toDate();
            bizEquipment.productCountry = query.value("product_country").toString();
            bizEquipment.manufacturer = query.value("manufacturer").toString();
            bizEquipment.produceDate = query.value("produce_date").toString();
            bizEquipment.purchaseDate = query.value("purchase_date").toString();
            bizEquipment.unitPrice = query.value("unit_price").toString();
            bizEquipment.usageStatus = query.value("usage_status").toString();
            bizEquipment.qualityStatus = query.value("quality_status").toString();
            bizEquipment.deptName = query.value("dept_name").toString();
            bizEquipment.directorName = query.value("director_name").toString();
            bizEquipment.supplierName = query.value("supplier_name").toString();
            bizEquipment.location = query.value("location").toString();
            bizEquipment.testRange = query.value("test_range").toString();
            bizEquipment.type = query.value("type").toString();
            bizEquipment.standardType = query.value("standard_type").toString();
            bizEquipment.category = query.value("category").toString();
            bizEquipment.level = query.value("level").toString();
            bizEquipment.measureCycle = query.value("measure_cycle").toString();
            bizEquipment.unpackRecordName = query.value("unpack_record_name").toString();

            resultList.append(bizEquipment);
        }
    } else {
        LogUtil::PrintLog("ERROR", QString("查询标准设备失败[%1]").arg(query.lastError().text()));
    }

    return resultList;
}
QList<BizEquipmentInfoDto> EquipmentDao::getValidBizEqptInfoList(const BizEquipmentRequest request)
{
    QList<BizEquipmentInfoDto> resultList;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT bei.* FROM biz_equipment_info bei";

    sql = QString("%1 %2").arg(sql).arg(generateBizEqptInfoListPageWhereClause(request));

    // 添加分页查询
    sql = QString("%1 ORDER BY bei.measure_valid_date DESC;").arg(sql);
//    qDebug() << sql;

    query.prepare(sql);
    bindValueBizEqptInfoListPage(query, request);

    bool isSuccess = query.exec();
    if (isSuccess) {
        while (query.next()) {
            BizEquipmentInfoDto bizEquipment;

            bizEquipment.id = query.value("id").toString();
            bizEquipment.equipmentNo = query.value("equipment_no").toString();
            bizEquipment.labCode = query.value("lab_code").toString();
            bizEquipment.groupCode = query.value("group_code").toString();
            bizEquipment.equipmentName = query.value("equipment_name").toString();
            bizEquipment.model = query.value("model").toString();
            bizEquipment.manufactureNo = query.value("manufacture_no").toString();
            bizEquipment.measureValidDate = query.value("measure_valid_date").toDate();
            bizEquipment.productCountry = query.value("product_country").toString();
            bizEquipment.manufacturer = query.value("manufacturer").toString();
            bizEquipment.produceDate = query.value("produce_date").toString();
            bizEquipment.purchaseDate = query.value("purchase_date").toString();
            bizEquipment.unitPrice = query.value("unit_price").toString();
            bizEquipment.usageStatus = query.value("usage_status").toString();
            bizEquipment.qualityStatus = query.value("quality_status").toString();
            bizEquipment.deptName = query.value("dept_name").toString();
            bizEquipment.directorName = query.value("director_name").toString();
            bizEquipment.supplierName = query.value("supplier_name").toString();
            bizEquipment.location = query.value("location").toString();
            bizEquipment.testRange = query.value("test_range").toString();
            bizEquipment.type = query.value("type").toString();
            bizEquipment.standardType = query.value("standard_type").toString();
            bizEquipment.category = query.value("category").toString();
            bizEquipment.level = query.value("level").toString();
            bizEquipment.measureCycle = query.value("measure_cycle").toString();
            bizEquipment.unpackRecordName = query.value("unpack_record_name").toString();

            resultList.append(bizEquipment);
        }
    } else {
        LogUtil::PrintLog("ERROR", QString("查询标准设备失败[%1]").arg(query.lastError().text()));
    }

    return resultList;
}

QStringList EquipmentDao::getBelongStandardIdByStdEquipmentId(QString stdEqptId)
{
    QStringList resultList;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT STANDARD_ID FROM biz_equipment_standard_equipment_relation re WHERE re.equipment_id = :bizEqptId;";

    query.prepare(sql);
    query.bindValue(":bizEqptId", stdEqptId);

    if (query.exec()) {
        while (query.next()) {
            resultList << query.value(0).toString();
        }
    } else {
        LogUtil::PrintLog("ERROR", QString("查询标准设备所属标准装置[%1]失败[%2]").arg(stdEqptId).arg(query.lastError().text()));
    }

    return resultList;
}

bool EquipmentDao::deleteBizEquipment(QString bizEqptId)
{
    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "DELETE FROM biz_equipment_info bei WHERE bei.id = :id;";

    query.prepare(sql);
    query.bindValue(":id", bizEqptId);

    dbLocal.transaction();

    bool isSuccess = query.exec();
    if (!isSuccess) {
        dbLocal.rollback();
        LogUtil::PrintLog("ERROR", QString("删除标准设备[%1]失败[%2]").arg(bizEqptId).arg(query.lastError().text()));
        return false;
    }

    dbLocal.commit();
    return isSuccess;
}

QString EquipmentDao::createBizStandardEquipment(const BizEquipmentInfoDto newBizEqpt, const QStringList stdIdList, const QList<BizEquipmentUncertaintyDto> beuDataList)
{
    quint64 newId = idWorker.nextId();

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "INSERT INTO biz_equipment_info "
                  "(id, lab_code, group_code, equipment_name, manufacturer, manufacture_no, model, test_range, measure_valid_date, create_time, update_time) "
                  "VALUES "
                  "(:id, :labCode, :groupCode, :name, :maker, :serialNo, :model, :testRange, :validDate, :createTime, :createTime);";

    query.prepare(sql);
    query.bindValue(":id", newId);
    query.bindValue(":labCode", newBizEqpt.labCode);
    query.bindValue(":groupCode", newBizEqpt.groupCode);
    query.bindValue(":name", newBizEqpt.equipmentName);
    query.bindValue(":maker", newBizEqpt.manufacturer);
    query.bindValue(":serialNo", newBizEqpt.manufactureNo);
    query.bindValue(":model", newBizEqpt.model);
    query.bindValue(":testRange", newBizEqpt.testRange);
    query.bindValue(":validDate", newBizEqpt.measureValidDate.toString("yyyy-MM-dd"));
    query.bindValue(":createTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

//    qDebug() << sql;

    // 开启事务
    dbLocal.transaction();

    if (query.exec()) {
        // 保存成功 保存所属标准装置
        for (QString standardId : stdIdList) {
            QString relSql = "INSERT INTO biz_equipment_standard_equipment_relation (id, equipment_id, standard_id, update_time) VALUES (:id, :eqptId, :stdId, :updateTime);";
            query.prepare(relSql);
            query.bindValue(":id", idWorker.nextId());
            query.bindValue(":eqptId", newId);
            query.bindValue(":stdId", standardId);
            query.bindValue(":updateTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

//            qDebug() << relSql;

            if (query.exec() == false) {
                dbLocal.rollback();
                LogUtil::PrintLog("ERROR", QString("新增标准设备时，新增标准设备和标准装置关联关系失败[%1][%2][%3]").arg(newBizEqpt.equipmentName).arg(standardId).arg(query.lastError().text()));
                return "-1";
            }
        }

        // 保存不确定度数据
        for (BizEquipmentUncertaintyDto beuData : beuDataList) {
            QString uncertSql = "INSERT INTO zd_standard_equipment_uncertainty "
                                "(id, equ_id, uncertainty_type, uncertainty_unit, uncertainty, standard_unit, standard_value, k_value, create_time, update_time) "
                                "VALUES "
                                "(:id, :equId, :uncertaintyType, :uncertaintyUnit, :uncertainty, :standardUnit, :standardValue, :kValue, :createTime, :createTime);";

            query.prepare(uncertSql);
            query.bindValue(":id", idWorker.nextId());
            query.bindValue(":equId", newId);
            query.bindValue(":uncertaintyType", beuData.uncertaintyType);
            query.bindValue(":uncertaintyUnit", beuData.uncertaintyUnit);
            query.bindValue(":uncertainty", beuData.uncertainty);
            query.bindValue(":standardUnit", beuData.standardUnit);
            query.bindValue(":standardValue", beuData.standardValue);
            query.bindValue(":kValue", beuData.kValue);
            query.bindValue(":createTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

//            qDebug() << uncertSql;

            if (!query.exec()) {
                // 保存失败
                dbLocal.rollback();
                LogUtil::PrintLog("ERROR", QString("新增标准设备时，标准设备不确定度添加失败[bizEqptId = %1][%2]").arg(newId).arg(query.lastError().text()));

                return "-1";
            }
        }

        // 提交事务
        dbLocal.commit();
        return QString::number(newId);
    } else {
        // 回滚事务
        dbLocal.rollback();
        LogUtil::PrintLog("ERROR", QString("新增标准设备[%1]失败[%2]").arg(newBizEqpt.equipmentName).arg(query.lastError().text()));
        return "-1";
    }
}

bool EquipmentDao::editBizStandardEquipment(const BizEquipmentInfoDto bizEqpt, const QStringList relRemoveList, const QStringList relAddList, const QList<BizEquipmentUncertaintyDto> beuDataList)
{
    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "UPDATE biz_equipment_info "
                  "SET "
                  "lab_code = :labCode, group_code = :groupCode, equipment_name = :name, manufacturer = :maker, "
                  "manufacture_no = :serialNo, model = :model, test_range = :testRange, measure_valid_date = :validDate, "
                  "update_time = :updateTime "
                  "WHERE id = :id;";

    query.prepare(sql);
    query.bindValue(":labCode", bizEqpt.labCode);
    query.bindValue(":groupCode", bizEqpt.groupCode);
    query.bindValue(":name", bizEqpt.equipmentName);
    query.bindValue(":maker", bizEqpt.manufacturer);
    query.bindValue(":serialNo", bizEqpt.manufactureNo);
    query.bindValue(":model", bizEqpt.model);
    query.bindValue(":testRange", bizEqpt.testRange);
    query.bindValue(":validDate", bizEqpt.measureValidDate.toString("yyyy-MM-dd"));
    query.bindValue(":updateTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));
    query.bindValue(":id", bizEqpt.id);

//    qDebug() << sql;

    // 开启事务
    dbLocal.transaction();

    if (query.exec()) {
        // 保存成功
        if (relRemoveList.isEmpty() == false) {
            QString placeholders = QString("?,").repeated(relRemoveList.size()).chopped(1);
            QString relRmvSql = QString("DELETE FROM biz_equipment_standard_equipment_relation WHERE equipment_id = :eqptId AND standard_id IN (%1);").arg(placeholders);
//            qDebug() << relRmvSql;
            query.prepare(relRmvSql);
            query.addBindValue(bizEqpt.id);
            for (QString relRmv : relRemoveList) {
                query.addBindValue(relRmv);
            }
            if (query.exec() == false) {
                dbLocal.rollback();
                LogUtil::PrintLog("ERROR", QString("编辑标准设备时，移除标准设备和标准装置旧关联关系失败[%1][%2]").arg(bizEqpt.equipmentName).arg(query.lastError().text()));
                return false;
            }
        }

        for (QString standardId : relAddList) {
            QString relSql = "INSERT INTO biz_equipment_standard_equipment_relation (id, equipment_id, standard_id, update_time) VALUES (:id, :eqptId, :stdId, :updateTime);";
            query.prepare(relSql);
            query.bindValue(":id", idWorker.nextId());
            query.bindValue(":eqptId", bizEqpt.id);
            query.bindValue(":stdId", standardId);
            query.bindValue(":updateTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

//            qDebug() << relSql;

            if (query.exec() == false) {
                dbLocal.rollback();
                LogUtil::PrintLog("ERROR", QString("编辑标准设备时，新增标准设备和标准装置关联关系失败[%1][%2][%3]").arg(bizEqpt.equipmentName).arg(standardId).arg(query.lastError().text()));
                return false;
            }
        }

        // 删除旧的不确定度数据
        QString uncertRmvSql = "DELETE FROM zd_standard_equipment_uncertainty WHERE equ_id = :id;";

        query.prepare(uncertRmvSql);
        query.bindValue(":id", bizEqpt.id);

        if (query.exec() == false) {
            dbLocal.rollback();
            LogUtil::PrintLog("ERROR", QString("编辑标准设备时，标准设备不确定度删除失败[%1][%2]").arg(bizEqpt.equipmentName).arg(query.lastError().text()));
            return false;
        }

        // 保存不确定度数据
        for (BizEquipmentUncertaintyDto beuData : beuDataList) {
            QString uncertSql = "INSERT INTO zd_standard_equipment_uncertainty "
                                "(id, equ_id, uncertainty_type, uncertainty_unit, uncertainty, standard_unit, standard_value, k_value, create_time, update_time) "
                                "VALUES "
                                "(:id, :equId, :uncertaintyType, :uncertaintyUnit, :uncertainty, :standardUnit, :standardValue, :kValue, :createTime, :createTime);";

            query.prepare(uncertSql);
            query.bindValue(":id", idWorker.nextId());
            query.bindValue(":equId", bizEqpt.id);
            query.bindValue(":uncertaintyType", beuData.uncertaintyType);
            query.bindValue(":uncertaintyUnit", beuData.uncertaintyUnit);
            query.bindValue(":uncertainty", beuData.uncertainty);
            query.bindValue(":standardUnit", beuData.standardUnit);
            query.bindValue(":standardValue", beuData.standardValue);
            query.bindValue(":kValue", beuData.kValue);
            query.bindValue(":createTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

            if (!query.exec()) {
                // 保存失败
                dbLocal.rollback();
                LogUtil::PrintLog("ERROR", QString("编辑标准设备时，标准设备不确定度添加失败[bizEqptId = %1][%2]").arg(beuData.equId).arg(query.lastError().text()));

                return false;
            }
        }

        // 提交事务
        dbLocal.commit();
        return true;
    } else {
        // 回滚事务
        dbLocal.rollback();
        LogUtil::PrintLog("ERROR", QString("编辑标准设备[%1]失败[%2]").arg(bizEqpt.equipmentName).arg(query.lastError().text()));
        return false;
    }
}

QList<QStringList> EquipmentDao::getBizEqptStandardList()
{
    QList<QStringList> resultList;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT id, standard_name FROM biz_equipment_standard_info;";

    query.prepare(sql);

    if (query.exec()) {
        while (query.next()) {
            QStringList item;
            item << query.value("id").toString() << query.value("standard_name").toString();

            resultList.append(item);
        }
    } else {
        LogUtil::PrintLog("ERROR", QString("查询标准装置列表失败[%1]").arg(query.lastError().text()));
    }

    return resultList;
}

QList<BizEquipmentUncertaintyDto> EquipmentDao::getBizEquipmentUncertaintyByEqpt(QString bizEquId)
{
    QList<BizEquipmentUncertaintyDto> resultList;

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "SELECT * FROM zd_standard_equipment_uncertainty WHERE equ_id = :id";
    query.prepare(sql);
    query.bindValue(":id", bizEquId);

//    qDebug() << sql << bizEquId;

    if(query.exec()){
        while(query.next()){
            BizEquipmentUncertaintyDto beuDto;

            beuDto.id = query.value("id").toString();
            beuDto.equId = query.value("equ_id").toString();
            beuDto.uncertaintyType = query.value("uncertainty_type").toString();
            beuDto.uncertaintyTypeName = beuDto.uncertaintyType == "0" ? "不确定度" : "相对不确定度";
            beuDto.uncertaintyUnit = query.value("uncertainty_Unit").toString();
            beuDto.uncertainty = query.value("uncertainty").toString();
            beuDto.standardUnit = query.value("standard_unit").toString();
            beuDto.standardValue = query.value("standard_value").toString();
            beuDto.kValue = query.value("k_value").toString();

            resultList.append(beuDto);
        }
    } else {
        LogUtil::PrintLog("ERROR", QString("标准设备不确定度查询失败[bizEqptId = %1][%2]").arg(bizEquId).arg(query.lastError().text()));
    }

    return resultList;
}

bool EquipmentDao::insertBizEquipmentUncertainty(BizEquipmentUncertaintyDto beuData)
{
    quint64 newId = idWorker.nextId();

    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "INSERT INTO zd_standard_equipment_uncertainty "
                  "(id, equ_id, uncertainty_type, uncertainty_unit, uncertainty, standard_unit, standard_value, k_value, create_time, update_time) "
                  "VALUES "
                  "(:id, :equId, :uncertaintyType, :uncertaintyUnit, :uncertainty, :standardUnit, :standardValue, :kValue, :createTime, :createTime);";

    query.prepare(sql);
    query.bindValue(":id", newId);
    query.bindValue(":equId", beuData.equId);
    query.bindValue(":uncertaintyType", beuData.uncertaintyType);
    query.bindValue(":uncertaintyUnit", beuData.uncertaintyUnit);
    query.bindValue(":uncertainty", beuData.uncertainty);
    query.bindValue(":standardUnit", beuData.standardUnit);
    query.bindValue(":standardValue", beuData.standardValue);
    query.bindValue(":kValue", beuData.kValue);
    query.bindValue(":createTime", QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss"));

//    qDebug() << sql;

    // 开启事务
    dbLocal.transaction();

    if (!query.exec()) {
        // 保存失败
        dbLocal.rollback();
        LogUtil::PrintLog("ERROR", QString("标准设备不确定度添加失败[bizEqptId = %1][%2]").arg(beuData.equId).arg(query.lastError().text()));

        return false;
    }

    dbLocal.commit();
    return true;
}

bool EquipmentDao::deleteBizEquipmentUncertainty(QString bizEquId)
{
    QSqlDatabase dbLocal = CDbConnectionPool::instance().openConnection("local");
    QSqlQuery query(dbLocal);

    QString sql = "DELETE FROM zd_standard_equipment_uncertainty WHERE equ_id = :id;";

    query.prepare(sql);
    query.bindValue(":id", bizEquId);

//    qDebug() << sql << bizEquId;

    dbLocal.transaction();

    bool isSuccess = query.exec();
    if (!isSuccess) {
        dbLocal.rollback();
        LogUtil::PrintLog("ERROR", QString("标准设备不确定度删除失败[%1][%2]").arg(bizEquId).arg(query.lastError().text()));
        return false;
    }

    dbLocal.commit();
    return isSuccess;
}

QString EquipmentDao::generateBizEqptInfoListPageWhereClause(BizEquipmentRequest request)
{
    QString where = "WHERE 1=1";
    if (!request.labCode.isEmpty()) {
        where = QString("%1 AND lab_code = :labCode").arg(where);
    }
    if (!request.groupCode.isEmpty()) {
        where = QString("%1 AND group_code = :groupCode").arg(where);
    }
    if (!request.equipmentName.isEmpty()) {
        where = QString("%1 AND equipment_name like :eqptName").arg(where);
    }
    if (!request.model.isEmpty()) {
        where = QString("%1 AND model like :model").arg(where);
    }
    if (!request.manufactureNo.isEmpty()) {
        where = QString("%1 AND manufacture_no like :manuNo").arg(where);
    }
    if (!request.validDateStart.isEmpty()) {
        where = QString("%1 AND measure_valid_date > :start").arg(where);
    }
    if (!request.validDateEnd.isEmpty()) {
        where = QString("%1 AND measure_valid_date <= :end").arg(where);
    }

    return where;
}

void EquipmentDao::bindValueBizEqptInfoListPage(QSqlQuery query, BizEquipmentRequest request)
{
    if (!request.labCode.isEmpty()) {
        query.bindValue(":labCode", request.labCode);
    }
    if (!request.groupCode.isEmpty()) {
        query.bindValue(":groupCode", request.groupCode);
    }
    if (!request.equipmentName.isEmpty()) {
        query.bindValue(":eqptName", "%" + request.equipmentName + "%");
    }
    if (!request.model.isEmpty()) {
        query.bindValue(":model", "%" + request.model + "%");
    }
    if (!request.manufactureNo.isEmpty()) {
        query.bindValue(":manuNo", "%" + request.manufactureNo + "%");
    }
    if (!request.validDateStart.isEmpty()) {
        query.bindValue(":start", request.validDateStart);
    }
    if (!request.validDateEnd.isEmpty()) {
        query.bindValue(":end", request.validDateEnd);
    }
}