htl_ccs/IMCS_CCS/Service/Impl/HttpRequestService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading;
using IMCS.CCS.Entitys;
using IMCS.CCS.Models.vo;
using IMCS.CCS.Models;
using IMCS.CCS.DeviceProtocol;
using System;
using S7.Net;
using IMCS_CCS.Utils;
using IMCS_CCS.Utils.DeviceProtocol;
using HslCommunication.Profinet.Siemens;
using Microsoft.Extensions.Configuration;
using IMCS.CCS.Service;
using IMCS_CCS.Model.vo;
using FTP;
using HslCommunication;
using System.Text.RegularExpressions;
using System.IO;
using System.Reflection;
using Newtonsoft.Json;

namespace IMCS.CCS.Services
{
    public class HttpRequestService : IHttpRequestService
    {
        private readonly IDeviceService _deviceService;

        private readonly ITaskCallbackService _taskCallbackService;

        private readonly ICcsActionService _ccsActionService;

        private readonly ICcsTagValueService _ccsTagValueService;

        private readonly IEquipmentMonitorService _equipmentMonitorService;

        private readonly ICcsActionAddressService _ccsActionAddressService;

        private readonly ITaskJobService _taskJobService;

        private int SLEEP_TIME = 1000;

        string LocalPath = "D:\\PROG";

        private string mazakUrlContext; 

        private string ecsRootUrlContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

        public HttpRequestService(IDeviceService deviceService, ITaskCallbackService taskCallbackService,
                                  ICcsActionService ccsActionService, ICcsTagValueService ccsTagValueService,
                                  IEquipmentMonitorService equipmentMonitorService, ICcsActionAddressService ccsActionAddressService,
                                  IApiRequestService apiRequestService, ITaskJobService taskJobService,
                                  IConfiguration configuration)
        {
            _deviceService = deviceService;
            _taskCallbackService = taskCallbackService;
            _ccsActionService = ccsActionService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _ccsActionAddressService = ccsActionAddressService;
            _apiRequestService = apiRequestService;
            _taskJobService = taskJobService;
            Configuration = configuration;
            mazakUrlContext = Configuration.GetConnectionString("mazakUrlContext"); 
            ecsRootUrlContext = Configuration.GetConnectionString("ecsRootUrlContext");
        }

        /// <summary>
        /// 获取状态当前值
        /// </summary> 
        public string GetTagValue(RequestTagValueData req)
        {
            CcsTagValue queryParam = new CcsTagValue();
            queryParam.Ip = req.ip;
            queryParam.Address = req.tagname;
            List<CcsTagValue> tagValues = _ccsTagValueService.GetList(queryParam);
            string tagValue = "0";
            if (tagValues != null && tagValues.Count > 0)
            {
                tagValue = tagValues[0].TagValue;
            }
            return tagValue;

        }

        /// <summary>
        /// 益模调用接口，显示3D
        /// </summary> 
        public async Task<List<ResponseDigitalTwinsData>> GetDigitalTwins()
        {
            List<Device> devices = _deviceService.GetDeviceList();
            List<ResponseDigitalTwinsData> list = new List<ResponseDigitalTwinsData>();

            //String query3dUrl = ecsRootUrlContext + "/api/authority/agv/agvCallbackService/query3dResouceDataInfo";
            //var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, query3dUrl, new Object(), null);
            //ResponsePageData<ResponseDigitalTwinsData> responseData = JsonConvert.DeserializeObject<ResponsePageData<ResponseDigitalTwinsData>>(result.Message);
            //list = responseData.Data;
            ResponseDigitalTwinsData aa = new ResponseDigitalTwinsData();
            list.Add(aa);
            List<ResponseDigitalTwinsData> collectDatas = new List<ResponseDigitalTwinsData>();
            foreach (ResponseDigitalTwinsData responseDigitalTwinsData in list)
            {
                //EquipmentMonitor equipmentMonitor = await _equipmentMonitorService.GetById(long.Parse(responseDigitalTwinsData.resourceId));
                //if (equipmentMonitor == null || equipmentMonitor.IP == null)
                //{
                //    continue;
                //}
                //Device device = devices.Where(x => x.Ip.Equals(equipmentMonitor.IP)).FirstOrDefault();
                //if (null != device && equipmentMonitor.Type == ProtocalTypeEnum.MAZAK.ToString())
                if(1==1)
                {
                    RequestHeidhData reqBody = new RequestHeidhData();
                    reqBody.ServerUrl = "127.0.0.1";
                    reqBody.DeviceType = "Mazaka";
                    reqBody.Type = "Collect";
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, reqBody, null);
                    if (Result.IsSuccess)
                    {
                        ResponseHeidhData retData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                        if (retData != null && retData.code == 0)
                        {
                            ResponseDigitalTwinsData twinsData = JsonConvert.DeserializeObject<ResponseDigitalTwinsData>(retData.runDatasInfo);
                            //responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(twinsData.feedRate) ? twinsData.feedRate : "0";
                            //responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(twinsData.spindleMagnification) ? twinsData.spindleMagnification : "0";
                            //responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(twinsData.spindleSpeed) ? twinsData.spindleSpeed + "00" : "0";
                            //responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(twinsData.spindleLoad) ? twinsData.spindleMagnification : "-";
                            twinsData.toolsInfo = JsonConvert.DeserializeObject<List<ToolsInfo>>(retData.toolsInfo);
                            twinsData.alarms = JsonConvert.DeserializeObject<List<ErrorInfo>>(retData.errorsInfo);
                            twinsData.id = responseDigitalTwinsData.id;
                            twinsData.deviceType = responseDigitalTwinsData.deviceType;
                            twinsData.resourceId = responseDigitalTwinsData.resourceId;
                            twinsData.deviceName = responseDigitalTwinsData.deviceName;
                            twinsData.monitoringStatus = responseDigitalTwinsData.monitoringStatus;
                            collectDatas.Add(twinsData);
                        }
                    }
                } 
            }

