data2/rentichengfenApi.git

const express = require('express');
const bodyParser = require('body-parser');
const mysql = require('mysql2');
const fs = require('fs').promises;
const path = require('path');
const logger = require(path.resolve(__dirname, 'logger'));
// 转成能识别的url
const ViapiUtil = require('@alicloud/viapi-utils');
 
const facebody20191230 = require('@alicloud/facebody20191230');
const OpenApi = require('@alicloud/openapi-client');
const Util = require('@alicloud/tea-util');
const thirdPartyApi = require(path.resolve(__dirname, 'thirdPartyApi'));
 
const app = express();
const port = 3000;
 
// 设置 JSON 请求体的最大大小为 5MB
app.use(express.json({ limit: '5mb' }));
 
// 设置 URL 编码请求体的最大大小为 5MB
app.use(express.urlencoded({ extended: true, limit: '5mb' }));
 
// 使用 body-parser 中间件解析 JSON 请求体
app.use(bodyParser.json());
 
// 创建 MySQL 连接池
const pool = mysql.createPool({
    host: 'rds.leon056.com',
    port: 26422, // 确保端口号正确
    user: 'root',
    password: 'PalGain2007', // 请替换为您的数据库密码
    database: 'hemodialysis_sys'  // 请替换为您的数据库名称
});
 
const createClient = () => {
    // 工程代码泄露可能会导致 AccessKey 泄露，并威胁账号下所有资源的安全性。以下代码示例仅供参考。
    // 建议使用更安全的 STS 方式，更多鉴权访问方式请参见：https://help.aliyun.com/document_detail/378664.html。
    let config = new OpenApi.Config({
        // 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_ID。
        accessKeyId: 'LTAI5tPBxZiqgd9h6gcL9Qzc',
        // 必填，请确保代码运行环境设置了环境变量 ALIBABA_CLOUD_ACCESS_KEY_SECRET。
        accessKeySecret: 'IE6nsjJMTul2ZHkeQ27bg4wmWIngTu',
    });
    // Endpoint 请参考 https://api.aliyun.com/product/facebody
    config.endpoint = `facebody.cn-shanghai.aliyuncs.com`;
    return new facebody20191230.default(config);
}
app.get('/', (req, res) => {
    
    res.json({mas:'hahahahh'});
  });
