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 Newtonsoft.Json;
using IMCS_CCS.Utils.DeviceProtocol;
using HslCommunication.Profinet.Siemens;
using Microsoft.Extensions.Configuration;
using IMCS.CCS.Service;
using IMCS_CCS.Model.vo;
using FTP;

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 int SLEEP_TIME = 500;

        string LocalPath = "D:\\PROG";

        private string fanucUrlContext;

        private string opcuacUrlContext;

        private string ftpUrlContext;

        private string ftpUserContext;

        private string ftpPwdContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

        public HttpRequestService(IDeviceService deviceService, ITaskCallbackService taskCallbackService,
                                  ICcsActionService ccsActionService, ICcsTagValueService ccsTagValueService,
                                  IEquipmentMonitorService equipmentMonitorService, IApiRequestService apiRequestService,
                                  IConfiguration configuration)
        {
            _deviceService = deviceService;
            _taskCallbackService = taskCallbackService;
            _ccsActionService = ccsActionService;
            _ccsTagValueService = ccsTagValueService;
            _equipmentMonitorService = equipmentMonitorService;
            _apiRequestService = apiRequestService;
            Configuration = configuration;
            fanucUrlContext = Configuration.GetConnectionString("fanucUrlContext");
            opcuacUrlContext = Configuration.GetConnectionString("opcuacUrlContext");
            ftpUrlContext = Configuration.GetConnectionString("FTPServer");
            ftpUserContext = Configuration.GetConnectionString("FTPUser");
            ftpPwdContext = Configuration.GetConnectionString("FTPPwd");
        }

        /// <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<ResponseDigitalTwinsData> list = new List<ResponseDigitalTwinsData>();

            List<EquipmentMonitor> equipmentMonitors = await _equipmentMonitorService.GetList();
            foreach (EquipmentMonitor equipment in equipmentMonitors)
            {
                ResponseDigitalTwinsData digitalTwinsData = new ResponseDigitalTwinsData();
                digitalTwinsData.id = equipment.Id.ToString();
                digitalTwinsData.deviceType = equipment.Type;
                digitalTwinsData.deviceName = equipment.Name;
                digitalTwinsData.monitoringStatus = equipment.Status;
                digitalTwinsData.operationName = "工序名称";
                digitalTwinsData.orderName = "100001";
                digitalTwinsData.orderNumber = "100002";
                digitalTwinsData.productName = "100003";
                digitalTwinsData.productNumber = "100004";
                digitalTwinsData.feedRate = "50";
                digitalTwinsData.spindleLoad = "100";
                digitalTwinsData.spindleMagnification = "80";
                digitalTwinsData.spindleSpeed = "40";
                list.Add(digitalTwinsData);
            }
            return list;

        }

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

        }
        /// <summary>
        /// 智能单元取物品
        /// </summary> 
        public async Task<ResponseECSData> GetIntelligenceUnit(RequestData<LocationData> 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.GetIntelligenceUnit + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.GetIntelligenceUnit.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress) && !string.IsNullOrEmpty(actionInfo.CheckValue))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    if (actionInfo.CheckType ? operateResult.ToString().Equals(actionInfo.CheckValue) : operateResult.ToString() != actionInfo.CheckValue)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                if (!string.IsNullOrEmpty(actionInfo.Address))
                {
                    string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                    s7.Write(Address1, Convert.ToInt16(req.data.Location));
                    Thread.Sleep(SLEEP_TIME);
                }
                if (!string.IsNullOrEmpty(actionInfo.Address2))
                {
                    string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                    s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                }
                s7.Close();


                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.GetIntelligenceUnit.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetIntelligenceUnit + "取物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetIntelligenceUnit));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 柔性线取物品
        /// </summary> 
        public async Task<ResponseECSData> GetFlexibleWire(RequestData<LocationData> 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.GetFlexibleWire + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.GetFlexibleWire.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    bool CheckFlag = string.IsNullOrEmpty(actionInfo.CheckValue) ? false : (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue));
                    bool CheckFlag2 = string.IsNullOrEmpty(actionInfo.CheckValue2) ? true : (actionInfo.CheckType2 ? (operateResult.ToString() == actionInfo.CheckValue2) : (operateResult.ToString() != actionInfo.CheckValue2));
                    bool CheckFlag3 = string.IsNullOrEmpty(actionInfo.CheckValue3) ? true : (actionInfo.CheckType3 ? (operateResult.ToString() == actionInfo.CheckValue3) : (operateResult.ToString() != actionInfo.CheckValue3));
                    if (CheckFlag && CheckFlag2 && CheckFlag3)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress4))
                {
                    string CheckAddress4 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress4);

                    var operateResult = ((ushort)s7.Read(CheckAddress4)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue4 : operateResult.ToString() != actionInfo.CheckValue4)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                        s7.Close();
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress5))
                {
                    string CheckAddress5 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress5);

                    var operateResult = ((ushort)s7.Read(CheckAddress5)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue5 : operateResult.ToString() != actionInfo.CheckValue5)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                        s7.Close();
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.GetFlexibleWire.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);

                taskCallbackData.Address3 = actionInfo.Address5;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetFlexibleWire + "取物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetFlexibleWire));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 质量中心取物品
        /// </summary> 
        public async Task<ResponseECSData> GetQualityCenter(RequestData<LocationData> 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.GetQualityCenter + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.GetQualityCenter.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetQualityCenter + "取物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress) && !string.IsNullOrEmpty(actionInfo.CheckValue))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    if (actionInfo.CheckType ? operateResult.ToString().Equals(actionInfo.CheckValue) : operateResult.ToString() != actionInfo.CheckValue)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetQualityCenter + "取物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.GetQualityCenter.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetQualityCenter + "取物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetQualityCenter));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 智能单元送物品
        /// </summary> 
        public async Task<ResponseECSData> SendIntelligenceUnit(RequestData<LocationData> 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.SendIntelligenceUnit + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendIntelligenceUnit.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendIntelligenceUnit + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                    responseData.result = "false";
                    return responseData;
                }

                //条件判断
                if (!string.IsNullOrEmpty(actionInfo.CheckAddress) && !string.IsNullOrEmpty(actionInfo.CheckValue))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    if (actionInfo.CheckType ? operateResult.ToString().Equals(actionInfo.CheckValue) : operateResult.ToString() != actionInfo.CheckValue)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendIntelligenceUnit + "放物品异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendIntelligenceUnit.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendIntelligenceUnit + "放物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendIntelligenceUnit));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 柔性线送物品
        /// </summary> 
        public async Task<ResponseECSData> SendFlexibleWire(RequestData<LocationData> 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.SendFlexibleWire + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendFlexibleWire.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                    responseData.result = "false";
                    return responseData;
                }
                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    bool CheckFlag = string.IsNullOrEmpty(actionInfo.CheckValue) ? false : (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue));
                    bool CheckFlag2 = string.IsNullOrEmpty(actionInfo.CheckValue2) ? true : (actionInfo.CheckType2 ? (operateResult.ToString() == actionInfo.CheckValue2) : (operateResult.ToString() != actionInfo.CheckValue2));
                    bool CheckFlag3 = string.IsNullOrEmpty(actionInfo.CheckValue3) ? true : (actionInfo.CheckType3 ? (operateResult.ToString() == actionInfo.CheckValue3) : (operateResult.ToString() != actionInfo.CheckValue3));
                    if (CheckFlag && CheckFlag2 && CheckFlag3)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品异常===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                        responseData.result = "false";
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress4))
                {
                    string CheckAddress4 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress4);

                    var operateResult = ((ushort)s7.Read(CheckAddress4)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue4 : operateResult.ToString() != actionInfo.CheckValue4)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                        s7.Close();
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress5))
                {
                    string CheckAddress5 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress5);

                    var operateResult = ((ushort)s7.Read(CheckAddress5)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue5 : operateResult.ToString() != actionInfo.CheckValue5)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                        s7.Close();
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendFlexibleWire.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);

                taskCallbackData.Address3 = actionInfo.CallbackAddress3;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendFlexibleWire + "放物品异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendFlexibleWire));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 质量中心送物品
        /// </summary> 
        public async Task<ResponseECSData> SendQualityCenter(RequestData<LocationData> 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.SendQualityCenter + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendQualityCenter.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                    responseData.result = "false";
                    return responseData;
                }

                //条件判断
                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    if (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue))
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendQualityCenter.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendQualityCenter + "放物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendQualityCenter));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 柔性线机器人移动物品
        /// </summary> 
        public async Task<ResponseECSData> MoveRobotPosition(RequestData<LocationData> 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.MoveRobotPosition + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.MoveRobotPosition.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                    responseData.result = "false";
                    return responseData;
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    bool CheckFlag = string.IsNullOrEmpty(actionInfo.CheckValue) ? false : (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue));
                    bool CheckFlag2 = string.IsNullOrEmpty(actionInfo.CheckValue2) ? true : (actionInfo.CheckType2 ? (operateResult.ToString() == actionInfo.CheckValue2) : (operateResult.ToString() != actionInfo.CheckValue2));
                    bool CheckFlag3 = string.IsNullOrEmpty(actionInfo.CheckValue3) ? true : (actionInfo.CheckType3 ? (operateResult.ToString() == actionInfo.CheckValue3) : (operateResult.ToString() != actionInfo.CheckValue3));
                    if (CheckFlag && CheckFlag2 && CheckFlag3)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress4))
                {
                    string CheckAddress4 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress4);

                    var operateResult = ((ushort)s7.Read(CheckAddress4)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue4 : operateResult.ToString() != actionInfo.CheckValue4)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                        s7.Close();
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress5))
                {
                    string CheckAddress5 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress5);

                    var operateResult = ((ushort)s7.Read(CheckAddress5)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue5 : operateResult.ToString() != actionInfo.CheckValue5)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                        s7.Close();
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.MoveRobotPosition.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);

                taskCallbackData.Address3 = actionInfo.Address3;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition) + "移动物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.MoveRobotPosition + "移动物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.MoveRobotPosition));
                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.GetDeviceAllList();

                Device device = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).FirstOrDefault();

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

                /*CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.UploadFile.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0]; */

                FtpClient ftpClient = new DeviceFtp().Connect(ftpUrlContext, ftpUserContext, ftpPwdContext);
                ftpClient.Get(req.data.fileName, LocalPath, req.data.fileName);
                ftpClient.DisConnect();
                try
                {
                    DeviceSFTP sftp = new DeviceSFTP(device.Ip, device.Port, device.UserName, device.Password);
                    bool ifcon = sftp.Connect();
                    if (ifcon)
                    {
                        sftp.Put(LocalPath + "\\" + req.data.fileName, req.data.remotePath + req.data.fileName);
                        sftp.Disconnect();
                    }

                }
                catch (Exception exscp)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常,scp连接失败," + exscp.Message + "，" + 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, null, null);
                await _taskCallbackService.Create(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;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                //opcua启动程序
                if (actionInfo.ProtocolType == ProtocalTypeEnum.OPCUA.ToString())
                {
                    RequestOpcUaData opcUaReq = new RequestOpcUaData();
                    opcUaReq.ServerUrl = device.ServerUrl;
                    opcUaReq.UserName = device.UserName;
                    opcUaReq.Password = device.Password;
                    opcUaReq.Path = actionInfo.FilePath + req.data.remotePath;
                    opcUaReq.Type = OpcUaActionTypeEnum.StartNcProgram.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (Result.IsSuccess && responseOpcUaData.result)
                    {

                        Thread.Sleep(SLEEP_TIME);
                        if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                        {
                            opcUaReq.Type = OpcUaActionTypeEnum.Read.ToString();
                            opcUaReq.Addresses = new List<string>() { actionInfo.CheckAddress };
                            Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                            responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                            if (Result.IsSuccess && responseOpcUaData.result)
                            {
                                string checkValue = responseOpcUaData.values.FirstOrDefault();
                                if (checkValue != actionInfo.CheckValue)
                                {
                                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                                      EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                                    responseData.result = "false";
                                    return responseData;
                                }
                            }
                        }

                        opcUaReq.Type = OpcUaActionTypeEnum.Write.ToString();
                        opcUaReq.Addresses = new List<string>() { actionInfo.Address };
                        opcUaReq.Values = new List<string>() { "True" };
                        Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                        responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                        if (Result.IsSuccess && responseOpcUaData.result)
                        {
                            //插入回调
                            TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartNCProgram.ToString(),
                            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                            await _taskCallbackService.Create(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;
                        }
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                      EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.result = "false";
                        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> SendLinShift(RequestData<SendLinShiftData> 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.SendLinShift + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendLinShift.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                DeviceOPCUat opcUa = new DeviceOPCUat(device.ServerUrl, device.UserName, device.Password);
                Thread.Sleep(500);
                if (opcUa.IsConnection)
                {
                    List<string> Tags = new List<string>();
                    string TagName = actionInfo.Address;
                    string OpcTagNameX = TagName + "01]";
                    Tags.Add(OpcTagNameX);
                    string OpcTagNameY = TagName + "02]";
                    Tags.Add(OpcTagNameY);
                    string OpcTagNameZ = TagName + "03]";
                    Tags.Add(OpcTagNameZ);
                    string OpcTagNameA = TagName + "04]";
                    Tags.Add(OpcTagNameA);
                    string OpcTagNameB = TagName + "05]";

                    Tags.Add(OpcTagNameB);
                    List<string> values = new List<string>();

                    values.Add(req.data.X);
                    values.Add(req.data.Y);
                    values.Add(req.data.Z);
                    values.Add(req.data.A);
                    values.Add(req.data.B);
                    opcUa.OpcUa_WriteValue(values, Tags);
                    opcUa.disConnect();

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendLinShift.ToString(),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShift), req.taskId, req.taskNodeId, actionInfo.Address2, actionInfo.CallbackValue2);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                    responseData.result = "false";
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShift + "粗偏写入异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShift));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 精偏写入
        /// </summary> 
        public async Task<ResponseECSData> SendLinShiftFine(RequestData<SendLinShiftData> 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.SendLinShiftFine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendLinShiftFine.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                DeviceOPCUat opcUa = new DeviceOPCUat(device.ServerUrl, device.UserName, device.Password);
                Thread.Sleep(500);
                if (opcUa.IsConnection)
                {
                    List<string> Tags = new List<string>();
                    string TagName = actionInfo.Address;
                    string OpcTagNameX = TagName + "06]";
                    Tags.Add(OpcTagNameX);
                    string OpcTagNameY = TagName + "07]";
                    Tags.Add(OpcTagNameY);
                    string OpcTagNameZ = TagName + "08]";
                    Tags.Add(OpcTagNameZ);
                    string OpcTagNameA = TagName + "09]";
                    Tags.Add(OpcTagNameA);
                    string OpcTagNameB = TagName + "10]";
                    Tags.Add(OpcTagNameB);

                    Tags.Add(OpcTagNameB);
                    List<string> values = new List<string>();

                    values.Add(req.data.X);
                    values.Add(req.data.Y);
                    values.Add(req.data.Z);
                    values.Add(req.data.A);
                    values.Add(req.data.B);
                    opcUa.OpcUa_WriteValue(values, Tags);
                    opcUa.disConnect();

                    //插入回调
                    TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendLinShift.ToString(),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine), req.taskId, req.taskNodeId, actionInfo.Address2, actionInfo.CallbackValue2);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    return responseData;
                }
                else
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入异常===>>" + JsonConvert.SerializeObject(req),
                  EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                    responseData.result = "false";
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendLinShiftFine + "精偏写入异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendLinShiftFine));
                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;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                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;
                }

                //string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(actionInfo.Address, true);
                //s7.Write(Address1, true);
                Thread.Sleep(SLEEP_TIME);
                s7.Write(actionInfo.Address, false);
                Thread.Sleep(SLEEP_TIME);
                //string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                //s7.Write(Address2, true);
                s7.Write(actionInfo.Address2, true);
                Thread.Sleep(SLEEP_TIME);
                s7.Write(actionInfo.Address2, false);
                //s7.Write(Address2, false); 
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartCleanMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCleanMachine), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                await _taskCallbackService.Create(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>
        /// 启动打标机
        /// </summary> 
        public async Task<ResponseECSData> StartLabelMachine(RequestData<WorkData> 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.StartLabelMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                    responseData.result = "false";
                    return responseData;

                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartLabelMachine.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];
                string TypeNo = "";
                string SmallTypeNo = "";
                string OrderNo = "";
                string TaskNo = "";
                string ProductNo = "";
                string BatchNo = "";
                string SerialNo = "";


                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartLabelMachine + "启动打标机异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                    responseData.result = "false";
                    return responseData;
                }
                string[] sArray;

                if (!string.IsNullOrEmpty(actionInfo.Address5) && !string.IsNullOrEmpty(TypeNo))
                {
                    sArray = actionInfo.Address5.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(TypeNo, 1));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address6) && !string.IsNullOrEmpty(SmallTypeNo))
                {
                    sArray = actionInfo.Address6.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(SmallTypeNo, 1));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address7) && !string.IsNullOrEmpty(SmallTypeNo))
                {
                    sArray = actionInfo.Address7.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(OrderNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address8) && !string.IsNullOrEmpty(TaskNo))
                {
                    sArray = actionInfo.Address8.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(TaskNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address9) && !string.IsNullOrEmpty(ProductNo))
                {
                    sArray = actionInfo.Address9.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(ProductNo, 128));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address10) && !string.IsNullOrEmpty(BatchNo))
                {
                    sArray = actionInfo.Address10.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(BatchNo, 32));
                }
                if (!string.IsNullOrEmpty(actionInfo.Address11) && !string.IsNullOrEmpty(SerialNo))
                {
                    sArray = actionInfo.Address11.Split('.');
                    s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(SerialNo, 6));
                }


                short mc = 0;
                s7.Write(ToolUtils.AddressConvertDBW(actionInfo.Address), mc);

                Thread.Sleep(SLEEP_TIME);
                mc = 1;
                s7.Write(ToolUtils.AddressConvertDBW(actionInfo.Address2), mc);
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartLabelMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.Address3 = actionInfo.CallbackAddress3;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine) + "启动打标机成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartLabelMachine + "启动打标机故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartLabelMachine));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 启动三坐标
        /// </summary> 
        public async Task<ResponseECSData> StartCoordinateMeasuringMachine(RequestData<WorkData> 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.StartCoordinateMeasuringMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.StartCoordinateMeasuringMachine.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

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

                //条件判断 
                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    var operateResult = s7.ReadInt16(actionInfo.CheckAddress);
                    if (actionInfo.CheckType ? (operateResult.Content.ToString() == actionInfo.CheckValue) : (operateResult.Content.ToString() != actionInfo.CheckValue))
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartCoordinateMeasuringMachine + "机器人报警===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                        responseData.result = "false";
                        return responseData;
                    }
                }
                if (!string.IsNullOrEmpty(actionInfo.CheckAddress2))
                {
                    var operateResult = s7.ReadInt16(actionInfo.CheckAddress2);
                    if (actionInfo.CheckType2 ? (operateResult.Content.ToString() == actionInfo.CheckValue2) : (operateResult.Content.ToString() != actionInfo.CheckValue2))
                    {
                        s7.ConnectClose();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartCoordinateMeasuringMachine + "启动三坐标未就绪===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);

                s7.Write(actionInfo.Address, ToolUtils.ReturnBtyesWtitString(req.data.workId, 40));
                Thread.Sleep(SLEEP_TIME);

                s7.Write(actionInfo.Address2, ToolUtils.ReturnBtyesWtitString(req.data.workType, 20));
                short n = 1;

                s7.Write(actionInfo.Address3, n);
                Thread.Sleep(SLEEP_TIME);

                n = 0;
                s7.Write(actionInfo.Address3, n);
                s7.ConnectClose();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.StartCoordinateMeasuringMachine.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine) + "启动三坐标成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.StartCoordinateMeasuringMachine + "启动三坐标故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartCoordinateMeasuringMachine));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 伺服舵机取物品
        /// </summary> 
        public async Task<ResponseECSData> GetServoStacker(RequestData<LocationData> 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.GetServoStacker + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.GetServoStacker.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    bool CheckFlag = string.IsNullOrEmpty(actionInfo.CheckValue) ? false : (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue));
                    bool CheckFlag2 = string.IsNullOrEmpty(actionInfo.CheckValue2) ? true : (actionInfo.CheckType2 ? (operateResult.ToString() == actionInfo.CheckValue2) : (operateResult.ToString() != actionInfo.CheckValue2));
                    bool CheckFlag3 = string.IsNullOrEmpty(actionInfo.CheckValue3) ? true : (actionInfo.CheckType3 ? (operateResult.ToString() == actionInfo.CheckValue3) : (operateResult.ToString() != actionInfo.CheckValue3));
                    if (CheckFlag && CheckFlag2 && CheckFlag3)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                        responseData.result = "false";
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress4))
                {
                    string CheckAddress4 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress4);

                    var operateResult = ((ushort)s7.Read(CheckAddress4)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue4 : operateResult.ToString() != actionInfo.CheckValue4)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                        s7.Close();
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress5))
                {
                    string CheckAddress5 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress5);

                    var operateResult = ((ushort)s7.Read(CheckAddress5)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue5 : operateResult.ToString() != actionInfo.CheckValue5)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                        s7.Close();
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.GetServoStacker.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker), req.taskId, req.taskNodeId, actionInfo.CallbackAddress, actionInfo.CallbackValue);

                taskCallbackData.Address3 = actionInfo.Address3;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker) + "取物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.GetServoStacker + "取物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 伺服舵机放物品
        /// </summary> 
        public async Task<ResponseECSData> SendServoStacker(RequestData<LocationData> 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.SendServoStacker + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                    responseData.result = "false";
                    return responseData;
                }

                CcsAction actionQuery = new CcsAction();
                actionQuery.OperateType = ActionTypeEnum.SendServoStacker.ToString();
                actionQuery.Ip = req.url;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                    responseData.result = "false";
                    return responseData;
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress))
                {
                    string CheckAddress = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress);
                    var operateResult = ((ushort)s7.Read(CheckAddress)).ConvertToShort();
                    if (actionInfo.CheckType ? (operateResult.ToString() == actionInfo.CheckValue) : (operateResult.ToString() != actionInfo.CheckValue))
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress2))
                {
                    string CheckAddress2 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress2);
                    var operateResult = ((ushort)s7.Read(CheckAddress2)).ConvertToShort();
                    if (actionInfo.CheckType2 ? operateResult.ToString() == actionInfo.CheckValue2 : operateResult.ToString() != actionInfo.CheckValue2)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                        responseData.result = "false";
                        return responseData;
                    }
                }

                if (!string.IsNullOrEmpty(actionInfo.CheckAddress3))
                {
                    string CheckAddress3 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress3);
                    var operateResult = ((ushort)s7.Read(CheckAddress3)).ConvertToShort();
                    if (actionInfo.CheckType3 ? operateResult.ToString() == actionInfo.CheckValue3 : operateResult.ToString() != actionInfo.CheckValue3)
                    {
                        s7.Close();
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                        responseData.result = "false";
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress4))
                {
                    string CheckAddress4 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress4);

                    var operateResult = ((ushort)s7.Read(CheckAddress4)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue4 : operateResult.ToString() != actionInfo.CheckValue4)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                        s7.Close();
                        return responseData;
                    }
                }


                if (!string.IsNullOrEmpty(actionInfo.CheckAddress5))
                {
                    string CheckAddress5 = ToolUtils.AddressConvertDBW(actionInfo.CheckAddress5);

                    var operateResult = ((ushort)s7.Read(CheckAddress5)).ConvertToShort();

                    if (actionInfo.CheckType ? operateResult.ToString() == actionInfo.CheckValue5 : operateResult.ToString() != actionInfo.CheckValue5)
                    {
                        responseData.result = "false";
                        Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                        s7.Close();
                        return responseData;
                    }
                }

                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                s7.Write(Address1, Convert.ToInt16(req.data.Location));
                Thread.Sleep(SLEEP_TIME);

                string Address2 = ToolUtils.AddressConvertDBW(actionInfo.Address2);
                s7.Write(Address2, Convert.ToInt16(actionInfo.MoveIndex));
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.SendServoStacker.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker), req.taskId, req.taskNodeId, actionInfo.Address2, actionInfo.CallbackValue);

                taskCallbackData.Address3 = actionInfo.Address5;
                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker) + "放物品成功===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.SendServoStacker + "放物品故障===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.SendServoStacker));
                responseData.result = "false";
                return responseData;
            }
        }

        /// <summary>
        /// 刀具接口列表
        /// </summary> 
        public async Task<List<ResponseToolData>> GetTools(RequestToolData req)
        {
            List<ResponseToolData> list = new List<ResponseToolData>();
            CcsTagValue tagValueQuery = new CcsTagValue();
            tagValueQuery.Ip = req.url;
            tagValueQuery.Component = "刀具";
            tagValueQuery.ComponentNumber = "57";
            List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery);
            ResponseToolData toolData = new ResponseToolData();
            foreach (CcsTagValue tagValue in tagValues)
            {
                if (tagValue.Description == "刀具寿命预警")
                {
                    toolData.warnLife = tagValue.TagValue;
                }
                else if (tagValue.Description == "刀具寿命目标值")
                {
                    toolData.targetLife = tagValue.TagValue;
                }
                else if (tagValue.Description == "工件数")
                {
                    toolData.workPiece = tagValue.TagValue;
                }
                else if (tagValue.Description == "工件数预警值")
                {
                    toolData.workPieceWarn = tagValue.TagValue;
                }
                else if (tagValue.Description == "工件数目标值")
                {
                    toolData.workPieceTarget = tagValue.TagValue;
                }
                else if (tagValue.Description == "磨损量")
                {
                    toolData.wear = tagValue.TagValue;
                }
                else if (tagValue.Description == "磨损量预警值")
                {
                    toolData.wearWarn = tagValue.TagValue;
                }
                else if (tagValue.Description == "磨损量目标值")
                {
                    toolData.wearTarget = tagValue.TagValue;
                }
                else if (tagValue.Description == "刀具名称")
                {
                    toolData.name = tagValue.TagValue;
                }
            }
            list.Add(toolData);

            return list;
        }

        /// <summary>
        /// 读RFID
        /// </summary> 
        public async Task<ResponseECSData> ReadRFID(RequestData<WorkData> 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;
                actionQuery.OrderIndex = req.data.orderIndex;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];
                string Content = req.data.content;

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.ReadRFID + "读取RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID));
                    responseData.result = "false";
                    return responseData;
                }


                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                string[] sArray = actionInfo.Address.Split('.');
                s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(Content, 128));
                Thread.Sleep(SLEEP_TIME);

                short n = 1;
                s7.Write(actionInfo.Address2, n);
                Thread.Sleep(SLEEP_TIME);
                n = 0;
                s7.Write(actionInfo.Address2, n);
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.ReadRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.ReadRFID), req.taskId, req.taskNodeId, actionInfo.Address2, actionInfo.CallbackValue);

                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                // await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.ReadRFID) + "读取RFID故障===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                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<WorkData> 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;
                actionQuery.OrderIndex = req.data.orderIndex;
                List<CcsAction> actions = _ccsActionService.GetList(actionQuery);
                CcsAction actionInfo = actions[0];
                string Content = req.data.content;

                Plc s7 = DevicePlcS7.S7(req.url, ProtocalTypeEnum.S7_1500.ToString());
                if (s7.IsConnected != true)
                {
                    s7.Close();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.WriteRFID + "写RFID故障===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID));
                    responseData.result = "false";
                    return responseData;
                }


                string Address1 = ToolUtils.AddressConvertDBW(actionInfo.Address);
                string[] sArray = actionInfo.Address.Split('.');
                s7.WriteBytes(DataType.DataBlock, Convert.ToInt16(sArray[0].Substring(2)), Convert.ToInt16(sArray[1]) + 2, ToolUtils.ReturnBtyesWtitString(Content, 128));
                Thread.Sleep(SLEEP_TIME);

                short n = 1;
                s7.Write(actionInfo.Address2, n);
                Thread.Sleep(SLEEP_TIME);
                n = 0;
                s7.Write(actionInfo.Address2, n);
                s7.Close();

                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.WriteRFID.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.WriteRFID), req.taskId, req.taskNodeId, actionInfo.Address2, actionInfo.CallbackValue);

                taskCallbackData.CallbackValue2 = actionInfo.CallbackValue2;
                taskCallbackData.CallbackValue3 = actionInfo.CallbackValue3;
                // await _taskCallbackService.Create(taskCallbackData);
                Log.Instance.WriteLogAdd(EnumHelper.GetDescription(ActionTypeEnum.WriteRFID) + "写RFID故障===>>" + JsonConvert.SerializeObject(req)
                   , EnumHelper.GetDescription(ActionTypeEnum.GetServoStacker));
                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;
            }
        }

    }
}