DBScript/01_DDL/01_DDL_TABLE_WGQ.sql

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,43 @@
use WGQ_WB19011_CORE
go

/*==============================================================*/
/* Table: Wms_outInStockRecord_V2_Mes                               */
/* Description: å‡ºå…¥åº“记录(为推送MES)                */
/* Author:shaocx                                                */
/* CreateTime:2025-09-17                                */
/*==============================================================*/
IF NOT EXISTS( SELECT 1 FROM SYSOBJECTS  WHERE ID = OBJECT_ID('Wms_outInStockRecord_V2_Mes') AND TYPE = 'U')
create table Wms_outInStockRecord_V2_Mes(
   ID            int       IDENTITY(1,1) NOT NULL, -- ä¸»é”®

   OutInFlagName      VARCHAR(10)   ,---  å‡ºå…¥åº“类型 1 å…¥åº“ 2 å‡ºåº“
   
   ListNo    NVARCHAR(128)    NULL , -- å‡ºå…¥å•å·
   Code    NVARCHAR(128)    NULL , -- åž‹æå”¯ä¸€ç¼–码
   Name    NVARCHAR(128)    NULL , -- ç‰©æ–™åç§°
   
   SerialNo    NVARCHAR(128)    NULL , -- åˆ†æ®µå·
   IssueProjectNo    NVARCHAR(128)    NULL , -- å‘放工程号
   
   PlaceCode   VARCHAR(100)     NULL , -- åº“位编码
   OccurrenceTime    datetime    NULL , -- å‘生时间
  
   
   IsSendToMes  int    NULL , -- æŽ¨é€çŠ¶æ€
   IsSendToMesStr VARCHAR(100)     NULL , -- æŽ¨é€çŠ¶æ€
   SendToMesCount  int    NULL , -- æŽ¨ç»™MES次数
   SendToMesTime datetime    null, -- æŽ¨ç»™MES时间
   MesRet  NVARCHAR(128)    NULL , -- MES返回结果
   
   
   Remark    NVARCHAR(128)    NULL , -- å¤‡æ³¨
   Creator        varchar(128)    null,-- åˆ›å»ºäºº
   CreateTime        datetime    null, -- åˆ›å»ºæ—¶é—´
   LastModifier        varchar(128)    null,-- ä¿®æ”¹äºº
   LastModifyTime   datetime    null -- ä¿®æ”¹æ—¶é—´
   
   constraint PK_Wms_outInStockRecord_V2_Mes primary key (ID) 
)
GO


 DBScript/01_DDL/02_DDL_TABLE_Edit_WGQ.sql

 DBScript/01_DDL/03_DDL_VIEW_WGQ.sql

 DBScript/01_DDL/04_DDL_INDEX_WGQ.sql

 DBScript/02_DML/01_InitData.sql

 DEmon/WebWIPAPI/Controllers/MesIntegrController.cs

@@ -1,12 +1,18 @@
using iWareDataCore.BASE.Entity;
using AutoMapper;
using iWareCommon.Common.Entity;
using iWareCommon.Utils;
using iWareDataCore.BASE.Entity;
using iWareDataCore.BASE.Service;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Web.Mvc;
using WebWIPAPI.Models;
using WebWIPAPI.Properties;
using WebWIPAPI.Utils;

using LogTextHelper = WebWIPAPI.Utils.LogTextHelper;

