htl_ccs/IMCS_CCS/Controllers/CcsController.cs

using IMCS.CCS.Entitys;
using IMCS.CCS.Models;
using IMCS.CCS.Models.vo;
using IMCS.CCS.Services;
using IMCS_CCS.Model.vo;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.Threading.Tasks;
 

namespace IMCS.CCS.Controllers
{
    //[Route("api/[controller]")]
    [ApiController]
    /// <summary>
    /// ECS接口
    /// </summary> 
    public class CcsController : ControllerBase
    {
        private readonly IHttpRequestService _httpRequestService;

        public CcsController(IHttpRequestService httpRequestService)
        {
            _httpRequestService = httpRequestService;
        }

        /// <summary>
        /// 获取状态当前值： POST: api/RequestTagValueData
        /// </summary> 
        /// <returns></returns> 
        [Route("api/GetTagValue")]
        [HttpPost]
        public string GetTagValue(RequestTagValueData req)
        {
            return _httpRequestService.GetTagValue(req);
        }

        /// <summary>
        /// 益模调用接口，显示3D： POST: api/GetDigitalTwins
        /// </summary> 
        /// <returns></returns> 
        [Route("api/GetDigitalTwins")]
        [HttpPost]
        public async Task<ActionResult<List<ResponseDigitalTwinsData>>> GetDigitalTwins()
        {
            return await _httpRequestService.GetDigitalTwins();
        }

        /// <summary>
        /// 查询设备状态： POST: api/GetEquipMent
        /// </summary> 
        /// <returns></returns> 
        [Route("api/GetEquipMent")]
        [HttpPost]
        public async Task<ActionResult<List<EquipmentMonitor>>> GetEquipMent(){
            return await _httpRequestService.GetEquipMent();
        }



