接口改为富达模式

kyy

2 天以前 bd18a149bfd83807d7cbcf80a2384ef502184a96

接口改为富达模式

 WebApi/Gs.HostIIS/appsettings.json

@@ -6,12 +6,12 @@
    }
  },
  "AllowedHosts": "*",
 // "ConnectionStrings": "Data Source=172.100.1.114,12468;Initial Catalog=TEST_MES;User ID=sa;Password =FuDa@2025",
  "ConnectionStrings": "Data Source=172.16.2.238,12468;Initial Catalog=TEST_MES;User ID=sa;Password =FuDa@2025",
   "ConnectionStrings": "Data Source=172.100.1.114,12468;Initial Catalog=TEST_MES;User ID=sa;Password =FuDa@2025",
 // "ConnectionStrings": "Data Source=172.16.2.238,12468;Initial Catalog=TEST_MES;User ID=sa;Password =FuDa@2025",

  "TestErpUrl": "http://192.168.1.149:8066/WebService1.asmx/MesToErpinfoTest",
  "TestErpUrl2": "http://192.168.1.149:8066/WebService1.asmx/MesToErpUpdateFlag",
  "ProductionErpUrl": "http://192.168.1.149:8066/WebService1.asmx/mesToErpinfoFormal",
  "TestErpUrl": "http://172.100.1.114:8082/",
  "TestErpUrl2": "http://172.100.1.114:8082/",
  "ProductionErpUrl": "http://172.100.1.114:8082/",
  "ServicesPath": "Services",
  "LogPath": "logs",
  "UploadPath": "upload",

 WebApi/Gs.Sys/Services/FmController.cs