namespace WebWIPAPI.Controllers
{
@@ -17,35 +23,334 @@
    {

        /// <summary>
        /// åŒæ­¥ç«‹åº“的物料信息
        /// WCS>>WIP:每天定时WCS推送立库里的物料信息
        /// æä¾›åº“存信息
        /// </summary>
        /// <param name="sysCode"></param>
        /// <param name="wareHouseInfo"></param>
        /// <param name="processCardNumber"></param>
        /// <param name="wareHouseId"></param>
        /// <param name="timestamp"></param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult syncMaterialInfo()
        {
            var msg = "";
            var datalist = PlaceMaterialViewService.GetInstance().GetPlacePreview(out msg);

            var responseMessage = new ApiResponse<List<PlaceMaterialViewEntity>>()
            var responseMessage = new ApiResponse<List<PlaceMaterialViewEntity>>();
            try
            {
                Code = 200,
                Success = true,
                Message = "成功",
                Data = datalist,
            };

                var msg = "";
                var datalist = PlaceMaterialViewService.GetInstance().GetPlacePreview(out msg);
                if (!string.IsNullOrEmpty(msg))
                {
                    responseMessage = new ApiResponse<List<PlaceMaterialViewEntity>>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "获取异常:" + msg,
                        Data = null,
                    };
                }
                else
                {
                    responseMessage = new ApiResponse<List<PlaceMaterialViewEntity>>()
                    {
                        Code = 200,
                        Success = true,
                        Message = "成功",
                        Data = datalist,
                    };
                }
            }
            catch (Exception ex)
            {
                responseMessage = new ApiResponse<List<PlaceMaterialViewEntity>>()
                {
                    Code = 500,
                    Success = false,
                    Message = "异常:" + ex.Message,
                    Data = null,
                };
            }
            //将对象转化为json格式
            var responseStr = JsonConvert.SerializeObject(responseMessage);
            LogTextHelper.WriteLine(Resources.LogDir, "WIPAPI:{0},{1}, {2}", "syncMaterialInfo", "请求参数：" + "", "响应信息;" + responseStr);
            return Json(responseMessage, JsonRequestBehavior.DenyGet);
        }

        /// <summary>
        /// å¯¼å…¥å…¥åº“单
        /// </summary>
        /// <param name="inputmaterials"></param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult importInOrder(List<MaterialViewForMesEntity> importMaterials)
        {
            var responseMessage = new ApiResponse<string>();
            var msg = "";

            try
            {
                #region éªŒè¯
                if (importMaterials?.Count() == 0)
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "数据条数为0",
                        Data = null,
                    };
                    return ApiResponseHelper.ReturnApiResponse(responseMessage, "importInOrder", "");
                }
                if (importMaterials.Select(x => x.ListNo).Distinct().Count() != 1)
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "本次请求单号必须为同一值",
                        Data = null,
                    };
                    return ApiResponseHelper.ReturnApiResponse(responseMessage, "importInOrder", "");
                }
                #endregion

                #region ä¸šåŠ¡å¤„理

                //第一步：先新增到物料基础表
                List<MaterialViewEntity> materials = new List<MaterialViewEntity>();

                materials = ClassHelper.RotationMapping_Json<List<MaterialViewEntity>, List<MaterialViewForMesEntity>>(importMaterials);


                MaterialViewService.GetInstance().ImportExcelFromMes(materials, out msg);
                if (!string.IsNullOrEmpty(msg))
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "新增到物料基础表异常:" + msg,
                        Data = null,
                    };
                }
                else
                {
                    Thread.Sleep(400);//注意：休眠毫秒，用于数据库事务提交

                    string typeName = "入库";
                    List<InputMaterialEntity> inputmaterials = new List<InputMaterialEntity>();
                    inputmaterials = ClassHelper.RotationMapping_Json<List<InputMaterialEntity>, List<MaterialViewForMesEntity>>(importMaterials);
                    handler_importOutOrder(typeName, inputmaterials, out msg);

                    #endregion

                    if (!string.IsNullOrEmpty(msg))
                    {
                        responseMessage = new ApiResponse<string>()
                        {
                            Code = 500,
                            Success = false,
                            Message = "生成入库任务异常:" + msg,
                            Data = null,
                        };
                    }
                    else
                    {
                        responseMessage = new ApiResponse<string>()
                        {
                            Code = 200,
                            Success = true,
                            Message = "成功",
                            Data = null,
                        };
                    }
                }

            }
            catch (Exception ex)
            {
                responseMessage = new ApiResponse<string>()
                {
                    Code = 500,
                    Success = false,
                    Message = "异常:" + ex.Message,
                    Data = null,
                };
            }

            return ApiResponseHelper.ReturnApiResponse(responseMessage, "importInOrder", "");
        }


        /// <summary>
        /// å¯¼å…¥å‡ºåº“单
        /// </summary>
        /// <param name="inputmaterials"></param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult importOutOrder(List<InputMaterialEntity> inputmaterials)
        {
            var responseMessage = new ApiResponse<string>();
            try
            {
                var msg = "";

                #region éªŒè¯
                if (inputmaterials?.Count() == 0)
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "数据条数为0",
                        Data = null,
                    };
                    return ApiResponseHelper.ReturnApiResponse(responseMessage, "importOutOrder", "");
                }
                if (inputmaterials.Select(x => x.ListNo).Distinct().Count() != 1)
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "本次请求单号必须为同一值",
                        Data = null,
                    };
                    return ApiResponseHelper.ReturnApiResponse(responseMessage, "importOutOrder", "");
                }
                #endregion

                #region ä¸šåŠ¡å¤„理

                string typeName = "出库";
                handler_importOutOrder(typeName, inputmaterials, out msg);

                #endregion

                if (!string.IsNullOrEmpty(msg))
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 500,
                        Success = false,
                        Message = "生成出库任务异常:" + msg,
                        Data = null,
                    };
                }
                else
                {
                    responseMessage = new ApiResponse<string>()
                    {
                        Code = 200,
                        Success = true,
                        Message = "成功",
                        Data = null,
                    };
                }

            }
            catch (Exception ex)
            {
                responseMessage = new ApiResponse<string>()
                {
                    Code = 500,
                    Success = false,
                    Message = "异常:" + ex.Message,
                    Data = null,
                };
            }

            return ApiResponseHelper.ReturnApiResponse(responseMessage, "importOutOrder", "");
        }


        /// <summary>
        /// å…¬å…±å¯¼å…¥ å…¥åº“单或出库单
        /// </summary>
        /// <param name="typeName"></param>
        /// <param name="inputmaterials"></param>
        /// <param name="msg"></param>
        private void handler_importOutOrder(string typeName, List<InputMaterialEntity> inputmaterials, out string msg)
        {
            try
            {
                #region ä¸šåŠ¡å¤„理

                msg = "";
                //var inputmaterials = InputMaterialService.GetInstance().QueryByParam(new QueryParam { Filter = new Dictionary<string, object> { { "Status", "未生成" } } }, out msg);
                if (inputmaterials != null && inputmaterials.Count > 0)
                {
                    var placeMaterial = PlaceMaterialViewService.GetInstance().QueryByParam(new QueryParam { }, out msg);
                    var inoutdetails = InOutListDetailViewService.GetInstance().QueryByParam(new QueryParam { }, out msg);
                    List<string> codes = new List<string>();
                    inputmaterials.ForEach(x => codes.Add(x.Code));
                    List<int> ids = new List<int>();
                    var materials = InputMaterialService.GetInstance().GetIds(codes);
                    List<InOutListDetailEntity> detail = new List<InOutListDetailEntity>();
                    for (int i = 0; i < materials.Count; i++)
                    {
                        if (typeName == "入库")
                        {

                            if (placeMaterial.Select(x => x.MaterialId).Contains(materials[i].id))
                            {
                                msg = materials[i].code + "已存在立库中，不能添加到入库单明细中！";
                                break;
                            }
                            if (inoutdetails.Select(x => x.MaterialId).Contains(materials[i].id))
                            {
                                msg = materials[i].code + "已存在之前的入库单明细中，不能添加到当前入库单明细中！";
                                break;
                            }

                        }
                        else
                        {
                            if (!placeMaterial.Select(x => x.MaterialId).Contains(materials[i].id))
                            {
                                msg = materials[i].code + "不在立库中，不能添加到出库单明细中！";
                                break;
                            }
                            if (inoutdetails.Select(x => x.MaterialId).Contains(materials[i].id))
                            {
                                var inoutdeta = inoutdetails.FirstOrDefault(x => x.MaterialId == materials[i].id);
                                if (inoutdeta.TypeName == "出库")
                                {
                                    msg = materials[i].name + "已存在之前的出库单明细中，不能添加到当前出库单明细中！";
                                    break;
                                }
                            }
                        }
                        InOutListDetailEntity inoutdetail = new InOutListDetailEntity()
                        {
                            MaterialId = materials[i].id,
                            IsFinish = 0
                        };
                        detail.Add(inoutdetail);
                    }
                    if (!string.IsNullOrEmpty(msg))
                    {
                        return;
                    }
                    InOutListService.GetInstance().CreateListAndDetial(
                        new InOutListEntity
                        {
                            ListNo = inputmaterials.First().ListNo,
                            CreateTime = DateTime.Now,
                            TypeName = typeName,
                            Status = 0,
                            Remark = "",
                            InOutListDetail = detail
                        }, out msg);
                }
                else
                {
                    msg = ("请先确保出入库单物料明细不为空！");
                }


                #endregion
            }
            catch (Exception)
            {
                throw;
            }
        }

    }
}

 DEmon/WebWIPAPI/Global.asax.cs

@@ -1,4 +1,5 @@
using System;
using AutoMapper;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
@@ -19,6 +20,8 @@
            WebApiConfig.Register(GlobalConfiguration.Configuration);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);


        }
    }
}

 DEmon/WebWIPAPI/Utils/ApiResponseHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,38 @@
using Newtonsoft.Json;
using System.Web.Mvc;
using WebWIPAPI.Models;
using WebWIPAPI.Properties;


namespace WebWIPAPI.Utils
{
    /// <summary>
    /// API响应帮助类
    /// </summary>
    public class ApiResponseHelper
    {
        /// <summary>
        /// å°†æŒ‡å®šçš„泛型 API å“åº”对象序列化为 JSON æ ¼å¼æ—¥å¿—并记录，然后返回一个禁止 GET è¯·æ±‚çš„ JSON ç»“果。
        /// </summary>
        /// <typeparam name="T">ApiResponse æ³›åž‹ç±»åž‹å‚数，表示响应数据的类型</typeparam>
        /// <param name="response">要返回的 API å“åº”对象，包含状态码、消息和数据等信息</param>
        /// <param name="actionName">当前 API å¯¹åº”çš„ Action åç§°ï¼Œç”¨äºŽæ—¥å¿—记录，标识请求来源</param>
        /// <param name="requestParams">请求参数的描述信息，可以是参数对象的 JSON å­—符串或简要描述，默认为空字符串</param>
        /// <returns>
        /// è¿”回一个配置为禁止 GET è¯·æ±‚çš„ <see cref="JsonResult"/>，
        /// å…¶ä¸­åŒ…含传入的 <paramref name="response"/> æ•°æ®ï¼Œ
        /// å¹¶åœ¨æ—¥å¿—中记录 Action åç§°ã€è¯·æ±‚参数与响应信息。
        /// </returns>
        public static JsonResult ReturnApiResponse<T>(ApiResponse<T> response, string actionName, string requestParams = "")
        {
            var responseStr = JsonConvert.SerializeObject(response);
            LogTextHelper.WriteLine(Resources.LogDir, "WIPAPI:{0},{1}, {2}", actionName, "请求参数：" + requestParams, "响应信息：" + responseStr);
            return new JsonResult
            {
                Data = response,
                JsonRequestBehavior = JsonRequestBehavior.DenyGet
            };
        }

    }
}

 DEmon/WebWIPAPI/Utils/ClassHelper.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
