using pinggaoWebApi.Services;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Configuration;
using System.Linq;
using System.Web;
using System.Web.Services;
using Newtonsoft.Json;
using System.Web.Http;
using System.Xml.Linq;
using System.Xml.Serialization;
using System.Net.Http;
using System.Text;
using System.Web.UI.WebControls;
using pinggaoWebApi.Models;
using static pinggaoWebApi.Controllers.SapRoot;
using Newtonsoft.Json.Linq;
using System.Web.Mvc;
using System.Xml;
using System.Data;
using pinggaoWebApi.Controllers;
using System.Threading.Tasks;
using System.IO;
using System.Data.SqlTypes;
using System.Text.RegularExpressions;
using System.Reflection;

namespace pinggaoWebApi
{

    /// <summary>
    /// WebService1 的摘要说明
    /// </summary>
    [WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
    [System.ComponentModel.ToolboxItem(false)]
    // 若要允许使用 ASP.NET AJAX 从脚本中调用此 Web 服务，请取消注释以下行。 
    // [System.Web.Script.Services.ScriptService]

    public class WebService : System.Web.Services.WebService
    {
        public static void EnsureArrayFormats(JObject json, string name)
        {
            foreach (var property in json.Properties())
            {
                // 如果当前属性名与指定名称匹配
                if (property.Name.Equals(name))
                {
                    // 如果属性值是 JObject，且不是 JArray，则将其包装成数组
                    if (property.Value is JObject)
                    {
                        JArray newArray = new JArray(property.Value);
                        property.Value = newArray;
                    }
                    // 如果属性值已经是 JArray，则不需要进一步操作
                    else if (property.Value is JArray)
                    {
                        // 已经是数组，无需操作
                    }
                    // 如果属性值是其他类型，则将其转换为单个元素的数组
                    else
                    {
                        JArray newArray = new JArray(property.Value);
                        property.Value = newArray;
                    }
                }
                // 如果属性值是 JObject，递归检查其子属性
                else if (property.Value is JObject)
                {
                    EnsureArrayFormats((JObject)property.Value, name);
                }
            }
        }
        /// <summary>
        /// 数据
        /// </summary>
        /// <param name="json"></param>
        /// <param name="name"></param>
        /// <param name="name1"></param>
        public static void EnsureArrayFormat(JObject json, string name, string name1)
        {
            foreach (var property in json.Properties())
            {
                if (property.Name == name || property.Name == name1)
                {
                    if (property.Value is JObject && !(property.Value is JArray))
                    {
                        // 若为单个对象，包装成数组
                        property.Value = new JArray(property.Value);
                    }
                }
                if (property.Value is JObject)
                {
                    // 递归处理子对象
                    EnsureArrayFormat((JObject)property.Value, name, name1);
                }
                else if (property.Value is JArray)
                {
                    // 递归处理数组中的每个元素
                    foreach (var item in (JArray)property.Value)
                    {
                        if (item is JObject)
                        {
                            EnsureArrayFormat((JObject)item, name, name1);
                        }
                    }
                }
            }
        }
        public static void EnsureArrayFormat(JObject json, string propertyName)
        {
            // 查找名为 propertyName 的属性
            JProperty property = json.Property(propertyName);

            if (property != null)
            {
                // 检查属性值是否为 JObject 类型（即单个对象）
                if (property.Value is JObject)
                {
                    // 将单个对象包装成数组
                    JArray newArray = new JArray(property.Value);
                    property.Value = newArray;
                }
                else if (property.Value is JArray)
                {
                    // 如果属性值已经是 JArray，则不需要做任何操作
                    // 但如果需要递归检查数组中的每个元素，可以在这里实现
                }
            }
        }
        /// <summary>
        /// 数据
        /// </summary>
        /// <param name="json"></param>
        /// <param name="name"></param>
        /// <param name="name1"></param>
        public static void EnsureArrayFormat(JObject json, string name, string name1, string name2)
        {
            foreach (var property in json.Properties())
            {
                if (property.Name == name || property.Name == name2)
                {
                    if (property.Value is JObject && !(property.Value is JArray))
                    {
                        // 若为单个对象，包装成数组
                        property.Value = new JArray(property.Value);
                    }
                }
                if (property.Value is JObject)
                {
                    // 递归处理子对象
                    EnsureArrayFormat((JObject)property.Value, name, name1, name2);
                }
                else if (property.Value is JArray)
                {
                    // 递归处理数组中的每个元素
                    foreach (var item in (JArray)property.Value)
                    {
                        if (item is JObject)
                        {
                            EnsureArrayFormat((JObject)item, name, name1, name2);
                        }
                    }
                }
            }
        }    
        public static void EnsureArrayFormats(JObject json, string name, string name1, string name2)
        {
            foreach (var property in json.Properties())
            {
                if (property.Name == name || property.Name == name2 || property.Name == name1)
                {
                    if (property.Value is JObject && !(property.Value is JArray))
                    {
                        // 若为单个对象，包装成数组
                        property.Value = new JArray(property.Value);
                    }
                }
                if (property.Value is JObject)
                {
                    // 递归处理子对象
                    EnsureArrayFormat((JObject)property.Value, name, name1, name2);
                }
                else if (property.Value is JArray)
                {
                    // 递归处理数组中的每个元素
                    foreach (var item in (JArray)property.Value)
                    {
                        if (item is JObject)
                        {
                            EnsureArrayFormat((JObject)item, name, name1, name2);
                        }
                    }
                }
            }
        }

        [WebMethod]
        public string InWorkArea(string data)
        {
            var result = "";
            LogHelper.Info($"接口 InWorkArea 输入参数{data}");

           
            return result;
        }
        /// <summary>
        /// 外采收货
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string WCReceiveXmlData(string ROOT)
        {

            LogHelper.Info("外采收货接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "WCReceiveXmlData");
            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "WLPZ", "HEAD", "ITEM");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<Root>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "WCReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"WCReceiveXmlData mobox返回参数{feedinfo}");

            var jsonObj = JsonConvert.DeserializeObject<WcReturnRoot.Root>(feedinfo);

            var json = JsonConvert.SerializeObject(jsonObj);
            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            LogHelper.Info("  外采收货" + xml);
            return xml;

        }


        /// <summary>
        /// 内采收货
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public  string NCReceiveXmlData(string ROOT)
        {
            LogHelper.Info("进来了" + ROOT);
            LogHelper.Info("内采收货" + ConfigurationManager.AppSettings["URL"].ToString() + "NCReceiveXmlData");

            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "WLPZ", "HEAD", "ITEM");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<NcDto.Root>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "NCReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"NCReceiveXmlData mobox返回参数{feedinfo}");
            var jsonObj = JsonConvert.DeserializeObject<WcReturnRoot.Root>(feedinfo);

            var json = JsonConvert.SerializeObject(jsonObj);
            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            LogHelper.Info("  内采收货返回" + xml);
            return xml;

        }
        /// <summary>
        /// 生产订单领料单(生成领料单)
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string LLDReceiveXmlData(string ROOT)
        {

            LogHelper.Info("生产订单领料单(生成领料单)" + ConfigurationManager.AppSettings["URL"].ToString() + "LLDReceiveXmlData");
            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "SCDDLL", "ITEM", "");
            //EnsureArrayFormat(jsonObject["ROOT"]["SCDDLL"] as JObject, "ITEM");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<CKDdto.RootModel>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "LLDReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"LLDReceiveXmlData mobox返回参数{feedinfo}");

            var jsonObj = JsonConvert.DeserializeObject<LLDReturnRoot.Root>(feedinfo);

            var json = JsonConvert.SerializeObject(jsonObj);

            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            LogHelper.Info("生产订单领料单(生成领料单)" + xml);
            return xml;

        }