            return list;

        }

        /// <summary>
        /// 查询设备状态
        /// </summary> 
        public async Task<List<EquipmentMonitor>> GetEquipMent()
        {
            return await _equipmentMonitorService.GetList();

        }
     

        /// <summary>
        /// 机器人取放动作
        /// </summary> 
        public async Task<ResponseECSData> RobotAction(RequestData<LocationData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip == req.url && x.Port == req.port).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    return responseData;
                } 
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.RobotAction.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    return responseData;
                } 
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询条件
                List<CcsActionAddress> CcsActionAddressChecks = new List<CcsActionAddress>();
                if (req.data.taskType == "1" && (req.data.destLocation == "30" || req.data.destLocation == "900")) //取料
                {
                    CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_GET.ToString()).ToList();
                }
                else if (req.data.taskType == "1" && (req.data.destLocation != "30" && req.data.destLocation != "900")) //放料
                {
                    CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_SEND.ToString()).ToList();
                }
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.result = "false";
                            return responseData;
                        } 
                    }
                } 
 
                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList(); 
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        //string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString(); 
                       
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                            } 
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        } 

                        //同步更新数据库状态
                        //CcsTagValue tagValueQuery = new CcsTagValue();
                        //tagValueQuery.Ip = req.url;
                        //tagValueQuery.Address = actionAddress.Address;
                        //CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault(); 
                        //if(tagValue != null)
                        //{
                        //    tagValue.TagValue = actionAddress.Value;
                        //    await _ccsTagValueService.Update(tagValue);
                        //} 

                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                bool checkFlag = true;
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    { 
                        //取参数传参值
                        string dataValue = getProperties(req.data, actionAddress.Description); 
                        //读取写入结果
                        string readWriteResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if(dataValue != readWriteResult)
                        {
                            checkFlag = false;
                            break;
                        } 
                        
                    }
                    
                }
                //不通过不写执行
                if (!checkFlag)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "写入失败,plc没有写入相应的值" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false"; 
                    return responseData; 
                }
                //二次写入地址列表
                List<CcsActionAddress> CcsActionAddressWriteSeconds = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_SECOND.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteSeconds)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {
                            //取参数传参值
                            string dataValue = getProperties(req.data, actionAddress.Description);
                            if (!string.IsNullOrEmpty(dataValue))
                            {
                                s7.Write(actionAddress.Address, Convert.ToInt16(dataValue));
                            }
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.RobotAction.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction), req.taskId, req.taskNodeId);
                taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
               
                if(req.data.taskType == "1" && (req.data.destLocation == "30" || req.data.destLocation == "900")) //取料完成
                {
                    taskCallbackData.CallbackValue = "2";
                }else if (req.data.taskType == "1" && (req.data.destLocation != "30" && req.data.destLocation != "900")) //放料完成
                {
                    taskCallbackData.CallbackValue = "4";
                }
                else if (req.data.taskType == "512" ) //移动完成
                {
                    taskCallbackData.CallbackValue = "4"; //todo 待确定移动完成 值
                }

                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.RobotAction) + "操作成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "取异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                responseData.result = "false";
                return responseData;
            }
        } 

        /// <summary>
        /// 上传文件
        /// </summary> 
        public async Task<ResponseECSData> UploadFile(RequestData<UploadFileData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

            try
            {
                List<Device> devices = _deviceService.GetDeviceList();
         
                Device deviceMazak = devices.Where(x => x.Ip.Equals(req.url)
                                           && x.ProtocolType.Equals(ProtocalTypeEnum.MAZAK.ToString())).FirstOrDefault(); 

                if (deviceMazak == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    return responseData;
                }
                //mazak系统上传
                if (deviceMazak != null)
                {
                    RequestOpcUaData deviceReq = new RequestOpcUaData();
                    deviceReq.ServerUrl = req.url;

                    deviceReq.Path = req.data.fileName;
                    deviceReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, deviceReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (!Result.IsSuccess || !responseOpcUaData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        return responseData;
                    }
                }
                
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.UploadFile.ToString(),
                EnumHelper.GetDescription(ActionTypeEnum.UploadFile), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传成功===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.result = "false";
                return responseData;
            }
        }

       
        /// <summary>
        /// 启动机床程序
        /// </summary> 
        public async Task<ResponseECSData> StartNCProgram(RequestData<StartNCProgramData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartNCProgram.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                if (actionInfo.ProtocolType == ProtocalTypeEnum.MAZAK.ToString()) 
                {

                    SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                    OperateResult ConnectionResult = s7.ConnectServer();
                    if (!ConnectionResult.IsSuccess)
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        return responseData;
                    }

                    //查询条件
                    List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                        {

                            string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                            if (actionAddress.CheckType ? operateResult.Equals(actionAddress.Value) : operateResult != actionAddress.Value)
                            {
                                s7.ConnectClose();
                                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                                EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                                responseData.result = "false";
                                return responseData;
                            }
                        }
                    }
                     

                    //查询写入地址列表
                    List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address))
                        {  
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                           
                            Thread.Sleep(SLEEP_TIME);
                        }
                    }

                    List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                    foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                        {
                            string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                            if (operateResult != actionAddress.Value)
                            {
                                s7.ConnectClose();
                                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "异常===>>" + "写入失败" + JsonConvert.SerializeObject(req),
                                EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                                responseData.result = "false";
                                return responseData;
                            }
                        }
                    }
                    s7.ConnectClose();

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(actionInfo.PlcIp, ActionTypeEnum.StartNCProgram.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram), req.taskId, req.taskNodeId);
                    await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));                    
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                     EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "程序异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                responseData.result = "false";
                return responseData;
            }
        }
    

        /// <summary>
        /// 启动清洗机
        /// </summary> 
        public async Task<ResponseECSData> StartCleanMachine(RequestData<object> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    return responseData;

                }
                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartCleanMachine.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault(); 

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
              
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "启动故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                     
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartCleanMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine) + "启动成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartCleanMachine + "启动故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 读RFID
        /// </summary> 
        public async Task<ResponseECSData> ReadRFID(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.ReadRFID.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "读取RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                actionAddressQuery.Type = ActionAddressTypeEnum.WRITE.ToString();       
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        if (!string.IsNullOrEmpty(actionAddress.Value))
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        } 

                        Thread.Sleep(SLEEP_TIME);
                    }
                } 

                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (operateResult != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "异常===>>" + "写入失败" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                s7.ConnectClose();
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.ReadRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine) + "读取RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                return responseData;

                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.ReadRFID) + " 读取RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "读取RFID故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 写RFID
        /// </summary> 
        public async Task<ResponseECSData> WriteRFID(RequestData<RFIData> req)
        {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            List<Device> devices = _deviceService.GetDeviceList();
            try
            {
                Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();

                if (device == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.WriteRFID.ToString();
                actionQuery.Ip = req.url;
                CcsAction actionInfo = _ccsActionService.GetList(actionQuery).FirstOrDefault();

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(req.url);
                HslCommunication.OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                    responseData.result = "false";
                    return responseData;
                }

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;        
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);

                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {  
                        if (string.IsNullOrEmpty(actionAddress.Value))
                        {  
                            s7.Write(actionAddress.Address, ToolUtils.ReturnBtyesWtitString(req.data.content, 2048));
                        }
                        else
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));
                        } 

                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                List<CcsActionAddress> CcsActionAddressWriteChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE_CHECK.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWriteChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();
                        if (operateResult != actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "异常===>>" + "写入失败" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                            responseData.result = "false";
                            return responseData;
                        }
                    }
                }

                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.WriteRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(setCallBackValue(CcsActionAddresses, taskCallbackData));
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + "写RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                return responseData;

                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + " 写RFID成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                responseData.result = "false";
                return responseData;
            }
        }


        /// <summary>
        /// 刀具接口列表
        /// </summary> 
        public async Task<List<ResponseToolData>> GetTools(RequestToolData req)
        {
            List<Device> devices = _deviceService.GetDeviceList();

            Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();
            List<ResponseToolData> list = new List<ResponseToolData>();
            
          if(device.ProtocolType == ProtocalTypeEnum.MAZAK.ToString())
            {
                RequestHeidhData hdhReq = new RequestHeidhData();
                hdhReq.ServerUrl = device.ServerUrl;
                
                hdhReq.Type = "ToolList";
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, mazakUrlContext, hdhReq, null);                
                if (Result.IsSuccess)
                {
                    ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseData.toolsInfo);
                }
            }

            return list;
        }

      

        /// <summary>
        /// 设备上线离线
        /// </summary> 
        public async Task<ResponseCommonData> UpdateDeviceState(RequestDeviceUpdateData req)
        {
            ResponseCommonData responseData = new ResponseCommonData();
            List<Device> devices = _deviceService.GetDevices();
            try
            {
                Device device = devices.Where(x => x.Ip == req.ip).FirstOrDefault();

                if (device == null)
                {
                    responseData.msg = "设备不存在";
                    responseData.result = "false";
                    return responseData;
                }
                device.UseState = req.useState;
                device.OfflineUpdateTime = DateTime.Now;
                await _deviceService.UpdateAndCache(device); 
                return responseData;
            }
            catch (Exception ex)
            {
                responseData.msg = ex.Message;
                responseData.result = "false";
                return responseData;
            }
        }
        /// <summary>
        /// 获取回调列表
        /// </summary> 
        public async Task<List<TaskCallback>> GetCallBackListByCondition(RequestCallBackData vo)
        {
            List<TaskCallback> list = new List<TaskCallback>();
            try {
                TaskCallback taskCallback = new TaskCallback();
                if (!string.IsNullOrEmpty(vo.IP))
                {
                    taskCallback.IP = vo.IP;
                } 
                if (!string.IsNullOrEmpty(vo.TaskId))
                {
                    taskCallback.TaskId = vo.TaskId;
                }
                if (!string.IsNullOrEmpty(vo.TaskNodeId))
                {
                    taskCallback.TaskNodeId = vo.TaskNodeId;
                }
                list = await _taskCallbackService.GetListByCondition(taskCallback);

            }
            catch (Exception ex)
            { 
                return list;
            }
            return list;
        }
 

        //设置回调值
        private TaskCallback setCallBackValue(List<CcsActionAddress> CcsActionAddresses, TaskCallback taskCallbackData)
        {
            List<CcsActionAddress> CcsActionAddressCallBacks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackFails = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK_FAIL.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackResets = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.RESET.ToString()).ToList();
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBacks)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.Address = actionAddress.Address;
                    taskCallbackData.CallbackValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.Address2 = actionAddress.Address;
                    taskCallbackData.CallbackValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.Address3 = actionAddress.Address;
                    taskCallbackData.CallbackValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackFails)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.FailAddress = actionAddress.Address;
                    taskCallbackData.CallbackFailValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.FailAddress2 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.FailAddress3 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackResets)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.SuccessResetAddress = actionAddress.Address;
                    taskCallbackData.SuccessResetValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.SuccessResetAddress2 = actionAddress.Address;
                    taskCallbackData.SuccessResetValue2 = actionAddress.Value;
                }
                
            }
            return taskCallbackData;
        }
        
        public string getProperties<T>(T t , string propertyName)
        {
            string tStr = string.Empty;
            if (t == null)
            {
                return tStr;
            }
            System.Reflection.PropertyInfo[] properties = t.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public);

            if (properties.Length <= 0)
            {
                return tStr;
            }
            foreach (System.Reflection.PropertyInfo item in properties)
            {
                string name = item.Name;
                object value = item.GetValue(t, null);
                if ((item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String")) && name == propertyName)
                {
                    tStr = value.ToString();
                    break;
                }
                
            }
            return tStr;
        }
    }
}