using Newtonsoft.Json;

namespace WebWIPAPI.Utils
{
    public class ClassHelper
    {
        ///// <summary>
        ///// å®žä½“互转
        ///// </summary>
        ///// <typeparam name="T">新转换的实体</typeparam>
        ///// <typeparam name="S">要转换的实体</typeparam>
        ///// <param name="s"></param>
        ///// <returns></returns>
        //public static T RotationMapping<T, S>(S s)
        //{
        //    T target = Activator.CreateInstance<T>();
        //    var originalObj = s.GetType();
        //    var targetObj = typeof(T);
        //    foreach (PropertyInfo original in originalObj.GetProperties())
        //    {
        //        foreach (PropertyInfo t in targetObj.GetProperties())
        //        {
        //            if (t.Name == original.Name)
        //            {
        //                t.SetValue(target, original.GetValue(s, null), null);
        //            }
        //        }
        //    }
        //    return target;
        //}
        public static T RotationMapping_Json<T, S>(S s)
        {
            var oldStr = JsonConvert.SerializeObject(s);
            return JsonConvert.DeserializeObject<T>(oldStr);
        }


    }
}

 DEmon/WebWIPAPI/Web.config

@@ -40,4 +40,14 @@
    <add name="DbModelLog" connectionString="data source=.;initial catalog=WGQ_WB19011_LOG;user id=sa;password=123abc.com;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
    <add name="DbModelCore" connectionString="data source=.;initial catalog=WGQ_WB19011_CORE;user id=sa;password=123abc.com;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="Autofac" publicKeyToken="17863af14b0044da" culture="neutral" />
        <bindingRedirect oldVersion="0.0.0.0-4.8.1.0" newVersion="4.8.1.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>


</configuration>

 DEmon/WebWIPAPI/WebWIPAPI.csproj

@@ -41,6 +41,9 @@
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="AutoMapper, Version=6.2.0.0, Culture=neutral, PublicKeyToken=be96cd2c38ef1005, processorArchitecture=MSIL">
      <HintPath>..\packages\AutoMapper.6.2.0\lib\net45\AutoMapper.dll</HintPath>
    </Reference>
    <Reference Include="EntityFramework, Version=6.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\dll\EntityFramework.dll</HintPath>
@@ -49,9 +52,14 @@
      <HintPath>..\dll\EntityFramework.SqlServer.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\packages\Newtonsoft.Json.4.5.11\lib\net40\Newtonsoft.Json.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web.DynamicData" />
    <Reference Include="System.Web.Entity" />
    <Reference Include="System.Web.ApplicationServices" />
@@ -70,9 +78,6 @@
    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <Private>True</Private>
      <HintPath>..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
    </Reference>
    <Reference Include="Newtonsoft.Json">
      <HintPath>..\packages\Newtonsoft.Json.4.5.11\lib\net40\Newtonsoft.Json.dll</HintPath>
    </Reference>
    <Reference Include="System.Net.Http">
    </Reference>
@@ -127,6 +132,8 @@
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="Utils\ApiResponseHelper.cs" />
    <Compile Include="Utils\ClassHelper.cs" />
    <Compile Include="Utils\LogTextHelper.cs" />
  </ItemGroup>
  <ItemGroup>
@@ -165,6 +172,9 @@
      <Name>iWareDataCore</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <PropertyGroup>
    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
@@ -179,7 +189,7 @@
    <VisualStudio>
      <FlavorProperties GUID="{349c5851-65df-11da-9384-00065b846f21}">
        <WebProjectProperties>
          <UseIIS>True</UseIIS>
          <UseIIS>False</UseIIS>
          <AutoAssignPort>False</AutoAssignPort>
          <DevelopmentServerPort>47533</DevelopmentServerPort>
          <DevelopmentServerVPath>/</DevelopmentServerVPath>

 DEmon/WebWIPAPI/packages.config

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="AutoMapper" version="6.2.0" targetFramework="net45" />
</packages>

 DEmon/iWareCc/Service1.cs

@@ -413,6 +413,8 @@
            //ReSendThread.Name = "向WIP重新推送报文";
            //StartThread(ReSendThread);

            //开启推送给MES的出入库完成线程 ã€Editby shaocx,2025-09-17】
            new Thread(mesDataTranfficForRealMes.Handler).Start();

        }

@@ -445,7 +447,7 @@
            //结束生成入库主任务的线程
            CloseThread(CreatMainTaskInThread);

              //结束生成出库主任务的线程
            //结束生成出库主任务的线程
            CloseThread(CreatMainTaskOutThread);

            //关闭分解任务的线程
