MedicalInsurance/BeiJingMI/Business/IrisServices.cs

/******************************************************************************
 * 文件名称: CardReader.cs
 * 文件说明: 读卡的封装，包括社保卡，身份证，电子凭证等等
 * 当前版本: V1.0
 * 创建日期: 2022-06-25
 *
 * * 2020-06-20: 增加 IrisServices 类(基类)
 * *****  2020-06-25: 增加 CardReader 方法，获取URL地址,USER信息，地方版SSCard.dll使用
 * *****  2020-06-25: 增加 CardReader 方法重载，国家版电子凭证使用
 * 
 * 
 * * 2020-06-20: 增加 HisIrisServices 类(子类)
 * *****  2020-06-25: 增加 CardReader 方法，获取URL地址,USER信息，地方版SSCard.dll使用
 * *****  2020-06-25: 增加 CardReader 方法重载，国家版电子凭证使用
 * 
 * 
 * * 2020-06-20: 增加 MIIrisServices 类(子类)
 * *****  2020-06-25: 增加 CardReader 方法，获取URL地址,USER信息，地方版SSCard.dll使用
 * *****  2020-06-25: 增加 CardReader 方法重载，国家版电子凭证使用



******************************************************************************/
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PTMedicalInsurance.Variables;
using PTMedicalInsurance.Helper;
using System.Windows.Forms;
using System.Xml;

namespace PTMedicalInsurance.Business
{
    
    class IrisServices
    {
    }

    class HisIrisServices
    {
        private InvokeHelper invoker = new InvokeHelper();
        AnalysisXML AnXML = new AnalysisXML();
        ReadCardClass rcl = new ReadCardClass();

        #region【医保字典与HIS字典对照】
        public int GetHISDir(out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                //joTmp.Add("admID", Global.pat.adm_Dr);
                //joTmp.Add("interfaceDr", Global.inf.interfaceDr);
                //joTmp.Add("billID", Global.pat.billID);
                string serviceCode = "06010114";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, "获取HIS字典数据信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "获取HIS字典数据异常" + ":" + ex.Message;
                return -1;
            }
        }

        public int GetMedInsuDir(string medInsutype, string searchstr, out string outParam)        
        {
            outParam = "";
            string errMsg;
            try
            {
                string sqlstr = " SELECT B.ID, B.Code,B.Descripts AS Name FROM HB_Dictionary A "
                              + " JOIN HB_DictionaryDataDetail B ON A.ID = B.HBDictionary_Dr"
                              + " WHERE A.InsuCode = '" + medInsutype + "'"
                              + " And  B.Descripts like '%" + searchstr + "%'"
                              + " and A.Interface_Dr = '" + Global.inf.interfaceDr.ToString() + "'";

                dynamic joInparm = new JObject();
                dynamic joTmp = new JObject();
                joTmp.sqlStr = sqlstr;
                JArray jaParams = new JArray();
                jaParams.Add(joTmp);
                joInparm.Add("params", JArray.FromObject(jaParams));
                joInparm.code = "09010014";
                string inParam = joInparm.ToString();
                JObject joRtn = invoker.invokeInsuService(inParam, "获取医保字典数据");

                outParam = joRtn.ToString();
                return 0;
            }
            catch (Exception ex)
            {
                outParam = "获取医保字典数据异常" + ":" + ex.Message;
                return -1;
            }
        }