        /// <summary>
        /// 机器人取放动作： POST: api/RobotAction
        /// </summary> 
        /// <returns></returns>
        [Route("api/RobotAction")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> RobotAction(RequestData<LocationData> data)
        {
            return await _httpRequestService.RobotAction(data);
        } 

        /// <summary>
        /// 上传文件： POST: api/UploadFile
        /// </summary> 
        /// <returns></returns>
        [Route("api/UploadFile")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> UploadFile(RequestData<UploadFileData> data)
        {
            return await _httpRequestService.UploadFile(data);
        }

       

        /// <summary>
        /// 启动机床程序： POST: api/StartNCProgram
        /// </summary> 
        /// <returns></returns>
        [Route("api/StartNCProgram")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> StartNCProgram(RequestData<StartNCProgramData> data)
        {
            return await _httpRequestService.StartNCProgram(data);
        }
        
        /// <summary>
        /// 启动清洗机： POST: api/StartCleanMachine
        /// </summary> 
        /// <returns></returns>
        [Route("api/StartCleanMachine")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> StartCleanMachine(RequestData<object> data)
        {
            return await _httpRequestService.StartCleanMachine(data);
        }

        /// <summary>
        /// 读RFID： POST: api/ReadRFID
        /// </summary> 
        /// <returns></returns>
        [Route("api/ReadRFID")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> ReadRFID(RequestData<RFIData> data)
        {
            return await _httpRequestService.ReadRFID(data);
        }

        /// <summary>
        /// 写RFID： POST: api/WriteRFID
        /// </summary> 
        /// <returns></returns>
        [Route("api/WriteRFID")]
        [HttpPost] 
        public async Task<ActionResult<ResponseECSData>> WriteRFID(RequestData<RFIData> data)
        {
            return await _httpRequestService.WriteRFID(data);
        }

        /// <summary>
        /// 设备上线离线： POST: api/UpdateDeviceState
        /// </summary> 
        /// <returns></returns>
        [Route("api/UpdateDeviceState")]
        [HttpPost]
        public async Task<ResponseCommonData> UpdateDeviceState(RequestDeviceUpdateData req)
        {
            return await _httpRequestService.UpdateDeviceState(req);
        }

        /// <summary>
        /// 获取任务回调列表： POST: api/GetCallBackList
        /// </summary> 
        /// <returns></returns>
        [Route("api/GetCallBackList")]
        [HttpPost]
        public async Task<List<TaskCallback>> GetCallBackListByCondition(RequestCallBackData vo)
        {
            return await _httpRequestService.GetCallBackListByCondition(vo);
        }

        /// <summary>
        /// 刀具接口列表： POST: api/GetTools
        /// </summary> 
        /// <returns></returns>
        [Route("api/GetTools")]
        [HttpPost]
        public async Task<ActionResult<List<ResponseToolData>>> GetTools(RequestToolData data)
        {
            return await _httpRequestService.GetTools(data);
        }

        /// <summary>
        /// 非任务上传文件： POST: api/UploadFileWithOutTask
        /// </summary> 
        /// <returns></returns>
        [Route("api/UploadFileWithOutTask")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> UploadFileWithOutTask(RequestData<UploadFileData> data)
        {
            return await _httpRequestService.UploadFileWithOutTask(data);
        }

        /// <summary>
        /// 非任务删除文件： POST: api/DeleteFileWithOutTask
        /// </summary> 
        /// <returns></returns>
        [Route("api/DeleteFileWithOutTask")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> DeleteFileWithOutTask(RequestData<UploadFileData> data)
        {
            return await _httpRequestService.DeleteFileWithOutTask(data);
        }

        /// <summary>
        /// 读取点位： POST: api/readPoint
        /// </summary> 
        /// <returns></returns>
        [Route("api/readPoint")]
        [HttpPost]
        public async Task<ActionResult<ResponseCCSData<List<ResponseEcsPoint>>>> readPoint(RequestData<RequestPoint> data)
        {
            return await _httpRequestService.readPoint(data);
        }

        /// <summary>
        /// 写入点位： POST: api/writePoint
        /// </summary> 
        /// <returns></returns>
        [Route("api/writePoint")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> writePoint(RequestData<RequestPoint> data)
        {
            return await _httpRequestService.writePoint(data);
        }

        /// <summary>
        /// 更新刀具库数据： POST: api/updateToolInfo
        /// </summary> 
        /// <returns></returns>
        [Route("api/updateToolInfo")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> updateToolInfo(RequestData<ToolData> data)
        {
            return await _httpRequestService.updateToolInfo(data);
        }

        /// <summary>
        /// 读写RFID临时： POST: api/WriteRFIDTemp
        /// </summary> 
        /// <returns></returns>
        [Route("api/WriteRFIDTemp")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> WriteRFIDTemp(RequestData<RFIData> data)
        {
            return await _httpRequestService.WriteRFIDTemp(data);
        }

        /// <summary>
        /// 手动换刀
        /// </summary> 
        /// <returns></returns>
        [Route("api/HandleChangeTool")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> HandleChangeTool(RequestData<HandleChangeTool> data)
        {
            return await _httpRequestService.HandleChangeTool(data);
        }


        /// <summary>
        /// 刀具出库
        /// </summary> 
        /// <returns></returns>
        [Route("api/StorgeOut")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> StorgeOut(RequestData<RFIData> data)
        {
            return await _httpRequestService.StorgeOut(data);
        }

        /// <summary>
        /// 手动处理机器人取放动作： POST: api/HandRobotAction
        /// </summary> 
        /// <returns></returns>
        [Route("api/HandRobotAction")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> HandRobotAction(RequestData<LocationData> data)
        {
            return await _httpRequestService.HandRobotAction(data);
        }

        /// <summary>
        /// 拍照： POST: api/TakePhoto
        /// </summary> 
        /// <returns></returns>
        [Route("api/TakePhoto")]
        [HttpPost]
        public async Task<ActionResult<ResponseECSData>> TakePhoto(RequestData<LocationData> data)
        {
            return await _httpRequestService.TakePhoto(data);
        }

        /// <summary>
        /// 任务更新刀库数据： POST: api/UpdateMachineTool
        /// </summary> 
        /// <returns></returns>
        [Route("api/UpdateMachineTool")]
        [HttpPost]
        public async Task<ResponseECSData> UpdateMachineTool(RequestData<ToolData> data)
        {
            return await _httpRequestService.UpdateMachineTool(data);
        }

    }
}