@@ -516,8 +518,8 @@

            var s = (StackerEntity)stacker;
            //LogTextHelper.WriteLine(Resources.LogDir, "获取堆垛机{0}状态线程已开启", s.Equipment.EquipName);
            var items = new string[] 
            {           
            var items = new string[]
            {
                s.OpcReadItems.SrmNo,// 1Srm编号
                s.OpcReadItems.Mode,// 2任务号 
                s.OpcReadItems.Alarm,// 3告警
@@ -857,7 +859,7 @@
                    {
                        gateService.HandleMsgSCReceive(gateService.ReadFromDatagramPoolSCReceive());
                    }
                    else 
                    else
                    {
                        gateService.HandleMsgReceive(gateService.ReadFromDatagramPoolReceive());
                        gateService.HandleMsgAlarmReceive(gateService.ReadFromDatagramPoolAlarmReceive());
@@ -928,20 +930,20 @@
        /// </summary>
        private void CreateMainInTask()
        {
               var c = (ConveyorEntity)CacheEntity.Conveyors.Find(x => x.Equipment.EquipName == "conveyor1");
               var mainTaskContainer = new MainTaskContainer();
               var ç”Ÿæˆå…¥åº“主任务 = new æ ¹æ®æ‰«ç ç”Ÿæˆå…¥åº“主任务(c, mainTaskContainer);
               var ä¿å­˜ç”Ÿæˆçš„任务 = new ä¿å­˜ç”Ÿæˆçš„入库任务(c, mainTaskContainer);
               ç”Ÿæˆå…¥åº“主任务.NextHandler = ä¿å­˜ç”Ÿæˆçš„任务;
            var c = (ConveyorEntity)CacheEntity.Conveyors.Find(x => x.Equipment.EquipName == "conveyor1");
            var mainTaskContainer = new MainTaskContainer();
            var ç”Ÿæˆå…¥åº“主任务 = new æ ¹æ®æ‰«ç ç”Ÿæˆå…¥åº“主任务(c, mainTaskContainer);
            var ä¿å­˜ç”Ÿæˆçš„任务 = new ä¿å­˜ç”Ÿæˆçš„入库任务(c, mainTaskContainer);
            ç”Ÿæˆå…¥åº“主任务.NextHandler = ä¿å­˜ç”Ÿæˆçš„任务;

                while (true)
            while (true)
            {
                if (CacheEntity.IsAutoRun)
                {
                    if (CacheEntity.IsAutoRun)
                    {
                        ç”Ÿæˆå…¥åº“主任务.Handle();
                    }
                    Thread.Sleep(1000);
                    ç”Ÿæˆå…¥åº“主任务.Handle();
                }
                Thread.Sleep(1000);
            }
        }
        /// <summary>
        /// ç”Ÿæˆå‡ºåº“主任务
@@ -1287,7 +1289,7 @@
                {
                    try
                    {
                       // string stackerName = Enum.GetName(typeof(EEquipmentCnName), EEquipmentCnName.stacker1);
                        // string stackerName = Enum.GetName(typeof(EEquipmentCnName), EEquipmentCnName.stacker1);
                        var reports = dbModel.COUNTStackerReports.Where(x => x.isfinished == (int)EYesOrNo.否).ToList();
                        var stacker = CacheEntity.Stackers.FirstOrDefault(x => x.Equipment.EquipName == "stacker1");
                        var unfinishedReport = reports.FirstOrDefault(x => x.name == stacker.Equipment.EquipName);

 DEmon/iWareCc/SystemInteraction/HTTPService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,493 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Text;

namespace iWareCc
{
    public class HTTPService
    {
        private string BaseURI = "";
        public HTTPService(string baseURI)
        {
            this.BaseURI = baseURI;
        }

        #region GET调用webapi公共方法

        /// <summary>
        /// é€šè¿‡GET方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T getContent<T>(string url, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                using (HttpResponseMessage response = client.GetAsync(url).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T result = JsonConvert.DeserializeObject<T>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡GET方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string getContentForString(string url, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                using (HttpResponseMessage response = client.GetAsync(url).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常,response:" + JsonConvert.SerializeObject(response));
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "},response:" + JsonConvert.SerializeObject(response));
                    }
                }
            }
            catch
            {
                throw;
            }
        }
        #endregion

        #region POST调用webapi公共方法

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <typeparam name="T2">出参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T2 postContent<T, T2>(string url, T parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.DefaultRequestHeaders.Add("Authorization", "123456");
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T2 result = JsonConvert.DeserializeObject<T2>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForString(string url, IDictionary<string, string> parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForString(string url, string parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);
                var ee = new { name = parameter };
                if (parameter=="")
                {
                    parameter = ee.ToString();
                }
              
                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        return response.StatusCode.ToString();
                       // throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务(AGV专用)
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForStringForAgv(string url, string parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);
                var ee = new { name = parameter };
                if (parameter == "")
                {
                    parameter = ee.ToString();
                }

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    var result = response.Content.ReadAsStringAsync().Result;
                    return result;
                }
            }
            catch (Exception ex)
            {
                throw;
            }
        }


        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string postContentForStringWithToken(string url, string parameter,
            Guid requestId, string token, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.DefaultRequestHeaders.Add("Authorization", token.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PostAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        #endregion

        #region PUT调用webapi公共方法

        /// <summary>
        /// é€šè¿‡PUT方法调用HTTP服务
        /// </summary>
        /// <typeparam name="T">入参类型</typeparam>
        /// <typeparam name="T2">出参类型</typeparam>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public T2 putContent<T, T2>(string url, T parameter, Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var str_result = response.Content.ReadAsStringAsync().Result;
                        T2 result = JsonConvert.DeserializeObject<T2>(str_result);
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡PUT方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string putContentForString(string url, IDictionary<string, string> parameter,
            Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                string str = JsonConvert.SerializeObject(parameter);
                var httpContent = new StringContent(str, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }

        /// <summary>
        /// é€šè¿‡POST方法调用HTTP服务
        /// </summary>
        /// <param name="url">服务地址</param>
        /// <param name="parameter">入参字符串</param>
        /// <param name="requestId">发起请求的行为标识</param>
        /// <param name="timeout">超时时间，单位：秒，默认为30秒</param>
        /// <returns></returns>
        public string putContentForString(string url, string parameter,
            Guid requestId, int timeout = 30)
        {
            try
            {
                var client = new HttpClient();

                client.BaseAddress = new Uri(this.BaseURI);
                client.DefaultRequestHeaders.Accept.Clear();
                client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
                client.DefaultRequestHeaders.Add("RequestId", requestId.ToString());
                client.Timeout = new TimeSpan(0, 0, timeout);

                var httpContent = new StringContent(parameter, Encoding.UTF8);
                httpContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
                using (HttpResponseMessage response = client.PutAsync(url, httpContent).Result)
                {
                    if (response.IsSuccessStatusCode)
                    {
                        var result = response.Content.ReadAsStringAsync().Result;
                        return result;
                    }
                    else if (response.StatusCode == HttpStatusCode.InternalServerError)
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常");
                    }
                    else
                    {
                        throw new Exception("{" + this.BaseURI + "}被调用的HTTP服务接口{" + url + "}内部发生异常{" + response.StatusCode + "}");
                    }
                }
            }
            catch
            {
                throw;
            }
        }
        #endregion
    }
}

 DEmon/iWareCc/SystemInteraction/PushMesHandler.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;

namespace iWareCc
{
    /// <summary>
    /// MES推送接口
    /// </summary>
    public class PushMesHandler
    {
        public static string mes_api_url = "";// ConfigHelper.GetConfigString("MesUrl");//修改为配置文件 ã€EditBy shaocx,2022-01-27】
        static HTTPService mes_api = new HTTPService(mes_api_url);//mes基地址

        /// <summary>
        /// ç»™MES推送入库信息
        /// </summary>
        /// <param name="pushData"></param>
        /// <returns></returns>
        public static ApiResponse<string> Mes_InStockSend(List<InboundStockInfoToMes> pushData)
        {
            ApiResponse<string> res = null;
            var funName = "Mes_InStockSend";
            try
            {
                MesRequest<List<InboundStockInfoToMes>> mesRequest = new MesRequest<List<InboundStockInfoToMes>>();
                mesRequest.Datas = pushData;
                mesRequest.TableName = "T_WMS_Inbound_Record";
                mesRequest.PrimaryKeys = "identifier";

                string paprm = JsonConvert.SerializeObject(mesRequest);
                //Log4NetHelper.WriteInfoLog(_logType, $"{funName},准备参数:{paprm}");
                Guid guid = System.Guid.NewGuid();

                //模拟
                if (1 == 2)
                {//模拟环境
                    res = new ApiResponse<string>();
                    res.Code = 500;
                    res.Success = false;
                    res.Message = "系统模拟完成";
                }
                else
                {
                    var resStr = mes_api.postContentForString("", paprm, guid);
                    //Log4NetHelper.WriteInfoLog(_logType, $"{funName},结果返回:{resStr}");
                    res = JsonConvert.DeserializeObject<ApiResponse<string>>(resStr);
                }

                //Log4NetHelper.WriteInfoLog(_logType, $"{funName},参数:{paprm},返回:{JsonConvert.SerializeObject(res)}");
            }
            catch (Exception ex)
            {
                //Log4NetHelper.WriteErrorLog(_logType, $"{funName},异常:" + ex.Message, ex);
                res.Code = 500;
                res.Success = false;
                res.Message = "wms发送异常:" + ex.Message;
            }
            return res;

        }


        ///// <summary>
        ///// ç»™MES推送出库信息
        ///// </summary>
        ///// <param name="pushData"></param>
        ///// <returns></returns>
        //public static ApiResponse Mes_OutStockSend(List<InboundStockInfoToMes> pushData, LogType _logType)
        //{
        //    ApiResponse<string> res = null;
        //    var funName = "Mes_OutStockSend";
        //    try
        //    {
        //        MesRequest<List<InboundStockInfoToMes>> mesRequest = new MesRequest<List<InboundStockInfoToMes>>();
        //        mesRequest.Datas = pushData;
        //        mesRequest.TableName = "T_WMS_Outbound_Record";
        //        mesRequest.PrimaryKeys = "identifier";

        //        string paprm = JsonConvert.SerializeObject(mesRequest);
        //        //Log4NetHelper.WriteInfoLog(_logType, $"{funName},准备参数:{paprm}");
        //        Guid guid = System.Guid.NewGuid();
        //        //模拟
        //        if (Form1.isvirtual)
        //        {//模拟环境
        //            res = new ApiResponse<string>();
        //            res.ErrorCode = 0;
        //            res.ErrorMsg = "系统模拟完成";
        //        }
        //        else
        //        {
        //            var resStr = mes_api.postContentForString("", paprm, guid);
        //            //Log4NetHelper.WriteInfoLog(_logType, $"{funName},结果返回:{resStr}");
        //            res = JsonConvert.DeserializeObject<ApiResponse<string>>(resStr);
        //        }

        //        //Log4NetHelper.WriteInfoLog(_logType, $"{funName},参数:{paprm},返回:{JsonConvert.SerializeObject(res)}");
        //    }
        //    catch (Exception ex)
        //    {
        //        //Log4NetHelper.WriteErrorLog(_logType, $"{funName},异常:" + ex.Message, ex);
        //        res.ErrorCode = 4;
        //        res.ErrorMsg = "wms发送异常:" + ex.Message;
        //    }
        //    return res;

        //}


    }
}

 DEmon/iWareCc/SystemInteraction/dto/ApiResponse.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// é€šç”¨æ³›åž‹æŽ¥å£å“åº”模型
    /// </summary>
    /// <typeparam name="T">Data å­—段的类型，可以是任意类型，如 string、int、自定义类等</typeparam>
    public class ApiResponse<T>
    {
        /// <summary>
        /// çŠ¶æ€ç ï¼Œä¾‹å¦‚ 200 è¡¨ç¤ºæˆåŠŸ
        /// </summary>
        public int Code { get; set; }

        /// <summary>
        /// æ˜¯å¦æˆåŠŸï¼Œtrue è¡¨ç¤ºæˆåŠŸï¼Œfalse è¡¨ç¤ºå¤±è´¥
        /// </summary>
        public bool Success { get; set; }

        /// <summary>
        /// è¿”回消息，例如："成功" æˆ–错误信息
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// è¿”回的数据内容，类型为泛型 T
        /// </summary>
        public T Data { get; set; }
    }
}

 DEmon/iWareCc/SystemInteraction/dto/InboundStockInfoToMes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// æŽ¨é€å…¥åº“接口 - è¯·æ±‚参数中的单个入库记录项
    /// </summary>
    public class InboundStockInfoToMes
    {

        /// <summary>
        /// å‡ºå…¥åº“标记
        /// </summary>
        public string BusinessFlag { get; set; }

        /// <summary>
        /// åˆ†æ®µå·
        /// </summary>
        public string SerialNo { get; set; }

        /// <summary>
        /// èˆ¹å·/发放工程号
        /// </summary>
        public string IssueProjectNo { get; set; }

        /// <summary>
        /// åº“位号
        /// </summary>
        public string PlaceCode { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–码
        /// </summary>
        public string Code { get; set; }


        /// <summary>
        /// å‘生时间
        /// </summary>
        public string OccurrenceTime { get; set; }



        /// <summary>
        /// æ—¶é—´æˆ³(参数自动初始化)
        /// </summary>
        public string Timestamp { get; set; } = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");




    }
}

 DEmon/iWareCc/SystemInteraction/dto/MesRequest.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace iWareCc
{
    /// <summary>
    /// æŽ¨é€ä¿¡æ¯
    /// </summary>
    public class MesRequest<T>
    {
        /// <summary>
        /// æ•°æ®
        /// </summary>
        public T Datas { get; set; }

        /// <summary>
        /// ç³»ç»Ÿç±»åž‹
        /// </summary>
        public string SystemType { get; set; } = "ERP";
        /// <summary>
        /// Secret
        /// </summary>
        public string Secret { get; set; } = "HJY^*HGYIIY";


        /// <summary>
        /// è¡¨å
        /// </summary>
        public string TableName { get; set; }

        /// <summary>
        /// ä¸»é”®
        /// </summary>
        public string PrimaryKeys { get; set; }
    }
}

 DEmon/iWareCc/SystemInteraction/mesDataTranfficForRealMes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,96 @@
