ZLPlugin_MR/clsPlugin.cs

//-----------------------------------------------------------------------------
// 文 件 名: clsPlugin
// 作    者：blanksea
// 创建时间：2023/10/13 9:48:34
// 描    述：
// 版    本：
//-----------------------------------------------------------------------------
// 历史更新纪录
//-----------------------------------------------------------------------------
// 版    本：1.0           修改时间：2020/08/25           修改人： 苏纯栋         
// 修改内容：建立子插件项目模板
// 适用HIS版本： 35.0 ~ 35.130
//*****************************************************************************
// 版    本：1.1           修改时间：2020/12/22           修改人： 苏纯栋
// 修改内容：新增日志类，封装标准存储方式及存储路径；新增数据查询辅助类
// 适用HIS版本： 35.0 ~ 35.130
//*****************************************************************************
// 版    本：1.2           修改时间：2021/03/18           修改人： 苏纯栋         
// 修改内容：新增JSON类，调整DBHelper辅助类，新增WebService服务动态调用，新增扩展类，规范MessageBox调用显示
// 修改内容：新增用户信息模型及配置信息模型，新增domain及model层
// 修改内容：迁移原数据，调整IclsPlugin函数签名匹配35.140版本
// 修改内容：补全所有功能方法的使用说明及参数备注
// 适用HIS版本： 35.0 ~ 35.140
//*****************************************************************************
// 版    本：1.3           修改时间：2021/09/14           修改人： 苏纯栋
// 修改内容：修复部分bug
// 适用HIS版本： 35.0 ~ 35.140
//*****************************************************************************
// 版    本：1.4           修改时间：2021/11/16           修改人： 苏纯栋
// 修改内容：修复部分bug
// 修改内容：调整Ini初始化说明,修复因主插件重复调用引起的重复初始化
// 修改内容：新增AES及DES加解密操作类
// 适用HIS版本： 35.0 ~ 35.140
//-----------------------------------------------------------------------------
// Copyright (C) 2013-2023 重庆中联信息科技贵阳公司接口部
//-----------------------------------------------------------------------------
using ADODB;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;
using ZLPlugin_MR.Domain;
using ZLPlugin_MR.Domain.Units;
using ZLPlugin_MR.Model;
using ZLPlugin_MR.ServerImpl;

namespace ZLPlugin_MR
{
    [ComVisible(true)]
    [Guid("65d940c4-4970-4392-ad70-f2a76fec089c")]
    [ProgId("ZLPlugin_MR.clsPlugin")]
    public class clsPlugin : IclsPlugIn
    {
        Connection OracleConnect;//初始化时获取连接对象

        //==========================================规范使用说明==============================================================
        //使用插件时，为了规范化代码，便于后期维护，请将自己要使用实现的功能从“未实现功能”的region中移动到“已实现功能”中来
        //====================================================================================================================

        #region 已实现的功能
        static bool IsInit = false;
        public void Initialize(Connection cnOracle, long lngSys, long lngModual, int int场合 = -1)
        {
            //功能：初始化
            //事件触发点：登录导航台时触发；进入医生站时连续触发
            //注意事项：因会重复触发，经测试定义的类变量进入时重复定义类变量，标记的static变量不会出现问题，建议：
            // 1. 需要定义到类内部的全局变量，使用静态变量static；
            // 2. 需要使用的静态变量初始化，放入下方初始化操作中，以避免重复调用 
            Log.Info("初始化 Initialize");
            if (!IsInit)
            {
                Tools.Connection = cnOracle;
                OracleConnect = cnOracle;
                Domain.Infos.Con = cnOracle;
                Domain.Infos.ReadConfig();
                Log.ClearLogAsyn().Start();
                IsInit = true;
            }
        }
        public bool AdviceSend(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngSendID)
        {
            //        '功能：发送医嘱完成后调用，当住院护士同时发送多个病人医嘱时一个病人会调用一次。
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达(门诊没有“发送”模块),1254=住院医嘱发送)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngSendID=发送号(病人医嘱发送.id)
            Log.Info("AdviceSend   lngModual == " + lngModual );
            Log.Info("AdviceSend   lngSys == " + lngSys);
            //住院的时候发送 不需要  20241015
            if (lngModual == 1254)
            {
                return true;
            }
            //--------------  20241015
            Log.Info("AdviceSend  enter=="+ lngSendID);
            try
            {
                Log.Info("AdviceSend  enter==");
                int res = 1;
                int waittingdate = 0;
                int yzzState = 0;
                LisPacs_MR_Bll.IsAgree(out res, out waittingdate, out yzzState);
                if (res == 0)//互认关闭
                {
                    return true;
                }
                List<YZData> ss_list = LisPacs_MR_Bll.GetYZList(lngSendID);

                string hisApplyId = Tools.Generate16CharGUID();

                string patientSource = "1"; //病人来源

                string code = "";
                string billProjectNames = "";  //开单项目名称
                List<Codes> listlis;
                List<Codes> listpacs;
                LisPacs_MR_Bll.GetTreatmentId(ss_list, out code, out listlis, out listpacs,out billProjectNames);
                Log.Info("code==" + code);
                Log.Info("billProjectNames==" + billProjectNames);
                decimal totalPrice = 0;
                int hrType = 0;
                if (listlis.Count == 0 && listpacs.Count == 0)
                {
                    Log.Info("listlis.Count == 0");
                    return true;
                }
                else if (listlis.Count > 0 && listpacs.Count == 0)//只有检验
                {
                    hrType = 1;
                }
                else if (listpacs.Count > 0 && listlis.Count == 0)//只有检查
                {
                    hrType = 2;
                }
                if (hrType == 1)
                {
                    totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                     //totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZLXM(zlxmid);
                }
                else if (hrType == 2)
                {
                    for (var ii = 0; ii < listpacs.Count; ii++)
                    {
                        totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 2);
                    }
                    // totalPrice = LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(zlxmid, listpacs[0].zxksid, listpacs[0].part, listpacs[0].method, 2);
                }
                else
                {
                    //获取合单之后 同时有检查和检验  的开单项目唯一id  以及金额
                    totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                    for (var ii = 0; ii < listpacs.Count; ii++)
                    {
                        totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 2);
                    }
                }
                Recordset rd = LisPacs_MR_Bll.GetMZPostJson(lngClinicID, code, hrType, totalPrice.ToString(), hisApplyId);
                string json = Tools.RecordsetToJson(rd);
                Log.Info(json);
                SocketClient clientSend = new SocketClient("127.0.0.1", 6061);
                clientSend.Send(json);
                //Tools.Delay(10000, 0);

                Log.Info("初始化完成！");
                try
                {
                    clientSend.WhileReceive(waittingdate);
                }
                catch (Exception e)
                {
                    Log.Info("接收失败！" + e.Message);
                }

                if (!string.IsNullOrWhiteSpace(SocketClient.Message))
                {
                    ResultsEx rex = new ResultsEx();
                    rex = JSON.JsonToObject<ResultsEx>(Tools.FormatStr(SocketClient.Message), Encoding.UTF8);
                    if (rex.ResultCode == 2)//有互认
                    {
                        
                        clientSend.WhileReceive(waittingdate);
                        MessageBox.Show("回传数据至his！");
                        // SocketClient.Message = null;
                        SaveData(waittingdate, lngPatientID, lngClinicID, listlis, listpacs, 1);
                        //保存开单项目
                        int ii = LisPacs_MR_Bll.InsertHuRenBillProject(Dns.GetHostName(), lngPatientID, billProjectNames, 999, Tools.GetHostIp(), Infos.UserInfo.ID.ToString(), hisApplyId, hrType.ToString(), Infos.UserInfo.姓名,patientSource);
                        Log.Info("开单状态=" + ii);
                        clientSend.Close();
                        return true;
                    }
                    else if (rex.ResultCode == -1)//互认引用失败
                    {
                        MessageBox.Show(rex.ResultText.ToString(), "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                        clientSend.Close();
                        return true;
                    }
                    else
                    {
                        MessageBox.Show(rex.ResultText.ToString(), "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                        int ii = LisPacs_MR_Bll.InsertHuRenBillProject(Dns.GetHostName(), lngPatientID, billProjectNames, 999, Tools.GetHostIp(), Infos.UserInfo.ID.ToString(), hisApplyId, hrType.ToString(), Infos.UserInfo.姓名, patientSource);
                        Log.Info("开单状态=" + ii);
                        clientSend.Close();
                        return true;//此病人不存在互认信息
                    }
                }
                clientSend.Close();
            }
            catch (Exception ex)
            {
                Log.Info(ex.Message);
                Log.Info(ex.StackTrace);
                MessageBox.Show(ex.Message, "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                
            }
            /*if (clientSend != null)
            {
                clientSend.Close();
            }*/
            Log.Info("AdviceSend  end==");
            return true;
        }
        public bool AdviceSave(long lngSys, long lngModual, long lngPatientID, long lngClinicID, Recordset rsAdvice, int int场合 = -1)
        {
            //        '功能：保存医嘱时(事务开始前)调用,返回False时不保存医嘱
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      rsAdvice=当前病人本次新开或修改的所有医嘱记录，字段同AdviceEnter接口的该参数,除此之外，门诊调用时，还包含医嘱对应的诊断的疾病ID
            //'               字段 EditState  '1 - 新增，2－修改
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            Log.Info("AdviceSave  lngModual==" + lngModual);
            Log.Info("AdviceSave   lngSys == " + lngSys);
            rsAdvice.Filter = "";
          //  SocketClient socketClient = new SocketClient("127.0.0.1", 6061);
            try
            {
                int res = 1;
                int waittingdate = 0;
                int yzzState = 0;
                LisPacs_MR_Bll.IsAgree(out res, out waittingdate, out yzzState);
                if (res == 0)//互认关闭
                {
                    return true;
                }
                string str = Tools.GetAdviceSaveData(rsAdvice);
                Log.Info("保存前医嘱:" + str);
                if (str == "")
                {
                    return true;
                }
                if (yzzState == 1)
                {
                    #region 仅印江人民医院使用，仅支持住院，因为一张纸发送医嘱后也会触发此方法
                    if (lngModual == 1252)
                    {
                        return true;
                    }
                    #endregion
                }

                List<YZData> ss_list = JSON.JsonToObject<List<YZData>>(Tools.FormatStr(str), Encoding.UTF8);
                //这里需要过滤 保存修改的数据
                ss_list = ss_list.Where(data => !'2'.Equals(data.EDITSTATE)).ToList();
                if (ss_list.Count <= 0)
                {
                    Log.Info("过滤修改后没有数据:");
                    return true;
                }

                string hisApplyId = Tools.Generate16CharGUID();
                Log.Info("hisApplyId==" + hisApplyId);
                string patientSource = ""; //病人来源

                string code = "";
                string billProjectNames = "";  //开单项目名称
                List<Codes> listlis;
                List<Codes> listpacs;
                Log.Info("");
                LisPacs_MR_Bll.GetTreatmentId(ss_list, out code, out listlis, out listpacs, out billProjectNames);
                Log.Info("code==" + code);
                Log.Info("billProjectNames==" + billProjectNames);
                Recordset rd = new Recordset();
                decimal totalPrice = 0;
                int hrType = 0;
                if (listlis.Count == 0 && listpacs.Count == 0)
                {
                    Log.Info("listlis.Count == 0 && listpacs.Count == 0");
                    return true;
                }
                else if (listlis.Count > 0 && listpacs.Count == 0)//只有检验
                {
                    hrType = 1;
                }
                else if (listpacs.Count > 0 && listlis.Count == 0)//只有检查
                {
                    hrType = 2;
                }

                if (lngModual == 1253)//住院
                {
                    if (hrType == 1)
                    {
                        totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                        //totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZLXM(zlxmid);
                    }
                    else if (hrType == 2)
                    {
                        for (var ii = 0; ii < listpacs.Count; ii++)
                        {
                            totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 1);
                        }
                    }
                    else
                    {
                        //获取合单之后 同时有检查和检验  的开单项目唯一id  以及金额
                        totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                        for (var ii = 0; ii < listpacs.Count; ii++)
                        {
                            totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 1);
                        }
                    }
                    //totalPrice = LisPacs_MR_Bll.GetZYTotalPrice(zlxmid);
                     patientSource = "2"; 
                    rd = LisPacs_MR_Bll.GetZYPostJson(lngPatientID, lngClinicID, code, hrType, totalPrice.ToString(), hisApplyId);
                }
                else
                {
                    //totalPrice = LisPacs_MR_Bll.GetMZTotalPrice(lngPatientID, yzid);
                    if (hrType == 1)
                    {
                        totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                        //totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZLXM(zlxmid);
                    }
                    else if (hrType == 2)
                    {
                        for (var ii = 0; ii < listpacs.Count; ii++)
                        {
                            totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 2);
                        }
                        // totalPrice = LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(zlxmid, listpacs[0].zxksid, listpacs[0].part, listpacs[0].method, 2);
                    }
                    else
                    {
                        //获取合单之后 同时有检查和检验  的开单项目唯一id  以及金额
                        totalPrice = LisPacs_MR_Bll.GetTotalPriceForLisByZlxmIds(LisPacs_MR_Bll.GetZlxmIdFromList(listlis));// 获取总金额
                        for (var ii = 0; ii < listpacs.Count; ii++)
                        {
                            totalPrice += LisPacs_MR_Bll.GetTotalPriceForPacsByZLXM(listpacs[ii].zlxmid, listpacs[ii].zxksid, listpacs[ii].part, listpacs[ii].method, 1);
                        }
                    }
                    patientSource = "1";
                    rd = LisPacs_MR_Bll.GetMZPostJson(lngClinicID, code, hrType, totalPrice.ToString(), hisApplyId);
                }
                SocketClient socketClient = new SocketClient("127.0.0.1", 6061);
                //Results result = new Results();
                string json = Tools.RecordsetToJson(rd);
                Log.Info(json);
                socketClient.Send(json);
                Log.Info("waittingdate=" + waittingdate);
                try
                {
                    socketClient.WhileReceive(waittingdate);
                }
                catch (Exception e)
                {
                    Log.Info("接收失败！" + e.Message);
                    return false;
                }
                Log.Info("listlis count！" + listlis.Count);
                Log.Info("listpacs count！" + listpacs.Count);
                if (!string.IsNullOrWhiteSpace(SocketClient.Message))
                {
                    ResultsEx rex = new ResultsEx();
                    rex = JSON.JsonToObject<ResultsEx>(Tools.FormatStr(SocketClient.Message), Encoding.UTF8);
                    if (rex.ResultCode == 2)//有互认
                    {
                        
                        socketClient.WhileReceive(waittingdate);
                        MessageBox.Show("回传数据至his！");
                        SaveData(waittingdate, lngPatientID, lngClinicID, listlis, listpacs, -1);
                        //保存开单项目
                        int ii = LisPacs_MR_Bll.InsertHuRenBillProject(Dns.GetHostName(), lngPatientID, billProjectNames, 999, Tools.GetHostIp(), Infos.UserInfo.ID.ToString(), hisApplyId, hrType.ToString(), Infos.UserInfo.姓名, patientSource);
                        Log.Info("开单状态=" + ii);
                        socketClient.Close();
                        return true;
                    }
                    else if (rex.ResultCode == -1)//互认引用失败
                    {
                        MessageBox.Show(rex.ResultText.ToString(), "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                        socketClient.Close();
                        return true;
                    }
                    else
                    {
                        MessageBox.Show(rex.ResultText.ToString(), "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                        int ii = LisPacs_MR_Bll.InsertHuRenBillProject(Dns.GetHostName(), lngPatientID, billProjectNames, 999, Tools.GetHostIp(), Infos.UserInfo.ID.ToString(), hisApplyId, hrType.ToString(), Infos.UserInfo.姓名, patientSource);
                        Log.Info("开单状态=" + ii);
                        socketClient.Close();
                        return true;//此病人不存在互认信息
                    }
                }
                socketClient.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "中联软件", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                Log.Info(ex.Message);
                Log.Info(ex.StackTrace);
            }
            /*if (client != null)
            {
                client.Close();
            }*/
            Log.Info("AdviceSave  end==");
            return true;
        }