        public static void EnsureArrayFormat2(JObject obj, string propertyName)
        {
            foreach (var prop in obj.Properties().ToList())
            {
                if (prop.Name == propertyName && prop.Value is JValue)
                {
                    obj[propertyName] = new JArray(prop.Value);
                }
                else if (prop.Value is JObject childObj)
                {
                    EnsureArrayFormat2(childObj, propertyName);
                }
                else if (prop.Value is JArray childArray)
                {
                    foreach (var item in childArray)
                    {
                        if (item is JObject itemObj)
                        {
                            EnsureArrayFormat2(itemObj, propertyName);
                        }
                    }
                }
            }
        }
        public class SingleOrArrayConverter<T> : JsonConverter
        {
            public override bool CanConvert(Type objectType)
            {
                return objectType == typeof(List<T>);
            }

            public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
            {
                // 先检查是否为null
                if (reader.TokenType == JsonToken.Null)
                {
                    return new List<T>();
                }

                // 处理空数组情况
                if (reader.TokenType == JsonToken.StartArray)
                {
                    try
                    {
                        var list = new List<T>();
                        while (reader.Read() && reader.TokenType != JsonToken.EndArray)
                        {
                            if (reader.TokenType == JsonToken.Null)
                            {
                                list.Add(default(T));
                            }
                            else
                            {
                                list.Add(serializer.Deserialize<T>(reader));
                            }
                        }
                        return list;
                    }
                    catch (JsonSerializationException)
                    {
                        // 如果数组解析失败，返回空列表
                        return new List<T>();
                    }
                }

                // 处理单个值情况
                if (reader.TokenType == JsonToken.String ||
                    reader.TokenType == JsonToken.Integer ||
                    reader.TokenType == JsonToken.Float ||
                    reader.TokenType == JsonToken.Boolean)
                {
                    try
                    {
                        return new List<T> { serializer.Deserialize<T>(reader) };
                    }
                    catch
                    {
                        return new List<T>();
                    }
                }

                // 处理对象情况（如 { "XLH": "value" }）
                if (reader.TokenType == JsonToken.StartObject)
                {
                    reader.Read(); // 跳过StartObject
                    if (reader.TokenType == JsonToken.PropertyName)
                    {
                        reader.Read(); // 跳过属性名
                        return ReadJson(reader, objectType, existingValue, serializer);
                    }
                }

                // 其他情况返回空列表
                return new List<T>();
            }