using iWareDataCore.ORM;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

namespace iWareCc
{
    /// <summary>
    /// MES出入库数据传输(真正的MES)
    /// </summary>
    public class mesDataTranfficForRealMes
    {
        //public static LogType _logType = LogType.mesDataTranfficForRealMes;
        public static async void Handler()
        {
            while (true)
            {
                try
                {
                    Thread.Sleep(5000);

                    using (DbModelCore mod = new DbModelCore())
                    {
                        List<Wms_outInStockRecord_V2_Mes> sendMesData = mod.Wms_outInStockRecord_V2_Mes.Where(x => x.IsSendToMes == 0).OrderBy(x => x.ID).ToList();

                        if (sendMesData.Count > 0)
                        {
                            //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},要推送{sendMesData.Count()}条!";
                            foreach (var itemTask in sendMesData)
                            {
                                try
                                {
                                    ApiResponse<string> ret = null;

                                    //获取信息明细
                                    List<InboundStockInfoToMes> pushData = new List<InboundStockInfoToMes>();
                                    pushData.Add(new InboundStockInfoToMes()
                                    {
                                        BusinessFlag = itemTask.OutInFlagName,

                                        OccurrenceTime​ = itemTask.CreateTime?.ToString("yyyy-MM-dd HH:mm:ss"),
                                        Code = itemTask.Code,
                                        PlaceCode = itemTask.PlaceCode,
                                        SerialNo = itemTask.SerialNo,
                                        IssueProjectNo = itemTask.IssueProjectNo,


                                    });


                                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},已推送结束，返回:{JsonConvert.SerializeObject(ret)}";
                                    if (ret.Success)
                                    {
                                        itemTask.IsSendToMes = 1;//推送成功
                                        itemTask.IsSendToMesStr = "成功";
                                    }
                                    else
                                    {
                                        itemTask.IsSendToMes = 0;//推送失败
                                        itemTask.IsSendToMesStr = "失败";
                                    }
                                    itemTask.SendToMesTime = DateTime.Now;
                                    itemTask.MesRet = ret.Message;
                                    itemTask.SendToMesCount = (itemTask.SendToMesCount ?? 0) + 1;
                                    if (itemTask.IsSendToMes == 0 && itemTask.SendToMesCount > 100)
                                    {
                                        itemTask.IsSendToMes = 3;//表示强制推送成功
                                        itemTask.IsSendToMesStr = "强制成功";
                                    }
                                    mod.SaveChanges();

                                }
                                catch (Exception ex)
                                {
                                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},推送给MES数据异常:" + JsonConvert.SerializeObject(ex);
                                    //Log4NetHelper.WriteErrorLog(_logType, //SystemWarningMsg.msg_mesDataTranfficForRealMes, ex);
                                }
                            }
                        }
                        else
                        {
                            //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},没有数据要推送给MES!";
                        }
                    }
                }
                catch (Exception ex)
                {
                    //SystemWarningMsg.msg_mesDataTranfficForRealMes = $"{MyExtend.MsgTimeStr()},数据要推送给MES出现异常:" + ex.Message;
                    //Log4NetHelper.WriteErrorLog(_logType, //SystemWarningMsg.msg_mesDataTranfficForRealMes, ex);
                }
            }
        }
    }
}

 DEmon/iWareCc/iWareCc.csproj