@@ -228,59 +228,214 @@
            return isAdmin;
        }

        /*       #region 发送erp新版本

               /// <summary>
               /// 
               /// </summary>
               /// <param name="model">keyType:1审核，0反审核</param>
               /// <returns></returns>
               [RequestMethod(RequestMethods.POST)]
               public string SendErp([FromBody] dynamic model)
               {
                   //string keyGuid = model.keyGuid; 原生主键
                   //string keyUserGuid = model.keyUserGuid;操作用户
                   //string keyProduce = model.keyProduce;存储过程名
                   //string keyTaskName = model.keyTaskName;任务名
                   //string keyChild = model.keyChild;任务子节点名
                   //string keyMeth = model.keyMeth;方法名
                   //string keyNo = model.keyNo;单据编号
                   int _rtnInt = 0;
                   string _rtnStr = "";
                   try
                   {
                       string _erpJson = GetErpParam(model);
                       if (_erpJson.Length <= 0)
                           return "-1读取erp参数失败！";
                       string keyUserGuid = model.keyUserGuid;
                       string keyGuid = model.keyGuid;
                       string keyNo = model.keyNo;
                       string idtype = model.idtype;//2仅仅是更新工单状态的时候有

                       if (keyGuid.Length != 36)
                           keyGuid = "00000000-0000-0000-0000-000000000000";
                       if (string.IsNullOrEmpty(idtype))
                           (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson, keyUserGuid, keyGuid, keyNo);
                       else
                           (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson, keyUserGuid, keyGuid, keyNo, 2);
                   }
                   catch (Exception ex)
                   {
                       Gs.Toolbox.LogHelper.Debug(this.ToString(), "Fm SendErp:" + ex.Message);
                       return "发送erp失败:" + ex.Message;
                   }
                   if (_rtnInt <= 0)
                   {
                       return "发送erp失败:" + _rtnStr;
                   }
                   return _rtnStr;
               }

               /// <summary>
               /// 构建erp参数
               /// </summary>
               /// <param name="model"></param>
               /// <returns></returns>
               private string GetErpParam(dynamic model)
               {
                   string keyGuid = model.keyGuid;
                   string keyUserGuid = model.keyUserGuid;
                   string keyProduce = model.keyProduce;
                   string keyTaskName = model.keyTaskName;
                   string keyChild = model.keyChild;
                   string keyMeth = model.keyMeth;
                   string keyNo = model.keyNo;
                   string idtype = model.idtype;//这个仅仅是更新工单状态的时候有

                   if (keyMeth.ToUpper() == "delete".ToUpper())
                       return "";
                   try
                   {
                       System.Data.DataSet dset = new System.Data.DataSet();
                       SqlParameter[] parameters =
                             {
                              new("@inOrderGuid", keyGuid),
                              new("@inEdtUserGuid", keyUserGuid),
                              new("@keyMeth", keyMeth.ToLower()),
                          };
                       dset = DbHelperSQL.RunProcedure(keyProduce, parameters, "0");
                       if (dset == null)
                           return "";
                       if (dset.Tables.Count <= 0)
                           return "";
                       if (dset.Tables[0].Rows.Count <= 0)
                           return "";
                       //这是普通的接口
                       if (string.IsNullOrEmpty(idtype))
                       {
                           string _mesGuid = dset.Tables[0].Rows[0][0].ToString();
                           dynamic _datajson = new ExpandoObject();
                           if (dset.Tables.Count > 1)
                           {
                               //这是这是普通的接口里的结案，结构和其它不一样
                               if (keyMeth.ToLower() == "toclose".ToLower() || keyMeth.ToLower() == "closure".ToLower() || keyMeth.ToLower() == "unfinish")
                               {
                                   _datajson = dset.Tables[1].Rows[0].RowToDynamic();
                               }
                               else
                               {
                                   _datajson = dset.Tables[0].Rows[0].RowToDynamic();
                                   List<dynamic> _lst = dset.Tables[1].TableToDynamicList();
                                   ((IDictionary<string, object>)_datajson)[keyChild] = _lst;
                               }
                           }
                           var _obj = new
                           {
                               mesid = _mesGuid,
                               taskname = keyTaskName,
                               optype = keyMeth,
                               datajson = JsonConvert.SerializeObject(_datajson),
                           };
                           return JsonConvert.SerializeObject(_obj);
                       }
                       //这是订单回传标识
                       List<dynamic> _datajson22 = new List<dynamic>();
                       dynamic _ob = new ExpandoObject();
                       _ob.ENTRY = dset.Tables[0].TableToDynamicList();
                       _datajson22.Add(_ob);
                       var _obj22 = new
                       {
                           taskname = keyTaskName,
                           idtype = idtype,
                           datajson = JsonConvert.SerializeObject(_datajson22),
                       };
                       return JsonConvert.SerializeObject(_obj22);
                   }
                   catch (Exception ex)
                   {
                       Gs.Toolbox.LogHelper.Debug(this.ToString(), ex.Message);
                       throw ex;
                   }
               }
               #endregion
       */

        #region 发送erp新版本

        /// <summary>
        /// 
        /// 发送数据到ERP系统
        /// </summary>
        /// <param name="model">keyType:1审核，0反审核</param>
        /// <returns></returns>
        /// <param name="model">包含以下字段的动态对象：
        /// - keyGuid: 原生主键
        /// - keyUserGuid: 操作用户GUID
        /// - keyProduce: 存储过程名
        /// - keyTaskName: 任务名
        /// - keyChild: 任务子节点名
        /// - keyMeth: 方法名（如add、update、delete、toclose等）
        /// - keyNo: 单据编号
        /// - keyUrl: 接口地址
        /// - idtype: 特殊操作类型标识（如工单状态更新）
        /// - keyType: 操作类型（1=审核，0=反审核）
        /// </param>
        /// <returns>成功返回ERP响应消息，失败返回错误描述</returns>
        /// <remarks>
        /// 将MES数据打包成ERP载荷并根据请求的操作类型推送
        /// 通过存储过程转换业务数据，调用InterfaceUtil推送到ERP
        /// </remarks>
        [RequestMethod(RequestMethods.POST)]
        public string SendErp([FromBody] dynamic model)
        {
            //string keyGuid = model.keyGuid; 原生主键
            //string keyUserGuid = model.keyUserGuid;操作用户
            //string keyProduce = model.keyProduce;存储过程名
            //string keyTaskName = model.keyTaskName;任务名
            //string keyChild = model.keyChild;任务子节点名
            //string keyMeth = model.keyMeth;方法名
            //string keyNo = model.keyNo;单据编号
            int _rtnInt = 0;
            string _rtnStr = "";
            try
            {
                // 构建ERP请求参数
                string _erpJson = GetErpParam(model);
                if (_erpJson.Length <= 0)
                    return "-1读取erp参数失败！";
                string keyUserGuid = model.keyUserGuid;
                string keyGuid = model.keyGuid;
                string keyNo = model.keyNo;
                string idtype = model.idtype;//2仅仅是更新工单状态的时候有

                if (keyGuid.Length != 36)
                    keyGuid = "00000000-0000-0000-0000-000000000000";
                string idtype = model.idtype; // 仅在更新工单状态时使用
                string keyUrl = model.keyUrl;
                if (string.IsNullOrEmpty(idtype))
                    (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson, keyUserGuid, keyGuid, keyNo);
                {
                    // 常规接口：按操作类型推送单条业务数据
                    (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson,
                        keyUserGuid, keyGuid, keyNo, 0, keyUrl);
                }
                else
                    (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson, keyUserGuid, keyGuid, keyNo, 2);
                {
                    // 带idtype的请求用于特殊流程（如关闭、反关闭），ERP需要额外的状态标记
                    (_rtnInt, _rtnStr) = InterfaceUtil.HttpPostErp(_erpJson,
                        keyUserGuid, keyGuid, keyNo, 2, keyUrl);
                }
            }
            catch (Exception ex)
            {
                Gs.Toolbox.LogHelper.Debug(this.ToString(), "Fm SendErp:" + ex.Message);
                // 记录ERP数据转换异常，便于定位存储过程或序列化问题
                Gs.Toolbox.LogHelper.Debug(this.ToString(),
                    "Fm SendErp:" + ex.Message);
                return "发送erp失败:" + ex.Message;
            }

            if (_rtnInt <= 0)
            {
                return "发送erp失败:" + _rtnStr;
            }

            return _rtnStr;
        }

        /// <summary>
        /// 构建erp参数
        /// 构建ERP参数（内部方法）
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        /// <param name="model">包含业务参数的动态对象</param>
        /// <returns>JSON格式的ERP参数字符串</returns>
        /// <remarks>
        /// 调用业务定义的存储过程将MES数据打包给ERP
        /// 根据keyMeth（操作方法）和idtype决定返回数据结构
        /// </remarks>
        private string GetErpParam(dynamic model)
        {
            string keyGuid = model.keyGuid;
@@ -290,19 +445,20 @@
            string keyChild = model.keyChild;
            string keyMeth = model.keyMeth;
            string keyNo = model.keyNo;
            string idtype = model.idtype;//这个仅仅是更新工单状态的时候有

            string idtype = model.idtype; // 仅在更新工单状态时使用
            if (keyMeth.ToUpper() == "delete".ToUpper())
                // 删除操作无需向ERP推送数据，只需返回空串
                return "";
            try
            {
                System.Data.DataSet dset = new System.Data.DataSet();
                SqlParameter[] parameters =
                      {
                       new("@inOrderGuid", keyGuid),
                       new("@inEdtUserGuid", keyUserGuid),
                       new("@keyMeth", keyMeth.ToLower()),
                   };
                {
                    new("@inOrderGuid", keyGuid),
                    new("@inEdtUserGuid", keyUserGuid),
                    new("@keyMeth", keyMeth.ToLower()),
                };
                // 调用业务定义的存储过程，将MES数据打包给ERP
                dset = DbHelperSQL.RunProcedure(keyProduce, parameters, "0");
                if (dset == null)
                    return "";
@@ -310,53 +466,69 @@
                    return "";
                if (dset.Tables[0].Rows.Count <= 0)
                    return "";
                //这是普通的接口
                // 常规接口处理逻辑
                if (string.IsNullOrEmpty(idtype))
                {
                    // 常规出参：第一张表是主数据，第二张表（若存在）是子表集合
                    string _mesGuid = dset.Tables[0].Rows[0][0].ToString();
                    dynamic _datajson = new ExpandoObject();
                    if (dset.Tables.Count > 1)
                    {
                        //这是这是普通的接口里的结案，结构和其它不一样
                        if (keyMeth.ToLower() == "toclose".ToLower() || keyMeth.ToLower() == "closure".ToLower() || keyMeth.ToLower() == "unfinish")
                        // 多表返回时，需要把子表集合挂到datajson中
                        // 结案操作的结构与其他不一样，特殊处理
                        if (keyMeth.ToLower() == "toclose".ToLower() ||
                            keyMeth.ToLower() == "closure".ToLower() ||
                            keyMeth.ToLower() == "unfinish")
                        {
                            _datajson = dset.Tables[1].Rows[0].RowToDynamic();
                        }
                        else
                        {
                            _datajson = dset.Tables[0].Rows[0].RowToDynamic();
                            List<dynamic> _lst = dset.Tables[1].TableToDynamicList();
                            ((IDictionary<string, object>)_datajson)[keyChild] = _lst;
                            List<dynamic> _lst =
                                dset.Tables[1].TableToDynamicList();
                            ((IDictionary<string, object>)_datajson)[keyChild] =
                                _lst;
                        }
                    }
                    var _obj = new
                    else if (dset.Tables.Count == 1)
                    {
                        mesid = _mesGuid,
                        taskname = keyTaskName,
                        optype = keyMeth,
                        datajson = JsonConvert.SerializeObject(_datajson),
                    };
                    return JsonConvert.SerializeObject(_obj);
                        _datajson = dset.Tables[0].Rows[0].RowToDynamic();
                    }

                    // var _obj = new
                    // {
                    //     mesid = _mesGuid,
                    //     taskname = keyTaskName,
                    //     optype = keyMeth,
                    //     datajson = JsonConvert.SerializeObject(_datajson),
                    // };
                    // return JsonConvert.SerializeObject(_obj);
                    return JsonConvert.SerializeObject(_datajson);
                }
                //这是订单回传标识

                // 订单回传标识处理逻辑（带idtype）
                List<dynamic> _datajson22 = new List<dynamic>();
                dynamic _ob = new ExpandoObject();
                _ob.ENTRY = dset.Tables[0].TableToDynamicList();
                _datajson22.Add(_ob);
                var _obj22 = new
                {
                    taskname = keyTaskName,
                    idtype = idtype,
                    datajson = JsonConvert.SerializeObject(_datajson22),
                };
                return JsonConvert.SerializeObject(_obj22);
                // var _obj22 = new
                // {
                //     taskname = keyTaskName,
                //     idtype = idtype,
                //     datajson = JsonConvert.SerializeObject(_datajson22),
                // };
                // return JsonConvert.SerializeObject(_obj22);
                return JsonConvert.SerializeObject(_datajson22);
            }
            catch (Exception ex)
            {
                // 记录ERP数据转换异常，便于定位存储过程或序列化问题
                Gs.Toolbox.LogHelper.Debug(this.ToString(), ex.Message);
                throw ex;
            }
        }

        #endregion



 WebApi/Gs.Toolbox/InterfaceUtil.cs