app.get('/test', async (req, res) => {
try {
const token=await thirdPartyApi.getAccessToken()
logger.info('返回token=='+JSON.stringify(token))
res.json(token);
}catch(err){
    logger.info('catch=='+JSON.stringify(err))
}
});
// 定义 /webuser 路由处理器  用患者code 换信息
app.post('/webuser', async (req, res) => {
    const mode=req.body
    logHttps(mode)
    const action = req.body.action;
    const deviceID = req.body.deviceID;
    const type = req.body.type;
    const xid = req.body.xid;
    logger.info(`成分分析仪用户请求req body action=${action},deviceID=${deviceID},type=${type},xid=${xid}`)
    if (action === 'doWebUser' && deviceID && type !== undefined) {
        try {
            const pathParams={code:xid}
            const data = await thirdPartyApi.fetchThirdPartyData('/patient/info/detail2', 'POST', {}, null,  pathParams,{});
            logger.info(`get patInfo data=${JSON.stringify(data)}`)
            console.log('get patInfo ----',data.data)
            // console.log(data)
            if(data?.code===200&&data?.message==='SUCCESS'&&data?.data){
                const user = data.data;
                response = {
                    recode: 2001,
                    userinfo: {
                        name: user.patientName,
                        sex: user.patientGenderText,
                        age: user.age,
                        usernum: user.code, //这个是数据返回会携带回来UID
                        address: user.patientAddress,
                        remark: '患者人脸识别111'
                    },
                    remsg: "success"
                };
                logger.info('Successfully returned patient information')
                console.log('Successfully returned patient information')
            }else{
                response = {
                    retcode: 1001,
                    remsg: "没有找到患者，请先检查患者code"
                };
            }
            res.json(response);
 
        } catch (err) {
            console.error(err);
            logger.error(err)
            res.status(500).json({ retCode: "-1", msg: err });
        }
    } else {
        // 如果请求参数不符合预期，则返回错误信息
        res.status(400).json({ retCode: "-1", msg: "Invalid request parameters" });
    }
});
// 定义人脸识别  用base64图片文件换患者信息
app.post('/faceuser', async (req, res) => {
    try{
        const action = req.body.action;
        const deviceID = req.body.deviceID;
        // base64图像内容，base64 编码(长宽像素值范围：80*80~200*200，注意：图片的base64 编码是不包含图片头的，如 data:image/jpg;base64,)
        const content = req.body.content;
        const mode=req.body
        mode.content=''
        logger.info(`人脸识别请求deviceID=${deviceID},action=${action}`)
        if (action == 'doFace' && deviceID && content) {
            // 转成oss路径
            const ossurl = await base64toFile(content, deviceID)
            logger.info(`得到oss图片路径=${ossurl}`)
            let searchFaceRequest = new facebody20191230.SearchFaceRequest({
                dbName: 'Face_systemtest',
                imageUrl: ossurl,
                limit: 1,
            });
 
            let runtime = new Util.RuntimeOptions({});
            try {
                // 复制代码运行请自行打印 API 的返回值
                const data = await createClient().searchFaceWithOptions(searchFaceRequest, runtime);
                const matchList = data.body.data?.matchList
                let response = null
                if (matchList?.length > 0) {
                    const faceItems = matchList[0].faceItems
                    if (faceItems?.length === 0) {
                        logger.info(`没有找到患者对应的人脸`)
                        response = {
                            retCode: "0",
                            msg: "没有找到患者，请先检查患者code"
                        };
                    } else if (faceItems[0].score >= 0.2) {
                        const entityId = faceItems[0].entityId
                        console.log(entityId, '患者id找到了')
                        const pathParams={code:entityId}
                        const data = await thirdPartyApi.fetchThirdPartyData('/patient/info/detail2', 'POST', {}, null,  pathParams,{});
                        logger.info(`患者接口请求成功`)
                        if(data?.code===200&&data?.message==='SUCCESS'&&data?.data){
                            const user = data.data;
                            response = {
                                recode: 2001,
                                userinfo: {
                                    name: user.patientName,
                                    sex: user.patientGenderText,
                                    age: user.age,
                                    usernum: user.code, //这个是数据返回会携带回来UID
                                    address: user.patientAddress,
                                    remark: '患者人脸识别111'
                                },
                                remsg: "success"
                            };
                            logger.info(`返回患者信息成功=${user.patientName}`)
                        }else{
                            response = {
                                retcode: 1001,
                                remsg: "没有找到患者，请先检查患者code"
                            };
                        }
                        
                    } else {
                        response = {
                            retcode: 1001,
                            remsg: "没有找到患者，请先检查患者code"
                        };
                    }
                    res.json(response);
                }
                else {
                    res.status(500).json({ retCode: "-1", msg: "没有识别到患者" });
                }
            } catch (error) {
                // 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
                // 错误 message
                console.log(error)
                res.status(400).json({ retCode: "-1", msg: error });
 
            }
        } else {
            // 如果请求参数不符合预期，则返回错误信息
            res.status(400).json({ retCode: "-1", msg: "Invalid request parameters 333"  });
        }
    }catch(err){
        res.status(400).json({ retCode: "-1", msg: err });
    }
 
 
 
 
})
// 定义设备数据回传接口
// 定义数据回传接口
app.post('/webResults',async (req, res) =>{
    const action = req.body.action;
    const deviceID = req.body.deviceID;
    const mode=req.body
    mode.action='webResults'
    logger.info(`人体成分分析仪结果返回请求deviceID=${deviceID},action=${JSON.stringify(mode)}`)
    try {
      
        const datas=mode.datas
        datas.forEach(async element => {
            // 组合数据
            let data={}
            // 没有BF
            if(element.fatFree){
                data={
                    id:0,
                    code:element.recordNo,
                    patientCode:element.userID,
                    commTime:element.measureTime,
                    rtcfJsonBf:JSON.stringify(element)
                }
            }
            // 没有BMI
            if(element.bmi){
                data={
                    id:0,
                    code:element.recordNo,
                    patientCode:element.userID,
                    commTime:element.measureTime,
                    rtcfJsonBmi:JSON.stringify(element)
                }
            }
            console.log(data)
            const resdata = await thirdPartyApi.fetchThirdPartyData('/patient/rtcf/result/save', 'POST', {}, data,{},{});
            logger.info(`结果插入成功`)
            console.log(resdata)
        });
        response = {
            recode: "2000",
            remsg: "成功2222"
        };
        res.json(response)
       
    }catch(err){
        logger.errer(`结果插入失败`)
        res.status(4000).json({ reCode: "4000", msg: "Invalid request parameters" });
    }
    
})
// 定义北京悦琦创通科技有限公司VBP-10系列HTTP通信协议
/**
 * patientId={patientId} 
 */