@@ -94,6 +94,7 @@
    <Reference Include="System.Core" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Management" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="System.Xml.Linq" />
@@ -195,6 +196,12 @@
    <Compile Include="Srm\EnumType\ESrmAlarm1.cs" />
    <Compile Include="Srm\Strategy\推送堆垛机告警状态.cs" />
    <Compile Include="Srm\Strategy\推送堆垛机状态.cs" />
    <Compile Include="SystemInteraction\dto\ApiResponse.cs" />
    <Compile Include="SystemInteraction\dto\InboundStockInfoToMes.cs" />
    <Compile Include="SystemInteraction\dto\MesRequest.cs" />
    <Compile Include="SystemInteraction\HTTPService.cs" />
    <Compile Include="SystemInteraction\mesDataTranfficForRealMes.cs" />
    <Compile Include="SystemInteraction\PushMesHandler.cs" />
    <Compile Include="Task\Service\TaskService.cs" />
    <Compile Include="Util\OPCHelper.cs" />
    <Compile Include="Util\SocketClient.cs" />

 DEmon/iWareDataCore/BASE/Entity/MaterialViewForMesEntity.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
using iWareCommon.Common.Entity;
using iWareCommon.Utils;
using iWareDataCore.ORM;
using System;
using System.Collections.Generic;
using System.Linq;

namespace iWareDataCore.BASE.Entity
{
    public class MaterialViewForMesEntity : MaterialViewEntity
    {
        /// 7出入库单号
        /// </summary>
        public string ListNo { get; set; }

    }
}

 DEmon/iWareDataCore/BASE/Service/InOutListService.cs

@@ -12,7 +12,7 @@