@@ -18,16 +18,19 @@
    /// <param name="hNo"></param>
    /// <param name="urlType">如果为2，则是更新工单状态</param>
    /// <returns>如果成功返回日志guid,否则返回串</returns>
    public static (int, string) HttpPostErp(string param, string edtUserGuid = "", string abtGuid = "", string hNo = "", int urlType = 0)
    public static (int, string) HttpPostErp(string param,
        string edtUserGuid = "", string abtGuid = "", string hNo = "",
        int urlType = 0, string keyUrl = "")
    {
        int _rtn = 0;
        string docNo = string.Empty;
        //日志详细，发送的时候，记录日志，存储过程调用的时候，再累加上mes业务的操作结果
        System.Text.StringBuilder sbLog = new System.Text.StringBuilder();
        sbLog.Append(DateTime.Now.ToString() + "开始发送");
        string strLogGuid = Guid.NewGuid().ToString();
        string url = AppSettingsHelper.getValueByKey("TestErpUrl");
        string url = AppSettingsHelper.getValueByKey("TestErpUrl") + keyUrl;
        if (urlType == 2)
            url = AppSettingsHelper.getValueByKey("TestErpUrl2");
            url = AppSettingsHelper.getValueByKey("TestErpUrl2") + keyUrl;
        HttpWebRequest request = null;
        StreamWriter requestStream = null;
        WebResponse response = null;
@@ -41,7 +44,9 @@
            request.Timeout = 150000;
            request.AllowAutoRedirect = false;
            request.ServicePoint.Expect100Continue = false;
            HttpRequestCachePolicy noCachePolicy = new HttpRequestCachePolicy(HttpRequestCacheLevel.NoCacheNoStore);
            HttpRequestCachePolicy noCachePolicy =
                new HttpRequestCachePolicy(HttpRequestCacheLevel
                    .NoCacheNoStore);
            request.CachePolicy = noCachePolicy;
            requestStream = new StreamWriter(request.GetRequestStream());
            requestStream.Write(param);
@@ -57,7 +62,8 @@
        }
        catch (Exception ex)
        {
            LogHelper.Debug(url, "HttpPostErp response:" + param + "，ex:" + ex.Message);
            LogHelper.Debug(url,
                "HttpPostErp response:" + param + "，ex:" + ex.Message);
            responseStr = ex.Message;
            _rtn = -1;
        }
