300_ccs/IMCS_CCS/Service/Impl/HttpRequestService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading;
using IMCS.CCS.Entitys;
using IMCS.CCS.Models.vo;
using IMCS.CCS.Models;
using IMCS.CCS.DeviceProtocol;
using System;
using S7.Net;
using IMCS_CCS.Utils;
using 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;
using HslCommunication;
using System.Text.RegularExpressions;
using System.IO;
using WinSCP;

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

        private readonly ITaskCallbackService _taskCallbackService;

        private readonly ICcsActionService _ccsActionService;

        private readonly ICcsTagValueService _ccsTagValueService;

        private readonly IEquipmentMonitorService _equipmentMonitorService;

        private readonly ICcsActionAddressService _ccsActionAddressService;

        private readonly ITaskJobService _taskJobService;

        private int SLEEP_TIME = 1000;

        string LocalPath = "D:\\PROG";

        private string fanucUrlContext;

        private string opcuacUrlContext;

        private string hdhUrlContext; 

        private string ecsRootUrlContext;

        public IConfiguration Configuration { get; }

        private readonly IApiRequestService _apiRequestService;

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

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

        }

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

            String query3dUrl = ecsRootUrlContext + "/api/authority/agv/agvCallbackService/query3dResouceDataInfo";
            var result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, query3dUrl, new Object(), null);
            ResponsePageData<ResponseDigitalTwinsData> responseData = JsonConvert.DeserializeObject<ResponsePageData<ResponseDigitalTwinsData>>(result.Message);
            list = responseData.Data;
            foreach(ResponseDigitalTwinsData responseDigitalTwinsData in list)
            {
                EquipmentMonitor equipmentMonitor = await _equipmentMonitorService.GetById(long.Parse(responseDigitalTwinsData.resourceId));
                if (equipmentMonitor==null || equipmentMonitor.IP == null)
                {
                    continue;
                }
                Device device = devices.Where(x => x.Ip.Equals(equipmentMonitor.IP)).FirstOrDefault();
                if (null!=device && equipmentMonitor.Type == "HEIDEHAIN")
                {
                    RequestHeidhData hdhReq = new RequestHeidhData();                    
                    hdhReq.ServerUrl = device.ServerUrl;
                    hdhReq.MachineName = device.UserName;
                    hdhReq.Type = "Collect";
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    if (Result.IsSuccess)
                    {
                        ResponseHeidhData retData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                        if (!string.IsNullOrEmpty(retData.runDatasInfo.Trim()))
                        {                            
                            ResponseDigitalTwinsData twinsData = JsonConvert.DeserializeObject<ResponseDigitalTwinsData>(retData.runDatasInfo);
                            responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(twinsData.feedRate)? twinsData.feedRate : "0";
                            responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(twinsData.spindleMagnification)? twinsData.spindleMagnification:"0";
                            responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(twinsData.spindleSpeed) ? twinsData.spindleSpeed + "00" : "0";
                            responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(twinsData.spindleLoad) ? twinsData.spindleMagnification : "-";
                        }
                    }
                }
                else if(null != device && equipmentMonitor.Type == "FANUC")
                {
                    string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                    //调用发那科接口
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=All", null, null);

                    if (Result.IsSuccess)
                    {
                        ResponseFanucData responseFanucData = JsonConvert.DeserializeObject<ResponseFanucData>(Result.Message);
                        responseDigitalTwinsData.feedRate = !string.IsNullOrEmpty(responseFanucData.ActFeed)? responseFanucData.ActFeed:"0";
                        responseDigitalTwinsData.spindleMagnification = !string.IsNullOrEmpty(responseFanucData.SpindleMagnification)? responseFanucData.SpindleMagnification:"0";
                        responseDigitalTwinsData.spindleSpeed = !string.IsNullOrEmpty(responseFanucData.ActSpindle)? responseFanucData.ActSpindle : "0";
                        responseDigitalTwinsData.spindleLoad = !string.IsNullOrEmpty(responseFanucData.SpindleLoad)? responseFanucData.SpindleLoad : "-";
                    }
                }
            }

            return list;

        }

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

        }
     

        /// <summary>
        /// 机器人取放动作
        /// </summary> 
        public async Task<ResponseECSData> RobotAction(RequestData<LocationData> req)
        {
            Console.WriteLine("获取imcs数据:" + JsonConvert.SerializeObject(req));
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);
            
            try
            {
                List<Device> devices = _deviceService.GetDeviceList();

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

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

                SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.Ip);
                OperateResult ConnectionResult = s7.ConnectServer();
                if (!ConnectionResult.IsSuccess)
                {
                    s7.ConnectClose();
                    Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                    responseData.result = "false";
                    responseData.msg = ActionTypeEnum.RobotAction + "异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req);
                    return responseData;
                } 
                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery); 
               
                //查询条件
                List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    {
                        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                        if (actionAddress.CheckType ? operateResult != actionAddress.Value : operateResult == actionAddress.Value)
                        {
                            s7.ConnectClose();
                            Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                            responseData.msg = ActionTypeEnum.RobotAction + "异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req);
                            responseData.result = "false";
                            return responseData;
                        } 
                    }
                } 
 
                //查询写入地址列表
                List<CcsActionAddress> CcsActionAddressWrites = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.WRITE.ToString()).ToList();
                foreach (CcsActionAddress actionAddress in CcsActionAddressWrites)
                {
                    if (!string.IsNullOrEmpty(actionAddress.Address))
                    {
                        string operateResult = s7.ReadInt16(actionAddress.Address).Content.ToString();

                        if (actionAddress.Sort == 1)
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(actionAddress.Value));

                            //同步更新数据库状态
                            CcsTagValue tagValueQuery = new CcsTagValue();
                            tagValueQuery.Ip = req.url;
                            tagValueQuery.Address = actionAddress.Address;
                            CcsTagValue tagValue = _ccsTagValueService.GetList(tagValueQuery).ToList().FirstOrDefault(); 
                            if(tagValue != null)
                            {
                                tagValue.TagValue = actionAddress.Value;
                                await _ccsTagValueService.Update(tagValue);
                            }
                            
                        }
                        else if (actionAddress.Sort == 2)
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(req.data.Location));
                        }
                        else if (actionAddress.Sort == 3)
                        {
                            s7.Write(actionAddress.Address, Convert.ToInt16(req.data.DestLocation));
                        }

                        Thread.Sleep(SLEEP_TIME);
                    }
                }

                
                //CcsActionAddress checkAddressSucess = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK_SUCESS.ToString()).FirstOrDefault();
                //if (checkAddressSucess != null)
                //{
                //    string operateResult = s7.ReadBool(checkAddressSucess.Address).Content.ToString();
                //    if(operateResult != checkAddressSucess.Value)
                //    {
                //        s7.ConnectClose();
                //        Log.Instance.WriteLogAdd(ActionTypeEnum.RobotAction + "异常===>>" + "操作不成功,请重试" + JsonConvert.SerializeObject(req),
                //        EnumHelper.GetDescription(ActionTypeEnum.RobotAction));
                //        responseData.result = "false";
                //        return responseData;
                //    }
                //}
                s7.ConnectClose();

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

        // 预上传文件，下发请求上料nc指令
        public async Task<ResponseECSData> PredictUploadFile(RequestData<UploadFileData> req) {
            ResponseECSData responseData = new ResponseECSData(req.taskId, req.taskNodeId);

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

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

                // 判断机床是否在线
                if (deviceOpcUa == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = "查询设备表,需要设备为离线状态";
                    return responseData;
                }

                //海德汉系统需要进行预上传,发送上料请求
/*               if (deviceHeidenhain != null)
                {
                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                    hdhReq.MachineName = deviceHeidenhain.UserName;
                    hdhReq.Path = req.data.fileName;
                    hdhReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    //远程机床相对路径
                    hdhReq.Address = req.data.remotePath;

                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "预上传传参,发送请求上料申请===>>" + JsonConvert.SerializeObject(hdhReq),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "预上传异常,发送请求上料申请===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        responseData.msg = ActionTypeEnum.UploadFile + "预上传异常,发送请求上料申请===>>" + JsonConvert.SerializeObject(req);
                        return responseData;
                    }
                }

                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "预上传成功,发送请求上料申请===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));*/

                // 启动程序，使机床变为可上料状态
                RequestHeidhData hdhReq2 = new RequestHeidhData();
                hdhReq2.ServerUrl = deviceHeidenhain.ServerUrl;
                hdhReq2.MachineName = deviceHeidenhain.UserName;
                hdhReq2.Path = Path.GetFileName(req.data.fileName);                
                hdhReq2.Type = HeidnActionTypeEnum.ApplyFeeding.ToString();
                hdhReq2.Address = req.data.remotePath;
                var ResultStatus = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq2, null);
                ResponseHeidhData responseHeidhData2 = JsonConvert.DeserializeObject<ResponseHeidhData>(ResultStatus.Message);
                if (!ResultStatus.IsSuccess || !responseHeidhData2.result)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(hdhReq2),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.result = "false";
                    responseData.msg = ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(hdhReq2);
                    return responseData;
                }

            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "预上传异常,发送请求上料申请===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.msg = ActionTypeEnum.UploadFile + "预上传异常,发送请求上料申请===>>" + ex.Message + JsonConvert.SerializeObject(req);
                responseData.result = "false";
            }

            return responseData;    
        }

        private string GenPath(string part1, string part2)
        {
            string sFullPath = part1;
            switch (part2)
            {
                case ".":
                    break;
                case "..":
                    if (part1.EndsWith(@"\") && part1.Length > 5)
                        part1 = part1.Substring(0, part1.Length - 3);
                    int iLastFolderPos = part1.LastIndexOf(@"\");
                    if (iLastFolderPos >= 0)
                        sFullPath = part1.Substring(0, iLastFolderPos + 1);
                    break;
                default:
                    if (part1.EndsWith(@"\"))
                        sFullPath = part1 + part2;
                    else
                        sFullPath = part1 + @"\" + part2;
                    break;
            }
            return sFullPath;
        }

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

            try
            {
                List<Device> devices = _deviceService.GetDeviceList();
                Device deviceFtp = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.FTP.ToString())).FirstOrDefault();
                Device deviceOpcUa = devices.Where(x => x.Ip.Equals(req.url)
                                           && x.ProtocolType.Equals(ProtocalTypeEnum.OPCUA.ToString())).FirstOrDefault();
           
                Device deviceHeidenhain = devices.Where(x => x.Ip.Equals(req.url)
                                            && x.ProtocolType.Equals(ProtocalTypeEnum.HEIDEHAIN.ToString())).FirstOrDefault();

                if (deviceOpcUa == null && deviceHeidenhain == null)
                {
                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                    responseData.result = "false";
                    responseData.msg = ActionTypeEnum.UploadFile + "设备已离线===>>" + JsonConvert.SerializeObject(req);
                    return responseData;
                }
                //西门子系统上传
                if (deviceOpcUa != null)
                {
                    RequestOpcUaData opcUaReq = new RequestOpcUaData();
                    opcUaReq.ServerUrl = deviceOpcUa.ServerUrl;
                    opcUaReq.UserName = deviceOpcUa.UserName;
                    opcUaReq.Password = deviceOpcUa.Password;
                    opcUaReq.Path = req.data.fileName;
                    opcUaReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, opcuacUrlContext, opcUaReq, null);
                    ResponseOpcUaData responseOpcUaData = JsonConvert.DeserializeObject<ResponseOpcUaData>(Result.Message);
                    if (!Result.IsSuccess || !responseOpcUaData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        responseData.msg = ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req);
                        return responseData;
                    }
                }
                else if(deviceHeidenhain != null)
                { 
                 
                    RequestHeidhData hdhReq = new RequestHeidhData();
                    hdhReq.ServerUrl = deviceHeidenhain.ServerUrl;
                    hdhReq.MachineName = deviceHeidenhain.UserName;
                    hdhReq.Path = req.data.fileName;
                    hdhReq.Type = OpcUaActionTypeEnum.Upload.ToString();
                    //远程机床相对路径
                    hdhReq.Address = req.data.remotePath;

                    Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传传参===>>" + JsonConvert.SerializeObject(hdhReq),
                       EnumHelper.GetDescription(ActionTypeEnum.UploadFile));

                    var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                    ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    if (!Result.IsSuccess || !responseHeidhData.result)
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                        responseData.result = "false";
                        responseData.msg = ActionTypeEnum.UploadFile + "上传异常===>>" + JsonConvert.SerializeObject(req);
                        return responseData;
                    }  
                }  
                //插入回调
                TaskCallback taskCallbackData = new TaskCallback(req.url, ActionTypeEnum.UploadFile.ToString(),
                EnumHelper.GetDescription(ActionTypeEnum.UploadFile), req.taskId, req.taskNodeId);
                await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传成功===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.msg = ActionTypeEnum.UploadFile + "上传成功===>>" + JsonConvert.SerializeObject(req);
                return responseData;
            }
            catch (Exception ex)
            {
                Log.Instance.WriteLogAdd(ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.UploadFile));
                responseData.result = "false";
                responseData.msg = ActionTypeEnum.UploadFile + "上传异常===>>" + ex.Message + JsonConvert.SerializeObject(req);
                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";
                    responseData.msg = "检测到设备已离线";
                    return responseData;
                }

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

                CcsActionAddress actionAddressQuery = new CcsActionAddress();
                actionAddressQuery.ActionId = actionInfo.Id;
                List<CcsActionAddress> CcsActionAddresses = _ccsActionAddressService.GetList(actionAddressQuery);
                //opcua启动程序
                if (actionInfo.ProtocolType == ProtocalTypeEnum.OPCUA.ToString())
                { 
                    //插入回调
                    //获取启动前放的 工位
                    TaskCallback queryTaskCallBack = new TaskCallback();
                    queryTaskCallBack.IP = actionInfo.PlcIp;
                    queryTaskCallBack.Description = ProtocalTypeEnum.OPCUA.ToString();
                    TaskCallback TaskBean = await _taskCallbackService.GetRobotActionList(queryTaskCallBack);

                    TaskCallback taskCallbackData = new TaskCallback(actionInfo.PlcIp, ActionTypeEnum.StartNCProgram.ToString(),
                    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram), req.taskId, req.taskNodeId);
                    taskCallbackData = setCallBackValue(CcsActionAddresses, taskCallbackData);
                    taskCallbackData.Description = ProtocalTypeEnum.OPCUA.ToString();
                    if(TaskBean != null)
                    {
                        taskCallbackData.Data = TaskBean.Data;
                    }
                    else
                    {
                        Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "失败,上一放动作 没有工位信息===>>" + JsonConvert.SerializeObject(req),
                       EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                        responseData.msg = ActionTypeEnum.StartNCProgram + "失败,上一放动作 没有工位信息===>>" + JsonConvert.SerializeObject(req);
                        return responseData;
                    }
                    
                    await _taskCallbackService.CreateOrUpdateAndCache(taskCallbackData);
                    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动成功===>>" + JsonConvert.SerializeObject(req),
                        EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    responseData.msg = ActionTypeEnum.StartNCProgram + "启动成功===>>" + JsonConvert.SerializeObject(req);
                    return responseData; 

                }  else if (actionInfo.ProtocolType == ProtocalTypeEnum.HEIDEHAIN.ToString()) 
                { 
                    //调用机器人plc启动海德汉程序 
                    //SiemensS7Net s7 = DevicePlcS7.SiemensS7(actionInfo.PlcIp);
                    //OperateResult ConnectionResult = s7.ConnectServer();
                    //if (!ConnectionResult.IsSuccess)
                    //{
                    //    s7.ConnectClose();
                    //    Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "PLC连接不上" + JsonConvert.SerializeObject(req),
                    //    EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    //    responseData.result = "false";
                    //    return responseData;
                    //}
                        
                    ////查询条件
                    //List<CcsActionAddress> CcsActionAddressChecks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CHECK.ToString()).ToList();
                    //foreach (CcsActionAddress actionAddress in CcsActionAddressChecks)
                    //{
                    //    if (!string.IsNullOrEmpty(actionAddress.Address) && !string.IsNullOrEmpty(actionAddress.Value))
                    //    {
                             
                    //        string operateResult = s7.ReadBool(actionAddress.Address).Content.ToString();
                    //        if (actionAddress.CheckType ? operateResult.Equals(actionAddress.Value) : operateResult != actionAddress.Value)
                    //        {
                    //            s7.ConnectClose();
                    //            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动程序异常===>>" + "条件不满足" + JsonConvert.SerializeObject(req),
                    //            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                    //            responseData.result = "false";
                    //            return responseData;
                    //        }
                    //    }
                    //}
                    
                        RequestHeidhData hdhReq = new RequestHeidhData();
                        hdhReq.ServerUrl = device.ServerUrl;
                        hdhReq.MachineName = device.UserName;
                        hdhReq.Path = req.data.remotePath;  
                        hdhReq.Type = OpcUaActionTypeEnum.StartNcProgram.ToString();
                        var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);
                        ResponseHeidhData responseHeidhData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                        if (!Result.IsSuccess || !responseHeidhData.result)
                        {
                            Log.Instance.WriteLogAdd(ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req),
                            EnumHelper.GetDescription(ActionTypeEnum.StartNCProgram));
                            responseData.result = "false";
                            responseData.msg = ActionTypeEnum.StartNCProgram + "启动异常===>>" + JsonConvert.SerializeObject(req);
                            return responseData;
                        }

                    
                    //s7.ConnectClose();

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

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

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

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

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

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

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

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

                     
                s7.ConnectClose();

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

        /// <summary>
        /// 启动吹干
        /// </summary> 
        public async Task<ResponseECSData> StartDryMachine(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.StartDryMachine + "设备已离线===>>" + JsonConvert.SerializeObject(req),
                    EnumHelper.GetDescription(ActionTypeEnum.StartDryMachine));
                    responseData.result = "false";
                    return responseData;

                }

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

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

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

                s7.ConnectClose();

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

        
       

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

            Device device = devices.Where(x => x.Ip.Equals(req.url) && x.Port.Equals(req.port)).FirstOrDefault();
            List<ResponseToolData> list = new List<ResponseToolData>();
            if (device.ProtocolType == ProtocalTypeEnum.OPCUA.ToString())
            {
                CcsTagValue tagValueQuery = new CcsTagValue();
                tagValueQuery.Ip = req.url;
                tagValueQuery.Component = "刀具";
                List<CcsTagValue> tagValues = _ccsTagValueService.GetList(tagValueQuery);
                List<CcsTagValue> toolNumberList = tagValues.GroupBy(x => x.ComponentNumber)
                .Select(group => new CcsTagValue
                {
                    ComponentNumber = group.Key
                }).ToList();
                foreach (CcsTagValue toolNumber in toolNumberList)
                {
                    ResponseToolData toolData = new ResponseToolData();
                    foreach (CcsTagValue tagValue in tagValues)
                    {
                        if (toolNumber.ComponentNumber == tagValue.ComponentNumber)
                        {
                            toolData.number = toolNumber.ComponentNumber;
                            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);


                }
            }
            else if (device.ProtocolType == ProtocalTypeEnum.FANUC.ToString())
            {
                string Url = fanucUrlContext + "?ip=" + device.Ip + "&port=" + device.Port;
                //调用发那科接口
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Get, Url + "&fun=ToolList", null, null);

                if (Result.IsSuccess)
                {
                    List<ResponseToolData> responseFanucData = JsonConvert.DeserializeObject<List<ResponseToolData>>(Result.Message);
                    //list = JsonConvert.DeserializeObject<List<ResponseToolData>>(Result.Message.ToolLife);                    
                    //list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseFanucData.ToolLife);
                    list = responseFanucData;
                }
            }else if(device.ProtocolType == ProtocalTypeEnum.HEIDEHAIN.ToString())
            {
                RequestHeidhData hdhReq = new RequestHeidhData();
                hdhReq.ServerUrl = device.ServerUrl;
                hdhReq.MachineName = device.UserName;
                hdhReq.Type = "ToolList";
                var Result = await _apiRequestService.RequestAsync(RequsetModeEnum.Post, hdhUrlContext, hdhReq, null);                
                if (Result.IsSuccess)
                {
                    ResponseHeidhData responseData = JsonConvert.DeserializeObject<ResponseHeidhData>(Result.Message);
                    list = JsonConvert.DeserializeObject<List<ResponseToolData>>(responseData.toolsInfo);
                }
            }

            return list;
        }

      

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

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

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

        //设置回调值
        private TaskCallback setCallBackValue(List<CcsActionAddress> CcsActionAddresses, TaskCallback taskCallbackData)
        {
            List<CcsActionAddress> CcsActionAddressCallBacks = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackFails = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.CALLBACK_FAIL.ToString()).ToList();
            List<CcsActionAddress> CcsActionAddressCallBackResets = CcsActionAddresses.Where(o => o.Type == ActionAddressTypeEnum.RESET.ToString()).ToList();
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBacks)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.Address = actionAddress.Address;
                    taskCallbackData.CallbackValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.Address2 = actionAddress.Address;
                    taskCallbackData.CallbackValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.Address3 = actionAddress.Address;
                    taskCallbackData.CallbackValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackFails)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.FailAddress = actionAddress.Address;
                    taskCallbackData.CallbackFailValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.FailAddress2 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue2 = actionAddress.Value;
                }
                else if (actionAddress.Sort == 3)
                {
                    taskCallbackData.FailAddress3 = actionAddress.Address;
                    taskCallbackData.CallbackFailValue3 = actionAddress.Value;
                }
            }
            foreach (CcsActionAddress actionAddress in CcsActionAddressCallBackResets)
            {
                if (actionAddress.Sort == 1)
                {
                    taskCallbackData.SuccessResetAddress = actionAddress.Address;
                    taskCallbackData.SuccessResetValue = actionAddress.Value;
                }
                else if (actionAddress.Sort == 2)
                {
                    taskCallbackData.SuccessResetAddress2 = actionAddress.Address;
                    taskCallbackData.SuccessResetValue2 = actionAddress.Value;
                }
                
            }
            return taskCallbackData;
        }

    }
}