namespace iWareDataCore.BASE.Service
{
  public  class InOutListService : CommonService<InOutListEntity, BASEInOutList, DbModelCore>
    public class InOutListService : CommonService<InOutListEntity, BASEInOutList, DbModelCore>
    {
        private static object Lock = new object();

@@ -54,6 +54,15 @@
                {
                    List<BASEInOutListDetail> inldlst = new List<BASEInOutListDetail>();
                    msg = "";

                    //验证单号是否已经存在 ã€Editby shaocx,2025-09-17】
                    var findInOutList = DbModel.BASEInOutLists.FirstOrDefault(x => x.listno == iol.ListNo);
                    if (findInOutList != null)
                    {
                        msg = $"单号{iol.ListNo}已存在";
                        return -1;
                    }

                    iol.InOutListDetail.ForEach(x => { inldlst.Add(x.ToOrm()); });
                    BASEInOutList biol = new BASEInOutList();
                    biol = iol.ToOrm();
@@ -77,7 +86,7 @@
                msg = "";
                using (var dbModel = new DbModelCore())
                {
                    var cutInOut = dbModel.BASEInOutLists.FirstOrDefault(x=>x.listno== inoutNo);
                    var cutInOut = dbModel.BASEInOutLists.FirstOrDefault(x => x.listno == inoutNo);
                    if (cutInOut == null)
                    {
                        msg = "出入库单号不存在";
@@ -89,7 +98,7 @@
                        msg = "物料不存在";
                        return false;
                    }
                    var findInOutDetail = dbModel.BASEInOutListDetails.FirstOrDefault(x => x.inoutlistid == cutInOut.id && x.materialid== cutMarital.id);
                    var findInOutDetail = dbModel.BASEInOutListDetails.FirstOrDefault(x => x.inoutlistid == cutInOut.id && x.materialid == cutMarital.id);
                    if (findInOutDetail != null)
                    {
                        msg = "此单号和物料已存在";
@@ -112,7 +121,7 @@
                return false;
            }
        }
        

        public override int Delete(int id, out string msg)
        {
            msg = "";

 DEmon/iWareDataCore/BASE/Service/MaterialViewService.cs

@@ -73,7 +73,7 @@
                    var codes = new List<string>();
                    List<MaterialEntity> materlst = new List<MaterialEntity>();
                    var materialSaves = new List<MaterialEntity>();
                    var existMaterialcodes = dbModel.BASEMaterials.Select(x =>x.code).ToList();
                    var existMaterialcodes = dbModel.BASEMaterials.Select(x => x.code).ToList();
                    bool b1 = true;
                    foreach (MaterialViewEntity m in materials)
                    {
@@ -81,14 +81,14 @@
                        if (string.IsNullOrEmpty(m.Code))
                        {
                            msg = string.Format("在第{0}行，物料号不能为空，请修改后重新导入", i + 1);
                            b1= false;
                            b1 = false;
                            break;
                        }

                        if (string.IsNullOrEmpty(m.Wide))
                        {
                            msg = string.Format("在第{0}行，宽不能为空，请修改后重新导入", i + 1);
                            b1= false;
                            b1 = false;
                            break;
                        }
                        var type = types.FirstOrDefault(x => x.name == m.TypeName);
@@ -96,7 +96,7 @@
                        {
                            m.MaterialType = 5;//其他
                        }
                        else 
                        else
                        {
                            m.MaterialType = type.id;
                        }
@@ -107,8 +107,8 @@
                        codes.Add(m.Code);
                        if (string.IsNullOrEmpty(m.Name)) { m.Name = m.Description; }
                        if (string.IsNullOrEmpty(m.Version)) { m.Version = "00"; }
                   
                        MaterialEntity mt=new MaterialEntity()

                        MaterialEntity mt = new MaterialEntity()
                        {
                            ClassificationSociety = m.ClassificationSociety,
                            Code = m.Code,
@@ -135,41 +135,41 @@
                            VerticalPosition = m.VerticalPosition,
                            Wide = m.Wide
                        };
                         materialSaves.Add(mt); 
                        materialSaves.Add(mt);

                    }
                    if (!b1) 
                    if (!b1)
                    {
                        return b1;
                    }
                    var sql = string.Format("INSERT INTO BASEMaterial(status, name, code, materialno, version, typeid, guaranteeperiod, cost, classificationsociety, unit, serialno, description, remark, verticalposition, weight, issueprojectno, procurementprojectno, cuttingtype, pageno, thick, wide, length, markingpen, laneseparation) VALUES");
                    for (var j = 0; j < materialSaves.Count ; j++)
                    for (var j = 0; j < materialSaves.Count; j++)
                    {
                               sql += string.Format("({0}, '{1}', '{2}', '{3}', {4}, '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12}', '{13}', '{14}', '{15}','{16}' ,'{17}', '{18}', '{19}', '{20}', '{21}','{22}','{23}' ),",
                                materialSaves[j].Status,
                                StringHelper.RelpaceQuot(materialSaves[j].Name),
                                StringHelper.RelpaceQuot(materialSaves[j].Code),
                                StringHelper.RelpaceQuot(materialSaves[j].MaterialNo),
                                StringHelper.RelpaceQuot(materialSaves[j].Version),
                                materialSaves[j].TypeId,
                                StringHelper.RelpaceQuot(materialSaves[j].GuaranteePeriod),
                                materialSaves[j].Cost,
                                StringHelper.RelpaceQuot(materialSaves[j].ClassificationSociety),
                                StringHelper.RelpaceQuot(materialSaves[j].Unit),
                                StringHelper.RelpaceQuot(materialSaves[j].SerialNo),
                                StringHelper.RelpaceQuot(materialSaves[j].Description),
                                StringHelper.RelpaceQuot(materialSaves[j].Remark),
                                StringHelper.RelpaceQuot(materialSaves[j].VerticalPosition),
                                StringHelper.RelpaceQuot(materialSaves[j].Weight),
                                StringHelper.RelpaceQuot(materialSaves[j].IssueProjectNo),
                                StringHelper.RelpaceQuot(materialSaves[j].ProcurementProjectNo),
                                StringHelper.RelpaceQuot(materialSaves[j].CuttingType),
                                StringHelper.RelpaceQuot(materialSaves[j].PageNo),
                                StringHelper.RelpaceQuot(materialSaves[j].Thick),
                                StringHelper.RelpaceQuot(materialSaves[j].Wide),
                                StringHelper.RelpaceQuot(materialSaves[j].Length),
                                StringHelper.RelpaceQuot(materialSaves[j].MarkingPen),
                                StringHelper.RelpaceQuot(materialSaves[j].LaneSeparation));
                        sql += string.Format("({0}, '{1}', '{2}', '{3}', {4}, '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12}', '{13}', '{14}', '{15}','{16}' ,'{17}', '{18}', '{19}', '{20}', '{21}','{22}','{23}' ),",
                         materialSaves[j].Status,
                         StringHelper.RelpaceQuot(materialSaves[j].Name),
                         StringHelper.RelpaceQuot(materialSaves[j].Code),
                         StringHelper.RelpaceQuot(materialSaves[j].MaterialNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Version),
                         materialSaves[j].TypeId,
                         StringHelper.RelpaceQuot(materialSaves[j].GuaranteePeriod),
                         materialSaves[j].Cost,
                         StringHelper.RelpaceQuot(materialSaves[j].ClassificationSociety),
                         StringHelper.RelpaceQuot(materialSaves[j].Unit),
                         StringHelper.RelpaceQuot(materialSaves[j].SerialNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Description),
                         StringHelper.RelpaceQuot(materialSaves[j].Remark),
                         StringHelper.RelpaceQuot(materialSaves[j].VerticalPosition),
                         StringHelper.RelpaceQuot(materialSaves[j].Weight),
                         StringHelper.RelpaceQuot(materialSaves[j].IssueProjectNo),
                         StringHelper.RelpaceQuot(materialSaves[j].ProcurementProjectNo),
                         StringHelper.RelpaceQuot(materialSaves[j].CuttingType),
                         StringHelper.RelpaceQuot(materialSaves[j].PageNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Thick),
                         StringHelper.RelpaceQuot(materialSaves[j].Wide),
                         StringHelper.RelpaceQuot(materialSaves[j].Length),
                         StringHelper.RelpaceQuot(materialSaves[j].MarkingPen),
                         StringHelper.RelpaceQuot(materialSaves[j].LaneSeparation));
                    }
                    if (sql.EndsWith(","))
                    {
@@ -190,7 +190,148 @@
        }


        /// <summary>
        /// å¯¼å…¥ç‰©æ–™åŸºç¡€æ•°æ®ï¼Œæ¥æºMES ã€Editby shaocx,2025-09-17】
        /// </summary>
        /// <param name="materials"></param>
        /// <param name="msg"></param>
        /// <returns></returns>
        public bool ImportExcelFromMes(List<MaterialViewEntity> materials, out string msg)
        {
            using (var dbModel = new DbModelCore())
            {
                try
                {
                    msg = "";
                    if (materials.Count < 1)
                    {
                        msg = "物料记录数为0，请修改后重新导入";
                        return false;
                    }
                    var types = dbModel.BASEMaterialTypes.Where(x => 1 == 1).ToList();
                    var i = 0;
                    var codes = new List<string>();
                    List<MaterialEntity> materlst = new List<MaterialEntity>();
                    var materialSaves = new List<MaterialEntity>();
                    var existMaterialcodes = dbModel.BASEMaterials.Select(x => x.code).ToList();
                    bool b1 = true;
                    foreach (MaterialViewEntity m in materials)
                    {
                        i += 1;
                        if (string.IsNullOrEmpty(m.Code))
                        {
                            msg = string.Format("在第{0}行，物料号不能为空，请修改后重新导入", i + 1);
                            b1 = false;
                            break;
                        }

                        if (string.IsNullOrEmpty(m.Wide))
                        {
                            msg = string.Format("在第{0}行，宽不能为空，请修改后重新导入", i + 1);
                            b1 = false;
                            break;
                        }
                        var type = types.FirstOrDefault(x => x.name == m.TypeName);
                        if (type == null)
                        {
                            m.MaterialType = 5;//其他
                        }
                        else
                        {
                            m.MaterialType = type.id;
                        }
                        if (existMaterialcodes.Contains(m.Code))
                        {
                            continue;
                        }
                        codes.Add(m.Code);
                        if (string.IsNullOrEmpty(m.Name)) { m.Name = m.Description; }
                        if (string.IsNullOrEmpty(m.Version)) { m.Version = "00"; }

                        MaterialEntity mt = new MaterialEntity()
                        {
                            ClassificationSociety = m.ClassificationSociety,
                            Code = m.Code,
                            MaterialNo = m.MaterialNo,
                            Cost = m.Cost,
                            CuttingType = m.CuttingType,
                            Description = m.Description,
                            GuaranteePeriod = m.GuaranteePeriod,
                            IssueProjectNo = m.IssueProjectNo,
                            Length = m.Length,
                            SerialNo = m.SerialNo,
                            Name = m.Name,
                            LaneSeparation = m.Laneseparation,
                            MarkingPen = m.MarkingPen,
                            PageNo = m.PageNo,
                            Status = 1,
                            Thick = m.Thick,
                            Unit = m.Unit,
                            Remark = m.Remark,
                            ProcurementProjectNo = m.ProcurementProjectNo,
                            TypeId = m.MaterialType,
                            Version = m.Version,
                            Weight = m.Weight,
                            VerticalPosition = m.VerticalPosition,
                            Wide = m.Wide
                        };
                        materialSaves.Add(mt);

                    }
                    if (!b1)
                    {
                        return b1;
                    }
                    if (materialSaves?.Count == 0)
                    {//说明这些物料都有了，不需要再导入了 ã€Editby shaocx,2025-09-17】
                        return true;
                    }
                    var sql = string.Format("INSERT INTO BASEMaterial(status, name, code, materialno, version, typeid, guaranteeperiod, cost, classificationsociety, unit, serialno, description, remark, verticalposition, weight, issueprojectno, procurementprojectno, cuttingtype, pageno, thick, wide, length, markingpen, laneseparation) VALUES");
                    for (var j = 0; j < materialSaves.Count; j++)
                    {
                        sql += string.Format("({0}, '{1}', '{2}', '{3}', {4}, '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12}', '{13}', '{14}', '{15}','{16}' ,'{17}', '{18}', '{19}', '{20}', '{21}','{22}','{23}' ),",
                         materialSaves[j].Status,
                         StringHelper.RelpaceQuot(materialSaves[j].Name),
                         StringHelper.RelpaceQuot(materialSaves[j].Code),
                         StringHelper.RelpaceQuot(materialSaves[j].MaterialNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Version),
                         materialSaves[j].TypeId,
                         StringHelper.RelpaceQuot(materialSaves[j].GuaranteePeriod),
                         materialSaves[j].Cost,
                         StringHelper.RelpaceQuot(materialSaves[j].ClassificationSociety),
                         StringHelper.RelpaceQuot(materialSaves[j].Unit),
                         StringHelper.RelpaceQuot(materialSaves[j].SerialNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Description),
                         StringHelper.RelpaceQuot(materialSaves[j].Remark),
                         StringHelper.RelpaceQuot(materialSaves[j].VerticalPosition),
                         StringHelper.RelpaceQuot(materialSaves[j].Weight),
                         StringHelper.RelpaceQuot(materialSaves[j].IssueProjectNo),
                         StringHelper.RelpaceQuot(materialSaves[j].ProcurementProjectNo),
                         StringHelper.RelpaceQuot(materialSaves[j].CuttingType),
                         StringHelper.RelpaceQuot(materialSaves[j].PageNo),
                         StringHelper.RelpaceQuot(materialSaves[j].Thick),
                         StringHelper.RelpaceQuot(materialSaves[j].Wide),
                         StringHelper.RelpaceQuot(materialSaves[j].Length),
                         StringHelper.RelpaceQuot(materialSaves[j].MarkingPen),
                         StringHelper.RelpaceQuot(materialSaves[j].LaneSeparation));
                    }
                    if (sql.EndsWith(","))
                    {
                        sql = sql.Substring(0, sql.Length - 1);
                    }
                    var num = dbModel.Database.ExecuteSqlCommand(sql);

                    return string.IsNullOrEmpty(msg);

                }
                catch (Exception ex)
                {
                    msg = ex.Message;
                    LogTextHelper.WriteLog(Resources.LogDir, this.ToString(), "ImportExcel", ex.Message);
                    return false;
                }
            }
        }


    }

 DEmon/iWareDataCore/ORM/DbModelCore.cs

@@ -1,9 +1,6 @@
namespace iWareDataCore.ORM
{
    using System;
    using System.Data.Entity;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Linq;

    public partial class DbModelCore : DbContext
    {
@@ -53,10 +50,30 @@
        public virtual DbSet<WebOrderDetailView> WebOrderDetailView { get; set; }
        public virtual DbSet<MaterialPlaceView> MaterialPlaceView { get; set; }
        public virtual DbSet<BASEMaterialClass> BASEMaterialClass { get; set; }
        
        public virtual DbSet<Wms_outInStockRecord_V2_Mes> Wms_outInStockRecord_V2_Mes { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
              .Property(e => e.OutInFlagName)
              .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.PlaceCode)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.IsSendToMesStr)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.Creator)
                .IsUnicode(false);

            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
                .Property(e => e.LastModifier)
                .IsUnicode(false);

            modelBuilder.Entity<BASEInOutList>()
                .HasMany(e => e.BASEInOutListDetails)
                .WithRequired(e => e.BASEInOutList)

 DEmon/iWareDataCore/ORM/Wms_outInStockRecord_V2_Mes.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,61 @@
namespace iWareDataCore.ORM
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.DataAnnotations;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Data.Entity.Spatial;

    public partial class Wms_outInStockRecord_V2_Mes
    {
        public int ID { get; set; }

        [StringLength(10)]
        public string OutInFlagName { get; set; }

        [StringLength(128)]
        public string ListNo { get; set; }

        [StringLength(128)]
        public string Code { get; set; }

        [StringLength(128)]
        public string Name { get; set; }

        [StringLength(128)]
        public string SerialNo { get; set; }

        [StringLength(128)]
        public string IssueProjectNo { get; set; }

        [StringLength(100)]
        public string PlaceCode { get; set; }

        public DateTime? OccurrenceTime { get; set; }

        public int? IsSendToMes { get; set; }

        [StringLength(100)]
        public string IsSendToMesStr { get; set; }

        public int? SendToMesCount { get; set; }

        public DateTime? SendToMesTime { get; set; }

        [StringLength(128)]
        public string MesRet { get; set; }

        [StringLength(128)]
        public string Remark { get; set; }

        [StringLength(128)]
        public string Creator { get; set; }

        public DateTime? CreateTime { get; set; }

        [StringLength(128)]
        public string LastModifier { get; set; }

        public DateTime? LastModifyTime { get; set; }
    }
}