app.get('/getpatientInfo',async(req,res)=>{
    // 使用req.query访问查询字符串参数
  const patientId = req.query.patientId;
  const clientCode = req.query.clientCode;
  const mode={"action":'getpatientInfo',"patientId":patientId,}
  console.log(patientId,'-----------------',clientCode)
  logger.info(`血流量设备请求患者信息，请求参数=${patientId},clintCode=${clientCode}`)
  if(patientId&&clientCode){
    // 输出传入的patientid值
    try {
        //查询参数
        const pathParams={
            clientCode:clientCode,
            patQueryCode:patientId
        }
        const data = await thirdPartyApi.fetchThirdPartyDataNoToke('/patient/info/listPatsPublic', 'POST', {}, null,  pathParams,{});
        console.log(data.data.list)
        const rows= data.data.list
        if (rows.length > 0) {
            let users=[]
            rows.forEach(user=>{
                users.push({
                    patientId: user.code,
                    fullName: user.patientName,
                    gender: user.patientGender,
                    age: user.age,
                    birthday:'',
                    phoneNum:user.patientMobile,
                    address: user.patientAvatarIcon,
                    idType: user.patientIdentityType,
                    idNum: user.patientIdentityNo,
                    height:'',
                    weight:'',
                    requestDoctor:'',
                    requestDept :"",
                    examDoctor:'',
                    examDept:"",
                    diagnosisDoctor:''
                })
            })
            logger.info(`血流量设备请求患者信息，请求成功返回患者信息=${JSON.stringify(users)}`)
            res.json(users);
        } else {
            logger.info(`血流量设备请求患者信息，请求成功返回患者信息=[]`)
            res.json([]);
        }
    } catch (err) {
        console.error(err);
        logger.errer(`血流量设备请求患者信息，请求失败=${err}`)
        res.status(500).json({ retCode: "-1", msg: "接口出错！"+err });
    }
 
  }else{
    // 如果请求参数不符合预期，则返回错误信息
    
    res.status(400).json({ retCode: "-1", msg: "请求参数出错" });
  }
 
})
/**
 * PostCheckExam  病人信息及检测结果以JSON的形式回传至服务器
 */
app.post('/PostCheckExam',async (req,res)=>{
    try {
        const clientCode = req.query.clientCode;
        console.log('-------------------',clientCode)
        if(!clientCode){
            res.json({"Msg": "请求参数没有clientCode", "Status": "err" });
            return
        }
        const body=req.body
        console.log(body)
        logger.info(`血流量设备上报结果，请求信息clientCode=${clientCode}`)
        // 组合上传数据
        const data={
            id:0,
            code:'',
            patient_code :body.patientId,
            client_code:clientCode,
            exam_id:body.examId,
            SBPLB:body.SBPLB,
            MBPLB:body.MBPLB,
            DBPLB:body.DBPLB,
            PPLB:body.PPLB,
            SBPRB:body.SBPRB,
            MBPRB:body.MBPRB,
            DBPRB:body.DBPRB,
            PPRB:body.PPRB,
            SBPLA:body.SBPLA,
            MBPLA:body.MBPLA,
            DBPLA:body.DBPLA,
            SBPRA:body.SBPRA,
            MBPRA:body.MBPRA,
            DBPRA:body.DBPRA,
            ABIL:body.ABIL,
            ABIR:body.ABIR,
            BAIL:body.BAIL,
            BAIR:body.BAIR,
            PWVL:body.PWVL,
            PWVR:body.PWVR,
            TBIL:body.TBIL,
            TBIR:body.TBIR,
            SBPLAPTA:body.SBPLAPTA,
            DBPLAPTA:body.DBPLAPTA,
            MBPLAPTA:body.MBPLAPTA,
            PPLAPTA:body.PPLAPTA,
            SBPRAPTA:body.SBPRAPTA,
            DBPRAPTA:body.DBPRAPTA,
            MBPRAPTA:body.MBPRAPTA,
            PPRAPTA:body.PPRAPTA,
            SBPLAFA:body.SBPLAFA,
            DBPLAFA:body.DBPLAFA,
            MBPLAFA:body.MBPLAFA,
            PPLAFA:body.PPLAFA,
            SBPRAFA:body.SBPRAFA,
            DBPRAFA:body.DBPRAFA,
            MBPRAFA:body.MBPRAFA,
            PPRAFA:body.PPRAFA,
            index_LB:body.indexLB,
            index_RB:body.indexRB,
            index_LAPTA:body.indexLAPTA,
            index_RAPTA:body.indexRAPTA,
            index_LAFA:body.indexLAFA,
            index_RAFA:body.indexRAFA,
            image:body.image,
            request_doctor:body.requestDoctor,
            request_department:body.requestDepartment,
            request_date:body.requestDate,
            exam_department:body.examDepartment,
            diagnostician_doctor:body.diagnosticianDoctor,
            check_date:body.checkDate,
            check_result:body.checkResult,
            diagnosis:body.diagnosis,
            exam_type_id:body.examTypeId,
            exam_type_name:body.examTypeName,
            operator_doctor:body.operatorDoctor,
            abi_advice:body.abiAdvice,
            pwv_result:body.pwvResult
        }
        const resdata = await thirdPartyApi.fetchThirdPartyDataNoToke('/patient/result/from/doppler/blood/flow/device/saveData', 'POST', {}, data,{},{});
        console.log(resdata)
        if(resdata.code===200&&resdata?.data=='OK'){
            logger.info(`血流量设备上报结果，请求成功`)
            res.json({"Msg": "检查结果上传成功", "Status": "SUCCESS" });
 
        }else{
            logger.info(`血流量设备上报结果，请求失败`)
            res.json({"Msg": "检查结果上传失败", "Status": "err" });
        } 
    }
    catch(err){
        logger.info(`血流量设备上报结果，请求报错`)
        res.status(400).json({ retCode: "-1", msg: "请求出错了11" });
    }
  
 
    
})
 
