1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
using HH.WCS.Mobox3.pinggao.models;
using HH.WCS.Mobox3.pinggao;
using HH.WCS.Mobox3.pinggao.dispatch;
using HH.WCS.Mobox3.pinggao.util;
using HH.WCS.Mobox3.pinggao.wms;
using Newtonsoft.Json;
using Swashbuckle.Swagger;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using System.Web.UI.WebControls;
using System.Xml;
using System.Xml.Linq;
using static HH.WCS.Mobox3.pinggao.models.SapRoot;
using static HH.WCS.Mobox3.pinggao.api.ApiModel;
using static HH.WCS.Mobox3.pinggao.dispatch.NDC;
using static HH.WCS.Mobox3.pinggao.wms.ExpressionHelper;
 
namespace HH.WCS.Mobox3.pinggao.api
{
    public class TestController : System.Web.Http.ApiController
    {
        //   /// <summary>
        ///// 测试接口
        ///// </summary>
        ///// <param name="xmlData"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public HttpResponseMessage ReceiveXmlDatas([FromBody] XElement xmlData)
        //{
        //    if (xmlData == null)
        //    {
        //        LogHelper.Info("无数据:");
        //        return null;
        //    }
        //    XmlDocument xmlDoc = new XmlDocument();
        //    xmlDoc.LoadXml(xmlData.ToString());
        //    //将 XmlDocument 转换为 JSON 字符串
        //    string json1 = JsonConvert.SerializeXmlNode(xmlDoc);
        //    var data = JsonConvert.DeserializeObject<Root>(json1);
 
        //    // var json = JsonConvert.SerializeObject(new { id = 123, name = "jack" });
        //    var json = JsonConvert.SerializeObject(data.ROOT);
        //    string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
        //    var response = new HttpResponseMessage()
        //    {
        //        Content = new StringContent(xml, Encoding.UTF8, "application/xml")
        //    };
        //    return response;
 
        //}
        [HttpPost]
        public HttpResponseMessage ReceiveXmlDatas([FromBody] XElement xmlData)
        {
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlData.ToString());
            //将 XmlDocument 转换为 JSON 字符串
            string json1 = JsonConvert.SerializeXmlNode(xmlDoc);
            var data = JsonConvert.DeserializeObject<Root>(json1);
 
            // var json = JsonConvert.SerializeObject(new { id = 123, name = "jack" });
            var json = JsonConvert.SerializeObject(data.ROOT);
            string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
            var response = new HttpResponseMessage() {
                Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            };
            return response;
            // 处理XML数据
            // ...
 
 
        }
 
        public HttpResponseMessage Main()
        {
            string xmlData = @"<?xml version=""1.0"" encoding=""utf-8""?>
<ROOT>
    <WLPZ>
        <HEAD>
            <KEY>唯一标识</KEY>
            <GZRQ>过账日期</GZRQ>
            <GZRY>过账人员</GZRY>
            <GC>工厂</GC>
        </HEAD>
        <ITME>
            <WLPZBH>物料凭证编号</WLPZBH>
            <WLPZND>物料凭证年度</WLPZND>
            <WLPZZDXM>物料凭证中的项目</WLPZZDXM>
            <WLH>物料号</WLH>
            <JBJLDW>基本计量单位</JBJLDW>
            <SL>数量</SL>
            <CGPZH>采购凭证号</CGPZH>
            <CGPZXMBH>采购凭证项目编号</CGPZXMBH>
            <KCDD>库存地点</KCDD>
            <JYPBH>检验批编号</JYPBH>
            <KJPZSSRQ>会计凭证输入日期</KJPZSSRQ>
            <KJPZSRSJ>会计凭证输入时间</KJPZSRSJ>
            <PC>批次</PC>
            <ITEM1>
                <XLH>序列号</XLH>
            </ITEM1>
        </ITME> 
    </WLPZ>
</ROOT>";
 
            XmlDocument xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlData);
 
            XmlNodeList itemList = xmlDoc.SelectNodes("//ITME");
            XmlNodeList headList = xmlDoc.SelectNodes("//HEAD");
            var items = new List<Dictionary<string, object>>();
 