            public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
            {
                serializer.Serialize(writer, value);
            }
        }
        /// <summary>
        /// 其他出入库
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string OtherReceiveXmlData(string ROOT)
        {
            try
            {

               
                LogHelper.Info($"ROOT{ROOT}");
                LogHelper.Info("其他出入库" + ConfigurationManager.AppSettings["URL"].ToString() + "OtherReceiveXmlData");
                var ss = ConfigurationManager.AppSettings["URL"].ToString();
                //接收xml数据
                XmlDocument xmlDoc = new XmlDocument();
                xmlDoc.LoadXml(ROOT.ToString());

                //将 XmlDocument 转换为 JSON 字符串
                JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));


                LogHelper.Info($"jsonObject{JsonConvert.SerializeObject(jsonObject)}");

           
                // 处理特定字段，强制转换为数组
                EnsureArrayFormat(jsonObject, "WLPZ", "HEAD", "ITEM");


                EnsureArrayFormat2(jsonObject, "XLH");
                var settings = new JsonSerializerSettings
                {
                    Converters = { new SingleOrArrayConverter<string>() }
                };

                var result = JsonConvert.DeserializeObject<otherDto.Root>(jsonObject.ToString(), settings);

                var sss = jsonObject.ToString();
                ///  反序列化为RootWithArray
                var datas = JsonConvert.DeserializeObject<otherDto.Root>(jsonObject.ToString());



                var sdada = JsonConvert.SerializeObject(datas);
                LogHelper.Info($"111返回参数{sdada}");

                var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "OtherReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
                LogHelper.Info($"OtherReceiveXmlData mobox返回参数{feedinfo}");

                var jsonObj = JsonConvert.DeserializeObject<OtherReturnRoot.Root>(feedinfo);

