MedicalInsurance/BeiJingMI/InsuBusiness.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PTMedicalInsurance.Common;
using PTMedicalInsurance.Business;
using System.Windows.Forms;
using PTMedicalInsurance.Helper;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using PTMedicalInsurance.Variables;
using PTMedicalInsurance.Forms;
using System.IO;
using System.Reflection;
using System.Data;

namespace PTMedicalInsurance
{

    public class InsuBusiness : IInsuBusiness
    {
        //定义相关的变量
        private Patients patient;
        private Fees fee;
        private Settlements settlement;

        //json对象属性
        private JObject joInParam;
        private JArray jaSession ;
        private JArray jaParams;
        private JObject joParam;
        private JObject joInterface;

        //设置业务实例
        CenterBusiness cBus = new CenterBusiness();
        HisMainBusiness hBus = new HisMainBusiness();
        HisIrisServices hIS = new HisIrisServices();
        MIIrisServices mIS= new MIIrisServices();
        InvokeHelper invoker = new InvokeHelper();
        CardReader_HN CardRead = new CardReader_HN();
        ReadCardClass rcl = new ReadCardClass();

        private string businessType;
        private string operationType;  //RegisterOP 门诊挂号 SettlementOP门诊收费
        private string partialFlag;

        System.Type ComType = null;
        object ComInstance = null;

        public InsuBusiness()
        {
            Global.curEvt.path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            ComputerInfo comp = new ComputerInfo();
            Global.curEvt.mac = comp.GetMAC();
            Global.curEvt.ip = comp.GetIP(); //"10.1.4.100";  
            Global.pat.insuplc_admdvs = "";        //如果是NULL中心会报错
        }

        private int parseInparam(string inParam,out string errMsg)
        {
            errMsg = "";
            try
            {
                joInParam = JObject.Parse(inParam);
                jaSession = JArray.Parse(JsonHelper.getDestValue(joInParam, "session"));
                Global.curEvt.jaSession = jaSession;
                jaParams = JArray.Parse(JsonHelper.getDestValue(joInParam, "params"));
                joParam = JObject.FromObject(jaParams[0]);                
                joInterface = JObject.Parse(JsonHelper.getDestValue(joInParam, "interfaceinfo"));
                businessType = JsonHelper.getDestValue(joInParam, "businessType");
                operationType = JsonHelper.getDestValue(joInParam, "operationType");

                return 0;
            }
            catch (Exception ex)
            {
                errMsg = "parseInparam 解析入参异常：" + errMsg;
                return -1;
            }
        }
        