        private bool SaveData(int waittingdate, long lngPatientID, long lngClinicID, List<Codes> listlis, List<Codes> listpacs, int state)
        {
            Results result = new Results();
            Tools.Delay(waittingdate);
            if (string.IsNullOrWhiteSpace(SocketClient.Message))
            {
                return true;
            }
            try
            {
                result = JSON.JsonToObject<Results>(Tools.FormatStr(SocketClient.Message), Encoding.UTF8);
            }
            catch (Exception ex)//插件关闭时，返回格式不一样
            {
                ResultsEx rex = new ResultsEx();
                rex = JSON.JsonToObject<ResultsEx>(Tools.FormatStr(SocketClient.Message), Encoding.UTF8);
                Log.Info("SaveData catch" + ex.Message);
                return true;
            }
            if (result.ResultText[0].State == "0")//不互认
            {
                return true;
            }
            //Log.Info(SocketClient.Message);

            List<long> lisIds = new List<long>();
            List<long> pacsIds = new List<long>();
            Log.Info("Domain.Infos.UserInfo.编号 = " + Domain.Infos.UserInfo.编号);
            LisPacs_MR_Bll.SaveDataNew2(result, lngPatientID, lngClinicID, Infos.UserInfo.编号, listlis, listpacs, out lisIds, out pacsIds);
            Log.Info("state："+ state + "  lisId"+ lisIds.Count);
            if (state < 1)
            {
                return true;
            }
            //仅发送医嘱后执行
            if (lisIds.Count > 0)
            {
                lisIds.ForEach(xgid =>
                {
                    Log.Info("CancelYz  lisId="+ xgid);
                    LisPacs_MR_Bll.CancelYzzNew(lngPatientID, xgid, 1, 0);
                    Log.Info("CancelYz  end");
                });

            }
            if (pacsIds.Count > 0)
            {
                pacsIds.ForEach(xgid =>
                {
                    Log.Info("CancelYz  pacsId=" + xgid);
                    LisPacs_MR_Bll.CancelYzzNew(lngPatientID, xgid, 0, 1);
                    Log.Info("CancelYz  end");
                });
            }
            return true;
        }
        #endregion

        #region 未实现的功能
        public bool AddEMRBefore(string lngSys, long lngModual, long lngPatientID, long lngClinicID, long EMRFileID, params dynamic[] arrInput)
        {
            //功能：新增电子病历时候调用
            //参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(门诊病历 1250,住院病历 1251,护理病历 1255)
            //      lngPatientID=病人ID,lngClinicID=就诊ID/
            //      EMRFileID=病历文件列表.id
            //      arrInput是数组：扩展参数用于扩展使用，通过下标访一直接问时可能会报两种错，9－下标越界/13－类型不匹配：均表示参数没有传入
            //           所以访问参数前应先判断：If TypeName(arrInput(i)) <> "Error" Then 满足这个条件后才使用这个参数，否则就认为这个参数没有传入
            //           arrInput 目前未传入任何参数
            return true;
        }

        public bool AdvcieBeforToReview(long lngSys, long lngModual, long lngPatientID, long lngClinicID,
            long lngAdviceID, long lngSendID, string str核对人, string str核对时间, string str执行人, string strXML)
        {
            //功能：核对前调用，批量核对时每条医嘱调用一次
            //参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1261=住院医生站,1262=住院护士站)
            //      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //      lngAdviceID=病人医嘱记录.id
            //      lngSendID=医嘱发送号
            //      str核对人=核对人
            //      str核对时间=核对时间
            //      str执行人=执行人
            //      strXML=XML扩展参数
            //返回：true允许核对，false不能核对
            return true;
        }

        public void AdviceBeforeSend(string strEndDate, Recordset rsData, string strAdviceIDs, string strMsg)
        {
            //        '功能：医嘱发送前调用。
            //'参数：strEndDate 医嘱发送的结束时间(如果医嘱为长嘱则需要此参数) 格式：2015-11-18 18:00:00
            //'      rsData 从ZLHIS程序中组织传入，本次发送的所有医嘱，含以下字段。
            //'             病人ID
            //'             就诊ID    主页ID/挂号ID
            //'             挂号单    如果是门诊病人 病人挂号记录.NO；住院病为空。
            //'             医嘱ID    医嘱ID   病人医嘱记录.ID
            //'             相关ID    如果是主医嘱 该字段为0
            //'             收费细目ID
            //'             分解时间  医嘱执行分解的执行时间点格式：2015-11-18 12:00:00,2015-11-18 18:00:00,...
            //'             次数      执行数
            //'             单量
            //'             单量单位
            //'             总量
            //'             总量单位
            //'             场合   0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strAdviceIDs 出参  本次不允许发送的医嘱ID串，用逗号分割，如：23423,3123,64563；
            //'      strMsg     出参  提示信息。strMsg="" － 不提示；strMsg<>"" － ZLHIS程以 msgbox 方式弹出提示。
            //'                       当提示信息过多时，msgbox方式提示信息显示不完成，可以将strMsg置空，在接口内部自定义提示信息的展示方式，例如：加一个模态窗体来显示提示信息。
        }

        public bool AdviceCheckApplyCustom(long lngSys, long lngModual, long lngPatiID, string lng就诊ID, long lng文件ID, string strXML, ref dynamic objWeb, long lng医嘱ID = 0, string strReserve = "")
        {
            //        '功能：门诊住院自定义申请单检查表单数据
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatiID=病人ID,lng就诊ID=门诊挂号单号,住院主页ID
            //'      lng文件ID=申请单对应的病历文件列表.ID；lng医嘱ID 修改申请单时传入
            //'      strXML=自定义申请单的XML数据
            //'      objWeb=WebBrowser浏览器控件，可通过objWeb.document 对象访问网页表单数据进行检查
            //'      strReserve=扩展参数

            //'示例-----------------------------------------------------------------------------
            //'    Dim objXML As Object
            //'
            //'    Set objXML = CreateObject("MSXML2.DOMDocument")
            //'    If objXML Is Nothing Then
            //'        MsgBox "创建MSXML2.DOMDocument对象失败", vbExclamation, Me.Caption
            //'        Exit Function
            //'    End If
            //'    Call objXML.loadXML(strXML)
            //'    On Error Resume Next
            //'    objXML.selectSingleNode(".//" & "姓名").Text = mstr病人姓名

            //'    Set vDoc = webSub.Document
            //'    For i = 0 To vDoc.All.Length - 1
            //'        If UCase(vDoc.All(i).tagName) = "INPUT" Or UCase(vDoc.All(i).tagName) = "SELECT" Then
            //'            Set vtag = vDoc.All(i)
            //'            If vtag.Type = "text" Or vtag.Type = "password" Or vtag.Type = "hidden" Or vtag.Type = "select-one" Then
            //'                If vtag.Value = XXXX Then XXXXX
            //'            End If
            //'        End If
            //'    Next
            //'---------------------------------------------------------------------------------
            return true;
        }

        public bool AdviceCheckSendFee(long lngSys, long lngModual, long lngPatientID, long lngClinicID, double cur合计, int int场合 = -1, string strReserve = "")
        {
            //        '功能：医嘱发送前费用检查：检查通过返回true,检查不通过返回false
            //'参数：lngSys,lngModual = 当前调用接口的主程序系统号及模块号
            //'      lngPatientID = 病人ID,
            //'      lngClinicID = 就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      cur合计 = 病人本次要发送医嘱的记帐金额合计,包含记帐划价单的金额
            //'      int场合 = 调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strReserve = 保留参数,用于扩展使用
            return true;
        }