        public int GetRelationShipDir(int type, string searchstr, string HisCode, out string outParam)        
        {
            outParam = "";
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("HisType", type.ToString());

                if ((searchstr == "") && (HisCode == ""))
                {

                }
                else
                {
                    joTmp.Add("SearchStr", searchstr);
                    joTmp.Add("HisCode", HisCode);
                }

                string serviceCode = "09010111";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "获取HIS医保字典对照信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "获取HIS医保字典对照信息异常" + ":" + ex.Message;
                return -1;
            }
        }

        #endregion

        /// <summary>
        /// 获取患者基本信息
        /// </summary>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int GetHisPatBaseInfo(out string errMsg)
        {
            errMsg = "";
            try
            {
                dynamic joTmp = new JObject();
                joTmp.admID = Global.pat.adm_Dr;
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110021", joTmp).ToString(), "获取HIS患者基本信息");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    errMsg = "获取HIS患者基本信息失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    errMsg = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                errMsg = "GetHisPatBaseInfo异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 获取HIS就诊信息
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public JObject GetHISRegInfo(JObject joParam)
        {
            //string errMsg;
            try
            {
                string serviceCode = "09030048";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joParam).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, "获取HIS就诊信息");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取HIS就诊信息异常：", ex.Message);
            }
        }

        /// <summary>
        /// 获取HIS处方明细信息
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public JObject GetHISPrescFeeInfo(JObject joParam)
        {
            //string errMsg;
            try
            {
                string serviceCode = "09030049";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joParam).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, "获取HIS处方信息");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取HIS处方信息异常：", ex.Message);
            }
        }        

        /// <summary>
        /// 获取HIS处方明细信息
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public JObject GetPreVerificationData(JObject joParam)
        {
            //string errMsg;
            try
            {
                string serviceCode = "05110035";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joParam).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, "获取外配处方上传信息数据");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取外配处方上传信息异常：", ex.Message);
            }
        }

        /// <summary>
        /// 获取诊断信息
        /// </summary>
        /// <param name="jaSession"></param>
        /// <param name="diagnoses"></param>
        /// <returns></returns>
        public int getPatDiagnoses(Patients pat, out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                JObject joTmp = new JObject();
                joTmp.Add("admID", pat.adm_Dr);
                joTmp.Add("psn_no", pat.psn_no);

                //JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110001", joTmp).ToString(), "获取诊断信息");
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110014", joTmp).ToString(), "获取诊断信息");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "获取诊断信息失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "getPatDiagnoses 异常：" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 返回登记信息给HIS
        /// </summary>
        /// <param name="joRegIn"></param>
        /// <param name="joRegOut"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnRegisterInfoNew(JObject joRegIn, string MdtrtID, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSendToIris2401 = joRegIn;
                joSendToIris2401.Add("admID", Global.pat.adm_Dr);
                joSendToIris2401.Add("mdtrt_id", MdtrtID);
                joSendToIris2401.Add("interfaceDr", Global.inf.interfaceDr);
                joSendToIris2401.Add("billID", Global.pat.billID);

                string serviceCode = "05110002", serviceName = "将登记信息返回给HIS";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joRegIn).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, serviceName);
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "中心登记成功但云HIS平台保存失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = "返回给HIS成功";
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "HIS保存登记信息出现异常：！" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 返回登记信息给HIS
        /// </summary>
        /// <param name="joRegIn"></param>
        /// <param name="joRegOut"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnRegisterInfo(JObject joRegIn, JObject joRegOut, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSendToIris2401 = joRegIn;
                joSendToIris2401.Add("admID", Global.pat.adm_Dr);
                joSendToIris2401.Add("mdtrt_id", JsonHelper.getDestValue(joRegOut, "output.result.mdtrt_id"));
                joSendToIris2401.Add("interfaceDr", Global.inf.interfaceDr);
                joSendToIris2401.Add("billID", Global.pat.billID);

                string serviceCode = "05110002", serviceName = "将登记信息返回给HIS";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joRegIn).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, serviceName);
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "中心登记成功但云HIS平台保存失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = "返回给HIS成功";
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "HIS保存登记信息出现异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 获取His费用
        /// </summary>
        /// <param name="pat"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int getHisFee(Patients pat, out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                dynamic joIrisParam = new JObject();
                JArray jaIrisParams = new JArray();
                JObject joIrisTmp = new JObject();
                joIrisParam.code = "05110003";
                joIrisParam.session = Global.curEvt.jaSession;
                joIrisTmp.Add("admID", pat.adm_Dr);
                joIrisTmp.Add("billID", pat.billID);
                joIrisTmp.Add("recordID", pat.recordID);
                jaIrisParams.Add(joIrisTmp);
                joIrisParam.Add("params", JArray.FromObject(jaIrisParams));

                JObject joRtn = invoker.invokeHISService(joIrisParam.ToString(), "获取HIS费用");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "deleteFee 异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 取消登记信息
        /// </summary>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int cancleRegister( out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                joTmp.Add("admID", Global.pat.adm_Dr);
                joTmp.Add("interfaceDr", Global.inf.interfaceDr);
                joTmp.Add("billID", Global.pat.billID);
                string serviceCode = "05110004";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeHISService(inpar, "取消HIS登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = joRtn.ToString();
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "取消登记异常" + ":" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// HIS预结算
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int preSettlementInfo(JObject joParam, JObject joSetlinfo, out string outParam)
        {
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                joTmp = joParam.DeepClone();
                joTmp.insuPayInfo = joSetlinfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.middleSettleFlag = "";

                JObject joSumFee = new JObject();
                if (sumInsuRtnSettlInfo(joSetlinfo, out joSumFee, out errMsg) != 0)
                {
                    outParam = "汇总结算结果失败，请联系管理员！" + errMsg;
                    return -1;
                }

                joTmp.sumFeeObj = joSumFee;
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110020", joTmp).ToString(), "返回2303结算结果给HIS");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回2303结算结果给HIS失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回2303结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }
        //public int preSettlementInfo(JObject joParam, JObject joSetlinfo, out string outParam)
        //{
        //    string errMsg;
        //    try
        //    {
        //        dynamic joTmp = new JObject();
        //        joTmp = joParam.DeepClone();
        //        joTmp.insuPayInfo = joSetlinfo;
        //        joTmp.updateUserID = Global.user.ID;
        //        joTmp.middleSettleFlag = "";
        //        JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110011", joTmp).ToString(), "返回2304结算结果给HIS");
        //        if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
        //        {
        //            outParam = "返回2303结算结果给HIS失败，请联系管理员！" + errMsg;
        //            return -1;
        //        }
        //        else
        //        {
        //            outParam = joRtn.ToString();
        //            return 0;
        //        }
        //    }
        //    catch (Exception ex)
        //    {
        //        outParam = "返回2303结算结果给HIS出现异常：！" + ex.Message;
        //        return -1;
        //    }

        //}

        /// <summary>
        /// 返回住院结算信息给HIS
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnInpatSettlementInfo(JObject joParam, JObject joSetlinfo, out string outParam)
        {
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                joTmp = joParam.DeepClone();
                joTmp.insuPayInfo = joSetlinfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.middleSettleFlag = "";

                JObject joSumFee = new JObject();
                if (sumInsuRtnSettlInfo(joSetlinfo, out joSumFee, out errMsg) != 0)
                {
                    outParam = "汇总结算结果失败，请联系管理员！" + errMsg;
                    return -1;
                }

                joTmp.sumFeeObj = joSumFee;
                //JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110007", joTmp).ToString(), "返回2304结算结果给HIS");
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110017", joTmp).ToString(), "返回2304结算结果给HIS");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回2304结算结果给HIS失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回2304结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 预结算后返回门诊结算信息给HIS，HIS进行预结算
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int preSettlementOP(JObject joAppRtnMsg, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSetlInfo = new JObject();
                JObject joRegInfo = new JObject();
                JObject joSumFee = new JObject();

                //本地门诊
                if (Global.pat.iOtherProvLocal == 0)
                {
                    if (sumInsuRtnSettlInfoOPNew(joAppRtnMsg, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                    {
                        outParam = "汇总【本地门诊】结算结果失败，请联系管理员！" + errMsg;
                        return -1;
                    }
                }
                else //异地门诊
                {
                    if (sumInsuRtnSettlInfoOPNewOther(joAppRtnMsg, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                    {
                        outParam = "汇总【异地门诊】结算结果失败，请联系管理员！" + errMsg;
                        return -1;
                    }
                }

                dynamic joTmp = new JObject();
                joTmp.settleInfo = joSetlInfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.regInfo = joRegInfo;
                joTmp.middleSettleFlag = "";
                joTmp.interfaceDr = Global.inf.interfaceDr;

                dynamic joHisInfo = new JObject();
                joHisInfo.admID = Global.pat.adm_Dr;
                joHisInfo.billID = Global.pat.billID;
                joHisInfo.recordID = Global.pat.recordID;

                joTmp.hisInfo = joHisInfo;
                joTmp.psn_type = Global.pat.psn_type;
                joTmp.sumFeeObj = joSumFee;

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110019", joTmp).ToString(), "返回门诊结算结果给HIS进行预结算");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回门诊结算结果给HIS进行预结算失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回门诊结算结果给HIS进行预结算异常！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 预结算后返回门诊结算信息给HIS，HIS进行预结算
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int preSettlementOPNew(XmlDocument xmlDoc, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSetlInfo = new JObject();
                JObject joRegInfo = new JObject();
                JObject joSumFee = new JObject();

                //本地门诊
                if (Global.pat.iOtherProvLocal == 0)
                {
                    if (sumInsuRtnSettlInfoOPNew(xmlDoc, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                    {
                        outParam = "汇总【本地门诊】结算结果失败，请联系管理员！" + errMsg;
                        return -1;
                    }
                }
                else //异地门诊
                {
                    if (sumInsuRtnSettlInfoOPNewOther(xmlDoc, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                    {
                        outParam = "汇总【异地门诊】结算结果失败，请联系管理员！" + errMsg;
                        return -1;
                    }
                }

                dynamic joTmp = new JObject();
                joTmp.settleInfo = joSetlInfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.regInfo = joRegInfo;
                joTmp.middleSettleFlag = "";
                joTmp.interfaceDr = Global.inf.interfaceDr;

                dynamic joHisInfo = new JObject();
                joHisInfo.admID = Global.pat.adm_Dr;
                joHisInfo.billID = Global.pat.billID;
                joHisInfo.recordID = Global.pat.recordID;

                joTmp.hisInfo = joHisInfo;
                joTmp.psn_type = Global.pat.psn_type;
                joTmp.sumFeeObj = joSumFee;                

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110019", joTmp).ToString(), "返回门诊结算结果给HIS进行预结算");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回门诊结算结果给HIS进行预结算失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回门诊结算结果给HIS进行预结算异常！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 预结算后返回门诊结算信息给HIS，HIS进行预结算
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int preSettlement(JObject joSetlInpar, JObject joSetlinfo, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSumFee = new JObject();
                if (sumInsuRtnSettlInfo(joSetlinfo, out joSumFee, out errMsg) != 0)
                {
                    outParam = "汇总结算结果失败，请联系管理员！" + errMsg;
                    return -1;
                }

                dynamic joTmp = new JObject();
                joTmp.settleInfo = joSetlinfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.regInfo = joSetlInpar;
                joTmp.middleSettleFlag = "";
                joTmp.interfaceDr = Global.inf.interfaceDr;
                dynamic joHisInfo = new JObject();
                joHisInfo.admID = Global.pat.adm_Dr;
                joHisInfo.billID = Global.pat.billID;
                joHisInfo.recordID = Global.pat.recordID;
                joTmp.hisInfo = joHisInfo;
                joTmp.psn_type = Global.pat.psn_type;

                joTmp.sumFeeObj = joSumFee;

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110019", joTmp).ToString(), "返回2206结算结果给HIS进行预结算");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回2206结算结果给HIS进行预结算失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回2206结算结果给HIS进行预结算异常！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 返回门诊结算信息给HIS
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnOutpatSettlementInfoOP(string AppRtnMsg, int iOtherProvLocal, out string outParam)
        {
            string errMsg;
            JObject joSetlInfo = new JObject();
            JObject joRegInfo = new JObject();
            JObject joSumFee = new JObject();

            try
            {
                if (GetSettlementRtnValue(AppRtnMsg, iOtherProvLocal, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }

                if (sumInsuRtnSettlInfoOP(iOtherProvLocal, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                {
                    outParam = "返回门诊结算结果给HIS失败，请联系管理员！";
                    return -1;
                }

                //XmlDocument xmlDoc = AnXML.GetXmlDoc(AppRtnMsg);
                //if (sumInsuRtnSettlInfoOPNew(xmlDoc, out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                //{
                //    outParam = "返回门诊结算结果给HIS失败，请联系管理员！";
                //    return -1;
                //}

                dynamic joTmp = new JObject();
                joTmp.settleInfo = joSetlInfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.regInfo = joRegInfo;
                joTmp.middleSettleFlag = "";
                joTmp.interfaceDr = Global.inf.interfaceDr;
                dynamic joHisInfo = new JObject();
                joHisInfo.admID = Global.pat.adm_Dr;
                joHisInfo.billID = Global.pat.billID;
                joHisInfo.recordID = Global.pat.recordID;
                joTmp.hisInfo = joHisInfo;
                joTmp.psn_type = Global.pat.psn_type;

                joTmp.sumFeeObj = joSumFee;

                //0511018 {"feeObj":{"ybAmt":"医保支付","psnAcctAmt":"个人账户","psnCashAmt":"个人现金","hospAmt":"医院垫付"}}

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110018", joTmp).ToString(), "返回门诊医保结算结果给HIS");
                //JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110009", joTmp).ToString(), "返回2207结算结果给HIS");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回门诊结算结果给HIS失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回门诊结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 返回住院结算信息给HIS
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnOutpatSettlementInfoNewIP(JObject joParam,out string outParam)
        {
            string errMsg;
            JObject joSetlInfo = new JObject();
            JObject joRegInfo = new JObject();
            JObject joSumFee = new JObject();

            try
            {
                if (sumInsuRtnSettlInfoNew_ZY(out joSetlInfo, out joRegInfo, out joSumFee, out errMsg) != 0)
                {
                    outParam = "返回住院结算结果给HIS失败，请联系管理员！";
                    return -1;
                }

                dynamic joTmp = new JObject();
                joTmp = joParam.DeepClone();
                joTmp.insuPayInfo = joSetlInfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.middleSettleFlag = "";
                //dynamic joHisInfo = new JObject();
                //joHisInfo.admID = Global.pat.adm_Dr;
                //joHisInfo.billID = Global.pat.billID;
                //joHisInfo.recordID = Global.pat.recordID;
                //joTmp.hisInfo = joHisInfo;  
                joTmp.sumFeeObj = joSumFee;

                //0511018 {"feeObj":{"ybAmt":"医保支付","psnAcctAmt":"个人账户","psnCashAmt":"个人现金","hospAmt":"医院垫付"}}

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110017", joTmp).ToString(), "返回住院医保结算结果给HIS");
                //JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110009", joTmp).ToString(), "返回2207结算结果给HIS");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回住院结算结果给HIS失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回住院结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 返回门诊结算信息给HIS
        /// </summary>
        /// <param name="joSetlInpar"></param>
        /// <param name="joSetlinfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int returnOutpatSettlementInfo(JObject joSetlInpar, JObject joSetlinfo, out string outParam)
        {
            string errMsg;
            try
            {
                JObject joSumFee = new JObject();
                if (sumInsuRtnSettlInfo(joSetlinfo, out joSumFee, out errMsg) != 0) 
                {
                    outParam = "返回2207结算结果给HIS失败，请联系管理员！";
                    return -1;
                }

                dynamic joTmp = new JObject();
                joTmp.settleInfo = joSetlinfo;
                joTmp.updateUserID = Global.user.ID;
                joTmp.regInfo = joSetlInpar;
                joTmp.middleSettleFlag = "";
                joTmp.interfaceDr = Global.inf.interfaceDr;
                dynamic joHisInfo = new JObject();
                joHisInfo.admID = Global.pat.adm_Dr;
                joHisInfo.billID = Global.pat.billID;
                joHisInfo.recordID = Global.pat.recordID;
                joTmp.hisInfo = joHisInfo;
                joTmp.psn_type = Global.pat.psn_type;

                joTmp.sumFeeObj = joSumFee;

                //0511018 {"feeObj":{"ybAmt":"医保支付","psnAcctAmt":"个人账户","psnCashAmt":"个人现金","hospAmt":"医院垫付"}}

                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110018", joTmp).ToString(), "返回2207结算结果给HIS");
                //JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110009", joTmp).ToString(), "返回2207结算结果给HIS");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "返回2207结算结果给HIS失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回22207结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 获取结算费用的封装
        /// </summary>
        /// <param name="jo"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        private decimal getFee(JObject jo, string path)
        {
            try
            {
                string temp = JsonHelper.getDestValue(jo, path);
                if (temp == "")
                {
                    return 0;
                }
                else
                {
                    return decimal.Parse(temp);
                }
            }
            catch (Exception ex)
            {
                Global.writeLog("getFee异常：" + ex.Message);
                return 0;
            }
        }

        /// <summary>
        /// 汇总门诊结算医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="joRtn"></param>
        /// <param name="joSetlInfo"></param>
        /// <param name="joRegInfo"></param>
        /// <param name="joSumFee"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoOPNew(JObject joRtn, out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            //解析费用分解（门诊预结算）返回值
            //交易信息（tradeinfo）
            string tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
            string feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
            string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
            tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);
            Global.pat.tradeNo = tradeno;

            //汇总支付信息（sumpay）
            string feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
            string fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
            string cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
            string personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付            
            //支付信息（payinfo）
            string mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
            string mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
            string mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
            string mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
            string mzselfpay2 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzselfpay2");//个人自付2
            string mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
            string mzbigselfpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigselfpay"); //门诊大额自付金额
            string mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzoutofbig"); //超大额自付金额
            string bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
            string jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
            string big_ill_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.big_ill_pay"); //大病支付金额
            string civil_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.civil_pay"); //民政救助支付金额
            string ExServicePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.ExServicePay"); //退役军转干部退役医疗费支付
            string txbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.txbz"); //退休补助金额
            string offi_true = JsonHelper.getDestValue(joRtn, "root.output.payinfo.offi_true");  //单位补充医疗保险（原公疗）支付金额
            string year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzfeein");  //年度门诊医保内费用累计
            string year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzbigpay");  //年度门诊大额支付累计
            string year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzoutofbig");  //门诊大额封顶后医保内金额累计
            string first_year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzfeein");  //一级医院年度门诊医保内费用累计
            string first_year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzbigpay");  //一级医院年度门诊大额支付累计
            string first_year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzoutofbig");  //一级医院门诊大额封顶后医保内金额累计
            string selfpay1 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.selfpay1"); //自付一
            string bigillcomm = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bigillcomm"); //年度大病内累计金额            

            string fQTJJZF = "0";
            //decimal fQTJJZF = decimal.Parse(bcpay)
            //                + decimal.Parse(jcbz)
            //                + decimal.Parse(txbz)
            //                + decimal.Parse(offi_true)
            //                + decimal.Parse(big_ill_pay)
            //                + decimal.Parse(civil_pay)
            //                + decimal.Parse(ExServicePay);

            Global.pat.acctPayAmt = personcountpay;

            ////明细信息（feeitem）
            //XmlNode FeeTtemArrayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/feeitemarray"); 
            //string recipeno = FeeTtemArrayNode.SelectNodes("feeitem")[0].Attributes["recipeno"].InnerText; //处方序号

            //MessageBox.Show("解析XML结果：\r\n交易流水号：" + tradeno + "\r\n收费单据号：" + feeno + "\r\n处方号：" + recipeno);

            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();
            joSetl.Add("setl_id", tradeno);      //结算ID
            joSetl.Add("setl_time", tradedate);      //结算时间
            joSetl.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
            joSetl.Add("hifdm_pay", jcbz);      //伤残人员医疗保障基金支出
            joSetl.Add("cvlserv_flag", "");      //公务员标志
            joSetl.Add("med_type", Global.pat.medType);      //医疗类别
            joSetl.Add("exp_content", "");      //字段扩展
            joSetl.Add("brdy", Global.pat.brdy);      //出生日期
            joSetl.Add("naty", Global.pat.naty);      //民族
            joSetl.Add("psn_cash_pay", cash);      //个人现金支出
            joSetl.Add("certno", Global.pat.certNO);      //证件号码
            joSetl.Add("hifmi_pay", big_ill_pay);      //居民大病保险资金支出
            joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
            joSetl.Add("act_pay_dedc", mzpayfirst);      //实际支付起付线
            joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
            joSetl.Add("balc", Global.pat.balc);      //余额
            joSetl.Add("medins_setl_id", feeno);      //医药机构结算ID
            joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
            joSetl.Add("acct_mulaid_pay", "");      //个人账户共济支付金额
            joSetl.Add("clr_way", "");      //清算方式
            joSetl.Add("hifob_pay", mzbigpay);      //职工大额医疗费用补助基金支出
            joSetl.Add("oth_pay", fQTJJZF);      //其他支出
            joSetl.Add("medfee_sumamt", feeall);      //医疗费总额
            joSetl.Add("hifes_pay", offi_true);      //企业补充医疗保险基金支出
            joSetl.Add("gend", Global.pat.gend);      //性别
            joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
            joSetl.Add("acct_pay", personcountpay);      //个人账户支出
            joSetl.Add("fund_pay_sumamt", fund);      //基金支付总额
            joSetl.Add("fulamt_ownpay_amt", mzfeeout);      //全自费金额
            joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
            joSetl.Add("inscp_scp_amt", mzfeein);      //符合政策范围金额
            joSetl.Add("insutype", Global.pat.insuType);      //险种类型
            joSetl.Add("maf_pay", civil_pay);      //医疗救助基金支出
            joSetl.Add("psn_name", Global.pat.name);      //人员姓名
            joSetl.Add("psn_part_amt", decimal.Parse(cash) + decimal.Parse(personcountpay));      //个人负担总金额
            joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
            joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
            joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
            joSetl.Add("hifp_pay", fund);      //基本医疗保险统筹基金支出
            joSetl.Add("overlmt_selfpay", mzoutofbig);      //超限价金额
            joSetl.Add("preselfpay_amt", "");      //先行自付金额
            joSetl.Add("age", Global.pat.age);      //年龄
            joSetl.Add("clr_type", "");      //清算类别

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", mzfee);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", feeno);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展

            joRegInfo = new JObject();
            joRegInfo.Add("regInfo", joReg);

            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {
                ybAmt = decimal.Parse(fund);
                psnAcctAmt = decimal.Parse(personcountpay);     //账户支付金额
                psnCashAmt = decimal.Parse(cash); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(feeall);    //总费用

                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }
        }

        /// <summary>
        /// 汇总异地门诊结算医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="joRtn"></param>
        /// <param name="joSetlInfo"></param>
        /// <param name="joRegInfo"></param>
        /// <param name="joSumFee"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoOPNewOther(JObject joRtn, out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            //解析费用分解（门诊预结算）返回值
            //交易信息（tradeinfo）
            string tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
            string feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
            string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
            tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);
            Global.pat.tradeNo = tradeno;

            //汇总支付信息（sumpay）
            string feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
            string fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
            string cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
            string personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付
            string selFeeAll = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selFeeAll"); //全自付金额
            string selfPayFirst = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selfPayFirst"); //先行自付金额
            Global.pat.acctPayAmt = personcountpay;
            //支付信息（payinfo）
            string CLAB_PRESELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.CLAB_PRESELFPAY_FEE"); //乙类先行自付费用
            string OVERLMT_SELFPAY = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OVERLMT_SELFPAY"); //超限价自付费用
            string PSN_OWNPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_OWNPAY_FEE"); //个人自费费用
            string PSN_SELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_SELFPAY_FEE"); //个人自付费用
            string mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
            string mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
            string mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
            string mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
            string BasePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.BasePay"); //基本医疗保险统筹基金支付金额
            string GwybzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.GwybzPay"); //公务员医疗补助基金
            string bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
            string mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
            string jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
            string MzbzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.MzbzPay"); //门诊补助支付金额
            string OtherPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OtherPay"); //其他基金支付
            string Cash = JsonHelper.getDestValue(joRtn, "root.output.payinfo.Cash");//个人现金支付金额
            string PersonCountBalance = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PersonCountBalance");//个人账户支付金额
            string SelfPayFlag = JsonHelper.getDestValue(joRtn, "root.output.payinfo.SelfPayFlag");//全额垫付标志

            decimal fQTJJZF = decimal.Parse(OtherPay);

            //if (Global.pat.psn_no == "21000021090021090160007295")
            //{
            //    fQTJJZF = 0;
            //    OtherPay = "0";
            //}

            ////明细信息（feeitem）
            //XmlNode FeeTtemArrayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/feeitemarray"); 
            //string recipeno = FeeTtemArrayNode.SelectNodes("feeitem")[0].Attributes["recipeno"].InnerText; //处方序号
            //MessageBox.Show("解析XML结果：\r\n交易流水号：" + tradeno + "\r\n收费单据号：" + feeno + "\r\n处方号：" + recipeno);

            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();
            joSetl.Add("setl_id", tradeno);      //结算ID
            joSetl.Add("setl_time", tradedate);      //结算时间
            joSetl.Add("cvlserv_pay", GwybzPay);      //公务员医疗补助资金支出
            joSetl.Add("hifdm_pay", jcbz);      //伤残人员医疗保障基金支出
            joSetl.Add("cvlserv_flag", SelfPayFlag);      //公务员标志
            joSetl.Add("med_type", Global.pat.medType);      //医疗类别
            joSetl.Add("exp_content", "");      //字段扩展
            joSetl.Add("brdy", Global.pat.brdy);      //出生日期
            joSetl.Add("naty", Global.pat.naty);      //民族
            joSetl.Add("psn_cash_pay", cash);      //个人现金支出
            joSetl.Add("certno", Global.pat.certNO);      //证件号码
            joSetl.Add("hifmi_pay", mzbigpay);      //居民大病保险资金支出
            joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
            joSetl.Add("act_pay_dedc", mzpayfirst);      //实际支付起付线
            joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
            joSetl.Add("balc", Global.pat.balc);      //余额
            joSetl.Add("medins_setl_id", feeno);      //医药机构结算ID
            joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
            joSetl.Add("acct_mulaid_pay", 0);      //个人账户共济支付金额
            joSetl.Add("clr_way", "");      //清算方式
            joSetl.Add("hifob_pay", mzbigpay);      //职工大额医疗费用补助基金支出
            joSetl.Add("oth_pay", fQTJJZF);      //其他支出
            joSetl.Add("medfee_sumamt", feeall);      //医疗费总额
            joSetl.Add("hifes_pay", bcpay);      //企业补充医疗保险基金支出
            joSetl.Add("gend", Global.pat.gend);      //性别
            joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
            joSetl.Add("acct_pay", personcountpay);      //个人账户支出
            joSetl.Add("fund_pay_sumamt", fund);      //基金支付总额
            joSetl.Add("fulamt_ownpay_amt", mzfeeout);      //全自费金额
            joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
            joSetl.Add("inscp_scp_amt", mzfeein);      //符合政策范围金额
            joSetl.Add("insutype", Global.pat.insuType);      //险种类型
            joSetl.Add("maf_pay", MzbzPay);      //医疗救助基金支出
            joSetl.Add("psn_name", Global.pat.name);      //人员姓名
            joSetl.Add("psn_part_amt", decimal.Parse(cash) + decimal.Parse(personcountpay));      //个人负担总金额
            joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
            joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
            joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
            joSetl.Add("hifp_pay", fund);      //基本医疗保险统筹基金支出
            joSetl.Add("overlmt_selfpay", OVERLMT_SELFPAY);      //超限价金额
            joSetl.Add("preselfpay_amt", selfPayFirst);      //先行自付金额
            joSetl.Add("age", Global.pat.age);      //年龄
            joSetl.Add("clr_type", "");      //清算类别

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", mzfee);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", feeno);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展

            joRegInfo = new JObject();
            joRegInfo.Add("regInfo", joReg);

            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {
                //ybAmt = decimal.Parse(fund) + decimal.Parse(OtherPay);

                ybAmt = decimal.Parse(fund); //北京返回基金支付=所有基金支付汇总 
                psnAcctAmt = decimal.Parse(personcountpay);     //账户支付金额
                psnCashAmt = decimal.Parse(cash); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(feeall);    //总费用

                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                //if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                //{
                //    errMsg = "ybAmt + OtherPay + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                //    return -1;
                //}

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }
        }

        /// <summary>
        /// 汇总门诊结算医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="jo"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoOPNew(XmlDocument xmlDoc, out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            //解析费用分解（门诊预结算）返回值
            //交易信息（tradeinfo）
            XmlNode TradeInfoNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/tradeinfo");
            string tradeno = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "tradeno", 0); //交易流水号
            string feeno = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "feeno", 0); //收费单据号            
            string tradedate = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "tradedate", 0); //交易时间 格式为:YYYYMMDDHHMMSS
            Global.pat.tradeNo = tradeno;

            tradedate = tradedate.Trim().Substring(0, 4)
                + "-" + tradedate.Trim().Substring(4, 2)
                + "-" + tradedate.Trim().Substring(6, 2)
                + " " + tradedate.Trim().Substring(8, 2)
                + ":" + tradedate.Trim().Substring(10, 2)
                + ":" + tradedate.Trim().Substring(12, 2);

            //汇总支付信息（sumpay）
            XmlNode SumPayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/sumpay");
            string feeall = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "feeall", 1); //费用总金额
            string fund = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "fund", 1); //基金支付
            string cash = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "cash", 1); //现金支付
            string personcountpay = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "personcountpay", 1); //个人帐户支付
            Global.pat.acctPayAmt = personcountpay;

            //支付信息（payinfo）
            XmlNode PayInfoNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/payinfo");
            string mzfee = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfee", 1); //费用总金额
            string mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfeein", 1); //医保内总金额
            string mzfeeout = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfeeout", 1); //医保外总金额
            string mzpayfirst = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzpayfirst", 1); //本次付起付线金额
            string mzselfpay2 = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzselfpay2", 1);//个人自付2
            string mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzbigpay", 1); //门诊大额支付金额
            string mzbigselfpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzbigselfpay", 1); //门诊大额自付金额
            string mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzoutofbig", 1); //超大额自付金额
            string bcpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "bcpay", 1); //补充保险支付
            string jcbz = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "jcbz", 1); //军残补助保险支付

            string big_ill_pay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "big_ill_pay", 1); //大病支付金额
            string civil_pay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "civil_pay", 1); //民政救助支付金额
            string ExServicePay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "ExServicePay", 1); //退役军转干部退役医疗费支付

            string txbz = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "txbz", 1); //退休补助金额
            string offi_true = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "offi_true", 1);  //单位补充医疗保险（原公疗）支付金额
            string year_mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzfeein", 1);  //年度门诊医保内费用累计
            string year_mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzbigpay", 1);  //年度门诊大额支付累计
            string year_mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzoutofbig", 1);  //门诊大额封顶后医保内金额累计
            string first_year_mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzfeein", 1);  //一级医院年度门诊医保内费用累计
            string first_year_mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzbigpay", 1);  //一级医院年度门诊大额支付累计
            string first_year_mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzoutofbig", 1);  //一级医院门诊大额封顶后医保内金额累计
            string selfpay1 = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "selfpay1", 1); //自付一
            string bigillcomm = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "bigillcomm", 1); //年度大病内累计金额

            decimal fQTJJZF = decimal.Parse(bcpay)
                            + decimal.Parse(jcbz)
                            + decimal.Parse(txbz)
                            + decimal.Parse(offi_true)
                            + decimal.Parse(big_ill_pay)
                            + decimal.Parse(civil_pay)
                            + decimal.Parse(ExServicePay);

            ////明细信息（feeitem）
            //XmlNode FeeTtemArrayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/feeitemarray"); 
            //string recipeno = FeeTtemArrayNode.SelectNodes("feeitem")[0].Attributes["recipeno"].InnerText; //处方序号

            //MessageBox.Show("解析XML结果：\r\n交易流水号：" + tradeno + "\r\n收费单据号：" + feeno + "\r\n处方号：" + recipeno);

            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();
            joSetl.Add("setl_id", tradeno);      //结算ID
            joSetl.Add("setl_time", tradedate);      //结算时间
            joSetl.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
            joSetl.Add("hifdm_pay", jcbz);      //伤残人员医疗保障基金支出
            joSetl.Add("cvlserv_flag", "");      //公务员标志
            joSetl.Add("med_type", Global.pat.medType);      //医疗类别
            joSetl.Add("exp_content", "");      //字段扩展
            joSetl.Add("brdy", Global.pat.brdy);      //出生日期
            joSetl.Add("naty", Global.pat.naty);      //民族
            joSetl.Add("psn_cash_pay", cash);      //个人现金支出
            joSetl.Add("certno", Global.pat.certNO);      //证件号码
            joSetl.Add("hifmi_pay", big_ill_pay);      //居民大病保险资金支出
            joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
            joSetl.Add("act_pay_dedc", mzpayfirst);      //实际支付起付线
            joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
            joSetl.Add("balc", Global.pat.balc);      //余额
            joSetl.Add("medins_setl_id", feeno);      //医药机构结算ID
            joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
            joSetl.Add("acct_mulaid_pay", "");      //个人账户共济支付金额
            joSetl.Add("clr_way", "");      //清算方式
            joSetl.Add("hifob_pay", mzbigpay);      //职工大额医疗费用补助基金支出
            joSetl.Add("oth_pay", fQTJJZF);      //其他支出
            joSetl.Add("medfee_sumamt", feeall);      //医疗费总额
            joSetl.Add("hifes_pay", offi_true);      //企业补充医疗保险基金支出
            joSetl.Add("gend", Global.pat.gend);      //性别
            joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
            joSetl.Add("acct_pay", personcountpay);      //个人账户支出
            joSetl.Add("fund_pay_sumamt", fund);      //基金支付总额
            joSetl.Add("fulamt_ownpay_amt", mzfeeout);      //全自费金额
            joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
            joSetl.Add("inscp_scp_amt", mzfeein);      //符合政策范围金额
            joSetl.Add("insutype", Global.pat.insuType);      //险种类型
            joSetl.Add("maf_pay", civil_pay);      //医疗救助基金支出
            joSetl.Add("psn_name", Global.pat.name);      //人员姓名
            joSetl.Add("psn_part_amt", decimal.Parse(cash) + decimal.Parse(personcountpay));      //个人负担总金额
            joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
            joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
            joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
            joSetl.Add("hifp_pay", fund);      //基本医疗保险统筹基金支出
            joSetl.Add("overlmt_selfpay", mzoutofbig);      //超限价金额
            joSetl.Add("preselfpay_amt", "");      //先行自付金额
            joSetl.Add("age", Global.pat.age);      //年龄
            joSetl.Add("clr_type", "");      //清算类别

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", mzfee);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", feeno);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展

            //joRegInfo = new JObject();
            //joRegInfo.Add("regInfo", joReg);
            joRegInfo = joReg;
            
            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {                
                ybAmt = decimal.Parse(fund);
                psnAcctAmt = decimal.Parse(personcountpay);     //账户支付金额
                psnCashAmt = decimal.Parse(cash); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(feeall);    //总费用
                
                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }

        }

        /// <summary>
        /// 汇总异地门诊结算医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="jo"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoOPNewOther(XmlDocument xmlDoc, out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            //解析费用分解（门诊预结算）返回值
            //交易信息（tradeinfo）
            XmlNode TradeInfoNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/tradeinfo");
            string tradeno = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "tradeno", 0); //交易流水号
            string feeno = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "feeno", 0); //收费单据号            
            string tradedate = AnXML.FormatXMLElement(xmlDoc, TradeInfoNode, "tradedate", 0); //交易时间 格式为:YYYYMMDDHHMMSS
            Global.pat.tradeNo = tradeno;

            tradedate = tradedate.Trim().Substring(0, 4)
                + "-" + tradedate.Trim().Substring(4, 2)
                + "-" + tradedate.Trim().Substring(6, 2)
                + " " + tradedate.Trim().Substring(8, 2)
                + ":" + tradedate.Trim().Substring(10, 2)
                + ":" + tradedate.Trim().Substring(12, 2);

            //汇总支付信息（sumpay）
            XmlNode SumPayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/sumpay");
            string feeall = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "feeall", 1); //费用总金额
            string fund = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "fund", 1); //基金支付
            string cash = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "cash", 1); //现金支付
            string personcountpay = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "personcountpay", 1); //个人帐户支付

            string selFeeAll = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "selFeeAll", 1); //全自付金额
            string selfPayFirst = AnXML.FormatXMLElement(xmlDoc, SumPayNode, "selfPayFirst", 1); //先行自付金额

            Global.pat.acctPayAmt = personcountpay;

            //支付信息（payinfo）
            XmlNode PayInfoNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/payinfo");
            string CLAB_PRESELFPAY_FEE = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "CLAB_PRESELFPAY_FEE", 1); //乙类先行自付费用
            string OVERLMT_SELFPAY = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "OVERLMT_SELFPAY", 1); //超限价自付费用
            string PSN_OWNPAY_FEE = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "PSN_OWNPAY_FEE", 1); //个人自费费用
            string PSN_SELFPAY_FEE = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "PSN_SELFPAY_FEE", 1); //个人自付费用
            string mzpayfirst = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzpayfirst", 1); //本次付起付线金额
            string mzfee = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfee", 1); //费用总金额
            string mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfeein", 1); //医保内总金额
            string mzfeeout = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzfeeout", 1); //医保外总金额
            string BasePay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "BasePay", 1); //基本医疗保险统筹基金支付金额
            string GwybzPay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "GwybzPay", 1); //公务员医疗补助基金
            string bcpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "bcpay", 1); //补充保险支付
            string mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzbigpay", 1); //门诊大额支付金额
            string jcbz = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "jcbz", 1); //军残补助保险支付
            string MzbzPay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "MzbzPay", 1); //门诊补助支付金额
            string OtherPay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "OtherPay", 1); //其他基金支付
            string Cash = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "Cash", 1);//个人现金支付金额
            string PersonCountBalance = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "PersonCountBalance", 1);//个人账户支付金额
            string SelfPayFlag = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "SelfPayFlag", 1);//全额垫付标志

            //string mzselfpay2 = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzselfpay2", 1);//个人自付2   
            //string mzbigselfpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzbigselfpay", 1); //门诊大额自付金额
            //string mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "mzoutofbig", 1); //超大额自付金额
            //string big_ill_pay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "big_ill_pay", 1); //大病支付金额
            //string civil_pay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "civil_pay", 1); //民政救助支付金额
            //string ExServicePay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "ExServicePay", 1); //退役军转干部退役医疗费支付
            //string txbz = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "txbz", 1); //退休补助金额
            //string offi_true = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "offi_true", 1);  //单位补充医疗保险（原公疗）支付金额
            //string year_mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzfeein", 1);  //年度门诊医保内费用累计
            //string year_mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzbigpay", 1);  //年度门诊大额支付累计
            //string year_mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "year_mzoutofbig", 1);  //门诊大额封顶后医保内金额累计
            //string first_year_mzfeein = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzfeein", 1);  //一级医院年度门诊医保内费用累计
            //string first_year_mzbigpay = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzbigpay", 1);  //一级医院年度门诊大额支付累计
            //string first_year_mzoutofbig = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "first_year_mzoutofbig", 1);  //一级医院门诊大额封顶后医保内金额累计
            //string selfpay1 = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "selfpay1", 1); //自付一
            //string bigillcomm = AnXML.FormatXMLElement(xmlDoc, PayInfoNode, "bigillcomm", 1); //年度大病内累计金额

            //decimal fQTJJZF = decimal.Parse(bcpay)
            //                + decimal.Parse(jcbz)
            //                + decimal.Parse(GwybzPay)
            //                + decimal.Parse(bcpay)
            //                + decimal.Parse(MzbzPay)
            //                + decimal.Parse(OtherPay)
            //                + decimal.Parse(ExServicePay);

            decimal fQTJJZF = decimal.Parse(OtherPay);

            ////明细信息（feeitem）
            //XmlNode FeeTtemArrayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/feeitemarray"); 
            //string recipeno = FeeTtemArrayNode.SelectNodes("feeitem")[0].Attributes["recipeno"].InnerText; //处方序号
            //MessageBox.Show("解析XML结果：\r\n交易流水号：" + tradeno + "\r\n收费单据号：" + feeno + "\r\n处方号：" + recipeno);

            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();
            joSetl.Add("setl_id", tradeno);      //结算ID
            joSetl.Add("setl_time", tradedate);      //结算时间
            joSetl.Add("cvlserv_pay", GwybzPay);      //公务员医疗补助资金支出
            joSetl.Add("hifdm_pay", jcbz);      //伤残人员医疗保障基金支出
            joSetl.Add("cvlserv_flag", SelfPayFlag);      //公务员标志
            joSetl.Add("med_type", Global.pat.medType);      //医疗类别
            joSetl.Add("exp_content", "");      //字段扩展
            joSetl.Add("brdy", Global.pat.brdy);      //出生日期
            joSetl.Add("naty", Global.pat.naty);      //民族
            joSetl.Add("psn_cash_pay", cash);      //个人现金支出
            joSetl.Add("certno", Global.pat.certNO);      //证件号码
            joSetl.Add("hifmi_pay", mzbigpay);      //居民大病保险资金支出
            joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
            joSetl.Add("act_pay_dedc", mzpayfirst);      //实际支付起付线
            joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
            joSetl.Add("balc", Global.pat.balc);      //余额
            joSetl.Add("medins_setl_id", feeno);      //医药机构结算ID
            joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
            joSetl.Add("acct_mulaid_pay", 0);      //个人账户共济支付金额
            joSetl.Add("clr_way", "");      //清算方式
            joSetl.Add("hifob_pay", mzbigpay);      //职工大额医疗费用补助基金支出
            joSetl.Add("oth_pay", fQTJJZF);      //其他支出
            joSetl.Add("medfee_sumamt", feeall);      //医疗费总额
            joSetl.Add("hifes_pay", bcpay);      //企业补充医疗保险基金支出
            joSetl.Add("gend", Global.pat.gend);      //性别
            joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
            joSetl.Add("acct_pay", personcountpay);      //个人账户支出
            joSetl.Add("fund_pay_sumamt", fund);      //基金支付总额
            joSetl.Add("fulamt_ownpay_amt", mzfeeout);      //全自费金额
            joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
            joSetl.Add("inscp_scp_amt", mzfeein);      //符合政策范围金额
            joSetl.Add("insutype", Global.pat.insuType);      //险种类型
            joSetl.Add("maf_pay", MzbzPay);      //医疗救助基金支出
            joSetl.Add("psn_name", Global.pat.name);      //人员姓名
            joSetl.Add("psn_part_amt", decimal.Parse(cash) + decimal.Parse(personcountpay));      //个人负担总金额
            joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
            joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
            joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
            joSetl.Add("hifp_pay", fund);      //基本医疗保险统筹基金支出
            joSetl.Add("overlmt_selfpay", OVERLMT_SELFPAY);      //超限价金额
            joSetl.Add("preselfpay_amt", selfPayFirst);      //先行自付金额
            joSetl.Add("age", Global.pat.age);      //年龄
            joSetl.Add("clr_type", "");      //清算类别

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", mzfee);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", feeno);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展

            joRegInfo = new JObject();
            joRegInfo.Add("regInfo", joReg);

            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {
                ybAmt = decimal.Parse(fund) + decimal.Parse(OtherPay);
                psnAcctAmt = decimal.Parse(personcountpay);     //账户支付金额
                psnCashAmt = decimal.Parse(cash); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(feeall);    //总费用

                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + OtherPay + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }

        }

        /// <summary>
        /// 汇总门诊结算医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="jo"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoOP(int iOtherProvLocal, out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            string fQTJJZF = "0";
            //decimal fQTJJZF = decimal.Parse(Global.Set.bcpay)
            //                + decimal.Parse(Global.Set.jcbz)
            //                + decimal.Parse(Global.Set.txbz)
            //                + decimal.Parse(Global.Set.offi_true)
            //                + decimal.Parse(Global.Set.big_ill_pay)
            //                + decimal.Parse(Global.Set.civil_pay)
            //                + decimal.Parse(Global.Set.ExServicePay);

            ////明细信息（feeitem）
            //XmlNode FeeTtemArrayNode = AnXML.GetNodeFromPath(xmlDoc.DocumentElement, "output/feeitemarray"); 
            //string recipeno = FeeTtemArrayNode.SelectNodes("feeitem")[0].Attributes["recipeno"].InnerText; //处方序号

            //MessageBox.Show("解析XML结果：\r\n交易流水号：" + tradeno + "\r\n收费单据号：" + feeno + "\r\n处方号：" + recipeno);

            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();

            if (iOtherProvLocal == 0)
            {
                joSetl.Add("setl_id", Global.Set.tradeno);      //结算ID
                joSetl.Add("setl_time", Global.Set.tradedate);      //结算时间
                joSetl.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
                joSetl.Add("hifdm_pay", Global.Set.jcbz);      //伤残人员医疗保障基金支出
                joSetl.Add("cvlserv_flag", "");      //公务员标志
                joSetl.Add("med_type", Global.pat.medType);      //医疗类别
                joSetl.Add("exp_content", "");      //字段扩展
                joSetl.Add("brdy", Global.pat.brdy);      //出生日期
                joSetl.Add("naty", Global.pat.naty);      //民族
                joSetl.Add("psn_cash_pay", Global.Set.cash);      //个人现金支出
                joSetl.Add("certno", Global.pat.certNO);      //证件号码
                joSetl.Add("hifmi_pay", Global.Set.big_ill_pay);      //居民大病保险资金支出
                joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
                joSetl.Add("act_pay_dedc", Global.Set.mzpayfirst);      //实际支付起付线
                joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
                joSetl.Add("balc", Global.pat.balc);      //余额
                joSetl.Add("medins_setl_id", Global.Set.feeno);      //医药机构结算ID
                joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
                joSetl.Add("acct_mulaid_pay", "");      //个人账户共济支付金额
                joSetl.Add("clr_way", iOtherProvLocal);      //清算方式
                joSetl.Add("hifob_pay", Global.Set.mzbigpay);      //职工大额医疗费用补助基金支出
                joSetl.Add("oth_pay", fQTJJZF);      //其他支出
                joSetl.Add("medfee_sumamt", Global.Set.feeall);      //医疗费总额
                joSetl.Add("hifes_pay", Global.Set.offi_true);      //企业补充医疗保险基金支出
                joSetl.Add("gend", Global.pat.gend);      //性别
                joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
                joSetl.Add("acct_pay", Global.Set.personcountpay);      //个人账户支出
                joSetl.Add("fund_pay_sumamt", Global.Set.fund);      //基金支付总额
                joSetl.Add("fulamt_ownpay_amt", Global.Set.mzfeeout);      //全自费金额
                joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
                joSetl.Add("inscp_scp_amt", Global.Set.mzfeein);      //符合政策范围金额
                joSetl.Add("insutype", Global.pat.insuType);      //险种类型
                joSetl.Add("maf_pay", Global.Set.civil_pay);      //医疗救助基金支出
                joSetl.Add("psn_name", Global.pat.name);      //人员姓名
                joSetl.Add("psn_part_amt", decimal.Parse(Global.Set.cash) + decimal.Parse(Global.Set.personcountpay));      //个人负担总金额
                joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
                joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
                joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
                joSetl.Add("hifp_pay", Global.Set.fund);      //基本医疗保险统筹基金支出
                joSetl.Add("overlmt_selfpay", Global.Set.mzoutofbig);      //超限价金额
                joSetl.Add("preselfpay_amt", "");      //先行自付金额
                joSetl.Add("age", Global.pat.age);      //年龄
                joSetl.Add("clr_type", "");      //清算类别
            }
            else
            {
                joSetl.Add("setl_id", Global.Set.tradeno);      //结算ID
                joSetl.Add("setl_time", Global.Set.tradedate);      //结算时间
                joSetl.Add("cvlserv_pay", Global.Set.GwybzPay);      //公务员医疗补助资金支出
                joSetl.Add("hifdm_pay", Global.Set.jcbz);      //伤残人员医疗保障基金支出
                joSetl.Add("cvlserv_flag", Global.Set.SelfPayFlag);      //公务员标志
                joSetl.Add("med_type", Global.pat.medType);      //医疗类别
                joSetl.Add("exp_content", "");      //字段扩展
                joSetl.Add("brdy", Global.pat.brdy);      //出生日期
                joSetl.Add("naty", Global.pat.naty);      //民族
                joSetl.Add("psn_cash_pay", Global.Set.cash);      //个人现金支出
                joSetl.Add("certno", Global.pat.certNO);      //证件号码
                joSetl.Add("hifmi_pay", Global.Set.mzbigpay);      //居民大病保险资金支出
                joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
                joSetl.Add("act_pay_dedc", Global.Set.mzpayfirst);      //实际支付起付线
                joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
                joSetl.Add("balc", Global.pat.balc);      //余额
                joSetl.Add("medins_setl_id", Global.Set.feeno);      //医药机构结算ID
                joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
                joSetl.Add("acct_mulaid_pay", 0);      //个人账户共济支付金额
                joSetl.Add("clr_way", iOtherProvLocal);      //清算方式
                joSetl.Add("hifob_pay", Global.Set.mzbigpay);      //职工大额医疗费用补助基金支出
                joSetl.Add("oth_pay", fQTJJZF);      //其他支出
                joSetl.Add("medfee_sumamt", Global.Set.feeall);      //医疗费总额
                joSetl.Add("hifes_pay", Global.Set.bcpay);      //企业补充医疗保险基金支出
                joSetl.Add("gend", Global.pat.gend);      //性别
                joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
                joSetl.Add("acct_pay", Global.Set.personcountpay);      //个人账户支出
                joSetl.Add("fund_pay_sumamt", Global.Set.fund);      //基金支付总额
                joSetl.Add("fulamt_ownpay_amt", Global.Set.mzfeeout);      //全自费金额
                joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
                joSetl.Add("inscp_scp_amt", Global.Set.mzfeein);      //符合政策范围金额
                joSetl.Add("insutype", Global.pat.insuType);      //险种类型
                joSetl.Add("maf_pay", Global.Set.MzbzPay);      //医疗救助基金支出
                joSetl.Add("psn_name", Global.pat.name);      //人员姓名
                joSetl.Add("psn_part_amt", decimal.Parse(Global.Set.cash) + decimal.Parse(Global.Set.personcountpay));      //个人负担总金额
                joSetl.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
                joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
                joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
                joSetl.Add("hifp_pay", Global.Set.fund);      //基本医疗保险统筹基金支出
                joSetl.Add("overlmt_selfpay", Global.Set.OVERLMT_SELFPAY);      //超限价金额
                joSetl.Add("preselfpay_amt", Global.Set.selfPayFirst);      //先行自付金额
                joSetl.Add("age", Global.pat.age);      //年龄
                joSetl.Add("clr_type", "");      //清算类别
            }

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", Global.Set.mzfee);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", Global.Set.feeno);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展
            joReg.Add("insuplc_admdvs", Global.pat.insuplc_admdvs);
            joReg.Add("mdtrtarea_admvs", Global.pat.mdtrtarea_admvs);
            joRegInfo = joReg;

            //joRegInfo = new JObject();
            //joRegInfo.Add("regInfo", joReg);

            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {
                ybAmt = decimal.Parse(Global.Set.fund);
                psnAcctAmt = decimal.Parse(Global.Set.personcountpay);     //账户支付金额
                psnCashAmt = decimal.Parse(Global.Set.cash); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(Global.Set.feeall);    //总费用

                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }
        }

        /// <summary>
        /// 汇总住院结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="jo"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfoNew_ZY(out JObject joSetlInfo, out JObject joRegInfo, out JObject joSumFee, out string errMsg)
        {           
            //按照基线版医保接口结算返回值格式和字段重新组织首信医保接口结算返回值
            JObject joSetl = new JObject();
            joSetl.Add("setl_id", Global.Set.settlID);      //结算ID
            joSetl.Add("setl_time", Global.Set.hisDischargeTime);      //结算时间
            joSetl.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
            joSetl.Add("hifdm_pay", 0);      //伤残人员医疗保障基金支出
            joSetl.Add("cvlserv_flag", "");      //公务员标志
            joSetl.Add("med_type", Global.pat.medType);      //医疗类别
            joSetl.Add("exp_content", "");      //字段扩展
            joSetl.Add("brdy", Global.pat.brdy);      //出生日期
            joSetl.Add("naty", Global.pat.naty);      //民族
            joSetl.Add("psn_cash_pay", Global.pat.cashpayAmt);      //个人现金支出
            joSetl.Add("certno", Global.pat.certNO);      //证件号码
            joSetl.Add("hifmi_pay", 0);      //居民大病保险资金支出
            joSetl.Add("psn_no", Global.pat.psn_no);      //人员编号
            joSetl.Add("act_pay_dedc", 0);      //实际支付起付线
            joSetl.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
            joSetl.Add("balc", Global.pat.balc);      //余额
            joSetl.Add("medins_setl_id", Global.pat.billID);      //医药机构结算ID
            joSetl.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
            joSetl.Add("acct_mulaid_pay", "");      //个人账户共济支付金额
            joSetl.Add("clr_way", "");      //清算方式
            joSetl.Add("hifob_pay", 0);      //职工大额医疗费用补助基金支出
            joSetl.Add("oth_pay", 0);      //其他支出
            joSetl.Add("medfee_sumamt", Global.pat.hisSumAmt);      //医疗费总额
            joSetl.Add("hifes_pay", 0);      //企业补充医疗保险基金支出
            joSetl.Add("gend", Global.pat.gend);      //性别
            joSetl.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
            joSetl.Add("acct_pay", Global.pat.acctPayAmt);      //个人账户支出
            joSetl.Add("fund_pay_sumamt", Global.pat.insuAmt);      //基金支付总额
            joSetl.Add("fulamt_ownpay_amt", 0);      //全自费金额
            joSetl.Add("hosp_part_amt", 0);      //医院负担金额          
            joSetl.Add("inscp_scp_amt", 0);      //符合政策范围金额
            joSetl.Add("insutype", Global.pat.insuType);      //险种类型
            joSetl.Add("maf_pay", 0);      //医疗救助基金支出
            joSetl.Add("psn_name", Global.pat.name);      //人员姓名
            joSetl.Add("psn_part_amt", decimal.Parse(Global.pat.cashpayAmt) + decimal.Parse(Global.pat.acctPayAmt));      //个人负担总金额
            joSetl.Add("clr_optins", "");      //清算经办机构
            joSetl.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
            joSetl.Add("psn_type", Global.pat.psn_type);      //人员类别
            joSetl.Add("hifp_pay", Global.pat.insuAmt);      //基本医疗保险统筹基金支出
            joSetl.Add("overlmt_selfpay", 0);      //超限价金额
            joSetl.Add("preselfpay_amt", "");      //先行自付金额
            joSetl.Add("age", Global.pat.age);      //年龄
            joSetl.Add("clr_type", "");      //清算类别

            //joSetlInfo = new JObject();
            //joSetlInfo.Add("settleInfo", joSetl);

            joSetlInfo = joSetl;

            //结算入参信息
            JObject joReg = new JObject();
            joReg.Add("psn_no", Global.pat.psn_no); //人员编号
            joReg.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);  //就诊凭证类型
            joReg.Add("mdtrt_cert_no", Global.pat.mdtrtcertNO);  //就诊凭证编号
            joReg.Add("med_type", Global.pat.medType);  //医疗类别
            joReg.Add("medfee_sumamt", Global.pat.hisSumAmt);  //医疗费总额
            joReg.Add("psn_setlway", "");  //个人结算方式
            joReg.Add("mdtrt_id", Global.pat.mdtrtID);  //就诊ID
            joReg.Add("chrg_bchno", Global.pat.billID);  //收费批次号
            joReg.Add("acct_used_flag", Global.pat.personAccountUsedFlag);  //个人账户使用标志
            joReg.Add("insutype", Global.pat.insuType);  //险种类型
            joReg.Add("pub_hosp_rfom_flag", "");  //公立医院改革标志
            joReg.Add("exp_content", ""); //字段扩展

            //joRegInfo = new JObject();
            //joRegInfo.Add("regInfo", joReg);

            joRegInfo = joReg;

            joSumFee = new JObject();
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            errMsg = "";
            try
            {
                ybAmt = decimal.Parse(Global.pat.insuAmt);
                psnAcctAmt = decimal.Parse(Global.pat.acctPayAmt);     //账户支付金额
                psnCashAmt = decimal.Parse(Global.pat.cashpayAmt); //现金支付金额
                hospAmt = 0;   //医院承担金额
                medFee = decimal.Parse(Global.pat.hisSumAmt);    //总费用

                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }

        }

        /// <summary>
        /// 汇总医保返回的结算金额（按照HIS的原则汇总，后期HIS按照这个来进行勾稽关系判断）
        /// </summary>
        /// <param name="jo"></param>
        /// <returns></returns>
        public int sumInsuRtnSettlInfo(JObject jo, out JObject joSumFee, out string errMsg)
        {
            // 医疗费总额是患者在医药机构花费的所有诊疗、药品、耗材、服务设施等项目费用的总和 = 基金支付总额 + 个人负担总金额 + 其他（如医院负担金额）；
            //3、基金支付总额 = 基本医保统筹基金支出（含职工基本医疗保险、居民基本医疗保险）+补充医疗保险基金支出 （含覆盖全体参保人的居民大病保险和大额医疗费用补助、覆盖部分参保人的企业职工大额医疗费用补助和公务员医疗补助等）+医疗救助基金支出 + 其他支出（如伤残人员医疗保障基金支出）；
            //5、个人账户支出中包含账户共济支付金额

            joSumFee = new JObject();

            errMsg = "";
            decimal ybAmt, psnAcctAmt, hospAmt, psnCashAmt, medFee;
            try
            {
                ybAmt = getFee(jo, "hifp_pay") //基本医保统筹基金支出
                      + getFee(jo, "hifes_pay") //企业补充医疗保险基金支出
                      + getFee(jo, "hifmi_pay") //居民大病保险
                                                //+ getFee(jo, "hifob_pay") //大额医疗费用补助
                      + getFee(jo, "hifob_pay") //职工大额医疗费用补助
                      + getFee(jo, "cvlserv_pay") //公务员医疗补助
                      + getFee(jo, "maf_pay") //医疗救助基金支出
                      + getFee(jo, "oth_pay"); //其他支出
                psnAcctAmt = getFee(jo, "acct_pay");     //账户支付金额
                psnCashAmt = getFee(jo, "psn_cash_pay"); //现金支付金额
                hospAmt = getFee(jo, "hosp_part_amt");   //医院承担金额
                medFee = getFee(jo, "medfee_sumamt");    //总费用
                joSumFee.Add("ybAmt", ybAmt);
                joSumFee.Add("psnAcctAmt", psnAcctAmt);
                joSumFee.Add("hospAmt", hospAmt);
                joSumFee.Add("psnCashAmt", psnCashAmt);

                if (medFee != (ybAmt + psnAcctAmt + psnCashAmt + hospAmt))
                {
                    errMsg = "ybAmt + psnAcctAmt + psnCashAmt + hospAmt != medFee";
                    return -1;
                }
                return 0;
            }
            catch (Exception ex)
            {
                errMsg = ex.Message;
                return 1;
            }

        }

        /// <summary>
        /// 取消结算信息
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int cancleSettlementInfo(JObject joParam,  out string outParam)
        {
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                joTmp = joParam.DeepClone();

                //joTmp.add("admID", Global.pat.adm_Dr.ToString());

                //joTmp.admID = Global.pat.adm_Dr.ToString();
                //joTmp.recordID = Global.pat.recordID.ToString();
                //joTmp.billID = Global.pat.billID.ToString();
                //joTmp.userID = Global.user.ID.ToString();
                //joTmp.locID = "";
                //joTmp.hospID = Global.inf.hisHospitalDr;
                //joTmp.groupID = "";                   
                //joTmp.ip = Global.curEvt.ip;
                //joTmp.psn_no = "";
                //joTmp.mdtrt_id = Global.pat.mdtrtID.ToString();
                //joTmp.insuplc_admdvs = "";
                //joTmp.setl_id = Global.pat.settlID.ToString();

                joTmp.updateUserID = Global.user.ID;
                joTmp.middleSettleFlag = "";
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110008", joTmp).ToString(), "取消HIS医保结算信息");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "取消HIS医保结算信息失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = "取消HIS医保结算信息成功";
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回2304结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 取消结算信息
        /// </summary>
        /// <param name="joParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int cancleSettlementInfoHAHA(JObject joParam, out string outParam)
        {
            string errMsg;
            try
            {
                dynamic joTmp = new JObject();
                //joTmp = joParam.DeepClone();

                //joTmp["params"]["admID"] = Global.pat.adm_Dr;

                joTmp.admID = "1413689";
                joTmp.recordID = "1702089";
                joTmp.billID = Global.pat.billID;
                joTmp.userID = "3";
                joTmp.locID = "1628";
                joTmp.hospID = "45";
                joTmp.groupID = "357";
                joTmp.ip = "10.65.37.156";
                joTmp.psn_no = "";
                joTmp.mdtrt_id = "HIS05155009240116103620";
                joTmp.insuplc_admdvs = "";
                joTmp.setl_id = "999007730A240116000002";

                joTmp.updateUserID = Global.user.ID;
                joTmp.middleSettleFlag = "";
                JObject joRtn = invoker.invokeHISService(JsonHelper.setIrisInpar("05110008", joTmp).ToString(), "取消HIS医保结算信息HAHA");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "取消HIS医保结算信息失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = "取消HIS医保结算信息成功";
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "返回2304结算结果给HIS出现异常：！" + ex.Message;
                return -1;
            }

        }

        public int getHISDir(JArray jaPagination, JArray jaParams, out JObject joRtn, out string outParam)
        {
            string errMsg;
            joRtn = new JObject();
            try
            {
                dynamic joTmp = new JObject();
                joTmp.pagination = jaPagination;
                joTmp.session = Global.curEvt.jaSession;
                joTmp.Add("params",jaParams);
                joTmp.code = "05111002";
                joRtn = invoker.invokeHISService(joTmp.ToString(), "查询HIS目录分页");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "查询HIS目录分页失败，请联系管理员！" + errMsg;
                    return -1;
                }
                else
                {
                    if (joRtn["result"]["Data"] == null)
                    {
                        outParam = "Data节点不存在";
                        return -1;
                    }
                    outParam = "查询HIS目录分页成功";
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "查询HIS目录分页异常：！" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 从HIS获取医保事前事中服务交易入参报文
        /// </summary>
        /// <param name="pat"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int GetInsuPatInfo(string TrigScen, Patients pat, out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                dynamic joIrisParam = new JObject();
                JArray jaIrisParams = new JArray();
                JObject joIrisTmp = new JObject();
                joIrisParam.code = "05110015";
                joIrisParam.session = Global.curEvt.jaSession;
                joIrisTmp.Add("admID", pat.adm_Dr);
                joIrisTmp.Add("billID", pat.billID);
                joIrisTmp.Add("recordID", pat.recordID);
                joIrisTmp.Add("userID",Global.user.ID);
                joIrisTmp.Add("hospID", Global.inf.hisHospitalDr);
                joIrisTmp.Add("psnNo", Global.pat.psn_no);
                joIrisTmp.Add("mdtrtId", Global.pat.mdtrtID);
                joIrisTmp.Add("InsuredType", Global.pat.insuType);
                joIrisTmp.Add("MedicalType", Global.pat.medType);
                joIrisTmp.Add("YBArea", Global.pat.insuplc_admdvs);
                joIrisTmp.Add("TrigScen", TrigScen);

                joIrisTmp.Add("InterfaceID", Global.inf.interfaceDr);

                jaIrisParams.Add(joIrisTmp);
                joIrisParam.Add("params", JArray.FromObject(jaIrisParams));

                JObject joRtn = invoker.invokeHISService(joIrisParam.ToString(), "获取HIS费用");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "GetInsuPatInfo医保事前事中服务报文获取 异常：" + ex.Message;
                return -1;
            }
        }

        public int GetSettlementRtnValue(string sRtn, int iOtherProvLocal, out string outParam)
        {
            try
            {
                outParam = "";
                JObject joRtn = AnXML.ConvertXMLToObject(sRtn);

                if (iOtherProvLocal == 0)
                {
                    //交易信息（tradeinfo）
                    Global.Set.tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
                    Global.Set.feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
                    string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
                    Global.Set.tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);

                    //汇总支付信息（sumpay）
                    Global.Set.feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
                    Global.Set.fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
                    Global.Set.cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
                    Global.Set.personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付            
                                                                                                                     //支付信息（payinfo）
                    Global.Set.mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
                    Global.Set.mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
                    Global.Set.mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
                    Global.Set.mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
                    Global.Set.mzselfpay2 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzselfpay2");//个人自付2
                    Global.Set.mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
                    Global.Set.mzbigselfpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigselfpay"); //门诊大额自付金额
                    Global.Set.mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzoutofbig"); //超大额自付金额
                    Global.Set.bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
                    Global.Set.jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
                    Global.Set.big_ill_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.big_ill_pay"); //大病支付金额
                    Global.Set.civil_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.civil_pay"); //民政救助支付金额
                    Global.Set.ExServicePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.ExServicePay"); //退役军转干部退役医疗费支付
                    Global.Set.txbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.txbz"); //退休补助金额
                    Global.Set.offi_true = JsonHelper.getDestValue(joRtn, "root.output.payinfo.offi_true");  //单位补充医疗保险（原公疗）支付金额
                    Global.Set.year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzfeein");  //年度门诊医保内费用累计
                    Global.Set.year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzbigpay");  //年度门诊大额支付累计
                    Global.Set.year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzoutofbig");  //门诊大额封顶后医保内金额累计
                    Global.Set.first_year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzfeein");  //一级医院年度门诊医保内费用累计
                    Global.Set.first_year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzbigpay");  //一级医院年度门诊大额支付累计
                    Global.Set.first_year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzoutofbig");  //一级医院门诊大额封顶后医保内金额累计
                    Global.Set.selfpay1 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.selfpay1"); //自付一
                    Global.Set.bigillcomm = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bigillcomm"); //年度大病内累计金额   
                }
                else
                {
                    //交易信息（tradeinfo）
                    Global.Set.tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
                    Global.Set.feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
                    string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
                    Global.Set.tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);
                    //汇总支付信息（sumpay）
                    Global.Set.feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
                    Global.Set.fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
                    Global.Set.cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
                    Global.Set.personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付
                    Global.Set.selFeeAll = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selFeeAll"); //全自付金额
                    Global.Set.selfPayFirst = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selfPayFirst"); //先行自付金额
                    Global.pat.acctPayAmt = Global.Set.personcountpay;
                    //支付信息（payinfo）
                    Global.Set.CLAB_PRESELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.CLAB_PRESELFPAY_FEE"); //乙类先行自付费用
                    Global.Set.OVERLMT_SELFPAY = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OVERLMT_SELFPAY"); //超限价自付费用
                    Global.Set.PSN_OWNPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_OWNPAY_FEE"); //个人自费费用
                    Global.Set.PSN_SELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_SELFPAY_FEE"); //个人自付费用
                    Global.Set.mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
                    Global.Set.mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
                    Global.Set.mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
                    Global.Set.mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
                    Global.Set.BasePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.BasePay"); //基本医疗保险统筹基金支付金额
                    Global.Set.GwybzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.GwybzPay"); //公务员医疗补助基金
                    Global.Set.bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
                    Global.Set.mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
                    Global.Set.jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
                    Global.Set.MzbzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.MzbzPay"); //门诊补助支付金额
                    Global.Set.OtherPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OtherPay"); //其他基金支付
                    Global.Set.Cash = JsonHelper.getDestValue(joRtn, "root.output.payinfo.Cash");//个人现金支付金额
                    Global.Set.PersonCountBalance = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PersonCountBalance");//个人账户支付金额
                    Global.Set.SelfPayFlag = JsonHelper.getDestValue(joRtn, "root.output.payinfo.SelfPayFlag");//全额垫付标志
                }

                return 0;
            }
            catch (Exception ex)
            {
                outParam = "解析结算信息异常：" + ex.Message;
                return -1;
            }
        }
    }

    class MIIrisServices
    {
        private InvokeHelper invoker = new InvokeHelper();
        AnalysisXML AnXML = new AnalysisXML();

        /// <summary>
        /// 获取接口信息
        /// </summary>
        /// <returns></returns>
        public JObject getInterface()
        {
            dynamic joParam = new JObject();
            joParam.HospitalDr = Global.inf.hospitalDr;
            joParam.InterfaceID = "";
            JObject joInparam = JsonHelper.setIrisInpar("09010003", joParam);
            InvokeHelper invoker = new InvokeHelper();
            return invoker.invokeInsuService(joInparam.ToString(), "获取接口信息");
        }

        public JObject getInterface(string interfaceID)
        {
            dynamic joParam = new JObject();
            joParam.HospitalDr = Global.inf.hospitalDr;
            joParam.InterfaceID = interfaceID;
            JObject joInparam = JsonHelper.setIrisInpar("09010003", joParam);
            InvokeHelper invoke = new InvokeHelper();
            JObject joRtn = invoke.invokeInsuService(joInparam.ToString(), "获取接口信息");
            JObject joInterfaceInfo = JObject.Parse(JsonHelper.getDestValue(joRtn, "result.data[0]"));
            joInterfaceInfo.Add("operatorNO", "0");
            joInterfaceInfo.Add("operatorName", "管理员");

            return joInterfaceInfo;
        }

        public JObject getInterface_TY(string interfaceID, string hospitalDr)        
        {
            dynamic joParam = new JObject();
            joParam.HospitalDr = hospitalDr;
            joParam.InterfaceID = interfaceID;
            JObject joInparam = JsonHelper.setIrisInpar("09010003", joParam);
            InvokeHelper invoke = new InvokeHelper();
            JObject joRtn = invoke.invokeInsuService(joInparam.ToString(), "获取接口信息");
            JObject joInterfaceInfo = JObject.Parse(JsonHelper.getDestValue(joRtn, "result.data[0]"));
            joInterfaceInfo.Add("operatorNO", "0");
            joInterfaceInfo.Add("operatorName", "管理员");


            return joInterfaceInfo;
        }

        /// <summary>
        /// 判断是否签到过，如果未签到，返回false,如果签到则返回ture，同时返回签到号
        /// </summary>
        /// <param name="signno"></param>
        /// <returns></returns>
        public bool isSigned(ref string signno)
        {
            JObject joIn = new JObject();
            joIn.Add("operatorNO", Global.user.ID.ToUpper());
            joIn.Add("operatorName", Global.user.name);
            joIn.Add("mac", Global.curEvt.mac);
            joIn.Add("ip", Global.curEvt.ip);
            joIn.Add("hospitalDr", Global.inf.hospitalDr);
            joIn.Add("interfaceDr", Global.inf.interfaceDr);
            joIn.Add("date", DateTime.Now.ToString("yyyy-MM-dd"));

            string data = JsonHelper.setIrisInpar("09010064", joIn).ToString();
            JObject joRtn = invoker.invokeInsuService(data, "查询签到信息");
            string errMsg = "";

            //MessageBox.Show("查询签到信息："+joRtn.ToString());

            if (JsonHelper.parseIrisRtnValue(joRtn,out errMsg)!= 0)
            {
                signno = "";
                return false;
            }
            else
            {                
                signno = JsonHelper.getDestValue(joRtn, "result.SignNo");                
                return true;
            }
        }

        /// <summary>
        ///保存签到信息
        /// </summary>
        /// <param name="signno"></param>
        /// <returns></returns>
        public int saveSignRecord( string signno,out string errMsg)
        {
            if (signno == "")
            {
                errMsg = "signno不能为空！";
                return -1;
            }
            errMsg = ""; ;
            JObject joIn = new JObject();
            joIn.Add("operatorNO", Global.user.ID);
            joIn.Add("operatorName", Global.user.name);
            joIn.Add("mac", Global.curEvt.mac);
            joIn.Add("ip", Global.curEvt.ip);
            joIn.Add("hospitalDr", Global.inf.hospitalDr);
            joIn.Add("interfaceDr", Global.inf.interfaceDr);
            joIn.Add("date", DateTime.Now.ToString("yyyy-MM-dd"));
            joIn.Add("signNo", signno);
            joIn.Add("createTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
            joIn.Add("division", Global.inf.areaCode);

            string data = JsonHelper.setIrisInpar("09010065", joIn).ToString();

            //MessageBox.Show("插入签到信息入参："+ data);

            JObject joRtn = invoker.invokeInsuService(data, "插入签到信息");

            if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
            {
                return -1;
            }
            else
            {
                return 0;
            }
        }
        /// <summary>
        /// 保存住院登记信息
        /// </summary>
        /// <param name="joRegIn"></param>
        /// <param name="joRegOut"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveInpatRegisterInfo(JObject joRegIn,JObject joRegOut,out string outParam)
        {
            //插入云医保平台
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                Global.pat.mdtrtcertType = JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_type");

                if (Global.pat.mdtrtcertType == "01")
                {
                    Global.pat.mdtrtcertType = "02";
                    Global.pat.mdtrtcertNO = Global.pat.certNO;
                }
                else
                {
                    Global.pat.mdtrtcertType = JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_type");
                    Global.pat.mdtrtcertNO = JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_no");
                }

                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("InsuRegID", JsonHelper.getDestValue(joRegOut, "output.result.mdtrt_id"));
                joTmp.Add("RegDate", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.begntime"));
                joTmp.Add("InsuType", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.insutype"));
                joTmp.Add("CertificateType", Global.pat.mdtrtcertType);  //JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_type")
                joTmp.Add("CertificateNO", Global.pat.mdtrtcertNO); //JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_no")
                joTmp.Add("MedicalType", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.med_type"));
                joTmp.Add("AttendDoctorNO", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.atddr_no"));
                joTmp.Add("ChiefPhyDocName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.chfpdr_name"));
                joTmp.Add("AdmInDiagDesc", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_diag_dscr"));
                joTmp.Add("AdmInDepCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_dept_codg"));
                joTmp.Add("AdmInDepName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_dept_name"));
                joTmp.Add("AdmBed", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_bed"));
                joTmp.Add("MainDiagCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dscg_maindiag_code"));
                joTmp.Add("MainDiagName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dscg_maindiag_name"));
                joTmp.Add("MainConditionDesc", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.main_cond_dscr"));
                joTmp.Add("DiseasecCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_codg"));
                joTmp.Add("DiseasecName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_name"));
                joTmp.Add("OperationCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.oprn_oprt_code"));
                joTmp.Add("OperationName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.oprn_oprt_name"));
                joTmp.Add("DiseasecTypeCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_type_code"));
                joTmp.Add("InsuranceAreaCode", Global.pat.insuplc_admdvs);
                joTmp.Add("TreatmentAreaCode", Global.pat.mdtrtarea_admvs);
                joTmp.Add("RegState", JsonHelper.getDestValue(joRegOut, "regstate"));
                joTmp.Add("ValidFlag", JsonHelper.getDestValue(joRegOut, "validflag"));
                joTmp.Add("Type", JsonHelper.getDestValue(joRegOut, "type"));
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("MSGID", Global.curEvt.msgid);
                joTmp.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joTmp.Add("ConerName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.coner_name"));
                joTmp.Add("Tel", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.tel"));

                string serviceCode = "09010044";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "新增住院登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = joRtn.ToString();
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "保存住院登记信息异常：" + ex.Message;
                return -1;
            }
            
        }

        /// <summary>
        /// 保存住院登记信息-北京首信医保
        /// </summary>
        /// <param name="joRegIn"></param>
        /// <param name="joRegOut"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveInpatRegisterInfoNew(JObject joRegIn,string MdtrtID, out string outParam)
        {
            //插入云医保平台
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                Global.pat.mdtrtcertType = JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_type");
                Global.pat.mdtrtcertNO = JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_no");

                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("InsuRegID", MdtrtID);
                joTmp.Add("RegDate", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.begntime"));
                joTmp.Add("InsuType", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.insutype"));
                joTmp.Add("CertificateType", Global.pat.mdtrtcertType);  //JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_type")
                joTmp.Add("CertificateNO", Global.pat.mdtrtcertNO); //JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.mdtrt_cert_no")
                joTmp.Add("MedicalType", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.med_type"));
                joTmp.Add("AttendDoctorNO", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.atddr_no"));
                joTmp.Add("ChiefPhyDocName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.chfpdr_name"));
                joTmp.Add("AdmInDiagDesc", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_diag_dscr"));
                joTmp.Add("AdmInDepCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_dept_codg"));
                joTmp.Add("AdmInDepName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_dept_name"));
                joTmp.Add("AdmBed", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.adm_bed"));
                joTmp.Add("MainDiagCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dscg_maindiag_code"));
                joTmp.Add("MainDiagName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dscg_maindiag_name"));
                joTmp.Add("MainConditionDesc", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.main_cond_dscr"));
                joTmp.Add("DiseasecCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_codg"));
                joTmp.Add("DiseasecName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_name"));
                joTmp.Add("OperationCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.oprn_oprt_code"));
                joTmp.Add("OperationName", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.oprn_oprt_name"));
                joTmp.Add("DiseasecTypeCode", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.dise_type_code"));
                joTmp.Add("InsuranceAreaCode", Global.pat.insuplc_admdvs);
                joTmp.Add("TreatmentAreaCode", Global.pat.mdtrtarea_admvs);
                joTmp.Add("RegState", "1");
                joTmp.Add("ValidFlag", "1");
                joTmp.Add("Type", "1");
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("MSGID", Global.curEvt.msgid);
                joTmp.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joTmp.Add("ConerName", JsonHelper.getDestValue(joRegIn, "mdtrtinfo.coner_name"));
                joTmp.Add("Tel", JsonHelper.getDestValue(joRegIn, "input.mdtrtinfo.tel"));

                string serviceCode = "09010044";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "新增住院登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = joRtn.ToString();
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "保存住院登记信息异常：" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 保存门诊登记信息
        /// </summary>
        /// <param name="jo2201Inpar"></param>
        /// <param name="jo2201Rtn"></param>
        /// <param name="jo2203Inpar"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveOutpatRegisterInfo(JObject jo2201Inpar, JObject jo2203Inpar, out string outParam)
        {
            //插入云医保平台
            JObject joTmp = new JObject();
            string errMsg = "";
            int admType = 3; //门诊结算

            if (Global.inf.operationType == "RegisterOP")
                admType = 7; //挂号

            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("InsuRegID", Global.pat.mdtrtID);
                joTmp.Add("RegDate", JsonHelper.getDestValue(jo2201Inpar, "data.begntime"));
                joTmp.Add("InsuType", JsonHelper.getDestValue(jo2201Inpar, "data.insutype"));
                joTmp.Add("CertificateType", JsonHelper.getDestValue(jo2201Inpar, "data.mdtrt_cert_type"));
                joTmp.Add("CertificateNO", JsonHelper.getDestValue(jo2201Inpar, "data.mdtrt_cert_no"));
                joTmp.Add("MedicalType", JsonHelper.getDestValue(jo2203Inpar, "mdtrtinfo.med_type"));
                joTmp.Add("AttendDoctorNO", JsonHelper.getDestValue(jo2201Inpar, "data.atddr_no"));
                joTmp.Add("ChiefPhyDocName", JsonHelper.getDestValue(jo2201Inpar, "data.dr_name"));
                joTmp.Add("AdmInDiagDesc", JsonHelper.getDestValue(jo2203Inpar, "mdtrtinfo.main_cond_dscr"));
                joTmp.Add("AdmInDepCode", JsonHelper.getDestValue(jo2201Inpar, "data.dept_code"));
                joTmp.Add("AdmInDepName", JsonHelper.getDestValue(jo2201Inpar, "data.dept_name"));
                joTmp.Add("AdmBed", Global.pat.iOtherProvLocal); //这里用来存异地标志
                joTmp.Add("MainDiagCode", " ");
                joTmp.Add("MainDiagName", " ");
                joTmp.Add("MainConditionDesc", JsonHelper.getDestValue(jo2203Inpar, "mdtrtinfo.main_cond_dscr"));
                joTmp.Add("DiseasecCode", JsonHelper.getDestValue(jo2203Inpar, "mdtrtinfo.dise_codg"));
                joTmp.Add("DiseasecName", JsonHelper.getDestValue(jo2203Inpar, "mdtrtinfo.dise_name"));
                joTmp.Add("OperationCode", "");
                joTmp.Add("OperationName", "");
                joTmp.Add("DiseasecTypeCode", "");
                joTmp.Add("InsuranceAreaCode", Global.pat.insuplc_admdvs);
                joTmp.Add("TreatmentAreaCode", Global.pat.mdtrtarea_admvs);
                joTmp.Add("RegState", 1);
                joTmp.Add("ValidFlag", 1);
                joTmp.Add("Type", admType);
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("MSGID", Global.curEvt.msgid);
                joTmp.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

                string serviceCode = "09010044";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "新增门诊登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = joRtn.ToString();
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "保存门诊登记信息异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 保存门诊登记信息
        /// </summary>
        /// <param name="jo2201Inpar"></param>
        /// <param name="jo2201Rtn"></param>
        /// <param name="jo2203Inpar"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveOutpatRegisterInfo(JObject jo2201Inpar, JObject jo2201Rtn,JObject jo2203Inpar, out string outParam)
        {
            //插入云医保平台
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("InsuRegID", JsonHelper.getDestValue(jo2201Rtn, "output.data.mdtrt_id"));
                joTmp.Add("RegDate", JsonHelper.getDestValue(jo2201Inpar, "input.data.begntime"));
                joTmp.Add("InsuType", JsonHelper.getDestValue(jo2201Inpar, "input.data.insutype"));
                joTmp.Add("CertificateType", JsonHelper.getDestValue(jo2201Inpar, "input.data.mdtrt_cert_type"));
                joTmp.Add("CertificateNO", JsonHelper.getDestValue(jo2201Inpar, "input.data.mdtrt_cert_no"));
                joTmp.Add("MedicalType", JsonHelper.getDestValue(jo2203Inpar, "input.mdtrtinfo.med_type"));
                joTmp.Add("AttendDoctorNO", JsonHelper.getDestValue(jo2201Inpar, "input.data.atddr_no"));
                joTmp.Add("ChiefPhyDocName", JsonHelper.getDestValue(jo2201Inpar, "input.data.dr_name"));
                joTmp.Add("AdmInDiagDesc", JsonHelper.getDestValue(jo2203Inpar, "input.mdtrtinfo.main_cond_dscr"));
                joTmp.Add("AdmInDepCode", JsonHelper.getDestValue(jo2201Inpar, "input.data.dept_code"));
                joTmp.Add("AdmInDepName", JsonHelper.getDestValue(jo2201Inpar, "input.data.dept_name"));
                joTmp.Add("AdmBed", "");
                joTmp.Add("MainDiagCode", " ");
                joTmp.Add("MainDiagName", " ");
                joTmp.Add("MainConditionDesc", JsonHelper.getDestValue(jo2203Inpar, "input.mdtrtinfo.main_cond_dscr"));
                joTmp.Add("DiseasecCode", JsonHelper.getDestValue(jo2203Inpar, "input.mdtrtinfo.dise_codg"));
                joTmp.Add("DiseasecName", JsonHelper.getDestValue(jo2203Inpar, "input.mdtrtinfo.dise_name"));
                joTmp.Add("OperationCode", "");
                joTmp.Add("OperationName", "");
                joTmp.Add("DiseasecTypeCode", "");
                joTmp.Add("InsuranceAreaCode", Global.pat.insuplc_admdvs);
                joTmp.Add("TreatmentAreaCode", Global.pat.mdtrtarea_admvs);
                joTmp.Add("RegState", JsonHelper.getDestValue(jo2201Rtn, "regstate"));
                joTmp.Add("ValidFlag", JsonHelper.getDestValue(jo2201Rtn, "validflag"));
                joTmp.Add("Type", JsonHelper.getDestValue(jo2201Rtn, "type"));
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("MSGID", Global.curEvt.msgid);
                joTmp.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));

                string serviceCode = "09010044";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "新增门诊登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = joRtn.ToString();
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "保存门诊登记信息异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 取消登记
        /// </summary>
        /// <param name="type"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int cancleRegister(int type,out string outParam)
        {
            outParam = "";
            string errMsg;

            try
            {
                dynamic joTmp = new JObject();
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PersonalNO",Global.pat.psn_no);
                joTmp.Add("InsuRegID", Global.pat.mdtrtID);
                joTmp.Add("CancleRegDate", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joTmp.Add("Type", type);
                joTmp.Add("ValidFlag", -1);
                joTmp.Add("updateUserID", Global.user.ID);
                string serviceCode = "09010044";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "取消云医保平台登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = "退结算失败，请根据输入条件检查是否存在该笔数据！" + errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "取消登记异常" +  ":" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 删除费用明细
        /// </summary>
        /// <param name="pat"></param>
        /// <param name="errMsg"></param>
        /// <returns></returns>
        public int  deleteFee(out string errMsg)
        {
            try
            {
                dynamic joTmp = new JObject();
                joTmp = new JObject();
                joTmp.code = "09010048";
                joTmp.HospitalDr = Global.inf.hospitalDr;
                joTmp.admID = Global.pat.adm_Dr;
                joTmp.mdtrt_id = Global.pat.mdtrtID;
                joTmp.updateUserID = Global.user.ID;
                JObject joRtn = invoker.invokeInsuService(joTmp.ToString(), "删除2301明细");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    return -1;
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception ex)
            {
                errMsg = "deleteFee 异常：" + ex.Message;
                return -1;
            }          
        }

        /// <summary>
        ///  根据HIS的费用明细获取对照关系
        /// </summary>
        /// <returns></returns>
        public int convertHisFeeWithInsuCode( JObject joHisFee, out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                JArray jaFee = JArray.FromObject(joHisFee["result"]);
                JObject joTmp = JsonHelper.setIrisInpar("09010045", jaFee);
                joTmp.Add("mdtrt_id", Global.pat.mdtrtID);
                joTmp.Add("med_type", Global.pat.medType);
                joTmp.Add("psn_no", Global.pat.psn_no);
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);

                JObject joRtn = invoker.invokeInsuService(joTmp.ToString(), "根据HIS的费用明细获取对照关系");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "convertHisFeeWithInsuCode 异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 插入医保费用
        /// </summary>
        /// <param name="jaTmp"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int insertFee(JArray jaTmp,out string outParam)
        {
            try
            { 
                outParam = "";
                string errMsg;
                dynamic joTmp = new JObject();
                joTmp = new JObject();
                joTmp.code = "09010046";
                joTmp.HospitalDr = Global.inf.hospitalDr;
                joTmp.admID = Global.pat.adm_Dr;
                joTmp.mdtrt_id = Global.pat.mdtrtID;
                joTmp.updateUserID = Global.user.ID;
                joTmp.Add("params", jaTmp);
                ;
                JObject joRtn = invoker.invokeInsuService(joTmp.ToString(), "插入2301明细");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
                catch (Exception ex)
                {
                    outParam = "insertFee 异常：" + ex.Message;
                    return -1;
                }
        }

        /// <summary>
        /// 更新医保费用
        /// </summary>
        /// <param name="jaTmp"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int updateFee(JArray jaTmp, out string outParam)
        {
            try
            {
                outParam = "";
                string errMsg;
                dynamic joTmp = new JObject();
                joTmp.code = "09010047";
                JArray jaParams = jaTmp;
                joTmp.Add("params", jaParams);
                joTmp.HospitalDr = Global.inf.hospitalDr;
                joTmp.admID = Global.pat.adm_Dr;
                joTmp.mdtrt_id = Global.pat.mdtrtID;
                joTmp.updateUserID =Global.user.ID;
                JObject joRtn = invoker.invokeInsuService(joTmp.ToString(), "更新2301明细");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "updateFee 异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 获取各项费用汇总
        /// </summary>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int getSumFee(out string outParam)
        {
            try
            {
                outParam = "";
                string errMsg;
                //调用IRIS获取医保各项金额
                dynamic joTmp = new JObject();
                joTmp = new JObject();
                joTmp.code = "09010049";
                joTmp.HospitalDr = Global.inf.hospitalDr;
                joTmp.admID = Global.pat.adm_Dr;
                joTmp.mdtrt_id = Global.pat.mdtrtID;
                joTmp.updateUserID = Global.user.ID; ;
                JObject joRtn = invoker.invokeInsuService(joTmp.ToString(), "获取各项费用汇总"); ;
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "getSumFee 异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 转换结算信息
        /// </summary>
        /// <param name="pat"></param>
        /// <param name="joSettlement"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int convertSettlementWithInsuCode(JObject joSettlement, out string outParam)
        {
            outParam = "";
            string errMsg;
            try
            {
                JObject joOutput = JObject.FromObject(joSettlement["output"]);
                //编码转换
                JObject joInpar = new JObject();
                joInpar.Add("hospitalDr", Global.inf.hospitalDr);
                joInpar.Add("interfaceDr", Global.inf.interfaceDr);
                joInpar.Add("output", joOutput);


                InvokeHelper invoker = new InvokeHelper();
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010055", joInpar).ToString(), "结算信息编码转换");
                if (JsonHelper.getDestValue(joRtn, "errorCode") != "")
                {
                    outParam = JsonHelper.getDestValue(joRtn, "errorMessage");
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "convertSettlementWithInsuCode 异常：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 插入门诊结算信息-北京市医保
        /// </summary>
        /// <param name="joSettlement"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveSettlementOP(string sRtn, int iOtherProvLocal, out string outParam)
        {
            JObject joSetlinfo = new JObject();

            try
            {
                if (GetSettlementRtnValue(sRtn, iOtherProvLocal,out string errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }


                string fQTJJZF="0";
                //float fQTJJZF = float.Parse(Global.Set.bcpay)
                //                + float.Parse(Global.Set.jcbz)
                //                + float.Parse(Global.Set.txbz)
                //                + float.Parse(Global.Set.offi_true)
                //                + float.Parse(Global.Set.big_ill_pay)
                //                + float.Parse(Global.Set.civil_pay)
                //                + float.Parse(Global.Set.ExServicePay);

                //MessageBox.Show("fQTJJZF：" + fQTJJZF.ToString());

                if (iOtherProvLocal == 0)
                {
                    joSetlinfo.Add("setl_id", Global.Set.tradeno);      //OrganSettlementID结算ID-交易流水号
                    joSetlinfo.Add("setl_time", Global.Set.tradedate);      //SettlementDate结算时间 -交易时间
                    joSetlinfo.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
                    joSetlinfo.Add("hifdm_pay", Global.Set.jcbz);      //伤残人员医疗保障基金支出-军残补助保险支付
                    joSetlinfo.Add("cvlserv_flag", "");      //公务员标志
                    joSetlinfo.Add("med_type", Global.pat.medType);      //医疗类别
                    joSetlinfo.Add("exp_content", "");      //字段扩展
                    joSetlinfo.Add("brdy", Global.pat.brdy);      //出生日期
                    joSetlinfo.Add("naty", Global.pat.naty);      //民族
                    joSetlinfo.Add("psn_cash_pay", Global.Set.cash);      //个人现金支出
                    joSetlinfo.Add("certno", Global.pat.certNO);      //证件号码
                    joSetlinfo.Add("hifmi_pay", Global.Set.big_ill_pay);      //SeriousIllnessPay居民大病保险资金支出-大病支付金额
                    joSetlinfo.Add("psn_no", Global.pat.psn_no);      //人员编号
                    joSetlinfo.Add("act_pay_dedc", Global.Set.mzpayfirst);      //ActualPayDeductible实际支付起付线-本次付起付线金额
                    joSetlinfo.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
                    joSetlinfo.Add("balc", Global.pat.balc);      //余额
                    joSetlinfo.Add("medins_setl_id", Global.Set.feeno);      //OrganSettlementID医药机构结算ID-收费单据号
                    joSetlinfo.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
                    joSetlinfo.Add("acct_mulaid_pay", "");      //个人账户共济支付金额
                    joSetlinfo.Add("clr_way", iOtherProvLocal);      //清算方式 0本地 1异地
                    joSetlinfo.Add("hifob_pay", Global.Set.mzbigpay);      //LargeExpensesSupplementPay职工大额医疗费用补助基金支出-门诊大额支付金额
                    joSetlinfo.Add("oth_pay", fQTJJZF);      //其他支出
                    joSetlinfo.Add("medfee_sumamt", Global.Set.feeall);      //医疗费总额
                    joSetlinfo.Add("hifes_pay", Global.Set.offi_true);      //EnterpriseSupplementPay企业补充医疗保险基金支出-单位补充医疗保险（原公疗）支付金额
                    joSetlinfo.Add("gend", Global.pat.gend);      //性别
                    joSetlinfo.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
                    joSetlinfo.Add("acct_pay", Global.Set.personcountpay);      //个人账户支出-个人帐户支付
                    joSetlinfo.Add("fund_pay_sumamt", Global.Set.fund);      //基金支付总额-基金支付
                    joSetlinfo.Add("fulamt_ownpay_amt", Global.Set.mzfeeout);      //OwnPayAmount全自费金额
                    joSetlinfo.Add("hosp_part_amt", 0);      //医院负担金额          
                    joSetlinfo.Add("inscp_scp_amt", Global.Set.mzfeein);      //InPolicyRangeAmount符合政策范围金额-医保内总金额
                    joSetlinfo.Add("insutype", Global.pat.insuType);      //险种类型
                    joSetlinfo.Add("maf_pay", Global.Set.civil_pay);      //MedicalAssistPay医疗救助基金支出-民政救助支付金额
                    joSetlinfo.Add("psn_name", Global.pat.name);      //人员姓名
                    joSetlinfo.Add("psn_part_amt", decimal.Parse(Global.Set.cash) + decimal.Parse(Global.Set.personcountpay));      //个人负担总金额
                    joSetlinfo.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
                    joSetlinfo.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
                    joSetlinfo.Add("psn_type", Global.pat.psn_type);      //人员类别
                    joSetlinfo.Add("hifp_pay", Global.Set.fund);      //FundPaySumamt基本医疗保险统筹基金支出-基金支付
                    joSetlinfo.Add("overlmt_selfpay", Global.Set.mzoutofbig);      //OverLimitAmount超限价金额-超大额自付金额
                    joSetlinfo.Add("preselfpay_amt", "");      //PreSelfPayAmount先行自付金额
                    joSetlinfo.Add("age", Global.pat.age);      //年龄
                    joSetlinfo.Add("clr_type", "");      //清算类别
                }
                else
                {
                    joSetlinfo.Add("setl_id", Global.Set.tradeno);      //结算ID
                    joSetlinfo.Add("setl_time", Global.Set.tradedate);      //结算时间
                    joSetlinfo.Add("cvlserv_pay", Global.Set.GwybzPay);      //公务员医疗补助资金支出
                    joSetlinfo.Add("hifdm_pay", Global.Set.jcbz);      //伤残人员医疗保障基金支出
                    joSetlinfo.Add("cvlserv_flag", Global.Set.SelfPayFlag);      //公务员标志
                    joSetlinfo.Add("med_type", Global.pat.medType);      //医疗类别
                    joSetlinfo.Add("exp_content", "");      //字段扩展
                    joSetlinfo.Add("brdy", Global.pat.brdy);      //出生日期
                    joSetlinfo.Add("naty", Global.pat.naty);      //民族
                    joSetlinfo.Add("psn_cash_pay", Global.Set.cash);      //个人现金支出
                    joSetlinfo.Add("certno", Global.pat.certNO);      //证件号码
                    joSetlinfo.Add("hifmi_pay", Global.Set.mzbigpay);      //居民大病保险资金支出
                    joSetlinfo.Add("psn_no", Global.pat.psn_no);      //人员编号
                    joSetlinfo.Add("act_pay_dedc", Global.Set.mzpayfirst);      //实际支付起付线
                    joSetlinfo.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
                    joSetlinfo.Add("balc", Global.pat.balc);      //余额
                    joSetlinfo.Add("medins_setl_id", Global.Set.feeno);      //医药机构结算ID
                    joSetlinfo.Add("psn_cert_type", Global.pat.certType);      //人员证件类型
                    joSetlinfo.Add("acct_mulaid_pay", 0);      //个人账户共济支付金额
                    joSetlinfo.Add("clr_way", iOtherProvLocal);      //清算方式
                    joSetlinfo.Add("hifob_pay", Global.Set.mzbigpay);      //职工大额医疗费用补助基金支出
                    joSetlinfo.Add("oth_pay", fQTJJZF);      //其他支出
                    joSetlinfo.Add("medfee_sumamt", Global.Set.feeall);      //医疗费总额
                    joSetlinfo.Add("hifes_pay", Global.Set.bcpay);      //企业补充医疗保险基金支出
                    joSetlinfo.Add("gend", Global.pat.gend);      //性别
                    joSetlinfo.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
                    joSetlinfo.Add("acct_pay", Global.Set.personcountpay);      //个人账户支出
                    joSetlinfo.Add("fund_pay_sumamt", Global.Set.fund);      //基金支付总额
                    joSetlinfo.Add("fulamt_ownpay_amt", Global.Set.mzfeeout);      //全自费金额
                    joSetlinfo.Add("hosp_part_amt", 0);      //医院负担金额          
                    joSetlinfo.Add("inscp_scp_amt", Global.Set.mzfeein);      //符合政策范围金额
                    joSetlinfo.Add("insutype", Global.pat.insuType);      //险种类型
                    joSetlinfo.Add("maf_pay", Global.Set.MzbzPay);      //医疗救助基金支出
                    joSetlinfo.Add("psn_name", Global.pat.name);      //人员姓名
                    joSetlinfo.Add("psn_part_amt", decimal.Parse(Global.Set.cash) + decimal.Parse(Global.Set.personcountpay));      //个人负担总金额
                    joSetlinfo.Add("clr_optins", Global.Set.clearingOrgan);      //清算经办机构
                    joSetlinfo.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
                    joSetlinfo.Add("psn_type", Global.pat.psn_type);      //人员类别
                    joSetlinfo.Add("hifp_pay", Global.Set.fund);      //基本医疗保险统筹基金支出
                    joSetlinfo.Add("overlmt_selfpay", Global.Set.OVERLMT_SELFPAY);      //超限价金额
                    joSetlinfo.Add("preselfpay_amt", Global.Set.selfPayFirst);      //先行自付金额
                    joSetlinfo.Add("age", Global.pat.age);      //年龄
                    joSetlinfo.Add("clr_type", "");      //清算类别
                }

                joSetlinfo.Add("HospitalDr", Global.inf.hospitalDr);
                joSetlinfo.Add("admID", Global.pat.adm_Dr);
                joSetlinfo.Add("ValidFlag", 1);
                joSetlinfo.Add("BillType", 1);
                joSetlinfo.Add("updateUserID", Global.user.ID);
                joSetlinfo.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joSetlinfo.Add("billID", Global.pat.billID);
                joSetlinfo.Add("recordID", Global.pat.recordID);
                joSetlinfo.Add("msgid", Global.Set.feeno);  //门诊打印入参之一 收费单据号
                joSetlinfo.Add("interfaceDr", Global.inf.interfaceDr);
                joSetlinfo.Add("admType", Global.pat.admType);
                joSetlinfo.Add("insuplc_admdvs", Global.pat.insuplc_admdvs);

                joSetlinfo.Add("HospitalizationsDays", Global.Set.hospitalizationsDays);
                joSetlinfo.Add("HospitalizationsTimes", Global.Set.hospitalizationsTimes);
                joSetlinfo.Add("HISAdmTime", Global.Set.hisAdmTime);
                joSetlinfo.Add("HISDischargeTime", Global.Set.hisDischargeTime);
                joSetlinfo.Add("ExpContent", Global.pat.medType);

                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010051", joSetlinfo).ToString(), "插入结算信息");
                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "插入结算信息：" + ex.Message;
                return -1;
            }
        }

        public int GetSettlementRtnValue(string sRtn, int iOtherProvLocal, out string outParam)
        {
            try
            {
                outParam = "";
                JObject joRtn = AnXML.ConvertXMLToObject(sRtn);

                if (iOtherProvLocal == 0)
                {
                    //交易信息（tradeinfo）
                    Global.Set.tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
                    Global.Set.feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
                    string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
                    Global.Set.tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);

                    //汇总支付信息（sumpay）
                    Global.Set.feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
                    Global.Set.fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
                    Global.Set.cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
                    Global.Set.personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付            
                                                                                                                     //支付信息（payinfo）
                    Global.Set.mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
                    Global.Set.mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
                    Global.Set.mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
                    Global.Set.mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
                    Global.Set.mzselfpay2 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzselfpay2");//个人自付2
                    Global.Set.mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
                    Global.Set.mzbigselfpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigselfpay"); //门诊大额自付金额
                    Global.Set.mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzoutofbig"); //超大额自付金额
                    Global.Set.bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
                    Global.Set.jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
                    Global.Set.big_ill_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.big_ill_pay"); //大病支付金额
                    Global.Set.civil_pay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.civil_pay"); //民政救助支付金额
                    Global.Set.ExServicePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.ExServicePay"); //退役军转干部退役医疗费支付
                    Global.Set.txbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.txbz"); //退休补助金额
                    Global.Set.offi_true = JsonHelper.getDestValue(joRtn, "root.output.payinfo.offi_true");  //单位补充医疗保险（原公疗）支付金额
                    Global.Set.year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzfeein");  //年度门诊医保内费用累计
                    Global.Set.year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzbigpay");  //年度门诊大额支付累计
                    Global.Set.year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.year_mzoutofbig");  //门诊大额封顶后医保内金额累计
                    Global.Set.first_year_mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzfeein");  //一级医院年度门诊医保内费用累计
                    Global.Set.first_year_mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzbigpay");  //一级医院年度门诊大额支付累计
                    Global.Set.first_year_mzoutofbig = JsonHelper.getDestValue(joRtn, "root.output.payinfo.first_year_mzoutofbig");  //一级医院门诊大额封顶后医保内金额累计
                    Global.Set.selfpay1 = JsonHelper.getDestValue(joRtn, "root.output.payinfo.selfpay1"); //自付一
                    Global.Set.bigillcomm = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bigillcomm"); //年度大病内累计金额   
                }
                else
                {
                    //交易信息（tradeinfo）
                    Global.Set.tradeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradeno");
                    Global.Set.feeno = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.feeno");
                    string tradedate = JsonHelper.getDestValue(joRtn, "root.output.tradeinfo.tradedate");
                    Global.Set.tradedate = tradedate.Trim().Substring(0, 4) + "-" + tradedate.Trim().Substring(4, 2) + "-" + tradedate.Trim().Substring(6, 2) + " " + tradedate.Trim().Substring(8, 2) + ":" + tradedate.Trim().Substring(10, 2) + ":" + tradedate.Trim().Substring(12, 2);
                    //汇总支付信息（sumpay）
                    Global.Set.feeall = JsonHelper.getDestValue(joRtn, "root.output.sumpay.feeall"); //费用总金额
                    Global.Set.fund = JsonHelper.getDestValue(joRtn, "root.output.sumpay.fund"); //基金支付
                    Global.Set.cash = JsonHelper.getDestValue(joRtn, "root.output.sumpay.cash"); //现金支付
                    Global.Set.personcountpay = JsonHelper.getDestValue(joRtn, "root.output.sumpay.personcountpay"); //个人帐户支付
                    Global.Set.selFeeAll = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selFeeAll"); //全自付金额
                    Global.Set.selfPayFirst = JsonHelper.getDestValue(joRtn, "root.output.sumpay.selfPayFirst"); //先行自付金额
                    Global.pat.acctPayAmt = Global.Set.personcountpay;
                    //支付信息（payinfo）
                    Global.Set.CLAB_PRESELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.CLAB_PRESELFPAY_FEE"); //乙类先行自付费用
                    Global.Set.OVERLMT_SELFPAY = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OVERLMT_SELFPAY"); //超限价自付费用
                    Global.Set.PSN_OWNPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_OWNPAY_FEE"); //个人自费费用
                    Global.Set.PSN_SELFPAY_FEE = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PSN_SELFPAY_FEE"); //个人自付费用
                    Global.Set.mzpayfirst = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzpayfirst"); //本次付起付线金额
                    Global.Set.mzfee = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfee"); //费用总金额
                    Global.Set.mzfeein = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeein"); //医保内总金额
                    Global.Set.mzfeeout = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzfeeout"); //医保外总金额
                    Global.Set.BasePay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.BasePay"); //基本医疗保险统筹基金支付金额
                    Global.Set.GwybzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.GwybzPay"); //公务员医疗补助基金
                    Global.Set.bcpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.bcpay"); //补充保险支付
                    Global.Set.mzbigpay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.mzbigpay"); //门诊大额支付金额
                    Global.Set.jcbz = JsonHelper.getDestValue(joRtn, "root.output.payinfo.jcbz"); //军残补助保险支付
                    Global.Set.MzbzPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.MzbzPay"); //门诊补助支付金额
                    Global.Set.OtherPay = JsonHelper.getDestValue(joRtn, "root.output.payinfo.OtherPay"); //其他基金支付
                    Global.Set.Cash = JsonHelper.getDestValue(joRtn, "root.output.payinfo.Cash");//个人现金支付金额
                    Global.Set.PersonCountBalance = JsonHelper.getDestValue(joRtn, "root.output.payinfo.PersonCountBalance");//个人账户支付金额
                    Global.Set.SelfPayFlag = JsonHelper.getDestValue(joRtn, "root.output.payinfo.SelfPayFlag");//全额垫付标志
                }

                return 0;
            }
            catch (Exception ex)
            {
                outParam = "解析结算信息异常：" + ex.Message;
                return -1;
            }       
        }

        /// <summary>
        /// 插入住院结算信息-北京市医保
        /// </summary>
        /// <param name="joSettlement"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveSettlementNewIP(out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";

            try
            {                      
                JObject joSetlinfo = new JObject();
                joSetlinfo.Add("setl_id", Global.Set.settlID);      //结算ID 住院非实时结算ID赋值流水号
                joSetlinfo.Add("setl_time", Global.Set.hisDischargeTime);      //HIS结算时间
                joSetlinfo.Add("cvlserv_pay", 0);      //公务员医疗补助资金支出
                joSetlinfo.Add("hifdm_pay", 0);      //伤残人员医疗保障基金支出
                joSetlinfo.Add("cvlserv_flag", "");      //公务员标志
                joSetlinfo.Add("med_type", Global.pat.medType);      //医疗类别
                joSetlinfo.Add("exp_content", "");      //字段扩展
                joSetlinfo.Add("brdy", Global.pat.brdy);      //出生日期
                joSetlinfo.Add("naty", Global.pat.naty);      //民族
                joSetlinfo.Add("psn_cash_pay", Global.pat.cashpayAmt);      //个人现金支出
                joSetlinfo.Add("certno", Global.pat.certNO);      //证件号码
                joSetlinfo.Add("hifmi_pay", 0);      //居民大病保险资金支出
                joSetlinfo.Add("psn_no", Global.pat.psn_no);      //人员编号
                joSetlinfo.Add("act_pay_dedc", 0);      //实际支付起付线
                joSetlinfo.Add("mdtrt_cert_type", Global.pat.mdtrtcertType);      //就诊凭证类型
                joSetlinfo.Add("balc", Global.pat.balc);      //余额
                joSetlinfo.Add("medins_setl_id", Global.pat.billID);      //医药机构结算ID
                joSetlinfo.Add("psn_cert_type", "01");      //人员证件类型
                joSetlinfo.Add("acct_mulaid_pay", 0);      //个人账户共济支付金额
                joSetlinfo.Add("clr_way", "1");      //清算方式
                joSetlinfo.Add("hifob_pay", 0);      //职工大额医疗费用补助基金支出
                joSetlinfo.Add("oth_pay", 0);      //其他支出
                joSetlinfo.Add("medfee_sumamt", Global.pat.hisSumAmt);      //医疗费总额
                joSetlinfo.Add("hifes_pay", 0);      //企业补充医疗保险基金支出
                joSetlinfo.Add("gend", Global.pat.gend);      //性别
                joSetlinfo.Add("mdtrt_id", Global.pat.mdtrtID);      //就诊ID
                joSetlinfo.Add("acct_pay", Global.pat.acctPayAmt);      //个人账户支出
                joSetlinfo.Add("fund_pay_sumamt", Global.pat.insuAmt);      //基金支付总额
                joSetlinfo.Add("fulamt_ownpay_amt", 0);      //全自费金额
                joSetlinfo.Add("hosp_part_amt", 0);      //医院负担金额          
                joSetlinfo.Add("inscp_scp_amt", 0);      //符合政策范围金额
                joSetlinfo.Add("insutype", Global.pat.insuType);      //险种类型
                joSetlinfo.Add("maf_pay", 0);      //医疗救助基金支出
                joSetlinfo.Add("psn_name", Global.pat.name);      //人员姓名
                joSetlinfo.Add("psn_part_amt", decimal.Parse(Global.pat.cashpayAmt) + decimal.Parse(Global.pat.acctPayAmt));      //个人负担总金额
                joSetlinfo.Add("clr_optins", "");      //清算经办机构
                joSetlinfo.Add("pool_prop_selfpay", "");      //基本医疗保险统筹基金支付比例
                joSetlinfo.Add("psn_type", Global.pat.psn_type);      //人员类别
                joSetlinfo.Add("hifp_pay", Global.pat.insuAmt);      //基本医疗保险统筹基金支出
                joSetlinfo.Add("overlmt_selfpay", 0);      //超限价金额
                joSetlinfo.Add("preselfpay_amt", 0);      //先行自付金额
                joSetlinfo.Add("age", Global.pat.age);      //年龄
                joSetlinfo.Add("clr_type", "21");      //清算类别

                joSetlinfo.Add("DiseasecCode", Global.pat.DiseasecCode);
                joSetlinfo.Add("DiseasecName", Global.pat.DiseasecName);

                joSetlinfo.Add("HospitalDr", Global.inf.hospitalDr);
                joSetlinfo.Add("admID", Global.pat.adm_Dr);
                joSetlinfo.Add("ValidFlag", 1);
                joSetlinfo.Add("BillType", 1);
                joSetlinfo.Add("updateUserID", Global.user.ID);
                joSetlinfo.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joSetlinfo.Add("billID", Global.pat.billID);
                joSetlinfo.Add("recordID", Global.pat.recordID);
                joSetlinfo.Add("msgid", Global.curEvt.msgid);
                joSetlinfo.Add("interfaceDr", Global.inf.interfaceDr);
                joSetlinfo.Add("admType", Global.pat.admType);
                joSetlinfo.Add("insuplc_admdvs", Global.pat.insuplc_admdvs);

                joSetlinfo.Add("HospitalizationsDays", Global.Set.hospitalizationsDays);
                joSetlinfo.Add("HospitalizationsTimes", Global.Set.hospitalizationsTimes);
                joSetlinfo.Add("HISAdmTime", Global.Set.hisAdmTime);
                joSetlinfo.Add("HISDischargeTime", Global.Set.hisDischargeTime);

                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010051", joSetlinfo).ToString(), "插入结算信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "插入结算信息：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 插入结算信息
        /// </summary>
        /// <param name="joSettlement"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveSettlement(JObject joSettlement, out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                JObject joSetlinfo = JObject.Parse(JsonHelper.getDestValue(joSettlement, "output.setlinfo"));
                joSetlinfo.Add("HospitalDr", Global.inf.hospitalDr);
                joSetlinfo.Add("admID", Global.pat.adm_Dr);
                joSetlinfo.Add("ValidFlag", 1);
                joSetlinfo.Add("BillType", 1);
                joSetlinfo.Add("updateUserID",Global.user.ID);
                joSetlinfo.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joSetlinfo.Add("billID", Global.pat.billID);
                joSetlinfo.Add("recordID", Global.pat.recordID);
                joSetlinfo.Add("msgid", Global.curEvt.msgid);
                joSetlinfo.Add("interfaceDr", Global.inf.interfaceDr);
                joSetlinfo.Add("admType", Global.pat.admType);
                joSetlinfo.Add("insuplc_admdvs", Global.pat.insuplc_admdvs);

                joSetlinfo.Add("HospitalizationsDays", Global.Set.hospitalizationsDays);
                joSetlinfo.Add("HospitalizationsTimes", Global.Set.hospitalizationsTimes);
                joSetlinfo.Add("HISAdmTime", Global.Set.hisAdmTime);
                joSetlinfo.Add("HISDischargeTime", Global.Set.hisDischargeTime);

                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010051", joSetlinfo).ToString(), "插入结算信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "插入结算信息：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 保存结算信息
        /// </summary>
        /// <param name="joSettlement"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int saveSettlementDetail(JObject joSettlement, out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                JObject joSetlDetail = new JObject();
                joSetlDetail.Add("HospitalDr", Global.inf.hospitalDr);
                joSetlDetail.Add("InterfaceDr", Global.inf.interfaceDr);
                joSetlDetail.Add("MdtrtID", Global.pat.mdtrtID);
                joSetlDetail.Add("SettlementID", JsonHelper.getDestValue(joSettlement, "output.setlinfo.setl_id"));
                joSetlDetail.Add("AdmID", Global.pat.adm_Dr);
                joSetlDetail.Add("updateUserID", Global.user.ID);
                if (JsonHelper.getDestValue(joSettlement, "output.setldetail") == "")
                {
                    outParam = "中心返回结算明细为空！";
                    Global.writeLog(outParam);
                    return 0;
                }
                JArray jaSetlDetail = JArray.Parse(JsonHelper.getDestValue(joSettlement, "output.setldetail"));
                joSetlDetail.Add("setldetail", jaSetlDetail);
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010056", joSetlDetail).ToString(), "插入结算明细信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "插入结算信息：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 取消结算
        /// </summary>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int cancleSettlement(string newSettlID, out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("admID", Global.pat.adm_Dr);
                joTmp.Add("mdtrt_id", Global.pat.mdtrtID);
                joTmp.Add("setl_id", Global.pat.settlID);
                joTmp.Add("new_setl_id", newSettlID);
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("msgid", Global.curEvt.msgid);
                joTmp.Add("OccurTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
                joTmp.Add("ExpContent", Global.pat.partialFlag);

                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010052", joTmp).ToString(), "取消结算信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "取消结算信息：" + ex.Message;
                return -1;
            }
        }
     
        /// <summary>
        /// 查询登记信息
        /// </summary>
        /// <param name="type"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int queryRegisterInfo(int type,out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {                
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("admID", Global.pat.adm_Dr);
                joTmp.Add("mdtrt_id", Global.pat.mdtrtID);
                joTmp.Add("type", type);

                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010050", joTmp).ToString(), "查询云平台患者登记信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "查询云平台患者登记信息：" + ex.Message;
                return -1;
            }
        }

        /// <summary>
        /// 插入患者该次就诊参保信息-北京首信医保
        /// </summary>
        /// <param name="joBaseInfo"></param>
        /// <param name="joInsuInfo"></param>
        /// <param name="joIdetInfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int insertPatCurInsuInfoNew(string patInfo, out string outParam)
        {
            HisMainBusiness hBus = new HisMainBusiness();
            JObject joTmp = new JObject();
            JObject joPatInfo = new JObject();
            joPatInfo = hBus.ConvertXMLToObject(patInfo);
            string errMsg = "";
            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmID", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("MdtrtID", Global.pat.mdtrtID);
                joTmp.Add("PsnCertType", "01");
                joTmp.Add("PsnCertNO", Global.pat.certNO); 
                joTmp.Add("Gend", Global.pat.gend);
                joTmp.Add("Naty", Global.pat.iOtherProvLocal);
                joTmp.Add("Brdy", Global.pat.brdy);
                joTmp.Add("Age", Global.pat.age);
                joTmp.Add("Balc", Global.pat.balc);
                joTmp.Add("Insutype", Global.pat.insuType);
                joTmp.Add("PsnType", Global.pat.psn_type);
                joTmp.Add("PsnInsuStas", Global.pat.isinredlist);
                joTmp.Add("PsnInsuDate", "");
                joTmp.Add("PausInsuDate", "");
                joTmp.Add("Cvlservflag", Global.pat.isyt); 
                joTmp.Add("insuplcAdmdvs", Global.pat.insuplc_admdvs);
                joTmp.Add("EmpName", Global.pat.isspecifiedhosp);
                joTmp.Add("PsnIdettype", Global.pat.ischronichosp);
                joTmp.Add("PsnTypeLv", Global.pat.jclevel);
                joTmp.Add("IdetBegntime", Global.pat.fromhosp);
                //joTmp.Add("IdetEndtime", Global.pat.DiseasecCode); 
                joTmp.Add("updateUserID", Global.user.ID);

                joTmp.Add("ExtField1", joPatInfo.ToString());

                string serviceCode = "09010070";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "插入患者该次就诊参保信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "医保平台插入患者该次就诊参保信息：" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 插入患者该次就诊参保信息-北京首信医保
        /// </summary>
        /// <param name="patInfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int insertPatCurInsuInfo(JObject joPatInfo, out string outParam)
        {
            HisMainBusiness hBus = new HisMainBusiness();
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmID", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("MdtrtID", Global.pat.psn_no);
                joTmp.Add("PsnCertType", "01");
                joTmp.Add("PsnCertNO", Global.pat.certNO);
                joTmp.Add("Gend", Global.pat.gend);
                joTmp.Add("Naty", Global.pat.iOtherProvLocal);
                joTmp.Add("Brdy", Global.pat.brdy);
                joTmp.Add("Age", Global.pat.age);
                joTmp.Add("Balc", Global.pat.balc);
                joTmp.Add("Insutype", Global.pat.insuType);
                joTmp.Add("PsnType", Global.pat.psn_type);
                joTmp.Add("PsnInsuStas", Global.pat.isinredlist);
                joTmp.Add("PsnInsuDate", "");
                joTmp.Add("PausInsuDate", "");
                joTmp.Add("Cvlservflag", Global.pat.isyt);
                joTmp.Add("insuplcAdmdvs", Global.pat.insuplc_admdvs);
                joTmp.Add("EmpName", Global.pat.isspecifiedhosp);
                joTmp.Add("PsnIdettype", Global.pat.ischronichosp);
                joTmp.Add("PsnTypeLv", Global.pat.jclevel);
                joTmp.Add("IdetBegntime", "");
                //joTmp.Add("IdetEndtime", Global.pat.DiseasecCode); 
                joTmp.Add("updateUserID", Global.user.ID);
                joTmp.Add("ExtField1", joPatInfo.ToString());

                string serviceCode = "09010070";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "插入患者该次就诊参保信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "医保平台插入患者该次就诊参保信息：" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 插入患者该次就诊参保信息
        /// </summary>
        /// <param name="joBaseInfo"></param>
        /// <param name="joInsuInfo"></param>
        /// <param name="joIdetInfo"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int insertPatCurInsuInfo(JObject joBaseInfo, JObject joInsuInfo, JObject joIdetInfo, out string outParam)
        {
            JObject joTmp = new JObject();
            string errMsg = "";
            try
            {
                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmID", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);
                joTmp.Add("MdtrtID", Global.pat.mdtrtID);
                joTmp.Add("PsnCertType", JsonHelper.getDestValue(joBaseInfo, "psn_cert_type"));
                joTmp.Add("PsnCertNO", JsonHelper.getDestValue(joBaseInfo, "certno"));
                joTmp.Add("Gend", JsonHelper.getDestValue(joBaseInfo, "gend"));
                joTmp.Add("Naty", JsonHelper.getDestValue(joBaseInfo, "naty"));
                joTmp.Add("Brdy", JsonHelper.getDestValue(joBaseInfo, "brdy"));
                joTmp.Add("Age", JsonHelper.getDestValue(joBaseInfo, "age"));
                joTmp.Add("Balc", JsonHelper.getDestValue(joInsuInfo, "balc"));
                joTmp.Add("Insutype", JsonHelper.getDestValue(joInsuInfo, "insutype"));
                joTmp.Add("PsnType", JsonHelper.getDestValue(joInsuInfo, "psn_type"));
                joTmp.Add("PsnInsuStas", JsonHelper.getDestValue(joInsuInfo, "psn_insu_stas"));
                joTmp.Add("PsnInsuDate", JsonHelper.getDestValue(joInsuInfo, "psn_insu_date"));
                joTmp.Add("PausInsuDate", JsonHelper.getDestValue(joInsuInfo, "paus_insu_date"));
                joTmp.Add("Cvlservflag", JsonHelper.getDestValue(joInsuInfo, "cvlserv_flag"));
                joTmp.Add("insuplcAdmdvs", JsonHelper.getDestValue(joInsuInfo, "insuplc_admdvs"));
                joTmp.Add("EmpName", JsonHelper.getDestValue(joInsuInfo, "emp_name"));
                joTmp.Add("PsnIdettype", JsonHelper.getDestValue(joIdetInfo, "psn_idet_type"));
                joTmp.Add("PsnTypeLv", JsonHelper.getDestValue(joIdetInfo, "psn_type_lv"));
                joTmp.Add("IdetBegntime", JsonHelper.getDestValue(joIdetInfo, "begntime"));
                joTmp.Add("IdetEndtime", JsonHelper.getDestValue(joIdetInfo, "endtime"));
                joTmp.Add("updateUserID", Global.user.ID);

                Global.pat.certNO = JsonHelper.getDestValue(joBaseInfo, "certno");

                string serviceCode = "09010070";
                string inpar = JsonHelper.setIrisInpar(serviceCode, joTmp).ToString();
                JObject joRtn = invoker.invokeInsuService(inpar, "插入患者该次就诊参保信息");

                if (JsonHelper.parseIrisRtnValue(joRtn, out errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "医保平台插入患者该次就诊参保信息：" + ex.Message;
                return -1;
            }

        }

        /// <summary>
        /// 插入患者医嘱共享信息
        /// </summary>
        /// <param name="infotype">00：查询门诊历史交易 01：参保人照片</param>
        /// <param name="joRtnMedOrder"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        public int insertMedOrderShareInfo(string infotype, JObject joRtnMedOrder, out string outParam)        
        {
            JObject joTmp = new JObject();
            string micode = "", icno = "", serverdatetime = "", allowqueryflag = "", signinfo = "", patientphoto = "";

            try
            {
                if (infotype == "00") //插入就诊历史信息
                {
                    micode = JsonHelper.getDestValue(joRtnMedOrder, "sysinfo.micode"); 
                    //icno = JsonHelper.getDestValue(joRtnMedOrder, "sysinfo.icno");
                    serverdatetime = JsonHelper.getDestValue(joRtnMedOrder, "sysinfo.serverdatetime");
                    allowqueryflag = JsonHelper.getDestValue(joRtnMedOrder, "sysinfo.allowqueryflag");
                    signinfo = JsonHelper.getDestValue(joRtnMedOrder, "sysinfo.signinfo");                    

                    //if (icno.Trim() != Global.pat.psn_no.Trim())
                    //{
                    //    outParam = "医嘱共享接口返回信息与读卡返回信息不一致,icno：" + icno + " <> psn_no：" + Global.pat.psn_no;
                    //    return -1;
                    //}
                }
                else if (infotype == "01") //插入照片信息
                {
                    patientphoto = JsonHelper.getDestValue(joRtnMedOrder, "patientphoto");
                }

                joTmp.Add("HospitalDr", Global.inf.hospitalDr);
                joTmp.Add("InterfaceDr", Global.inf.interfaceDr);
                joTmp.Add("AdmDr", Global.pat.adm_Dr);
                joTmp.Add("PatientName", Global.pat.name);
                joTmp.Add("PersonalNO", Global.pat.psn_no);                 
                joTmp.Add("CertNo", Global.pat.certNO);
                joTmp.Add("Infotype", infotype); //查询信息类型 00：查询门诊历史交易 01：参保人照片
                joTmp.Add("MiCode", micode); //医疗机构编码
                joTmp.Add("ServerDateTime", serverdatetime); //中心端系统日期
                joTmp.Add("AllowQueryFlag", allowqueryflag); //查询准许标识
                joTmp.Add("SignInfo", signinfo); //签名信息                
                joTmp.Add("UpdateTime", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")); //更新时间
                joTmp.Add("UpdateUserID", Global.user.ID);

                joTmp.Add("ExTend", joRtnMedOrder.ToString()); //扩展详细信息-接口返回值 joRtnMedOrder.ToString()
                joTmp.Add("PatientPhoto", patientphoto); //就诊人照片二进制码-接口返回值 

                string serviceCode = "09010110";
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar(serviceCode, joTmp).ToString(), "插入医嘱共享信息"+ infotype);

                if (JsonHelper.parseIrisRtnValue(joRtn, out string errMsg) != 0)
                {
                    outParam = errMsg;
                    return -1;
                }
                else
                {
                    outParam = joRtn.ToString();
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = "医保平台插入医嘱共享信息异常" + ex.Message;
                return -1;
            }

        }

        #region 目录下载及对照
        /// <summary>
        /// 通过分页的方式查询医保目录
        /// </summary>
        /// <param name="currentPage"></param>
        /// <param name="pageSize"></param>
        /// <param name="irisCode"></param>
        /// <param name="directoryType"></param>
        public JObject getMIDirectoryByPagination(JObject jo)
        {
            string currentPage;
            string pageSize;
            string serviceCode;
            string directoryType;
            string directoryCode;
            string directoryName;
            string directoryDr;
            string approvalNO ;
            string manufacturer;
            try
            {
                currentPage = JsonHelper.getDestValue(jo, "currentPage");
                pageSize = JsonHelper.getDestValue(jo, "pageSize");
                serviceCode = JsonHelper.getDestValue(jo, "serviceCode");
                directoryType = JsonHelper.getDestValue(jo, "directoryType");
                directoryCode = JsonHelper.getDestValue(jo, "directoryCode");
                directoryName = JsonHelper.getDestValue(jo, "directoryName");
                directoryDr = JsonHelper.getDestValue(jo, "directoryDr");
                approvalNO = JsonHelper.getDestValue(jo, "approvalNO");
                manufacturer= JsonHelper.getDestValue(jo, "manufacturer");

                InvokeHelper invoker = new InvokeHelper();
                dynamic joInput = new JObject();
                joInput.code = serviceCode;
                dynamic joTmp = new JObject();
                JArray jaParmas = new JArray();
                joTmp.HospitalDr = Global.inf.hospitalDr;
                joTmp.InterfaceDr = directoryDr;
                joTmp.Code = directoryCode;
                joTmp.Name = directoryName;
                joTmp.ApprovalNO = approvalNO;
                joTmp.Manufacturer = manufacturer;

                jaParmas.Add(joTmp);
                joInput.Add("params", JArray.FromObject(jaParmas));
                JArray jaPagination = new JArray();
                joTmp = new JObject();
                joTmp.pageSize = pageSize;
                joTmp.currentPage = currentPage;
                joTmp.sortColumn = "";
                joTmp.sortOrder = "";
                joTmp.hisType = directoryType;
                jaPagination.Add(joTmp);
                joInput.Add("pagination", JArray.FromObject(jaPagination));

                return invoker.invokeInsuService(joInput.ToString(), "查询医保目录分页");
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "getDirectoryByPagination", ex.Message);
            }

        }

        /// <summary>
        /// 根据HisType获取当前目录最大版本号
        /// </summary>
        /// <param name="directoryType"></param>
        /// <returns></returns>
        public JObject getDirectoryMaxVersionNO(int directoryType)
        {
            try
            {
                dynamic joParam = new JObject();
                joParam.HospitalDr = Global.inf.hospitalDr;
                joParam.InterfaceDr = Global.inf.interfaceDr;
                joParam.HisType = directoryType + 1;
                JObject joInparam = JsonHelper.setIrisInpar("09010037", joParam);
                JObject joRtn = invoker.invokeInsuService(joInparam.ToString(), "获取版本最大号");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取版本号异常：", ex.Message);
            }
        }

        public JObject insertDictionary(JObject joData)
        {
            try
            {
                JObject joInparam = JsonHelper.setIrisInpar("09010073", joData);
                JObject joRtn = invoker.invokeInsuService(joInparam.ToString(), "插入字典表");
                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "插入字典表异常：", ex.Message);
            }

        }

        public JObject insertDictionaryDataDetail(JArray jaData)
        {
            try
            {
                dynamic joParam = new JObject();
                joParam.HospitalDr = Global.inf.hospitalDr;
                joParam.InterfaceDr = Global.inf.interfaceDr;
                JObject joInparam = JsonHelper.setIrisInpar("09010074", jaData);
                JObject joRtn = invoker.invokeInsuService( joInparam.ToString(),"插入字典明细表");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "插入字典明细表异常：", ex.Message);
            }

        }

        public JObject ConvertHISDir(JObject joHisRtnDir)
        {
            try
            {
                //传给医保平台，进行对照匹配
                dynamic  joParam = new JObject();
                joParam.TotalCount = joHisRtnDir["result"]["TotalCount"];
                joParam.HospitalDr = Global.inf.hospitalDr;
                joParam.InterfaceDr = Global.inf.interfaceDr;
                joParam.Data = joHisRtnDir["result"]["Data"];
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010057", joParam).ToString(), "转换HIS目录分页，显示对照状态及对照的医保编码");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "转换HIS目录分页异常：", ex.Message);
            }

        }

        public JObject GetMappedHISDir(JArray jaPagination, JArray jaParams)
        {
            try
            {
                //传给医保平台，进行对照匹配
                dynamic joParam = new JObject();
                joParam.pagination = jaPagination;
                joParam.session = Global.curEvt.jaSession;
                joParam.Add("params", jaParams);
                joParam.code = "09010058";
                JObject joRtn = invoker.invokeInsuService(joParam.ToString(), "获取已对照目录分页");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取已对照目录分页异常：", ex.Message);
            }
        }

        public JObject GetNoMappHISDir(JObject joHisRtnDir)
        {
            try
            {
                //传给医保平台，进行对照匹配
                dynamic joParam = new JObject();
                joParam.TotalCount = joHisRtnDir["result"]["TotalCount"];
                joParam.HospitalDr = Global.inf.hospitalDr;
                joParam.InterfaceDr = Global.inf.interfaceDr;
                joParam.Data = joHisRtnDir["result"]["Data"];
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010088", joParam).ToString(), "获取未对照目录");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取未对照目录异常：", ex.Message);
            }
        }

        public JObject GetNoMappHISDirTooLarge(JObject joHisRtnDir)
        {
            string OutParam = "";
            try
            {
                //数目量大的情况下需要简化 只取HisCode
                JArray ja = JArray.Parse(joHisRtnDir["result"]["Data"].ToString());

                JArray jaItem = new JArray();
                for (int i = 0; i < ja.Count; i++)
                {
                    JObject jo = new JObject();
                    jo.Add("itemCode", ja[i]["itemCode"].ToString());

                    jaItem.Add(jo);
                }

                //传给医保平台，进行对照匹配
                dynamic joParam = new JObject();
                joParam.TotalCount = joHisRtnDir["result"]["TotalCount"];
                joParam.HospitalDr = Global.inf.hospitalDr;
                joParam.InterfaceDr = Global.inf.interfaceDr;
                joParam.Data = jaItem; //joHisRtnDir["result"]["Data"];
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010088", joParam).ToString(), "获取未对照目录");

                //对返回的数目巨大的参数值进行处理
                JArray jaHisDirALL = JArray.Parse(joHisRtnDir["result"]["Data"].ToString()); //所有HIS项目
                JArray jaNoMappDir = JArray.Parse(joRtn["result"]["Data"].ToString()); //未对照项目 只有itemCode有值
                JArray jaNoMappItem = new JArray();

                for (int m = 0; m < jaHisDirALL.Count; m++)
                {
                    string HISCode = jaHisDirALL[m]["itemCode"].ToString();

                    for (int n = 0; n < jaNoMappDir.Count; n++)
                    {
                        string NoMappHISCode = jaNoMappDir[n]["itemCode"].ToString();

                        if (HISCode == NoMappHISCode)
                        {
                            JObject jo = new JObject();
                            jo = JObject.Parse(jaHisDirALL[m].ToString());

                            jaNoMappItem.Add(jo);
                        }
                    }
                }

                JObject joRtnNoMappedResult = new JObject();
                joRtnNoMappedResult.Add("TotalCount", joRtn["result"]["TotalCount"]);
                joRtnNoMappedResult.Add("Data", jaNoMappItem);

                JObject joRtnNoMapped = new JObject();
                joRtnNoMapped.Add("errorCode", joRtn["errorCode"]);
                joRtnNoMapped.Add("errorMessage", joRtn["errorMessage"]);
                joRtnNoMapped.Add("result", joRtnNoMappedResult);

                //MessageBox.Show("哈哈："+joRtnNoMapped.ToString());
                OutParam = JsonHelper.Compress(joRtnNoMapped);
                return joRtnNoMapped;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "获取未对照目录异常：", ex.Message);
            }
            finally
            {
                Global.writeLog_Iris("获取未对照目录信息DLL内部拼接:", "05111002接口服务的返回值 " + JsonHelper.Compress(joHisRtnDir), OutParam);
            }
        }

        public JObject UpdateDirectoryBySelf(JObject joIn)
        {
            try
            {
                //查询区域通用目录 
                MIIrisServices mIS = new MIIrisServices();
                JObject joRtnTY = mIS.getInterface_TY(Global.inf.interfaceDr.ToString(), "");
                string InsuCurrencyCataLogue = JsonHelper.getDestValue(joRtnTY, "InsuCurrencyCataLogue");  //通用目录编码 6
                string InterfaceName_TY = JsonHelper.getDestValue(joRtnTY, "InterfaceName_TY");            //通用目录接口名称  
                string HospName_TY = JsonHelper.getDestValue(joRtnTY, "HospitalName");                     //通用目录所属医院名称
                string HospitalDr_TY = JsonHelper.getDestValue(joRtnTY, "HospitalDr_TY");                  //通用目录所属医院ID

                JObject joParam = (JObject)joIn.DeepClone();
                if ((InsuCurrencyCataLogue != "") && (HospitalDr_TY != ""))
                {
                    joParam.Add("updateUserID", Global.user.ID);
                    joParam.Add("HospitalDr", HospitalDr_TY);
                    joParam.Add("InterfaceDr", InsuCurrencyCataLogue);
                }
                else
                {
                    joParam.Add("updateUserID", Global.user.ID);
                    joParam.Add("HospitalDr", Global.inf.hospitalDr);
                    joParam.Add("InterfaceDr", Global.inf.interfaceDr);
                }
                InvokeHelper invoker = new InvokeHelper();
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010035", joParam).ToString(), "手动修改医保目录表");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "手动修改医保目录表异常：", ex.Message);
            }

        }

        public JObject QueryTransactionLog(JObject joSqlStr)
        {
            try
            {

                InvokeHelper invoker = new InvokeHelper();
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010060", joSqlStr).ToString(), "查询交易日志（冲正）");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "查询交易日志（冲正）异常：", ex.Message);
            }

        }

        public JObject QuerySettlementInfo(JObject joSqlStr)
        {
            try
            {
                InvokeHelper invoker = new InvokeHelper();
                JObject joRtn = invoker.invokeInsuService(JsonHelper.setIrisInpar("09010059", joSqlStr).ToString(), "查询结算信息");

                return joRtn;
            }
            catch (Exception ex)
            {
                return JsonHelper.setExceptionJson(-1, "查询结算信息异常：", ex.Message);
            }
        }
        #endregion  

    }
}