            foreach (XmlNode itemNode in itemList)
            {
                var itemDict = new Dictionary<string, object>();
                foreach (XmlNode childNode in itemNode.ChildNodes)
                {
                    itemDict.Add(childNode.Name, childNode.InnerText);
                }
                items.Add(itemDict);
            }
            ROOT rOOT = new ROOT();
            //rOOT.WLPZ = new WLPZ();
 
            ////多xml转类
            //List<ITME> ss = MapDictionariesToClasses<ITME>(items);
            //rOOT.WLPZ.ITME = ss;
 
            string json = JsonConvert.SerializeObject(new { ITME = items });
            string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
            var response = new HttpResponseMessage()
            {
                Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            };
            return response;
        }
        /// <summary>
        /// 单个
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dictionary"></param>
        /// <returns></returns>
        public static T MapDictionaryToClass<T>(Dictionary<string, object> dictionary) where T : new()
        {
            T obj = new T();
 
            foreach (var prop in typeof(T).GetProperties())
            {
                if (dictionary.TryGetValue(prop.Name, out object value))
                {
                    // 尝试将值转换为属性的类型并进行赋值
                    try
                    {
                        prop.SetValue(obj, value);
                    }
                    catch (Exception ex)
                    {
                        // 处理类型转换异常或其他异常
                        Console.WriteLine($"Error setting property {prop.Name}: {ex.Message}");
                    }
                }
            }
 
            return obj;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dictionaries"></param>
        /// <returns></returns>
        public static List<T> MapDictionariesToClasses<T>(List<Dictionary<string, object>> dictionaries) where T : new()
        {
            List<T> list = new List<T>();
 
            foreach (var dict in dictionaries)
            {
                T obj = new T();
                foreach (var prop in typeof(T).GetProperties())
                {
                    if (dict.TryGetValue(prop.Name, out object value))
                    {
                        try
                        {
                            prop.SetValue(obj, value);
                        }
                        catch (Exception ex)
                        {
                            // Handle the exception according to your needs
                            Console.WriteLine($"Error setting property {prop.Name}: {ex.Message}");
                        }
                    }
                }
                list.Add(obj);
            }
 
            return list;
        }
 
        public SimpleResult NdcRecives(string From, string To)
        {
            SimpleResult result = new SimpleResult();
            result.resultCode = 0;
            result.resultMsg = "成功";
            try
            {
                var db = new SqlHelper<object>().GetInstance();
                var locinfo = db.Queryable<Location>().Where(a => a.S_CODE == From).First();
                if (locinfo?.N_LOCK_STATE != 0)
                {
                    result.resultCode = 1;
                    result.resultMsg = "起始库位已锁";
                    LogHelper.Info("起始库位已锁");
                    return result;
                }
                var endlocinfo = db.Queryable<Location>().Where(a => a.S_CODE == To).First();
                if (endlocinfo?.N_LOCK_STATE != 0)
                {
                    result.resultCode = 1;
                    result.resultMsg = "终点库位已锁";
                    LogHelper.Info("终点库位已锁");
                    return result;
                }
 
                var wcsTask = new WCSTask
                {
                    S_OP_CODE = "",
                    S_OP_NAME = "",
                    S_CODE = WCSHelper.GenerateTaskNo(),
                    S_TYPE = "转运",
                    S_START_LOC = From,
                    S_START_AREA = locinfo.S_AREA_CODE,
                    S_START_WH = locinfo.S_WH_CODE,
                    S_END_LOC = endlocinfo.S_CODE,
                    S_END_AREA = endlocinfo.S_AREA_CODE,
                    S_END_WH = endlocinfo.S_WH_CODE,
                    S_SCHEDULE_TYPE = "NDC",
                    //N_CNTR_COUNT = 1,
                    S_CNTR_CODE = WMSHelper.GenerateCntrCodeNo()
                };
 
                bool res = WCSHelper.CreateTask(wcsTask);
                if (res)
                {
                    LocationHelper.LockLoc(locinfo.S_CODE, 2);
                    LocationHelper.LockLoc(endlocinfo.S_CODE, 1);
                }
 
            }
            catch (Exception ex)
            {
                throw;
            }
            return result;
 
        }
    }
 
 
}