// 启动服务器
app.listen(port, async () => {
    logger.info(`Server running at http://localhost:${port}/`)
    console.log(`Server running at http://localhost:${port}/`);
});
/**
 * 
 * @param {*} file base64图片格式转本地
 */
// base64z转文件后验证
const base64toFile = async (dataurl, imgName) => {
    // 将 Base64 数据转换为 Buffer
    const buffer = Buffer.from(dataurl, 'base64');
    // 定义输出文件路径
    // 定义输出文件路径
    const outputDir = path.join(__dirname, 'img');
    const outputPath = path.join(outputDir, `${imgName}.png`);
    await ensureDirectoryExists(outputDir);
    await fs.writeFile(outputPath, buffer);
    const ossUrl = await getOssUrl(outputPath)
    // 删除本地图片
    delImg(outputPath)
    console.log('File saved to', outputPath);
    console.log(`得到ossUrl=${ossUrl}`)
    return ossUrl
 
}
//验证后删除文件图片
const delImg = (path) => {
    fs.unlink(path, (err) => {
        if (err) {
            console.log('删除失败')
        } else {
            console.log('删除成功')
        }
    })
}
 
// 确保输出目录存在
const ensureDirectoryExists = async (directory) => {
    try {
        await fs.mkdir(directory, { recursive: true });
    } catch (err) {
        console.error('Error creating directory:', err);
    }
}
// 将文件上传到阿里的oss
const getOssUrl = async (path) => {
    let ossUrl = await ViapiUtil.default.upload('LTAI5tPBxZiqgd9h6gcL9Qzc', 'IE6nsjJMTul2ZHkeQ27bg4wmWIngTu', path);
    console.log(ossUrl)
    return ossUrl
}
 
// 访问日志记录
const logHttps=(mode)=>{
    try{
        let sqlStr=`INSERT INTO system_log (id, code, url, parameter) VALUES (0, '', '${mode.action}', '${JSON.stringify(mode)}')`
        console.log(sqlStr)
        pool.promise().query(sqlStr)
    }catch (err) {
        console.error('访问日志记录错误:', err);
    }
}
 
/**
 * 根据身份证算年龄
 */
 
function getAgeFromIdCard(idCard) {
    // 检查身份证号码长度是否正确
    if (idCard.length !== 18) {
        // throw new Error('身份证号码长度必须为18位');
        return ''
    }
    // 获取出生年月日
    const birthYear = parseInt(idCard.substring(6, 10), 10);
    const birthMonth = parseInt(idCard.substring(10, 12), 10);
    const birthDay = parseInt(idCard.substring(12, 14), 10);
 
    // 获取当前日期
    const now = new Date();
    const currentYear = now.getFullYear();
    const currentMonth = now.getMonth() + 1; // 注意：getMonth() 返回的月份是从0开始的
    const currentDay = now.getDate();
 
    // 计算年龄
    let age = currentYear - birthYear;
 
    // 如果当前日期在生日之前，则年龄减一
    if (currentMonth < birthMonth || (currentMonth === birthMonth && currentDay < birthDay)) {
        age--;
    }
 
    return age;
}