        /// <summary>
        /// 签到
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Init(string InParam)
        {
            string errMsg, rtnResult ="";
            JObject joRtn = new JObject();
            try
            {
                if (hBus.initEnvironment(InParam, out errMsg) != 0)
                {   
                    return JsonHelper.setExceptionJson(-100, "initEnvironment 失败", errMsg).ToString();
                }
                else
                {                   
                    if (mIS.isSigned(ref Global.curEvt.signno) != true)
                    {
                        //北京没有初始化
                        Global.curEvt.signno = DateTime.Now.ToString("yyyyMMddHHmmss");
                        //插入签到表
                        if (mIS.saveSignRecord(Global.curEvt.signno, out errMsg) != 0)
                        {
                            rtnResult = JsonHelper.setIrisReturnValue(0, "北京首信医保无签到接口,HIS签到成功但插入签到表失败:" + errMsg, null).ToString();
                        }
                        else
                        {
                            rtnResult = JsonHelper.setIrisReturnValue(0, "北京首信医保无签到接口,HIS签到成功", joRtn).ToString();
                        }                                               
                    }
                    else                    
                    {
                        rtnResult = JsonHelper.setIrisReturnValue(0, "初始化成功！", null).ToString();
                    }

                    return rtnResult;
                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-100, "Init 异常", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("初始化结果：" + rtnResult);
            }
        }

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="inParam"></param>
        /// <param name="outParam"></param>
        /// <returns></returns>
        private int init(string inParam, out string outParam)
        {
            string errMsg;
            outParam = "";
            try
            {
                //BS架构调用方式问题，每次调用都需要重新初始化
                JObject joInitRtn = JObject.Parse(Init(inParam));
                if (JsonHelper.parseIrisRtnValue(joInitRtn, out errMsg) != 0)
                {
                    outParam = JsonHelper.setExceptionJson(-100, "init(HIS医保环境初始化)", errMsg).ToString();
                    return -1;
                }
                else
                {
                    return 0;
                }
            }
            catch (Exception ex)
            {
                outParam = JsonHelper.setExceptionJson(-100, "init(HIS医保环境初始化)异常", ex.Message).ToString();
                return -1;
            }
        }

        /// <summary>
        /// 获取患者信息
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string GetPatientInfo(string InParam)
        {
            Global.writeLog("GetPatientInfo入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            int errCode;
            string errMsg, rtnResult = "",outParam;
            JObject joPatInfoRtn = new JObject();
            //BS架构调用方式问题，每次调用都需要重新初始化
            if (init(InParam,out outParam)!= 0)
            {
                rtnResult = outParam;
                return rtnResult;
            }
            JObject joInParam = JObject.Parse(InParam);
            string businessType = JsonHelper.getDestValue(joInParam,"businessType");
            Global.pat.admID = JsonHelper.getDestValue(joInParam, "params[0].admID");
            if (!string.IsNullOrEmpty(Global.pat.admID))
            {
                Global.pat.adm_Dr = int.Parse(Global.pat.admID);
            }

            try
            {
                switch (businessType)
                {
                    case "M1"://门诊读卡
                        {
                            //打开读卡窗口，操作员选择读卡类型后进行读卡器读卡，再进行1101获取参保信息
                            if (hBus.readCard(out outParam) != 0)
                            {                                
                                rtnResult = JsonHelper.setExceptionJson(-1, "读卡失败！", outParam).ToString();
                            }
                            else
                            {
                                string patInfo = outParam;
                                JObject joPatInfo = hBus.ConvertXMLToObject(outParam);

                                //展示患者信息界面
                                if (hBus.showPatInfo(joPatInfo, out outParam) != 0)
                                {
                                    rtnResult = outParam;
                                    MessageBox.Show(rtnResult);
                                    //return rtnResult;
                                }
                                else
                                {
                                    //赋值全局变量,统一异地和本地返回的参保信息
                                    hBus.setGlobalPatAfaterShowPatInfo(joPatInfo, out joPatInfoRtn, out errMsg);

                                    //在这里判断，建档的时候会直接拦截,因此加上判断条件
                                    //校验HIS姓名与医保姓名是否一致
                                    if (!string.IsNullOrEmpty(Global.pat.admID))
                                    {
                                        if (hBus.checkName(Global.pat.name, out errMsg) != 0)
                                        {
                                            rtnResult = JsonHelper.setExceptionJson(-1, "校验HIS与医保姓名是否一致", errMsg).ToString();
                                            return rtnResult;
                                        }
                                    }

                                    //插入患者本次就诊用的参保信息
                                    if (mIS.insertPatCurInsuInfo(joPatInfo, out outParam) != 0)
                                    {
                                        rtnResult = JsonHelper.setExceptionJson(-1, "插入患者参保信息失败，请联系管理员！", outParam).ToString();
                                        //return rtnResult;
                                    }
                
                                    rtnResult = JsonHelper.setIrisReturnValue(0, "", joPatInfoRtn).ToString();
                                   //return rtnResult;
                                }
                            }

                            break;
                        }
                    case "Z1"://住院读卡
                        {            
                            //打开读卡窗口，操作员选择读卡类型后进行读卡器读卡，再进行1101获取参保信息
                            if (hBus.readCard(out outParam) != 0)
                            {                                
                                rtnResult = JsonHelper.setExceptionJson(-1, "读卡失败！", outParam).ToString();       
                            }
                            else
                            {                           
                                string patInfo = outParam;
                                JObject joPatInfo = hBus.ConvertXMLToObject(outParam);

                                //展示患者信息界面
                                if (hBus.showPatInfo(joPatInfo, out outParam) != 0)
                                {
                                    rtnResult = outParam;
                                    MessageBox.Show(rtnResult);
                                    //return rtnResult;
                                }
                                else
                                {
                                    //赋值全局变量，统一异地和本地返回的参保信息
                                    hBus.setGlobalPatAfaterShowPatInfo(joPatInfo, out joPatInfoRtn, out errMsg);

                                    //在这里判断，建档的时候会直接拦截,因此加上判断条件
                                    //校验HIS姓名与医保姓名是否一致
                                    if (!string.IsNullOrEmpty(Global.pat.admID))
                                    {
                                        if (hBus.checkName(Global.pat.name, out errMsg) != 0)
                                        {
                                            rtnResult = JsonHelper.setExceptionJson(-1, "校验HIS与医保姓名是否一致", errMsg).ToString();
                                            return rtnResult;
                                        }
                                    }

                                    //插入患者本次就诊用的参保信息
                                    if (mIS.insertPatCurInsuInfo(joPatInfo, out outParam) != 0)
                                    {
                                        rtnResult = JsonHelper.setExceptionJson(-1, "插入患者参保信息失败，请联系管理员！", outParam).ToString();
                                        //return rtnResult;
                                    }

                                    rtnResult = JsonHelper.setIrisReturnValue(0, "", joPatInfoRtn).ToString();
                                    //return rtnResult;
                                }
                            }

                            break;
                        }
                    case "MedicalOrderSharing": //医嘱共享 MedicalOrderSharing MedicalOrderSharing
                        {
                            string type = JsonHelper.getDestValue(joInParam, "params[0].type");  //调用医嘱共享业务接口-00：查询门诊历史交易 01：参保人照片               
                            Global.pat.psn_no = JsonHelper.getDestValue(joInParam, "params[0].psn_No");
                            Global.inf.interfaceDr = int.Parse(JsonHelper.getDestValue(joInParam, "interfaceID"));                          
                            Global.pat.adm_Dr = int.Parse(JsonHelper.getDestValue(joInParam, "params[0].admID"));
                            Global.pat.name = JsonHelper.getDestValue(joInParam, "params[0].PatientName");
                            Global.pat.certNO = JsonHelper.getDestValue(joInParam, "params[0].certNO");
                            Global.user.ID = JsonHelper.getDestValue(joInParam, "session[0].userID");

                            JObject joRtn = mIS.getInterface_TY(Global.inf.interfaceDr.ToString(), "");
                            Global.inf.hospitalDr = int.Parse(JsonHelper.getDestValue(joRtn, "HospitalDr"));

                            //查询参保人员信息
                            string sqlStr = " SELECT TOP 1 * FROM BS_MIPatCurrentInsuInfo "
                                          + " WHERE Interface_Dr=" + Global.inf.interfaceDr
                                          + " AND Hospital_Dr=" + Global.inf.hospitalDr
                                          + " And PersonalNO='" + Global.pat.psn_no + "'";

                            JObject joSqlstr = new JObject();
                            joSqlstr.Add("sqlStr", sqlStr);

                            JArray jaParam = new JArray();
                            jaParam.Add(joSqlstr);
                            JObject joSettlQuery = new JObject();
                            joSettlQuery.Add("params", jaParam);
                            joSettlQuery.Add("code", "09010082");
                            JObject joInRtn = invoker.invokeInsuService(joSettlQuery.ToString(), "查询医保平台患者参保信息");

                            string sOther = JsonHelper.getDestValue(joInRtn, "result.rows[0].naty"); //0本地 1异地

                            //根据患者的医保编码长度来判断是否本地或异地患者
                            if (sOther == "0")                            
                            {
                                #region【调用医嘱共享业务接口-00：查询门诊历史交易 01：参保人照片】
                                JObject joMedOrderShare = new JObject();
                                //00调用医嘱共享接口查询门诊历史交易
                                if (hBus.MedInsuOrderShareInfo("00", out joMedOrderShare, out outParam) != 0)
                                {
                                    rcl.Close(ComType, ComInstance, out errMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-101, "MedInsuOrderShareInfo-00：", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    //调用IRIS服务插入医嘱共享信息表
                                    if (mIS.insertMedOrderShareInfo("00", joMedOrderShare, out outParam) != 0)
                                    {
                                        rcl.Close(ComType, ComInstance, out errMsg);
                                        rtnResult = JsonHelper.setExceptionJson(-102, "insertMedOrderShareInfo-00：", outParam).ToString();
                                        return rtnResult;
                                    }
                                }

                                //01调用医嘱共享接口查询患者照片
                                if (hBus.MedInsuOrderShareInfo("01", out joMedOrderShare, out outParam) != 0)
                                {
                                    rcl.Close(ComType, ComInstance, out errMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-101, "MedInsuOrderShareInfo-01：", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    //调用IRIS服务插入医嘱共享信息表
                                    if (mIS.insertMedOrderShareInfo("01", joMedOrderShare, out outParam) != 0)
                                    {
                                        rcl.Close(ComType, ComInstance, out errMsg);
                                        rtnResult = JsonHelper.setExceptionJson(-102, "insertMedOrderShareInfo-01：", outParam).ToString();
                                        return rtnResult;
                                    }
                                }

                                rtnResult = JsonHelper.setExceptionJson(0, "insertMedOrderShareInfo-01：", outParam).ToString();
                                return rtnResult;
                                #endregion
                            }
                            else
                            {
                                rtnResult = JsonHelper.setExceptionJson(0, "insertMedOrderShareInfo-03：", "异地患者不需要调用医嘱共享业务接口").ToString();
                                return rtnResult;
                            }

                            break;
                        }
                }

                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setIrisReturnValue(-1 , "GetPatientInfo发生异常;" + ex.Message,null).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("GetPatientInfo出参:" + JsonHelper.Compress(rtnResult));
            }            
        }

        /// <summary>
        /// 登记
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Register(string InParam)
        {            
            Global.writeLog("Register 入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }
                //获取pat
                hBus.GetRegPatInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "M2"://门诊登记
                        {
                            break;
                        }
                    case "M2C"://门诊登记撤销
                        {
                            break;
                        }
                    case "Z0"://住院修改
                        {
                            break;
                        }
                    case "Z2"://入院登记
                        {
                            string  regInParam = "";
                            Global.pat.admType = 2;
                            Global.pat.RYorCY = "1";
                            //需要HIS生成一个唯一的登记流水号前端展示出来 手工录入首信客户端
                            Global.pat.mdtrtID = "05155009" + DateTime.Now.ToString("yyMMddHHmmss"); //"05155009" + DateTime.Now.ToString("yyMMddHHmmss")

                            if (Global.pat.mdtrtID == "")
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "住院登记流水号不能为空!", outParam).ToString();
                                return rtnResult;
                            }

                            if (hBus.GetInPatRegisterFormNew(out regInParam) == 0)
                            {
                                //插入医保平台
                                JObject joRegInfo = JObject.Parse(JsonHelper.setCenterInpar_plain("2401", regInParam));

                                if (mIS.saveInpatRegisterInfoNew(joRegInfo, Global.pat.mdtrtID, out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "云平台保存登记信息", outParam).ToString();
                                    return rtnResult;
                                }

                                //返回登记信息，插入HIS                                
                                if (hIS.returnRegisterInfoNew(joRegInfo, Global.pat.mdtrtID, out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "HIS平台保存登记信息", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    rtnResult = JsonHelper.setIrisReturnValue(0, "登记成功", null).ToString();
                                    return rtnResult;
                                }
                            }
                            else
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "获取住院登记信息", regInParam).ToString();
                                return rtnResult;
                            }                          
                        }
                    case "Z2C"://入院登记取消
                        {
                            //北京无取消中心登记接口 直接返回中西取消成功后取消医保平台登记
                            if (mIS.cancleRegister(1, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "中心取消登记成功，但云医保平台取消失败，", outParam).ToString();
                                return rtnResult;
                            }

                            //取消HIS 登记
                            if (hIS.cancleRegister( out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "中心和云医保平台取消登记成功，但HIS取消失败，", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                //CM 20230602 删除医保平台医保费用明细上传表数据
                                mIS.deleteFee(out errMsg);
                                rtnResult = JsonHelper.setIrisReturnValue(0, "取消医保登记成功", null).ToString();
                                return rtnResult;
                            }
                        }
                    case "Z6"://出院登记
                        {
                            rtnResult = JsonHelper.setIrisReturnValue(0, "出院登记成功", null).ToString();
                            return rtnResult;
                        }
                    case "Z6C"://出院登记取消
                        {
                            rtnResult = JsonHelper.setIrisReturnValue(0, "取消出院登记成功", null).ToString();
                            return rtnResult;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "Register 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }
                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setIrisReturnValue(-1, "Register 发生异常;" + ex.Message, null).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("Register 出参:" + JsonHelper.Compress(rtnResult));
            }

            return "";
        }

        /// <summary>
        /// 费用上传
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string FeeUpload(string InParam)
        {
            Global.writeLog("FeeUpload 入参:" +  JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            int errCode;
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }
                //获取pat
                hBus.GetFeeHisInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "M3"://门诊费用上传
                        {
                            break;
                        }
                    case "M3C"://门诊费用撤销
                        {

                            break;
                        }
                    case "Z3"://入院费用上传
                        {
                            Global.pat.admType = 2;
                            //从医保平台获取患者详细的医保登记信息
                            if (mIS.queryRegisterInfo(1, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "查询患者云平台登记信息", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                JObject joReg = JObject.Parse(outParam);
                                Global.pat.medType = JsonHelper.getDestValue(joReg, "data.MedicalType");
                                Global.pat.insuType = JsonHelper.getDestValue(joReg, "data.InsuType");
                                Global.pat.gend = JsonHelper.getDestValue(joReg, "data.Gend");

                                if (Global.pat.gend == "")
                                    Global.pat.gend = "1";
                            }

                            //先取消中心费用传送
                            // cBus.cancleFeeUpload("2302", out errMsg);
                            //再删除医保传送表的数据
                            //mIS.deleteFee( out errMsg);

                            //开始进行费用传送
                            //调用HIS费用查询信息
                            if (hIS.getHisFee(Global.pat, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "获取HIS费用", outParam).ToString();
                                return rtnResult;
                            }

                            //调用医保平台转换
                            JObject joHisFee = JObject.Parse(outParam);
                            if (mIS.convertHisFeeWithInsuCode(joHisFee,out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "转换HIS费用", outParam).ToString();
                                return rtnResult;
                            }

                            JArray jaFeeDetail = JArray.Parse(JsonHelper.getDestValue(JObject.Parse(outParam), "data"));

                            //组织出院诊断和手术信息
                            if (hBus.writeDisToFile(out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "组织zyjd出院诊断和手术入参", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                //写入文件内容
                                Global.writeInFile("zyjd" + Global.pat.adm_Dr, outParam);       
                            }

                            //按指定条数分割后上传，保存，更新
                            if (hBus.writeFeeToFile(jaFeeDetail, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "组织zyfy出院费用入参", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                //写入文件内容
                                Global.writeInFile("zyfy" + Global.pat.adm_Dr, outParam);
                                rtnResult = JsonHelper.setIrisReturnValue(0, "住院费用【" + "zyfy" + Global.pat.adm_Dr + ".in】导出成功", null).ToString();
                                return rtnResult;
                            }
                        }
                    case "Z3C"://住院费用上传取消
                        {
                            rtnResult = JsonHelper.setIrisReturnValue(0, "住院费用上传取消成功", null).ToString();
                            return rtnResult;

                            //if (mIS.deleteFee(out errMsg) != 0)                            
                            //{
                            //    rtnResult = JsonHelper.setExceptionJson(-1, "删除医保平台费用", errMsg).ToString();
                            //    return rtnResult;
                            //}
                            //else
                            //{
                            //    rtnResult = JsonHelper.setIrisReturnValue(0, "住院费用上传取消成功", null).ToString();
                            //    return rtnResult;
                            //}
                        }

                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "FeeUpload 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "FeeUpload 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("FeeUpload 出参：" + JsonHelper.Compress(rtnResult));
            }

        }

        /// <summary>
        /// 结算
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string Settlement(string InParam)
        {
            Global.writeLog("Settlement 入参：" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult; 
                }

                //获取pat
                hBus.GetSettlementHisInfo(businessType, joInParam, out Global.pat);

                //MessageBox.Show("businessType：" + businessType + "|||Global.pat.partialFlag：" + Global.pat.partialFlag);

                switch (businessType)
                {
                    case "M4"://门诊预结算
                        {
                            OutpatientRegistration frmReg = new OutpatientRegistration();
                            if (frmReg.ShowDialog() == DialogResult.OK)
                            {
                                rtnResult = "调用结束";
                            }

                            break;
                        }
                    case "M4C"://门诊预结算撤销
                        {
                            break;
                        }
                    case "M5"://门诊结算
                        {                            
                            string patInfo = "";
                            string CloseMsg = "";
                            JObject joPatInfo = new JObject();
                            JObject jo = new JObject();    

                            if (hBus.readCardSettle(out ComType, out ComInstance, out outParam) != 0)
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-100, "readCard：", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                patInfo = outParam;
                                joPatInfo = hBus.ConvertXMLToObject(outParam);

                                //展示患者信息界面                                
                                //if (hBus.showPatInfo(joPatInfo, out outParam) != 0)
                                //{
                                //    rcl.Close(ComType, ComInstance, out CloseMsg);
                                //    rtnResult = JsonHelper.setExceptionJson(-100, "showPatInfoNew：", outParam).ToString();
                                //    return rtnResult;
                                //}

                                //患者信息赋值给全局变量
                                if (hBus.setGlobalPatAfaterShowPatInfo(joPatInfo, out jo, out errMsg) != 0)                                
                                {
                                    rcl.Close(ComType, ComInstance, out CloseMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-1, "取参保返回值赋值全局变量setGlobalPatAfaterShowPatInfo", errMsg).ToString();
                                    return rtnResult;
                                }

                                #region【调用医嘱共享业务接口-00：查询门诊历史交易 01：参保人照片】
                                if ((Global.inf.operationType == "RegisterOP") && (Global.pat.bMedInsuShare))    //挂号结算的时候调用                                                                                                                                    
                                {
                                    JObject joMedOrderShare = new JObject();

                                    //00调用医嘱共享接口查询门诊历史交易
                                    if (hBus.MedInsuOrderShareInfo("00", out joMedOrderShare, out outParam) != 0)
                                    {
                                        rcl.Close(ComType, ComInstance, out CloseMsg);
                                        rtnResult = JsonHelper.setExceptionJson(-100, "MedInsuOrderShareInfo-00：", outParam).ToString();
                                        return rtnResult;
                                    }
                                    else
                                    {
                                        //调用IRIS服务插入医嘱共享信息表
                                        if (mIS.insertMedOrderShareInfo("00", joMedOrderShare, out outParam) != 0)
                                        {
                                            rcl.Close(ComType, ComInstance, out CloseMsg);
                                            rtnResult = JsonHelper.setExceptionJson(-100, "insertMedOrderShareInfo-00：", outParam).ToString();
                                            return rtnResult;
                                        }
                                    }
                                    //01调用医嘱共享接口获取参保人员照片
                                    if (hBus.MedInsuOrderShareInfo("01", out joMedOrderShare, out outParam) != 0)
                                    {
                                        rcl.Close(ComType, ComInstance, out CloseMsg);
                                        rtnResult = JsonHelper.setExceptionJson(-100, "MedInsuOrderShareInfo-01：", outParam).ToString();
                                        return rtnResult;
                                    }
                                    else
                                    {
                                        //调用IRIS服务插入医嘱共享信息表
                                        if (mIS.insertMedOrderShareInfo("01", joMedOrderShare, out outParam) != 0)
                                        {
                                            rcl.Close(ComType, ComInstance, out CloseMsg);
                                            rtnResult = JsonHelper.setExceptionJson(-100, "insertMedOrderShareInfo-01：", outParam).ToString();
                                            return rtnResult;
                                        }
                                    }
                                }
                                #endregion
                            }                          

                            //校验HIS姓名与医保姓名是否一致
                            if (hBus.checkName(Global.pat.name, out errMsg) != 0)
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "校验HIS与医保姓名是否一致", errMsg).ToString();
                                return rtnResult;
                            }

                            //北京医保没有门诊挂号和门诊就诊信息上传交易，这里自定义一个登记流水号
                            Global.pat.mdtrtID = "HIS05155009" + DateTime.Now.ToString("yyMMddHHmmss");                 

                            //插入患者本次就诊用的参保信息
                            if (mIS.insertPatCurInsuInfo(joPatInfo, out outParam) != 0)
                            {
                                if (DialogResult.Yes != MessageBox.Show(outParam, " 是否继续？ ", MessageBoxButtons.YesNo))
                                {
                                    rcl.Close(ComType, ComInstance, out CloseMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-1, "插入患者本次就诊用的参保信息，请联系管理员！是否继续？", outParam).ToString();
                                    return rtnResult;
                                }
                            }

                            //显示门诊登记面板
                            //if (hBus.showOutPatRegisterForm(out outParam, out string presInfo) != 0)
                            //{
                            //    rcl.Close(ComType, ComInstance, out CloseMsg);
                            //    rtnResult = JsonHelper.setExceptionJson(-1, "显示门诊登记面板", outParam).ToString();
                            //    return rtnResult;
                            //}

                            //显示门诊登记面板和患者参保信息
                            if (hBus.showOutPatRegisterFormNew(joPatInfo, out outParam, out string presInfo) != 0)                            
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "显示门诊登记面板", outParam).ToString();
                                return rtnResult;
                            }

                            JObject joReg = JObject.Parse(outParam);
                            //组织医保平台插入门诊医保登记参数
                            JObject jo2201Inpar = JObject.Parse(JsonHelper.getDestProperty(joReg, "data"));
                            JObject jo2203Inpar = new JObject();
                            jo2203Inpar.Add("mdtrtinfo", JObject.Parse(JsonHelper.getDestValue(joReg, "mdtrtinfo")));
                            jo2203Inpar.Add("diseinfo", JArray.Parse(JsonHelper.getDestValue(joReg, "diseinfo")));                            

                            //插入门诊医保登记信息
                            if (mIS.saveOutpatRegisterInfo(jo2201Inpar, jo2203Inpar, out errMsg) != 0)
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "门诊登记医保平台保存失败，请联系管理员！", errMsg).ToString();
                                return rtnResult;
                            }

                            //组织费用明细参数
                            if (hBus.setFeeInParam(out outParam) != 0)
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "组织费用明细参数异常", outParam).ToString();
                                return rtnResult;
                            }