 DEmon/iWareDataCore/Test_ORM/Test_ORM.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,40 @@
//using System;
//using System.ComponentModel.DataAnnotations.Schema;
//using System.Data.Entity;
//using System.Linq;

//namespace iWareDataCore.Test_ORM
//{
//    public partial class Test_ORM : DbContext
//    {
//        public Test_ORM()
//            : base("name=Test_ORM")
//        {
//        }

//        public virtual DbSet<Wms_outInStockRecord_V2_Mes> Wms_outInStockRecord_V2_Mes { get; set; }

//        protected override void OnModelCreating(DbModelBuilder modelBuilder)
//        {
//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.OutInFlagName)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.PlaceCode)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.IsSendToMesStr)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.Creator)
//                .IsUnicode(false);

//            modelBuilder.Entity<Wms_outInStockRecord_V2_Mes>()
//                .Property(e => e.LastModifier)
//                .IsUnicode(false);
//        }
//    }
//}

 DEmon/iWareDataCore/iWareDataCore.csproj

@@ -77,6 +77,7 @@
    <Compile Include="BASE\Entity\InOutListEntity.cs" />
    <Compile Include="BASE\Entity\EmptyPlaceViewEntity.cs" />
    <Compile Include="BASE\Entity\InputMaterialEntity.cs" />
    <Compile Include="BASE\Entity\MaterialViewForMesEntity.cs" />
    <Compile Include="BASE\Entity\WebOrderDetailViewEntity.cs" />
    <Compile Include="BASE\Entity\WebOrderDetailEntity.cs" />
    <Compile Include="BASE\Entity\MaterialClassEntity.cs" />
@@ -256,6 +257,8 @@
    <Compile Include="TASK\Service\MainTaskViewService.cs" />
    <Compile Include="TASK\Service\PartTaskService.cs" />
    <Compile Include="TASK\Service\PartTaskViewService.cs" />
    <Compile Include="Test_ORM\Test_ORM.cs" />
    <Compile Include="ORM\Wms_outInStockRecord_V2_Mes.cs" />
    <Compile Include="WebDav\Entity\FileInfo.cs" />
    <Compile Include="WebDav\Service\FileService.cs" />
  </ItemGroup>