                var json = JsonConvert.SerializeObject(jsonObj);
                string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;
                LogHelper.Info("其他出入库返回" + xml);
                return xml;
            }
            catch (Exception e)
            {
                LogHelper.Info("其他出入库返回" + e.Message);
                throw;
            }
          

        }
        ///// <summary>
        ///// 外采内采通用收货
        ///// </summary>
        ///// <param name="ROOT"></param>
        ///// <returns></returns>
        //[WebMethod]
        //[ValidateInput(false)] // 禁用请求验证
        //public string TYReceiveXmlData(string ROOT)
        //{

        //    LogHelper.Info("收货接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "WCReceiveXmlData");
        //    var ss = ConfigurationManager.AppSettings["URL"].ToString();
        //    //接收xml数据
        //    XmlDocument xmlDoc = new XmlDocument();
        //    xmlDoc.LoadXml(ROOT.ToString());

        //    //将 XmlDocument 转换为 JSON 字符串
        //    JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

        //    // 处理特定字段，强制转换为数组
        //    EnsureArrayFormat(jsonObject, "WLPZ", "HEAD", "ITEM");
        //    ///  反序列化为RootWithArray
        //    var wcdatas = JsonConvert.DeserializeObject<Root>(jsonObject.ToString());

        //    if (wcdatas.ROOT.WLPZ[0].HEAD.YDLX== "103"|| wcdatas.ROOT.WLPZ[0].HEAD.YDLX == "104")
        //    {

        //        var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "WCReceiveXmlData", JsonConvert.SerializeObject(wcdatas), "application/json");
        //        LogHelper.Info($"WCReceiveXmlData mobox返回参数{feedinfo}");



        //        var jsonObj = JsonConvert.DeserializeObject<WcReturnRoot.Root>(feedinfo);

        //        var json = JsonConvert.SerializeObject(jsonObj);
        //        string xml = JsonConvert.DeserializeXmlNode(json, "").OuterXml;

        //        return xml;
        //    }
        //    else
        //    {
        //        var ncdatas = JsonConvert.DeserializeObject<NcDto.Root>(jsonObject.ToString());
        //        var sss = JsonConvert.SerializeObject(wcdatas);
        //        var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "NCReceiveXmlData", JsonConvert.SerializeObject(ncdatas), "application/json");
        //        LogHelper.Info($"NCReceiveXmlData mobox返回参数{feedinfo}");

        //        var jsonObj = JsonConvert.DeserializeObject<WcReturnRoot.Root>(feedinfo);

        //        var json = JsonConvert.SerializeObject(jsonObj);
        //        string xml = JsonConvert.DeserializeXmlNode(json, "").OuterXml;

        //        return xml;
        //    }

        //}

        ///// <summary>
        /////内采收货
        ///// </summary>
        ///// <param name="ROOT"></param>
        ///// <returns></returns>
        //[WebMethod]
        //public ReturrnBackNC.Root NCReceiveXmlData(NcDto.ROOT2 ROOT)
        //{
        //    string result;

        //    LogHelper.Info("内采收货接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "NCReceiveXmlData");
        //    var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "NCReceiveXmlData", JsonConvert.SerializeObject(ROOT), "application/json");
        //    LogHelper.Info($"NCReceiveXmlData mobox返回参数{feedinfo}");
        //    var data = JsonConvert.DeserializeObject<ReturrnBackNC.ITEM>(feedinfo);

        //    // 假设data是一个已经初始化的ITEM对象
        //    ReturrnBackNC.ITEM data1 = new ReturrnBackNC.ITEM
        //    {
        //        KEY = data?.WLPZBH,
        //        WLPZBH = data?.WLPZBH,
        //        WLPZND = data?.WLPZND,
        //        MSGCODE = data?.MSGCODE,
        //        MSGDESP = data?.WLPZBH
        //    };
        //    if (string.IsNullOrEmpty(feedinfo))
        //    {
        //        data1.WLPZBH = "";
        //        data1.MSGCODE = "1";
        //        data1.MSGDESP = "未调通";
        //    }
        //    // 实例化ROOT对象，并将ITEM对象赋值给ROOT的Item属性
        //    ReturrnBackNC.ROOT root = new ReturrnBackNC.ROOT
        //    {
        //        ITEM = data
        //    };
        //    ReturrnBackNC.Root roots = new ReturrnBackNC.Root
        //    {
        //        ROOT = root
        //    };
        //    return roots;

        //}




        ///// <summary>
        /////其他出入库
        ///// </summary>
        ///// <param name="ROOT"></param>
        ///// <returns></returns>
        //[WebMethod]
        //public ReturrnBack.Root OtherReceiveXmlData(otherDto.ROOT3 ROOT)
        //{
        //    string result;

        //    LogHelper.Info("其他出入库接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "OtherReceiveXmlData");
        //    var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "OtherReceiveXmlData", JsonConvert.SerializeObject(ROOT), "application/json");
        //    LogHelper.Info($"OtherReceiveXmlData mobox返回参数{feedinfo}");
        //    var data = JsonConvert.DeserializeObject<ReturrnBack.ITEM>(feedinfo);

        //    // 假设data是一个已经初始化的ITEM对象
        //    ReturrnBack.ITEM data1 = new ReturrnBack.ITEM
        //    {
        //        WLPZBH = data?.WLPZBH,
        //        MSGCODE = data?.MSGCODE,
        //        MSGDESP = data?.WLPZBH
        //    };
        //    if (string.IsNullOrEmpty(feedinfo))
        //    {
        //        data1.WLPZBH = "";
        //        data1.MSGCODE = "1";
        //        data1.MSGDESP = "未调通";
        //    }
        //    // 实例化ROOT对象，并将ITEM对象赋值给ROOT的Item属性
        //    ReturrnBack.ROOT root = new ReturrnBack.ROOT
        //    {
        //        ITEM = data
        //    };
        //    ReturrnBack.Root roots = new ReturrnBack.Root
        //    {
        //        ROOT = root
        //    };
        //    return roots;

        //}




        /// <summary>
        /// 生产订单信息获取
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string OrderReceiveXmlData(string ROOT)
        {

            LogHelper.Info("生产订单信息获取" + ConfigurationManager.AppSettings["URL"].ToString() + "OrderReceiveXmlData");
            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "SCDD", "ITEM");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<OrderDto.Root>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "OrderReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"OtherReceiveXmlData mobox返回参数{feedinfo}");

            var jsonObj = JsonConvert.DeserializeObject<Orderback.Root>(feedinfo);

            var json = JsonConvert.SerializeObject(jsonObj);
            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            return xml;

        }
        /// <summary>
        ///生产订单信息获取
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        //[WebMethod]
        //public ReturrnBack.Root OrderReceiveXmlData(OrderDto.ROOT4 ROOT)
        //{
        //    string result;

        //    LogHelper.Info("生产订单信息获取接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "OrderReceiveXmlData");
        //    var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "OrderReceiveXmlData", JsonConvert.SerializeObject(ROOT), "application/json");
        //    LogHelper.Info($"OrderReceiveXmlData mobox返回参数{feedinfo}");
        //    var data = JsonConvert.DeserializeObject<ReturrnBack.ITEM>(feedinfo);

        //    // 假设data是一个已经初始化的ITEM对象
        //    ReturrnBack.ITEM data1 = new ReturrnBack.ITEM
        //    {
        //        WLPZBH = data?.WLPZBH,
        //        MSGCODE = data?.MSGCODE,
        //        MSGDESP = data?.WLPZBH
        //    };
        //    if (string.IsNullOrEmpty(feedinfo))
        //    {
        //        data1.WLPZBH = "";
        //        data1.MSGCODE = "1";
        //        data1.MSGDESP = "未调通";
        //    }
        //    // 实例化ROOT对象，并将ITEM对象赋值给ROOT的Item属性
        //    ReturrnBack.ROOT root = new ReturrnBack.ROOT
        //    {
        //        ITEM = data
        //    };
        //    ReturrnBack.Root roots = new ReturrnBack.Root
        //    {
        //        ROOT = root
        //    };
        //    return roots;

        //}






        /// <summary>
        /// 主物料信息获取
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string MaterReceiveXmlData(string ROOT)
        {
            try
            {

                LogHelper.Info("主物料信息获取接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "MaterReceiveXmlData");
            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "ITEM", "");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<MaterDto.Root6>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "MaterReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"MaterReceiveXmlData mobox返回参数{feedinfo}");

            var jsonObj = JsonConvert.DeserializeObject<WLReturnRoot.Root>(feedinfo);
          
            var json = JsonConvert.SerializeObject(jsonObj);
            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            return xml;
            }
            catch (Exception ex)
            {
                LogHelper.Info($"MaterReceiveXmlData 报错{ex.Message}");
                throw;
            }


        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ROOT"></param>
        /// <returns></returns>
        [WebMethod]
        [ValidateInput(false)] // 禁用请求验证
        public string GYSReceiveXmlData(string ROOT)
        {

            LogHelper.Info("供应商信息获取接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "GYSReceiveXmlData");
            var ss = ConfigurationManager.AppSettings["URL"].ToString();
            //接收xml数据
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(ROOT.ToString());

            //将 XmlDocument 转换为 JSON 字符串
            JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            EnsureArrayFormat(jsonObject, "GYSXX", "", "GYSHB");
            ///  反序列化为RootWithArray
            var datas = JsonConvert.DeserializeObject<GYSDto.Root9>(jsonObject.ToString());
            var sdada = JsonConvert.SerializeObject(datas);

            var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "GYSReceiveXmlData", JsonConvert.SerializeObject(datas), "application/json");
            LogHelper.Info($"MaterReceiveXmlData mobox返回参数{feedinfo}");

            var jsonObj = JsonConvert.DeserializeObject<GYSReturnRoot.Root>(feedinfo);

            var json = JsonConvert.SerializeObject(jsonObj);
            string xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + JsonConvert.DeserializeXmlNode(json, "").OuterXml;

            return xml;

        }
        ///// <summary>
        /////主物料信息获取
        ///// </summary>
        ///// <param name="ROOT"></param>
        ///// <returns></returns>
        //[WebMethod]
        //public ReturrnBack.Root MaterReceiveXmlData(MaterDto.ROOT5 ROOT)
        //{
        //    string result;

        //    LogHelper.Info("主物料信息获取接口地址" + ConfigurationManager.AppSettings["URL"].ToString() + "MaterReceiveXmlData");
        //    var feedinfo = HttpHelper.WebPost(ConfigurationManager.AppSettings["URL"].ToString() + "MaterReceiveXmlData", JsonConvert.SerializeObject(ROOT), "application/json");
        //    LogHelper.Info($"MaterReceiveXmlData mobox返回参数{feedinfo}");
        //    var data = JsonConvert.DeserializeObject<ReturrnBack.ITEM>(feedinfo);

        //    // 假设data是一个已经初始化的ITEM对象
        //    ReturrnBack.ITEM data1 = new ReturrnBack.ITEM
        //    {
        //        WLPZBH = data?.WLPZBH,
        //        MSGCODE = data?.MSGCODE,
        //        MSGDESP = data?.WLPZBH
        //    };
        //    if (string.IsNullOrEmpty(feedinfo))
        //    {
        //        data1.WLPZBH = "";
        //        data1.MSGCODE = "1";
        //        data1.MSGDESP = "未调通";
        //    }
        //    // 实例化ROOT对象，并将ITEM对象赋值给ROOT的Item属性
        //    ReturrnBack.ROOT root = new ReturrnBack.ROOT
        //    {
        //        ITEM = data
        //    };
        //    ReturrnBack.Root roots = new ReturrnBack.Root
        //    {
        //        ROOT = root
        //    };
        //    return roots;

        //}
    }
}