                            //费用分解 feeitemarray
                            string sMXXX = outParam;
                            string sCFXX = presInfo;

                            //预结算、divide费用分解、DivideNation异地门诊收费预结算
                            if (hBus.preSettlementOutPatOP(ComType, ComInstance, sCFXX, sMXXX, out outParam) != 0)                            
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "门诊医保预结算信息", outParam).ToString();
                                return rtnResult;
                            }

                            //正式结算、本地Trade结算确认、HISFinishedNotice本地门诊交易完成通知(本地对账)，异地TradeNation门诊结算、TradeCheckNation异地门诊交易实时对账
                            if (hBus.SettlementOPOutPat(ComType, ComInstance, sCFXX, sMXXX, out outParam) != 0)
                            {
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                rtnResult = JsonHelper.setExceptionJson(-1, "门诊医保正式结算信息", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                //挂号结算不弹框展示医保返回费用信息
                                if (Global.inf.operationType != "RegisterOP")
                                {
                                    //展示医保返回费用信息
                                    if (hBus.showMedInsuFeeOP(Global.Set.SettleStr, out outParam) != 0)
                                    {
                                        rcl.Close(ComType, ComInstance, out CloseMsg);
                                        rtnResult = JsonHelper.setExceptionJson(-1, "展示门诊结算返回费用明细信息错误", outParam).ToString();
                                        return rtnResult;
                                    }
                                }
                                                 
                                //返回给云医保平台结算信息                               
                                if (mIS.saveSettlementOP(Global.Set.SettleStr, Global.pat.iOtherProvLocal, out errMsg) != 0)
                                {
                                    rcl.Close(ComType, ComInstance, out CloseMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-1, "结算成功，但云医保平台保存失败", errMsg).ToString();
                                    return rtnResult;
                                } 
                                
                                //返回给HIS                                          
                                if (hIS.returnOutpatSettlementInfoOP(Global.Set.SettleStr, Global.pat.iOtherProvLocal, out outParam) != 0)
                                {
                                    rcl.Close(ComType, ComInstance, out CloseMsg);
                                    rtnResult = JsonHelper.setExceptionJson(-1, "返回门诊结算信息给HIS", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {                        
                                    //MessageBox.Show("returnToFrontEndAfterSettlementOP：" + Global.Set.SettleStr);

                                    rcl.Close(ComType, ComInstance, out CloseMsg);
                                    JObject joHisServieRtn = JObject.Parse(outParam);                                 
                                    hBus.returnToFrontEndAfterSettlementOP(Global.Set.SettleStr, Global.pat.iOtherProvLocal, joHisServieRtn, out outParam);

                                    //本地、异地门诊结算完成后 打印收据
                                    if (hBus.printBill(ComType, ComInstance, out string PrintMsg) != 0)                                    
                                    {
                                        rcl.Close(ComType, ComInstance, out CloseMsg);
                                        MessageBox.Show("收据打印异常,请在【医保结算查询打印】菜单重新打印：" + PrintMsg);
                                        rtnResult = JsonHelper.setIrisReturnValue(0, "结算成功,收据打印失败" + PrintMsg, JObject.Parse(outParam)).ToString();
                                    }
                                    else
                                    {
                                        rcl.Close(ComType, ComInstance, out CloseMsg);
                                        rtnResult = JsonHelper.setIrisReturnValue(0, "结算成功", JObject.Parse(outParam)).ToString();
                                    }

                                    return rtnResult;
                                }
                            }                          
                        }
                    case "M5C"://门诊结算撤销
                        {
                            string CloseMsg = "";

                            //hIS.cancleSettlementInfoHAHA(null, out string rr);
                            //rtnResult = JsonHelper.setIrisReturnValue(0, "取消结算成功", null).ToString();
                            //return rtnResult;

                            //撤销中心医保结算
                            if (hBus.cancelSettleMentRecord(out outParam) != 0)                            
                            {                                
                                rtnResult = JsonHelper.setExceptionJson(-1, "中心取消结算失败，", outParam).ToString();
                                rcl.Close(ComType, ComInstance, out CloseMsg);
                                return rtnResult;
                            }
                            else
                            {
                                string newSettleID = outParam; //退费成功中心返回的退费交易流水号tradeno

                                //退云医保平台结算
                                if (mIS.cancleSettlement(newSettleID, out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "取消平台结算信息", outParam).ToString();
                                    //return rtnResult;
                                }
                                
                                int admType = 3; //门诊结算
                                if (Global.inf.operationType == "RegisterOP")
                                    admType = 7; //挂号

                                //取消医保平台登记
                                if (mIS.cancleRegister(admType, out outParam) != 0)
                                {          
                                    rtnResult = JsonHelper.setExceptionJson(-1, "中心取消登记成功，但云医保平台取消失败，", outParam).ToString();
                                    //return rtnResult;
                                }
                                //退HIS结算
                                if (hIS.cancleSettlementInfo(joParam, out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "取消HIS结算信息", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    rtnResult = JsonHelper.setIrisReturnValue(0, "取消结算成功", null).ToString();
                                    return rtnResult;
                                }
                            }
                        }
                    case "Z4"://住院预结算
                        {                            
                            Global.pat.RYorCY = "2";
                            Global.pat.admType = 2;

                            rtnResult = JsonHelper.setExceptionJson(-100, "该接口不支持预结算！", null).ToString();
                            return rtnResult;
                        }
                    case "Z4C"://住院预结算撤销
                        {
                            rtnResult = JsonHelper.setExceptionJson(-100, "该接口不支持预结算取消！", null).ToString();
                            return rtnResult;
                        }
                    case "Z5"://住院结算
                        {
                            //Global.pat.hisSumAmt = "147.66";
                            Global.pat.hisPrePayment = "0.00"; //医保结算不加入预交金
                            Global.Set.settlID = "HIS05155009" + DateTime.Now.ToString("yyMMddHHmmss");

                            //弹框输入本次住院报销金额                            
                            if (hBus.InputInsuAmt(Global.pat.hisSumAmt, Global.pat.hisPrePayment, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "获取医保基金支付金额", outParam).ToString();
                                return rtnResult;
                            }
                            else
                            {
                                //从云医保平台获取患者详细的医保登记信息
                                if (mIS.queryRegisterInfo(1, out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "查询患者云平台登记信息", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    JObject joReg = JObject.Parse(outParam);
                                    Global.pat.medType = JsonHelper.getDestValue(joReg, "data.MedicalType");
                                    Global.pat.insuType = JsonHelper.getDestValue(joReg, "data.InsuType");
                                    Global.pat.mdtrtcertType= JsonHelper.getDestValue(joReg, "data.CertificateType");
                                    Global.pat.mdtrtcertNO = JsonHelper.getDestValue(joReg, "data.CertificateNO");
                                    Global.pat.DiseasecCode= JsonHelper.getDestValue(joReg, "data.MainDiagCode");
                                    Global.pat.DiseasecName = JsonHelper.getDestValue(joReg, "data.MainDiagName");
                                }

                                //返回给云医保平台结算信息
                                if (mIS.saveSettlementNewIP(out errMsg) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "医保结算成功,但云医保平台保存失败", errMsg).ToString();
                                    return rtnResult;
                                }
                                //返回给HIS
                                if (hIS.returnOutpatSettlementInfoNewIP(joParam,out outParam) != 0)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-1, "返回住院结算信息给HIS", outParam).ToString();
                                    return rtnResult;
                                }
                                else
                                {
                                    JObject joHisServieRtn = JObject.Parse(outParam);
                                    hBus.returnToFrontEndAfterSettlementNewIP(joHisServieRtn, out outParam);

                                    rtnResult = JsonHelper.setIrisReturnValue(0, "结算成功", JObject.Parse(outParam)).ToString();
                                    return rtnResult;
                                }
                            }
                               
                        }
                    case "Z5C"://住院结算撤销
                        {                            
                            //查询结算表
                            string sqlStr = " SELECT Top 1 * FROM  BS_MedInsuSettlement "
                                          + " WHERE billType = 1 and ValidFlag=1 and Hospital_Dr=" + Global.inf.hospitalDr
                                          + " and Adm_Dr='" + Global.pat.adm_Dr + "'"
                                          + " and MdtrtID='" + Global.pat.mdtrtID + "'"
                                          + " And SettlementID='" + Global.pat.settlID + "'"
                                          + " Order By ID DESC ";

                            JObject joSql = new JObject();
                            joSql.Add("sqlStr", sqlStr);
                            JObject joSettlInfo = mIS.QuerySettlementInfo(joSql);
                            if (JsonHelper.getDestValue(joSettlInfo, "result.data[0]") == "")                            
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "09010059查询医保平台结算记录表返回", "未查询到医保平台结算记录").ToString();
                                return rtnResult;
                            }

                            //Global.pat.insuplc_admdvs = JsonHelper.getDestValue(joSettlInfo, "result.data[0].insuplc_admdvs");
                            //Global.pat.SettID_YBJSB = JsonHelper.getDestValue(joSettlInfo, "result.data[0].SettlementID");
                            //if (Global.pat.settlID != Global.pat.SettID_YBJSB)
                            //{
                            //    rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", "前端传来结算SettlementID【" + Global.pat.settlID + "】与DLL通过SQL语句" + joSql
                            //                                              + ",获取到的SettlementID【" + Global.pat.SettID_YBJSB + "】不一致,可能存在HIS单边账,请联系医保开发人员处理该笔结算记录！").ToString();
                            //    return rtnResult;
                            //}

                            //取消平台结算信息
                            if (mIS.cancleSettlement(Global.pat.settlID, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "中心结算取消成功，医保平台结算信息取消失败！", outParam).ToString();
                                return rtnResult;
                            }

                            //取消HIS医保结算信息
                            if (hIS.cancleSettlementInfo(joParam, out outParam) != 0)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-1, "中心跟医保平台结算取消成功， 取消HIS结算信息失败！", outParam).ToString();
                                return rtnResult;
                            }

                            rtnResult = JsonHelper.setIrisReturnValue(0, "取消结算成功", null).ToString();
                            return rtnResult;
                        }
                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "Settlement 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("Settlement 出参：" + JsonHelper.Compress(rtnResult));
            }
        }

        /// <summary>
        /// 辅助交易
        /// </summary>
        /// <param name="InParam"></param>
        /// <returns></returns>
        public string AgentFun(string InParam)
        {
            Global.writeLog("AgentFun 入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            int errCode;
            string errMsg, rtnResult = "", outParam;
            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }

                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }

                //获取pat
                //hBus.GetFeeHisInfo(businessType, joInParam, out Global.pat);
                switch (businessType)
                {
                    case "BasicData"://基础数据维护
                        {
                            BasicData bd = new BasicData();

                            if (bd.ShowDialog() != DialogResult.OK)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出基础数据维护界面").ToString();
                                return rtnResult;
                            }

                            break;
                        }
                    case "Exception"://异常处理
                        {
                            //显示异常处理界面
                            HandleException frmEX = new HandleException();       

                            if (frmEX.ShowDialog() != DialogResult.OK)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出异常处理界面").ToString();
                                return rtnResult;
                            }

                            break;
                        }
                    case "CheckAndClearing"://对账清算
                        {
                            Clearing frmEX = new Clearing();
                           
                            if (frmEX.ShowDialog() != DialogResult.OK)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出对账清算界面").ToString();
                                return rtnResult;
                            }

                            break;
                        }
                    case "Print"://打印
                        {
                            //显示打印界面
                            SettlementBillPrint frmSettlList;
                            string insuAdmObj = JsonHelper.getDestValue(joInParam, "insuAdmObj");

                            if (insuAdmObj == "")
                            {
                                frmSettlList = new SettlementBillPrint();
                                //frmSettlList.ShowDialog();

                                if (frmSettlList.ShowDialog() != DialogResult.OK)
                                {
                                    rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出打印界面界面").ToString();
                                    return rtnResult;
                                }
                            }
                            else
                            {
                                JObject joInsuAdmObj = JObject.Parse(insuAdmObj);
                                frmSettlList = new SettlementBillPrint(joInsuAdmObj);
                                string groupID = JsonHelper.getDestValue((JObject)Global.curEvt.jaSession[0], "groupID");
                                string userName = JsonHelper.getDestValue((JObject)Global.curEvt.jaSession[0], "userName");

                                DataTable dt = (DataTable)frmSettlList.dgvSettlRecord.DataSource;
                                int i = frmSettlList.dgvSettlRecord.CurrentRow.Index;

                                string AdmID = dt.Rows[i]["AdmID"].ToString();
                                string PsnNo = dt.Rows[i]["PersonnelNO"].ToString();
                                string MdtrtID = dt.Rows[i]["MdtrtID"].ToString();
                                string SettlementID = dt.Rows[i]["SettlementID"].ToString();
                                Global.pat.adm_Dr = int.Parse(AdmID);

                                frmSettlList.btnPrint_Click(null, null);
                            }

                            return JsonHelper.setIrisReturnValue(0, "", null).ToString();
                            break;
                        }

                    case "Log"://日志
                        {
                            MessageBox.Show(businessType);
                            break;
                        }
                    case "RecordUpload"://上传记录
                        {
                            MessageBox.Show(businessType);
                            break;
                        }
                    case "HospitalRegister"://备案
                        {
                            ToRecordChoose Referral = new ToRecordChoose();
                            Referral.ShowDialog();
                            break;
                        }
                    case "PrescribeCirculation"://医保处方流转
                        {
                            //PrescriptionCirculation PresCir = new PrescriptionCirculation();
                            PrescriptionCirculation PresCir = new PrescriptionCirculation("0000833734");
                            //PresCir.WindowState = FormWindowState.Minimized;
                            if (PresCir.ShowDialog() != DialogResult.OK)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出提交外配处方信息界面").ToString();
                                return rtnResult;
                            }

                            break;
                        }
                    case "ElectronicSettlementCertificate"://医保电子票据信息上传
                        {
                            frmEcSettlCertUpload ecu = new frmEcSettlCertUpload();

                            if (ecu.ShowDialog() != DialogResult.OK)
                            {
                                rtnResult = JsonHelper.setExceptionJson(-100, "", "已退出医保电子票据信息上传界面").ToString();
                                return rtnResult;
                            }

                            break;
                        }

                    default:
                        {
                            rtnResult = JsonHelper.setExceptionJson(-1, "AgentFun 交易", "传入的业务编码不对！").ToString();
                            return rtnResult;
                        }
                }
                return rtnResult;
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "AgentFun 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("AgentFun 出参：" + JsonHelper.Compress(rtnResult));
            }
        }

        public string Download(string InParam)
        {
            Global.writeLog("Download 入参:" + JsonHelper.Compress(InParam));
            //设置返回值，错误信息
            int errCode;
            string errMsg, rtnResult = "", outParam;

            try
            {
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }

                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }

                dynamic joData = new JObject();

                joData.data = joParam["data"];
                //string code = (string)joInParam["code"];
                string funNO = (string)joParam["funNO"];
                switch (businessType)
                {

                    case "DirectoryDownload":
                        {
                            string downloadParam = JsonHelper.setCenterInpar(funNO, joData.ToString());
                            rtnResult = hBus.DownloadDirectory(funNO, downloadParam).ToString();
                            break;
                        }
                    case "DictionayDownload":
                        {
                            string downloadParam = JsonHelper.setCenterInpar(funNO, joData.ToString());
                            rtnResult = hBus.downDictionary(downloadParam);
                            break;
                        }
                }
                return rtnResult;

            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-100, "Download", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("Download 出参：" +  rtnResult);
            }


        }
        
        public string PlatformDirectConnect(string InParam)
        {           
            //设置返回值，错误信息
            int errCode;
            string errMsg, rtnResult = "", outParam;
            try
            {
                Global.writeLog("PlatformDirectConnect 入参:" + JsonHelper.Compress(InParam));
                //解析入参
                if (parseInparam(InParam, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "", errMsg).ToString();
                    return rtnResult;
                }

                Global.businessType = businessType;
                string funNO = JsonHelper.getDestValue(joInParam, "funNO");
                //BS架构调用方式问题，每次调用都需要重新初始化
                if (init(InParam, out outParam) != 0)
                {
                    rtnResult = outParam;
                    return rtnResult;
                }

                JObject joRtn = invoker.invokeCenterService(funNO, JsonHelper.setCenterInpar(funNO, joParam));
                if (JsonHelper.parseCenterRtnValue(joRtn, out errMsg) != 0)
                {
                    rtnResult = JsonHelper.setExceptionJson(-1, "平台直连错误", errMsg).ToString();
                    return rtnResult;
                }
                else
                {
                    rtnResult = JsonHelper.setIrisReturnValue(0, "", joRtn).ToString();
                    return rtnResult;
                }
            }
            catch (Exception ex)
            {
                rtnResult = JsonHelper.setExceptionJson(-1, "PlatformDirectConnect 交易", ex.Message).ToString();
                return rtnResult;
            }
            finally
            {
                Global.writeLog("PlatformDirectConnect 出参：" + JsonHelper.Compress(rtnResult));
            }
        }

    }
}