@@ -67,51 +73,110 @@
            requestStream = null;
            response = null;
        }

        /*if (_rtn != -1)
              {
                  Result _result = JsonConvert.DeserializeObject<Result>(responseStr);
                  if ("200".Equals(_result.code))
                      _rtn = 1;
              }*/
      
        if (_rtn != -1)
        {
            Result _result = JsonConvert.DeserializeObject<Result>(responseStr);
            if ("200".Equals(_result.state))
                _rtn = 1;
                Result _result = JsonConvert.DeserializeObject<Result>(responseStr);
                // 新判断规则：status=0 且 message=Success 才算成功
                if (_result?.status == "0" && _result?.message == "Success")
                    _rtn = 1;
               docNo = _result.data.doc_no;
        }

        sbLog.Append("," + DateTime.Now.ToString() + "结束发送");
        if (_rtn > 0)
        {
            sbLog.Append(",发送成功");

            //发送成功反写erp单号
           
            SqlParameter[] parameters =
               {
                new("@hNo", hNo),
                new("@erpNo",docNo),
                new("@Api", keyUrl)  ,
                new("@in1", ""),
                new("@in2", ""),
               };
            DbHelperSQL.RunProcedure("[prc_Rev_ErpNo]", parameters);
        }
        else
            sbLog.Append(",发送失败,mes退出操作");
        try
        {
            SqlParameter[] parameters =
    {
            new("@edtUserGuid", edtUserGuid),
            new("@abtGuid", abtGuid),
            new("@abtTable", ""),
            new("@detail", sbLog.ToString()),
            new("@hNo", hNo),
            new("@RtnLogGuid", strLogGuid),
            new("@SendJson", param),
            new("@RtnJson", responseStr),
            new("@isSuccess", (_rtn>0?1:0)),
            new("@isErp", 1),
        };
            {
                new("@edtUserGuid", edtUserGuid),
                new("@abtGuid", abtGuid),
                new("@abtTable", ""),
                new("@detail", sbLog.ToString()),
                new("@hNo", hNo),
                new("@RtnLogGuid", strLogGuid),
                new("@SendJson", param),
                new("@RtnJson", responseStr),
                new("@isSuccess", (_rtn > 0 ? 1 : 0)),
                new("@isErp", 1),
            };
            DbHelperSQL.RunProcedure("[prc_log_create]", parameters);
        }
        catch (Exception ex)
        {
            LogHelper.Debug(url, "HttpPostErp 写入日志表" + ex.Message);
        }

        return (_rtn, (_rtn > 0 ? strLogGuid : responseStr));
    }


}


/// <summary>
/// 接口返回结果根对象
/// </summary>
public class Result
{
    /// <summary>
    /// 200成功，否则失败
    /// 状态码：0表示成功，-1表示失败
    /// </summary>
    public string? state { get; set; }
    public string? msg { get; set; }

    public string? status { get; set; }

    /// <summary>
    /// 状态描述：Success表示成功，失败时为具体异常信息
    /// </summary>
    public string? message { get; set; }

    /// <summary>
    /// 数据体：成功时返回到货单信息，失败时为具体异常信息
    /// </summary>
    public ResultData? data { get; set; }
}

/// <summary>
/// 接口返回的Data对象（强类型）
/// 对应JSON：{"doc_type_no":"370","doc_no":"20251209001","msg":"创建到货单成功."}
/// </summary>
public class ResultData
{
    /// <summary>
    /// 单据类型编号
    /// </summary>
    public string? doc_type_no { get; set; }

    /// <summary>
    /// 单据编号
    /// </summary>
    public string? doc_no { get; set; }

    /// <summary>
    /// 操作结果描述
    /// </summary>
    public string? msg { get; set; }
}