        public bool AdviceDeletBefor(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合 = -1)
        {
            //        '功能：医嘱删除前调用（返回False则取消删除医嘱）
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool AdviceDeleted(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合 = -1)
        {
            //        '功能：医嘱删除后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool AdviceEditAfter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, Recordset rsAdvice, int int场合 = -1)
        {
            //        '功能：每输入完一条医嘱项目进行下一条医嘱输入时调用，或者在表格换行时调用(传入的医嘱是上一行的内容－－新开或修改过的医嘱)
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      rsAdvice=当前录入的一条或一组医嘱记录（中药配方、成套方案、批量复制医嘱在输入时不调用）
            //'      字段为表“病人医嘱记录”的大部分字段，包括：ID, 相关id, 序号, 病人来源（1=门诊,2=住院), 病人id, 挂号单/主页ID,
            //'                姓名, 性别, 年龄, 婴儿, 医嘱状态, 医嘱期效, 诊疗类别, 诊疗项目id, 收费细目id, 天数, 单次用量, 总给予量, 医嘱内容, 医生嘱托, 标本部位,
            //'                检查方法 , 执行标记, 执行频次, 频率次数, 频率间隔, 间隔单位, 执行时间方案, 计价特性, 执行科室id, 执行性质, 紧急标志, 可否分零,
            //'                开始执行时间,执行终止时间(住院调用才有，没填时为cdate(0)), 病人科室id, 开嘱科室id, 开嘱医生, 开嘱时间, 挂号单, 前提id, 摘要
            //'                ,除此之外，门诊调用时，还包含医嘱对应的诊断的疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool AdviceEnter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, Recordset rsAdvice, int int场合 = -1)
        {
            //        '功能：保存医嘱时(事务开始前)调用,返回False时不保存医嘱
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      rsAdvice=当前病人本次新开或修改的所有医嘱记录，字段同AdviceEnter接口的该参数,除此之外，门诊调用时，还包含医嘱对应的诊断的疾病ID
            //'               字段 EditState  '1 - 新增，2－修改
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool AdviceLoadApplyCustom(long lngSys, long lngModual, long lngPatiID, string lng就诊ID, long lng文件ID, string strXML, long lng医嘱ID = 0, string strReserve = "")
        {
            //        '功能：门诊住院自定义申请单读取数据处理(XML处理)
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatiID=病人ID,lng就诊ID=门诊挂号单号,住院主页ID
            //'      lng文件ID=申请单对应的病历文件列表.ID；lng医嘱ID 修改申请单时传入
            //'      strXML=自定义申请单的XML数据(出参)
            //'      lng医嘱ID=修改和查看时，医嘱ID不为空，新开时为空
            //'      strReserve=扩展参数

            //'示例-----------------------------------------------------------------------------
            //'    Dim objXML As Object
            //'
            //'    Set objXML = CreateObject("MSXML2.DOMDocument")
            //'    If objXML Is Nothing Then
            //'        MsgBox "创建MSXML2.DOMDocument对象失败", vbExclamation, Me.Caption
            //'        Exit Function
            //'    End If
            //'    Call objXML.loadXML(strXML)
            //'    On Error Resume Next
            //'    objXML.selectSingleNode(".//" & "姓名").Text = mstr病人姓名
            //'---------------------------------------------------------------------------------
            return true;
        }

        public bool AdviceMakeFee(long lngSys, long lngModual, string strCurFee, Recordset rsNowFee, double dblCount, string strReserve = "")
        {
            //        '功能：获取检查医嘱子医嘱行对应的费用收取次数，具体收几次费由接口内部处理，医嘱发送时调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      strCurFee当前医嘱记录行对的相关信息，固定格式，用<sTab>分割，
            //'              lng医嘱ID & "<sTab>" & lng当前医嘱ID & "<sTab>" & lng诊疗项目ID & "<sTab>" & lng收费项目ID & "<sTab>" & int收费方式 & "<sTab>" & str部位 & "<sTab>" & str方法 & "<sTab>" & (dbl总量 * dbl计价数量)
            //'      rsNowFee 本次发送中已经处理的费用项目 包含的字段
            //            '"医嘱ID", adBigInt '一组医嘱的ID
            //            '"诊疗项目ID", adBigInt
            //            '"收费项目ID", adBigInt
            //            '"收费方式", adInteger
            //            '"收费时间", adVarChar, 10
            //            '"执行部门ID", adBigInt
            //            '"子医嘱ID", adBigInt '相关ID不为空的医嘱行的医嘱ID
            //            '"检查部位", adVarChar, 30
            //            '"检查方法", adVarChar, 30
            //            '"数量", adDouble '收费数量
            //'      dblCount 出参数取值-1，0，>0；-1表示按主程序原有逻辑收取相当于是正常收费、为0表示本次不用收取、>0表示本次收费次数
            //'      strReserve 保留扩展参数
            //'特殊说明，rsNowFee 记录集只能读取不能修改删除
            return true;
        }

        public bool AdviceRevoked(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合 = -1)
        {
            //        '功能：医嘱作废后调用，一条医嘱调用一次
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool AdviceRevokedBefore(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合, string strMsg, string strReserve = "")
        {
            //        '功能：医嘱作废前调用，一条医嘱调用一次
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strMsg   提示信息，接口内部组织返回给主程序进行提示，空串则不提示
            //'      strReserve   扩展参数
            //'返回：true允许作废，false不能作废
            return true;
        }

        public bool AdviceRollSend(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合, string strMsg, string strReserve = "")
        {
            //        '功能：医嘱回退发送后调用，一条医嘱调用一次
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strMsg   提示信息，接口内部组织返回给主程序进行提示，空串则不提示
            //'      strReserve   扩展参数
            return true;
        }

        public bool AdviceRollSendBefore(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngAdviceID, int int场合, string strMsg, string strReserve = "")
        {
            //        '功能：医嘱回退发送前调用，一条医嘱调用一次
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      lngAdviceID=病人医嘱记录.id
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strMsg   提示信息，接口内部组织返回给主程序进行提示，空串则不提示
            //'      strReserve   扩展参数
            //'返回：true允许回退，false不能回退
            return true;
        }

        public bool AdviceRowChange(long lngSys, long lngModual, long lngPatientID, long lngClinicID, Recordset rsAdvice, int int场合 = -1)
        {
            //        '功能：医嘱编辑时切换医嘱行时(医嘱编辑界面医嘱表格行变换)调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      rsAdvice=当前病人本次新开的所有医嘱记录，字段同AdviceEnter接口的该参数,除此之外，门诊调用时，还包含医嘱对应的诊断的疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        

        public bool AdviceSaveApplyCustom(long lngSys, long lngModual, long lngPatiID, string lng就诊ID, long lng文件ID, string strXML, ref dynamic objWeb, long lng医嘱ID = 0, string strReserve = "")
        {
            //        '功能：门诊住院自定义申请单保存数据处理(XML处理)
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatiID=病人ID,lng就诊ID=门诊挂号单号,住院主页ID
            //'      lng文件ID=申请单对应的病历文件列表.ID；lng医嘱ID 修改申请单时传入
            //'      strXML=自定义申请单的XML数据(出参)
            //'      objWeb=WebBrowser浏览器控件，可通过objWeb.document 对象访问网页表单数据进行检查
            //'      strReserve=扩展参数

            //'示例-----------------------------------------------------------------------------
            //'    Dim objXML As Object
            //'
            //'    Set objXML = CreateObject("MSXML2.DOMDocument")
            //'    If objXML Is Nothing Then
            //'        MsgBox "创建MSXML2.DOMDocument对象失败", vbExclamation, Me.Caption
            //'        Exit Function
            //'    End If
            //'    Call objXML.loadXML(strXML)
            //'    On Error Resume Next
            //'    objXML.selectSingleNode(".//" & "姓名").Text = mstr病人姓名

            //'    Set vDoc = webSub.Document
            //'    For i = 0 To vDoc.All.Length - 1
            //'        If UCase(vDoc.All(i).tagName) = "INPUT" Or UCase(vDoc.All(i).tagName) = "SELECT" Then
            //'            Set vtag = vDoc.All(i)
            //'            If vtag.Type = "text" Or vtag.Type = "password" Or vtag.Type = "hidden" Or vtag.Type = "select-one" Then
            //'                If vtag.Value = XXXX Then XXXXX
            //'            End If
            //'        End If
            //'    Next
            //'---------------------------------------------------------------------------------
            return true;
        }

        
        public bool AdviceSendEnd(long lngSys, long lngModual, string strSendIDs)
        {
            //        '功能：一次发送医嘱完成后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达(门诊没有“发送”模块),1254=住院医嘱发送)
            //'      strSendIDs 发送号可能有多个，用逗号分割
            return true;
        }

        public bool BeforeEMRDocSave(long lngSource, long lngPatiID, long lngPageID, long lngFileId, string strTitle, string strContent, params dynamic[] arrInput)
        {
            //        '功能：电子病历保存前调用
            //'参数：lngSource 1 门诊 2 住院
            //'      lngPatientID=病人ID,lngPageId=就诊ID/
            //'      lngFileId=病历文件列表.id
            //'      arrInput是数组：扩展参数用于扩展使用，通过下标访一直接问时可能会报两种错，9－下标越界/13－类型不匹配：均表示参数没有传入
            //'           所以访问参数前应先判断：If TypeName(arrInput(i)) <> "Error" Then 满足这个条件后才使用这个参数，否则就认为这个参数没有传入
            //'           arrInput 目前未传入任何参数
            return true;
        }

        public bool BeforeVitalSignsSave(long lng病人ID, long lng主页ID, long lng文件ID, string strDataXML)
        {
            //    '---------------------------------------------------------------------------------------------------------------------------------------------
            //'功能:体温单记录保存时调用此接口，接口返回成功体温单/记录单数据才允许保存
            //'入参:
            //'         lng病人ID：病人ID
            //'         lng主页ID：主页ID
            //'         lng文件ID：护理文件ID
            //'         strDataXML：数据XML串，格式如下：
            //                    '<DATALIST>
            //                    '    <ITEMLIST>
            //                    '        <FSSJ>2019-6-12 15:34</FSSJ>
            //                    '        <ITEM>
            //                    '            <XMXH>1</XMXH>
            //                    '            <XMMC>体温</XMMC>
            //                    '            <DATA>37.5</DATA>
            //                    '            <BW>腋温</BW>
            //                    '        </TEIM>
            //                    '        <ITEM>
            //                    '            <XMXH>2</XMXH>
            //                    '            <XMMC>脉搏</XMMC>
            //                    '            <DATA>110</DATA>
            //                    '            <BW></BW>
            //                    '        </TEIM>
            //                    '        .......
            //                    '    <ITEMLIST>
            //                    '    <ITEMLIST>
            //                    '        <FSSJ>2019-6-12 14:34</FSSJ>
            //                    '        <ITEM>
            //                    '            <XMXH>1</XMXH>
            //                    '            <XMMC>体温</XMMC>
            //                    '            <DATA>37</DATA>
            //                    '            <BW>腋温</BW>
            //                    '        </TEIM>
            //                    '        <ITEM>
            //                    '            <XMXH>2</XMXH>
            //                    '            <XMMC>脉搏</XMMC>
            //                    '            <DATA>120</DATA>
            //                    '            <BW></BW>
            //                    '        </TEIM>
            //                    '        .......
            //                    '    <ITEMLIST>
            //                    '    .........
            //                    '</DATALIST>
            //'出参:
            //'返回:成功返回true,否则返回Fale
            //'编制:刘鹏飞
            //'日期:2019-6-12 15:34
            return true;
        }

        public bool ChargeDeleteAndStrictValied(long lngModule, int int记录性质, bool bln门诊, bool bln划价单, string strNos)
        {
            //    '功能:检查删除划价单或对收费进行退费、和记帐，检查保存数据的合法性
            //'入参:lngModule-模块号
            //'     int记录性质-1-收费单;2-记帐单
            //'     bln划价单-是否当前是保存的划价单
            //'     strNOs-格式1:NO1:序号1,序号2,||NO2:序号1,序号2
            //'            络式2:NO1||NO2:序号1,序号2||...
            //'            络式3:NO1||NO2||...
            //'出参:
            //'返回:成功返回true,否则返回Fale
            return true;
        }

        public void ChargeSaveAfter(long lngSys, long lngModual, long lngPatientID, long lng主页ID, bool bln门诊, int int记录性质, string strNos)
        {
            //        '功能：在保存记帐、收费单后(事务结束后)调用
            //'入参：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lng病人ID（记帐表时，传入0)
            //'      lng主页ID（记帐表时，传入0)
            //'      bln门诊 -是否门诊费用
            //'      int记录性质-1-收费;2-记帐
            //'      strNO-单据号
        }

        public bool ChargeSaveValied(long lngSys, long lngModual, long int记录性质, bool bln门诊, bool bln划价单, string strNos, Recordset rsSaveItems)
        {
            //        '功能：收费合法性检查
            //'入参：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      int记录性质
            //'      bln门诊
            //'             --是否门诊费用
            //'      bln划价单
            //'      strNOs-门诊收费时，传入的划价单号（对本次收费的划价单号)
            //'      rsSaveItems
            //'             --当前保存的项目集，字段:病人ID，主页ID,单据序号, 序号,价格父号,收费细目ID，收入项目id，付数 ，数次，标准单价，应收金额 ，
            //'                                      实收金额，发生时间，项目编码，项目名称，费用类别,开单部门ID,开单人,执行部门ID
            return true;
        }

        public bool CheckChargeItem(long lngSys, long lngModule, int intType, int intMode, Recordset rsDetail, string strExpend = "")
        {
            //    '功能:收费项目有效性检查
            //'入参:lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'     intType:0-门诊;1-住院
            //'     intMode:0-录入明细时的常规检查;1-保存单据前的汇总检查
            //'     rsDetail-病人ID，主页ID，收费类别，收费细目ID，数量，单价，实收金额，开单人，开单科室,
            //'                  执行科室ID, 单据性质（1-收费单,2-记帐单), 是否划价(1-划价;0-正常的收费及记帐单)

            //'     strExpend-待以后扩展，暂无用
            //'出参:strExpend-待以后扩展，暂无用
            //'返回:数据合法返回true,否则返回False
            return true;
        }

        public bool CheckMecInfo(long lngSys, long lngModule, long lngPatiID, long lngPageID, dynamic colCtl, string strMsg, string strReserve = "")
        {
            //'功能:首页输入有效性检查
            //'返回：True是成功，False是失败
            //'参数：strMsg 返回参数 格式 例: 提示消息-(提醒:1/禁止:0)|控件Key值-提示消息-(提醒:1/禁止:0)|表格控件Key值-提示消息-(提醒:1/禁止:0)-Row-Col
            //'      strReserve=保留参数,用于扩展使用 固定格式，用<sTab>分割，
            //'      lngType执行 & "<sTab>" &...&  "<sTab>" & ... &  "<sTab>"
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      colCtl 病案首页控件集合
            //'      lngPageID－主页ID；
            //'------------------------------------------------------------colCtl控件集合Key值--------------------------------------------------------------
            //'结构化地址控件:出生地点(结构化), 籍贯(结构化), 现住址(结构化), 户口地址(结构化), 联系人地址(结构化),单位地址(结构化)
            //'结构化地址控件[属性]:value省,value市,value区县,value乡镇,value详细地址
            //'文本框:出生地点, 籍贯, 现住址, 户口地址, 联系人地址, 病人区域, 单位地址, 病案号, 档案号, X线号, 姓名, 其他证件, 联系人姓名, 入院科室, 入院病房,
            //'       出院科室, 出院病房, 医保号, 摘要, 门诊号, 监护人, 发病地址, 医学警示, 其他医学警示, 病理号, 死亡原因, 病原学诊断, 抢救病因, 输其他,
            //'       转入医疗机构, 31天内再住院, 转科1, 转科2, 转科3, 退出原因, 变异原因, 重症监护室名称, 肿瘤T, 肿瘤N, 肿瘤M, Email, 其他会诊, 引发药物,
            //'       临床表现, 透析尿素氮值, 其他关系, 入院转入, 单位电话, 单位邮编, 家庭电话, 家庭邮编, 户口邮编, 身高, 身高单位, 体重, 体重单位, 体温,
            //'       入院次数, 收缩压, 舒张压, 联系人电话, 年龄, 婴幼儿年龄, 新生儿出生体重, 新生儿入院体重, 住院天数, 住院号, 抢救次数, 成功次数, 特护,
            //'       一级护理, 二级护理, 三级护理, ICU, CCU, 输红细胞, 输血小板, 输血浆, 输全血, 自体回收, 呼吸机使用, 昏迷时间入院前_天, 昏迷时间入院前_小时,
            //'       昏迷时间入院前_分钟, 昏迷时间入院后_天, 昏迷时间入院后_小时, 昏迷时间入院后_分钟, 随诊期限, 费用和, 约束总时间, 重症监护天, 重症监护小时,
            //'       Apgar , QQ, 输白蛋白, 院内会诊, 外院会诊, 距上次住院时间,婴幼儿年龄_DAY,GC_监护人身份证号
            //'下拉框: 门诊医师 , 科主任, 主任或副主任, 进修医师, 主治医师, 住院医师, 研究生医师, 实习医师, 质控医师, 质控护士, 责任护士, 编目员, 主诊医师, 随诊期限(下拉)
            //'        付款方式, 性别, 婚姻, 职业, 国籍, 民族, 关系, 入院途径, 文化程度, 去向, 感染与死亡关系, 入院情况, 分化程度, 最高诊断依据, 门诊与出院XY,入院与出院XY,
            //'        门诊与入院, 术前与术后, 放射与病理, 临床与病理, 死亡期间, 临床与尸检, 门诊与出院ZY, 入院与出院ZY, 辩证, 治法, 方药, 治疗类别, 中医诊疗设备, 抢救方法,
            //'        中医诊疗技术, 自制中药制剂, 辨证施护, 病案质量, 病例分型, HBsAg, 血型, HCVAb, RH, HIVAb, 输液反应, 输血反应, 输血前9项检查, 生育状况, 出院方式,
            //'        再入院计划天数, 压疮发生期间, 压疮分期, 跌倒或坠床伤害, 跌倒或坠床原因, 距上次住院时间(下拉), 重返间隔时间, 约束方式, 约束工具, 约束原因,
            //'        新生儿离院方式 , 肿瘤分期, 临床路径管理, 法定传染病, 实施DGRS管理, 死亡患者尸检, 身份证, 变异原因(下拉), 健康卡号, 年龄(下拉), 婴幼儿年龄(下拉),联系人身份证
            //'时间控件: 出生日期 , 入院时间, 出院时间, 确诊日期, 死亡时间, 发病日期, 发病时间, 质控日期, 编目日期, 收回日期, 入科时间
            //'复选框: 再入院 , 入院前外院治疗, 是否确诊, 病原学检查, 新发肿瘤, 危重, 急症, 疑难, 示教病案, 科研病案, 疑难病例, 随诊, CT, MRI, 彩色多普勒,
            //'        传染病上传, 围术期死亡, 术后猝死, 进入路径, 完成路径, 变异, 住院出现危重, 是否同一疾病, 人工气道脱出, 重返重症医学科, 住院物理约束, 单病种管理,
            //'        细菌标本送检 , 会诊情况, 无过敏记录, 未找到时自由录入,无手术记录,无重症监护记录,无转科记录
            //'单选按钮: 再住院无 , 再住院有, 初诊, 复诊, ICU无, ICU有, XY按诊断输入, XY按疾病编码输入, ZY按诊断输入, ZY按疾病编码输入, 按诊断输入,
            //'          按疾病编码输入, 按药品目录输入, 按过敏源输入
            //'VS表格: 转科情况 (表格), 西医诊断(表格), 中医诊断(表格), 过敏信息(表格), 手术记录(表格), 住院费用(表格), 化疗记录信息(表格), 放疗记录信息(表格),
            //'        抗菌药物使用情况(表格), 抗精神病治疗情况(表格), 重症监护情况(表格), 病案附加项目(表格), 特殊检查情况(表格),器械导管使用情况(表格),病人感染记录(表格),
            //'        感染部位(表格),病人病原学检查(表格)
            //'list列表控件: 不良事件(表格), 感染因素(表格)
            //'树形表控件:  住院费用(树形表)
            //'------------------------------------------------------------表格控件列枚举--------------------------------------------------------------------
            //'过敏信息列枚举 : 过敏药物=0 ,过敏反应=1 ,过敏时间=2 ,过敏源编码=3 ,药物ID=4 ,过敏来源=5
            //'(西医诊断/中医诊断)列枚举 : 诊断类型=0 ,关联=1 ,诊断编码=2 ,诊断描述=3 ,中医证候=4 ,发病时间=5 ,备注=6 ,入院病情=7 ,出院情况=8 ,ICD附码=9 ,是否未治=10
            //'            是否疑诊=11 ,增加=12 ,Del=13 ,诊断ID=14 ,疾病ID=15 ,证候ID=16 ,医嘱IDs=17  ,诊断分类=18 ,固定附码=19 ,是否病人=20
            //'            诊断来源=24 ,疾病编码=25 ,疾病类别=26 ,证候编码=27 ,记录日期=28 ,记录人员=29 ,疗效限制=21 ,分娩信息=22 ,附码ID=23
            //'手术列枚举 : Copy=0 ,手术日期=1 ,结束日期=2 ,抗菌用药时间=3 ,手术情况=4 ,准备天数=5 ,手术编码=6 ,手术名称=7 ,再次手术=8 ,主刀医师=9 ,助产护士=10 ,助手1=11
            //'    助手2=12 ,麻醉开始时间=13 ,麻醉类型 (界面名称麻醉方式)= 14  ,ASA分级=15 ,NNIS分级=16 ,手术级别=17 ,麻醉医师=18 ,切口愈合=19 ,切口部位=20 ,重返手术室计划=21
            //'    重返手术室目的=22 ,切口感染=23 ,并发症=24 ,预防用抗菌药=25 ,抗菌药天数=26 ,非预期的二次手术=27 ,麻醉并发症=28 ,术中异物遗留=29 ,手术并发症=30 ,术后出血或血肿=31
            //'    手术伤口裂开=32 ,术后深静脉血栓=33 ,术后生理代谢紊乱=34 ,术后呼吸衰竭=35 ,术后肺栓塞=36 ,术后败血症=37 ,术后髋关节骨折=38 ,手术操作ID=39 ,诊疗项目ID=40 ,麻醉ID=41
            //'    麻醉方式(界面名称麻醉类型)=42  ,手麻来源=43
            //'化疗列枚举 : 化学治疗编码=0 ,开始日期=1 ,结束日期=2 ,疗程数=3 ,化疗方案=4 ,总量=5 ,化疗效果=6 ,疾病ID=7
            //'放疗列枚举 : 放射治疗编码=0 ,开始日期=1 ,结束日期=2 ,设野部位=3 ,放射剂量=4 ,累计量=5 ,放疗效果=6 ,疾病ID=7
            //'精神药品列枚举 : 药物名称=0 ,疗程=1 ,最高日量=2 ,特殊反应=3 ,疗效=4 ,药品ID=5
            //'重症监护枚举 : 序号=0 ,监护室名称=1 ,进入时间=2 ,退出时间=3 ,再入住计划=4 ,再入住原因=5
            //'重症监护器械枚举 : ICU类型=0 ,器械及导管=1 ,开始时间=2 ,结束时间=3 ,感染累计小时=4
            //'医院感染枚举 : 确诊日期=0 ,感染部位=1 ,医院感染名称=2 ,医院感染编码=3
            //'标本来源枚举 : 标本=0 ,病原学代码及名称=1 ,送检日期=2
            //'抗菌药枚举 : 序号=0 ,抗菌药物名=1 ,用药目的=2 ,使用阶段=3 ,使用天数=4 ,一类切口预防用=5 ,DDD数=6 ,联合用药=7
            //'---------------------------------------------------------------------------------------------------------------------------------------------
            //'使用itemData的控件:
            //'涉及动态加载下拉框: 用于存储数据的id
            //'不良事件 (表格), 感染因素(表格): 用于存储数据的编码
            //'使用rowdata的控件:
            //'过敏信息 (表格), 西医诊断(表格), 中医诊断(表格), 手术记录(表格): 用于存储数据的id
            //'化疗记录信息 (表格), 重症监护情况(表格), 放疗记录信息(表格), 抗精神病治疗情况(表格): 用于存储数据的序号
            //'抗菌药物使用情况 (表格): 用于存储数据的药名id
            return true;
        }

        public bool CheckPathInItem(long lngSys, long lngModual, long lngPatientID, long lngClinicID, Recordset rsAdvice, long lng路径项目ID, string str分类, int int场合 = -1, string strReserve = "")
        {
            //        '功能：对临床路径病人下医嘱时，传入当前下达的医嘱信息，由接口内部判断是否为路径外项目
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）/主页ID(住院调用时)
            //'      rsAdvice=当前录入的一条或一组医嘱记录（中药配方、成套方案、批量复制医嘱在输入时不调用）
            //'      字段为表“病人医嘱记录”的大部分字段，包括：ID, 相关id, 序号, 病人来源（1=门诊,2=住院), 病人id, 挂号单/主页ID,
            //'                姓名, 性别, 年龄, 婴儿, 医嘱状态, 医嘱期效, 诊疗类别, 诊疗项目id, 收费细目id, 天数, 单次用量, 总给予量, 医嘱内容, 医生嘱托, 标本部位,
            //'                检查方法 , 执行标记, 执行频次, 频率次数, 频率间隔, 间隔单位, 执行时间方案, 计价特性, 执行科室id, 执行性质, 紧急标志, 可否分零,
            //'                开始执行时间,执行终止时间(住院调用才有，没填时为cdate(0)), 病人科室id, 开嘱科室id, 开嘱医生, 开嘱时间, 挂号单, 前提id, 摘要
            //'                ,除此之外，门诊调用时，还包含医嘱对应的诊断的疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strReserve=保留参数,用于扩展使用
            //'      lng路径项目ID ， str分类：即做为入参数，也当做出参影响主程序判断。 当传入的传不为0和空值，表示主程序已经匹配成功能，接口内部仍可以对参数赋值设为不匹配。如果要保留ZLHIS主程序判断结果，则原值返回。
            //'            1.当前接判断为不是路径外项目时，则返回 路径项目ID和分类名称，lng路径项目ID - 病人路径执行.项目id，str分类 - 临床路径项目.分类
            //'            2.当前接判断为是路径外项目时，则返回0和空串，lng路径项目ID=0，str分类=""
            return true;
        }

        public bool ClinicFinish(long lngSys, long lngModual, long lngPatientID, long lngClinicID)
        {
            //        '功能：病人完成接诊后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）
            return true;
        }

        public bool ClinicReceive(long lngSys, long lngModual, long lngPatientID, long lngClinicID)
        {
            //        '功能：病人接诊操作后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）
            return true;
        }

        public bool CommitPatiInfo(string str卡号, Recordset rsInfo)
        {
            //    '功能:提交发卡信息
            //'入参:str卡号-卡号
            //'        rsInfo-返回的病人信息集(直接更新该表,字段为:病人ID,姓名,性别,年龄,出生日期,出生地点,身份证号,其他证件,身份,职业,家庭地址,家庭电话,家庭邮编,工作单位,单位邮编,医保号,医疗付款方式,费别,国籍,民族,婚姻状况,区域)
            //'返回:调用成功,返回true,否则返回False
            //'编制:刘兴洪
            //'日期:2011-06-10 17:33:19
            //'说明:准格尔旗区域卫生系统接口(提交发卡信息)
            //'问题:38841
            return true;
        }

        public bool CreateMecOK()
        {
            // '功能：病案部件创建与检查
            return true;
        }

        public bool DiagnosisDeleted(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngDiagID, string strDiagDesc, int int场合 = -1)
        {
            //        '功能：门诊病案中删除诊断后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）
            //'      lngDiagID=诊断ID或疾病ID(根据系统参数决定),strDiagDesc=诊断描述
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool DiagnosisEnter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngDiagID, string strDiagDesc, long lng原诊断id, int int场合 = -1)
        {
            //        '功能：门诊病案中输入主要诊断后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）
            //'      lngDiagID=诊断ID或疾病ID(根据系统参数决定),strDiagDesc=诊断描述
            //'      lng原诊断id=0 表示新添加的诊断， 不为0表示修改诊断，lng原诊断id的值就是修改前的 诊断ID或疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool DiagnosisEnterIn(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngDiagID, string strDiagDesc, long lng原诊断id,
            int int场合 = -1, int int诊断类型 = 0, int int诊断次序 = 0, string strReserve = "")
        {
            //        '功能：住院病案中输入诊断后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=主页ID
            //'      lngDiagID=诊断ID或疾病ID(根据系统参数决定),strDiagDesc=诊断描述
            //'      lng原诊断id=0 表示新添加的诊断， 不为0表示修改诊断，lng原诊断id的值就是修改前的诊断ID或疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      int诊断类型=1-西医门诊诊断;2-西医入院诊断;3-出院诊断(其他诊断);5-院内感染;6-病理诊断;7-损伤中毒码;10-并发症
            //'      int诊断次序=诊断类型下的顺序号
            //'      strReserve=扩展参数
            return true;
        }

        public bool DiagnosisOtherEnter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lngDiagID, string strDiagDesc, long lng原诊断id, int int场合 = -1)
        {
            //        '功能：门诊病案中输入次要诊断后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lngClinicID=就诊ID（挂号记录ID）
            //'      lngDiagID=诊断ID或疾病ID(根据系统参数决定),strDiagDesc=诊断描述
            //'      lng原诊断id=0 表示新添加的诊断， 不为0表示修改诊断，lng原诊断id的值就是修改前的 诊断ID或疾病ID
            //'      int场合=0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            return true;
        }

        public bool DrugBeforeSendByRecipe(long lng库房ID, string strNos, string strReserve = "")
        {
            //        '功能：药品处方发药前调用，按处方发药
            //'参数：lng库房ID  库房ID；
            //'      strNOs 一次发药可能多个处方，处方类型和处方号，格式；单据,NO|单据,NO...
            //'      strReserve=扩展参数
            //'      返回：True-继续发药，False-不继续发药
            return true;
        }

        public bool DrugBeforeSendBySumID(long lng库房ID, string str收发ids, string strReserve = "")
        {
            //        '功能：药品部门发药前调用，按收发id传送，主要通过收发ID来获取其他信息
            //'参数：lng库房ID  库房ID；
            //'      str收发ids 收发id串，收发id1,收发id2...
            //'      strReserve=扩展参数
            //'      返回：True-继续发药，False-不继续发药
            return true;
        }

        public bool DrugDosageByRecipe(long lng库房ID, string strNos, DateTime dteSendTime, string strReserve = "")
        {
            //        '功能：药品处方配药后调用，按处方配药
            //'参数：lng库房ID  库房ID；
            //'      strNOs 一次配药可能多个处方，处方类型和处方号，格式；单据,NO|单据,NO...
            //'      dteSendTime 配药时间，加上时间用于区别是哪次配药；
            //'      strReserve=扩展参数
            return true;
        }

        public bool DrugListWork(int intType, string str药品IDs, string strReserve = "")
        {
            //        '功能：药品目录通用业务接口
            //'      在完成药品目录中药品规格主要业务功能后调用该接口（增删改停用启用）
            //'参数：intType：业务类型，0-新增，1-修改，2-删除，3-停用，4-启用
            //'      str药品IDs ：药品id串，格式“药品id1,药品id2,...”
            //'      strReserve=扩展参数
            //'说明：业务类型=2修改时，正常情况是规格属性发生变化，也可能是因为该规格对应的品种属性修改，具体查询后比对
            //'      业务类型=3删除时，该接口是在ZLHIS功能执行后调用，在事务不同步情况下该药品已经在ZLHIS中删除了
            return true;
        }

        public bool DrugReturnByID(long lng库房ID, string strIDs, DateTime dteSendTime, string strReserve = "")
        {
            //        '功能：药品退药后调用，处方发药/部门发药业务都适用
            //'参数：lng库房ID  库房ID；
            //'      strIDs 一次退药操作可能退多个药品记录，格式；收发id,退药数量|收发id,退药数量...
            //'      dteSendTime 退药时间，一条收发id可能退多次，加上时间可以用于区别是哪次退药；
            //'      strReserve=扩展参数
            return true;
        }

        public bool DrugSendByRecipe(long lng库房ID, string strNos, DateTime dteSendTime, string strReserve = "")
        {
            //        '功能：药品处方发药后调用，按处方发药
            //'参数：lng库房ID  库房ID；
            //'      strNOs 一次发药可能多个处方，处方类型和处方号，格式；单据,NO|单据,NO...
            //'      dteSendTime 发药时间，可能一个处方退药了之后再发，加上时间用于区别是哪次发药；
            //'      strReserve=扩展参数
            return true;
        }

        public bool DrugSendBySumID(long lng库房ID, string strSumNO, string strReserve = "")
        {
            //        '功能：药品部门发药后调用，按收发id发药
            //'参数：lng库房ID  库房ID；
            //'      strSumNO 汇总发药号
            //'      strReserve=扩展参数
            return true;
        }

        public bool DrugSendCustomCheck(string str收发ids, string str返回收发ids, string strReserve = "")
        {
            //        '功能：药品部门发药主界面调用，按收发id传送，主要通过收发ID来获取其他信息
            //'参数：
            //'      str收发ids=收发id串，收发id1,收发id2...
            //'      str返回收发ids=返回主界面的收发ids，用来控制界面数据是否发药，默认返回的收发ids不发药
            //'      strReserve=扩展参数
            //'      返回：True-继续发药，False-不继续发药
            return true;
        }

        public bool DrugSendCustomCheckSet(string strFunName)
        {
            //        '功能：药品部门发药，自定义审核功能。返回true时部门发药主界面开启自定义审核功能按钮
            //'参数：strFunName：可以自定义功能名称，返回作为主界面工具栏按钮的名称
            //'返回：false-不启用，true-启用
            return true;
        }

        public bool DrugSendWorkNormal(long lngModual, string strFuncName, long lng库房ID, string strNO, int int单据, string strReserve = "")
        {
            //        '功能：药品发药业务调用
            //'参数：lngModual  模块号；
            //'      strFuncName  功能名称；
            //'      lng库房ID  库房ID；
            //'      strNO 单据号；
            //'      int单据 单据类型；
            //'      strReserve=扩展参数
            //'例：药品业务调用接口，传入库房ID，NO号，单据类型
            return true;
        }

        public bool DrugStuffWork(int intType, long lng库房ID, string strNO, int int单据, string strDate = "", string strReserve = "")
        {
            //        '功能：药品卫材流通通用业务接口
            //'      在完成流通主要业务功能后调用该接口（删除业务是在之前调用）
            //'参数：intType：业务类型，0-新增，1-修改，2-删除，3-审核，4-冲销
            //'      lng库房ID ：库房ID
            //'      strNO：单据号
            //'      int单据：单据类型
            //'      药品：0-计划；1-外购入库；2-自制入库；3-协药入库；4-其他入库；6-库房移出；7-部门领用；11-其他出库；12-盘点；
            //'      卫材：0-计划；15-材料外购入库,16-材料自制入库,17-材料其他入库,19-材料移库,20-部门材料领用,21-材料其他出库,22-材料盘点
            //'      strDate：单据日期，只有冲销时传入（因为允许部分冲销，用时间来区分本次冲销的是哪些数据，如果不传就是不允许部分冲销）
            //'      strReserve=扩展参数
            //'说明：1)根据传入的单据区分药品卫材和具体的业务类型
            //'      2)该接口可以通用于药品卫材所有的流通（包括计划，不包括发药/发料）的单据主要业务功能（增删改，审核，冲销），目前实现的功能如下
            //'      3)10.35.120 在药品申领、移库、外购、其他入库、其他出库、领用、盘点的审核功能中调用了接口
            return true;
        }

        public bool DrugStuffWorkNoramal(long lngModual, string strFuncName, long lng库房ID, string strNO, int int单据, string strReserve = "")
        {
            //        '功能：药品卫材流通管理业务调用
            //'参数：lngModual  模块号；
            //'      strFuncName  功能名称；
            //'      lng库房ID  库房ID；
            //'      strNO 单据号；
            //'      int单据 单据类型；
            //'      strReserve=扩展参数
            //'例：卫材外购入库调用接口，传入库房ID，NO号，单据类型
            //'    计划管理，单据类型=0
            return true;
        }

        public long EMPI_AddPatiInfo(long lngSys, long lngModule, long lngPatiID, long lngPageID, long lngClinicID, string strMsg, string strReserve = "")
        {
            //        '功能：向EMPI平台创建新病人信息
            //'返回：1是成功，0是失败
            //'参数：strMsg 出参接口内部赋值，成功、失败说明信息
            //'      strReserve=保留参数,用于扩展使用
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPageID－主页ID；lngClinicID－挂号ID；住院病人lngClinicID传0，门诊病人lngPageID传0
            return 1;
        }

        public long EMPI_ModifyPatiInfo(long lngSys, long lngModule, long lngPatiID, long lngPageID, long lngClinicID, string strMsg, string strReserve = "")
        {
            //        '功能：更新EMPI平台中的病人信息
            //'返回：1是成功，0是失败
            //'参数：strMsg 出参接口内部赋值，成功、失败说明信息
            //'      strReserve=保留参数,用于扩展使用
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPageID－主页ID；lngClinicID－挂号ID；住院病人lngClinicID传0，门诊病人lngPageID传0
            return 1;
        }

        public bool EMPI_QueryPatiInfo(long lngSys, long lngModule, Recordset rsIn, Recordset rsOut, string strReserve = "")
        {
            //        '功能：从EMPI平台中读取病人信息
            //'返回：是否查找成功，true－找到病人，false-未找到任何信息
            //'参数：
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      strReserve=保留参数,用于扩展使用：入院登记调用时代表：0-正常登记,1-预约登记,2-接收预约
            //'      rsIn HIS传入的病人信息
            //'      rsOut 返回的病人信息结果此记录集信息由接口内部进行赋值
            //'      rsInt和rsOut记录集字段相同，字段均为字符串类型，包含这些字段："病人ID,主页ID,挂号ID,门诊号,住院号,医保号,身份证号,其他证件,姓名,性别,出生日期,出生地点,国籍,民族,学历,职业,工作单位,邮箱,婚姻状况,家庭电话,联系人电话,单位电话,家庭地址,家庭地址邮编,户口地址,户口地址邮编,单位邮编,联系人地址,联系人关系,联系人姓名"
            //'说明：如果His没有找到病人而接口中找了病人或者两者的病人ID不一致，接口决定返回病人ID告诉His以接口的病人ID为准，则需要准确核实这个病人ID是否属于当前病人。
            //'       因为基本信息可能因EMPI发生变化，His不能判断信息的正确性。
            return false;
        }

        public bool ExeButtomClick(long lngSys, long lngModual, IntPtr objForm, string strName, string strFuncName,
            long lngPatiID, long lng主页ID, string str挂号单, long lng医嘱ID = 0, string strReserve = "")
        {
            //        '功能：执行窗体内部的功能
            //'参数：strName 当前窗体名称，strFuncName 菜名称(窗体中功能名称)
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngPatientID=病人ID,lng主页ID,str挂号单
            //'      lng医嘱ID=只有医技站传调用时会传入， 否则没传值
            //'    Exit Function '如使用此功能请修改接口内部实现
            //If objForm Is Nothing Then Exit Function
            //    ExeButtomClick = objForm.ExecuteFunc(lngSys, lngModual, objForm, strName, strFuncName, lngPatiID, lng主页ID, str挂号单, lng医嘱ID, strReserve)
            return true;
        }

        public void ExecuteFunc(long lngSys, long lngModual, string strFuncName, long lngPatiID,
            dynamic varRecId, dynamic varKeyId, string strReserve, int int场合 = -1, string strXML = "")
        {
            //        '功能：执行某个外挂功能
            //'参数：lngSys,lngModual=当前调用接口的上级系统号及模块号，病历调用时 lngModual＝1070，无int场合参数
            //'      strFuncName=要执行的功能名，该功能名之前由GetFuncNames函数返回
            //'      lngPatiID=当前病人ID,人员管理调用时，传入的人员ID， 新版LIS默认传入0
            //'      varRecId=数字或者字符串；对门诊病人，为当前挂号单号或者挂号ID；对住院病人，为当前住院主页ID，新版LIS默认传入0；挂号调用时，为挂号单号；收费调用时，为收费单号
            //'      varKeyId=数字或者字符串；当前的关键业务数据唯一标识ID，如医嘱ID
            //'           病历调用时 varKeyId=电子病历记录.id，在新增编辑未保存前其值=0,保存后或修改、审订时执行有值；
            //'           临床路径 varKeyId 病人路径id
            //'           新版LIS   varKeyId = 标本id ,当前有标本为标本id ,无标本则为0
            //'      strReserve=保留参数,用于扩展使用 当是病历调用时 strReserve＝ 病历文件列表.id 。当场合为5、6调用时,strReserve＝诊断内容
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS),3-挂号调用,4-收费调用,5-门诊医嘱下达诊断扩展,6-首页诊断扩展

            //'      strXml为XML格式的字符串,例：<ROOT><XXX>XXX</XXX></ROOT>
            //'       当门诊和住院医嘱界面调用时，strXml传入的节点：诊疗项目名称
            //'       当门诊医嘱界面调用时，strXml传入的节点：诊疗项目名称、界面科室ID、挂号科室ID
            //'       当住院医嘱界面调用时，strXml传入的节点：诊疗项目名称、病人科室ID、病人病区ID、界面科室ID、医护科室ID
            //'       场合为5和6时，strXml传入的节点：诊断ID、疾病ID

            //'特殊说明：当插件在人员管理模块调用时只传入lngSys、lngModual、strFuncName、lngPatiID、varRecId、varKeyId，
            //'          lngPatiID就是人员id，如果lngPatiID＝0表示界面上未选中人员；其中的varRecId和varKeyId等值都是传的0

            //    '注意：在采用分离插件后，功能的执行时，应该先对功能明进行判断。
            //    '先检查功能是否在本插件（zlPlugIn）中，然后再去执行扩展插件
        }

        public string GetButtomName(long lngSys, long lngModual, IntPtr objForm, string strName)
        {
            //        '功能：添加到菜单和工具栏上的按钮名称，菜单上级为 扩展，工具栏上直接加按钮
            //'参数：strName 当前窗体名称
            //'        Exit Function '如使用此功能请修改接口内部实现
            //    If objForm Is Nothing Then Exit Function
            //    GetButtomName = objForm.GetInSideFunc(lngSys, lngModual, objForm, strName)
            return "";
        }

        public IntPtr GetForm(long lngSys, long lngModual, string strName)
        {
            //        '功能：根据索引值返回对象。工作站窗体加载时调用
            //'        Exit Function '如使用此功能请修改接口内部实现
            //'    Select Case lngModual
            //'    Case m住院医生工作站
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    Case m住院护士工作站
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    Case m门诊医生工作站
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    Case m医技工作站
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    Case m门诊医嘱下达
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    Case m住院医嘱下达
            //'        Select Case strName
            //'        Case "Test1"
            //'            Set GetForm = New frmDockEx
            //'        Case "Test2"
            //'            Set GetForm = New frmDockEx
            //'        Case Else
            //'            Set GetForm = GetFormEx(lngSys, lngModual, strName)
            //'        End Select
            //'    End Select
            //    'todo 从这里以下开始编写自己的代码，上面的代码可以不删除
            //    '主插件调用本方法实例化页签窗体
            //    Select Case strName
            //        Case "页签名称1", "页签名称2"
            //            Set GetForm = New frmDockEx
            //    End Select
            //    Call mdlPublic.LoadPageInfo(lngSys, lngModual, strName)   '装载当前页签详细
            return IntPtr.Zero;
        }

        public string GetFormCaption(long lngSys, long lngModual)
        {
            //        '功能：在住院医生工作站中添加卡片的名称，逗号分割。
            //'    Dim strTmp As String, strThis As String
            //'    Exit Function '如使用此功能请修改接口内部实现
            //'    strTmp = GetFormCaptionEx(lngSys, lngModual)
            //'
            //'    Select Case lngModual
            //'    Case m住院医生工作站
            //'        strThis = "Test1,Test2"
            //'    Case m住院护士工作站
            //'        strThis = "Test1,Test2"
            //'    Case m门诊医生工作站
            //'        strThis = "Test1,Test2"
            //'    Case m医技工作站
            //'        strThis = "Test1,Test2"
            //'    Case m住院医嘱下达
            //'        strThis = "Test1,Test2"
            //'    Case m门诊医嘱下达
            //'        strThis = "Test1,Test2"
            //'    End Select
            //'    GetFormCaption = strThis & IIf(strTmp = "", "", "," & strTmp)
            return "";
        }

        public long GetFormHwnd(string strReserve = "")
        {
            //        '功能：病人信息管理 模块中调用 获取要嵌入的窗体句柄，
            //'参数：
            //'      strReserve=扩展参数
            return 0;
        }

        public string GetFuncNames(long lngSys, long lngModual, int int场合 = -1, string strReserve = "")
        {
            //        '功能：获取外挂功能列表；该接口一般在初始化之后调用一次，调用时机和频度可能因不同的主程序而不同
            //'参数：lngSys,lngModual=当前调用接口的上级系统号及模块号，病历调用时 lngModual=1070，无int场合参数
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS),3-门诊挂号调用,4-门诊收费调用,5-门诊医嘱下达诊断扩展,6-首页诊断扩展
            //'      strReserve=保留参数,用于扩展使用

            //'返回：外挂功能列表，格式为"功能名1,功能名2,功能名3,..."
            //'       "Auto"   关键字支持新版护士站-病人事务窗口：病人医嘱(门诊和住院)Dock页签界面、临床路径Dock页签界面，医嘱附费Dock页签界面，当切换病人后会自动执行该功能，该功能只充许有一个
            //'       "InTool" 表示当前这个功能，是否是直接显示还是以下拉方式二级菜单显示，
            //'说明：当插件在人员管理模块调用时只传入lngSys和lngModual，并且其中的lngModual＝0

            //'strReserve 扩展后被用于控件功能在ZLHIS工作站中菜单的显示样式，如果不对此参数赋值，则仍沿用以前返回值方式
            //'应用场合:
            //'   1.新版护士站主界面（菜单栏-工具-按钮下；工具栏；床头卡右键菜单）
            //'   2.包含（门诊/住院医嘱清单、临床路径，医嘱附费）模块嵌入的Dock页签显示的工作站界面切换到医嘱信息页签后窗口功能显示
            //'     如：门诊医生站-医嘱信息，住院医生站-医嘱信息，老版护士站-医嘱信息，新版护士站病-病人事物窗中-医嘱信息等。
            //'当窗口切换当对应页签后生效:
            //'      a.病人医嘱(门诊和住院)Dock页签界面，[菜单栏－医嘱、工具按钮下;工具栏；右键弹出随 医嘱  菜单弹出]；
            //'      b.临床路径Dock页签界面，[菜单栏－路径、工具 按钮下；工具栏；右键弹出随 路径 菜单弹出]；
            //'      c.医嘱附费Dock页签界面，[菜单栏－费用、工具 按钮下；工具栏；右键弹出随 费用 菜单弹出]；
            //'格式为: xml结构 "<menubar>...</menubar><toolbar>...</toolbar><popbar>...</popbar><hotkey>...</hotkey>"
            //'menubar   窗体主界面菜单栏"工具"中展示样式，结点内容逗号分割，"功能1,功能2,功能3,功能4"，
            //'          每个功能前可以前缀 “|:Auto:InTool:功能1”
            //'          "|"竖线，表示当前位进行菜单的分割就是菜单之前的分割线；
            //'          "Auto"   关键字支持新版护士站-病人事务窗口：病人医嘱(门诊和住院)Dock页签界面、临床路径Dock页签界面，医嘱附费Dock页签界面，当切换病人后会自动执行该功能，该功能只充许有一个
            //'          "InTool" 表示当前这个功能，是否是直接显示还是以下拉方式二级菜单显示，
            //'toolbar  窗体主界面工具栏中展示样式，结点内容逗号分割，"功能1,功能2,功能3,功能4"，
            //'         每个功能前可以前缀 “|:InTool:功能1”
            //'         "|"竖线，表示当前位进行菜单的分割就是菜单之前的分割线；
            //'         "InTool" 表示当前这个功能，是否是直接显示还是以下拉方式二级菜单显示，
            //'popbar   右键弹出菜单展示样式，结点内容逗号分割，"功能1,功能2,功能3,功能4"，
            //'         每个功能前可以前缀 “|:InTool:功能1”
            //'         "|"竖线，表示当前位进行菜单的分割就是菜单之前的分割线；
            //'         "InTool" 表示当前这个功能，是否是直接显示还是以下拉方式二级菜单显示，
            //'hotkey   窗体中快捷建，功能名|KeyCode|Shift 组合成成，例："快捷键功能1|116|0,快捷键功能2|123|0,快捷键功能3|49|4
            //'         原理：功能由 父窗体的Private Sub Form_KeyDown(KeyCode As Integer, Shift As Integer)事件进行触发
            //'         该功能仅门诊医生工作站医嘱下达界面-医嘱编辑 页签生效。
            return "";
        }

        public Dictionary<string, string> GetMeRecFormCol(long lngSys, long lngModule, long lngPatiID, long lngPageID, long lngPatiType)
        {
            //'初始化外挂附页窗体对象的集合，注：zlhis34最多可以扩展3个页签窗体
            throw new NotImplementedException();
        }

        public bool InPatiCancelOutBefore(long lng病人ID, long lng主页ID, string strReserve = "")
        {
            //        '功能：病人撤消出院之前调用(病人入出管理撤消出院操作时调用)
            //'参数：lng病人ID   病人ID
            //'      strReserve=扩展参数
            //'返回：true 允许撤消出院，false不能撤消出院
            return true;
        }

        public bool InPatiCashierAfter(long lng病人ID, long lng结帐ID, string strReserve = "")
        {
            //        '功能：业务评价 出院结账后调用
            //'参数：lng病人ID   病人ID；lng结帐ID 收费后产生病人结帐记录ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool InPatiCheckInAfter(long lng病人ID, long lng主页ID, string strReserve = "")
        {
            //        '功能：业务评价 入院处办理入院后调用
            //'参数：lng病人ID   lng主页ID
            //'      strReserve=扩展参数：入院登记调用时代表：0-正常登记,1-预约登记,2-接收预约
            return true;
        }

        public bool InPatiCheckInBranchAfter(long lng病人ID, long lng主页ID, string strReserve = "")
        {
            //        '功能：业务评价 护士站办理入科后调用
            //'参数：lng病人ID   lng主页ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool InPatiCheckInCancel(long lng病人ID, long lng主页ID, long lngType, string strReserve = "")
        {
            //        '功能：入院登记界面关闭或者点取消退出按钮时调用
            //'参数：lng病人ID   lng主页ID，这两个参数可能没有值，当登记界面被清空或者未录入时这两个值均为0
            //'      lngType 0-正常登记,1-预约登记,2-接收预约
            //'      strReserve=扩展参数
            return true;
        }

        public bool InPatiCheckOutAfter(long lng病人ID, long lng主页ID, string strReserve = "")
        {
            //        '功能：业务评价 护士站办理出院后调用(病人入出管理)
            //'参数：lng病人ID   病人ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool LisPrintCodeBefore(long lngSys, long lngModual, Recordset rsNumber)
        {
            //        '参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'   rsNumber 本次打印的条码记录集中 包含的字段
            //'   rsNumber 中可能会存在多个条码
            //'    rsNumber.Fields.Append "类别", adVarChar, 20
            //'    rsNumber.Fields.Append "管码", adVarChar, 18
            //'    rsNumber.Fields.Append "相关ID", adBigInt
            //'    rsNumber.Fields.Append "样本条码", adVarChar, 18
            //'    rsNumber.Fields.Append "执行科室ID", adVarChar, 18
            //'    rsNumber.Fields.Append "诊疗项目ID", adVarChar, 18
            //'    rsNumber.Fields.Append "婴儿", adBigInt
            //'    rsNumber.Fields.Append "紧急标志", adBigInt
            //'    rsNumber.Fields.Append "标本", adVarChar, 30
            //'    rsNumber.Fields.Append "医嘱内容", adVarChar, 500
            //'    rsNumber.Fields.Append "采集方式", adVarChar, 100
            //'    rsNumber.Fields.Append "开嘱医生", adVarChar, 50
            //'    rsNumber.Fields.Append "开嘱时间", adDate
            //'    rsNumber.Fields.Append "采样人", adVarChar, 50
            //'    rsNumber.Fields.Append "采样时间", adDate
            //'    rsNumber.Fields.Append "采血量", adVarChar, 20
            //'    rsNumber.Fields.Append "试管名称", adVarChar, 50
            //'    rsNumber.Fields.Append "病人来源", adInteger
            //'    rsNumber.Fields.Append "医嘱ID串", adVarChar, 500
            //'    rsNumber.Fields.Append "执行科室", adVarChar, 50
            //'    rsNumber.Fields.Append "婴儿姓名", adVarChar, 50
            //'    rsNumber.Fields.Append "婴儿性别", adVarChar, 50
            //'    rsNumber.Fields.Append "申请科室", adVarChar, 50
            //'  返回值未false 时候，条码不进行打印。
            return true;
        }

        public bool LoadMecInfo(long lngSys, long lngModule, long lngPatiID, long lngPageID, long lngPatiType, dynamic colCtl)
        {
            // '---------------------------------------------------------------------------------------------------------------------------------------------
            //'功能:首页加载自定义数据
            //'返回：True是成功，False是失败
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      colCtl 病案首页控件集合
            //'      lngPageID－主页ID；
            //'      lngPatiType－病人类型:1-门诊,2-住院
            //'      lngPatiID-病人id
            //'------------------------------------------------------------colCtl控件集合Key值--------------------------------------------------------------
            //'结构化地址控件:出生地点(结构化), 籍贯(结构化), 现住址(结构化), 户口地址(结构化), 联系人地址(结构化)
            //'结构化地址控件[属性]:value省,value市,value区县,value乡镇,value详细地址
            //'文本框:出生地点, 籍贯, 现住址, 户口地址, 联系人地址, 病人区域, 单位地址, 病案号, 档案号, X线号, 姓名, 其他证件, 联系人姓名, 入院科室, 入院病房,
            //'       出院科室, 出院病房, 医保号, 摘要, 门诊号, 监护人, 发病地址, 医学警示, 其他医学警示, 病理号, 死亡原因, 病原学诊断, 抢救病因, 输其他,
            //'       转入医疗机构, 31天内再住院, 转科1, 转科2, 转科3, 退出原因, 变异原因, 重症监护室名称, 肿瘤T, 肿瘤N, 肿瘤M, Email, 其他会诊, 引发药物,
            //'       临床表现, 透析尿素氮值, 其他关系, 入院转入, 单位电话, 单位邮编, 家庭电话, 家庭邮编, 户口邮编, 身高, 身高单位, 体重, 体重单位, 体温,
            //'       入院次数, 收缩压, 舒张压, 联系人电话, 年龄, 婴幼儿年龄, 新生儿出生体重, 新生儿入院体重, 住院天数, 住院号, 抢救次数, 成功次数, 特护,
            //'       一级护理, 二级护理, 三级护理, ICU, CCU, 输红细胞, 输血小板, 输血浆, 输全血, 自体回收, 呼吸机使用, 昏迷时间入院前_天, 昏迷时间入院前_小时,
            //'       昏迷时间入院前_分钟, 昏迷时间入院后_天, 昏迷时间入院后_小时, 昏迷时间入院后_分钟, 随诊期限, 费用和, 约束总时间, 重症监护天, 重症监护小时,
            //'       Apgar , QQ, 输白蛋白, 院内会诊, 外院会诊, 距上次住院时间
            //'下拉框: 门诊医师 , 科主任, 主任或副主任, 进修医师, 主治医师, 住院医师, 研究生医师, 实习医师, 质控医师, 质控护士, 责任护士, 编目员, 主诊医师, 随诊期限(下拉)
            //'        付款方式, 性别, 婚姻, 职业, 国籍, 民族, 关系, 入院途径, 文化程度, 去向, 感染与死亡关系, 入院情况, 分化程度, 最高诊断依据, 门诊与出院XY,入院与出院XY,
            //'        门诊与入院, 术前与术后, 放射与病理, 临床与病理, 死亡期间, 临床与尸检, 门诊与出院ZY, 入院与出院ZY, 辩证, 治法, 方药, 治疗类别, 中医诊疗设备, 抢救方法,
            //'        中医诊疗技术, 自制中药制剂, 辨证施护, 病案质量, 病例分型, HBsAg, 血型, HCVAb, RH, HIVAb, 输液反应, 输血反应, 输血前9项检查, 生育状况, 出院方式,
            //'        再入院计划天数, 压疮发生期间, 压疮分期, 跌倒或坠床伤害, 跌倒或坠床原因, 距上次住院时间(下拉), 重返间隔时间, 约束方式, 约束工具, 约束原因,
            //'        新生儿离院方式 , 肿瘤分期, 临床路径管理, 法定传染病, 实施DGRS管理, 死亡患者尸检, 身份证, 变异原因(下拉), 健康卡号, 年龄(下拉), 婴幼儿年龄(下拉),
            //'时间控件: 出生日期 , 入院时间, 出院时间, 确诊日期, 死亡时间, 发病日期, 发病时间, 质控日期, 编目日期, 收回日期, 入科时间
            //'复选框: 再入院 , 入院前外院治疗, 是否确诊, 病原学检查, 新发肿瘤, 危重, 急症, 疑难, 示教病案, 科研病案, 疑难病例, 随诊, CT, MRI, 彩色多普勒,
            //'        传染病上传, 围术期死亡, 术后猝死, 进入路径, 完成路径, 变异, 住院出现危重, 是否同一疾病, 人工气道脱出, 重返重症医学科, 住院物理约束, 单病种管理,
            //'        细菌标本送检 , 会诊情况, 无过敏记录, 未找到时自由录入
            //'单选按钮: 再住院无 , 再住院有, 初诊, 复诊, ICU无, ICU有, XY按诊断输入, XY按疾病编码输入, ZY按诊断输入, ZY按疾病编码输入, 按诊断输入,
            //'          按疾病编码输入, 按药品目录输入, 按过敏源输入
            //'VS表格: 转科情况 (表格), 西医诊断(表格), 中医诊断(表格), 过敏信息(表格), 手术记录(表格), 住院费用(表格), 化疗记录信息(表格), 放疗记录信息(表格),
            //'        抗菌药物使用情况(表格), 抗精神病治疗情况(表格), 重症监护情况(表格), 病案附加项目(表格), 特殊检查情况(表格)
            //'list列表控件: 不良事件(表格), 感染因素(表格)
            //'树形表控件:  住院费用(树形表)
            //'------------------------------------------------------------表格控件列枚举--------------------------------------------------------------------
            //'过敏信息列枚举 : 过敏药物=0 ,过敏反应=1 ,过敏时间=2 ,过敏源编码=3 ,药物ID=4 ,过敏来源=5
            //'(西医诊断/中医诊断)列枚举 : 诊断类型=0 ,关联=1 ,诊断编码=2 ,诊断描述=3 ,中医证候=4 ,发病时间=5 ,备注=6 ,入院病情=7 ,出院情况=8 ,ICD附码=9 ,是否未治=10
            //'            是否疑诊=11 ,增加=12 ,Del=13 ,诊断ID=14 ,疾病ID=15 ,证候ID=16 ,医嘱IDs=17  ,诊断分类=18 ,固定附码=19 ,是否病人=20
            //'            诊断来源=24 ,疾病编码=25 ,疾病类别=26 ,证候编码=27 ,记录日期=28 ,记录人员=29 ,疗效限制=21 ,分娩信息=22 ,附码ID=23
            //'手术列枚举 : Copy=0 ,手术日期=1 ,结束日期=2 ,抗菌用药时间=3 ,手术情况=4 ,准备天数=5 ,手术编码=6 ,手术名称=7 ,再次手术=8 ,主刀医师=9 ,助产护士=10 ,助手1=11
            //'    助手2=12 ,麻醉开始时间=13 ,麻醉类型 (界面名称麻醉方式)= 14  ,ASA分级=15 ,NNIS分级=16 ,手术级别=17 ,麻醉医师=18 ,切口愈合=19 ,切口部位=20 ,重返手术室计划=21
            //'    重返手术室目的=22 ,切口感染=23 ,并发症=24 ,预防用抗菌药=25 ,抗菌药天数=26 ,非预期的二次手术=27 ,麻醉并发症=28 ,术中异物遗留=29 ,手术并发症=30 ,术后出血或血肿=31
            //'    手术伤口裂开=32 ,术后深静脉血栓=33 ,术后生理代谢紊乱=34 ,术后呼吸衰竭=35 ,术后肺栓塞=36 ,术后败血症=37 ,术后髋关节骨折=38 ,手术操作ID=39 ,诊疗项目ID=40 ,麻醉ID=41
            //'    麻醉方式(界面名称麻醉类型)=42  ,手麻来源=43
            //'化疗列枚举 : 化学治疗编码=0 ,开始日期=1 ,结束日期=2 ,疗程数=3 ,化疗方案=4 ,总量=5 ,化疗效果=6 ,疾病ID=7
            //'放疗列枚举 : 放射治疗编码=0 ,开始日期=1 ,结束日期=2 ,设野部位=3 ,放射剂量=4 ,累计量=5 ,放疗效果=6 ,疾病ID=7
            //'精神药品列枚举 : 药物名称=0 ,疗程=1 ,最高日量=2 ,特殊反应=3 ,疗效=4 ,药品ID=5
            //'重症监护枚举 : 序号=0 ,监护室名称=1 ,进入时间=2 ,退出时间=3 ,再入住计划=4 ,再入住原因=5
            //'重症监护器械枚举 : ICU类型=0 ,器械及导管=1 ,开始时间=2 ,结束时间=3 ,感染累计小时=4
            //'医院感染枚举 : 确诊日期=0 ,感染部位=1 ,医院感染名称=2 ,医院感染编码=3
            //'标本来源枚举 : 标本=0 ,病原学代码及名称=1 ,送检日期=2
            //'抗菌药枚举 : 序号=0 ,抗菌药物名=1 ,用药目的=2 ,使用阶段=3 ,使用天数=4 ,一类切口预防用=5 ,DDD数=6 ,联合用药=7
            //'---------------------------------------------------------------------------------------------------------------------------------------------
            //'使用itemData的控件:
            //'涉及动态加载下拉框: 用于存储数据的id
            //'不良事件 (表格), 感染因素(表格): 用于存储数据的编码
            //'使用rowdata的控件:
            //'过敏信息 (表格), 西医诊断(表格), 中医诊断(表格), 手术记录(表格): 用于存储数据的id
            //'化疗记录信息 (表格), 重症监护情况(表格), 放疗记录信息(表格), 抗精神病治疗情况(表格): 用于存储数据的序号
            //'抗菌药物使用情况 (表格): 用于存储数据的药名id
            //'---------------------------------------------------------------------------------------------------------------------------------------------
            return true;
        }

        public void LogInAfter()
        {
            //'功能：登陆航导台之后
        }

        public void LogOutBefore()
        {
            //'功能：关闭航导台或者注销当前
        }

        public bool OutPatiExseAfter(long lng病人ID, long lng结帐ID, string strReserve = "")
        {
            return true;
        }

        public bool OutPatiInvoicePrintAfter(long lng病人ID, long str结帐IDs, string strReserve = "")
        {
            //        '功能：业务评价 门诊收费完成后调用
            //'参数：lng病人ID   病人ID；lng结帐ID 本次收费后产生病人结帐记录ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool OutPatiMedicineAfter(long lng病人ID, string strNO, int int单据, long lng药房ID, string strReserve = "")
        {
            //        '功能：业务评价 门诊发药后调用
            //'参数：lng病人ID   病人ID；strNO 单据号；int单据 单据类型；lng药房ID 药房ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool OutPatiRegisterAfter(long lng病人ID, long lng挂号ID, string strReserve = "")
        {
            //        '功能：业务评价 门诊挂号完成后调用
            //'参数：lng病人ID   病人ID；lng挂号ID 病人挂号ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool PathEvaluateAfter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lng路径记录ID, long lng阶段ID, int int场合 = -1, string strReserve = "")
        {
            //        '功能：评估路径评估后
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号1256=临床路径应用
            //'      lngPatientID=病人ID,lngClinicID=主页ID
            //'      lng路径记录ID=病人临床路径.id
            //'      lng阶段ID=当前评估的阶段ID
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strReserve=扩展参数
            return true;
        }

        public bool PathEvaluateBefore(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lng路径记录ID, long lng阶段ID, int int场合 = -1, string strReserve = "")
        {
            //        '功能：评估路径评估前
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号1256=临床路径应用
            //'      lngPatientID=病人ID,lngClinicID=主页ID
            //'      lng路径记录ID=病人临床路径.id
            //'      lng阶段ID=当前评估的阶段ID
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strReserve=扩展参数
            return true;
        }

        public bool PathImportAfter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lng路径ID, long lng版本号ID,
            int int场合 = -1, long lngDiagnosisType = 0, long lng疾病ID = 0, long lng诊断ID = 0, string strReserve = "")
        {
            //        '功能：路径导入后
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=主页ID
            //'      lng路径ID=临床路径目录.id
            //'      lng版本号ID=导入的版本号
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      strReserve=扩展参数
            return true;
        }

        public bool PathImportBefore(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long lng路径ID, long lng版本号ID,
            int int场合 = -1, long lngDiagnosisType = 0, long lng疾病ID = 0, long lng诊断ID = 0, string strReserve = "")
        {
            //        '功能：路径导入前
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号(1252=门诊医嘱下达,1253=住院医嘱下达)
            //'      lngPatientID=病人ID,lngClinicID=主页ID
            //'      lng路径ID=临床路径目录.id
            //'      lng版本号ID=导入的版本号
            //'      int场合  调用场合:0-医生站调用,1-护士站调用,2-医技站调用(PACS/LIS)
            //'      lngDiagnosisType 导入诊断类型 '诊断类型: 1 - 西医门诊诊断; 2 - 西医入院诊断; 11 - 中医门诊诊断; 12 - 中医入院诊断
            //'      lng疾病ID=导入疾病（疾病编码目录.ID）、lng诊断ID=导入诊断(疾病诊断目录.ID)
            //'      strReserve=扩展参数
            return true;
        }

        public bool PatiFeeAuditingAndCancelCheck(long lngModual, long lng病人ID, long lng主页ID, bool blnCancel = false, string strExpendXML = "")
        {
            //    '功能:病人费用审核和取消审核检查
            //'入参:lngModual-调用的模块号
            //'     lng病人ID-病人ID
            //'     lng主页ID-主页ID
            //'     blnCancel-取消执行时，传入True,执行时传入False
            //'     strExpendXML-保留参数,暂无，待以后扩展
            //'出参:strExpendXML-保留参数,暂无，待以后扩展
            //'返回:检查合法，返回True,否则返回False
            //'编制:刘兴洪
            //'日期:2016-09-01 17:09:06
            //'调用：
            //'  病人费用查询--病人审核和取消病人审核时调用(数据保存前调用)
            return true;
        }

        public bool PatiInfoSaveAfter(long lng病人ID, string strReserve = "")
        {
            //        '功能：病人信息管理 模块中调用 病人信息管理中保存病人信息后，事务提交后调用，插件中渠道自行处理数据保存
            //'参数：lng病人ID   病人ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool PatiInfoSaveBefore(long lng病人ID, string strReserve = "")
        {
            //        '功能：病人信息管理 模块中调用 病人信息管理中保存病人信息前，用于控制一些检查类的业务，返回False终止保存操作。
            //'参数：lng病人ID   病人ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool PatiPrePayAfter(long lng病人ID, int int预交类型, long lng预交ID, string strReserve = "")
        {
            //        '功能：业务评价 缴纳预交款后调用（门诊/住院通用，由参数 int预交类型 来区分）
            //'参数：lng病人ID   病人ID
            //'      int预交类型：0-门诊，1-住院
            //'      lng预交ID  预交记录ID
            //'      strReserve=扩展参数
            return true;
        }

        public bool PatiRegTriageCheck(long lngSys, long lngModule, byte bytFun, long lng挂号ID, string str医生 = "", string str诊室 = "", string str新号码 = "", long lng新出诊记录ID = 0)
        {
            //    '功能:挂号分诊检测接口
            //'入参:lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'     bytFun- 0-分诊;1-换号;2-完成就诊(13-恢复就诊);3-标记为不就诊;4-签道(14-取消签道);5-回诊(15-取消回诊);6-病人待诊
            //'     lng挂号ID-挂号ID
            //'     str医生-医生姓名(bytfun=0,1,2,4时传入)
            //'     str诊室-诊室名称(bytfun=0,1,2,4时传入)
            //'     str新号码-换号时的新号码(bytfun=1时传入）
            //'     lng新出诊记录ID-换号时的新号码(bytfun=1时传入）
            //'出参:
            //'返回:分诊合法返回true,否则返回False
            return true;
        }

        public bool PatiValiedCheck(long lngSys, long lngModule, long lngType, long lngPatiID, long lngPageID, string strPatiInforXML, string strReserve = "")
        {
            //        '功能：检查当前病人是否是指定的特殊病人
            //'返回：true时允许继续操作，False时不允许操作
            //'参数：
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号
            //'      lngType 操作类型：1－门诊挂号，2－住院入院，3－门诊收费，4－住院结帐，5-门诊结帐。
            //'      lngPatiID-病人ID: 新建档的，为0,否则传入建档病人ID
            //'      lngPageID-主页ID: 新建档的，为0,否则传入建档主页ID(住院传入主页ID) 特殊说明：仅 lngType=4 时才传入 lngPageID，其它均传0
            //'      strPatiInforXML-病人信息:针对未建档病人传入，"姓名，性别，年龄，出生日期，医保号，身份证号"，出生日期 格式:2016-11-11 12:12:12,操作类型=1时，还会传入当前挂号的医生姓名
            //'                      固定格式：<XM></XM><XB></XB><NL></NL><CSRQ></CSRQ><YBH></YBH><SFZH></SFZH><YSXM></YSXM>
            //'      strReserve=保留参数,用于扩展使用
            return true;
        }

        public bool PivaWorkNormal(long lngModual, string strFuncName, long lng库房ID, long lng配药id, string strReserve = "")
        {
            //        '功能：配置中心业务调用
            //'参数：lngModual  模块号；
            //'      strFuncName  功能名称；
            //'      lng库房ID  库房ID；
            //'      lng配药id 输液单id；
            //'      strReserve=扩展参数
            return true;
        }

        public bool QueryPatiInfo(long lngSys, long lngModule, string str卡号, Recordset rsInfo)
        {
            //    '功能:返回病人信息集。病人信息集为动态记录集，在接口中预先写好构建及返回字段模板；如果返回字段中"病人ID"<>0，则表示接口返回前已新建档案，挂号程序直接提取病人ID对应的档案信息，而不直接读取其他字段；
            //'入参:lngModule-调用的模块号
            //'出参:rsInfo-返回的病人信息集(直接更新该表,字段为:病人ID,姓名,性别,年龄,出生日期,出生地点,身份证号,其他证件,身份,职业,家庭地址,家庭电话,家庭邮编,工作单位,单位邮编,医保号,医疗付款方式,费别,国籍,民族,婚姻状况,区域)
            //'返回:调用成功,返回true,否则返回False
            //'编制:刘兴洪
            //'日期:2011-06-10 17:33:19
            //'说明:准格尔旗区域卫生系统接口(读取病人信息)
            //'问题:38841
            return true;
        }

        public void RefreshForm(long lngSys, long lngModual, IntPtr objForm, string strName, long lngPatiID, string str挂号单, long lng主页ID,
            bool blnMoved, long lng界面科室ID, long lng医护科室ID, long lng病区ID, long lng科室id, long lng前提ID, int int状态, int int执行状态, long lng路径状态 = -1)
        {
            //        '功能：刷新内部界面
            //'参数：strName 当前窗体名称
            //'      lngPatiID 病人id,str挂号单 挂号单号门诊病人才有否则为空，lng主页ID 住院病人才有否则为0
            //'      blnMoved=该病人的数据是否已转出
            //'      lng界面科室ID=如果当前医生站是会诊病人，则为会诊科室ID；如果是医技站调用，则为医技科室ID
            //'      lng医护科室ID=医护站界面ID
            //'      lng病区ID，lng科室ID=当“5-最近转科病人”时为病人原病区或原科室
            //'      lng前提ID=当由医技站调用时传入
            //'      int状态=0-在院病人,1-预出院病人,2-出院病人,3-待会诊病人(在院),4-已会诊病人,5-最近转科病人(在院),6-转科或转病区待入住病人(不含入院待入住)
            //'      int执行状态=当由医技站调用时传入,医技执行项目的执行状态
            //'      lng路径状态=-1:未导入,0-不符合导入条件，1-执行中，2-正常结束，3-变异结束
            //'    Exit Sub '如使用此功能请修改接口内部实现
            //    If objForm Is Nothing Then Exit Sub
            //    Call objForm.RefreshInSide(lngSys, lngModual, objForm, strName, lngPatiID, str挂号单, lng主页ID, _
            //     blnMoved, lng界面科室ID, lng医护科室ID, lng病区ID, lng科室ID, _
            //     lng前提ID, int状态, int执行状态, lng路径状态)
        }

        public bool SaveCtlInfoCheck(long lngSys, long lngModule, long lngPatiID, long lngPageID, Recordset rsCtlValueInfo, string strError, Recordset rsBackInfo, string strReserve = "")
        {
            //        '功能：检查当前病人录入的信息是否准确
            //'返回：检查到不合格的信息后返回错误信息,格式(信息名|控件名|Index|错误信息)
            //'参数：
            //'      lngSys,lngModual=当前调用接口的主程序系统号及模块号。
            //'      lngPatiID-病人ID: 新建档的，为0,否则传入建档病人ID
            //'      lngPageID-主页ID: 新建档的，为0,否则传入建档主页ID(住院传入主页ID) 特殊说明：仅 lngType=4 时才传入 lngPageID，其它均传0
            //'      rsCtlValueInfo:界面上录入的病人信息记录集:序号,信息名,控件名,Index(控件Index),ExpState(是否扩展),信息原值,信息现值,Edit(是否可编辑),是否改变
            //'      记录集数据有(控件名,信息名;): "txtPatient", "病人ID"; "txt住院号", "住院号"; "txt姓名", "姓名"; "txt医保号", "医保号"; "txt身份证号", "身份证号"; "cboIDNumber", "身份证未录原因";"txt支付密码", "支付密码"; "txt验证密码", "验证密码";
            //       '"txt出生日期", "出生日期"'"txt出生时间", "出生时间"' "txt年龄", "年龄"' "cbo年龄单位", "年龄单位"' "cbo性别", "性别"; "cbo费别", "费别"; "cbo医疗付款", "医疗付款方式"; "txt险类", "险类名";"cbo国籍","国籍"; "cbo民族", "民族";
            //       '"cbo身份", "身份"; "txt其他证件", "其他证件";"cbo学历", "学历"; "cbo婚姻状况", "婚姻状况"; "cbo职业", "职业"; "txt家庭地址", "现住址";"txt家庭电话", "家庭电话";"txt家庭地址邮编", "家庭地址邮编"; "txt户口地址", "户口地址";
            //       '"txt户口地址邮编", "户口地址邮编"; "txt籍贯", "籍贯"; "txt出生地点", "出生地点"; "txt区域", "区域"; "cbo病人类型", "病人类型"; "txt工作单位", "工作单位";"txt单位电话","单位电话"; "txt单位邮编", "单位邮编";"txt单位开户行", "单位开户行";
            //       '"txt单位帐号", "单位帐号";"txtMobile", "手机号"; "cbo联系人关系", "联系人关系"; "txt联系人姓名", "联系人姓名"; "txt联系人电话", "联系人电话"; "txt联系人身份证号", "联系人身份证号"; "txt联系人地址", "联系人地址"; "txt担保人", "担保人";
            //       '"chkUnlimit", "是否不限担保额"; "txt担保额", "担保额"; "dtp担保时限", "担保时限"; "chk临时担保", "是否临时担保";"txtReason", "担保原因"; "cbo入院科室","入院科室";"cbo入院病区", "入院病区"; "cbo床位","入院床位"; "txtTimes","第几次住院";
            //       '"cbo护理等级", "护理等级";"cbo门诊医师", "门诊医师"; "txt入院时间", "入院时间"; "chk再入院", "是否再入院";"chk陪伴", "是否陪伴"; "cbo住院目的", "住院目的"; "cbo入院病况", "入院病况"; "cbo入院属性", "入院属性"; "chk二级院转入", "是否二级院转入";
            //       '"txt门诊诊断", "门诊诊断";"cbo入院方式", "入院方式"; "txt转入", "转入医疗机构";"txt中医诊断", "中医诊断"; "txt备注", "备注";"PatiAddress(1)","出生地点";"PatiAddress(2)", "籍贯";"PatiAddress(3)", "现住址";"PatiAddress(4)", "户口地址";
            //       '"PatiAddress(5)", "联系人地址";"txtPages", "主页ID";"txtLinkManInfo","关系",
            //'      rsBackInfo:扩展参数,用于记录检查出的所有错误信息，返回到界面上显示出来
            //'      strReserve=保留参数,用于扩展使用
            return true;
        }

        public bool SetPassDiag(long lngPatientID, long lng主页ID, Recordset rsDiag)
        {
            //        '功能：合理用药监测传入诊断拦截
            //'参数：
            //'      lngPatientID=病人ID,lng主页ID= 主页ID
            //'      rsDiag=传入Pass的诊断记录;此记录由合理用药监测传入,此记录集允许增删改操作

            //'出参:
            //'      rsDiag返回加工后的诊断记录
            return true;
        }

        public bool SetPassExams(long lngPatientID, long lng主页ID, long lng挂号ID, string strExamsInfo)
        {
            //        '功能：合理用药监测传入检验信息
            //'参数：
            //'      lngPatientID=病人ID,lng主页ID= 主页ID,lng挂号ID-挂号ID
            //'出参:
            //'      strExamsInfo返回检验信息MXL\JSON字符串
            return true;
        }

        public bool ShowClinicHelp(long lngOwnHwnd, int int场合, int int病人来源, long lng病人ID, long lng就诊ID, string str项目IDs, string strReserve = "")
        {
            //        '功能:外接第三方诊疗参考
            //'入参:lngOwnHwnd：父窗体句柄
            //'         int场合：0-申请，1-报告
            //'         int病人来源：1-门诊，2-住院
            //'         lng病人ID：病人ID
            //'         lng就诊ID：主页ID/挂号ID
            //'         str项目IDs：诊疗项目IDs（例：111,222,333）
            //'         strReserve 扩展参数，格式特殊符号分割,保留关键字 <ITEM> <SP1> <SP2>
            //'               信息1<ITEM>信息2<ITEM>信息3....
            //'               当传入的是检查类诊疗项目时 信息1 被使用通过特殊符号 <SP1>，<SP2>分割
            //'               [检查项目ID]<SP2>[部位1]<SP2>[部位2]<SP2>[部位2]<SP1>[检查项目ID]<SP2>[部位1]<SP2>[部位2]<SP2>[部位2]......
            //'               例:231<SP2>头部<SP2>胸部<SP2>腹部<SP1>232<SP2>心脑<SP2>锁骨<SP2>颈椎
            //'               也可以不包含部位 231<SP1>232<SP1>233<SP2>颈椎
            //'         注意：应工作站调用时可能未指定病人,则入参[int病人来源、lng病人ID、lng就诊ID、str项目IDs、strReserve]传入值为空

            //    '出参:
            //    '返回:成功返回true,否则返回Fale
            return false;
        }

        public void SignEMRAfter(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long EMRFileID, params dynamic[] arrInput)
        {
            //        '功能：在签名窗口关闭且文档数据保存后调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号，lngModual固定传递1070
            //'      lngPatientID=病人ID,lngClinicID=就诊ID/主页ID
            //'      EMRFileID=电子病历记录.id  在新增编辑未保存前其值=0，保存后签名、修改时签名、审签有值；
            //'      arrInput是数组：扩展参数用于扩展使用，通过下标访一直接问时可能会报两种错，9－下标越界/13－类型不匹配：均表示参数没有传入
            //'           所以访问参数前应先判断：If TypeName(arrInput(i)) <> "Error" Then 满足这个条件后才使用这个参数，否则就认为这个参数没有传入
            //'           arrInput(0)－String：签名人的姓名
        }

        public bool SignEMRBefore(long lngSys, long lngModual, long lngPatientID, long lngClinicID, long EMRFileID, params dynamic[] arrInput)
        {
            //        '功能：电子病历签名前调用，事务未开启时
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号，lngModual固定传递1070
            //'      lngPatientID=病人ID,lngClinicID=就诊ID/主页ID
            //'      EMRFileID=电子病历记录.id
            //'      arrInput是数组：扩展参数用于扩展使用，通过下标访一直接问时可能会报两种错，9－下标越界/13－类型不匹配：均表示参数没有传入
            //'           所以访问参数前应先判断：If TypeName(arrInput(i)) <> "Error" Then 满足这个条件后才使用这个参数，否则就认为这个参数没有传入
            //'           arrInput 目前未传入任何参数
            //'返回：true时，允许继续签名，否则不弹出签名窗口，病历内部不做提示。
            return true;
        }

        public bool StuffReturnByID(long lng库房ID, string strIDs, DateTime dteSendTime, string strReserve = "")
        {
            //        '功能：卫材退料后调用
            //'参数：lng库房ID  库房ID；
            //'      strIDs 一次退料操作可能退多个卫材记录，格式；收发id,退料数量|收发id,退料数量...
            //'      dteSendTime 退料时间，一条收发id可能退多次，加上时间可以用于区别是哪次退料；
            //'      strReserve=扩展参数
            return true;
        }

        public bool StuffSendByRecipe(long lng库房ID, string strNos, DateTime dteSendTime, string strReserve = "")
        {
            //        '功能：卫材处方发料后调用，按处方发料
            //'参数：lng库房ID  库房ID；
            //'      strNOs 一次发料可能多个处方，处方类型和处方号，格式；单据,NO|单据,NO...
            //'      dteSendTime 发料时间，可能一个处方退料了之后再发，加上时间用于区别是哪次发料；
            //'      strReserve=扩展参数
            return true;
        }

        public bool StuffSendBySumID(long lng库房ID, string strSumNO, string strReserve = "")
        {
            //        '功能：卫材发料后调用，按收发id发料
            //'参数：lng库房ID  库房ID；
            //'      strSumNO 汇总发料号
            //'      strReserve=扩展参数


            //'    MsgBox "批量发料后调用PlugIn中StuffSendBySumID接口执行成功！发料信息如下..." & vbCrLf & _
            //'        "库房ID=" & lng库房ID & vbCrLf & _
            //'        "发料记录=" & strSumNO
            return true;
        }

        public void Terminate(long lngSys, long lngModual, int int场合 = -1)
        {

        }

        public bool TransfusionShowPatiList(long lngSys, long lngModual, long lng科室id, DateTime BeginTime, DateTime EndTime, string strReserve = "")
        {
            //        '功能：门诊输液系统病人列表刷新时调用
            //'参数：lngSys,lngModual=当前调用接口的主程序系统号及模块号 1264 门诊输液模块
            //'      lng科室id 科室，
            //'      BeginTime , EndTime 界面过滤时间范围，开始时间，结束时间
            //'      strReserve=扩展参数
            return true;
        }

        public bool zlGetSelfPaymentMode(long lngModule, long lng病人ID, string str主页Ids, long lng结帐ID, Recordset rsFeeLists, string strSelfPaymentMode_Out)
        {
            //    '功能:获取自费方式
            //'入参:lngModule-调用模块号
            //'       lng病人ID-病人ID
            //'       str主页Ids-当前主页IDs,多个用逗号分离
            //'       lng结帐ID-如果是医保病人，在医保结算后，调用本接口，传入当前的结帐ID,
            //'                       如果是普通病人，在读取费用明细后，调用本接口，结帐ID为0,但传入了rsFeeLists记录集
            //'       rsFeeLists-传入的本次结帐的费用明细数据（住院,单据号 ,项目,费目,ID,序号,记录性质,记录状态,执行状态,主页ID,计算单位,
            //'                       数量, 价格,应收金额,实收金额,未结金额,结帐金额, 统筹金额,类型, 收费类别,收费类别名,费别, 婴儿费, 执行部门id,
            //'                       科室,开单部门ID,开单人, 保险大类id,收费细目ID,门诊标志,排序, 医嘱序号,时间,登记时间）(即传入现结帐程序中的费用明细集）
            //'出参:strSelfPaymentMode_Out-返回结算方式,本接口返回true时有效,格式为:结算方式1,结算金额1,结算号码1||结算方式2,结算金额2,结算号码2||....
            //'返回:获取返回true,否则返回False
            //'编制:刘兴洪
            //'日期:2019-05-05 14:41:27
            //'调用时机:
            //'     1.普通病人:在读取病人费用明细后调用本接口
            //'     2.医保病人：进行医保结算后，调用本接口
            //'应用场景：慈善救助
            //'    1、慈善救助得患者需病区得护士进行身份的核对，患者在结帐的时候不会主动说自己是慈善救助的对象，所以让结账员手工录入的话，容易漏掉这部分。
            //'    2、慈善救助金额算法是：如果是医保病人，需要在医保结算完成之后才按照自费金额的xx%计算的，普通病人则直接是自费费用的xx%。
            return false;
        }

        public bool zlSendInfor(long lngSys, long lngModule, string strPatiXML, int int场合, string strFeedBack = "", string strErrMsg = "", string strReserve = "")
        {
            //        '功能：向短信平台发送消息
            //'返回：True是成功，False是失败
            //'入参：lngSys,lngModual：当前调用接口的主程序系统号及模块号
            //'      strPatiXML：包含病人信息的XML字符串
            //'      int场合：1-发卡时短信验证，2-账户余额变化提醒
            //'出参：strFeedBack：场合=1时返回验证码以及等待时间,格式:验证码|倒计时秒数
            //'      strErrMsg：错误信息
            //'      strReserve：扩展信息
            return true;
        }

        #endregion
    }
}